Determinación del punto medio entre 2 coordenados

Question

Estoy tratando de determinar el punto medio entre las ubicaciones en un MKMapView. Estoy siguiendo el método descrito here (y here) y lo reescribí en Objective-C, pero el mapa está centrado en algún lugar al noreste de la isla de Baffin, que no está cerca de los dos puntos.

Mi método basado en el método java vinculado anteriormente:

+(CLLocationCoordinate2D)findCenterPoint:(CLLocationCoordinate2D)_lo1 :(CLLocationCoordinate2D)_loc2 { 
    CLLocationCoordinate2D center; 

    double lon1 = _lo1.longitude * M_PI/180; 
    double lon2 = _loc2.longitude * M_PI/100; 

    double lat1 = _lo1.latitude * M_PI/180; 
    double lat2 = _loc2.latitude * M_PI/100; 

    double dLon = lon2 - lon1; 

    double x = cos(lat2) * cos(dLon); 
    double y = cos(lat2) * sin(dLon); 

    double lat3 = atan2(sin(lat1) + sin(lat2), sqrt((cos(lat1) + x) * (cos(lat1) + x) + y * y)); 
    double lon3 = lon1 + atan2(y, cos(lat1) + x); 

    center.latitude = lat3 * 180/M_PI; 
    center.longitude = lon3 * 180/M_PI; 

    return center; 
} 

Los 2 parámetros tienen los siguientes datos:

_loc1: 
    latitude = 45.4959839 
    longitude = -73.67826455 

_loc2: 
    latitude = 45.482889 
    longitude = -73.57522299 

Lo anterior se coloque correctamente en el mapa (en Montreal y alrededor de) . Estoy tratando de centrar el mapa en el punto medio entre el 2, sin embargo, mi método de devolver los siguientes:

latitude = 65.29055 
longitude = -82.55425 

la que en algún lugar del ártico, cuando debería ser alrededor de 500 millas al sur.

Answer 1

Solo una corazonada, pero me di cuenta de que las variables lon2 y lat2 se calculan con M_PI/100 y no con M_PI/180.

double lon1 = _lo1.longitude * M_PI/180; 
double lon2 = _loc2.longitude * M_PI/100; 

double lat1 = _lo1.latitude * M_PI/180; 
double lat2 = _loc2.latitude * M_PI/100; 

Cambiar estos a 180 podría ayudarlo un poco.

Answer 2

Creo que ya lo piensa un poco. Solo hazlo:

float lon3 = ((lon1 + lon2)/2) 
float lat3 = ((lat1 + lat2)/2) 

lat3 y lon3 será el punto central.

Answer 3

En caso de que alguien necesita código en Swift, la función de biblioteca que he escrito en Swift para calcular el punto medio entre las coordenadas MÚLTIPLES:

//  /** Degrees to Radian **/ 

class func degreeToRadian(angle:CLLocationDegrees) -> CGFloat{ 

    return ( (CGFloat(angle))/180.0 * CGFloat(M_PI) ) 

} 

//  /** Radians to Degrees **/ 

class func radianToDegree(radian:CGFloat) -> CLLocationDegrees{ 

    return CLLocationDegrees( radian * CGFloat(180.0/M_PI) ) 

} 

class func middlePointOfListMarkers(listCoords: [CLLocationCoordinate2D]) -> CLLocationCoordinate2D{ 

    var x = 0.0 as CGFloat 

    var y = 0.0 as CGFloat 

    var z = 0.0 as CGFloat 



    for coordinate in listCoords{ 

     var lat:CGFloat = degreeToRadian(coordinate.latitude) 

     var lon:CGFloat = degreeToRadian(coordinate.longitude) 

     x = x + cos(lat) * cos(lon) 

     y = y + cos(lat) * sin(lon); 

     z = z + sin(lat); 

    } 

    x = x/CGFloat(listCoords.count) 

    y = y/CGFloat(listCoords.count) 

    z = z/CGFloat(listCoords.count) 



    var resultLon: CGFloat = atan2(y, x) 

    var resultHyp: CGFloat = sqrt(x*x+y*y) 

    var resultLat:CGFloat = atan2(z, resultHyp) 



    var newLat = radianToDegree(resultLat) 

    var newLon = radianToDegree(resultLon) 

    var result:CLLocationCoordinate2D = CLLocationCoordinate2D(latitude: newLat, longitude: newLon) 

    return result 

} 

respuesta detallada se puede encontrar here

Answer 4

Para los usuarios de SWIFT, variante corregida como @dinjas sugiere

import Foundation 
import MapKit 
extension CLLocationCoordinate2D { 
    // MARK: CLLocationCoordinate2D+MidPoint 
    func middleLocationWith(location:CLLocationCoordinate2D) -> CLLocationCoordinate2D { 

     let lon1 = longitude * M_PI/180 
     let lon2 = location.longitude * M_PI/180 
     let lat1 = latitude * M_PI/180 
     let lat2 = location.latitude * M_PI/180 
     let dLon = lon2 - lon1 
     let x = cos(lat2) * cos(dLon) 
     let y = cos(lat2) * sin(dLon) 

     let lat3 = atan2(sin(lat1) + sin(lat2), sqrt((cos(lat1) + x) * (cos(lat1) + x) + y * y)) 
     let lon3 = lon1 + atan2(y, cos(lat1) + x) 

     let center:CLLocationCoordinate2D = CLLocationCoordinate2DMake(lat3 * 180/M_PI, lon3 * 180/M_PI) 
     return center 
    } 
}