[Processing] Calculs coordonnées Gps distance azimut

Version imprimable

Bonjour à tous,
j'utilise la formule de calcul de coordonnées : https://www.dcode.fr/calcul-coordonnees-geographiques, au paragraphe: "Comment calculer un point d'arrivée à partir d'un point de départ ?" .
J'ai retranscrit cette formule en Java et les coordonnées calculées m'indiquent un point différent de 50cm du calculateur en ligne, alors que les autres calculs de mon application sont précis au cm . Quelqu'un pourrait-il jeter un œil sur mon problème svp?
Pour simplifier la recherche, une solution pour la première partie de la formule me permettrait de résoudre la deuxième partie semblable. Voici ma formule en Java sur Processing4.0: En connaissant le point de départ (ϕ1,λ1) (latitude, longitude), la direction θ (azimut depuis le nord) et la distance d sur une sphère de rayon R, j'ai calculé le trajet (calculs en radian) et trouvé les coordonnées d'arrivée (ϕ2,λ2)
par la formule : l
Code:

1 2 3 4 lat = Math.asin(Math.sin(ϕ1)*Math.cos(distance/radius) +Math.cos(ϕ1)*Math.sin(distance/radius)*Math.cos(θ)) ; lat = lat*180/PI; lon = (λ1*PI/180) + Math.atan2(sin(θ*PI/180) * Math.sin(distance/radius) * cos(ϕ1*PI/180) , Math.cos(distance/radius) - Math.sin(ϕ1*PI/180) * Math.sin(lat*PI/180)); lon=lon*180/PI;

Apres correction de la formule, probablement car le site fait un arrondi en affichant ses resultats :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package test.gpsdistance;
 
import static java.lang.StrictMath.*;
 
public final class Main {
    private static final double DEG_TO_RAD = PI / 180.;
    private static final double RAD_TO_DEG = 180 / PI;
 
    public static void main(final String... args) {
        final var gps = new LatLon(12.34, 56.78);
        final double directionDeg = 45;
        final double distanceKm = 1000;
        final double radiusKm = 6371;
 
        final var site = new LatLon(18.606373170899, 63.477594317657);
 
        double lat = asin(sin(gps.lat() * DEG_TO_RAD) * cos(distanceKm / radiusKm) + cos(gps.lat() * DEG_TO_RAD) * sin(distanceKm / radiusKm) * cos(directionDeg * DEG_TO_RAD));
        double lon = (gps.lon() * DEG_TO_RAD) + atan2(sin(directionDeg * DEG_TO_RAD) * sin(distanceKm / radiusKm) * cos(gps.lat() * DEG_TO_RAD),
                cos(distanceKm / radiusKm) - sin(gps.lat() * DEG_TO_RAD) * sin(lat));
        lat = lat * RAD_TO_DEG;
        lon = lon * RAD_TO_DEG;
        System.out.printf("From (ϕ1,λ1) = %s, azimuth θ = %f°, distance d = %fKm -> (ϕ2,λ2) = %s%n", gps, directionDeg, distanceKm, new LatLon(lat, lon));
        System.out.printf("Was expecting (ϕ2,λ2) = %s%n", site);
    }
 
    public record LatLon(double lat, double lon) {
    }
}

Ce qui donne :

Code:

1
2
From (ϕ1,λ1) = LatLon[lat=12.34, lon=56.78], azimuth θ = 45.000000°, distance d = 1000.000000Km -> (ϕ2,λ2) = LatLon[lat=18.606373170899314, lon=63.477594317656866]
Was expecting (ϕ2,λ2) = LatLon[lat=18.606373170899, lon=63.477594317657]

On a :

Code:

1
2
3
4
5
J: 63.477594317656866
S: 63.477594317657
 
J: 18.606373170899314
S: 18.606373170899

10/01/2025, 01h57
Page35

Bonjour Bouye,
Merci beaucoup pour tes explications et ta proposition de formule en Java. Je suis sur Processing4.0 pour raison d'IHM et la syntaxe est un peu différente, bien que basée sur java. Merci encore de bien vouloir m'accompagner. Concernant la précision des coordonnées calculées en ligne par Dcode, elles sont parfaites et je les ai validées par tracé géométrique, ce sont les formules que j'ai interprétées à partir de celles affichées sur le site Dcode qui ne donnent pas le bon résultat. Je vais tester à nouveau sur la base de ta réponse.

J'allais dire qu'il est possible que le calcul par le norme flottante habituelle (IEEE 754) ne soit pas assez precises mais le résultat est également different de ce qu'on obtient via C/C++ .
Note par default le printf() de C fait un arrondi a la 6e décimale sur %f :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#include <cstdlib>
#include <cstdio>
#include <cmath>
 
using namespace std;
 
struct LatLon {
  double lat = 0;
  double lon = 0;
};
 
