给定一组纬度和经度点，如何计算该集合中心点的纬度和经度（也就是将所有点的视图居中的点）？
编辑：我用过的Python解决方案：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)
答案 0 :(得分：76)
谢谢！这是使用度数的OP解决方案的C＃版本。它使用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);
}
答案 1 :(得分：46)
只是平均它们的简单方法有奇怪的边缘情况，当它们从359'回到0'时会有角度。
A much earlier question on SO询问是否找到了一组罗盘角度的平均值。
对球形坐标推荐的方法的扩展将是：
答案 2 :(得分：38)
我发现这篇文章非常有用，所以这里是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());
}
答案 3 :(得分：26)
非常有用的帖子！我在JavaScript中实现了这一点，特此是我的代码。我成功地使用了这个。
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)]);
}
答案 4 :(得分：12)
为了节省一两分钟的时间，这里是Objective-C而不是python中使用的解决方案。这个版本采用NSArray的NSValues包含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;
}
答案 5 :(得分：12)
原始功能的Javascript版本
/**
* 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);
}
答案 6 :(得分：6)
非常好的解决方案，正是我的快速项目所需要的，所以这里是一个快捷的端口。谢谢＆amp;这里也是一个游乐场项目： 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)")
答案 7 :(得分：4)
如果您有兴趣获得点的非常简化的“中心”（例如，简单地将地图居中到您的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;
}
返回多边形中心的中间lat / lng坐标。
答案 8 :(得分：3)
这是使用Google Maps api的@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);
}
在应用程序build.gradle中添加：
implementation 'com.google.android.gms:play-services-maps:17.0.0'
答案 9 :(得分：3)
在Django中，这是微不足道的（实际上有效，我遇到了许多解决方案没有正确返回纬度的负面问题）。
例如，假设您正在使用django-geopostcodes（我是作者）。
this methods:{
checkproject: function(){
var fetch = this.count += 4;
axios.post('/loadmore', {fetch: fetch })
.then(response => {
this.fetched_projects.push(response.data);
})
.catch(function(error){
console.log(error);
});
}
是一个Django 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
实例，可用于执行诸如检索距该中心点10公里范围内的所有对象之类的事情;
point将此更改为原始Python是微不足道的;
Point引擎盖下Django正在使用GEOS - 更多细节见https://docs.djangoproject.com/en/1.10/ref/contrib/gis/geos/
答案 10 :(得分：2)
Dart 的实现，用于 Flutter ，以查找多个纬度，经度的中心点。
导入数学包
import 'dart:math' as math;
经纬度列表
List<LatLng> latLongList = [LatLng(12.9824, 80.0603),LatLng(13.0569,80.2425,)];
LatLng 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 = latLongList.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);
}
答案 11 :(得分：1)
这与所有权重相同的加权平均问题相同，并且有两个维度。
找出中心纬度的所有纬度的平均值以及中心经度的所有经度的平均值。
警告Emptor：这是近距离近似，当由于地球的曲率而偏离平均值超过几英里时，误差将变得难以驾驭。请记住，纬度和经度都是度数（不是真正的网格）。
答案 12 :(得分：1)
Dart / Flutter计算多个纬度/经度坐标对的中心点
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)
};
}
答案 13 :(得分：1)
Java版本（如果有人需要）。常量定义为静态，因此不会两次计算。
/**************************************************************************************************************
* 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);
}
答案 14 :(得分：1)
如果您想考虑使用的椭球，您可以找到公式 这里http://www.ordnancesurvey.co.uk/oswebsite/gps/docs/A_Guide_to_Coordinate_Systems_in_Great_Britain.pdf
见附件B
该文件包含许多其他有用的东西
乙
答案 15 :(得分：0)
我在JavaScript中完成了以下任务
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;
}
答案 16 :(得分：0)
作为对此线程的感谢，这是我对Ruby实现的一点贡献，希望我可以从某人的宝贵时间中节省几分钟：
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
答案 17 :(得分：0)
我使用从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;
}
答案 18 :(得分：0)
这是用于查找中心点的python版本。 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
答案 19 :(得分：0)
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
答案 20 :(得分：0)
如果您希望图像中显示所有点，则需要纬度和经度的极值，并确保您的视图包含具有您想要的任何边界的值。
（根据Alnitak的回答，你如何计算极值可能会有点问题，但如果它们在经度的两边都有几度，那么你就会调用射击并采取正确的射程。 ）
如果您不想扭曲这些点所在的任何地图，请调整边界框的纵横比，使其适合您分配给视图的任何像素，但仍然包含极值。
要使点以某个任意缩放级别为中心，请计算边界框的中心，使其“恰好适合”上述点，并将该点保持为中心点。
答案 21 :(得分：0)
Scala 版本：
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 + 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);
}