Oblicz punkt środkowy wielu par współrzędnych szerokość / długość geograficzna

148

Biorąc pod uwagę zestaw punktów szerokości i długości geograficznej, jak mogę obliczyć szerokość i długość geograficzną punktu środkowego tego zestawu (czyli punktu, który wyśrodkowuje widok we wszystkich punktach)?

EDYCJA: rozwiązanie Pythona, którego używałem:

Convert lat/lon (must be in radians) to Cartesian coordinates for each location.
X = cos(lat) * cos(lon)
Y = cos(lat) * sin(lon)
Z = sin(lat)

Compute average x, y and z coordinates.
x = (x1 + x2 + ... + xn) / n
y = (y1 + y2 + ... + yn) / n
z = (z1 + z2 + ... + zn) / n

Convert average x, y, z coordinate to latitude and longitude.
Lon = atan2(y, x)
Hyp = sqrt(x * x + y * y)
Lat = atan2(z, hyp)
zeke
źródło
2
Odnośnie rozwiązania: prawdopodobnie twoje błędy nie będą zbyt duże przy założeniu kulistej ziemi, ale Ziemię lepiej opisać jako elipsoidę.
John,
1
Napisał to jako funkcję Pythona i udostępnił go pod adresem gist.github.com/3718961
Alvin
14
Bardzo ważne jest, aby pamiętać, że przy założeniu, że szerokość i długość ciała są podane w radianach! Przez chwilę drapałem się po głowie, nie zdając sobie z tego sprawy. Aby zamienić na radiany z wartości dziesiętnych, pomnóż liczbę dziesiętną * pi / 180. Następnie, aby przekonwertować z radianów na dziesiętne, pomnóż przez 180 / pi. HTH
Ryan Guill
1
Przepraszam za spóźnienie, ale zastanawiałem się, jaka jest matematyka stojąca za tym algorytmem, czy ktoś mógłby mi doradzić kilka odczytów, w których jest to wyjaśnione? Dzięki!
tonix
1
Co to jest z, proszę?
SoS,

Odpowiedzi:

48

Proste podejście polegające na zwykłym uśrednieniu ich ma dziwne przypadki krawędziowe z kątami, gdy zawijają się od 359 'z powrotem do 0'.

Znacznie wcześniej pytanie na SO poproszony o znalezienie średni zestaw kompasu kątami.

Rozszerzeniem zalecanego tam podejścia dla współrzędnych sferycznych byłoby:

  • Przekształć każdą parę lat / długich na wektor 3D długości jednostki.
  • Zsumuj każdy z tych wektorów
  • Normalizuj wynikowy wektor
  • Konwertuj z powrotem na współrzędne sferyczne
Alnitak
źródło
6
Wydaje się dobrze, zrobiłem coś podobnego w oparciu o to, co znalazłem na tej stronie: geomidpoint.com/calculation.html .
zeke,
4
przeciwnik - proszę wyjaśnij i zaproponuj lepsze rozwiązanie, jeśli możesz.
Alnitak
90

Dzięki! Oto wersja C # rozwiązań OP przy użyciu stopni. Wykorzystuje klasę System.Device.Location.GeoCoordinate

    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);
    }
Jodacheese
źródło
40

Uważam, że ten post jest bardzo przydatny, więc oto rozwiązanie w PHP. Używałem tego z powodzeniem i po prostu chciałem zaoszczędzić trochę czasu innemu deweloperowi.

