कई अक्षांश / देशांतर समन्वय जोड़े के केंद्र बिंदु की गणना करें

Question

अक्षांश और देशांतर बिंदुओं के एक सेट को देखते हुए, मैं उस सेट के केंद्र बिंदु के अक्षांश और देशांतर की गणना कैसे कर सकता हूं (उर्फ एक बिंदु जो सभी बिंदुओं पर एक दृश्य केंद्रित करेगा)?

संपादित करें: पायथन समाधान मैंने उपयोग किया है:

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)

Comments

आपके समाधान के बारे में: संभवतः आपकी त्रुटियाँ एक गोलाकार पृथ्वी की धारणा के साथ बहुत बड़ी नहीं होंगी, लेकिन पृथ्वी को एक दीर्घवृत्त के रूप में वर्णित किया जाता है।

— जॉन

इसे अजगर समारोह के रूप में लिखा और इसे gist.github.com/3718961

— एल्विन

यह ध्यान रखना बहुत महत्वपूर्ण है कि यह माना जाता है कि आपके लाट और लंबे रेडियन में हैं! मैं थोड़ी देर के लिए अपने सिर को खरोंच रहा था कि साकार नहीं। दशमलव से रेडियन में बदलने के लिए, दशमलव * pi / 180 को गुणा करें। फिर रेडियन से दशमलव में वापस बदलने के लिए, 180 / पीआई से गुणा करें। HTH

— रयान गिल

देर से आने के लिए क्षमा करें, लेकिन मैं सोच रहा था कि इस एल्गोरिथम के पीछे क्या गणित है, क्या कोई मुझे कुछ रीडिंग की सलाह दे सकता है जहां यह समझाया गया है? धन्यवाद!

— टॉनिक्स

zPls क्या है ?

— मुसीबत का इशारा

Answer 1

जब उन्हें 359 'बैक टू 0' से लपेटते हैं, तो औसत औसत दृष्टिकोण में कोण के साथ अजीब धार वाले मामले होते हैं।

एक इतने पर बहुत पहले ही सवाल कम्पास कोण का एक सेट की औसत खोजने के बारे में पूछा।

गोलाकार निर्देशांक के लिए वहां सुझाए गए दृष्टिकोण का विस्तार होगा:

• प्रत्येक अक्षांश / लंबी जोड़ी को एक इकाई-लंबाई 3 डी वेक्टर में परिवर्तित करें।
• उनमें से प्रत्येक वैक्टर को योग करें
• परिणामी वेक्टर को सामान्य करें
• गोलाकार निर्देशांक में परिवर्तित करें

Comments

अच्छा लगता है, मैंने इस वेब साइट पर जो कुछ पाया है, उसके आधार पर कुछ ऐसा ही किया था: geomidpoint.com/calacle.html ।

— जेक

downvoter - कृपया समझाएं, और यदि आप कर सकते हैं तो बेहतर समाधान पेश करें।

— अलनीतक

Answer 2

धन्यवाद! यहां डिग्री का उपयोग करते हुए ओपी के समाधानों का सी # संस्करण है। यह System.Device.Location.GeoCoordinate class का उपयोग करता है

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

Answer 3

मैंने इस पोस्ट को बहुत उपयोगी पाया इसलिए यहाँ PHP में समाधान है। मैं इसे सफलतापूर्वक उपयोग कर रहा हूँ और बस कुछ समय के लिए एक और देव को बचाना चाहता था।