int main(int argc, char** argv) {
  const double PI = 3.141592653589793;
  const double DEG_TO_RAD = PI / 180.0;
  const double RAD_TO_DEG = 180 / PI;
 
  LatLon gps;
  gps.lat = 12.34;
  gps.lon = 56.78;
  const double directionDeg = 45;
  const double distanceKm = 1000;
  const double radiusKm = 6371;
 
  LatLon site;
  site.lat = 18.606373170899;
  site.lon = 63.477594317657;
 
  double lat = asin(sin(gps.lat * DEG_TO_RAD) * cos(distanceKm / radiusKm) + cos(gps.lat * DEG_TO_RAD) * sin(distanceKm / radiusKm) * cos(directionDeg * DEG_TO_RAD));
  double lon = (gps.lon * DEG_TO_RAD) + atan2(sin(directionDeg * DEG_TO_RAD) * sin(distanceKm / radiusKm) * cos(gps.lat * DEG_TO_RAD),
						cos(distanceKm / radiusKm) - sin(gps.lat * DEG_TO_RAD) * sin(lat));
  lat = lat * RAD_TO_DEG;
  lon = lon * RAD_TO_DEG;
  LatLon res;
  res.lat = lat;
  res.lon = lon;
 
  printf("From (ϕ1,λ1) = ( %f, %f), azimuth θ = %f°, distance d = %fKm -> (ϕ2,λ2) = ( %f, %f)\n", gps.lat, gps.lon, directionDeg, distanceKm, lat, lon);
  printf("Was expecting (ϕ2,λ2) = ( %f, %f)\n", site.lat, site.lon);
 
  printf("\n");
 
  printf("From (ϕ1,λ1) = ( %.20f, %.20f), azimuth θ = %f°, distance d = %fKm -> (ϕ2,λ2) = ( %.20f, %.20f)\n", gps.lat, gps.lon, directionDeg, distanceKm, lat, lon);
  printf("Was expecting (ϕ2,λ2) = ( %.20f, %.20f)\n", site.lat, site.lon);
 
  return EXIT_SUCCESS;
}

Ce qui donne:

Code:

1
2
3
4
5
From (ϕ1,λ1) = ( 12.340000, 56.780000), azimuth θ = 45.000000°, distance d = 1000.000000Km -> (ϕ2,λ2) = ( 18.606373, 63.477594)
Was expecting (ϕ2,λ2) = ( 18.606373, 63.477594)
 
From (ϕ1,λ1) = ( 12.33999999999999985789, 56.78000000000000113687), azimuth θ = 45.000000°, distance d = 1000.000000Km -> (ϕ2,λ2) = ( 18.60637317089931386249, 63.47759431765686599647)
Was expecting (ϕ2,λ2) = ( 18.60637317089900122369, 63.47759431765700099959)

Code:

1
2
3
4
5
6
7
8
9
J:   63.477594317656866
S:   63.477594317657
C:   63.477594
C20: 63.47759431765700099959
 
J:   18.606373170899314
S:   18.606373170899
C:   18.606373
C20: 18.60637317089900122369

* Ici C20 = C en imprimant 20 décimales.

Après il y a peut-être des differences aussi dans l’implémentation des fonctions trigonométriques. As-tu essaye la definition du site pour la fonction atan2() ?

Et sinon il faudrait comparer le nombre binaire pour savoir si les résultats sont vraiment différents. En Java c'est du big endian, et on obtient :

Code:

1
2
System.out.println(Long.toBinaryString(Double.doubleToRawLongBits(lat)));
System.out.println(Long.toBinaryString(Double.doubleToRawLongBits(lon)));

Code:

1
2
100000000110010100110110011101101000101101010100010111100110011
100000001001111101111010010000111001111100000111000101110111100

Pas vraiment sur de savoir comment faire en C/C++ sans écrire dans un fichier binaire, d'autant plus que je risque de choper un résultat en little endian vu que je suis sur un PC.

EDIT - Ah oui et en essayant avec BigDecimal ? Par contre il va falloir utiliser des libs externes pour la trigonométrie...

Citation:

Envoyé par bouye

J'allais dire qu'il est possible que le calcul par le norme flottante habituelle (IEEE 754) ne soit pas assez precises mais le résultat est également different de ce qu'on obtient via C/C++ .
Note par default le printf() de C fait un arrondi a la 6e décimale sur %f :
[CODE]#include <cstdlib>...

J'avance grâce à vos infos et maintenant la valeur numérique de la latitude issue d’une fichier.csv devient
Code:

1 2 3 4 double φ1 =(Double.parseDouble(table.getString(iLignecalcullatlonBearing, "LAT"))); et le calcul de lat: final double lat=(Math.asin(Math.sin(φ1* Math.PI/ 180.0d)*Math.cos(distance_D /6_371_000d) +Math.cos(φ1* Math.PI / 180.0d)*Math.sin(distance_D /6_371_000d)*Math.cos(θ* Math.PI / 180.0d) )) *180.0d/Math.PI ;
A tester maintenant.

12/01/2025, 13h50
Page35

Encore une fois merci, la précision est maintenant millimétrique!
A bientôt sur ce précieux forum. :D