/**
 * 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 (!is_array($data)) return FALSE;

    $num_coords = count($data);

    $X = 0.0;
    $Y = 0.0;
    $Z = 0.0;

    foreach ($data as $coord)
    {
        $lat = $coord[0] * pi() / 180;
        $lon = $coord[1] * pi() / 180;

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

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

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

    $lon = atan2($Y, $X);
    $hyp = sqrt($X * $X + $Y * $Y);
    $lat = atan2($Z, $hyp);

    return array($lat * 180 / pi(), $lon * 180 / pi());
}
Tom Tucker
źródło
1
Skorzystałem z tego rozwiązania, ale daje trochę błędne rozwiązanie - jeśli przeszukuję środek niektórych współrzędnych na mapie, to jakby „waży” punkty i zwykle pozostaje tam, gdzie jest ich więcej.
LowFieldTheory
2
@Alnitak Tutaj chcemy przeszukać środek obszaru wyznaczonego przez współrzędne. Czy na pewno skomentowałeś we właściwym miejscu?
LowFieldTheory
29

Bardzo przydatny post! Zaimplementowałem to w JavaScript, niniejszym mój kod. Użyłem tego z powodzeniem.

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

Gio
źródło
1
Wiem, że post jest stary, ale czy mógłbyś zamieścić odniesienie lub coś wyjaśniającego matematykę stojącą za algorytmem, który opublikowałeś? Dzięki!
tonix
Działało idealnie! Dzięki
andrewoodleyjr
Przetestowałem skrypt za pomocą Google Apps Script, ale wynik nie jest dokładnym punktem środkowym ścieżki. Jest gdzieś w pobliżu, ale nie bezpośrednio na torze. Czy istnieje lepsza formuła, aby uzyskać dokładny punkt środkowy NA TORZE?
Dirk
12

Wersja JavaScript oryginalnej funkcji

/**
 * 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);
}
Kelvin Spencer
źródło
12

Aby ewentualnie zaoszczędzić komuś minutę lub dwie, oto rozwiązanie, które zostało użyte w Objective-C zamiast w Pythonie. Ta wersja pobiera NSArray of NSValues, który zawiera MKMapCoordinates, który został wywołany w mojej implementacji:

#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;
}
Daryll H.
źródło
2
Dla każdego, ile to jest warte, Zamiast używać własnego makra dla stopni w radianach, importuj <GLKit/GLKMath.h>i używaj GLKMathDegreesToRadiansiGLKMathRadiansToDegrees
pnizzle
8

bardzo fajne rozwiązania, właśnie to, czego potrzebowałem do mojego szybkiego projektu, więc oto szybki port. dzięki, a oto projekt placu zabaw: 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)")
Peter Pohlmann
źródło
4

Jeśli jesteś zainteresowany uzyskaniem bardzo uproszczonego „środka” punktów (na przykład, aby po prostu wyśrodkować mapę do środka Twojego wielokąta gmaps), oto podstawowe podejście, które zadziałało.

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

Zwraca środkową współrzędną szerokości / długości dla środka wielokąta.

Kerry Emerson
źródło
4

W Django jest to trywialne (i faktycznie działa, miałem problemy z wieloma rozwiązaniami, które nie zwracały poprawnie negatywów dla szerokości geograficznej).

Na przykład, powiedzmy, że używasz django-geopostkodów (których jestem autorem).

from django.contrib.gis.geos import MultiPoint
from django.contrib.gis.db.models.functions import Distance
from django_geopostcodes.models import Locality

qs = Locality.objects.anything_icontains('New York')
points = [locality.point for locality in qs]
multipoint = MultiPoint(*points)
point = multipoint.centroid

pointjest Pointinstancją Django, której można następnie używać do wykonywania takich czynności, jak pobieranie wszystkich obiektów znajdujących się w promieniu 10 km od tego punktu centralnego;

Locality.objects.filter(point__distance_lte=(point, D(km=10)))\
    .annotate(distance=Distance('point', point))\
    .order_by('distance')

Zmiana tego na surowy Python jest trywialna;

from django.contrib.gis.geos import Point, MultiPoint

points = [
    Point((145.137075, -37.639981)),
    Point((144.137075, -39.639981)),
]
multipoint = MultiPoint(*points)
point = multipoint.centroid

Pod maską Django używa GEOS - więcej szczegółów na https://docs.djangoproject.com/en/1.10/ref/contrib/gis/geos/

alexhayes
źródło
3

Wersja Java, jeśli ktoś jej potrzebuje. Stałe zdefiniowano jako static, aby nie obliczać ich dwukrotnie.

/**************************************************************************************************************
 *   Center of geometry defined by coordinates
 **************************************************************************************************************/
private static double pi = Math.PI / 180;
private static double xpi = 180 / Math.PI;

public static Coordinate center(Coordinate... arr) {
    if (arr.length == 1) {
        return arr[0];
    }
    double x = 0, y = 0, z = 0;

    for (Coordinate c : arr) {
        double latitude = c.lat() * pi, longitude = c.lon() * pi;
        double cl = Math.cos(latitude);//save it as we need it twice
        x += cl * Math.cos(longitude);
        y += cl * Math.sin(longitude);
        z += Math.sin(latitude);
    }

    int total = arr.length;

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

    double centralLongitude = Math.atan2(y, x);
    double centralSquareRoot = Math.sqrt(x * x + y * y);
    double centralLatitude = Math.atan2(z, centralSquareRoot);

    return new Coordinate(centralLatitude * xpi, centralLongitude * xpi);
}
Stan Sokolov
źródło
3

