Obtenir lat/long, compte tenu des point, la distance et le relèvement

Donné un point existant en lat/long, la distance (en KM) et le palier (en degrés converti en radians), je voudrais calculer la nouvelle lat/long. Cette site les cultures en place, encore et encore, mais j'ai juste ne peut pas obtenir la formule de travailler pour moi.

Les formules que de prendre le lien ci-dessus sont:

lat2 = asin(sin(lat1)*cos(d/R) + cos(lat1)*sin(d/R)*cos(θ))

lon2 = lon1 + atan2(sin(θ)*sin(d/R)*cos(lat1), cos(d/R)−sin(lat1)*sin(lat2))

La formule ci-dessus est pour MSExcel où-

asin          = arc sin()   
d             = distance (in any unit)   
R             = Radius of the earth (in the same unit as above)  
and hence d/r = is the angular distance (in radians)  
atan2(a,b)    = arc tan(b/a)  
θ is the bearing (in radians, clockwise from north);

Voici le code que j'ai obtenu en Python.

import math

R = 6378.1 #Radius of the Earth
brng = 1.57 #Bearing is 90 degrees converted to radians.
d = 15 #Distance in km

#lat2  52.20444 - the lat result I'm hoping for
#lon2  0.36056 - the long result I'm hoping for.

lat1 = 52.20472 * (math.pi * 180) #Current lat point converted to radians
lon1 = 0.14056 * (math.pi * 180) #Current long point converted to radians

lat2 = math.asin( math.sin(lat1)*math.cos(d/R) +
             math.cos(lat1)*math.sin(d/R)*math.cos(brng))

lon2 = lon1 + math.atan2(math.sin(brng)*math.sin(d/R)*math.cos(lat1),
                     math.cos(d/R)-math.sin(lat1)*math.sin(lat2))

print(lat2)
print(lon2)

- Je obtenir

lat2 = 0.472492248844 
lon2 = 79.4821662373

Quel est le problème?
Je recevais une réponse qui n'a aucun sens. La raison pour laquelle il n'a pas de sens parce que je n'étais pas la conversion de l'réponses degrés. Le Code a changé et inclus dans le post original comme une modification.
Il vous suffit de soumettre votre modifier, à titre de réponse, et d'accepter cette réponse, pour le rendre plus clair le fait que vous avez résolu votre problème. Sinon, il en sera de vous pénaliser pour laisser une question en suspens, le rendant légèrement plus susceptibles que les futurs utilisateurs ne sera pas la peine de répondre à vos questions.
Vous obtiendrez une meilleure précision et des résultats si vous utilisez numpy objets.
merci pour les conseils.

InformationsquelleAutor David M | 2011-08-28

Nécessaire pour convertir les réponses de radians retour à degrés. Code du travail ci-dessous:

import math

R = 6378.1 #Radius of the Earth
brng = 1.57 #Bearing is 90 degrees converted to radians.
d = 15 #Distance in km

#lat2  52.20444 - the lat result I'm hoping for
#lon2  0.36056 - the long result I'm hoping for.

lat1 = math.radians(52.20472) #Current lat point converted to radians
lon1 = math.radians(0.14056) #Current long point converted to radians

lat2 = math.asin( math.sin(lat1)*math.cos(d/R) +
     math.cos(lat1)*math.sin(d/R)*math.cos(brng))

lon2 = lon1 + math.atan2(math.sin(brng)*math.sin(d/R)*math.cos(lat1),
             math.cos(d/R)-math.sin(lat1)*math.sin(lat2))

lat2 = math.degrees(lat2)
lon2 = math.degrees(lon2)

print(lat2)
print(lon2)

J'ai essayer ceci mais seulement obtenir le même point de départ de retour?
même résultat pour moi aussi
Merci à vous, mis en œuvre que l'extrait de code dans Kotlin.

InformationsquelleAutor David M

La geopy bibliothèque prend en charge ce:

import geopy
from geopy.distance import VincentyDistance

# given: lat1, lon1, b = bearing in degrees, d = distance in kilometers

origin = geopy.Point(lat1, lon1)
destination = VincentyDistance(kilometers=d).destination(origin, b)

lat2, lon2 = destination.latitude, destination.longitude

Trouvé via https://stackoverflow.com/a/4531227/37610

cette bibliothèque a une certaine distance de questions en attente de réponse: github.com/geopy/geopy/pull/144

InformationsquelleAutor elliot42

Peut-être un peu tard pour répondre, mais après des tests d'autres réponses, il semble qu'ils ne fonctionnent pas correctement. Voici un code PHP que nous utilisons pour notre système. De travail dans toutes les directions.

