Comment calculer le cadre de sélection pour un emplacement donné en latitude/longitude?
J'ai donné un emplacement défini par la latitude et la longitude . Maintenant, je veux calculer un cadre de délimitation dans, par exemple. 10 kilomètres de ce point.
La boîte englobante doit être définie comme latmin, lngmin et latmax, lngmax.
J'ai besoin de ce matériel pour utiliser le panoramio API .
Est-ce que quelqu'un connaît la formule pour obtenir ces points?
Edit: Les gars, je cherche une formule/fonction qui prend lat & lng en entrée et renvoie un cadre de sélection comme latmin & lngmin et latmax & latmin . le pseudocode devrait bien se passer.
Edit: Je ne cherche pas une solution qui me montre la distance de 2 points
Je suggère d'approcher localement la surface de la Terre sous forme d'une sphère de rayon donné par l'ellipsoïde WGS84 à la latitude donnée. Je pense que le calcul exact de latMin et latMax nécessiterait des fonctions elliptiques et ne donnerait pas une augmentation appréciable de la précision (WGS84 est en soi une approximation).
Mon implémentation est la suivante (c'est écrit en Python; je ne l'ai pas testé):
# 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: Le code suivant convertit (degrés, nombres premiers, secondes) en degrés + fractions de degré et vice versa (non testé):
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))
J'ai écrit un article sur la recherche des coordonnées de délimitation:
http://JanMatuschek.de/LatitudeLongitudeBoundingCoordinates
L'article explique les formules et fournit également une implémentation Java. (Cela montre également pourquoi la formule de Federico pour la longitude min/max est inexacte.)
Ici, j'ai converti la réponse de Federico A. Ramponi en C # pour tous les intéressés:
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));
}
J'ai écrit une fonction JavaScript qui renvoie les quatre coordonnées d'une boîte carrée, à partir d'une distance et d'une paire de coordonnées:
'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()
];
};
Vous recherchez une formule ellipsoïde.
Le meilleur endroit que j'ai trouvé pour commencer à coder est basé sur la bibliothèque Geo :: Ellipsoid de CPAN. Il vous donne une base pour créer vos tests et comparer vos résultats avec ceux obtenus. Je l'ai utilisé comme base d'une bibliothèque similaire pour PHP chez mon précédent employeur.
Examinez la méthode location. Appelez-le deux fois et vous avez votre bbox.
Vous n'avez pas posté la langue que vous utilisiez. Une bibliothèque de géocodage est peut-être déjà disponible pour vous.
Oh, et si vous ne le savez pas encore, Google Maps utilise l'ellipsoïde WGS84.
Comme j'avais besoin d'une estimation très approximative, donc pour filtrer certains documents inutiles dans une requête elasticsearch, j'ai utilisé la formule ci-dessous:
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 = km requis à l'emplacement donné. Pour ton cas N = 10
Pas précis mais pratique.
J'ai adapté un script PHP que j'ai découvert dans ce but. Vous pouvez l’utiliser pour trouver les coins d’une boîte autour d’un point (disons à 20 km de distance). Mon exemple spécifique concerne l'API Google Maps:
Voici une implémentation simple utilisant JavaScript qui est basée sur la conversion du degré de latitude en kms où 1 degree latitude ~ 111.2 km.
Je calcule les limites de la carte à partir d'une latitude et d'une longitude données d'une largeur 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;
}
Illustration de l'excellente explication de @Jan Philip Matusche (votez pour sa réponse, pas celle-ci; j'ajoute ceci car j'ai pris un peu de temps pour comprendre la réponse initiale)
La technique de la boîte englobante consistant à optimiser la recherche des voisins les plus proches nécessiterait de déduire les paires de latitude et longitude minimum et maximum pour un point P à la distance d. Tous les points qui se trouvent en dehors de ceux-ci se trouvent certainement à une distance supérieure à d du point ..__ Une chose à noter ici est le calcul de la latitude de l'intersection, comme l'explique l'explication de Jan Philip Matuschek. La latitude d'intersection n'est pas à la latitude du point P mais légèrement décalée par rapport à celui-ci. Ceci est un élément souvent oublié mais important dans la détermination de la longitude de délimitation minimale et maximale correcte pour le point P pour la distance d. Ceci est également utile pour la vérification.
La distance en haversine entre (latitude d'intersection, longitude haute) et (latitude, longitude) de P est égale à la distance d.
Python Gist ici https://Gist.github.com/alexcpn/f95ae83a7ee0293a5225
Je travaillais sur le problème de la boîte englobante en tant que problème secondaire pour trouver tous les points dans le rayon SrcRad d'un point LAT, LONG statique. Il y a eu pas mal de calculs qui utilisent
maxLon = $lon + rad2deg($rad/$R/cos(deg2rad($lat)));
minLon = $lon - rad2deg($rad/$R/cos(deg2rad($lat)));
pour calculer les limites de la longitude, mais j’ai trouvé que cela ne donnait pas toutes les réponses nécessaires. Parce que ce que vous voulez vraiment faire, c'est
(SrcRad/RadEarth)/cos(deg2rad(lat))
Je sais, je sais que la réponse devrait être la même, mais j'ai constaté que ce n'était pas le cas. Il est apparu qu'en ne m'assurant pas que je faisais d'abord (SRCrad/RadEarth) puis en divisant par la partie Cos, je laissais de côté certains points de localisation.
Une fois que vous avez obtenu tous vos points de contour, si vous avez une fonction qui calcule la distance point à point donnée, il est facile d’obtenir longtemps les points qui se situent à un certain rayon du point fixe. Voici ce que j’ai fait ... Je sais que cela a pris quelques étapes supplémentaires mais cela m’a aidé
-- 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
;
Ici, j'ai converti la réponse de Federico A. Ramponi en PHP si cela vous intéresse:
<?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));
}
?>
Toutes les réponses ci-dessus ne sont que partiellement correctes. Particulièrement dans des régions comme l’Australie, ils incluent toujours un pôle et calculent un très grand rectangle, même pour 10 km.
En particulier, l'algorithme de Jan Philip Matuschek sur http://janmatuschek.de/LatitudeLongitudeBoundingCoordinates#UsingIndex incluait un très grand rectangle de (-37, -90, -180, 180) pour presque chaque point en Australie. La base de données est touchée par un grand nombre d'utilisateurs et la distance doit être calculée pour tous les utilisateurs dans presque la moitié du pays.
J'ai trouvé que l'algorithme Drupal API Earth du Rochester Institute of Technology fonctionnait mieux autour du pôle qu'ailleurs et était beaucoup plus facile à mettre en œuvre.
https://www.rit.edu/drupal/api/drupal/sites%21all%21modules%21location%21earth.inc/7.54
Utilisez earth_latitude_range et earth_longitude_range à partir de l'algorithme ci-dessus pour calculer le rectangle englobant
Et utilisez la formule de calcul distance documentée par google maps pour calculer la distance
Pour effectuer une recherche par kilomètres au lieu de miles, remplacez 3959 par 6371 .Pour (Lat, Lng) = (37, -122) et un tableau Markers avec les colonnes lat et lng, la formule est la suivante:
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;
Lisez ma réponse détaillée sur https://stackoverflow.com/a/45950426/5076414
C’est très simple, il suffit d’aller sur le site Web Panoramio, puis d’ouvrir la carte du monde à partir du site Web Panoramio. Accédez ensuite à l’emplacement spécifié, à la latitude et à la longitude requises.
Ensuite, vous avez trouvé la latitude et la longitude dans la barre d'adresse, par exemple dans cette adresse.
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
ce widget Panoramio JavaScript API crée un cadre de sélection autour d'une paire de lat/long, puis renvoie toutes les photos dans ces limites.
Un autre type de widget API Panoramio JavaScript dans lequel vous pouvez également changer la couleur de fond avec exemple et code est ici .
Il ne montre pas dans l'ambiance de composition.Il montre après la publication.
<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>
Merci @ Federico A. pour la mise en oeuvre de Phyton, je l’ai transférée dans une classe de catégorie Objective C. Voici:
#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
Je l’ai testé et semble fonctionner Nice… .. Struct BoundsLocation devrait être remplacé par une classe, je l’ai utilisée pour le partager ici.
Voici la réponse de Federico Ramponi dans Go. Remarque: pas de vérification d'erreur :(
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),
}
}