Berechnen Sie den Mittelpunkt mehrerer Breiten- / Längenkoordinatenpaare

Dank! Hier ist ein C# - version von OP-Lösungen in Grad. Es nutzt die System.- Gerät.Lage.GeoCoordinate Klasse

    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);
    }

InformationsquelleAutor der Antwort Yodacheese

Sehr nützlichen Beitrag! Ich habe diese umgesetzt in JavaScript, hiermit meinen code. Ich habe diese verwendet werden, erfolgreich.

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)]);
}

InformationsquelleAutor der Antwort Gio

Javascript-version der ursprünglichen Funktion

/**
 * Get a center latitude,longitude from an array of like geopoints
 *
 * @param array data 2 dimensional array of latitudes and longitudes
 * For Example:
 * $data = array
 * (
 *   0 = > array(45.849382, 76.322333),
 *   1 = > array(45.843543, 75.324143),
 *   2 = > array(45.765744, 76.543223),
 *   3 = > array(45.784234, 74.542335)
 * );
*/
function GetCenterFromDegrees(data)
{       
    if (!(data.length > 0)){
        return false;
    } 

    var num_coords = data.length;

    var X = 0.0;
    var Y = 0.0;
    var Z = 0.0;

    for(i = 0; i < data.length; i++){
        var lat = data[i][0] * Math.PI /180;
        var lon = data[i][1] * Math.PI /180;

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

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

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

    var lon = Math.atan2(Y, X);
    var hyp = Math.sqrt(X * X + Y * Y);
    var lat = Math.atan2(Z, hyp);

    var newX = (lat * 180 /Math.PI);
    var newY = (lon * 180 /Math.PI);

    return new Array(newX, newY);
}

InformationsquelleAutor der Antwort Kelvin Spencer

sehr schöne Lösungen, nur das, was ich brauchte für meine swift-Projekt, so hier ist ein swift-port. Dank & hier ist auch ein Spielplatz-Projekt:
https://github.com/ppoh71/playgounds/tree/master/centerLocationPoint.playground

/*
* calculate the center point of multiple latitude longitude coordinate-pairs
*/

import CoreLocation
import GLKit

var LocationPoints = [CLLocationCoordinate2D]()

//add some points to Location ne, nw, sw, se , it's a rectangle basicaly
LocationPoints.append(CLLocationCoordinate2D(latitude: 37.627512369999998, longitude: -122.38780611999999))
LocationPoints.append(CLLocationCoordinate2D(latitude: 37.627512369999998, longitude:  -122.43105867))
LocationPoints.append(CLLocationCoordinate2D(latitude: 37.56502528, longitude: -122.43105867))
LocationPoints.append(CLLocationCoordinate2D(latitude: 37.56502528, longitude: -122.38780611999999))

//center func
func getCenterCoord(LocationPoints: [CLLocationCoordinate2D]) -> CLLocationCoordinate2D{

    var x:Float = 0.0;
    var y:Float = 0.0;
    var z:Float = 0.0;

    for points in LocationPoints {

     let lat = GLKMathDegreesToRadians(Float(points.latitude));
     let long = GLKMathDegreesToRadians(Float(points.longitude));

        x += cos(lat) * cos(long);
        y += cos(lat) * sin(long);
        z += sin(lat);
    }

    x = x /Float(LocationPoints.count);
    y = y /Float(LocationPoints.count);
    z = z /Float(LocationPoints.count);

    let resultLong = atan2(y, x);
    let resultHyp = sqrt(x * x + y * y);
    let resultLat = atan2(z, resultHyp);



    let result = CLLocationCoordinate2D(latitude: CLLocationDegrees(GLKMathRadiansToDegrees(Float(resultLat))), longitude: CLLocationDegrees(GLKMathRadiansToDegrees(Float(resultLong))));

    return result;

}

//get the centerpoint
var centerPoint = getCenterCoord(LocationPoints)
print("Latitude: \(centerPoint.latitude) /Longitude: \(centerPoint.longitude)")

InformationsquelleAutor der Antwort ppoh71

Dies ist die gleiche wie die eines gewichteten durchschnittlichen problem, bei dem alle GEWICHTE gleich sind, und es gibt zwei Dimensionen.

Finden Sie den Mittelwert von allen breiten für Ihren center-Breite und der Durchschnitt aller Längengrade für die Mitte Länge.

Gewährleistungsausschluss: Dies ist ein Nähe-Distanz-approximation und der Fehler widerspenstigen werden, wenn die Abweichungen vom Mittelwert mehr als ein paar Meilen durch die Krümmung der Erde. Denken Sie daran, dass die breiten-und Längengrade sind Grad (nicht wirklich ein Gitter).

InformationsquelleAutor der Antwort jpredham

Wenn Sie möchten, dass alle Punkte sichtbar zu werden in das Bild, Sie würde wollen, dass die extrema in Breite und Länge und stellen Sie sicher, dass Ihre Ansicht enthält diese Werte mit dem, was Grenze, die Sie wollen.

(Von Alnitak Antwort, wie Sie berechnen die extrema kann ein wenig problematisch, aber wenn Sie ein paar Grad auf beiden Seiten der Länge umschließt, dann werden Sie rufen Sie die Aufnahme und nehmen Sie die Rechte Reihe.)

Wenn Sie nicht wollen, zu verfälschen was auch immer anzeigen, dass diese Punkte auf, dann passen Sie den Begrenzungsrahmen des Seitenverhältnisses so, dass es passt, was Pixel, die Sie haben zugeteilt, um die Ansicht, sondern beinhaltet noch den extrema.

Behalten die Punkte zentriert an einem beliebigen Zoom-Ebene, berechnet den Mittelpunkt der bounding-box, die "einfach passt" die Punkte wie oben, und halten Sie diesen Punkt als Mittelpunkt.

InformationsquelleAutor der Antwort John