Calculer le point central de plusieurs latitude/longitude paires de coordonnées

Merci! Voici une version de C# de l'OP, les solutions à l'aide de degrés. Il utilise la Système.De l'appareil.Emplacement.GeoCoordinate classe

    public static GeoCoordinate GetCentralGeoCoordinate(
        IList<GeoCoordinate> geoCoordinates)
    {
        if (geoCoordinates.Count == 1)
        {
            return geoCoordinates.Single();
        }

        double x = 0;
        double y = 0;
        double z = 0;

        foreach (var geoCoordinate in geoCoordinates)
        {
            var latitude = geoCoordinate.Latitude * Math.PI / 180;
            var longitude = geoCoordinate.Longitude * Math.PI / 180;

            x += Math.Cos(latitude) * Math.Cos(longitude);
            y += Math.Cos(latitude) * Math.Sin(longitude);
            z += Math.Sin(latitude);
        }

        var total = geoCoordinates.Count;

        x = x / total;
        y = y / total;
        z = z / total;

        var centralLongitude = Math.Atan2(y, x);
        var centralSquareRoot = Math.Sqrt(x * x + y * y);
        var centralLatitude = Math.Atan2(z, centralSquareRoot);

        return new GeoCoordinate(centralLatitude * 180 / Math.PI, centralLongitude * 180 / Math.PI);
    }

Très utile post! J'ai mis en place ce en JavaScript, par la présente, mon code. J'ai utilisé cela avec succès.

function rad2degr(rad) { return rad * 180 / Math.PI; }
function degr2rad(degr) { return degr * Math.PI / 180; }

/**
 * @param latLngInDeg array of arrays with latitude and longtitude
 *   pairs in degrees. e.g. [[latitude1, longtitude1], [latitude2
 *   [longtitude2] ...]
 *
 * @return array with the center latitude longtitude pairs in 
 *   degrees.
 */
function getLatLngCenter(latLngInDegr) {
    var LATIDX = 0;
    var LNGIDX = 1;
    var sumX = 0;
    var sumY = 0;
    var sumZ = 0;

    for (var i=0; i<latLngInDegr.length; i++) {
        var lat = degr2rad(latLngInDegr[i][LATIDX]);
        var lng = degr2rad(latLngInDegr[i][LNGIDX]);
        //sum of cartesian coordinates
        sumX += Math.cos(lat) * Math.cos(lng);
        sumY += Math.cos(lat) * Math.sin(lng);
        sumZ += Math.sin(lat);
    }

    var avgX = sumX / latLngInDegr.length;
    var avgY = sumY / latLngInDegr.length;
    var avgZ = sumZ / latLngInDegr.length;

    //convert average x, y, z coordinate to latitude and longtitude
    var lng = Math.atan2(avgY, avgX);
    var hyp = Math.sqrt(avgX * avgX + avgY * avgY);
    var lat = Math.atan2(avgZ, hyp);

    return ([rad2degr(lat), rad2degr(lng)]);
}

Dans l'intérêt de peut-être sauver quelqu'un d'une ou deux minutes, voici la solution qui a été utilisé en Objective-C au lieu de python. Cette version prend un NSArray de NSValues qui contiennent MKMapCoordinates, qui a été appelé dans ma mise en œuvre:

#import <MapKit/MKGeometry.h>

+ (CLLocationCoordinate2D)centerCoordinateForCoordinates:(NSArray *)coordinateArray {
    double x = 0;
    double y = 0;
    double z = 0;

    for(NSValue *coordinateValue in coordinateArray) {
        CLLocationCoordinate2D coordinate = [coordinateValue MKCoordinateValue];

        double lat = GLKMathDegreesToRadians(coordinate.latitude);
        double lon = GLKMathDegreesToRadians(coordinate.longitude);
        x += cos(lat) * cos(lon);
        y += cos(lat) * sin(lon);
        z += sin(lat);
    }

    x = x / (double)coordinateArray.count;
    y = y / (double)coordinateArray.count;
    z = z / (double)coordinateArray.count;

    double resultLon = atan2(y, x);
    double resultHyp = sqrt(x * x + y * y);
    double resultLat = atan2(z, resultHyp);

    CLLocationCoordinate2D result = CLLocationCoordinate2DMake(GLKMathRadiansToDegrees(resultLat), GLKMathRadiansToDegrees(resultLon));
    return result;
}

