blocks|key|840445|text|这与加权平均问题相同，其中所有权重都相同，并且有两个维度。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|840446|求出中心纬度的所有纬度的平均值，以及中心经度的所有经度的平均值。|840447|注意:这是一个近距离的近似，当由于地球的曲率而与平均值的偏差超过几英里时，误差将变得难以控制。请记住，纬度和经度是度(不是真正的网格)。|840448|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

This is is the same as a weighted average problem where all the weights are the same, and there are two dimensions. 

Find the average of all latitudes for your center latitude and the average of all longitudes for the center longitude.

Caveat Emptor: This is a close distance approximation and the error will become unruly when the deviations from the mean are more than a few miles due to the curvature of the Earth. Remember that latitudes and longitudes are degrees (not really a grid).

blocks|key|840568|text|如果您希望所有点在图像中都可见，则需要纬度和经度的极值，并确保视图包含这些值以及您想要的任何边框。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|840569|(从Alnitak的回答来看，你如何计算极值可能有点问题，但如果它们在环绕的经度的两边都有几度，那么你就可以决定并采取正确的范围。)|840570|如果你不想扭曲这些点所在的任何贴图，那么调整边界框的纵横比，以便它适合你分配给视图的任何像素，但仍然包括极值。|840571|要将点保持在某个任意缩放级别的中心，请计算与上面的点“恰好匹配”的边界框的中心，并将该点保持为中心点。|840572|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

If you want all points to be visible in the image, you'd want the extrema in latitude and longitude and make sure that your view includes those values with whatever border you want.

(From Alnitak's answer, how you calculate the extrema may be a little problematic, but if they're a few degrees on either side of the longitude that wraps around, then you'll call the shot and take the right range.)

If you don't want to distort whatever map that these points are on, then adjust the bounding box's aspect ratio so that it fits whatever pixels you've allocated to the view but still includes the extrema.

To keep the points centered at some arbitrary zooming level, calculate the center of the bounding box that "just fits" the points as above, and keep that point as the center point.

blocks|key|624812|text|如果你想考虑正在使用的椭球体，你可以在这里找到公式http://www.ordnancesurvey.co.uk/oswebsite/gps/docs/A_Guide_to_Coordinate_Systems_in_Great_Britain.pdf|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|624813|请参阅附件B|624814|该文档还包含许多其他有用的内容|624815|B|624816|entityMap|0|LINK|mutability|MUTABLE|url|http://www.ordnancesurvey.co.uk/oswebsite/gps/docs/A_Guide_to_Coordinate_Systems_in_Great_Britain.pdf^0|P|2T|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]]|C|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|K|$L|$5|M|N|O|C|$P|Q]]]]

If you wish to take into account the ellipsoid being used you can find the formulae
here <a href="http://www.ordnancesurvey.co.uk/oswebsite/gps/docs/A_Guide_to_Coordinate_Systems_in_Great_Britain.pdf" rel="nofollow">http://www.ordnancesurvey.co.uk/oswebsite/gps/docs/A_Guide_to_Coordinate_Systems_in_Great_Britain.pdf</a>

see Annexe B

The document contains lots of other useful stuff

B

blocks|key|840679|text|谢谢!下面是使用degrees的OP解决方案的C#版本。它利用System.Device.Location.GeoCoordinate类|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|840680|++++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+%2B=+Math.Cos(latitude)+*+Math.Cos(longitude);
++++++++++++y+%2B=+Math.Cos(latitude)+*+Math.Sin(longitude);
++++++++++++z+%2B=+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+%2B+y+*+y);
++++++++var+centralLatitude+=+Math.Atan2(z,+centralSquareRoot);

++++++++return+new+GeoCoordinate(centralLatitude+*+180+/+Math.PI,+centralLongitude+*+180+/+Math.PI);
++++}|code-block|syntax|javascript|840681|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/system.device.location.geocoordinate(v=vs.110).aspx^0|V|10|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Thanks! Here is a C# version of OP's solutions using degrees. It utilises the <a href="http://msdn.microsoft.com/en-us/library/system.device.location.geocoordinate(v=vs.110).aspx">System.Device.Location.GeoCoordinate</a> class

