dgpslistener.h

Gps 数据采集

  {
    result = -result;
  }
  
  return result; 
}

static inline double NMEAParserGetMinutesFromNMEALon(const char lon[11])
{
  char buf[8];

  buf[0] = lon[3];
  buf[1] = lon[4];  
  buf[2] = lon[5];
  buf[3] = lon[6];
  buf[4] = lon[7];
  buf[5] = lon[8];
  buf[6] = lon[9];
  buf[7] = '\0';

  return(atof(buf)); 
}

// Geodesy Foundation Classes (Sam Blackburn)

class CMath
{
  // This class encapsulates all of the math functions. It is here to allow you
  // to replace the C Runtime functions with your home-grown (and maybe better
  // implementation) routines

public:

  static inline double AbsoluteValue( const double& value );
  static inline double ArcCosine( const double& value );
  static inline double ArcSine( const double& value );
  static inline double ArcTangent( const double& value );
  static inline double ArcTangentOfYOverX( const double& y, const double& x );
  static inline double Ceiling( const double& value );
  static inline double ConvertDegreesToRadians( const double& degrees );
  static inline double ConvertRadiansToDegrees( const double& radians );
  static inline void   ConvertDecimalDegreesToDegreesMinutesSeconds( double decimal_degrees, double& degrees, double& minutes, double& seconds );
  // West is negative, East is positive, North is positive, south is negative
  static inline double ConvertDegreesMinutesSecondsCoordinateToDecimalDegrees( double degrees, double minutes, double seconds );
  static inline double Cosine( const double& value );
  static inline double HyperbolicCosine( const double& value );
  static inline double Pi( void );
  static inline double Sine( const double& value );
  static inline double SquareRoot( const double& value );
};

// This is Blackburn's inline functions implementation (original "CMath.inl") 

inline double CMath::AbsoluteValue(const double& value)
{
  return(::fabs(value));
}

inline double CMath::ArcCosine(const double& value)
{
  return(::acos(value));
}

inline double CMath::ArcSine(const double& value)
{
  return(::asin(value));
}

inline double CMath::ArcTangent(const double& value)
{
  return(::atan(value));
}

inline double CMath::ArcTangentOfYOverX( const double& y, const double& x)
{
  return(::atan2(y,x));
}

inline double CMath::Ceiling(const double& value)
{
  return(::ceil(value));
}

inline void CMath::ConvertDecimalDegreesToDegreesMinutesSeconds(double decimal_degrees,
                                                                double& degrees,
                                                                double& minutes,
                                                                double& seconds)
{
  double fractional_part = 0.0;

  double integer_part = 0;

  fractional_part = ::modf(decimal_degrees,&integer_part);

  degrees = integer_part;

  if (decimal_degrees < 0.0)
  {
    fractional_part *= (-1.0);
  }

  minutes = fractional_part * 60.0;

  fractional_part = ::modf(minutes,&integer_part);

  minutes = integer_part;

  seconds = fractional_part * 60.0;
}

inline double CMath::ConvertDegreesMinutesSecondsCoordinateToDecimalDegrees(double degrees, 
                                                                            double minutes, 
                                                                            double seconds)
{
  double decimal_degrees = 0.0;

  decimal_degrees = degrees;

  if (decimal_degrees < 0.0)
  {
    decimal_degrees *= (-1.0);
  }

  decimal_degrees += (double) (minutes / 60.0);
  decimal_degrees += (double) (seconds / 3600.0);

  if ( degrees < 0.0 )
  {
    decimal_degrees *= (-1.0);
  }

  return(decimal_degrees);
}

inline double CMath::ConvertDegreesToRadians(const double& degrees)
{
  double radians = 0.0;
  double pi_divided_by_180 = CMath::Pi() / 180.0;
   
  radians = degrees * pi_divided_by_180;

  return( radians );
}

inline double CMath::ConvertRadiansToDegrees(const double& radians)
{
  double degrees = 0.0;

  double conversion_factor = 180.0 / CMath::Pi();

  degrees = radians * conversion_factor;

  return( degrees );
}

