it-swarm.com.de

Wie berechnet man den Begrenzungsrahmen für eine bestimmte Lat/Lng-Position?

Ich habe einen durch Längen- und Breitengrad definierten Ort angegeben .. Nun möchte ich einen Begrenzungsrahmen innerhalb von z. 10 Kilometer von diesem Punkt.

Der Begrenzungsrahmen sollte als latmin, lngmin und latmax, lngmax definiert werden.

Ich brauche dieses Zeug, um die panoramio API zu verwenden.

Kennt jemand die Formel, wie man diese Punkte bekommt?

Edit: Jungs Ich suche nach einer Formel/Funktion, die lat & lng als Eingabe akzeptiert und eine Begrenzungsbox als latmin & lngmin und latmax & latmin zurückgibt Pseudocode sollte in Ordnung sein.

Edit: Ich suche keine Lösung, die mir die Entfernung von 2 Punkten anzeigt

95
Michal

Ich empfehle, die Erdoberfläche lokal als eine Kugel mit einem durch den WGS84-Ellipsoid bei gegebenem Breitengrad gegebenen Radius anzunähern. Ich vermute, dass die exakte Berechnung von latMin und latMax elliptische Funktionen erfordern würde und zu keiner nennenswerten Genauigkeitssteigerung führen würde (WGS84 ist selbst eine Annäherung).

Meine Implementierung folgt (Es ist in Python geschrieben; ich habe es nicht getestet):

# 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))

BEARBEITEN: Der folgende Code konvertiert (Grad, Primzahlen, Sekunden) in Grad + Bruchteile eines Grades und umgekehrt (nicht getestet):

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))
57

Ich habe einen Artikel über das Finden der Begrenzungskoordinaten geschrieben:

http://JanMatuschek.de/LatitudeLongitudeBoundingCoordinates

In diesem Artikel werden die Formeln erläutert und eine Java-Implementierung bereitgestellt. (Es zeigt auch, warum Federicos Formel für die Min/Max-Länge ungenau ist.)

52

Hier habe ich Federico A. Ramponis Antwort auf C # für alle Interessierten konvertiert:

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

Ich habe eine JavaScript-Funktion geschrieben, die die vier Koordinaten eines quadratischen Begrenzungsrahmens mit einem Abstand und einem Koordinatenpaar zurückgibt:

'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()
  ];
};
10
asalisbury

Sie suchen nach einer Ellipsoidformel. 

Der beste Ort, den ich zum Starten der Codierung gefunden habe, basiert auf der Geo :: Ellipsoid-Bibliothek von CPAN. Es gibt Ihnen eine Basis, um Ihre Tests zu erstellen und Ihre Ergebnisse mit ihren Ergebnissen zu vergleichen. Ich habe es als Grundlage für eine ähnliche Bibliothek für PHP bei meinem früheren Arbeitgeber verwendet.

Geo :: Ellipsoid

Schauen Sie sich die location-Methode an. Rufen Sie es zweimal an und Sie haben Ihre Bbox.

Sie haben nicht geschrieben, welche Sprache Sie verwendet haben. Möglicherweise ist bereits eine Geokodierungsbibliothek verfügbar.

Oh, und wenn Sie es noch nicht herausgefunden haben, verwendet Google Maps das WGS84-Ellipsoid.

6
jcoby

Da ich eine sehr grobe Schätzung brauchte, um einige unnötige Dokumente in einer Elasticsearch-Abfrage herauszufiltern, habe ich die folgende Formel verwendet: 

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, die vom angegebenen Standort aus erforderlich sind. Für Ihren Fall N = 10

Nicht genau, aber praktisch. 

5
Ajay

Ich habe ein PHP -Skript angepasst, bei dem ich genau das getan habe. Sie können es verwenden, um die Ecken einer Box um einen Punkt herum zu finden (etwa 20 km außerhalb). Mein spezielles Beispiel ist für die Google Maps-API:

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

4
Richard

Hier ist eine einfache Implementierung mit Javascript, die auf der Konvertierung von Breitengrad in km basiert, wobei 1 degree latitude ~ 111.2 km.

Ich berechne die Grenzen der Karte aus einer gegebenen Breite und Länge mit einer Breite von 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;
}
3
Noushad PP

Illustration von @Jan Philip Matuschek - ausgezeichnete Erklärung. (Bitte stimmen Sie seine Antwort ab, nicht diese; ich füge das hinzu, da ich mir ein wenig Zeit genommen habe, um die ursprüngliche Antwort zu verstehen.)

Die Begrenzungskastentechnik zum Optimieren des Findens nächster Nachbarn würde die Paare der minimalen und maximalen Breitengrade und Längengrade für einen Punkt P im Abstand d ableiten müssen. Alle Punkte, die außerhalb dieser Punkte liegen, befinden sich definitiv in einem Abstand von mehr als d vom Punkt ..__ Eine Sache, die hier zu beachten ist, ist die Berechnung der Schnittbreite, wie in der Erklärung von Jan Philip Matuschek hervorgehoben. Die Schnittbreite liegt nicht in der Breite des Punktes P, sondern ist geringfügig davon versetzt. Dies ist ein häufig verfehlter, aber wichtiger Teil bei der Bestimmung des korrekten minimalen und maximalen Begrenzungslängenwerts für Punkt P für die Entfernung d. Dies ist auch nützlich bei der Verifizierung. 