Oto wersja Androida oparta na odpowiedzi C # @ Yodacheese przy użyciu interfejsu API Map Google:

public static LatLng GetCentralGeoCoordinate(List<LatLng> geoCoordinates) {        
    if (geoCoordinates.size() == 1)
    {
        return geoCoordinates.get(0);
    }

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

    for(LatLng geoCoordinate : geoCoordinates)
    {
        double  latitude = geoCoordinate.latitude * Math.PI / 180;
        double longitude = geoCoordinate.longitude * Math.PI / 180;

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

    int total = geoCoordinates.size();

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

    double centralLongitude = Math.atan2(y, x);
    double centralSquareRoot = Math.sqrt(x * x + y * y);
    double centralLatitude = Math.atan2(z, centralSquareRoot);

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

}

w aplikacji build.gradle dodaj:

implementation 'com.google.android.gms:play-services-maps:17.0.0'
Hossein Amini
źródło
2

Implementacja Dart dla Flutter, aby znaleźć punkt środkowy dla wielu szerokości i długości geograficznych.

import pakietu matematycznego

import 'dart:math' as math;

Lista szerokości i długości geograficznej

List<LatLng> latLongList = [LatLng(12.9824, 80.0603),LatLng(13.0569,80.2425,)];

void getCenterLatLong(List<LatLng> latLongList) {
    double pi = math.pi / 180;
    double xpi = 180 / math.pi;
    double x = 0, y = 0, z = 0;

    if(latLongList.length==1)
    {
        return latLongList[0];
    }
    for (int i = 0; i < latLongList.length; i++) {
      double latitude = latLongList[i].latitude * pi;
      double longitude = latLongList[i].longitude * pi;
      double c1 = math.cos(latitude);
      x = x + c1 * math.cos(longitude);
      y = y + c1 * math.sin(longitude);
      z = z + math.sin(latitude);
    }

    int total = loadList.length;
    x = x / total;
    y = y / total;
    z = z / total;

    double centralLongitude = math.atan2(y, x);
    double centralSquareRoot = math.sqrt(x * x + y * y);
    double centralLatitude = math.atan2(z, centralSquareRoot);

    return LatLng(centralLatitude*xpi,centralLongitude*xpi);
}
MSARKrish
źródło
1

Jest to to samo, co problem średniej ważonej, w którym wszystkie wagi są takie same i istnieją dwa wymiary.

Znajdź średnią wszystkich szerokości geograficznych dla swojej środkowej szerokości geograficznej i średnią wszystkich długości geograficznych dla środkowej szerokości geograficznej.

Caveat Emptor: Jest to przybliżenie z bliskiej odległości i błąd stanie się niesforny, gdy odchylenia od średniej będą większe niż kilka mil z powodu krzywizny Ziemi. Pamiętaj, że szerokości i długości geograficzne to stopnie (nie są to tak naprawdę siatki).

jpredham
źródło
1
[-179,0], [+ 179,0] średnio na [0,0], co jest nieco dalekie od prawidłowego wyniku;)
Piskvor opuścił budynek
1

Brak obiektu w PHP. Biorąc pod uwagę tablicę par współrzędnych, zwraca środek.

/**
 * Calculate center of given coordinates
 * @param  array    $coordinates    Each array of coordinate pairs
 * @return array                    Center of coordinates
 */
function getCoordsCenter($coordinates) {    
    $lats = $lons = array();
    foreach ($coordinates as $key => $value) {
        array_push($lats, $value[0]);
        array_push($lons, $value[1]);
    }
    $minlat = min($lats);
    $maxlat = max($lats);
    $minlon = min($lons);
    $maxlon = max($lons);
    $lat = $maxlat - (($maxlat - $minlat) / 2);
    $lng = $maxlon - (($maxlon - $minlon) / 2);
    return array("lat" => $lat, "lon" => $lng);
}

Pomysł zaczerpnięty z # 4

