Comment calculer la boîte englobante pour un lat/lng emplacement?

Je suggère de rapprocher localement la surface de la Terre comme une sphère de rayon donné par l'ellipsoïde WGS84 à la même latitude. Je soupçonne que le calcul exact de latMin et latMax nécessiterait des fonctions elliptiques et ne céderait pas une augmentation sensible de la précision (WGS84 est elle-même une approximation).

Ma mise en œuvre suit (Il 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) à des degrés + fractions de degré, et vice-versa (pas 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))

Ici, j'ai converti Federico A. Ramponi la réponse de C# pour les personnes intéressées:

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

Vous êtes à la recherche d'un ellipsoïde de formule.

Le meilleur endroit que j'ai trouvé pour commencer le codage est basé sur la Géo::Ellipsoïde de la bibliothèque du CPAN. Il vous donne un point de départ pour créer vos tests et de comparer vos résultats avec ceux de ses résultats. Je l'ai utilisé comme base pour une bibliothèque semblable pour PHP à mon ancien employeur.

Geo::Ellipsoïde

Prendre un coup d'oeil à la location méthode. Appel deux fois et vous avez votre bbox.

Vous ne publiez pas ce que la langue que vous utilisez. Il y a peut-être déjà un géocodage bibliothèque disponible pour vous.

Oh, et si vous n'avez pas pensé à elle maintenant, Google maps utilise l'ellipsoïde WGS84.

J'ai adapté un script PHP que j'ai trouvé pour faire juste cela. Vous pouvez l'utiliser pour trouver les coins d'une zone autour d'un point (20 km). Mon exemple est pour l'API Google Maps:

http://www.richardpeacock.com/blog/2011/11/draw-box-around-coordinate-google-maps-based-miles-or-kilometers

Illustration de @Jan Philip Matuschek excellente explication.(Veuillez jusqu'-vote de sa réponse, de ce pas, je suis en ajoutant ce que j'ai pris un peu de temps dans la compréhension de l'original de la réplique)

La boîte englobante de la technique de l'optimisation de trouver des voisins les plus proches en aurait besoin pour tirer le minimum et le maximum de latitude,de longitude paires, pour un point P à la distance d . Tous les points qui tombent en dehors de ces sont certainement à une distance supérieure à d du point.
Une chose à noter ici est le calcul de la latitude d'intersection comme le souligne Jan Philip Matuschek explication. La latitude d'intersection n'est pas à la latitude du point P, mais légèrement décalé par rapport à elle. C'est souvent oubliée, mais une partie importante dans la détermination de la corriger minimum et maximum de délimitation de la longitude du point P pour la distance d.Ceci est également utile lors de la vérification.

La haversine distance entre (latitude d'intersection,la longitude haut) à (latitude,longitude) de P est égale à la distance d.

Python gist ici https://gist.github.com/alexcpn/f95ae83a7ee0293a5225

C'est très simple il suffit d'aller à panoramio site web et ensuite ouvrir la Carte du Monde de panoramio site web.Ensuite, allez à l'emplacement indiqué ce qui la latitude et la longitude nécessaire.

Alors vous avez trouvé la latitude et de longitude dans la barre d'adresse par exemple à 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 Panoramio API JavaScript widget de créer un cadre de sélection autour d'un lat/long de la paire et puis en la retournant toutes les photos dans ces limites.

Un autre type de Panoramio API JavaScript widget dans lequel vous pouvez aussi changer la couleur d'arrière-plan avec exemple et le code est ici.

Il ne s'affiche pas dans la composition de l'humeur.Ce spectacle après la publication.

<div dir="ltr" style="text-align: center;" trbidi="on">
<script src="https://ssl.panoramio.com/wapi/wapi.js?v=1&amp;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 @Fedrico A. pour le Phyton mise en œuvre, j'ai porté dans un Objectif de la catégorie C de la classe. Ici 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

Je l'ai testé et semble être de travail agréable.
Struct BoundsLocation devrait être remplacé par une classe, je l'ai utilisé juste pour le partager ici.

Voici Federico Ramponi réponse en Aller. Note: pas de vérification des erreurs 🙁

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