<pre class="lang-csh prettyprint-override"><code> public static GeoCoordinate GetCentralGeoCoordinate(
 IList&lt;GeoCoordinate&gt; 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);
 }
</code></pre>

blocks|key|840716|text|如果你有兴趣获得一个非常简单的点的“中心”(例如，简单地将地图居中到你的gmaps多边形的中心)，那么这里有一个对我有效的基本方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|840717|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;
}|code-block|syntax|javascript|840718|这将返回多边形中心的中间经纬度/lng坐标。|840719|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

If you are interested in obtaining a very simplified 'center' of the points (for example, to simply center a map to the center of your gmaps polygon), then here's a basic approach that worked for me.

<pre><code>public function center() {
 $minlat = false;
 $minlng = false;
 $maxlat = false;
 $maxlng = false;
 $data_array = json_decode($this-&gt;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] &lt; $minlat) ? $data_coords[0] : $minlat; }
 if ($maxlat === false) { $maxlat = $data_coords[0]; } else { $maxlat = ($data_coords[0] &gt; $maxlat) ? $data_coords[0] : $maxlat; }
 if ($minlng === false) { $minlng = $data_coords[1]; } else { $minlng = ($data_coords[1] &lt; $minlng) ? $data_coords[1] : $minlng; }
 if ($maxlng === false) { $maxlng = $data_coords[1]; } else { $maxlng = ($data_coords[1] &gt; $maxlng) ? $data_coords[1] : $maxlng; }
 }
 }
 $lat = $maxlat - (($maxlat - $minlat) / 2);
 $lng = $maxlng - (($maxlng - $minlng) / 2);
 return $lat.','.$lng;
}
</code></pre>

This returns the middle lat/lng coordinate for the center of a polygon.