Code PHP:

lat1 = latitude du point de départ en degrés

long1 = longitude du point de départ en degrés

d = distance en KM

angle = azimut en degrés

function get_gps_distance($lat1,$long1,$d,$angle)
{
    # Earth Radious in KM
    $R = 6378.14;

    # Degree to Radian
    $latitude1 = $lat1 * (M_PI/180);
    $longitude1 = $long1 * (M_PI/180);
    $brng = $angle * (M_PI/180);

    $latitude2 = asin(sin($latitude1)*cos($d/$R) + cos($latitude1)*sin($d/$R)*cos($brng));
    $longitude2 = $longitude1 + atan2(sin($brng)*sin($d/$R)*cos($latitude1),cos($d/$R)-sin($latitude1)*sin($latitude2));

    # back to degrees
    $latitude2 = $latitude2 * (180/M_PI);
    $longitude2 = $longitude2 * (180/M_PI);

    # 6 decimal for Leaflet and other system compatibility
   $lat2 = round ($latitude2,6);
   $long2 = round ($longitude2,6);

   // Push in array and get back
   $tab[0] = $lat2;
   $tab[1] = $long2;
   return $tab;
 }

Regardez bien, mais je pense que le demandeur aimerais avoir quelque chose en python. De mal?
encore valable et utile, merci.
peut-être mieux nommé get_gps_coord ou similaire. Vous n'obtenez pas la distance, vous offre que de la touche func. Mais merci pour cela, c'est exactement ce que je cherchais. De nombreuses recherches de retour calcul de la distance entre coords (faux positifs). Merci!
C'est génial et solution de travail..merci !!
Génial! Merci pour votre contribution!

InformationsquelleAutor Peter

9

Cette question est connue comme la problème direct dans l'étude de géodésie.

C'est en effet un question populaire et qui est une constante source de confusion. La raison en est que la plupart des gens sont à la recherche pour une simple et directe de réponse. Mais il n'en est aucun, parce que la plupart des gens posent cette question sont fournit pas suffisamment d'informations, simplement parce qu'ils ne sont pas conscients qu':
1. La terre n'est pas une sphère parfaite, car il est aplati/comprimé par pôles
2. En raison de (1) la terre n'a pas un Rayon constant, R. Voir ici.
3. La terre n'est pas parfaitement lisse (variations d'altitude), etc.
4. En raison de la tectonique des plaque de mouvement, un point géographique de lat/lon position peut changer par plusieurs millimètres (au moins), chaque année.
Par conséquent, il ya beaucoup de différentes hypothèses utilisées dans les différents modèles géométriques qui s'appliquent différemment, en fonction de votre besoin de précision. Donc, pour répondre à la question que vous devez tenir compte de ce que précision vous aimeriez avoir votre résultat.

Quelques exemples:
- Je suis à la recherche d'un emplacement approximatif de la plus proche à quelques kilomètres de petite taille ( < 100 km) les distances de latitudes entre 0-70 deg N|S. (La terre est ~appartement de type.)
- Je veux une réponse qui est bon n'importe où sur le globe, mais seulement précis à propos de quelques mètres
- Je veux un super précision de positionnement qui est valable en bas à atomique échelles de nanometers [nm].
- Je veux des réponses qui est très rapide et facile à calculer et pas de calcul intensif.
De sorte que vous pouvez avoir beaucoup de choix de l'algorithme à utiliser. En outre, chaque langage de programmation a sa propre implémentation ou "package", multiplié par le nombre de modèles et le modèle de développeurs besoins spécifiques. À toutes fins pratiques, ici, elle est payante à ignorer toute autre langue en dehors javascript, car il ressemblent de très près à un pseudo-code, de par sa nature. Ainsi, il peut être facilement converti en une autre langue, avec un minimum de modifications.

Puis les modèles principaux sont:
- Euclidian/Flat earth model: bon pour de très courtes distances, en vertu de ~10 km
- Spherical model: bon pour les grandes distances longitudinales, mais avec une petite différence de latitude. Modèle populaire:
  - Haversine: compteur précision sur [km] les échelles, code très simple.
- Ellipsoidal models: Plus précise à tout lat/lon et de la distance, mais c'est toujours une approximation numérique qui dépendent de la précision dont vous avez besoin. Certains modèles populaires sont:
  - Lambert: ~10 mètres précision de plus de 1000 km.
  - Paul D. Thomas: Andoyer-Lambert rapprochement
  - Vincenty: millimètre la précision et l'efficacité de calcul
  - Kerney: nanomètre précision
