Section courante

A propos

Section administrative du site

Triangulation d'une position

La triangulation et la trilatération géométrique sont deux méthodes distinctes permettant de déterminer la position d'un point inconnu. La triangulation repose sur la mesure des angles entre des points de référence, tandis que la trilatération utilise uniquement les distances connues entre le point cible et plusieurs références. Dans le contexte de la géométrie plane, trois distances suffisent pour localiser un point unique en trouvant l'intersection de trois cercles. En géodésie et en navigation GPS, la trilatération est préférée car les récepteurs GPS mesurent le temps de propagation des signaux satellites pour calculer leur position. L'algorithme de trilatération transforme ces distances en coordonnées cartésiennes, en utilisant des vecteurs normalisés et des projections géométriques. Une fois les calculs effectués, la position est obtenue sous forme de coordonnées (x, y) ou latitude/longitude selon le domaine d'application. Cette technique est utilisée dans de nombreux domaines tels que la robotique, la télécommunication et la localisation en intérieur. En combinant précision et simplicité, la trilatération est une solution efficace pour la détermination de positions.

Trilateration géométrique

Ce programme implémente un algorithme de trilatération géométrique, une méthode permettant de déterminer la position d'un point inconnu à partir de ses distances connues par rapport à trois points de référence. Il utilise un type personnalisé TPoint pour représenter des coordonnées en deux dimensions (x, y). La procédure Trilaterate applique des calculs basés sur la géométrie vectorielle afin de trouver l'intersection des trois cercles centrés sur A, B et C, chacun ayant un rayon correspondant à la distance du point inconnu. Elle exploite des transformations de base, notamment la normalisation des vecteurs (Ex et Ey), pour exprimer la position en coordonnées locales. Dans la section principale du programme, les trois points de référence sont définis avec leurs distances respectives au point cible, et la procédure Trilaterate est appelée pour obtenir les coordonnées recherchées. Enfin, le programme affiche la position calculée sous forme de coordonnées (x, y), fournissant ainsi la localisation estimée du point inconnu.

  1. Program TrilaterationGeometrique;
  2.  
  3. {$E+,N+}
  4.  
  5. Type
  6.  TPoint=Record
  7.   x,y:Double;
  8.  End;
  9.  
  10. Var
  11.  A,B,C,P:TPoint;
  12.  r1,r2,r3:Double;
  13.  
  14. Procedure Trilaterate(A,B,C:TPoint;r1,r2,r3:Double;Var R:TPoint);
  15. Var
  16.  d,exx,exy,i,j,eyx,eyy,x,y:Double;
  17.  Ex,Ey,P:TPoint;
  18. Begin
  19.  d:=Sqrt(Sqr(B.x-A.x)+Sqr(B.y-A.y));
  20.  Ex.x:=(B.x-A.x)/d;
  21.  Ex.y:=(B.y-A.y)/d;
  22.  i:=Ex.x*(C.x-A.x)+Ex.y*(C.y-A.y);
  23.  Ey.x:=(C.x-A.x-i*Ex.x);
  24.  Ey.y:=(C.y-A.y-i*Ex.y);
  25.  j:=Sqrt(Sqr(Ey.x)+Sqr(Ey.y));
  26.  Ey.x:=Ey.x/j;
  27.  Ey.y:=Ey.y/j;
  28.  x:=(Sqr(r1)-Sqr(r2)+Sqr(d))/(2*d);
  29.  y:=(Sqr(r1)-Sqr(r3)+Sqr(i)+sqr(j)-2*i*x)/(2*j);
  30.  R.x:=A.x+x*Ex.x+y*Ey.x;
  31.  R.y:=A.y+x*Ex.y+y*Ey.y;
  32. End;
  33.  
  34. BEGIN
  35.   A.x := 0; A.y := 0; { Premier point }
  36.   B.x := 5; B.y := 0; { Deuxième point }
  37.   C.x := 2; C.y := 4; { Troisième point }
  38.  
  39.   r1 := 2.5;  { Distance du point inconnu à A }
  40.   r2 := 3.2;  { Distance du point inconnu à B }
  41.   r3 := 2.8;  { Distance du point inconnu à C }
  42.  
  43.   Trilaterate(A, B, C, r1, r2, r3,P);
  44.  
  45.   WriteLn('Position triangulée : (', P.x:0:2, ', ', P.y:0:2, ')');
  46. END.

