ossimGpt.h

Go to the documentation of this file.

//*******************************************************************
//
// License:  See top level LICENSE.txt.
//
// Author: Garrett Potts
//
// Description:
//
// Contains class declaration for gpt.
//
// CONSTRUCTOR TAKES LAT/LON IN DEGREES!!!
//
// Height is relative to the ellipsoid in meters.
//
//*******************************************************************
//  $Id: ossimGpt.h 23159 2015-02-20 20:09:20Z okramer $

#ifndef ossimGpt_HEADER
#define ossimGpt_HEADER 1

#include <ossim/base/ossimConstants.h>
#include <ossim/base/ossimDpt.h>
#include <ossim/base/ossimDpt3d.h>
#include <ossim/base/ossimEcefPoint.h>
#include <ossim/base/ossimDatumFactory.h>
#include <ossim/base/ossimString.h>
#include <iosfwd>

class  ossimDatum;

class OSSIM_DLL ossimGpt
{
public:
   ossimGpt(const double alat=0,  // degrees
            const double alon=0,  // degrees
            const double ahgt=0,
            const ossimDatum* aDatum=ossimDatumFactory::instance()->wgs84())
      : lat(alat),
        lon(alon),
        hgt(ahgt),  // relative to the ellipsoid
        theDatum(aDatum) {}//limitLonTo180();}

   ossimGpt(const ossimGpt& src);
   
   ossimGpt(const ossimEcefPoint &aPt,
            const ossimDatum* aDatum=ossimDatumFactory::instance()->wgs84());

   ossimGpt(const ossimDpt3d &aPt) :
      lat(aPt.y), lon(aPt.x), hgt(aPt.z), theDatum(ossimDatumFactory::instance()->wgs84()) {}

   double latr()const{return lat*RAD_PER_DEG;}

   void latr(double radianValue){lat = radianValue*DEG_PER_RAD;}

   double lonr()const{return lon*RAD_PER_DEG;}

   void lonr(double radianValue)
      {lon = radianValue*DEG_PER_RAD; }//limitLonTo180();}

   double latd()const{return lat;}

   void latd(double degreeValue){lat = degreeValue;}

   double lond()const{return lon;}

   void lond(double degreeValue){lon = degreeValue; }//limitLonTo180();}

   double height()const{return hgt;}

   double heightMSL() const;

   void height(double height){hgt = height;}

   void heightMSL(double heightMSL);

   void makeNan(){lat=ossim::nan(); lon=ossim::nan(); hgt=ossim::nan();}
   bool isNan()const
   {
      return (ossim::isnan(lat)&&ossim::isnan(lon)&&ossim::isnan(hgt));
   }
   bool hasNans()const
   {
      return (ossim::isnan(lat)||ossim::isnan(lon)||ossim::isnan(hgt));
   }
   bool isLatNan()const{return ossim::isnan(lat);}
   bool isLonNan()const{return ossim::isnan(lon);}
   bool isLonLatNan()const{return (ossim::isnan(lat)||ossim::isnan(lon));}
   bool isLatLonNan() const{return (ossim::isnan(lat)||ossim::isnan(lon));}
   bool isHgtNan()const{return ossim::isnan(hgt);}

   std::ostream& print(std::ostream& os, ossim_uint32 precision=15) const;

   friend OSSIMDLLEXPORT std::ostream& operator<<(std::ostream& os,
                                                  const ossimGpt& pt);
   
   ossimString toString(ossim_uint32 precision=15) const;

   void toPoint(const std::string& s);
   
   friend OSSIMDLLEXPORT std::istream& operator>>(std::istream& is,
                                                  ossimGpt& pt);

   const ossimDatum* datum()const{return theDatum;}

   void datum(const ossimDatum* aDatum){theDatum = aDatum?aDatum:theDatum;}

   void changeDatum(const ossimDatum *datum);

   const ossimGpt& operator = (const ossimGpt &aPt);
   bool operator ==(const ossimGpt& gpt)const;

   bool operator != (const ossimGpt& gpt) const { return !(*this == gpt); }
   
   void  limitLonTo180()
   { if (lon <= -180.0) lon += 360.0; else if (lon > 180.0) lon -= 360.0; }

   void wrap();

   void clampLon(double low, double high)
      {
         if(lon < low) lon = low;
         if(lon > high) lon = high;
      }

   void clampLat(double low, double high)
      {
         if(lat < low) lat = low;
         if(lat > high) lat = high;
      }

   void clampHgt(double low, double high)
      {
         if(hgt < low) hgt = low;
         if(hgt > high) hgt = high;
      }
      
   double distanceTo(const ossimGpt& arg_gpt) const;

   double azimuthTo(const ossimGpt& arg_gpt) const;

   ossimDpt metersPerDegree() const;
   
   ossimString toDmsString()const;

   bool isEqualTo(const ossimGpt& rhs, ossimCompareType compareType=OSSIM_COMPARE_FULL)const;
   ossim_float64 lat; //> latitude in degrees measure
   ossim_float64 lon; //> longitude in degrees measure

   ossim_float64 hgt;

private:
   
   const ossimDatum* theDatum;
 
};

inline const ossimGpt& ossimGpt::operator=(const ossimGpt& aPt)
{
   if ( this != &aPt )
   {
      lat = aPt.lat;
      lon = aPt.lon;
      hgt = aPt.hgt;

      if(aPt.datum())
      {
         theDatum = aPt.datum();
      }
      if(!theDatum)
      {
         theDatum = ossimDatumFactory::instance()->wgs84();
      }
   }
   return *this;
}

inline void ossimGpt::wrap()
{
   if ( lon > 180.0 )
   {
      do
      {
         lon = lon - 360.0;
      } while ( lon > 180.0 );
   }
   else if ( lon < -180.0  )
   {
      do
      {
         lon = lon + 360.0;
      } while ( lon < -180.0 );
   }
   if ( lat > 90.0 )
   {
      if ( lat > 360.0 ) // Remove total wraps.
      {
         do
         {
            lat = lat - 360.0;
         } while ( lat > 360.0);
      }
      if ( lat > 270.0 ) // Between 270 and 360.
      {
         lat = lat - 360.0;
      }
      else if ( lat > 90 ) // Between 90 and 270.
      {
         lat = 180.0 - lat;
      }
   }
   else if ( lat < -90.0  )
   {
      if ( lat < -360.0 ) // Remove total wraps.
      {
         do
         {
            lat = lat + 360.0;
         } while ( lat < -360.0);
      }
      if ( lat < -270.0 ) 
      {
         lat = 360.0 + lat; // Between -270 and -360;
      }
      else if ( lat < -90.0 )
      {
         lat = -180.0 - lat;
      }
   }
}

#endif /* #ifndef ossimGpt_HEADER */