C:/Active/libraries/cxutils/2.0/include/cxutils/math/coordinates.h

Go to the documentation of this file.

#ifndef __CXUTILS_MATH_COORDINATES_H
#define __CXUTILS_MATH_COORDINATES_H

#include "point3d.h"
#include "quaternion.h"

namespace CxUtils
{
    class Wgs;  //  Forward declaration for World-Geodetic System structure.
    class Utm;  //  Forward declaration for Universtal-Transmercator position structure.
    class Gcc;  //  Forward declaration for Geo-Centric Coordinates position structure.
    class Orientation;  // Forward declaration of orientation data structure.
   
    class CX_UTILS_DLL Wgs
    {
    public:
        Wgs();
        Wgs(const Wgs& wgs);
        Wgs(const Utm& utm);
        Wgs(const double latitude, const double longitude);
        Wgs(const double latitude, const double longitude, const double elevation);
        int Set(const double latitude, const double longitude);
        int Set(const double latitude, const double longitude, const double elevation);
        int Set(const double latDeg, const double latMin, const double latSec,
                const double lonDeg, const double lonMin, const double lonSec);
        int Set(const double latDeg, const double latMin, const double latSec,
                const double lonDeg, const double lonMin, const double lonSec,
                const double elevation);
        int Get(double& latitude, double& longitude) const;
        int Get(double& latitude, double& longitude, double &elevation) const;
        int Get(double& latDeg, double& latMin, double& latSec, 
                double& lonDeg, double& lonMin, double& lonSec, 
                double& elevation) const;
        void Print() const;
        std::string ToString(const bool degreesMinutesFlag = false) const;
        static double GreatCircleDistance(const Wgs& p1, const Wgs& p2);
        Wgs& operator()(const double lat, const double lon, const double elev);
        Wgs& operator=(const Wgs& wgs);
        Wgs& operator<<(const Utm& utm);
        Wgs& operator<<(const Gcc& gcc);
        void operator>>(Utm& utm) const;
        bool operator==(const Wgs& wgs) const;
        inline void operator>>(Gcc& gcc) const;
        double mLatitude;       
        double mLongitude;      
        double mElevation;      
    };

    class CX_UTILS_DLL Utm
    {
    public:
        Utm();
        Utm(const Utm& utm);
        Utm(const Wgs& wgs);
        Utm(const double northing, const double easting,
            const int zoneNumber, const int zoneLetter);
        int Set(const double northing, const double easting,
                const int zoneNumber, const int zoneLetter);
        int Set(const double northing, const double easting,
                const int zoneNumber, const int zoneLetter, 
                const double elevation);
        int Get(double& northing, double& easting,
                int& zoneNumber, int& zoneLetter) const;
        int Get(double& northing, double& easting,
                int& zoneNumber, int& zoneLetter,
                double& elevation) const;
        void Print() const;
        inline Utm& operator()(const double northing, const double easting, 
                               const int zoneNumber, const int zoneLetter,
                               const double elevation = 0)
        {
            Set(northing, easting, zoneNumber, zoneLetter, elevation);
            return *this;
        }   
        static double Distance(const Utm& utm1, const Utm& utm2);
        Utm& operator=(const Utm& utm);
        Utm& operator<<(const Wgs& wgs);
        Utm& operator<<(const Gcc& gcc);
        void operator>>(Gcc& gcc) const;
        void operator>>(Wgs& wgs) const;
        bool operator==(const Utm& utm) const;
        int mZoneNumber;          
        int mZoneLetter;          
        double mNorthing;         
        double mEasting;          
        double mElevation;        
    };

    class CX_UTILS_DLL Gcc : public Point3D
    {
    public:
        Gcc();
        Gcc(const Gcc& gcc);
        Gcc(const double x, const double y, const double z);
        void Print() const;
        double GetMagnitude() const;
        operator Point3D() const { return *((Point3D*)(this)); }
        inline Gcc& operator()(const double x, const double y, const double z)
        {
            mX = x; mY = y; mZ = z;
            return *this;
        }
        Gcc& operator=(const Point3D& p3d);
        Gcc& operator=(const Gcc& gcc);
        bool operator==(const Gcc& gcc) const;
        Gcc& operator<<(const Wgs& wgs);
        Gcc& operator<<(const Utm& utm);
        void operator>>(Wgs& wgs) const;
        void operator>>(Utm& utm) const;
    };


    class CX_UTILS_DLL Orientation
    {
    public:
        static double AngleDiff(const double angleSrc, 
                                const double angleDest,
                                const bool radiansFlag = true);

        static Point3D AngleDiff(const Point3D& angleSrc, 
                                 const Point3D& angleDest,
                                 const bool radiansFlag = true);

        static double AddToAngle(const double angleSrc,
                                 const double angleDiff,
                                 const bool radiansFlag = true);
        static Point3D AddAngles(const Point3D& src,
                                 const Point3D& delta,
                                 const bool radiansFlag = true);
        static double GetGlobalAngle(const Wgs& srcPos,
                                     const Wgs& destPos,
                                     const bool radiansFlag = true);
        static double GetGlobalAngle(const Utm& srcPos,
                                     const Utm& destPos,
                                     const bool radiansFlag = true);
    };


    CX_UTILS_DLL void GccXyzToWgsHpr(const Gcc& gcc, const Point3D& xyz, Wgs& wgs, Point3D& hpr);

    CX_UTILS_DLL void WgsHprToGccXyz(const Wgs& wgs, const Point3D& hpr, Gcc& gcc, Point3D& xyz);

    CX_UTILS_DLL void WgsHprToGccXyz(const Wgs& wgs, const Point3D& hpr, Point3D& xyz);

    inline void WgsToUtm(const Wgs& wgs, Utm& utm) { utm << wgs; }    
    inline void WgsToGcc(const Wgs& wgs, Gcc& gcc) { gcc << wgs; }    
    inline void UtmToWgs(const Utm& utm, Wgs& wgs) { wgs << utm; }    
    inline void UtmToGcc(const Utm& utm, Gcc& gcc) { gcc << utm; }    
    inline void GccToWgs(const Gcc& gcc, Wgs& wgs) { wgs << gcc; }    
    inline void GccToUtm(const Gcc& gcc, Utm& utm) { utm << gcc; }    
}

#endif //  __COORDINATES_H

/*  End of File */