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 , ellExemple 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)