Trilateration géographie

Ce programme en Pascal implémente la trilatération géographique pour déterminer un point inconnu à partir des distances connues de trois points de référence. Il commence par définir une structure pour stocker les coordonnées et distances des points. Il inclut des fonctions pour convertir entre degrés et radians ainsi que pour manipuler les angles trigonométriques. Ensuite, il convertit les coordonnées géographiques en coordonnées cartésiennes avant d'appliquer la trilatération. Cette technique utilise les vecteurs unitaires pour projeter et calculer la position du point inconnu. Enfin, les coordonnées cartésiennes sont reconverties en latitude et longitude pour afficher la position estimée :

  1. Program TrilaterationGeographie;
  2.  
  3. {$E+,N+}
  4.  
  5. Const
  6.  EarthRadius=6371000;  { Rayon moyen de la Terre en mètres }
  7.  
  8. Type
  9.  TPoint=Record
  10.   lat,lon:Double;  { Latitude et longitude en degrés }
  11.   dist:Double;     { Distance au point inconnu en mètres }
  12.  End;
  13.  
  14. Function ArcCos(a:Real):Real;
  15. Const
  16.  PI=3.141592653589793;
  17. Begin
  18.  If Abs(a)=1.0 Then ArcCos := (1-a)*PI/2.0
  19.                Else ArcCos := Arctan(-a/Sqrt(1-a*a))+2*Arctan(1);
  20. End;
  21.  
  22. Function ArcSin(a:Real):Real;
  23. Const
  24.  PI=3.141592653589793;
  25. Begin
  26.  If Abs(a)=1.0Then ArcSin:=PI/2.0
  27.               Else ArcSin:=ArcTan(a/Sqrt(1-a*a));
  28. End;
  29.  
  30. Function Arctan2(y,x:Double):Double;
  31. Const
  32.  PI=3.141592653589793;
  33. Begin
  34.  If x>0 Then Arctan2:=Arctan(y/x) Else
  35.  If(x<0)and(y>=0)Then Arctan2:=Arctan(y/x)+PI Else
  36.  If(x<0)And(y<0)Then Arctan2:=Arctan(y/x)-PI Else
  37.  If(x=0)And(y>0)Then Arctan2:=PI/2 Else
  38.  If(x=0)And(y<0)Then Arctan2:=-PI/2
  39.                 Else Arctan2:=0;  { Cas x = 0 et y = 0, angle indéfini }
  40. End;
  41.  
  42.  { Conversion de degrés en radians }
  43. Function DegToRad(deg:Double):Double;Begin
  44.  DegToRad:=deg*Pi/180;
  45. End;
  46.  
  47.  { Conversion de radians en degrés }
  48. Function RadToDeg(rad:Double):Double;Begin
  49.  RadToDeg:=rad*180/Pi;
  50. End;
  51.  
  52.  { Conversion de latitude/longitude en coordonnées cartésiennes (X, Y, Z) }
  53. Procedure LatLonToXYZ(lat,lon:Double;Var x,y,z:Double);
  54. Var
  55.  latRad,lonRad:Double;
  56. Begin
  57.  latRad:=DegToRad(lat);
  58.  lonRad:=DegToRad(lon);
  59.  
  60.  x:=EarthRadius*Cos(latRad)*Cos(lonRad);
  61.  y:=EarthRadius*Cos(latRad)*sin(lonRad);
  62.  z:=EarthRadius*Sin(latRad);
  63. End;
  64.  
  65.  { Fonction de trilatération }
  66. Procedure Trilaterate(p1,p2,p3:TPoint;Var lat,lon:Double);
  67. Var
  68.  x1, y1, z1, x2, y2, z2, x3, y3, z3: Double;
  69.  exx, exy, exz, i, eyx, eyy, eyz, j, ezx, ezy, ezz, x, y, z, d, a, b: Double;
  70. Begin
  71.   { Conversion des 3 points en coordonnées cartésiennes }
  72.  LatLonToXYZ(p1.lat, p1.lon, x1, y1, z1);
  73.  LatLonToXYZ(p2.lat, p2.lon, x2, y2, z2);
  74.  LatLonToXYZ(p3.lat, p3.lon, x3, y3, z3);
  75.  
  76.   { Vecteur unité ex dans la direction de p2 - p1 }
  77.  exx := (x2 - x1) / sqrt(sqr(x2 - x1) + sqr(y2 - y1) + sqr(z2 - z1));
  78.  exy := (y2 - y1) / sqrt(sqr(x2 - x1) + sqr(y2 - y1) + sqr(z2 - z1));
  79.  exz := (z2 - z1) / sqrt(sqr(x2 - x1) + sqr(y2 - y1) + sqr(z2 - z1));
  80.  
  81.   { Distance entre p1 et p2 }
  82.  d := sqrt(sqr(x2 - x1) + sqr(y2 - y1) + sqr(z2 - z1));
  83.  
  84.   { Projeter p3 sur le vecteur ex }
  85.  i := exx * (x3 - x1) + exy * (y3 - y1) + exz * (z3 - z1);
  86.  
  87.   { Vecteur unité ey perpendiculaire à ex }
  88.  eyx := (x3 - x1 - i * exx) / sqrt(sqr(x3 - x1 - i * exx) + sqr(y3 - y1 - i * exy) + sqr(z3 - z1 - i * exz));
  89.  eyy := (y3 - y1 - i * exy) / sqrt(sqr(x3 - x1 - i * exx) + sqr(y3 - y1 - i * exy) + sqr(z3 - z1 - i * exz));
  90.  eyz := (z3 - z1 - i * exz) / sqrt(sqr(x3 - x1 - i * exx) + sqr(y3 - y1 - i * exy) + sqr(z3 - z1 - i * exz));
  91.  
  92.   { Projeter p3 sur ey }
  93.   j := eyx * (x3 - x1) + eyy * (y3 - y1) + eyz * (z3 - z1);
  94.  
  95.   { Vecteur unité ez perpendiculaire à ex et ey }
  96.  ezx := exy * eyz - exz * eyy;
  97.  ezy := exz * eyx - exx * eyz;
  98.  ezz := exx * eyy - exy * eyx;
  99.  
  100.   { Calculer x et y }
  101.  x := (sqr(p1.dist) - sqr(p2.dist) + sqr(d)) / (2 * d);
  102.  y := (sqr(p1.dist) - sqr(p3.dist) + sqr(i) + sqr(j)) / (2 * j) - (i / j) * x;
  103.  
  104.   { Calculer z }
  105.  a := sqr(p1.dist) - sqr(x) - sqr(y);
  106.  If a<0 Then z:=0
  107.         Else z:=sqrt(a);
  108.  
  109.   { Convertir (x, y, z) en latitude et longitude }
  110.  lat:=RadToDeg(arcsin(z/EarthRadius));
  111.  lon:=RadToDeg(arctan2(y,x));
  112. End;
  113.  
  114.  { Programme principal }
  115. Var
  116.  p1,p2,p3:TPoint;
  117.  lat,lon:Double;
  118. BEGIN
  119.   { Définition des 3 points de référence et leurs distances }
  120.  p1.lat := 48.8566;  p1.lon := 2.3522;  p1.dist := 5000;   { Paris }
  121.  p2.lat := 48.8584;  p2.lon := 2.2945;  p2.dist := 3000;   { Tour Eiffel }
  122.  p3.lat := 48.8738;  p3.lon := 2.2950;  p3.dist := 4000;   { Arc de Triomphe }
  123.  
  124.   { Calcul de la position inconnue }
  125.  Trilaterate(p1, p2, p3, lat, lon);
  126.  
  127.   { Affichage du résultat }
  128.  Writeln('Latitude: ', lat:0:6, ' Longitude: ', lon:0:6);
  129. END.

on obtiendra le résultat suivant :

Latitude: 0.024719 Longitude: -16.436257

Dernière mise à jour : Dimanche, le 16 mars 2025