PositionWGS84.hpp

Go to the documentation of this file.

//
// PositionWGS84.hpp
//
// Type of positions in the WGS-84 coordinate system.
//
// 2011-11-11, Willhvo
//

#ifndef POSITIONWGS84_HPP
#define POSITIONWGS84_HPP

#include "../BasicDatatypes.hpp"
#include "../tools/MathToolbox.hpp"
#include "Point3D.hpp"

namespace datatypes
{
        
//
// Position in the WGS-84 coordinate system.
//
// WGS-84 coordinates can be provided by several data sources like GPS
// receivers, IMUs or other positioning systems.
//
class PositionWGS84 : public BasicData
{
public:

        enum PositionWGS84SourceType
        {
                Unknown = 0,
                GPS_SPS,
                GPS_PPS,
                GPS_SBAS,
                GPS_SBAS_Omnistar_VBS,
                GPS_SBAS_Omnistar_HP,
                GPS_GBAS,
                GPS_GBAS_RTK_Float,
                GPS_GBAS_RTK_Integer,
                IMU,
                LandmarkPositioning,
                Manual,
                CAN
        };

        PositionWGS84();

        virtual ~PositionWGS84();

        // Estimate the memory usage of this object
        inline virtual const UINT32 getUsedMemory() const {return (sizeof(*this));};
        
        void setMeasurementTime(time_t val) { m_timeOfMeasurement = val; }

        void setLatitudeInRad(double val);

        void transformToTangentialPlane(const PositionWGS84& origin, double* easting, double* northing, double* height) const;
        void transformToTangentialPlane(const PositionWGS84& origin, double* easting, double* northing) const;
        void transformFromTangentialPlane(double dX, double dY, const PositionWGS84& origin);

        double distanceToPos(const PositionWGS84& pos) const;

        void setLatitudeInDeg(double val) { setLatitudeInRad(val * deg2rad); }

        void setLatitudeInNMEA(double Dm, char H);

        void setLatitudeInNMEA(double Dm) { setLatitudeInNMEA(Dm, 'N'); }

        void setLatitudeSigmaInMeter(double val) { m_latitudeSigma = val; }

        void setLongitudeInRad(double val);

        void setLongitudeInDeg(double val) { setLongitudeInRad(val * deg2rad); }

        void setLongitudeInNMEA(double Dm, char H);

        void setLongitudeInNMEA(double Dm) { setLongitudeInNMEA(Dm, 'E'); }

        void setLongitudeSigmaInMeter(double val) { m_longitudeSigma = val; }

        void setAltitudeInMeterMSL(double val) { m_altitudeMSL = val; }

        void setAltitudeSigmaInMeterMSL(double val) { m_altitudeMSLSigma = val; }

        void setCourseAngleInRad(double val)
        {
                m_courseAngle = normalizeRadians(val);
                if (m_courseAngle <= 0.0)
                {
                        m_courseAngle += 2.0 * PI;
                }
        }

        void setCourseAngleInDeg(double val) { setCourseAngleInRad(val * deg2rad); }

        void setCourseAngleSigmaInRad(double val) { m_courseAngleSigma = val; }

        void setCourseAngleSigmaInDeg(double val) { setCourseAngleSigmaInRad(val * deg2rad); }

        void setYawAngleInRad(double val) { m_yawAngle = val; }
        void setYawAngleInDeg(double val) { setYawAngleInRad(val * deg2rad); }

        void setYawAngleSigmaInRad(double val) { m_yawAngleSigma = val; }
        void setYawAngleSigmaInDeg(double val) { setYawAngleSigmaInRad(val * deg2rad); }

        void setPitchAngleInRad(double val) { m_pitchAngle = val; }
        void setPitchAngleInDeg(double val) { setPitchAngleInRad(val * deg2rad); }

        void setPitchAngleSigmaInRad(double val) { m_pitchAngleSigma = val; }
        void setPitchAngleSigmaInDeg(double val) { setPitchAngleSigmaInRad(val * deg2rad); }

        void setRollAngleInRad(double val) { m_rollAngle = val; }
        void setRollAngleInDeg(double val) { setRollAngleInRad(val * deg2rad); }