blocks|key|840753|text|我发现这篇文章非常有用，所以这里是用PHP编写的解决方案。我已经成功地使用了这个，只是想节省另一个开发人员的时间。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|840754|/**
+*+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+%2B=+$a;
++++++++$Y+%2B=+$b;
++++++++$Z+%2B=+$c;
++++}

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

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

++++return+array($lat+*+180+/+pi(),+$lon+*+180+/+pi());
}|code-block|syntax|javascript|840755|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I found this post very useful so here is the solution in PHP. I've been using this successfully and just wanted to save another dev some time.

<pre class="lang-php prettyprint-override"><code>/**
 * 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 = &gt; array(45.849382, 76.322333),
 * 1 = &gt; array(45.843543, 75.324143),
 * 2 = &gt; array(45.765744, 76.543223),
 * 3 = &gt; 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());
}
</code></pre>

blocks|key|625012|text|为了尽可能节省某人一两分钟的时间，这里是Objective-C中使用的解决方案，而不是python。此版本采用包含MKMapCoordinates的NSValues的NSArray，这是我的实现中需要的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|625013|#import+<MapKit/MKGeometry.h>|code-block|syntax|javascript|625014|%2B+(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+%2B=+cos(lat)+*+cos(lon);
++++++++y+%2B=+cos(lat)+*+sin(lon);
++++++++z+%2B=+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+%2B+y+*+y);
++++double+resultLat+=+atan2(z,+resultHyp);

++++CLLocationCoordinate2D+result+=+CLLocationCoordinate2DMake(GLKMathRadiansToDegrees(resultLat),+GLKMathRadiansToDegrees(resultLon));
++++return+result;
}|625015|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|D|7|M|8|@]|9|@]|A|$E|F]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

In the interest of possibly saving someone a minute or two, here is the solution that was used in Objective-C instead of python. This version takes an NSArray of NSValues that contain MKMapCoordinates, which was called for in my implementation:

<pre><code>#import &lt;MapKit/MKGeometry.h&gt;
</code></pre>

<pre class="lang-c prettyprint-override"><code>+ (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;
}
</code></pre>

blocks|key|625062|text|非常有用的帖子！我已经在JavaScript中实现了这一点，这里是我的代码。我已经成功地使用了这一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|625063|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%2B%2B)+{
++++++++var+lat+=+degr2rad(latLngInDegr[i][LATIDX]);
++++++++var+lng+=+degr2rad(latLngInDegr[i][LNGIDX]);
++++++++//+sum+of+cartesian+coordinates
++++++++sumX+%2B=+Math.cos(lat)+*+Math.cos(lng);
++++++++sumY+%2B=+Math.cos(lat)+*+Math.sin(lng);
++++++++sumZ+%2B=+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+%2B+avgY+*+avgY);
++++var+lat+=+Math.atan2(avgZ,+hyp);

++++return+([rad2degr(lat),+rad2degr(lng)]);
}|code-block|syntax|javascript|625064|​|625065|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Very useful post! I've implemented this in JavaScript, hereby my code. I've used this successfully. 

<pre class="lang-js prettyprint-override"><code>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&lt;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)]);
}
</code></pre>

blocks|key|840935|text|非常好的解决方案，正是我的swift项目所需要的，所以这里有一个swift端口。谢谢&这里还有一个游乐场项目：https://github.com/ppoh71/playgounds/tree/master/centerLocationPoint.playground|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|840936|/*
*+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+%2B=+cos(lat)+*+cos(long);
++++++++y+%2B=+cos(lat)+*+sin(long);
++++++++z+%2B=+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+%2B+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)")|code-block|syntax|javascript|840937|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/ppoh71/playgounds/tree/master/centerLocationPoint.playground^0|1J|27|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

very nice solutions, just what i needed for my swift project, so here's a swift port. thanks &amp; here's also a playground project: 
<a href="https://github.com/ppoh71/playgounds/tree/master/centerLocationPoint.playground" rel="noreferrer">https://github.com/ppoh71/playgounds/tree/master/centerLocationPoint.playground</a>

<pre><code>/*
* 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]) -&gt; 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)")
</code></pre>

blocks|key|625180|text|原始函数的Javascript版本|type|unstyled|depth|inlineStyleRanges|entityRanges|data|625181|/**
+*+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%2B%2B){
++++++++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+%2B=+a;
++++++++Y+%2B=+b;
++++++++Z+%2B=+c;
++++}

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

++++var+lon+=+Math.atan2(Y,+X);
++++var+hyp+=+Math.sqrt(X+*+X+%2B+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);
}|code-block|syntax|javascript|625182|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Javascript version of the original function

<pre><code>/**
 * 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 = &gt; array(45.849382, 76.322333),
 * 1 = &gt; array(45.843543, 75.324143),
 * 2 = &gt; array(45.765744, 76.543223),
 * 3 = &gt; array(45.784234, 74.542335)
 * );
*/
function GetCenterFromDegrees(data)
{ 
 if (!(data.length &gt; 0)){
 return false;
 } 

 var num_coords = data.length;

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

 for(i = 0; i &lt; 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);
}
</code></pre>

blocks|key|625245|text|在Django中，这是微不足道的(实际上，我遇到了一些解决方案不能正确返回latitude负片的问题)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|625246|例如，假设您正在使用django-geopostcodes+(我是它的作者)。|offset|length|625247|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|code-block|syntax|javascript|625248|point是一个Django+Point实例，然后可以用来做一些事情，比如检索中心点10+is内的所有对象；|style|CODE|625249|Locality.objects.filter(point__distance_lte=(point,+D(km=10)))\
++++.annotate(distance=Distance('point',+point))\
++++.order_by('distance')|625250|将其更改为原始Python是微不足道的；|625251|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|625252|在幕后，Django正在使用GEOS+-更多详细信息请访问https://docs.djangoproject.com/en/1.10/ref/contrib/gis/geos/|625253|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/alexhayes/django-geopostcodes|1|https://docs.djangoproject.com/en/1.10/ref/contrib/gis/geos/^0|0|A|J|0|0|0|0|5|F|5|0|0|0|0|T|1O|1|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@]|9|@$D|18|E|19|1|1A]]|A|$]]|$1|F|3|G|5|H|7|1B|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|1C|8|@$D|1D|E|1E|M|N]|$D|1F|E|1G|M|N]]|9|@]|A|$]]|$1|O|3|P|5|H|7|1H|8|@]|9|@]|A|$I|J]]|$1|Q|3|R|5|6|7|1I|8|@]|9|@]|A|$]]|$1|S|3|T|5|H|7|1J|8|@]|9|@]|A|$I|J]]|$1|U|3|V|5|6|7|1K|8|@]|9|@$D|1L|E|1M|1|1N]]|A|$]]|$1|W|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]|14|$5|Z|10|11|A|$12|15]]]]

