1

Salut!

J'ai des points avec des coordonnées de type latitude, longitude, altitude.
Comment obtenir des coordonnées X,Y,Z pour pouvoir les afficher via OpenGL?

2

Latitude, longitude et altitude sont des coordonnées sur une sphère, donc pas convertissables directement en (x, y, z)...
Tu dois connaitre le rayon de ta sphère et convertir latitude longitude altitude en coordonnées sphériques, puis en coordonnées cartésiennes ^^
Sauf erreur de ma part, ça doit donner quelque chose comme
r = rayon_sphere + altitude
theta = longitude
phi = latitude
Après, il reste juste à convertir ça en cartésien avec les formules habituelles ^^
avatar
Le scénario de notre univers a été rédigée par un bataillon de singes savants. Tout s'explique enfin.
T'as un problème ? Tu veux un bonbon ?
[CrystalMPQ] C# MPQ Library/Tools - [CrystalBoy] C# GB Emulator - [Monoxide] C# OSX library - M68k Opcodes

3

Finallement en cherchant bien : http://www.ngs.noaa.gov/PC_PROD/XYZWIN/

4

le gps n'utilise pas une sphère, mais un géoïde prévu mour modéliser l'anomalie de sphéricité de la terre (plus plate aux poles)

si tu as besoin de précision, renseigne toi sur le géoïde WGS84.

sinon, la sphère suffit smile

5

6

les éphémérides c'est plutôt pour connaitre la position des satellites non? smile

7

Martial Demolins (./5) :
il esxiste des softs de conversion GWS84-> coordonnées cartésiennes, mais je ne sais plus les quelles.

En fait le truc c'est que je suis sur un gros projet d'IA dans laquelle il y a une classe qui gère les conversions de coordonnées.
J'ai des coordonnées de type x,y,z mais aussi GPS (degré décimal, degré minute décimal, degré minute seconde décimal et degré minute seconde).
Pour convertir des coordonnées GPS en d'autres pas de problème mais pour des coordonnées x,y,z je n'y arrive pas.
C'est important non seulement pour permettre le calcul de distances avec des coordonnées hétérogènes mais surtout pour pouvoir représenter les points dans une interface 3D.

Comme mes recherches ne m'ont apporté que le lien au dessus, que le site à propos du WGS84 (merci squalyl pour l'orientation des recherches) n'est plus accessible et que comme de toute façon le WGS84 n'est pas le seul géoïde, j'ai décidé de faire une recherche dans Google Code (Dieu(x) bénisse(nt) les logiciels libre!) et j'ai trouvé des trucs super intéressants sur http://www.google.com/codesearch?hl=fr&q=show:pAXgrSQyU9w:u0evdjPyiH0:fhP-Yl5qipM&sa=N&ct=rd&cs_p=http://ftp.gnu.org/gnu/gama/gama-1.8.00.tar.gz&cs_f=gama-1.8.00/gnu_gama/ellipsoid.cpp et http://www.google.com/codesearch?hl=fr&q=show:AiS7TbWrtqk:u0evdjPyiH0:YbTGh6vyumk&sa=N&ct=rd&cs_p=http://ftp.gnu.org/gnu/gama/gama-1.8.00.tar.gz&cs_f=gama-1.8.00/gnu_gama/ellipsoids.h

PS : pour les géoïde existant j'ai trouvé cette liste avec les paramètres de conversion :
"Airy ellipsoid 1830",
"Modified Airy",
"Appl. Physics. 1965",
"Andrae 1876 (Denmark, Iceland)",
"Australian National 1965",
"Bessel ellipsoid 1841",
"Bessel 1841 (Namibia)",
"Clarke ellipsoid 1858 1st",
"Clarke ellipsoid 1858 2nd",
"Clarke ellipsoid 1866",
"Clarke ellipsoid 1880",
"Clarke ellipsoid 1880 (modified)",
"Comm. des Poids et Mesures 1799",
"Delambre 1810 (Belgium)",
"Engelis 1985",
"Everest 1830",
"Everest 1948",
"Everest 1956",
"Everest 1969",
"Everest (Sabah and Sarawak)",
"Fisher 1960 (Mercury Datum)",
"Modified Fisher 1960",
"Fischer 1968",
"GRS 67 (IUGG 1967)",
"Geodetic Reference System 1980",
"Hayford 1909 (International)",
"Helmert ellipsoid 1906",
"Hough",
"IAU 1976",
"International 1924 (Hayford 1909)",
"Kaula 1961",
"Krassovski ellipsoid 1940",
"Lerch 1979",
"Maupertius 1738",
"Mercury spheroid 1960",
"MERIT 1983",
"New International 1967",
"Naval Weapons Lab., 1965",
"Plessis 1817 (France)",
"Southeast Asia",
"Soviet Geodetic System 85",
"Schott 1900 spheroid",
"South American Spheroid 1969",
"Walbeck",
"WGS 60",
"WGS 66",
"WGS 72",
"World Geodetic System 1984"

8

ouais y'a plein de géoïdes locaux smile

9

Je me suis aperçu que Géoïde <> Ellipsoïde et que ce que j'ai trouvé concerne les ellipsoïdes seulement. J'ai aussi vu sur Wikipedia que le calcul avec les géoïdes est plus précis ... mais que la conversion est aussi plus compliquée...

M'enfin maintenant c'est bon!
J'ai réussi à adapter à ma classe les sources trouvées sur Google Code.
Je vais me mettre à la recherche d'un convertisseur utilisant ces différents systèmes locaux pour vérifier les valeurs que j'obtiens (le seul que j'ai trouvé ne converti qu'avec WGS84 et Everest).