inline double CMath::Cosine(const double& value)
{
  return(::cos(value));
}

inline double CMath::HyperbolicCosine(const double& value)
{
  return(::cosh(value));
}

inline double CMath::Pi(void)
{
  return( 3.1415926535897932384626433832795028841971693993751058209749445923078164 );
}

inline double CMath::Sine(const double& value)
{
  return(::sin(value));
}

inline double CMath::SquareRoot(const double& value)
{
  return(::sqrt(value));
}

// End of the inline functions

class CEarthCoordinate
{
  // This is a Cartesian coordinate (Earth Centered, Earth Fixed)

protected:

  double m_X_CoordinateInMeters; // Positive points to intersection of the Prime Meridian and the equator
  double m_Y_CoordinateInMeters; // Positive points to the intersection of 90 degrees east of Prime Meridian and the equator
  double m_Z_CoordinateInMeters; // Positive points to the North Pole, Negative towards the South Pole

public:

  CEarthCoordinate();
  CEarthCoordinate(const CEarthCoordinate& source);
  ~CEarthCoordinate();

  void   Copy(const CEarthCoordinate& source);
  void   Get(double& x_coordinate,double& y_coordinate,double& z_coordinate) const;
  double GetXCoordinateInMeters(void) const;
  double GetYCoordinateInMeters(void) const;
  double GetZCoordinateInMeters(void) const;
  void   Set(double x_coordinate,double y_coordinate,double z_coordinate);
  void   SetXCoordinateInMeters(double x_coordinate);
  void   SetYCoordinateInMeters(double y_coordinate);
  void   SetZCoordinateInMeters(double z_coordinate);

  CEarthCoordinate& operator = (const CEarthCoordinate& source);
};

class CPolarCoordinate
{
protected:

  double m_UpDownAngleInDegrees; // Polar Angle, Phi
  double m_LeftRightAngleInDegrees; // Equatorial Angle, Theta
  double m_DistanceFromSurfaceInMeters;

public:

  CPolarCoordinate();
  CPolarCoordinate(const CPolarCoordinate& source);
  ~CPolarCoordinate();

  void   Copy(const CPolarCoordinate& source);
  void   Get(double& up_down_angle,double& left_right_angle,double& distance_from_surface) const;
  double GetUpDownAngleInDegrees(void) const;
  double GetLeftRightAngleInDegrees(void) const;
  double GetDistanceFromSurfaceInMeters(void) const;
  void   Set(double up_down_angle,double left_right_angle,double distance_from_surface);
  void   SetUpDownAngleInDegrees(double up_down_angle);
  void   SetLeftRightAngleInDegrees(double left_right_angle);
  void   SetDistanceFromSurfaceInMeters(double distance_from_surface);

  CPolarCoordinate& operator = (const CPolarCoordinate& source);
};

class CEarth
{
protected:

  // These are the magic numbers. They are the "real" data. They are facts,
  // measurements. Everything else about an ellipse is derived (or computed from)
  // these two data items.

  double m_PolarRadiusInMeters;
  double m_EquatorialRadiusInMeters;

  // Here be the things that can be derived from our hard data.
  // We compute these values using the two pieces of data that we
  // know about the ellipse.

  double m_Flattening;
  double m_EccentricitySquared;

  // Here's stuff specific to the C++ class

  int m_EllipsoidID;

  void m_ComputeFlattening( void );
  void m_ComputeEccentricitySquared( void );
  void m_Initialize( void );
      
public:

  enum _EllipsoidType
  {
    Unknown,
    Perfect_Sphere,
    Airy,
    Austrailian_National,
    Bessell_1841,
    Bessel_1841_Nambia,
    Clarke_1866,
    Clarke_1880,
    Everest,
    Fischer_1960_Mercury,
    Fischer_1968,
    GRS_1967,
    GRS_1980,
    Helmert_1906,
    Hough,
    International,
    Krassovsky,
    Modified_Airy,
    Modified_Everest,
    Modified_Fischer_1960,
    South_American_1969,
    Topex_Poseidon_Pathfinder_ITRF,
    WGS_60,
    WGS_66,
    WGS_72,
    WGS_84,
    Custom
  }
  ELLIPSOIDS;