Références:
InformationsquelleAutor not2qubit
3

lon1 et lat1 en degrés

brng = roulement en radians

d = distance en km

R = rayon de la Terre en km
```
lat2 = math.degrees((d/R) * math.cos(brng)) + lat1
long2 = math.degrees((d/(R*math.sin(math.radians(lat2)))) * math.sin(brng)) + long1
```
J'ai implémenté un algorithme et la mienne en PHP et comparées elle. Cette version a couru dans environ 50% du temps. Les résultats obtenus ont été identiques, de sorte qu'il semble être mathématiquement équivalentes.

Je n'ai pas testé le code python ci-dessus, donc il peut y avoir des erreurs de syntaxe.
- Pas de travail. Du Nord au Sud, le résultat est correct mais c'est faux dans "Ouest-Est" de la direction.
InformationsquelleAutor Chris
3

Façon rapide à l'aide de geopy
```
from geopy import distance
#distance.distance(unit=15).destination((lat,lon),bering) 
#Exemples
distance.distance(nautical=15).destination((-24,-42),90) 
distance.distance(miles=15).destination((-24,-42),90)
distance.distance(kilometers=15).destination((-24,-42),90) 
```
- Sans en indiquer la méthode que vous utilisez pour le calcul, la réponse est pratiquement inutile.
- Si @plinio-bueno-andrade silva a été conscient ou non, geopy.distance.distance currently uses geodesic. geopy Et pour être plus précis, le modèle ellipsoïdal utilisé par défaut est le WGS-84 ellipsoïde, "qui est le plus précis à l'échelle mondiale."
InformationsquelleAutor Plinio Bueno Andrade Silva

J'ai porté à répondre par Brad vanilla JS répondre, avec n Bing maps dépendance

https://jsfiddle.net/kodisha/8a3hcjtd/

// ----------------------------------------
// Calculate new Lat/Lng from original points
// on a distance and bearing (angle)
// ----------------------------------------
let llFromDistance = function(latitude, longitude, distance, bearing) {
// taken from: https://stackoverflow.com/a/46410871/13549 
// distance in KM, bearing in degrees
const R = 6378.1; // Radius of the Earth
const brng = bearing * Math.PI / 180; // Convert bearing to radian
let lat = latitude * Math.PI / 180; // Current coords to radians
let lon = longitude * Math.PI / 180;
// Do the math magic
lat = Math.asin(Math.sin(lat) * Math.cos(distance / R) + Math.cos(lat) * Math.sin(distance / R) * Math.cos(brng));
lon += Math.atan2(Math.sin(brng) * Math.sin(distance / R) * Math.cos(lat), Math.cos(distance / R) - Math.sin(lat) * Math.sin(lat));
// Coords back to degrees and return
return [(lat * 180 / Math.PI), (lon * 180 / Math.PI)];
}
let pointsOnMapCircle = function(latitude, longitude, distance, numPoints) {
const points = [];
for (let i = 0; i <= numPoints - 1; i++) {
const bearing = Math.round((360 / numPoints) * i);
console.log(bearing, i);
const newPoints = llFromDistance(latitude, longitude, distance, bearing);
points.push(newPoints);
}
return points;
}
const points = pointsOnMapCircle(41.890242042122836, 12.492358982563019, 0.2, 8);
let geoJSON = {
"type": "FeatureCollection",
"features": []
};
points.forEach((p) => {
geoJSON.features.push({
"type": "Feature",
"properties": {},
"geometry": {
"type": "Point",
"coordinates": [
p[1],
p[0]
]
}
});
});
document.getElementById('res').innerHTML = JSON.stringify(geoJSON, true, 2);

En outre, j'ai ajouté geoJSON à l'exportation, de sorte que vous pouvez simplement coller résultant geoJSON pour
http://geojson.io/#map=17/41.89017/12.49171 et de voir les résultats instantanément.

Résultat:
Obtenir lat/long, compte tenu des point, la distance et le relèvement

Le geojson la carte est très utile pour moi de cibler un endroit sur une carte

InformationsquelleAutor kodisha

1

Aussi tard, mais pour ceux qui pourraient trouver cela, vous obtiendrez des résultats plus précis à l'aide de la geographiclib de la bibliothèque. Découvrez la géodésique problème descriptions et les exemples de JavaScript pour une simple introduction à la façon de les utiliser pour répondre à l'objet de la question ainsi que de nombreux autres. Mises en œuvre dans une variété de langues, y compris Python. Beaucoup mieux que de coder votre propre si vous vous souciez de précision; mieux que VincentyDistance dans la précédente "utiliser une bibliothèque" recommandation. La documentation dit: "L'accent est mis sur le retour des résultats précis avec des erreurs à proximité de tour-off (environ 5 à 15 nanomètres)."