DabitNG
źródło
1
To nie zadziała dla współrzędnych przecinających 180-ty południk. Na przykład dwa punkty podłużne, -175 i 175, zwróciłyby środek 0 w algorytmie, przy czym rzeczywisty środek będzie wynosił -180 lub 180.
Winch
1

Oto wersja Pythona do znajdowania punktu środkowego. Lat1 i lon1 to listy szerokości i długości geograficznej. przywróci szerokość i długość geograficzną punktu środkowego.

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
Faisal
źródło
1

Dart / Flutter Oblicz punkt środkowy wielu par współrzędnych szerokość / długość geograficzna

Map<String, double> getLatLngCenter(List<List<double>> coords) {
    const LATIDX = 0;
    const LNGIDX = 1;
    double sumX = 0;
    double sumY = 0;
    double sumZ = 0;

    for (var i = 0; i < coords.length; i++) {
      var lat = VectorMath.radians(coords[i][LATIDX]);
      var lng = VectorMath.radians(coords[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 / coords.length;
    var avgY = sumY / coords.length;
    var avgZ = sumZ / coords.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 {
      "latitude": VectorMath.degrees(lat),
      "longitude": VectorMath.degrees(lng)
    };
  }
Miguel Chiquin
źródło
0

Jeśli chcesz, aby wszystkie punkty były widoczne na obrazie, chciałbyś uzyskać ekstrema w szerokości i długości geograficznej i upewnij się, że twój widok zawiera te wartości z dowolną krawędzią.

(Z odpowiedzi Alnitaka, sposób obliczania ekstremów może być trochę problematyczny, ale jeśli są one kilka stopni po obu stronach zawijającej się długości geograficznej, wtedy sprawdzisz strzał i wybierzesz właściwy zakres.)

Jeśli nie chcesz zniekształcać mapy, na której znajdują się te punkty, dostosuj współczynnik kształtu obwiedni tak, aby pasował do wszystkich pikseli, które przypisałeś do widoku, ale nadal zawiera ekstrema.

Aby punkty były wyśrodkowane na jakimś dowolnym poziomie powiększenia, oblicz środek obwiedni, która „po prostu pasuje” do punktów, jak powyżej, i zachowaj ten punkt jako środek.

Jan
źródło
0

Zrobiłem to zadanie w javascript jak poniżej

function GetCenterFromDegrees(data){
    // var data = [{lat:22.281610498720003,lng:70.77577162868579},{lat:22.28065743343672,lng:70.77624369747241},{lat:22.280860953131217,lng:70.77672113067706},{lat:22.281863655593973,lng:70.7762061465462}];
    var num_coords = data.length;
    var X = 0.0;
    var Y = 0.0;
    var Z = 0.0;

    for(i=0; i<num_coords; i++){
        var lat = data[i].lat * Math.PI / 180;
        var lon = data[i].lng * 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;

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

    var finalLat = lat * 180 / Math.PI;
    var finalLng =  lon * 180 / Math.PI; 

    var finalArray = Array();
    finalArray.push(finalLat);
    finalArray.push(finalLng);
    return finalArray;
}
Renish Gotecha
źródło
0

W ramach podziękowania za ten wątek, oto mój mały wkład w implementację w Rubim, mając nadzieję, że zaoszczędzę komuś kilka minut z ich cennego czasu:

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
Fatos Morina
źródło
0

Użyłem formuły, którą dostałem z www.geomidpoint.com i napisałem następującą implementację w C ++. arrayI geocoordssą moje własne zajęcia, których funkcjonalność powinna być oczywista.

/*
 * midpoints calculated using formula from www.geomidpoint.com
 */
   geocoords geocoords::calcmidpoint( array<geocoords>& points )
   {
      if( points.empty() ) return geocoords();

      float cart_x = 0,
            cart_y = 0,
            cart_z = 0;

      for( auto& point : points )
      {
         cart_x += cos( point.lat.rad() ) * cos( point.lon.rad() );
         cart_y += cos( point.lat.rad() ) * sin( point.lon.rad() );
         cart_z += sin( point.lat.rad() );
      }

      cart_x /= points.numelems();
      cart_y /= points.numelems();
      cart_z /= points.numelems();

      geocoords mean;

      mean.lat.rad( atan2( cart_z, sqrt( pow( cart_x, 2 ) + pow( cart_y, 2 ))));
      mean.lon.rad( atan2( cart_y, cart_x ));

      return mean;
   }
Chris Lang
źródło