Je diffuse tout de même les sources pour les personnes que ça pourrait intéresser (je n'ai pas fini, les fonctions sont peut-être un peu abstraites) :ipsoid )); } CLocate.cpp ://  --------------------------------------------------------------------------------------- // //                                                                                          // //                    Copyright (c) 2006 Spomky.Dev                                         // //                       <http://www.spomky.com/>                                           // // ---------------------------------------------------------------------------------------- // //  This program is free software; you can redistribute it and/or modify                    // //  it under the terms of the GNU General Public License as published by                    // //  the Free Software Foundation; either version 2 of the License, or                       // //  (at your option) any later version.                                                     // //                                                                                          // //  You may not change or alter any portion of this comment or credits                      // //  of supporting developers from this source code or any supporting                        // //  source code which is considered copyrighted (c) material of the                         // //  original comment or credit authors.                                                     // //                                                                                          // //  This program is distributed in the hope that it will be useful,                         // //  but WITHOUT ANY WARRANTY; without even the implied warranty of                          // //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                           // //  GNU General Public License for more details.                                            // //                                                                                          // //  You should have received a copy of the GNU General Public License                       // //  along with this program; if not, write to the Free Software                             // //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA                // // ---------------------------------------------------------------------------------------- // // Author: Webmaster/Spomky.Dev (webmaster@spomky.com) // URL:  http://www.spomky.com // Project:  //C++ CODE SOURCE #include "CLocate.h" CLocate::COORDINATES_Dd CLocate::convertCoordDd( const CLocate::COORDINATES_DMd source ) {      COORDINATES_Dd result;      POINT_Dd la = convertPointDd(source.latitude) , lo = convertPointDd(source.longitude);            result.altitude = source.altitude;            result.latitude = la;      result.longitude = lo;      return result; } CLocate::COORDINATES_Dd CLocate::convertCoordDd( const CLocate::COORDINATES_DMSd source ) {      COORDINATES_Dd result;      POINT_Dd la = convertPointDd(source.latitude) , lo = convertPointDd(source.longitude);            result.altitude = source.altitude;      result.latitude = la;      result.longitude = lo;      return result; } CLocate::COORDINATES_Dd CLocate::convertCoordDd( const CLocate::COORDINATES_DMS source ) {      COORDINATES_Dd result;      POINT_Dd la = convertPointDd(source.latitude) , lo = convertPointDd(source.longitude);            result.altitude = source.altitude;      result.latitude = la;      result.longitude = lo;      return result; } CLocate::COORDINATES_DMd CLocate::convertCoordDMd( const CLocate::COORDINATES_Dd source ) {      COORDINATES_DMd result;      POINT_DMd la = convertPointDMd(source.latitude) , lo = convertPointDMd(source.longitude);            result.altitude = source.altitude;      result.latitude = la;      result.longitude = lo;      return result; } CLocate::COORDINATES_DMd CLocate::convertCoordDMd( const CLocate::COORDINATES_DMSd source ) {      COORDINATES_DMd result;      POINT_DMd la = convertPointDMd(source.latitude) , lo = convertPointDMd(source.longitude);            result.altitude = source.altitude;      result.latitude = la;      result.longitude = lo;      return result; } CLocate::COORDINATES_DMd CLocate::convertCoordDMd( const CLocate::COORDINATES_DMS source ) {      COORDINATES_DMd result;      POINT_DMd la = convertPointDMd(source.latitude) , lo = convertPointDMd(source.longitude);            result.altitude = source.altitude;      result.latitude = la;      result.longitude = lo;      return result; } CLocate::COORDINATES_DMSd CLocate::convertCoordDMSd( const CLocate::COORDINATES_Dd source ) {      COORDINATES_DMSd result;      POINT_DMSd la = convertPointDMSd(source.latitude) , lo = convertPointDMSd(source.longitude);            result.altitude = source.altitude;      result.latitude = la;      result.longitude = lo;      return result; } CLocate::COORDINATES_DMSd CLocate::convertCoordDMSd( const CLocate::COORDINATES_DMd source ) {      COORDINATES_DMSd result;      POINT_DMSd la = convertPointDMSd(source.latitude) , lo = convertPointDMSd(source.longitude);            result.altitude = source.altitude;      result.latitude = la;      result.longitude = lo;      return result; } CLocate::COORDINATES_DMSd CLocate::convertCoordDMSd( const CLocate::COORDINATES_DMS source ) {      COORDINATES_DMSd result;      POINT_DMSd la = convertPointDMSd(source.latitude) , lo = convertPointDMSd(source.longitude);            result.altitude = source.altitude;      result.latitude = la;      result.longitude = lo;      return result; } CLocate::COORDINATES_DMS CLocate::convertCoordDMS( const CLocate::COORDINATES_Dd source ) {      COORDINATES_DMS result;      POINT_DMS la = convertPointDMS(source.latitude) , lo = convertPointDMS(source.longitude);            result.altitude = source.altitude;      result.latitude = la;      result.longitude = lo;      return result; } CLocate::COORDINATES_DMS CLocate::convertCoordDMS( const CLocate::COORDINATES_DMd source ) {      COORDINATES_DMS result;      POINT_DMS la = convertPointDMS(source.latitude) , lo = convertPointDMS(source.longitude);            result.altitude = source.altitude;      result.latitude = la;      result.longitude = lo;      return result; } CLocate::COORDINATES_DMS CLocate::convertCoordDMS( const CLocate::COORDINATES_DMSd source ) {      COORDINATES_DMS result;      POINT_DMS la = convertPointDMS(source.latitude) , lo = convertPointDMS(source.longitude);            result.altitude = source.altitude;      result.latitude = la;      result.longitude = lo;      return result; } // Vers Dd CLocate::POINT_Dd CLocate::convertPointDd( const CLocate::POINT_DMd source ) {      POINT_Dd result;      result.d = std::abs(source.d);      result.d += std::abs(source.m)/60;      if ( source.d < 0 )           result.d *= -1;      return result; } CLocate::POINT_DMd CLocate::convertPointDMd( const CLocate::POINT_DMSd source ) {      POINT_DMd result;      result.d = source.d;      result.m = std::abs(source.m);      result.m += std::abs(source.s)/60;      return result; } CLocate::POINT_DMSd CLocate::convertPointDMSd( const CLocate::POINT_DMS source ) {      POINT_DMSd result;      result.d = source.d;      result.m = std::abs(source.m);      result.s = std::abs(source.s);      return result; } CLocate::POINT_Dd CLocate::convertPointDd( const CLocate::POINT_DMSd source ) {      return convertPointDd(convertPointDMd(source)); } CLocate::POINT_Dd CLocate::convertPointDd( const CLocate::POINT_DMS source ) {      return convertPointDd(convertPointDMd(convertPointDMSd(source))); } CLocate::POINT_DMd CLocate::convertPointDMd( const CLocate::POINT_DMS source ) {      return convertPointDMd(convertPointDMSd(source)); } //Vers DMS CLocate::POINT_DMd CLocate::convertPointDMd( const CLocate::POINT_Dd source ) {      POINT_DMd result;      result.d = (long)source.d;      result.m = (std::abs(source.d) - std::abs(source.d)) * 60;      return result; } CLocate::POINT_DMSd CLocate::convertPointDMSd( const CLocate::POINT_DMd source ) {      POINT_DMSd result;      result.d = source.d;      result.m = (long)std::abs(source.m);      result.s = (std::abs(source.m) - std::abs(source.m)) * 60;      return result; } CLocate::POINT_DMS CLocate::convertPointDMS( const CLocate::POINT_DMSd source ) {      POINT_DMS result;      result.d = source.d;      result.m = std::abs(source.m);      result.s = (long)std::abs(source.s);      return result; } CLocate::POINT_DMS CLocate::convertPointDMS( const CLocate::POINT_DMd source ) {      return convertPointDMS(convertPointDMSd(source)); } CLocate::POINT_DMS CLocate::convertPointDMS( const CLocate::POINT_Dd source ) {      return convertPointDMS(convertPointDMSd(convertPointDMd(source))); } CLocate::POINT_DMSd CLocate::convertPointDMSd( const CLocate::POINT_Dd source ) {      return convertPointDMSd(convertPointDMd(source)); } long long double CLocate::getDistance( const CLocate::COORDINATES_XYZ s , const CLocate::COORDINATES_XYZ d ) {      return (long long double)sqrt( pow((s.x - d.x),2) + pow((s.y - d.y),2) + pow((s.z - d.z),2) ); } long long double CLocate::getDistance( const CLocate::COORDINATES_Dd s , const CLocate::COORDINATES_Dd d ) {      return getDistance(s.latitude,s.longitude,d.latitude,d.longitude,s.altitude,d.altitude); } long long double CLocate::getDistance( const CLocate::COORDINATES_DMd s , const CLocate::COORDINATES_DMd d ) {      return getDistance(s.latitude,s.longitude,d.latitude,d.longitude,s.altitude,d.altitude); } long long double CLocate::getDistance( const CLocate::COORDINATES_DMSd s , const CLocate::COORDINATES_DMSd d ) {      return getDistance(s.latitude,s.longitude,d.latitude,d.longitude,s.altitude,d.altitude); } long long double CLocate::getDistance( const CLocate::COORDINATES_DMS s , const CLocate::COORDINATES_DMS d ) {      return getDistance(s.latitude,s.longitude,d.latitude,d.longitude,s.altitude,d.altitude); } //Fonction principale de calcul de distances entre points de type GPS //Cette fonction prend en compte depuis le 12/01/2007 l'altitude des points. //Le calul avec des altitudes différentes est une approximation. long long double CLocate::getDistance( const CLocate::POINT_Dd s_lat , const CLocate::POINT_Dd s_long , const CLocate::POINT_Dd d_lat , const CLocate::POINT_Dd d_long , const double s_alt , const double d_alt ) {      long long double distance;      distance = (EARTH_R) * (long long double)(PI/2 - asin( sin(DEGtoRAD(d_lat.d)) * sin(DEGtoRAD(s_lat.d)) + cos(DEGtoRAD(d_long.d) - DEGtoRAD(s_long.d)) * cos(DEGtoRAD(d_lat.d)) * cos(DEGtoRAD(s_lat.d))));      if ( s_alt != d_alt )           distance = (long long double)sqrt( pow(distance,2) + pow((s_alt - d_alt),2) );      return distance; } long long double CLocate::getDistance( const CLocate::POINT_DMd s_lat , const CLocate::POINT_DMd s_long , const CLocate::POINT_DMd d_lat , const CLocate::POINT_DMd d_long , const double s_alt , const double d_alt ) {      return getDistance(convertPointDd(s_lat),convertPointDd(s_long),convertPointDd(d_lat),convertPointDd(d_long),s_alt,d_alt); } long long double CLocate::getDistance( const CLocate::POINT_DMSd s_lat , const CLocate::POINT_DMSd s_long , const CLocate::POINT_DMSd d_lat , const CLocate::POINT_DMSd d_long , const double s_alt , const double d_alt ) {      return getDistance(convertPointDd(s_lat),convertPointDd(s_long),convertPointDd(d_lat),convertPointDd(d_long),s_alt,d_alt); } long long double CLocate::getDistance( const CLocate::POINT_DMS s_lat , const CLocate::POINT_DMS s_long , const CLocate::POINT_DMS d_lat , const CLocate::POINT_DMS d_long , const double s_alt , const double d_alt ) {      return getDistance(convertPointDd(s_lat),convertPointDd(s_long),convertPointDd(d_lat),convertPointDd(d_long),s_alt,d_alt); } std::string CLocate::getCoordinatesAsString( const CLocate::COORDINATES coord , const CLocate::COORD_TYPE type ) {      std::ostringstream result;            if ( type == CLocate::COORD_unset || type == CLocate::COORD_default )           return "";                 switch ( type )      {           case COORD_XYZ :                result << coord.XYZ.x << ";" << coord.XYZ.y << ";" << coord.XYZ.z;                break;           case COORD_Dd :                result << coord.Dd.latitude.d << ";" << coord.Dd.longitude.d << ";" << coord.Dd.altitude;                break;           case COORD_DMd :                result << coord.DMd.latitude.d << "," << coord.DMd.latitude.m << ";" << coord.DMd.longitude.d << "," << coord.DMd.longitude.m << "," << coord.DMd.altitude;                break;           case COORD_DMSd :                result << coord.DMSd.latitude.d << "," << coord.DMSd.latitude.m << "," << coord.DMSd.latitude.s << ";" << coord.DMSd.longitude.d << "," << coord.DMSd.longitude.m << "," << coord.DMSd.longitude.s << ";" << coord.DMSd.altitude;                break;           case COORD_DMS :                result << coord.DMS.latitude.d << ","<< coord.DMS.latitude.m << "," << coord.DMS.latitude.s << ";"  << coord.DMS.longitude.d << "," << coord.DMS.longitude.m << "," << coord.DMS.longitude.s << "; " << coord.DMS.altitude;                break;           default :                return "";      }            return result.str(); } bool CLocate::convertObjectCoordinates( const CLocate::COORDINATES coord_src , CLocate::COORDINATES* coord_dest , const CLocate::COORD_TYPE type_src , const CLocate::COORD_TYPE type_dest ) {      if ( coord_dest == NULL || type_src == COORD_XYZ || type_dest == COORD_XYZ || type_src == type_dest )           return false;            switch ( type_dest )      {           case COORD_Dd:                if ( type_src == COORD_DMd )                     coord_dest->Dd = CLocate::convertCoordDd(coord_src.DMd);                if ( type_src == COORD_DMSd )                     coord_dest->Dd = CLocate::convertCoordDd(coord_src.DMSd);                if ( type_src == COORD_DMS )                     coord_dest->Dd = CLocate::convertCoordDd(coord_src.DMS);                break;           case COORD_DMd:                if ( type_src == COORD_Dd )                     coord_dest->DMd = CLocate::convertCoordDMd(coord_src.Dd);                if ( type_src == COORD_DMSd )                     coord_dest->DMd = CLocate::convertCoordDMd(coord_src.DMSd);                if ( type_src == COORD_DMS )                     coord_dest->DMd = CLocate::convertCoordDMd(coord_src.DMS);                break;           case COORD_DMSd:                if ( type_src == COORD_Dd )                     coord_dest->DMSd = CLocate::convertCoordDMSd(coord_src.Dd);                if ( type_src == COORD_DMd )                     coord_dest->DMSd = CLocate::convertCoordDMSd(coord_src.DMd);                if ( type_src == COORD_DMS )                     coord_dest->DMSd = CLocate::convertCoordDMSd(coord_src.DMS);                break;           case COORD_DMS:                if ( type_src == COORD_Dd )                     coord_dest->DMS = CLocate::convertCoordDMS(coord_src.Dd);                if ( type_src == COORD_DMd )                     coord_dest->DMS = CLocate::convertCoordDMS(coord_src.DMd);                if ( type_src == COORD_DMSd )                     coord_dest->DMS = CLocate::convertCoordDMS(coord_src.DMSd);                break;           default :                return false;      }            return true; } std::string CLocate::getEllipsoidName( const ELLIPSOID value ) {      switch(value)      {           case ELLIPSOID_unset:                return "";                break;           case ELLIPSOID_airy:                return "Airy ellipsoid 1830";                break;           case ELLIPSOID_airy_mod:                return "Modified Airy";                break;           case ELLIPSOID_apl1965:                return "Appl. Physics. 1965";                break;           case ELLIPSOID_andrae1876:                return "Andrae 1876 (Denmark, Iceland)";                break;           case ELLIPSOID_australian:                return "Australian National 1965";                break;           case ELLIPSOID_bessel:                return "Bessel ellipsoid 1841";                break;           case ELLIPSOID_bessel_nam:                return "Bessel 1841 (Namibia)";                break;           case ELLIPSOID_clarke1858a:                return "Clarke ellipsoid 1858 1st";                break;           case ELLIPSOID_clarke1858b:                return "Clarke ellipsoid 1858 2nd";                break;           case ELLIPSOID_clarke1866:                return "Clarke ellipsoid 1866";                break;           case ELLIPSOID_clarke1880:                return "Clarke ellipsoid 1880";                break;           case ELLIPSOID_clarke1880m:                return "Clarke ellipsoid 1880 (modified)";                break;           case ELLIPSOID_cpm1799:                return "Comm. des Poids et Mesures 1799";                break;           case ELLIPSOID_delambre:                return "Delambre 1810 (Belgium)";                break;           case ELLIPSOID_engelis:                return "Engelis 1985";                break;           case ELLIPSOID_everest1830:                return "Everest 1830";                break;           case ELLIPSOID_everest1848:                return "Everest 1948";                break;           case ELLIPSOID_everest1856:                return "Everest 1956";                break;           case ELLIPSOID_everest1869:                return "Everest 1969";                break;           case ELLIPSOID_everest_ss:                return "Everest (Sabah and Sarawak)";                break;           case ELLIPSOID_fisher1960:                return "Fisher 1960 (Mercury Datum)";                break;           case ELLIPSOID_fisher1960m:                return "Modified Fisher 1960";                break;           case ELLIPSOID_fischer1968:                return "Fischer 1968";                break;           case ELLIPSOID_grs67:                return "GRS 67 (IUGG 1967)";                break;           case ELLIPSOID_grs80:                return "Geodetic Reference System 1980";                break;           case ELLIPSOID_hayford:                return "Hayford 1909 (International)";                break;           case ELLIPSOID_helmert:                return "Helmert ellipsoid 1906";                break;           case ELLIPSOID_hough:                return "Hough";                break;           case ELLIPSOID_iau76:                return "IAU 1976";                break;           case ELLIPSOID_international:                return "International 1924 (Hayford 1909)";                break;           case ELLIPSOID_kaula:                return "Kaula 1961";                break;           case ELLIPSOID_krassovski:                return "Krassovski ellipsoid 1940";                break;           case ELLIPSOID_lerch:                return "Lerch 1979";                break;           case ELLIPSOID_mprts:                return "Maupertius 1738";                break;           case ELLIPSOID_mercury:                return "Mercury spheroid 1960";                break;           case ELLIPSOID_merit:                return "MERIT 1983";                break;           case ELLIPSOID_new_intl:                return "New International 1967";                break;           case ELLIPSOID_nwl1965:                return "Naval Weapons Lab., 1965";                break;           case ELLIPSOID_plessis:                return "Plessis 1817 (France)";                break;           case ELLIPSOID_se_asia:                return "Southeast Asia";                break;           case ELLIPSOID_sgs85:                return "Soviet Geodetic System 85";                break;           case ELLIPSOID_schott:                return "Schott 1900 spheroid";                break;           case ELLIPSOID_sa1969:                return "South American Spheroid 1969";                break;           case ELLIPSOID_walbeck:                return "Walbeck";                break;           case ELLIPSOID_wgs60:                return "WGS 60";                break;           case ELLIPSOID_wgs66:                return "WGS 66";                break;           case ELLIPSOID_wgs72:                return "WGS 72";                break;           case ELLIPSOID_wgs84:                return "World Geodetic System 1984";                break;           default :                return "";                break;      } } /******************************************************************************************/ /*                                                                                        */ /* TRAVAIL EXPÉRIMENTAL SUR LA TRANSFORMATIONS DE COORDONNÉES GPS VERS XYZ ET INVERSEMENT */ /*                                                                                        */ /******************************************************************************************/ //Fonctions issues de Ellipsoid.h (projet externe sous licence GPL) double CLocate::M( const CLocate::ELLIPSOID_CONST ellipsoid , const double b ) {       double w = CLocate::W( ellipsoid , b );      return ellipsoid.AIme2/(w*w*w); } double CLocate::N( const CLocate::ELLIPSOID_CONST ellipsoid , const double b ) {       return ellipsoid.A/CLocate::W( ellipsoid , b ); } double CLocate::W( const CLocate::ELLIPSOID_CONST ellipsoid , const double b ) {       double p = sin(b);      return sqrt(1 - ellipsoid.e2*p*p); } double CLocate::V( const CLocate::ELLIPSOID_CONST ellipsoid , const double b ) {       double p = cos(b);      return sqrt(1 + ellipsoid.e22*p*p);  } double CLocate::F( const CLocate::ELLIPSOID_CONST ellipsoid , const double b ) {       return sqrt(1 + ellipsoid.n*cos(b+b) + ellipsoid.n*ellipsoid.n); } CLocate::ELLIPSOID_CONST CLocate::getEllipsoidConst( CLocate::ELLIPSOID value ) {      ELLIPSOID_CONST temp;      temp.A = 0;      temp.B = 0;      temp.ff = 0;      temp.n = 0;      temp.e2 = 0;      temp.e22 = 0;      temp.Ime2 = 0;      temp.Ipe22 = 0;      temp.AIme2 = 0;      temp.AB = 0;            switch(value) {           case CLocate::ELLIPSOID_airy :                CLocate::updateEllipsoidConst( &temp , 6377563.396, 6356256.910 ,  0 ,  0 );                break;           case CLocate::ELLIPSOID_airy_mod :                CLocate::updateEllipsoidConst( &temp , 6377340.189, 6356034.446 ,  0 ,  0 );                break;           case CLocate::ELLIPSOID_apl1965 :                CLocate::updateEllipsoidConst( &temp , 6378137 ,  0 ,  0 , 298.25 );                break;           case CLocate::ELLIPSOID_andrae1876 :                CLocate::updateEllipsoidConst( &temp , 6377104.43 ,  0 ,  0 , 300.0 );                break;           case CLocate::ELLIPSOID_australian :                CLocate::updateEllipsoidConst( &temp , 6378160 ,  0 ,  0 , 298.25 );                break;           case CLocate::ELLIPSOID_bessel :                CLocate::updateEllipsoidConst( &temp , 6377397.15508, 6356078.96290 ,  0 ,  0 );                break;           case CLocate::ELLIPSOID_bessel_nam :                CLocate::updateEllipsoidConst( &temp , 6377483.865 ,  0 ,  0 , 299.1528128 );                break;           case CLocate::ELLIPSOID_clarke1858a :                CLocate::updateEllipsoidConst( &temp , 6378361, 6356685 ,  0 ,  0 );                break;           case CLocate::ELLIPSOID_clarke1858b :                CLocate::updateEllipsoidConst( &temp , 6378558, 6355810 ,  0 ,  0 );                break;           case CLocate::ELLIPSOID_clarke1866 :                CLocate::updateEllipsoidConst( &temp , 6378206.4, 6356583.8 ,  0 ,  0 );                break;           case CLocate::ELLIPSOID_clarke1880 :                CLocate::updateEllipsoidConst( &temp , 6378316, 6356582 ,  0 ,  0 );                break;           case CLocate::ELLIPSOID_clarke1880m :                CLocate::updateEllipsoidConst( &temp , 6378249.145 ,  0 ,  0 , 293.4663 );                break;           case CLocate::ELLIPSOID_cpm1799 :                CLocate::updateEllipsoidConst( &temp , 6375738.7 ,  0 ,  0 , 334.29 );                break;           case CLocate::ELLIPSOID_delambre :                CLocate::updateEllipsoidConst( &temp , 6376428 ,  0 ,  0 , 311.5 );                break;           case CLocate::ELLIPSOID_engelis :                CLocate::updateEllipsoidConst( &temp , 6378136.05 ,  0 ,  0 , 298.2566 );                break;           case CLocate::ELLIPSOID_everest1830 :                CLocate::updateEllipsoidConst( &temp , 6377276.345 ,  0 ,  0 , 300.8017 );                break;           case CLocate::ELLIPSOID_everest1848 :                CLocate::updateEllipsoidConst( &temp , 6377304.063 ,  0 ,  0 , 300.8017 );                break;           case CLocate::ELLIPSOID_everest1856 :                CLocate::updateEllipsoidConst( &temp , 6377301.243 ,  0 ,  0 , 300.8017 );                break;           case CLocate::ELLIPSOID_everest1869 :                CLocate::updateEllipsoidConst( &temp , 6377295.664 ,  0 ,  0 , 300.8017 );                break;           case CLocate::ELLIPSOID_everest_ss :                CLocate::updateEllipsoidConst( &temp , 6377298.556 ,  0 ,  0 , 300.8017 );                break;           case CLocate::ELLIPSOID_fisher1960 :                CLocate::updateEllipsoidConst( &temp , 6378166 ,  0 ,  0 , 298.3 );                break;           case CLocate::ELLIPSOID_fisher1960m :                CLocate::updateEllipsoidConst( &temp , 6378155 ,  0 ,  0 , 298.3 );                break;           case CLocate::ELLIPSOID_fischer1968 :                CLocate::updateEllipsoidConst( &temp , 6378150 ,  0 ,  0 , 298.3 );                break;           case CLocate::ELLIPSOID_grs67 :                CLocate::updateEllipsoidConst( &temp , 6378160 ,  0 ,  0 , 298.2471674270 );                break;           case CLocate::ELLIPSOID_grs80 :                CLocate::updateEllipsoidConst( &temp , 6378137 ,  0 ,  0 , 298.257222101 );                break;           case CLocate::ELLIPSOID_hayford :                CLocate::updateEllipsoidConst( &temp , 6378388 ,  0 ,  0 , 297 );                break;           case CLocate::ELLIPSOID_helmert :                CLocate::updateEllipsoidConst( &temp , 6378200 ,  0 ,  0 , 298.3 );                break;           case CLocate::ELLIPSOID_hough :                CLocate::updateEllipsoidConst( &temp , 6378270 ,  0 ,  0 , 297 );                break;           case CLocate::ELLIPSOID_iau76 :                CLocate::updateEllipsoidConst( &temp , 6378140 ,  0 ,  0 , 298.257 );                break;           case CLocate::ELLIPSOID_international :                CLocate::updateEllipsoidConst( &temp , 6378388 ,  0 ,  0 , 297 );                break;           case CLocate::ELLIPSOID_kaula :                CLocate::updateEllipsoidConst( &temp , 6378163 ,  0 ,  0 , 298.24 );                break;           case CLocate::ELLIPSOID_krassovski :                CLocate::updateEllipsoidConst( &temp , 6378245 ,  0 ,  0 , 298.3 );                break;           case CLocate::ELLIPSOID_lerch :                CLocate::updateEllipsoidConst( &temp , 6378139 ,  0 ,  0 , 298.257 );                break;           case CLocate::ELLIPSOID_mprts :                CLocate::updateEllipsoidConst( &temp , 6397300 ,  0 ,  0 , 191.0 );                break;           case CLocate::ELLIPSOID_mercury :                CLocate::updateEllipsoidConst( &temp , 6378166 ,  0 ,  0 , 298.3 );                break;           case CLocate::ELLIPSOID_merit :                CLocate::updateEllipsoidConst( &temp , 6378137 ,  0 ,  0 , 298.257 );                break;           case CLocate::ELLIPSOID_new_intl :                CLocate::updateEllipsoidConst( &temp , 6378157.5, 6356772.2 ,  0 ,  0 );                break;           case CLocate::ELLIPSOID_nwl1965 :                CLocate::updateEllipsoidConst( &temp , 6378145 ,  0 ,  0 , 298.25 );                break;           case CLocate::ELLIPSOID_plessis :                CLocate::updateEllipsoidConst( &temp , 6376523, 6355863 ,  0 ,  0 );                break;           case CLocate::ELLIPSOID_se_asia :                CLocate::updateEllipsoidConst( &temp , 6378155, 6356773.3205 ,  0 ,  0 );                break;           case CLocate::ELLIPSOID_sgs85 :                CLocate::updateEllipsoidConst( &temp , 6378136 ,  0 ,  0 , 298.257 );                break;           case CLocate::ELLIPSOID_schott :                CLocate::updateEllipsoidConst( &temp , 6378157 ,  0 ,  0 , 304.5 );                break;           case CLocate::ELLIPSOID_sa1969 :                CLocate::updateEllipsoidConst( &temp , 6378160 ,  0 ,  0 , 298.25 );                break;           case CLocate::ELLIPSOID_walbeck :                CLocate::updateEllipsoidConst( &temp , 6376896, 6355834.8467 ,  0 ,  0 );                break;           case CLocate::ELLIPSOID_wgs60 :                CLocate::updateEllipsoidConst( &temp , 6378165 ,  0 ,  0 , 298.3 );                break;           case CLocate::ELLIPSOID_wgs66 :                CLocate::updateEllipsoidConst( &temp , 6378145 ,  0 ,  0 , 298.25 );                break;           case CLocate::ELLIPSOID_wgs72 :                CLocate::updateEllipsoidConst( &temp , 6378135 ,  0 ,  0 , 298.26 );                break;           case CLocate::ELLIPSOID_wgs84 :                CLocate::updateEllipsoidConst( &temp , 6378137 ,  0 ,  0 , 298.257223563 );                break;           default :                break;      }            return temp; } void CLocate::updateEllipsoidConst( CLocate::ELLIPSOID_CONST* ellipsoid , const double pa , const double pb , const double pf , const double pf1 ) {      if ( ellipsoid == NULL )           return;            ellipsoid->A = pa;      if (pb)      {           ellipsoid->B  = pb;           ellipsoid->ff = (ellipsoid->A - ellipsoid->B)/ellipsoid->A;      }      else if (pf)      {           ellipsoid->ff = pf;           ellipsoid->B  = ellipsoid->A*(1 - ellipsoid->ff);      }      else      {           ellipsoid->ff = 1/pf1;           ellipsoid->B  = ellipsoid->A*(1 - ellipsoid->ff);      }      double a2=ellipsoid->A*ellipsoid->A, b2=ellipsoid->B*ellipsoid->B;      ellipsoid->n   = (ellipsoid->A - ellipsoid->B)/(ellipsoid->A + ellipsoid->B);      ellipsoid->e2  = (a2 - b2)/a2;      ellipsoid->e22 = (a2 - b2)/b2;      ellipsoid->Ime2  = 1 - ellipsoid->e2;      ellipsoid->Ipe22 = 1 + ellipsoid->e22;      ellipsoid->AIme2 = ellipsoid->A*ellipsoid->Ime2;      ellipsoid->AB    = ellipsoid->A/ellipsoid->B; } //Adaptation pour mon projet CLocate::COORDINATES_XYZ CLocate::convertCoordXYZ( const CLocate::COORDINATES_Dd coord , const CLocate::ELLIPSOID ellipsoid ) {      COORDINATES_XYZ temp;      temp.x = 0;      temp.y = 0;      temp.z = 0;            //On récupère les constantes en fonction de l'ellipsoïde demandée. Si elle est vaut ELLIPSOID_unset on arrête le calcul      if ( ellipsoid == ELLIPSOID_unset )           return temp;            ELLIPSOID_CONST ELLIPSOID_const = CLocate::getEllipsoidConst(ellipsoid);            //On va créer de nouvelles constantes pour notre conversion. Ces constantes sont fonctions des coordonnées et de l'ellipsoïde      const double sb = sin( DEGtoRAD(coord.latitude.d) );      const double cb = cos( DEGtoRAD(coord.latitude.d) );      const double sl = sin( DEGtoRAD(coord.longitude.d) );      const double cl = cos( DEGtoRAD(coord.longitude.d) );      const double nn = CLocate::N( ELLIPSOID_const , DEGtoRAD(coord.latitude.d) );      const double n1 = nn*ELLIPSOID_const.Ime2 + coord.altitude;      const double nh = nn + coord.altitude;            temp.x = nh*cb*cl;      temp.y = nh*cb*sl;      temp.z = n1*sb;      return temp; } CLocate::COORDINATES_XYZ CLocate::convertCoordXYZ( const CLocate::COORDINATES_DMd coord , const CLocate::ELLIPSOID ellipsoid ) {      return CLocate::convertCoordXYZ( CLocate::convertCoordDd( coord ) , ellipsoid ); } CLocate::COORDINATES_XYZ CLocate::convertCoordXYZ( const CLocate::COORDINATES_DMSd coord , const CLocate::ELLIPSOID ellipsoid ) {      return CLocate::convertCoordXYZ( CLocate::convertCoordDd( coord ) , ellipsoid ); } CLocate::COORDINATES_XYZ CLocate::convertCoordXYZ( const CLocate::COORDINATES_DMS coord , const CLocate::ELLIPSOID ellipsoid ) {      return CLocate::convertCoordXYZ( CLocate::convertCoordDd( coord ) , ellipsoid ); } // CLocate::COORDINATES_Dd CLocate::convertCoordDd( const CLocate::COORDINATES_XYZ coord , const CLocate::ELLIPSOID ellipsoid ) {      COORDINATES_Dd temp;      temp.latitude.d = 0;      temp.longitude.d = 0;      temp.altitude = 0;            CLocate::COORDINATES_XYZ coord2 = coord;            //On récupère les constantes en fonction de l'ellipsoïde demandée. Si elle est vaut ELLIPSOID_unset on arrête le calcul      if ( ellipsoid == ELLIPSOID_unset )           return temp;            ELLIPSOID_CONST ELLIPSOID_const = CLocate::getEllipsoidConst(ellipsoid);      double t, tan_u, cos2_u, cos_u, sin2_u, sin_u;      temp.longitude.d = atan2( coord2.y , coord2.x );      coord2.x = fabs(coord2.x);      coord2.y = fabs(coord2.y);      if ( coord2.x > coord2.y )      {           t = coord2.y/coord2.x;           coord2.x = coord2.x * sqrt(1 + t*t);      }       else if (coord2.y)      {           t = coord2.x/coord2.y;           coord2.x = coord2.y * sqrt(1 + t*t);      }      else      {           temp.longitude.d = 0;           if (coord2.z > 0)           {                temp.latitude.d = M_PI/2;                temp.altitude = coord2.z - ELLIPSOID_const.Ime2*CLocate::N(ELLIPSOID_const,temp.latitude.d);           }           else           {                temp.latitude.d = -M_PI/2;                temp.altitude = -coord2.z - ELLIPSOID_const.Ime2*CLocate::N(ELLIPSOID_const,temp.latitude.d);           }           return temp;      }            tan_u  = ELLIPSOID_const.AB*coord2.z/coord2.x;      cos2_u = 1/(1 + tan_u*tan_u);      cos_u  = sqrt(cos2_u);      sin2_u = 1 - cos2_u;      sin_u  = sqrt(sin2_u);      if (coord2.z < 0) sin_u = -sin_u;            temp.latitude.d = atan2(coord2.z + ELLIPSOID_const.e22*ELLIPSOID_const.B*sin2_u*sin_u, coord2.x - ELLIPSOID_const.e2*ELLIPSOID_const.A*cos2_u*cos_u);            if (coord2.x > fabs(coord2.z))           temp.altitude = coord2.x/cos(temp.latitude.d) - CLocate::N(ELLIPSOID_const,temp.latitude.d);      else           temp.altitude = coord2.z/sin(temp.latitude.d) - ELLIPSOID_const.Ime2*CLocate::N(ELLIPSOID_const,temp.latitude.d);            temp.latitude.d = RADtoDEG( temp.latitude.d );      temp.longitude.d = RADtoDEG( temp.longitude.d );            return temp; } CLocate::COORDINATES_DMd CLocate::convertCoordDMd( const CLocate::COORDINATES_XYZ coord , const CLocate::ELLIPSOID ellipsoid ) {      return CLocate::convertCoordDMd(CLocate::convertCoordDd( coord , ellipsoid )); } CLocate::COORDINATES_DMSd CLocate::convertCoordDMSd( const CLocate::COORDINATES_XYZ coord , const CLocate::ELLIPSOID ellipsoid ) {      return CLocate::convertCoordDMSd(CLocate::convertCoordDd( coord , ellipsoid )); } CLocate::COORDINATES_DMS CLocate::convertCoordDMS( const CLocate::COORDINATES_XYZ coord , const CLocate::ELLIPSOID ellipsoid ) {      return CLocate::convertCoordDMS(CLocate::convertCoordDd( coord , ell

Exemple pour l'utiliser (vite fait en utilisant les valeurs de ce site):
	CLocate::COORDINATES temp_xyz;
	temp_xyz.XYZ.x = 4593339;
	temp_xyz.XYZ.y = 560128.4;
	temp_xyz.XYZ.z = 4374982;
	
	CLocate::COORDINATES temp_dd;
	temp_dd.Dd = CLocate::convertCoordDd(temp_xyz.XYZ,CLocate::ELLIPSOID_wgs84);
	std::cout << CLocate::getCoordinatesAsString(temp_dd,CLocate::COORD_Dd) << std::endl;


PS : les remarques sont les bienvenues
PS : Martial Demolins>>tu pourras dire que tu connais un soft de plus (lol)

10

Un truc à Googler : GCTP et GCTP2

Kochise
avatar
Si Dieu m'a de nouveau fait homme, cette fois il m'a pas raté : marcher sur l'eau et dupliquer les pains, ça marche p'us :/

11

spomky (./9)


Bonjour,
moi aussi je cherche a transformer mes coordonnées GPS en X Y Z
Mais quand je compile le code il marche pas . De plus j'ai du mal a tout comprendre.
merci d'avance

12

si c'est juste un soft de conversion, Circé ( http://www.ign.fr/rubrique.asp?rbr_id=1700 ) fait ça très bien, je m'en suis servi hier et je sais qu'il sait faire les conversions entre wgs84 / lambert divers / XYZ

Même si le logiciel vous sert pas, je sais qu'il donne plein d'infos sur les géoïdes, exemple de truc qu'il m'a sorti hier:

--------------------------------------------------------------------------------
Transformation de type Standard
--------------------------------------------------------------------------------
COORDONNÉES INITIALES : Fichier C:\Documents and Settings\slo\Bureau\cellules_v2_lambert2e.txt
Référentiel géodésique : NTF (Paris)
Ellipsoïde : Clarke 1880 FR(a= 6378249.200, e2= 0.006803487646
Projection : Lambert 2 étendu
Coordonnées planes E, N, Altitude en mètres

COORDONNÉES FINALES : Fichier C:\Documents and Settings\slo\Bureau\cellules_v2_wgs84.txt
Référentiel géodésique : WGS84
Ellipsoïde : GRS 1980(a= 6378137.000, e2= 0.006694380036)
Méridien origine : Greenwich
Coordonnées géographiques en Degrés décimaux(lat, lon, altitude)
--------------------------------------------------------------------------------

308210.000 2351590.000 69.000 | 48.09799684 -1.58204018 69.000
308210.000 2351590.000 69.000 | 48.09799684 -1.58204018 69.000
308210.000 2351590.000 69.000 | 48.09799684 -1.58204018 69.000


etc...

13

En effet moi g les coordonnes des satellites (éphéméride X Y Z) et les coordonnées d'un point (latitude 48.55 longitude 2.18 altitude 208) il faut que j'écrive les coordonnées du point dans le même repère que les éphémérides pour que je puisse calculer la distance qui sépare les deux.

Comment je peut faire?

14

!call Ryo Saeba
--- Call : Ryo Saeba n'existe pas !


Lui saura t'aider embarrassed
avatar
Zut je suis reperé, vite ! L1+R1+L2+R2 !
Des ennemis ! ACTIVATING COMBAT MODE - MODULATING PHASE - POWER SURGE ! - CONFLICT RESOLVED
La longue liste des clichés de l'animé et du manga !
RAW ! RAW ! FIGHT THE POWER !

15

squalyl (./4) :
le gps n'utilise pas une sphère, mais un géoïde prévu mour modéliser l'anomalie de sphéricité de la terre (plus plate aux poles)

si tu as besoin de précision, renseigne toi sur le géoïde WGS84.

sinon, la sphère suffit smile
Euh non, il n'utilise pas du tout un géoïde mais un ellipsoïde...
a priori les coordonnées brutes qu'il te sort sont la latitude, la longitude et la *hauteur ellipsoïdale*, qui est différente de l'altitude !
mais bien sûr si tu es par terre et que tu as des données cartographiques précises, la latitude et la longitude te permettent de déduire l'altitude ^^ (et si tu es en l'air le GPS n'est pas fiable pour l'altitude de toute façon)

Le géoïde est une surface équipotentielle du champ de pesanteur, il n'y en a pas 36000 différents (il est complètement déterminé par le niveau de référence (altitude 0) choisi. En France c'est le niveau moyen de la mer mesuré par le marégraphe de Marseille.) Mais il a une forme irrégulière et ne peut donc pas servir de base pour des coordonnées 3D, c'est pourquoi on utilise des ellipsoïdes (de révolution) qui approchent au plus près le géoïde. La raison pour laquelle il y en a beaucoup est que par exemple pour faire une carte de France on va chercher un ellipsoïde qui est très proche du géoïde au niveau de la France (mais il peut constituer une mauvaise approximation à l'autre bout du monde) ; mais le GPS étant un système mondial il utilise un géoïde qui essaie de minimiser la différence globalement.

