Angle.h

Go to the documentation of this file.

#ifndef GCP_UTIL_ANGLE_H
#define GCP_UTIL_ANGLE_H

#include <cmath>
#include <string>
#include <iostream>

#include "gcp/util/common/ConformableQuantity.h"

namespace gcp {
  namespace util {
    
    class Angle : public ConformableQuantity {
    public:
      
      class Radians {};
      class Degrees {};
      class ArcSec {};
      class ArcMinutes {};
      class MilliArcSec {};

      Angle(bool modulo=false);

      Angle(std::string degrees, bool modulo=false);

      Angle(const Radians& units,     double radians, bool modulo=false);
      Angle(const Degrees& units,     double degrees, bool modulo=false);
      Angle(const MilliArcSec& units, double mas,     bool modulo=false);
      Angle(const ArcSec& units,      double as,      bool modulo=false);
      Angle(const ArcMinutes& units,  double am,      bool modulo=false);

      Angle(Angle& angle);
      Angle(const Angle& angle);
      void operator=(Angle& angle);
      void operator=(const Angle& angle);

      virtual ~Angle();
      
      void setRadians(double radians);
      void setDegrees(double degrees);
      void setDegrees(double degrees, double arcmin, double arcsec);
      void setArcMinutes(double am);
      void setMas(double mas);
      void setArcSec(double as);
      void setDegrees(std::string degrees);

      virtual void addRadians(double radians);
      virtual void addDegrees(double degrees);
      virtual void addDegrees(std::string degrees);

      inline double radians() {
    return radians_;
      }

      inline double degrees() {
    return radians_ * degPerRad_;
      }

      inline double arcsec() {
    return radians_ * arcSecPerRad_;
      }

      inline double arcmin() {
    return radians_ * arcMinPerRad_;
      }

      inline double mas() {
    return radians_ * masPerRad_;
      }

      std::string strDegrees();

      friend std::ostream& operator<<(std::ostream& os, Angle& angle);

      Angle operator+(Angle& angle);
      
      Angle operator-(Angle& angle);

      void operator/=(unsigned uval);

      Angle operator/(unsigned uval);

      bool operator>(Angle& angle);
      bool operator>(const Angle& angle);
      bool operator>=(Angle& angle);
      bool operator<(Angle& angle);
      bool operator<(const Angle& angle);
      bool operator<=(Angle& angle);

      //------------------------------------------------------------
      // Public utility methods

      static double sexagesimalToDouble(std::string valStr);

      static std::string doubleToSexagesimal(double val);

      static const double pi_;
      static const double twoPi_;

      static const double degPerRad_;
      static const double arcSecPerDegree_;
      static const double masPerDegree_;
      static const double arcSecPerRad_;
      static const double arcMinPerRad_;
      static const double masPerRad_;

      void initialize();

    protected:

      Angle(double radians, bool modulo);

      double radians_; // The radian representation of this angle
      bool modulo_;    // True if this angle should be manipulated
               // modulo twoPi_

    }; // End class Angle
    
  } // End namespace util
} // End namespace gcp



#endif // End #ifndef GCP_UTIL_ANGLE_H