InformationsquelleAutor jwd630
1

Il vous suffit d'échange les valeurs de la atan2(y,x) de la fonction. Pas atan2(x,y)!

InformationsquelleAutor Asrat

J'ai porté le Python, Javascript. Ceci renvoie à un Bing Maps Location objet, vous pouvez modifier à tout ce que vous voulez.

getLocationXDistanceFromLocation: function(latitude, longitude, distance, bearing) {
// distance in KM, bearing in degrees
var R = 6378.1,                         // Radius of the Earth
brng = Math.radians(bearing)       // Convert bearing to radian
lat = Math.radians(latitude),       // Current coords to radians
lon = Math.radians(longitude);
// Do the math magic
lat = Math.asin(Math.sin(lat) * Math.cos(distance / R) + Math.cos(lat) * Math.sin(distance / R) * Math.cos(brng));
lon += Math.atan2(Math.sin(brng) * Math.sin(distance / R) * Math.cos(lat), Math.cos(distance/R)-Math.sin(lat)*Math.sin(lat));
// Coords back to degrees and return
return new Microsoft.Maps.Location(Math.degrees(lat), Math.degrees(lon));
},

Merci de poster le code fonctionnel, y compris ce qu'il faut exécuter. I. e. ceci semble être dépendant de Microsoft.Cartes. Où trouver/ comment installer ce?
Vous ne devez utiliser Bing (Microsoft) Cartes si votre programme utilise Bing maps. Il suffit de prendre le Math.degrees(lat) et Math.degrees(lon) valeurs et de faire avec eux ce que vous avez besoin pour votre application.

InformationsquelleAutor Brad Mathews

Ici est une version de PHP basé sur Ed Williams de l'Aviation Formulaire. Le module est traité un peu différent en PHP. Cela fonctionne pour moi.

function get_new_waypoint ( $lat, $lon, $radial, $magvar, $range )
{
// $range in nm.
// $radial is heading to or bearing from    
// $magvar for local area.
$range = $range * pi() /(180*60);
$radial = $radial - $magvar ;
if ( $radial < 1 )
{
$radial = 360 + $radial - $magvar; 
}
$radial =  deg2rad($radial);
$tmp_lat = deg2rad($lat);
$tmp_lon = deg2rad($lon);
$new_lat = asin(sin($tmp_lat)* cos($range) + cos($tmp_lat) * sin($range) * cos($radial));
$new_lat = rad2deg($new_lat);
$new_lon = $tmp_lon - asin(sin($radial) * sin($range)/cos($new_lat))+ pi() % 2 * pi() -  pi();
$new_lon = rad2deg($new_lon);
return $new_lat." ".$new_lon;
}

Pourriez-vous expliquer un couple de variables? $gamme et $magvar pourrait utiliser un peu plus d'exposition pour les débutants lecteurs comme (moi:)
Veuillez voir ma réponse et le lien vers la formule qu'il utilise et à quelle précision nous pouvons nous attendre.

InformationsquelleAutor Bruce

J'ai porté à la réponse de @David M de java si quelqu'un voulait ça... je ne obtenir une légère différence de 52.20462299620793, 0.360433887489931

    double R = 6378.1;  //Radius of the Earth
double brng = 1.57;  //Bearing is 90 degrees converted to radians.
double d = 15;  //Distance in km
double lat2 = 52.20444; // - the lat result I'm hoping for
double lon2 = 0.36056; //- the long result I'm hoping for.
double lat1 = Math.toRadians(52.20472); //Current lat point converted to radians
double lon1 = Math.toRadians(0.14056); //Current long point converted to radians
lat2 = Math.asin( Math.sin(lat1)*Math.cos(d/R) +
Math.cos(lat1)*Math.sin(d/R)*Math.cos(brng));
lon2 = lon1 + Math.atan2(Math.sin(brng)*Math.sin(d/R)*Math.cos(lat1),
Math.cos(d/R)-Math.sin(lat1)*Math.sin(lat2));
lat2 = Math.toDegrees(lat2);
lon2 = Math.toDegrees(lon2);
System.out.println(lat2 + ", " + lon2);

InformationsquelleAutor Alessandro

Vous devez vous connecter pour publier un commentaire.