/**
 * 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());
}

Comments

मैंने इस समाधान का उपयोग किया है, लेकिन यह किसी भी तरह से गलत समाधान देता है - अगर मैं मानचित्र पर कुछ निर्देशांक के केंद्र को खोजता हूं तो यह अंक का "वजन" करता है और जहां अधिक अंक हैं वहां रहने के लिए झुकता है।

— LowFieldTheory

@Alnitak यहां हम निर्देशांकों द्वारा परिचालित क्षेत्र के केंद्र को खोजना चाहते हैं। क्या आप सुनिश्चित हैं कि आपने सही जगह पर टिप्पणी की है?

— LowFieldTheory

Answer 4

बहुत उपयोगी पोस्ट! मैंने इसे जावास्क्रिप्ट में लागू किया है, जिससे मेरा कोड है। मैंने इसका सफलतापूर्वक उपयोग किया है।

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

Comments

मुझे पता है कि पोस्ट पुरानी है, लेकिन क्या आप कृपया पोस्ट किए गए एल्गोरिदम के पीछे एक संदर्भ या कुछ समझा सकते हैं। धन्यवाद!

— टोनिक्स

पूरी तरह से काम किया! धन्यवाद

— andrewoodleyjr

मैंने Google Apps स्क्रिप्ट के साथ स्क्रिप्ट का परीक्षण किया लेकिन परिणाम किसी ट्रैक का सटीक केंद्र बिंदु नहीं है। यह कहीं आसपास है, लेकिन सीधे ट्रैक पर नहीं है। क्या TRACK पर सटीक मिडपॉइंट प्राप्त करने का बेहतर फॉर्मूला है?

— डिर्क

Answer 5

मूल फ़ंक्शन का जावास्क्रिप्ट संस्करण

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

Answer 6

संभवतया किसी को एक या दो मिनट बचाने के लिए, यहां वह समाधान है जो अजगर के बजाय ऑब्जेक्टिव-सी में इस्तेमाल किया गया था। यह संस्करण NSValues ​​का NSArray लेता है जिसमें MKMapCoordinates शामिल हैं, जिन्हें मेरे कार्यान्वयन के लिए बुलाया गया था:

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

Comments

किसी के लिए भी, इसके लायक क्या है, इसके बजाय रेडियन, आयात <GLKit/GLKMath.h>और उपयोग के लिए डिग्री के लिए अपने स्वयं के मैक्रो का उपयोग करने के लिए GLKMathDegreesToRadiansऔरGLKMathRadiansToDegrees

— pnizzle

Answer 7

बहुत अच्छा समाधान, बस मुझे अपने स्विफ्ट प्रोजेक्ट के लिए क्या चाहिए, इसलिए यहां एक स्विफ्ट पोर्ट है। धन्यवाद और यहाँ भी एक खेल का मैदान परियोजना है: 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)")

Answer 8

यदि आप अंकों के एक बहुत ही सरलीकृत 'केंद्र' को प्राप्त करने में रुचि रखते हैं (उदाहरण के लिए, बस एक नक्शा अपने gmaps बहुभुज के केंद्र के लिए केंद्र में), तो यहाँ एक मूल दृष्टिकोण है जो मेरे लिए काम करता है।

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

यह एक बहुभुज के केंद्र के लिए मध्य लैट / लैंग कोऑर्डिनेट करता है।

Answer 9

Django में यह तुच्छ है (और वास्तव में काम करता है, मेरे पास कई समाधान थे जो अक्षांश के लिए नकारात्मक रूप से वापसी नहीं कर रहे थे)।

उदाहरण के लिए, मान लें कि आप django-geopostcodes का उपयोग कर रहे हैं (जिनमें से मैं लेखक हूं)।

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

pointएक Django Pointउदाहरण है जो तब चीजों को करने के लिए इस्तेमाल किया जा सकता है जैसे कि उन सभी वस्तुओं को पुनः प्राप्त करना जो उस केंद्र बिंदु के 10 किमी के भीतर हैं;

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

इसे कच्चे पायथन में बदलना तुच्छ है;

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

हुड के तहत Django GEOS का उपयोग कर रहा है - https://docs.djangoproject.com/en/1.10/ref/contrib/gis/geos/ पर अधिक विवरण

Answer 10

जावा संस्करण अगर किसी को इसकी आवश्यकता है। स्थिरांक ने उन्हें दो बार गणना नहीं करने के लिए स्थिर परिभाषित किया।

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

Answer 11

यहां Google मैप्स एपीआई का उपयोग करके @ Yodacheese के C # उत्तर पर आधारित Android संस्करण दिया गया है:

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

}

एप्लिकेशन बिल्ड में जोड़ें।

implementation 'com.google.android.gms:play-services-maps:17.0.0'

Answer 12

यह एक भारित औसत समस्या के समान है जहां सभी भार समान हैं, और दो आयाम हैं।

अपने केंद्र अक्षांश के लिए सभी अक्षांशों का औसत और केंद्र देशांतर के लिए सभी अक्षांशों का औसत ज्ञात करें।

कैविट एम्प्टर: यह एक नजदीकी दूरी का अनुमान है और पृथ्वी के वक्रता के कारण मीन से विचलन कुछ मील से अधिक होने पर त्रुटि अनियंत्रित हो जाएगी। याद रखें कि अक्षांश और देशांतर डिग्री (वास्तव में ग्रिड नहीं) हैं।

Comments

[-179,0], [+ 179,0] औसत [0,0], जो कि सही परिणामों से कुछ हद तक दूर है।)

— पिस्कॉर ने

Answer 13

यदि आप इस बात का ध्यान रखना चाहते हैं कि इस्तेमाल किए जा रहे दीर्घवृत्ताकार का उपयोग आप यहां कर सकते हैं तो सूत्र यहाँ पर मिल सकते हैं ।

एनेक्सी बी देखें

दस्तावेज़ में बहुत सारे अन्य उपयोगी सामान हैं

बी

Comments

यहाँ अद्यतन लिंक है: ordnancesurvey.co.uk/docs/support/…

— जेरेमी व्हिचर

Answer 14

PHP में ऑब्जेक्ट से बाहर। समन्वित जोड़े की सरणी को देखते हुए, रिटर्न सेंटर।

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

# 4 से लिया गया विचार

Comments

यह 180 वें मध्याह्न रेखा को पार करने वाले निर्देशांक के लिए काम नहीं करेगा। उदाहरण के लिए, दो अनुदैर्ध्य बिंदु, -175 और 175 आपके एल्गोरिथ्म में 0 का एक केंद्र लौटाएंगे, जिससे वास्तविक केंद्र या तो -180 या 180 होगा।

— विंच

Answer 15

यहां केंद्र बिंदु खोजने के लिए अजगर संस्करण है। Lat1 और lon1 अक्षांश और देशांतर सूची हैं। यह केंद्र बिंदु के अक्षांश और देशांतर को पीछे हटा देगा।

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

Answer 16

कई अव्यवस्था, देशांतर के लिए केंद्र बिंदु खोजने के लिए स्पंदन के लिए डार्ट कार्यान्वयन ।

आयात गणित पैकेज

import 'dart:math' as math;

अक्षांश और देशांतर सूची

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

Answer 17

यदि आप चाहते हैं कि सभी बिंदु छवि में दिखाई दें, तो आप चाहते हैं कि अक्षांश और देशांतर में एक्स्ट्रेमा हो और सुनिश्चित करें कि आपके विचार में वे सीमाएँ शामिल हैं, जो आप चाहते हैं।

(अलनीतक के जवाब से, आप एक्स्ट्रेमा की गणना कैसे करते हैं, यह थोड़ा समस्याग्रस्त हो सकता है, लेकिन यदि वे देशांतर के दोनों ओर कुछ डिग्री हैं, जो चारों ओर से लपेटता है, तो आप शॉट को कॉल करेंगे और सही रेंज लेंगे।)

यदि आप इन बिंदुओं पर जो भी नक्शा बनाना चाहते हैं उसे विकृत नहीं करना चाहते हैं, तो बाउंडिंग बॉक्स के पहलू अनुपात को समायोजित करें ताकि यह आपके द्वारा दृश्य में आबंटित किए गए सभी पिक्सेल को फिट कर दे लेकिन फिर भी इसमें एक्स्ट्रेमा शामिल है।

कुछ मनमाने ढंग से जूमिंग स्तर पर केंद्रित बिंदुओं को रखने के लिए, बाउंडिंग बॉक्स के केंद्र की गणना करें जो ऊपर दिए गए बिंदुओं को "बस फिट" करता है, और उस बिंदु को केंद्र बिंदु के रूप में रखता है।

Answer 18

मैंने इस कार्य को नीचे की तरह जावास्क्रिप्ट में किया था

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

Answer 19

इस धागे की सराहना के रूप में, रूबी में कार्यान्वयन के साथ मेरा थोड़ा योगदान है, मुझे उम्मीद है कि मैं किसी को अपने कीमती समय से कुछ मिनटों में बचाऊंगा:

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

Answer 20

मैंने एक सूत्र का उपयोग किया जो मुझे www.geomidpoint.com से मिला और निम्नलिखित C ++ कार्यान्वयन लिखा। arrayऔर geocoordsमेरे अपने वर्गों जिसका कार्यक्षमता स्वतः स्पष्ट होना चाहिए।

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

Answer 21

डार्ट / स्पंदन कई अक्षांश / देशांतर समन्वय जोड़े के केंद्र बिंदु की गणना करते हैं

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