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.
- Program TrilaterationGeometrique;
-
- {$E+,N+}
-
- Type
- TPoint=Record
- x,y:Double;
- End;
-
- Var
- A,B,C,P:TPoint;
- r1,r2,r3:Double;
-
- Procedure Trilaterate(A,B,C:TPoint;r1,r2,r3:Double;Var R:TPoint);
- Var
- d,exx,exy,i,j,eyx,eyy,x,y:Double;
- Ex,Ey,P:TPoint;
- Begin
- d:=Sqrt(Sqr(B.x-A.x)+Sqr(B.y-A.y));
- Ex.x:=(B.x-A.x)/d;
- Ex.y:=(B.y-A.y)/d;
- i:=Ex.x*(C.x-A.x)+Ex.y*(C.y-A.y);
- Ey.x:=(C.x-A.x-i*Ex.x);
- Ey.y:=(C.y-A.y-i*Ex.y);
- j:=Sqrt(Sqr(Ey.x)+Sqr(Ey.y));
- Ey.x:=Ey.x/j;
- Ey.y:=Ey.y/j;
- x:=(Sqr(r1)-Sqr(r2)+Sqr(d))/(2*d);
- y:=(Sqr(r1)-Sqr(r3)+Sqr(i)+sqr(j)-2*i*x)/(2*j);
- R.x:=A.x+x*Ex.x+y*Ey.x;
- R.y:=A.y+x*Ex.y+y*Ey.y;
- End;
-
- BEGIN
- A.x := 0; A.y := 0; { Premier point }
- B.x := 5; B.y := 0; { Deuxième point }
- C.x := 2; C.y := 4; { Troisième point }
-
- r1 := 2.5; { Distance du point inconnu à A }
- r2 := 3.2; { Distance du point inconnu à B }
- r3 := 2.8; { Distance du point inconnu à C }
-
- Trilaterate(A, B, C, r1, r2, r3,P);
-
- WriteLn('Position triangulée : (', P.x:0:2, ', ', P.y:0:2, ')');
- 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 :
- Program TrilaterationGeographie;
-
- {$E+,N+}
-
- Const
- EarthRadius=6371000; { Rayon moyen de la Terre en mètres }
-
- Type
- TPoint=Record
- lat,lon:Double; { Latitude et longitude en degrés }
- dist:Double; { Distance au point inconnu en mètres }
- End;
-
- Function ArcCos(a:Real):Real;
- Const
- PI=3.141592653589793;
- Begin
- If Abs(a)=1.0 Then ArcCos := (1-a)*PI/2.0
- Else ArcCos := Arctan(-a/Sqrt(1-a*a))+2*Arctan(1);
- End;
-
- Function ArcSin(a:Real):Real;
- Const
- PI=3.141592653589793;
- Begin
- If Abs(a)=1.0Then ArcSin:=PI/2.0
- Else ArcSin:=ArcTan(a/Sqrt(1-a*a));
- End;
-
- Function Arctan2(y,x:Double):Double;
- Const
- PI=3.141592653589793;
- Begin
- If x>0 Then Arctan2:=Arctan(y/x) Else
- If(x<0)and(y>=0)Then Arctan2:=Arctan(y/x)+PI Else
- If(x<0)And(y<0)Then Arctan2:=Arctan(y/x)-PI Else
- If(x=0)And(y>0)Then Arctan2:=PI/2 Else
- If(x=0)And(y<0)Then Arctan2:=-PI/2
- Else Arctan2:=0; { Cas x = 0 et y = 0, angle indéfini }
- End;
-
- { Conversion de degrés en radians }
- Function DegToRad(deg:Double):Double;Begin
- DegToRad:=deg*Pi/180;
- End;
-
- { Conversion de radians en degrés }
- Function RadToDeg(rad:Double):Double;Begin
- RadToDeg:=rad*180/Pi;
- End;
-
- { Conversion de latitude/longitude en coordonnées cartésiennes (X, Y, Z) }
- Procedure LatLonToXYZ(lat,lon:Double;Var x,y,z:Double);
- Var
- latRad,lonRad:Double;
- Begin
- latRad:=DegToRad(lat);
- lonRad:=DegToRad(lon);
-
- x:=EarthRadius*Cos(latRad)*Cos(lonRad);
- y:=EarthRadius*Cos(latRad)*sin(lonRad);
- z:=EarthRadius*Sin(latRad);
- End;
-
- { Fonction de trilatération }
- Procedure Trilaterate(p1,p2,p3:TPoint;Var lat,lon:Double);
- Var
- x1, y1, z1, x2, y2, z2, x3, y3, z3: Double;
- exx, exy, exz, i, eyx, eyy, eyz, j, ezx, ezy, ezz, x, y, z, d, a, b: Double;
- Begin
- { Conversion des 3 points en coordonnées cartésiennes }
- LatLonToXYZ(p1.lat, p1.lon, x1, y1, z1);
- LatLonToXYZ(p2.lat, p2.lon, x2, y2, z2);
- LatLonToXYZ(p3.lat, p3.lon, x3, y3, z3);
-
- { Vecteur unité ex dans la direction de p2 - p1 }
- exx := (x2 - x1) / sqrt(sqr(x2 - x1) + sqr(y2 - y1) + sqr(z2 - z1));
- exy := (y2 - y1) / sqrt(sqr(x2 - x1) + sqr(y2 - y1) + sqr(z2 - z1));
- exz := (z2 - z1) / sqrt(sqr(x2 - x1) + sqr(y2 - y1) + sqr(z2 - z1));
-
- { Distance entre p1 et p2 }
- d := sqrt(sqr(x2 - x1) + sqr(y2 - y1) + sqr(z2 - z1));
-
- { Projeter p3 sur le vecteur ex }
- i := exx * (x3 - x1) + exy * (y3 - y1) + exz * (z3 - z1);
-
- { Vecteur unité ey perpendiculaire à ex }
- eyx := (x3 - x1 - i * exx) / sqrt(sqr(x3 - x1 - i * exx) + sqr(y3 - y1 - i * exy) + sqr(z3 - z1 - i * exz));
- eyy := (y3 - y1 - i * exy) / sqrt(sqr(x3 - x1 - i * exx) + sqr(y3 - y1 - i * exy) + sqr(z3 - z1 - i * exz));
- eyz := (z3 - z1 - i * exz) / sqrt(sqr(x3 - x1 - i * exx) + sqr(y3 - y1 - i * exy) + sqr(z3 - z1 - i * exz));
-
- { Projeter p3 sur ey }
- j := eyx * (x3 - x1) + eyy * (y3 - y1) + eyz * (z3 - z1);
-
- { Vecteur unité ez perpendiculaire à ex et ey }
- ezx := exy * eyz - exz * eyy;
- ezy := exz * eyx - exx * eyz;
- ezz := exx * eyy - exy * eyx;
-
- { Calculer x et y }
- x := (sqr(p1.dist) - sqr(p2.dist) + sqr(d)) / (2 * d);
- y := (sqr(p1.dist) - sqr(p3.dist) + sqr(i) + sqr(j)) / (2 * j) - (i / j) * x;
-
- { Calculer z }
- a := sqr(p1.dist) - sqr(x) - sqr(y);
- If a<0 Then z:=0
- Else z:=sqrt(a);
-
- { Convertir (x, y, z) en latitude et longitude }
- lat:=RadToDeg(arcsin(z/EarthRadius));
- lon:=RadToDeg(arctan2(y,x));
- End;
-
- { Programme principal }
- Var
- p1,p2,p3:TPoint;
- lat,lon:Double;
- BEGIN
- { Définition des 3 points de référence et leurs distances }
- p1.lat := 48.8566; p1.lon := 2.3522; p1.dist := 5000; { Paris }
- p2.lat := 48.8584; p2.lon := 2.2945; p2.dist := 3000; { Tour Eiffel }
- p3.lat := 48.8738; p3.lon := 2.2950; p3.dist := 4000; { Arc de Triomphe }
-
- { Calcul de la position inconnue }
- Trilaterate(p1, p2, p3, lat, lon);
-
- { Affichage du résultat }
- Writeln('Latitude: ', lat:0:6, ' Longitude: ', lon:0:6);
- END.
on obtiendra le résultat suivant :
Latitude: 0.024719 Longitude: -16.436257