Ensuite une fois qu'on a choisi un ellipsoïde, le géoïde lui-même peut être représenté par sa différence de hauteur avec l'ellipsoïde en chaque point (différence qu'il faut ajouter à la hauteur ellipsoïdale pour obtenir l'altitude. Enfin c'est une approximation parce que les verticales réelles ne sont pas les normales à l'ellipsoïde, mais pour des altitudes assez petites c'est pas trop pourri. Si on veut faire mieux il faut calculer la ligne verticale (normale au géoïde¹) passant par le point où on est.)

¹En réalité c'est une approximation aussi parce que les verticales ne sont pas des droites, mais pour le coup je crois que c'est vraiment une bonne approximation sachant que les altitudes sont au maximum de l'ordre de quelques kilomètres et que la courbure des verticales est malgré tout plutôt faible ^^
avatar
« Le bonheur, c'est une carte de bibliothèque ! » — The gostak distims the doshes.
Membrane fondatrice de la confrérie des artistes flous.
L'univers est-il un dodécaèdre de Poincaré ?
(``·\ powaaaaaaaaa ! #love#

16

oui j'ai compris des trucs depuis que j'ai écrit ce post hehe

apparemment le géoïde peut être approché par des harmoniques non? style série de fourier de sphères d'après ce que j'ai compris, ou un truc de ce genre...

17

muh ? jamais entendu parler de ça cheeky. Je sais que le géoïde est mesuré et qu'on modélise son évolution avec tout un tas de paramètres, genre rebond post-glaciaire etc., pour la prédire, mais j'ai jamais entendu parler de séries de Fourier de sphères cheeky
avatar
« Le bonheur, c'est une carte de bibliothèque ! » — The gostak distims the doshes.
Membrane fondatrice de la confrérie des artistes flous.
L'univers est-il un dodécaèdre de Poincaré ?
(``·\ powaaaaaaaaa ! #love#

18

19

fidoo (./11) :
Bonjour,
moi aussi je cherche a transformer mes coordonnées GPS en X Y Z
Mais quand je compile le code il marche pas . De plus j'ai du mal a tout comprendre.
merci d'avance

J'ai créé les paquets debian sources et binaires pour x86, x86_64 et lpia pour Hardy.
Les sources sont là : https://code.edge.launchpad.net/~spomky/gps-tools/CLocate
Mon dépôt est là : https://edge.launchpad.net/~spomky/+archive

J'ai commenté le header et la doc est dispo via doxygen
Sinon le code à mettre est plus simple maintenant :
	CLocate myCoord( CLocate::COORD_XYZ , CLocate::ELLIPSOID_wgs84 );
	myCoord.setDataFromValue( (long double)4593339 , (long double)560128.4 , (long double)4374982 );
	
	std::cout << myCoord.getDataAsXML(CLocate::COORD_DMSd) << std::endl;


J'ai essayé Circé avec l'exemple ; il me donne
	Lat : 43° 35' 10.58393"
	Lon : 6° 57' 9.10298"
	Hauteur :104.880 m


Avec ma classe :
	Lat : 43° 35' 10.5698"
	Lon : 6° 57' 9.10263"
	Hauteur :104.701 m


Circé est pas mal (je ne connaissais pas). Je suis sur d'autres petits projets liés au GPS aussi (parser de trames NMEA, widget Qt4 pour afficher position, direction, vitesse, ...) mais je me replongerai volontier dans tout ça pour intégrer le type plan et les projections, les heures/minutes/secondes décimales, radians, ...

20

Bonjour tout le monde,

spomky, tu as peut-être compris ce que tu as fait depuis. Les petites erreurs que tu as le montre bien. Mais mettons les points sur les i pour que tout le monde retienne des choses justes tongue

squalyl, tu as bien compris. Le quasi-géoïde est bien modélisé par des harmoniques sphériques. Vu la vitesse du rebond post-glaciaire & Cie, il n'y a aucune modélisation dans les systèmes officiels globaux.

Sally, les GPS n'ont pas souvent un modèle du géoïde intégrés dans leurs circuits. Néanmoins, si le GPS est suffisamment perfectionné, cela peut-être le cas. Le seul moyen de vérifier est d'avoir la trame NMEA GGA complète.

Sally, oui il n'y a qu'un seul géoïde. Enfin, si on veut chipoter, on peut dire qu'il y en a par moment différents, chaque année, on devrait le recalculer. Aussi, il y a bien 36 000 modélisation du géoïde. Le seul moyen d'avoir une valeur exacte d'altitude serait de se balader avec un gravimètre, un peu cher comme solution. Donc on a des modélisations à tout va, de plus en plus perfectionnée. Mais assez inégaux. Par exemple pour la France, on n'utilise pas de modèle global (comme le EGM96) mais un modèle national nommé QGF98, en sachant qu'auparavant on avait le NGF-IGN69).

Je ne vais pas remonter plus loin car à quelques détails près, Sally a bien résumé la situation.

Une dernière chose que j'ajouterai est sur la raison de la multiplicité des ellipsoïdes. Les raisons sont beaucoup plus historiques que techniques. Aujourd'hui, les modèles nationaux modernes coincident avec les modèles globaux.

21

intéressant, tu tiens tout ça d'ou? c'est ton boulot?

22

Ça m'intéresse aussi d'aller au delà de ces remarques.
Les écarts entre Circé et ma classe sont-ils acceptable?
Si non comment se rapprocher de la "vérité"?
Mon but n'est pas de faire une classe précise mais au moins qu'elle soit juste et facile à utiliser.

23

squalyl, oui c'est mon boulot, ingénieur géomaticien que ça s'appelle tongue

Pour avoir exactement les mêmes résultats que Circée (car normalement il n'y a pas de raison que ce soit différent), les algorithmes utilisés sont disponibles sur le site de l'ign. La même page où on télécharge Circée, rubrique algorithmes : http://ign.fr/rubrique.asp?rbr_id=1700&lng_id=FR#68096

24

./16, ./17, ./18> squalyl parle peut-etre des spherical harmonics? il me semble d'ailleurs que le "modele global (EGM96)" dont parle le ./20 est justement base sur des spherical harmonics, avec un tres gros nombre de coefficients (ca doit depasser la 100aine de milliers).
avatar
HURRRR !

25

26

Le modèle qui est décrit dans le ./20 de la façon suivante ?
JeromeC (./20) :
Le quasi-géoïde est bien modélisé par des harmoniques sphériques.
Effectivement, il utilise sans doute des « spherical harmonics » trioui
(cross)
avatar
« Le bonheur, c'est une carte de bibliothèque ! » — The gostak distims the doshes.
Membrane fondatrice de la confrérie des artistes flous.
L'univers est-il un dodécaèdre de Poincaré ?
(``·\ powaaaaaaaaa ! #love#

27

putain... trifus
mais je l'ai lu en plus ce post... gol
bon ben rien...
(cross)

EDIT: t'1 ca devient grave.. c'est pas la premiere fois en plus..
avatar
HURRRR !

28

ptet qu'il voulait parler de "spherical harmonics", non ?
avatar
Webmaster du site Ti-FRv3 (et aussi de DevLynx)
Si moins de monde enculait le système, alors celui ci aurait plus de mal à nous sortir de si grosses merdes !
"L'erreur humaine est humaine"©Nil (2006) // topics/6238-moved-jamais-jaurais-pense-faire-ca