In Django this is trivial (and actually works, I had issues with a number of the solutions not correctly returning negatives for latitude).

For instance, let's say you are using <a href="https://github.com/alexhayes/django-geopostcodes" rel="nofollow noreferrer">django-geopostcodes</a> (of which I am the author).

<pre class="lang-py prettyprint-override"><code>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
</code></pre>

<code>point</code> is a Django <code>Point</code> instance that can then be used to do things such as retrieve all objects that are within 10km of that centre point;

<pre class="lang-py prettyprint-override"><code>Locality.objects.filter(point__distance_lte=(point, D(km=10)))\
 .annotate(distance=Distance('point', point))\
 .order_by('distance')
</code></pre>

Changing this to raw Python is trivial;

<pre class="lang-py prettyprint-override"><code>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
</code></pre>

Under the hood Django is using GEOS - more details at <a href="https://docs.djangoproject.com/en/1.10/ref/contrib/gis/geos/" rel="nofollow noreferrer">https://docs.djangoproject.com/en/1.10/ref/contrib/gis/geos/</a>

blocks|key|625283|text|PHP中的对象外。给定坐标对数组，返回center。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|625284|/**
+*+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);
}|code-block|syntax|javascript|625285|取自#4|625286|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Out of object in PHP. Given array of coordinate pairs, returns center.

<pre><code>/**
 * 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 =&gt; $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" =&gt; $lat, "lon" =&gt; $lng);
}
</code></pre>

Taken idea from #4

blocks|key|841132|text|这是用于查找中心点的python版本。lat1和lon1是纬度和经度列表。它将恢复中心点的纬度和经度。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|841133|import+numpy+as+np

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+%2B=+a
++++++++Y+%2B=+b
++++++++Z+%2B=+c

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

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

++++newX+=+(lat+*+180+/+np.pi)
++++newY+=+(lon+*+180+/+np.pi)
++++return+newX,+newY|code-block|syntax|javascript|841134|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is the python Version for finding center point.
The lat1 and lon1 are latitude and longitude lists.
it will retuen the latitude and longitude of center point.
<pre class="lang-py prettyprint-override"><code>import numpy as np

def GetCenterFromDegrees(lat1,lon1):
 if (len(lat1) &lt;= 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
</code></pre>

blocks|key|625376|text|我用javascript完成了这个任务，如下所示|type|unstyled|depth|inlineStyleRanges|entityRanges|data|625377|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%2B%2B){
++++++++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+%2B=+a;
++++++++Y+%2B=+b;
++++++++Z+%2B=+c;
++++}

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

++++lon+=+Math.atan2(Y,+X);
++++var+hyp+=+Math.sqrt(X+*+X+%2B+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;
}|code-block|syntax|javascript|625378|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I did this task in javascript like below

<pre><code>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&lt;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;
}
</code></pre>

blocks|key|625432|text|为了感谢这个帖子，这里是我对Ruby实现的一点贡献，希望我能节省一些人几分钟的宝贵时间：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|625433|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+%7Cstation%7C
+++latitude+=+station.latitude+*+Math::PI+/+180
+++longitude+=+station.longitude+*+Math::PI+/+180

+++x+%2B=+Math.cos(latitude)+*+Math.cos(longitude)
+++y+%2B=+Math.cos(latitude)+*+Math.sin(longitude)
+++z+%2B=+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+%2B+y+*+y)
+central_latitude+=+Math.atan2(z,+central_square_root)

+[latitude:+central_latitude+*+180+/+Math::PI,+
+longitude:+central_longitude+*+180+/+Math::PI]
end|code-block|syntax|javascript|625434|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

As an appreciation for this thread, here is my little contribution with the implementation in Ruby, hoping that I will save someone a few minutes from their precious time:

<pre><code>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
</code></pre>

blocks|key|625498|text|我使用了从www.geomidpoint.com获得的公式，并编写了以下C%2B%2B实现。array和geocoords是我自己的类，它们的功能应该不言自明。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|625499|/*
+*+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+%2B=+cos(+point.lat.rad()+)+*+cos(+point.lon.rad()+);
+++++++++cart_y+%2B=+cos(+point.lat.rad()+)+*+sin(+point.lon.rad()+);
+++++++++cart_z+%2B=+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+)+%2B+pow(+cart_y,+2+))));
++++++mean.lon.rad(+atan2(+cart_y,+cart_x+));

++++++return+mean;
+++}|code-block|syntax|javascript|625500|entityMap^0|16|5|1C|9|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

I used a formula that I got from www.geomidpoint.com and wrote the following C++ implementation. The <code>array</code> and <code>geocoords</code> are my own classes whose functionality should be self-explanatory.

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

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

 for( auto&amp; 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;
 }
</code></pre>

blocks|key|625541|text|Java版本，如果有人需要的话。常量定义为静态，不会计算两次。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|625542|/**************************************************************************************************************
+*+++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+%2B=+cl+*+Math.cos(longitude);
++++++++y+%2B=+cl+*+Math.sin(longitude);
++++++++z+%2B=+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+%2B+y+*+y);
++++double+centralLatitude+=+Math.atan2(z,+centralSquareRoot);

++++return+new+Coordinate(centralLatitude+*+xpi,+centralLongitude+*+xpi);
}|code-block|syntax|javascript|625543|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Java Version if anyone needs it. Constants defined static to not calculate them twice.

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

blocks|key|625655|text|以下是基于@Yodacheese使用Google+Maps+api的C#答案的安卓版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|625656|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+%2B=+Math.cos(latitude)+*+Math.cos(longitude);
++++++++y+%2B=+Math.cos(latitude)+*+Math.sin(longitude);
++++++++z+%2B=+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+%2B+y+*+y);
++++double+centralLatitude+=+Math.atan2(z,+centralSquareRoot);

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

}|code-block|syntax|javascript|625657|在app+build.gradle中添加：|625658|implementation+'com.google.android.gms:play-services-maps:17.0.0'|625659|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here is the Android version based on @Yodacheese's C# answer using Google Maps api:

<pre><code>public static LatLng GetCentralGeoCoordinate(List&lt;LatLng&gt; 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);

}
</code></pre>

in app build.gradle add:

<pre><code>implementation 'com.google.android.gms:play-services-maps:17.0.0'
</code></pre>

blocks|key|625724|text|Dart/Flutter计算多个纬度/经度坐标对的中心点|type|unstyled|depth|inlineStyleRanges|entityRanges|data|625725|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%2B%2B)+{
++++++var+lat+=+VectorMath.radians(coords[i][LATIDX]);
++++++var+lng+=+VectorMath.radians(coords[i][LNGIDX]);
++++++//+sum+of+cartesian+coordinates
++++++sumX+%2B=+Math.cos(lat)+*+Math.cos(lng);
++++++sumY+%2B=+Math.cos(lat)+*+Math.sin(lng);
++++++sumZ+%2B=+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+%2B+avgY+*+avgY);
++++var+lat+=+Math.atan2(avgZ,+hyp);

++++return+{
++++++"latitude":+VectorMath.degrees(lat),
++++++"longitude":+VectorMath.degrees(lng)
++++};
++}|code-block|syntax|javascript|625726|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Dart/Flutter Calculate the center point of multiple latitude/longitude coordinate pairs

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

 for (var i = 0; i &lt; 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)
 };
 }
</code></pre>

blocks|key|841495|text|Scala版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|841496|import+scala.math._
++++
case+class+Coordinate(latitude:+Double,+longitude:+Double)
++++
def+center(coordinates:+List[Coordinate])+=+{
++val+(a:+Double,+b:+Double,+c:+Double)+=+coordinates.fold((0.0,+0.0,+0.0))+{
++++case+((x:+Double,+y:+Double,+z:+Double),+coord:+Coordinate)+=>
++++++val+latitude+=+coord.latitude+*+Pi+/+180
++++++val+longitude+=+coord.longitude+*+Pi+/+180
++++++(x+%2B+cos(latitude)+*+cos(longitude),+y+%2B+cos(latitude)+*+sin(longitude),+z+%2B+sin(latitude))
++}
++val+total+=+coordinates.length
++val+(x:+Double,+y:+Double,+z:+Double)+=+(a+/+total,+b+/+total,+c+/+total)
++val+centralLongitude+=+atan2(y,+x)
++val+centralSquareRoot+=+sqrt(x+*+x+%2B+y+*+y)
++val+centralLatitude+=+atan2(z,+centralSquareRoot)
++++
++Coordinate(centralLatitude+*+180+/+Pi,+centralLongitude+*+180+/+Pi);
}|code-block|syntax|javascript|841497|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Scala version:
<pre class="lang-scala prettyprint-override"><code>import scala.math._
 
case class Coordinate(latitude: Double, longitude: Double)
 
def center(coordinates: List[Coordinate]) = {
 val (a: Double, b: Double, c: Double) = coordinates.fold((0.0, 0.0, 0.0)) {
 case ((x: Double, y: Double, z: Double), coord: Coordinate) =&gt;
 val latitude = coord.latitude * Pi / 180
 val longitude = coord.longitude * Pi / 180
 (x + cos(latitude) * cos(longitude), y + cos(latitude) * sin(longitude), z + sin(latitude))
 }
 val total = coordinates.length
 val (x: Double, y: Double, z: Double) = (a / total, b / total, c / total)
 val centralLongitude = atan2(y, x)
 val centralSquareRoot = sqrt(x * x + y * y)
 val centralLatitude = atan2(z, centralSquareRoot)
 
 Coordinate(centralLatitude * 180 / Pi, centralLongitude * 180 / Pi);
}

</code></pre>

blocks|key|841609|text|因此，这些答案中的许多只是一种奇怪的方法的变体，该方法找不到包含所有点的边界框的真正中心。相反，它会找到大多数点的中心(一种加权中心)。如果您想要所有点的真实中心，而不考虑聚类和权重，您可以获得边界框并轻松找到这4个角的中心。如果你不关心地球曲率的因子分解，你可以使用像(C#代码)这样简单的东西：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|841610|var+lat+=+(coordinates.Min(x+=>+x.lat)+%2B+coordinates.Max(x+=>+x.lat))/2;
var+lon+=+(coordinates.Min(x+=>+x.lon)+%2B+coordinates.Max(x+=>+x.lon))/2;
return+new+Tuple<double,+double>(lat,+lon);|code-block|syntax|javascript|841611|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

So many of these answers are just variations on an odd approach that doesn't find the true center of the bounding box that comprises all the points. Rather it finds the center of most points (a weighted center of sorts). If you want the true center of all points regardless of clustering and weights, you can get the bounding box and easily find the center of those 4 corners. If you aren't concerned about factoring in earth curvature, you can get away with something as simple as (C# code):
<pre><code>var lat = (coordinates.Min(x =&gt; x.lat) + coordinates.Max(x =&gt; x.lat))/2;
var lon = (coordinates.Min(x =&gt; x.lon) + coordinates.Max(x =&gt; x.lon))/2;
return new Tuple&lt;double, double&gt;(lat, lon);
</code></pre>

Given a set of latitude and longitude points, how can I calculate the latitude and longitude of the center point of that set (aka a point that would center a view on all points)?

EDIT: Python solution I've used:

<pre class="lang-py prettyprint-override"><code>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)
</code></pre>

Calculate the center point of multiple latitude/longitude coordinate pairs

Objective-C

Flutter

Django

Python

Java

给定一组纬度和经度点，我如何计算该集合中心点的纬度和经度(也就是将视图集中在所有点上的一个点)？编辑:我使用过的Python解决方案：Convert lat/lon (must be in radians) to Cartesian coordinates for each location.X = cos(lat) ...

问计算多个纬度/经度坐标对的中心点
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问计算多个纬度/经度坐标对的中心点EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问计算多个纬度/经度坐标对的中心点
EN