Berechnung des neuen Längen- und Breitengrads aus alten + n Metern

Ich möchte 2 neue Längengrade und 2 neue Breiten basierend auf einer Koordinate und einer Entfernung in Metern erstellen. Ich möchte einen schönen Begrenzungsrahmen um einen bestimmten Punkt erstellen. Es ist für einen Teil einer Stadt und maximal ± 1500 Meter. Ich denke daher nicht, dass die Krümmung der Erde berücksichtigt werden muss.

Ich habe also 50.0452345(x) und 4.3242234(y) und möchte x + 500 Meter, x - 500 Meter, y - 500 Meter, y + 500 Meter wissen

Ich habe viele Algorithmen gefunden, aber fast alle scheinen sich mit dem Abstand zwischen Punkten zu befassen.

Die Anzahl der Kilometer pro Längengrad beträgt ungefähr

(2*pi/360) * r_earth * cos(theta)

Wo thetaist der Breitengrad in Grad und r_earthist ungefähr 6378 km.

Die Anzahl der Kilometer pro Breitengrad ist an allen Standorten ungefähr gleich, ca.

(2*pi/360) * r_earth = 111 km / degree 

So können Sie tun:

new_latitude  = latitude  + (dy / r_earth) * (180 / pi);
new_longitude = longitude + (dx / r_earth) * (180 / pi) / cos(latitude * pi/180);

Solange dxund dyklein im Vergleich zum Radius der Erde sind und Sie nicht zu nahe an die Pole kommen.

Die akzeptierte Antwort ist vollkommen richtig und funktioniert. Ich habe einige Änderungen vorgenommen und mich in diese verwandelt:

double meters = 50;

// number of km per degree = ~111km (111.32 in google maps, but range varies
   between 110.567km at the equator and 111.699km at the poles)
// 1km in degree = 1 / 111.32km = 0.0089
// 1m in degree = 0.0089 / 1000 = 0.0000089
double coef = meters * 0.0000089;

double new_lat = my_lat + coef;

// pi / 180 = 0.018
double new_long = my_long + coef / Math.cos(my_lat * 0.018);

Hoffe das hilft auch.

Für den Breitengrad tun Sie:

var earth = 6378.137,  //radius of the earth in kilometer
    pi = Math.PI,
    m = (1 / ((2 * pi / 360) * earth)) / 1000;  //1 meter in degree

var new_latitude = latitude + (your_meters * m);

Für die Länge tun:

var earth = 6378.137,  //radius of the earth in kilometer
    pi = Math.PI,
    cos = Math.cos,
    m = (1 / ((2 * pi / 360) * earth)) / 1000;  //1 meter in degree

var new_longitude = longitude + (your_meters * m) / cos(latitude * (pi / 180));

Die Variable your_meterskann einen positiven oder einen negativen Wert enthalten.

Haben Sie ausgecheckt: Wie finde ich den Lat / Long, der x km nördlich eines bestimmten Lat / Long liegt ?

Diese Berechnungen sind bestenfalls ärgerlich, ich habe viele davon gemacht. Die Haversine-Formel wird dein Freund sein.

Einige Referenzen: http://www.movable-type.co.uk/scripts/latlong.html

Ich musste ungefähr zwei Stunden aufwenden, um die Lösung von @nibot zu erarbeiten. Ich brauchte lediglich eine Methode, um eine Begrenzungsbox zu erstellen, deren Mittelpunkt und Breite / Höhe (oder Radius) in Kilometern angegeben sind:

Ich verstehe die Lösung mathematisch / geografisch nicht. Ich habe die Lösung (durch Versuch und Irrtum) optimiert, um die vier Koordinaten zu erhalten:

Norden:

private static Position FromKmToNPosition(Position p, double km)
{
    double r_earth = 6378;
    var pi = Math.PI;
    var new_latitude = p.Lat + (km / r_earth) * (180 / pi);
    return new Position(new_latitude, p.Long);
}

Osten:

private static Position FromKmToEPosition(Position p, double km)
{
    double r_earth = 6378;
    var pi = Math.PI;
    var new_longitude = p.Long + (km / r_earth) * (180 / pi) / Math.Cos(p.Lat * pi / 180);
    return new Position(p.Lat, new_longitude);
}

Süden:

private static Position FromKmToSPosition(Position p, double km)
{
    double r_earth = 6378;
    var pi = Math.PI;
    var new_latitude = p.Lat - (km / r_earth) * (180 / pi);
    return new Position(new_latitude, p.Long);
}

Westen:

private static Position FromKmToWPosition(Position p, double km)
{
    double r_earth = 6378;
    var pi = Math.PI;
    var new_longitude = p.Long - (km / r_earth) * (180 / pi) / Math.Cos(p.Lat * pi / 180);
    return new Position(p.Lat, new_longitude);
}

Wenn Sie nicht sehr genau sein müssen, dann: Jeder 10000 Meter entspricht ungefähr 0,1 für Breite und Länge. Zum Beispiel möchte ich Standorte 3000 Meter um point_A aus meiner Datenbank laden:

double newMeter =  3000 * 0.1 / 10000;
double lat1 = point_A.latitude - newMeter;
double lat2 = point_A.latitude + newMeter;
double lon1 = point_A.longitude - newMeter;
double lon1 = point_A.longitude + newMeter;
Cursor c = mDb.rawQuery("select * from TABLE1  where lat >= " + lat1 + " and lat <= " + lat2 + " and lon >= " + lon1 + " and lon <= " + lon2 + " order by id", null);

public double MeterToDegree(double meters, double latitude)
{
    return meters / (111.32 * 1000 * Math.Cos(latitude * (Math.PI / 180)));
}

var meters = 50;
var coef = meters * 0.0000089;
var new_lat = map.getCenter().lat.apply() + coef;
var new_long = map.getCenter().lng.apply() + coef / Math.cos(new_lat * 0.018);
map.setCenter({lat:new_lat, lng:new_long});