SpomkyLe 13/11/2007 à 23:30
eturn true;
}
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 & CLocate::operator=( const CLocate &object )
{
this->setDataFromObject( object );
return *this;
}
bool CLocate::operator==( const CLocate& object ) const
{
long double distance = this->getDistance( object );
return (this->epsilon >= 0 && distance < this->epsilon) || (this->epsilon < 0 && distance > this->epsilon);
}
void CLocate::setDataFromValue( const long double X , const long double Y , const long double Z )
{
this->data.Type = COORD_XYZ;
this->data.Coord.XYZ.x = X;
this->data.Coord.XYZ.y = Y;
this->data.Coord.XYZ.z = Z;
}
std::string CLocate::getCoordinateName( const COORD_TYPE type )
{
switch (type)
{
case COORD_unset:
return "unset";
case COORD_default:
return "default";
case COORD_XYZ:
return "X,Y,Z";
case COORD_Dd:
return "degrees decimal";
case COORD_DMd:
return "degrees,minutes decimal";
case COORD_DMSd:
return "degrees,minutes,secondes decimal";
case COORD_DMS:
return "degrees,minutes,secondes";
default:
return "unknown!";
}
}
void CLocate::setDataFromValue( const float lat_D , const float lon_D , const double alt )
{
this->data.Type = COORD_Dd;
this->data.Coord.Dd.latitude.d = lat_D;
this->data.Coord.Dd.longitude.d = lon_D;
this->data.Coord.Dd.altitude = alt;
}
void CLocate::setDataFromValue( const short lat_D , const float lat_M , const short lon_D , const float lon_M , const double alt )
{
this->data.Type = COORD_DMd;
this->data.Coord.DMd.latitude.d = lat_D;
this->data.Coord.DMd.latitude.m = lat_M;
this->data.Coord.DMd.longitude.d = lon_D;
this->data.Coord.DMd.longitude.m = lon_M;
this->data.Coord.DMd.altitude = alt;
}
void CLocate::setDataFromValue( const short lat_D , const short lat_M , const float lat_S , const short lon_D , const short lon_M , const float lon_S , const double alt )
{
this->data.Type = COORD_DMSd;
this->data.Coord.DMSd.latitude.d = lat_D;
this->data.Coord.DMSd.latitude.m = lat_M;
this->data.Coord.DMSd.latitude.s = lat_S;
this->data.Coord.DMSd.longitude.d = lon_D;
this->data.Coord.DMSd.longitude.m = lon_M;
this->data.Coord.DMSd.longitude.s = lon_S;
this->data.Coord.DMSd.altitude = alt;
}
void CLocate::setDataFromValue( const short lat_D , const short lat_M , const short lat_S , const short lon_D , const short lon_M , const short lon_S , const double alt )
{
this->data.Type = COORD_DMS;
this->data.Coord.DMS.latitude.d = lat_D;
this->data.Coord.DMS.latitude.m = lat_M;
this->data.Coord.DMS.latitude.s = lat_S;
this->data.Coord.DMS.longitude.d = lon_D;
this->data.Coord.DMS.longitude.m = lon_M;
this->data.Coord.DMS.longitude.s = lon_S;
this->data.Coord.DMS.altitude = alt;
}
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 - result.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 - result.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 double CLocate::getDistance( const CLocate::COORDINATES_XYZ s , const CLocate::COORDINATES_XYZ d )
{
return sqrt( (s.x - d.x)*(s.x - d.x) + (s.y - d.y)*(s.y - d.y) + (s.z - d.z)*(s.z - d.z) );
}
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 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 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 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);
}
//Le calcul avec des altitudes différentes est une approximation.
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 double distance = ((EARTH_R) * (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 = sqrt( distance*distance + (s_alt - d_alt)*(s_alt - d_alt) );
return distance;
}
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 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 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);
}
long double CLocate::getDistance( const CLocate::COORDINATE s , const CLocate::COORDINATE d , const CLocate::ELLIPSOID e )
{
COORDINATE temp;
if ( s.Type != d.Type )
temp = CLocate::convertCoordinate( d , s.Type );
else
temp = d;
switch( s.Type )
{
case COORD_XYZ:
return CLocate::getDistance( s.Coord.XYZ , d.Coord.XYZ );
case COORD_Dd:
return CLocate::getDistance( s.Coord.Dd , d.Coord.Dd );
case COORD_DMd:
return CLocate::getDistance( s.Coord.DMd , d.Coord.DMd );
case COORD_DMSd:
return CLocate::getDistance( s.Coord.DMSd , d.Coord.DMSd );
case COORD_DMS:
return CLocate::getDistance( s.Coord.DMS , d.Coord.DMS );
default:
return 0;
}
}
CLocate::COORDINATE CLocate::convertCoordinate( const CLocate::COORDINATE coord_src , const CLocate::COORD_TYPE type_dst )
{
if ( coord_src.Type == type_dst)
return coord_src;
COORDINATE temp;
temp.Coord = CLocate::convertCoordinates(coord_src.Coord,coord_src.Type,type_dst,coord_src.ellipsoid );
temp.Type = type_dst;
return temp;
}
CLocate::COORDINATES CLocate::convertCoordinates( const CLocate::COORDINATES coord_src , const CLocate::COORD_TYPE type_src , const CLocate::COORD_TYPE type_dest , const ELLIPSOID ellipsoid_ )
{
COORDINATES temp;
memset( &temp,0,sizeof(COORDINATES));
if ( type_src == COORD_unset || type_src == COORD_default || type_dest == COORD_unset || type_dest == COORD_default )
return temp;
if ( type_src == type_dest )
return coord_src;
if ( (type_src == COORD_XYZ || type_dest == COORD_XYZ) && ellipsoid_ == ELLIPSOID_unset )
return temp;
switch ( type_dest )
{
case COORD_Dd:
if ( type_src == COORD_DMd )
temp.Dd = CLocate::convertCoordDd(coord_src.DMd);
if ( type_src == COORD_DMSd )
temp.Dd = CLocate::convertCoordDd(coord_src.DMSd);
if ( type_src == COORD_DMS )
temp.Dd = CLocate::convertCoordDd(coord_src.DMS);
if ( type_src == COORD_XYZ )
temp.Dd = CLocate::convertCoordDd(coord_src.XYZ,ellipsoid_);
break;
case COORD_DMd:
if ( type_src == COORD_Dd )
temp.DMd = CLocate::convertCoordDMd(coord_src.Dd);
if ( type_src == COORD_DMSd )
temp.DMd = CLocate::convertCoordDMd(coord_src.DMSd);
if ( type_src == COORD_DMS )
temp.DMd = CLocate::convertCoordDMd(coord_src.DMS);
if ( type_src == COORD_XYZ )
temp.DMd = CLocate::convertCoordDMd(coord_src.XYZ,ellipsoid_);
break;
case COORD_DMSd:
if ( type_src == COORD_Dd )
temp.DMSd = CLocate::convertCoordDMSd(coord_src.Dd);
if ( type_src == COORD_DMd )
temp.DMSd = CLocate::convertCoordDMSd(coord_src.DMd);
if ( type_src == COORD_DMS )
temp.DMSd = CLocate::convertCoordDMSd(coord_src.DMS);
if ( type_src == COORD_XYZ )
temp.DMSd = CLocate::convertCoordDMSd(coord_src.XYZ,ellipsoid_);
break;
case COORD_DMS:
if ( type_src == COORD_Dd )
temp.DMS = CLocate::convertCoordDMS(coord_src.Dd);
if ( type_src == COORD_DMd )
temp.DMS = CLocate::convertCoordDMS(coord_src.DMd);
if ( type_src == COORD_DMSd )
temp.DMS = CLocate::convertCoordDMS(coord_src.DMSd);
if ( type_src == COORD_XYZ )
temp.DMS = CLocate::convertCoordDMS(coord_src.XYZ,ellipsoid_);
break;
case COORD_XYZ:
if ( type_src == COORD_Dd )
temp.XYZ = CLocate::convertCoordXYZ(coord_src.Dd,ellipsoid_);
if ( type_src == COORD_DMd )
temp.XYZ = CLocate::convertCoordXYZ(coord_src.DMd,ellipsoid_);
if ( type_src == COORD_DMSd )
temp.XYZ = CLocate::convertCoordXYZ(coord_src.DMSd,ellipsoid_);
if ( type_src == COORD_DMS )
temp.XYZ = CLocate::convertCoordXYZ(coord_src.DMS,ellipsoid_);
break;
default :
return temp;
}
return temp;
}
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;
}
}
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;
}
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;
if ( ellipsoid == ELLIPSOID_unset )
return temp;
ELLIPSOID_CONST ELLIPSOID_const = CLocate::getEllipsoidConst(ellipsoid);
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;
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 , ellipsoid ));
}
std::string CLocate::getCoordinatesAsString( const CLocate::COORDINATES coord , const CLocate::COORD_TYPE type , const int i )
{
std::ostringstream result;
if ( type == CLocate::COORD_unset )
return "";
switch ( type )
{
case COORD_XYZ :
result << CLocate::addTab(i) << coord.XYZ.x << ";" << coord.XYZ.y << ";" << coord.XYZ.z;
break;
case COORD_Dd :
result << CLocate::addTab(i) << coord.Dd.latitude.d << ";" << coord.Dd.longitude.d << ";" << coord.Dd.altitude;
break;
case COORD_DMd :
result << CLocate::addTab(i) << coord.DMd.latitude.d << "," << coord.DMd.latitude.m << ";" << coord.DMd.longitude.d << "," << coord.DMd.longitude.m << ";" << coord.DMd.altitude;
break;
case COORD_DMSd :
result << CLocate::addTab(i) << 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 << CLocate::addTab(i) << 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 CLocate::addTab(i);
}
return result.str();
}
std::string CLocate::getCoordinatesAsXML( const CLocate::COORDINATES coord , const CLocate::COORD_TYPE type , const int i )
{
std::ostringstream result;
if ( type == CLocate::COORD_unset )
return "";
switch ( type )
{
case COORD_XYZ :
result << CLocate::addTab(i) << "<xyz>\n";
result << CLocate::addTab(i) << "\t<x>" << coord.XYZ.x << "</x>\n";
result << CLocate::addTab(i) << "\t<y>" << coord.XYZ.y << "</y>\n";
result << CLocate::addTab(i) << "\t<z>" << coord.XYZ.z << "</z>\n";
result << CLocate::addTab(i) << "</xyz>";
break;
case COORD_Dd :
result << CLocate::addTab(i) << "<dd>\n";
result << CLocate::addTab(i) << "\t<lat>\n";
result << CLocate::addTab(i) << "\t\t<d>" << coord.Dd.latitude.d << "</d>\n";
result << CLocate::addTab(i) << "\t</lat>\n";
result << CLocate::addTab(i) << "\t<long>\n";
result << CLocate::addTab(i) << "\t\t<d>" << coord.Dd.longitude.d << "</d>\n";
result << CLocate::addTab(i) << "\t</long>\n";
result << CLocate::addTab(i) << "\t<alt>" << coord.Dd.altitude << "</alt>\n";
result << CLocate::addTab(i) << "</dd>";
break;
case COORD_DMd :
result << CLocate::addTab(i) << "<dmd>\n";
result << CLocate::addTab(i) << "\t<lat>\n";
result << CLocate::addTab(i) << "\t\t<d>" << coord.DMd.latitude.d << "</d>\n";
result << CLocate::addTab(i) << "\t\t<m>" << coord.DMd.latitude.m << "</m>\n";
result << CLocate::addTab(i) << "\t</lat>\n";
result << CLocate::addTab(i) << "\t<long>\n";
result << CLocate::addTab(i) << "\t\t<d>" << coord.DMd.longitude.d << "</d>\n";
result << CLocate::addTab(i) << "\t\t<m>" << coord.DMd.longitude.m << "</m>\n";
result << CLocate::addTab(i) << "\t</long>\n";
result << CLocate::addTab(i) << "\t<alt>" << coord.DMd.altitude << "</alt>\n";
result << CLocate::addTab(i) << "</dmd>";
break;
case COORD_DMSd :
result << CLocate::addTab(i) << "<dmsd>\n";
result << CLocate::addTab(i) << "\t<lat>\n";
result << CLocate::addTab(i) << "\t\t<d>" << coord.DMSd.latitude.d << "</d>\n";
result << CLocate::addTab(i) << "\t\t<m>" << coord.DMSd.latitude.m << "</m>\n";
result << CLocate::addTab(i) << "\t\t<s>" << coord.DMSd.latitude.s << "</s>\n";
result << CLocate::addTab(i) << "\t</lat>\n";
result << CLocate::addTab(i) << "\t<long>\n";
result << CLocate::addTab(i) << "\t\t<d>" << coord.DMSd.longitude.d << "</d>\n";
result << CLocate::addTab(i) << "\t\t<m>" << coord.DMSd.longitude.m << "</m>\n";
result << CLocate::addTab(i) << "\t\t<s>" << coord.DMSd.longitude.s << "</s>\n";
result << CLocate::addTab(i) << "\t</long>\n";
result << CLocate::addTab(i) << "\t<alt>" << coord.DMSd.altitude << "</alt>\n";
result << CLocate::addTab(i) << "</dmsd>";
break;
case COORD_DMS :
result << CLocate::addTab(i) << "<dms>\n";
result << CLocate::addTab(i) << "\t<lat>\n";
result << CLocate::addTab(i) << "\t\t<d>" << coord.DMS.latitude.d << "</d>\n";
result << CLocate::addTab(i) << "\t\t<m>" << coord.DMS.latitude.m << "</m>\n";
result << CLocate::addTab(i) << "\t\t<s>" << coord.DMS.latitude.s << "</s>\n";
result << CLocate::addTab(i) << "\t</lat>\n";
result << CLocate::addTab(i) << "\t<long>\n";
result << CLocate::addTab(i) << "\t\t<d>" << coord.DMS.longitude.d << "</d>\n";
result << CLocate::addTab(i) << "\t\t<m>" << coord.DMS.longitude.m << "</m>\n";
result << CLocate::addTab(i) << "\t\t<s>" << coord.DMS.longitude.s << "</s>\n";
result << CLocate::addTab(i) << "\t</long>\n";
result << CLocate::addTab(i) << "\t<alt>" << coord.DMS.altitude << "</alt>\n";
result << CLocate::addTab(i) << "</dms>";
break;
default :
return CLocate::addTab(i);
}
return result.str();
}
void CLocate::setCoordinateType( const CLocate::COORD_TYPE coord )
{
if ( coord == COORD_unset || coord == COORD_default || this->data.Type == coord )
return;
if ( this->data.Type == COORD_unset )
{
this->data.Type = coord;
return;
}
if ( this->data.Type == COORD_XYZ && this->data.ellipsoid == ELLIPSOID_unset )
return;
this->data = convertCoordinate( this->data , coord );
}
CLocate::COORD_TYPE CLocate::getCoordinateType( void ) const
{
return this->data.Type;
}
std::string CLocate::getDataAsString( const CLocate::COORD_TYPE coord, const int i ) const
{
if ( coord == COORD_unset )
return "";
if ( coord == this->data.Type || coord == COORD_default )
return this->getCoordinatesAsString( this->data.Coord , this->data.Type , i );
COORDINATE temp = this->convertCoordinate( this->data , coord );
return this->getCoordinatesAsString( temp.Coord , coord , i );
}
std::string CLocate::getDataAsXML( const CLocate::COORD_TYPE coord, const int i ) const
{
if ( coord == COORD_unset )
return "";
if ( coord == this->data.Type || coord == COORD_default )
return this->getCoordinatesAsXML( this->data.Coord , this->data.Type , i );
COORDINATE temp = this->convertCoordinate( this->data , coord );
return this->getCoordinatesAsXML( temp.Coord , coord , i );
}
bool CLocate::getDataAsBin( void* buffer , const CLocate::COORD_TYPE coord ) const
{
if ( coord == COORD_unset || buffer == NULL )
return false;
if ( coord == this->data.Type || coord == COORD_default )
{
memcpy( buffer , &this->data , this->getDataSizeForBin() );
return true;
}
COORDINATE temp = this->convertCoordinate( this->data , coord );
memcpy( buffer , &temp , this->getDataSizeForBin() );
return true;
}
std::string CLocate::addTab( const int i )
{
if ( i == 0 )
return "";
std::ostringstream result;
for ( int cptr = 0 ; cptr < i ; cptr++ )
result << "\t";
return result.str();
}
void CLocate::setEllipsoid( const CLocate::ELLIPSOID ellipsoid_ )
{
this->data.ellipsoid = ellipsoid_;
}
CLocate::ELLIPSOID CLocate::getEllipsoid( void ) const
{
return this->data.ellipsoid;
}
bool CLocate::setDataFromBin( const void* buffer )
{
if ( buffer == NULL )
return false;
memcpy( &this->data , buffer , sizeof(COORDINATE) );
return true;
}
bool CLocate::setDataFromObject( const CLocate &object )
{
if( object.getDataAsBin( &this->data ) == true )
{
this->setEllipsoid( object.getEllipsoid() );
this->epsilon = object.epsilon;
return true;
}
return false;
}
long double CLocate::getDistance( const CLocate &object ) const
{
COORDINATE temp;
object.getDataAsBin( &temp , this->data.Type );
return CLocate::getDistance( this->data , temp );
}
bool CLocate::getDataFromValue( long double* X , long double* Y , long double* Z ) const
{
if ( X == NULL || Y == NULL || Z == NULL )
return false;
if ( this->data.Type == COORD_XYZ )
{
*X = this->data.Coord.XYZ.x;
*Y = this->data.Coord.XYZ.y;
*Z = this->data.Coord.XYZ.z;
return true;
}
COORDINATE temp = this->convertCoordinate( this->data , COORD_XYZ );
*X = temp.Coord.XYZ.x;
*Y = temp.Coord.XYZ.y;
*Z = temp.Coord.XYZ.z;
return true;
}
bool CLocate::getDataFromValue( float* lat_d , float* lon_d , double* alt ) const
{
if ( lat_d == NULL || lon_d == NULL || alt == NULL )
return false;
if ( this->data.Type == COORD_Dd )
{
*lat_d = this->data.Coord.Dd.latitude.d;
*lon_d = this->data.Coord.Dd.longitude.d;
*alt = this->data.Coord.Dd.altitude;
return true;
}
COORDINATE temp = this->convertCoordinate( this->data , COORD_Dd );
*lat_d = temp.Coord.Dd.latitude.d;
*lon_d = temp.Coord.Dd.longitude.d;
*alt = temp.Coord.Dd.altitude;
return true;
}
bool CLocate::getDataFromValue( short* lat_d , float* lat_m , short* lon_d , float* lon_m , double* alt ) const
{
if ( lat_d == NULL || lat_m == NULL || lat_d == NULL || lat_m == NULL || alt == NULL )
return false;
if ( this->data.Type == COORD_DMd )
{
*lat_d = this->data.Coord.DMd.latitude.d;
*lat_m = this->data.Coord.DMd.latitude.m;
*lon_d = this->data.Coord.DMd.longitude.d;
*lon_m = this->data.Coord.DMd.longitude.m;
*alt = this->data.Coord.DMd.altitude;
return true;
}
COORDINATE temp = this->convertCoordinate( this->data , COORD_DMd );
*lat_d = temp.Coord.DMd.latitude.d;
*lat_m = temp.Coord.DMd.latitude.m;
*lon_d = temp.Coord.DMd.longitude.d;
*lon_m = temp.Coord.DMd.longitude.m;
*alt = temp.Coord.DMd.altitude;
return true;
}
bool CLocate::getDataFromValue( short* lat_d , short* lat_m , float* lat_s , short* lon_d , short* lon_m , float* lon_s , double* alt ) const
{
if ( lat_d == NULL || lat_m == NULL || lat_s == NULL || lat_d == NULL || lat_m == NULL || lat_s == NULL || alt == NULL )
return false;
if ( this->data.Type == COORD_DMSd )
{
*lat_d = this->data.Coord.DMSd.latitude.d;
*lat_m = this->data.Coord.DMSd.latitude.m;
*lat_s = this->data.Coord.DMSd.latitude.s;
*lon_d = this->data.Coord.DMSd.longitude.d;
*lon_m = this->data.Coord.DMSd.longitude.m;
*lon_s = this->data.Coord.DMSd.longitude.s;
*alt = this->data.Coord.DMSd.altitude;
return true;
}
COORDINATE temp = this->convertCoordinate( this->data , COORD_DMSd );
*lat_d = temp.Coord.DMSd.latitude.d;
*lat_m = temp.Coord.DMSd.latitude.m;
*lat_s = temp.Coord.DMSd.latitude.s;
*lon_d = temp.Coord.DMSd.longitude.d;
*lon_m = temp.Coord.DMSd.longitude.m;
*lon_s = temp.Coord.DMSd.longitude.s;
*alt = temp.Coord.DMSd.altitude;
return true;
}
bool CLocate::getDataFromValue( short* lat_d , short* lat_m , short* lat_s , short* lon_d , short* lon_m , short* lon_s , double* alt ) const
{
if ( lat_d == NULL || lat_m == NULL || lat_s == NULL || lat_d == NULL || lat_m == NULL || lat_s == NULL || alt == NULL )
return false;
if ( this->data.Type == COORD_DMS )
{
*lat_d = this->data.Coord.DMS.latitude.d;
*lat_m = this->data.Coord.DMS.latitude.m;
*lat_s = this->data.Coord.DMS.latitude.s;
*lon_d = this->data.Coord.DMS.longitude.d;
*lon_m = this->data.Coord.DMS.longitude.m;
*lon_s = this->data.Coord.DMS.longitude.s;
*alt = this->data.Coord.DMS.altitude;
return true;
}
COORDINATE temp = this->convertCoordinate( this->data , COORD_DMS );
*lat_d = temp.Coord.DMS.latitude.d;
*lat_m = temp.Coord.DMS.latitude.m;
*lat_s = temp.Coord.DMS.latitude.s;
*lon_d = temp.Coord.DMS.longitude.d;
*lon_m = temp.Coord.DMS.longitude.m;
*lon_s = temp.Coord.DMS.longitude.s;
*alt = temp.Coord.DMS.altitude;
r