Si vous êtes intéressés à obtenir une très simplifiée au 'centre' de points (par exemple, pour simplement le centre d'une carte au centre de votre gmaps polygone), alors voici une approche de base qui a fonctionné pour moi.

public function center() {
    $minlat = false;
    $minlng = false;
    $maxlat = false;
    $maxlng = false;
    $data_array = json_decode($this->data, true);
    foreach ($data_array as $data_element) {
        $data_coords = explode(',',$data_element);
        if (isset($data_coords[1])) {
            if ($minlat === false) { $minlat = $data_coords[0]; } else { $minlat = ($data_coords[0] < $minlat) ? $data_coords[0] : $minlat; }
            if ($maxlat === false) { $maxlat = $data_coords[0]; } else { $maxlat = ($data_coords[0] > $maxlat) ? $data_coords[0] : $maxlat; }
            if ($minlng === false) { $minlng = $data_coords[1]; } else { $minlng = ($data_coords[1] < $minlng) ? $data_coords[1] : $minlng; }
            if ($maxlng === false) { $maxlng = $data_coords[1]; } else { $maxlng = ($data_coords[1] > $maxlng) ? $data_coords[1] : $maxlng; }
        }
    }
    $lat = $maxlat - (($maxlat - $minlat) /2);
    $lng = $maxlng - (($maxlng - $minlng) /2);
    return $lat.','.$lng;
}

Renvoie le milieu lat/lng coordonner pour le centre d'un polygone.

C'est le même que la moyenne pondérée problème où tous les poids sont les mêmes, et il y a deux dimensions.

Trouver la moyenne de toutes les latitudes pour votre centre de la latitude et de la moyenne de toutes les longitudes pour le centre de longitude.

Caveat Emptor: C'est une distance proche du rapprochement et de l'erreur se déchaînent lorsque les écarts à la moyenne sont plus que quelques miles en raison de la courbure de la Terre. Rappelez-vous que les latitudes et les longitudes sont en degrés (pas vraiment une grille).

Si vous voulez tous les points pour être visible dans l'image, vous voulez les extrema de la latitude et de la longitude et assurez-vous que votre point de vue comprend les valeurs quelle que soit la bordure que vous voulez.

(À partir de Alnitak réponse, comment calculer les extrema peut être un peu problématique, mais si ils sont quelques degrés de chaque côté de la longitude qui s'enroule autour de vous, vous pourrez appeler le tir et prendre à droite la portée.)

Si vous ne voulez pas fausser quelle que soit la carte que ces points sont sur, puis ajuster la zone de délimitation de la hauteur de sorte qu'il s'adapte à ce que les pixels que vous avez alloué à la vue, mais ne comprend toujours les extrema.

De garder les points centré à l'arbitraire d'un zoom niveau, calculer le centre de la boîte englobante que "s'adapte" les points comme ci-dessus, et de garder ce point au centre de la.

Ici est la Version de python pour trouver le point central.
Le lat1 et lon1 sont la latitude et la longitude des listes.
il retuen la latitude et la longitude du point central.

def GetCenterFromDegrees(lat1,lon1):    
    if (len(lat1) <= 0):
    return false;

num_coords = len(lat1)

X = 0.0
Y = 0.0
Z = 0.0

for i in range (len(lat1)):
    lat = lat1[i] * np.pi /180
    lon = lon1[i] * np.pi /180

    a = np.cos(lat) * np.cos(lon)
    b = np.cos(lat) * np.sin(lon)
    c = np.sin(lat);

    X += a
    Y += b
    Z += c


X /= num_coords
Y /= num_coords
Z /= num_coords

lon = np.arctan2(Y, X)
hyp = np.sqrt(X * X + Y * Y)
lat = np.arctan2(Z, hyp)

newX = (lat * 180 /np.pi)
newY = (lon * 180 /np.pi)
return newX, newY

Comme une appréciation de ce fil, voici ma petite contribution à la mise en œuvre en Ruby, en espérant que je vais sauver quelqu'un a quelques minutes de leur précieux temps:

def self.find_center(locations)

 number_of_locations = locations.length

 return locations.first if number_of_locations == 1

 x = y = z = 0.0
 locations.each do |station|
   latitude = station.latitude * Math::PI /180
   longitude = station.longitude * Math::PI /180

   x += Math.cos(latitude) * Math.cos(longitude)
   y += Math.cos(latitude) * Math.sin(longitude)
   z += Math.sin(latitude)
 end

 x = x/number_of_locations
 y = y/number_of_locations
 z = z/number_of_locations

 central_longitude =  Math.atan2(y, x)
 central_square_root = Math.sqrt(x * x + y * y)
 central_latitude = Math.atan2(z, central_square_root)

 [latitude: central_latitude * 180 /Math::PI, 
 longitude: central_longitude * 180 /Math::PI]
end