  enum _DatumTypes
  {
    NAD_27 = Clarke_1866,
    Tokyo  = Bessell_1841,
  }
  DATUMS;

  CEarth(int ellipsoid = WGS_84); // Default constructor sets WGS 84 model
  ~CEarth();

  virtual void   AddLineOfSightDistanceAndDirectionToCoordinate(const CPolarCoordinate& point_1,double distance,double direction,CPolarCoordinate& point_2,double height_above_surface_of_point_2 = 0.0);
  virtual void   AddSurfaceDistanceAndDirectionToCoordinate(const CEarthCoordinate& point_1,double distance,double direction,CEarthCoordinate& point_2);
  virtual void   AddSurfaceDistanceAndDirectionToCoordinate(const CEarthCoordinate& point_1,double distance,double direction,CPolarCoordinate& point_2);
  virtual void   AddSurfaceDistanceAndDirectionToCoordinate(const CPolarCoordinate& point_1,double distance,double direction,CEarthCoordinate& point_2);
  virtual void   AddSurfaceDistanceAndDirectionToCoordinate(const CPolarCoordinate& point_1,double distance,double direction,CPolarCoordinate& point_2);
  virtual void   Convert(const CEarthCoordinate& cartesian_coordinate,CPolarCoordinate& polar_coordinate) const;
  virtual void   Convert(const CPolarCoordinate& polar_coordinate,CEarthCoordinate& cartesian_coordinate) const;
  virtual double GetDistanceToHorizon(const CEarthCoordinate& point_1) const;
  virtual double GetDistanceToHorizon(const CPolarCoordinate& point_1) const;
  virtual double GetEquatorialRadiusInMeters(void) const;
  virtual double GetPolarRadiusInMeters(void) const;
  virtual double GetLineOfSightDistanceFromCourse(const CEarthCoordinate& current_location,const CEarthCoordinate& point_a,const CEarthCoordinate& point_b) const;
  virtual double GetLineOfSightDistance(const CEarthCoordinate& point_1,const CEarthCoordinate& point_2) const;
  virtual double GetLineOfSightDistance(const CPolarCoordinate& point_1,const CEarthCoordinate& point_2) const;
  virtual double GetLineOfSightDistance(const CEarthCoordinate& point_1,const CPolarCoordinate& point_2) const;
  virtual double GetLineOfSightDistance(const CPolarCoordinate& point_1,const CPolarCoordinate& point_2) const;
  virtual double GetSurfaceDistance(const CEarthCoordinate& point_1,const CEarthCoordinate& point_2,double * heading_from_point_1_to_point_2 = 0,double * heading_from_point_2_to_point_1 = 0) const;
  virtual double GetSurfaceDistance(const CEarthCoordinate& point_1,const CPolarCoordinate& point_2,double * heading_from_point_1_to_point_2 = 0,double * heading_from_point_2_to_point_1 = 0) const;
  virtual double GetSurfaceDistance(const CPolarCoordinate& point_1,const CEarthCoordinate& point_2,double * heading_from_point_1_to_point_2 = 0,double * heading_from_point_2_to_point_1 = 0) const;
  virtual double GetSurfaceDistance(const CPolarCoordinate& point_1,const CPolarCoordinate& point_2,double * heading_from_point_1_to_point_2 = 0,double * heading_from_point_2_to_point_1 = 0) const;
  virtual void   SetEllipsoid(int ellipsoid );
  virtual void   SetEllipsoidByRadii(double equatorial_radius,double polar_radius);
  virtual void   SetEllipsoidByEquatorialRadiusAndFlattening(double equatorial_radius,double flattening);
};