Der Hersersiniendistanz zwischen (Breitengrad, Längengrad hoch) und (Breitengrad, Längengrad) von P ist gleich dem Abstand d.

Python Gist hier https://Gist.github.com/alexcpn/f95ae83a7ee0293a5225

 enter image description here

2
Alex Punnen

Ich arbeitete an dem Problem des Begrenzungsrahmens als Nebenproblem, um alle Punkte im SrcRad-Radius eines statischen LAT, LONG-Punktes zu finden. Es gibt einige Berechnungen, die verwendet werden

maxLon = $lon + rad2deg($rad/$R/cos(deg2rad($lat)));
minLon = $lon - rad2deg($rad/$R/cos(deg2rad($lat)));

um die Längengrenzen zu berechnen, aber ich fand das nicht alle Antworten, die benötigt wurden. Denn was Sie wirklich tun wollen, ist 

(SrcRad/RadEarth)/cos(deg2rad(lat))

Ich weiß, ich weiß, dass die Antwort gleich sein sollte, aber ich habe festgestellt, dass es nicht so war. Es stellte sich heraus, dass ich nicht sicher war, ob ich die (SRCrad/RadEarth) -Tätigkeit durchführte und dann durch den Cos-Teil aufteilte. Ich ließ einige Standortpunkte aus. 

Wenn Sie alle Punkte für den Begrenzungsrahmen erhalten haben, können Sie bei einer Funktion, die den Abstand von Punkt zu Punkt berechnet, lang, lang. Es ist einfach, nur die Punkte zu erhalten, die einen bestimmten Entfernungsradius vom festen Punkt haben. Hier ist, was ich getan habe ... Ich weiß, dass es ein paar zusätzliche Schritte erforderlich machte, aber es hat mir geholfen

-- 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
;
1
Greg Beck

Hier habe ich die Antwort von Federico A. Ramponi in PHP umgewandelt, wenn jemand interessiert ist:

<?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));
}
?>
0
Joe Black

Alle obigen Antworten sind nur teilweise korrekt. Speziell in einer Region wie Australien enthalten sie immer Pole und berechnen sogar für 10 km ein sehr großes Rechteck. 

Insbesondere der Algorithmus von Jan Philip Matuschek unter http://janmatuschek.de/LatitudeLongitudeBoundingCoordinates #UsingIndex enthielt für fast jeden Punkt in Australien ein sehr großes Rechteck aus (-37, -90, -180, 180). Dies bedeutet, dass eine große Anzahl von Benutzern in Datenbanken und Entfernungen für alle Benutzer in fast der Hälfte des Landes berechnet werden muss.

Ich fand heraus, dass der Drupal API-Algorithmus des Rochester Institute of Technology sowohl um die Pole als auch anderswo besser funktioniert und viel einfacher zu implementieren ist.

https://www.rit.edu/drupal/api/drupal/sites%21all%21modules%21location%21earth.inc/7.54

Verwenden Sie earth_latitude_range und earth_longitude_range aus dem obigen Algorithmus zur Berechnung des Begrenzungsrechtecks 

Verwenden Sie die von Google Maps [] dokumentierte Entfernungsberechnungsformel, um die Entfernung zu berechnen

https://developers.google.com/maps/solutions/store-locator/clothing-store-locator#outputting-data-as-xml-using-php

Um nach Kilometern anstelle von Meilen zu suchen, ersetzen Sie 3959 durch 6371 .Für (Lat, Lng) = (37, -122) und eine Markierungstabelle mit Spalten lat und lng lautet die Formel:

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;

Lesen Sie meine ausführliche Antwort unter https://stackoverflow.com/a/45950426/5076414

0
Sacky San

Es ist sehr einfach, einfach auf die panoramio-Website zu gehen und dann die Weltkarte von der panoramio-Website zu öffnen. Dann gehen Sie zu dem angegebenen Ort, der geografische Breite und Länge benötigt.

Dann haben Sie Breiten- und Längengrad in der Adressleiste zum Beispiel in dieser Adresse gefunden.

http://www.panoramio.com/map#lt=32.739485&ln=70.491211&z=9&k=1&a=1&tab=1&pl=all

lt = 32,739485 => Breite ln = 70,491211 => Länge

mit diesem Panoramio-JavaScript-API-Widget wird ein Begrenzungsrahmen um ein Lat/Long-Paar erstellt und anschließend alle Fotos in diesen Grenzen zurückgegeben.

Eine andere Art von Panoramio-JavaScript-API-Widget, in dem Sie auch die Hintergrundfarbe mit Beispiel und Code ändern können, ist hier .

Es wird nicht in kompositorischer Stimmung gezeigt. Es wird nach der Veröffentlichung angezeigt.

<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>
0
kahna9

Vielen Dank @Fedrico A. für die Phyton-Implementierung, ich habe sie in eine Objective-C-Kategorie-Klasse portiert. Hier ist:

#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

Ich habe es ausprobiert und scheint gut zu funktionieren . Struct BoundsLocation sollte durch eine Klasse ersetzt werden, ich habe es nur benutzt, um es hier zu teilen.

0
Jesuslg123

Hier ist Federico Ramponis Antwort in Go. Hinweis: keine Fehlerprüfung :(

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