Location.h

Go to the documentation of this file.

#ifndef LOCATION_H_
#define LOCATION_H_

#include "I1D.h"
#include "units/Unit.h"
#include "utils/Str.h"

//class RingBufferVoid;

class Location: public I1D<double>
{
public:
    Location( const Unit& unit );

    Location( const Unit& unit, const double& lat, const double& lon, bool scaleValues = true );

    Location( const Location& value );
    /*
        Location( const Unit& unit, const void *binary );
    */
    virtual ~Location()
    {}
    ;

    //void* operator new( size_t size );

    //void operator delete( void* p );

    const double getLat( const Unit& unit ) const;

    const double getLon( const Unit& unit ) const;

    void setLat( const Unit& unit, const double& lat );

    void setLon( const Unit& unit, const double& lat );

    Location* copy() const;
    /*
        virtual void minus( const DataValue* rhs, DataValue* assignTo ) const;

        virtual void times( const double rhs, DataValue* assignTo ) const;

        virtual double absDiff( const DataValue* rhs ) const;
    */
    virtual bool copyTo( const Unit& unit, unsigned char& assignTo ) const
    {
        return false;
    }

    virtual bool copyTo( const Unit& unit, float& assignTo ) const
    {
        return false;
    }

    virtual bool copyTo( const Unit& unit, double& assignTo ) const
    {
        return false;
    }

    virtual bool copyTo( const Unit& unit, double& assignTo, unsigned int dim ) const;

    virtual bool copyTo( const Unit& unit, int& assignTo ) const
    {
        return false;
    }
    /*
        virtual int compare( const Unit& unit, const unsigned char& compareTo ) const
        {
            return -1;
        }

        virtual int compare( const Unit& unit, const double& compareTo ) const
        {
            return -1;
        }

        virtual int compare( const Unit& unit, const float& compareTo ) const
        {
            return -1;
        }

        virtual int compare( const Unit& unit, const int& compareTo ) const
        {
            return -1;
        }

        virtual int compare( const DataValue& compareTo ) const;

        virtual bool equals( const Unit& unit, const unsigned char& compareTo ) const
        {
            return false;
        }

        virtual bool equals( const Unit& unit, const double& compareTo ) const
        {
            return false;
        }

        virtual bool equals( const Unit& unit, const float& compareTo ) const
        {
            return false;
        }

        virtual bool equals( const Unit& unit, const int& compareTo ) const
        {
            return false;
        }

        virtual bool equals( const DataValue& compareTo ) const;
    */
    bool setFrom( const Unit& unit, unsigned char value )
    {
        return false;
    }

    bool setFrom( const Unit& unit, double value )
    {
        return false;
    }

    bool setFrom( const Unit& unit, float value )
    {
        return false;
    }

    bool setFrom( const Unit& unit, int value )
    {
        return false;
    }

    bool setFrom( const DataValue& value );

    // as a Str
    Str toString( const Unit& unit ) const;
    /*
        unsigned int toStream( OutStream& outStream ) const;

        void fromBinary( const void *buffer );
    */
    Location& operator=( const Location& rhs );

    Location& operator+=( const Location& rhs );

    Location& operator-=( const Location& rhs );

    const Location operator+( const Location& rhs ) const;

    const Location operator-( const Location& rhs ) const;

    bool isNan() const;

    // Gives the bearing (in radians) between two locations (in radians).
    static double GetBearing( const double& latitude0, const double& longitude0, const double& latitude1, const double& longitude1 );

    // Gives the bearing (in radians) between this location and another (in radians).
    double getBearing( const double& latitude, const double& longitude ) const;

    // Gives the bearing (in radians) between this location and another.
    double getBearing( const Location& location1 ) const;

    // Calculates the vector (in meters) between two locations (in radians).
    static void CalcVector( const double& lat0, const double& lon0, const double& lat1, const double& lon1, double& toEast, double& toNorth );

    // Calculates the vector (in meters) between this location and another.
    void calcVector( const Location& location1, double& toEast, double& toNorth ) const;

    // Gives the distance (in meters) between two locations (in radians).
    static double GetDistance( const double& latitude0, const double& longitude0, const double& latitude1, const double& longitude1 );

    // Gives the distance (in meters) between two locations (in radians).
    // Derived from Spherical Law of Cosines, no inverse trig.
    // Less accurate at long distances (0.25% error at 4000km), but very accurate for short distances
    static double GetDistanceFast( const double& latitude0, const double& longitude0, const double& latitude1, const double& longitude1 );

    // Gives the distance (in meters) between this location and another (in radians).
    double getDistance( const double& latitude, const double& longitude ) const;

    // Gives the distance (in meters) between this location and another.
    double getDistance( const Location& location1 ) const;

    // Gives the distance (in meters) between this location and another using the fast algorithm described above.
    double getDistanceFast( const Location& location1 ) const;

    static void AtBearing( const float bearing, const float distance, double& lat, double& lon );

    static void AtBearingEllipsoid( const float bearing, const float distance, double& lat, double& lon );

    // Given a heading (the parameter "bearing"), and a distance, sets this location
    void atBearing( const double bearing, const double distance );

    // Calculate a new latitude due to an absolute change in northings
    static double NorthingsDelta( const double startLat, const float northingsDelta );

    // Calculate a new longitude due to an absolute change in eastings
    static double EastingsDelta( const double startLat, const double startLon, const float eastingsDelta );

    // Adjust latitude & longitude for an absolute change in northings and eastings
    static void Delta( double& lat, double& lon, double northings, double eastings );

    // Haversine function
    static double HavSin( double angle );

    static const double EARTH_RADIUS;
    static const double EARTH_RADIUS_INVERTED;

    virtual double* getPtr1d()
    {
        return value_;
    }

    virtual int getM() const
    {
        return 2;
    }

protected:

    Location();

    // The actual data
    double value_[2];

    double& lat_;

    double& lon_;

    //static RingBufferVoid* MallocRing_;

    //class StaticDestructor
    //{
    //public:
    //    ~StaticDestructor();
    //};

    //static Location::StaticDestructor StaticDestructor_;

};

#endif /*LOCATION_H_*/