Como calcular a caixa delimitadora para um determinado local latitude / longitude?
https://stackoverflow.com/questions/238260
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Eu dei um local definido pela latitude e longitude. Agora eu quero calcular uma caixa delimitadora dentro exemplo 10 quilômetros de esse ponto.
A caixa delimitadora deve ser definido como latmin, lngmin e latmax, lngmax.
Eu preciso deste material, a fim de usar o panoramio API .
Alguém sabe a fórmula de como obter thos pontos?
Editar: caras que eu estou procurando uma função / fórmula que leva GNL lat & como entrada e retorna uma caixa delimitadora como latmin & lngmin e latmax & latmin. MySQL, PHP, C #, javascript é bom, mas também pseudocódigo deve estar bem.
Editar: Não estou à procura de uma solução que me mostra a distância de 2 pontos
Solução
Eu sugiro aproximar localmente a superfície da Terra como uma esfera com raio dado pelo WGS84 elipsóide na latitude dada. Eu suspeito que o cálculo exato da latMin e latMax exigiria funções elípticas e não renderia um aumento sensível na precisão (WGS84 é por si só uma aproximação).
Meu implementação segue (Está escrito em Python, eu não testei):
# degrees to radians
def deg2rad(degrees):
return math.pi*degrees/180.0
# radians to degrees
def rad2deg(radians):
return 180.0*radians/math.pi
# Semi-axes of WGS-84 geoidal reference
WGS84_a = 6378137.0 # Major semiaxis [m]
WGS84_b = 6356752.3 # Minor semiaxis [m]
# Earth radius at a given latitude, according to the WGS-84 ellipsoid [m]
def WGS84EarthRadius(lat):
# http://en.wikipedia.org/wiki/Earth_radius
An = WGS84_a*WGS84_a * math.cos(lat)
Bn = WGS84_b*WGS84_b * math.sin(lat)
Ad = WGS84_a * math.cos(lat)
Bd = WGS84_b * math.sin(lat)
return math.sqrt( (An*An + Bn*Bn)/(Ad*Ad + Bd*Bd) )
# Bounding box surrounding the point at given coordinates,
# assuming local approximation of Earth surface as a sphere
# of radius given by WGS84
def boundingBox(latitudeInDegrees, longitudeInDegrees, halfSideInKm):
lat = deg2rad(latitudeInDegrees)
lon = deg2rad(longitudeInDegrees)
halfSide = 1000*halfSideInKm
# Radius of Earth at given latitude
radius = WGS84EarthRadius(lat)
# Radius of the parallel at given latitude
pradius = radius*math.cos(lat)
latMin = lat - halfSide/radius
latMax = lat + halfSide/radius
lonMin = lon - halfSide/pradius
lonMax = lon + halfSide/pradius
return (rad2deg(latMin), rad2deg(lonMin), rad2deg(latMax), rad2deg(lonMax))
EDIT: Os seguintes converte o código (graus, primos, segundos) para graus + fracções de um grau, e vice-versa (não testada):
def dps2deg(degrees, primes, seconds):
return degrees + primes/60.0 + seconds/3600.0
def deg2dps(degrees):
intdeg = math.floor(degrees)
primes = (degrees - intdeg)*60.0
intpri = math.floor(primes)
seconds = (primes - intpri)*60.0
intsec = round(seconds)
return (int(intdeg), int(intpri), int(intsec))
Outras dicas
Eu escrevi um artigo sobre encontrar as coordenadas delimitadoras:
http://JanMatuschek.de/LatitudeLongitudeBoundingCoordinates
O artigo explica as fórmulas e também fornece uma implementação Java. (É também mostra por fórmula de Federico para a longitude min / max é impreciso.)
Aqui eu ter convertido a resposta de Federico A. Ramponi para C # para qualquer pessoa interessada:
public class MapPoint
{
public double Longitude { get; set; } // In Degrees
public double Latitude { get; set; } // In Degrees
}
public class BoundingBox
{
public MapPoint MinPoint { get; set; }
public MapPoint MaxPoint { get; set; }
}
// Semi-axes of WGS-84 geoidal reference
private const double WGS84_a = 6378137.0; // Major semiaxis [m]
private const double WGS84_b = 6356752.3; // Minor semiaxis [m]
// 'halfSideInKm' is the half length of the bounding box you want in kilometers.
public static BoundingBox GetBoundingBox(MapPoint point, double halfSideInKm)
{
// Bounding box surrounding the point at given coordinates,
// assuming local approximation of Earth surface as a sphere
// of radius given by WGS84
var lat = Deg2rad(point.Latitude);
var lon = Deg2rad(point.Longitude);
var halfSide = 1000 * halfSideInKm;
// Radius of Earth at given latitude
var radius = WGS84EarthRadius(lat);
// Radius of the parallel at given latitude
var pradius = radius * Math.Cos(lat);
var latMin = lat - halfSide / radius;
var latMax = lat + halfSide / radius;
var lonMin = lon - halfSide / pradius;
var lonMax = lon + halfSide / pradius;
return new BoundingBox {
MinPoint = new MapPoint { Latitude = Rad2deg(latMin), Longitude = Rad2deg(lonMin) },
MaxPoint = new MapPoint { Latitude = Rad2deg(latMax), Longitude = Rad2deg(lonMax) }
};
}
// degrees to radians
private static double Deg2rad(double degrees)
{
return Math.PI * degrees / 180.0;
}
// radians to degrees
private static double Rad2deg(double radians)
{
return 180.0 * radians / Math.PI;
}
// Earth radius at a given latitude, according to the WGS-84 ellipsoid [m]
private static double WGS84EarthRadius(double lat)
{
// http://en.wikipedia.org/wiki/Earth_radius
var An = WGS84_a * WGS84_a * Math.Cos(lat);
var Bn = WGS84_b * WGS84_b * Math.Sin(lat);
var Ad = WGS84_a * Math.Cos(lat);
var Bd = WGS84_b * Math.Sin(lat);
return Math.Sqrt((An*An + Bn*Bn) / (Ad*Ad + Bd*Bd));
}
Eu escrevi uma função JavaScript que retorna a quatro coordenadas de uma caixa delimitadora quadrada, dada a distância e um par de coordenadas:
'use strict';
/**
* @param {number} distance - distance (km) from the point represented by centerPoint
* @param {array} centerPoint - two-dimensional array containing center coords [latitude, longitude]
* @description
* Computes the bounding coordinates of all points on the surface of a sphere
* that has a great circle distance to the point represented by the centerPoint
* argument that is less or equal to the distance argument.
* Technique from: Jan Matuschek <http://JanMatuschek.de/LatitudeLongitudeBoundingCoordinates>
* @author Alex Salisbury
*/
getBoundingBox = function (centerPoint, distance) {
var MIN_LAT, MAX_LAT, MIN_LON, MAX_LON, R, radDist, degLat, degLon, radLat, radLon, minLat, maxLat, minLon, maxLon, deltaLon;
if (distance < 0) {
return 'Illegal arguments';
}
// helper functions (degrees<–>radians)
Number.prototype.degToRad = function () {
return this * (Math.PI / 180);
};
Number.prototype.radToDeg = function () {
return (180 * this) / Math.PI;
};
// coordinate limits
MIN_LAT = (-90).degToRad();
MAX_LAT = (90).degToRad();
MIN_LON = (-180).degToRad();
MAX_LON = (180).degToRad();
// Earth's radius (km)
R = 6378.1;
// angular distance in radians on a great circle
radDist = distance / R;
// center point coordinates (deg)
degLat = centerPoint[0];
degLon = centerPoint[1];
// center point coordinates (rad)
radLat = degLat.degToRad();
radLon = degLon.degToRad();
// minimum and maximum latitudes for given distance
minLat = radLat - radDist;
maxLat = radLat + radDist;
// minimum and maximum longitudes for given distance
minLon = void 0;
maxLon = void 0;
// define deltaLon to help determine min and max longitudes
deltaLon = Math.asin(Math.sin(radDist) / Math.cos(radLat));
if (minLat > MIN_LAT && maxLat < MAX_LAT) {
minLon = radLon - deltaLon;
maxLon = radLon + deltaLon;
if (minLon < MIN_LON) {
minLon = minLon + 2 * Math.PI;
}
if (maxLon > MAX_LON) {
maxLon = maxLon - 2 * Math.PI;
}
}
// a pole is within the given distance
else {
minLat = Math.max(minLat, MIN_LAT);
maxLat = Math.min(maxLat, MAX_LAT);
minLon = MIN_LON;
maxLon = MAX_LON;
}
return [
minLon.radToDeg(),
minLat.radToDeg(),
maxLon.radToDeg(),
maxLat.radToDeg()
];
};
Você está procurando uma fórmula elipsóide.
O melhor lugar que eu encontrei para iniciar a codificação é baseado na Geo :: biblioteca Ellipsoid do CPAN. Dá-lhe uma linha de base para criar seus testes fora e comparar seus resultados com os seus resultados. Usei-o como base para uma biblioteca semelhante para PHP no meu empregador anterior.
Dê uma olhada no método location. Chamá-lo duas vezes e você tem a sua bbox.
Você não postar o idioma que você estava usando. Pode já ser um disponível geocodificação biblioteca para você.
Oh, e se você ainda não percebi isso por agora, o Google Maps usa o elipsóide WGS84.
Uma vez que eu precisava de uma estimativa muito grosseira, de modo a filtrar alguns documentos desnecessários em uma consulta ElasticSearch, eu empregou o abaixo fórmula:
Min.lat = Given.Lat - (0.009 x N)
Max.lat = Given.Lat + (0.009 x N)
Min.lon = Given.lon - (0.009 x N)
Max.lon = Given.lon + (0.009 x N)
= N kms necessário formar a localização dada. Para o seu caso N = 10
Não preciso, mas acessível.
Eu adaptei um script PHP que eu encontrei para fazer exatamente isso. Você pode usá-lo para encontrar os cantos de uma caixa em torno de um ponto (digamos, a 20 km fora). Meu exemplo específico é para o Google Maps API:
Aqui está uma implementação simples usando javascript que é baseado na conversão de grau latitude para kms onde 1 degree latitude ~ 111.2 km.
Eu estou calculando limites do mapa de uma determinada latitude e longitude com uma largura de 10 km.
function getBoundsFromLatLng(lat, lng){
var lat_change = 10/111.2;
var lon_change = Math.abs(Math.cos(lat*(Math.PI/180)));
var bounds = {
lat_min : lat - lat_change,
lon_min : lng - lon_change,
lat_max : lat + lat_change,
lon_max : lng + lon_change
};
return bounds;
}
Ilustração de @Jan Philip Matuschek excelente explicação (Por favor, up-votar a sua resposta, não isso, eu estou adicionando este como eu levei um pouco de tempo para entender a resposta original).
A técnica de caixa delimitadora de otimização de encontrar vizinhos mais próximos seria necessário para obter o mínimo e latitude máxima, pares de longitude, para um ponto P a uma distância d. Todos os pontos que estão fora estes são definitivamente a uma distância maior do que d do ponto. Uma coisa a notar aqui é o cálculo da latitude de intersecção como é realçado janeiro Philip Matuschek explicação. A latitude de intersecção não é na latitude do ponto P, mas ligeiramente deslocados dele. Esta é uma parte muitas vezes perdida, mas importante para determinar o máximo de longitude mínima delimitadora e correcta para o ponto P para os d.This distância também é útil na verificação.
A distância entre Haversine (latitude de intersecção, longitude alta) a (latitude, longitude) de P é igual à distância d.
Python essência aqui https://gist.github.com/alexcpn/f95ae83a7ee0293a5225
Eu estava trabalhando no problema caixa delimitadora como uma questão de lado para encontrar todos os pontos dentro SrcRad raio de um estática LAT, ponto LONG. Tem havido muito poucos cálculos que o uso
maxLon = $lon + rad2deg($rad/$R/cos(deg2rad($lat)));
minLon = $lon - rad2deg($rad/$R/cos(deg2rad($lat)));
para calcular os limites de longitude, mas eu achei isso para não dar todas as respostas que eram necessários. Porque o que você realmente quer fazer é
(SrcRad/RadEarth)/cos(deg2rad(lat))
Eu sei, eu sei a resposta deve ser o mesmo, mas eu achei que não era. Parecia que, por não ter certeza que eu estava fazendo a (RadEarth SRCrad /) Em primeiro lugar e, em seguida, dividindo por parte Cos eu estava deixando de fora alguns pontos de localização.
Depois de obter todos os seus pontos de caixa delimitadora, se você tem uma função que calcula o ponto a ponto Distância dada lat, long é fácil só obter os pontos que são de um determinado raio de distância do ponto fixo. Aqui está o que eu fiz. Eu sei que dei alguns passos extras, mas isso me ajudou
-- GLOBAL Constants
gc_pi CONSTANT REAL := 3.14159265359; -- Pi
-- Conversion Factor Constants
gc_rad_to_degs CONSTANT NUMBER := 180/gc_pi; -- Conversion for Radians to Degrees 180/pi
gc_deg_to_rads CONSTANT NUMBER := gc_pi/180; --Conversion of Degrees to Radians
lv_stat_lat -- The static latitude point that I am searching from
lv_stat_long -- The static longitude point that I am searching from
-- Angular radius ratio in radians
lv_ang_radius := lv_search_radius / lv_earth_radius;
lv_bb_maxlat := lv_stat_lat + (gc_rad_to_deg * lv_ang_radius);
lv_bb_minlat := lv_stat_lat - (gc_rad_to_deg * lv_ang_radius);
--Here's the tricky part, accounting for the Longitude getting smaller as we move up the latitiude scale
-- I seperated the parts of the equation to make it easier to debug and understand
-- I may not be a smart man but I know what the right answer is... :-)
lv_int_calc := gc_deg_to_rads * lv_stat_lat;
lv_int_calc := COS(lv_int_calc);
lv_int_calc := lv_ang_radius/lv_int_calc;
lv_int_calc := gc_rad_to_degs*lv_int_calc;
lv_bb_maxlong := lv_stat_long + lv_int_calc;
lv_bb_minlong := lv_stat_long - lv_int_calc;
-- Now select the values from your location datatable
SELECT * FROM (
SELECT cityaliasname, city, state, zipcode, latitude, longitude,
-- The actual distance in miles
spherecos_pnttopntdist(lv_stat_lat, lv_stat_long, latitude, longitude, 'M') as miles_dist
FROM Location_Table
WHERE latitude between lv_bb_minlat AND lv_bb_maxlat
AND longitude between lv_bb_minlong and lv_bb_maxlong)
WHERE miles_dist <= lv_limit_distance_miles
order by miles_dist
;
É muito simples, basta ir ao site Panoramio e mapa do mundo, em seguida, aberto das panoramio website.Then ir ao local especificado whichs latitude e longitude necessário.
Em seguida, você encontrou latitude e longitude na barra de endereços, por exemplo, neste endereço.
http: // www. panoramio.com/map#lt=32.739485&ln=70.491211&z=9&k=1&a=1&tab=1&pl=all
lt = 32.739485 => latitude ln = 70.491211 => longitude
este API Panoramio JavaScript Widget de criar uma caixa delimitadora em torno de um longo par / lat e, em seguida, retornar todas as fotos com nesses limites.
Outro tipo de widget Panoramio API JavaScript em que você também pode mudar a cor de fundo com exemplo e código é aqui .
Ele não mostra em compor mood.It show após a publicação.
<div dir="ltr" style="text-align: center;" trbidi="on">
<script src="https://ssl.panoramio.com/wapi/wapi.js?v=1&hl=en"></script>
<div id="wapiblock" style="float: right; margin: 10px 15px"></div>
<script type="text/javascript">
var myRequest = {
'tag': 'kahna',
'rect': {'sw': {'lat': -30, 'lng': 10.5}, 'ne': {'lat': 50.5, 'lng': 30}}
};
var myOptions = {
'width': 300,
'height': 200
};
var wapiblock = document.getElementById('wapiblock');
var photo_widget = new panoramio.PhotoWidget('wapiblock', myRequest, myOptions);
photo_widget.setPosition(0);
</script>
</div>
A resposta de Aqui eu ter convertido Federico A. Ramponi para PHP, se alguém estiver interessado:
<?php
# deg2rad and rad2deg are already within PHP
# Semi-axes of WGS-84 geoidal reference
$WGS84_a = 6378137.0; # Major semiaxis [m]
$WGS84_b = 6356752.3; # Minor semiaxis [m]
# Earth radius at a given latitude, according to the WGS-84 ellipsoid [m]
function WGS84EarthRadius($lat)
{
global $WGS84_a, $WGS84_b;
$an = $WGS84_a * $WGS84_a * cos($lat);
$bn = $WGS84_b * $WGS84_b * sin($lat);
$ad = $WGS84_a * cos($lat);
$bd = $WGS84_b * sin($lat);
return sqrt(($an*$an + $bn*$bn)/($ad*$ad + $bd*$bd));
}
# Bounding box surrounding the point at given coordinates,
# assuming local approximation of Earth surface as a sphere
# of radius given by WGS84
function boundingBox($latitudeInDegrees, $longitudeInDegrees, $halfSideInKm)
{
$lat = deg2rad($latitudeInDegrees);
$lon = deg2rad($longitudeInDegrees);
$halfSide = 1000 * $halfSideInKm;
# Radius of Earth at given latitude
$radius = WGS84EarthRadius($lat);
# Radius of the parallel at given latitude
$pradius = $radius*cos($lat);
$latMin = $lat - $halfSide / $radius;
$latMax = $lat + $halfSide / $radius;
$lonMin = $lon - $halfSide / $pradius;
$lonMax = $lon + $halfSide / $pradius;
return array(rad2deg($latMin), rad2deg($lonMin), rad2deg($latMax), rad2deg($lonMax));
}
?>
Graças @Fedrico A. para a implementação Phyton, tenho portado-lo em uma categoria de classe C Objetivo. Aqui está:
#import "LocationService+Bounds.h"
//Semi-axes of WGS-84 geoidal reference
const double WGS84_a = 6378137.0; //Major semiaxis [m]
const double WGS84_b = 6356752.3; //Minor semiaxis [m]
@implementation LocationService (Bounds)
struct BoundsLocation {
double maxLatitude;
double minLatitude;
double maxLongitude;
double minLongitude;
};
+ (struct BoundsLocation)locationBoundsWithLatitude:(double)aLatitude longitude:(double)aLongitude maxDistanceKm:(NSInteger)aMaxKmDistance {
return [self boundingBoxWithLatitude:aLatitude longitude:aLongitude halfDistanceKm:aMaxKmDistance/2];
}
#pragma mark - Algorithm
+ (struct BoundsLocation)boundingBoxWithLatitude:(double)aLatitude longitude:(double)aLongitude halfDistanceKm:(double)aDistanceKm {
double radianLatitude = [self degreesToRadians:aLatitude];
double radianLongitude = [self degreesToRadians:aLongitude];
double halfDistanceMeters = aDistanceKm*1000;
double earthRadius = [self earthRadiusAtLatitude:radianLatitude];
double parallelRadius = earthRadius*cosl(radianLatitude);
double radianMinLatitude = radianLatitude - halfDistanceMeters/earthRadius;
double radianMaxLatitude = radianLatitude + halfDistanceMeters/earthRadius;
double radianMinLongitude = radianLongitude - halfDistanceMeters/parallelRadius;
double radianMaxLongitude = radianLongitude + halfDistanceMeters/parallelRadius;
struct BoundsLocation bounds;
bounds.minLatitude = [self radiansToDegrees:radianMinLatitude];
bounds.maxLatitude = [self radiansToDegrees:radianMaxLatitude];
bounds.minLongitude = [self radiansToDegrees:radianMinLongitude];
bounds.maxLongitude = [self radiansToDegrees:radianMaxLongitude];
return bounds;
}
+ (double)earthRadiusAtLatitude:(double)aRadianLatitude {
double An = WGS84_a * WGS84_a * cosl(aRadianLatitude);
double Bn = WGS84_b * WGS84_b * sinl(aRadianLatitude);
double Ad = WGS84_a * cosl(aRadianLatitude);
double Bd = WGS84_b * sinl(aRadianLatitude);
return sqrtl( ((An * An) + (Bn * Bn))/((Ad * Ad) + (Bd * Bd)) );
}
+ (double)degreesToRadians:(double)aDegrees {
return M_PI*aDegrees/180.0;
}
+ (double)radiansToDegrees:(double)aRadians {
return 180.0*aRadians/M_PI;
}
@end
Eu testei e parece estar trabalhando agradável. Struct BoundsLocation deve ser substituído por uma classe, eu tê-lo usado apenas para partilhá-la aqui.
Toda a resposta acima são apenas parcialmente correta . Especialmente na região, como a Austrália, eles sempre incluem poste e calcular um grande retângulo mesmo para 10kms.
Especialmente o algoritmo por Jan Philip Matuschek em http://janmatuschek.de/LatitudeLongitudeBoundingCoordinates#UsingIndex inclui um muito grande retângulo de (-37, -90, -180, 180) para quase todos os pontos na Austrália. Isto atinge um grande usuários de banco de dados e distância têm que ser calculado para todos os usuários em quase a metade do país.
Eu achei que o Drupal API Algoritmo Terra pelo Rochester Institute of Technology funciona melhor em torno do pólo, bem como em outros lugares e é muito mais fácil de implementar.
Use earth_latitude_range e earth_longitude_range do algoritmo acima para calcular retângulo delimitador
E use o cálculo da distância fórmula documentado através do Google Maps a distância calcular
Para pesquisar por quilômetros em vez de milhas, substitua 3959 com 6371. Para (LAT, LNG) = (37, -122) e uma tabela de marcadores com colunas lat e GNL , a fórmula é:
SELECT id, ( 3959 * acos( cos( radians(37) ) * cos( radians( lat ) ) * cos( radians( lng ) - radians(-122) ) + sin( radians(37) ) * sin( radians( lat ) ) ) ) AS distance FROM markers HAVING distance < 25 ORDER BY distance LIMIT 0 , 20;
Leia a minha resposta detalhada em https://stackoverflow.com/a/45950426/5076414
Aqui está a resposta de Federico Ramponi em Go. Nota: nenhum erro de verificação: (
import (
"math"
)
// Semi-axes of WGS-84 geoidal reference
const (
// Major semiaxis (meters)
WGS84A = 6378137.0
// Minor semiaxis (meters)
WGS84B = 6356752.3
)
// BoundingBox represents the geo-polygon that encompasses the given point and radius
type BoundingBox struct {
LatMin float64
LatMax float64
LonMin float64
LonMax float64
}
// Convert a degree value to radians
func deg2Rad(deg float64) float64 {
return math.Pi * deg / 180.0
}
// Convert a radian value to degrees
func rad2Deg(rad float64) float64 {
return 180.0 * rad / math.Pi
}
// Get the Earth's radius in meters at a given latitude based on the WGS84 ellipsoid
func getWgs84EarthRadius(lat float64) float64 {
an := WGS84A * WGS84A * math.Cos(lat)
bn := WGS84B * WGS84B * math.Sin(lat)
ad := WGS84A * math.Cos(lat)
bd := WGS84B * math.Sin(lat)
return math.Sqrt((an*an + bn*bn) / (ad*ad + bd*bd))
}
// GetBoundingBox returns a BoundingBox encompassing the given lat/long point and radius
func GetBoundingBox(latDeg float64, longDeg float64, radiusKm float64) BoundingBox {
lat := deg2Rad(latDeg)
lon := deg2Rad(longDeg)
halfSide := 1000 * radiusKm
// Radius of Earth at given latitude
radius := getWgs84EarthRadius(lat)
pradius := radius * math.Cos(lat)
latMin := lat - halfSide/radius
latMax := lat + halfSide/radius
lonMin := lon - halfSide/pradius
lonMax := lon + halfSide/pradius
return BoundingBox{
LatMin: rad2Deg(latMin),
LatMax: rad2Deg(latMax),
LonMin: rad2Deg(lonMin),
LonMax: rad2Deg(lonMax),
}
}