        void setRollAngleSigmaInRad(double val) { m_rollAngleSigma = val; }
        void setRollAngleSigmaInDeg(double val) { setRollAngleSigmaInRad(val * deg2rad); }

        void setSource(const PositionWGS84SourceType val) { m_source = val; }

        void resetToDefault();



        const time_t& getMeasurementTime() const { return m_timeOfMeasurement; }

        const time_t& getTimestamp() const { return m_timeOfMeasurement; }

        double getLatitudeInRad() const { return m_latitude; }

        double getLatitudeInDeg() const { return (m_latitude * rad2deg); }

        double getLongitudeInRad() const { return m_longitude; }

        double getLongitudeInDeg() const { return (m_longitude * rad2deg); }

        double getCourseAngleInRad() const { return m_courseAngle; }

        double getCourseAngleInDeg() const { return (m_courseAngle * rad2deg); }

        double getYawAngleInRad() const { return m_yawAngle; }

        double getYawAngleInDeg() const { return (m_yawAngle * rad2deg); }

        double getYawAngleSigmaInRad() const { return m_yawAngleSigma; }
        double getYawAngleSigmaInDeg() const { return (m_yawAngleSigma * rad2deg); }

        double getPitchAngleInRad() const { return m_pitchAngle; }
        double getPitchAngleInDeg() const { return (m_pitchAngle * rad2deg); }

        double getPitchAngleSigmaInRad() const { return m_pitchAngleSigma; }
        double getPitchAngleSigmaInDeg() const { return (m_pitchAngleSigma * rad2deg); }

        double getRollAngleInRad() const { return m_rollAngle; }
        double getRollAngleInDeg() const { return (m_rollAngle * rad2deg); }

        double getRollAngleSigmaInRad() const { return m_rollAngleSigma; }
        double getRollAngleSigmaInDeg() const { return (m_rollAngleSigma * rad2deg); }

        bool operator==(const PositionWGS84& other) const;
        bool operator!=(const PositionWGS84& other) const { return !(*this == other); }


        double getAltitudeInMeterMSL() const { return m_altitudeMSL; }

        std::string toString() const;

        PositionWGS84SourceType getSource() const { return m_source; }

        std::string getSourceString() const;

        
        double dist( const PositionWGS84& pos ) const;

        Point3D getCartesianRelPos(const PositionWGS84& orign) const;

private:
        double NMEA2rad( double Dm );

        // NOTE 2008/01/18 (dw) : Change VERSION in cpp file when the interface is changed or bugs are fixed.
        //                                                Document changes in the HISTORY above.
        static const std::string VERSION;

        time_t  m_timeOfMeasurement;

        //                                                                 Unit                                                         Serialized size:
//      UINT8 m_deviceID;                               // ID of device                                         + 1 Bytes
        double m_latitude;                              // [rad]                                                        + 8 Bytes
        double m_latitudeSigma;                 // [m]                                                          + 8 Bytes
        double m_longitude;                             // [rad]                                                        + 8 Bytes
        double m_longitudeSigma;                // [m]                                                          + 8 Bytes
        double m_altitudeMSL;                   // [m]                                                          + 8 Bytes
        double m_altitudeMSLSigma;              // [m]                                                          + 8 Bytes
        double m_courseAngle;                   // [rad]                                                        + 8 Bytes
        double m_courseAngleSigma;              // [rad]                                                        + 8 Bytes
        double m_yawAngle;                              // [rad]                                                        + 8 Bytes
        double m_yawAngleSigma;                 // [rad]                                                        + 8 Bytes
        double m_pitchAngle;                    // [rad]                                                        + 8 Bytes
        double m_pitchAngleSigma;               // [rad]                                                        + 8 Bytes
        double m_rollAngle;                             // [rad]                                                        + 8 Bytes
        double m_rollAngleSigma;                // [rad]                                                        + 8 Bytes
        PositionWGS84SourceType m_source;                       // Source of position information       + 2 Bytes (encoded as UINT16)
        //                                                                                                                                      = 115 Bytes
};

std::string toString(const PositionWGS84::PositionWGS84SourceType& type);


}       // namespace datatypes



#endif // POSITIONWGS84_HPP