Projection.h

Go to the documentation of this file.

#ifndef Projection_h
#define Projection_h

#include <string>
#include <vector>

#include "PvlGroup.h" // protected data member object (m_mappingGrp)

namespace Isis {
  class Displacement;
  class Pvl;
  class WorldMapper;
  class Projection {
    public:
      // constructor
      Projection(Pvl &label);
      virtual ~Projection();
      virtual bool operator== (const Projection &proj);
      bool operator!= (const Projection &proj);

      // These return properties of the target
      bool IsSky() const;
      double EquatorialRadius() const;
      double PolarRadius() const;
      double Eccentricity() const;
      double LocalRadius(double lat) const;
      double LocalRadius() const; // requires SetGround or SetCoordinate

      // These return or change properties of the projection, independent of calculations
      virtual QString Name() const = 0;
      virtual QString Version() const = 0;
      virtual double TrueScaleLatitude() const;
      virtual bool IsEquatorialCylindrical();
      enum LatitudeType { Planetocentric, 
                          Planetographic  
                        };
      // Check latitude type or get latitude type as a string
      bool IsPlanetocentric() const;
      bool IsPlanetographic() const;
      QString LatitudeTypeString() const;
      // change latitude type
      double ToPlanetocentric(const double lat) const;
      double ToPlanetographic(const double lat) const;
      enum LongitudeDirection { PositiveEast, 
                                PositiveWest  
                              };
      // Check longitude direction or get longitude direction as a string
      bool IsPositiveEast() const;
      bool IsPositiveWest() const;
      QString LongitudeDirectionString() const;
      // Check longitude domain or get longitude domain as a string
      bool Has180Domain() const;
      bool Has360Domain() const;
      QString LongitudeDomainString() const;
      // Check if labels contain min/max lat/lon
      bool HasGroundRange() const;
      // Get min/max lat/lon
      double MinimumLatitude() const;
      double MaximumLatitude() const;
      double MinimumLongitude() const;
      double MaximumLongitude() const;
      // get rotation
      double Rotation() const;
      // Set world mapper
      void SetWorldMapper(WorldMapper *mapper);

      //  Calculations
      // Set ground position or x/y coordinate
      virtual bool SetGround(const double lat, const double lon);
      virtual bool SetCoordinate(const double x, const double y);
      bool IsGood() const;

      // Methods that depend on successful completion
      // of SetGround/SetCoordinate Get lat,lon, x,y
      double Latitude() const;
      double Longitude() const;
      double XCoord() const;
      double YCoord() const;
      // Set the universal ground coordinate (calls SetGround)
      bool SetUniversalGround(const double lat, const double lon);
      // Return the universal ground coordinate after successful SetCoordinate
      double UniversalLatitude();
      double UniversalLongitude();
      // Set world position (calls SetCoordinate on projected x/y)
      bool SetWorld(const double x, const double y);
      // Get computed world X/Y after successful SetGround
      double WorldX() const;
      double WorldY() const;
      // convert from projected coordinate to world coordinate
      double ToWorldX(const double projectionX) const;
      double ToWorldY(const double projectionY) const;
      // convert from world coordinate to projected coordinate
      double ToProjectionX(const double worldX) const;
      double ToProjectionY(const double worldY) const;
      // get resolution and scale for mapping world coordinates
      double Resolution() const;
      double Scale() const;

      // Return the x/y range which covers the lat/lon range in the labels
      virtual bool XYRange(double &minX, double &maxX,
                           double &minY, double &maxY);

      // set UpperLeftCornerX and UpperLeftCornerY in mapping group
      void SetUpperLeftCorner(const Displacement &x, const Displacement &y);

      // get mapping information
      virtual PvlGroup Mapping();
      virtual PvlGroup MappingLatitudes();
      virtual PvlGroup MappingLongitudes();

      // Static conversion methods
      static PvlGroup TargetRadii(QString target);
      static PvlGroup TargetRadii(Pvl &cubeLab, PvlGroup &mapGroup);
      static double ToHours(double angle);
      static QString ToDMS(double angle);
      static QString ToHMS(double angle);
      // change latitude type
      static double ToPlanetocentric(double lat,
                                     double eRadius, double pRadius);
      static double ToPlanetographic(double lat,
                                     double eRadius, double pRadius);
      // change longitude direction
      static double ToPositiveEast(const double lon, const int domain);
      static double ToPositiveWest(const double lon, const int domain);
      // change longitude domain
      static double To180Domain(const double lon);
      static double To360Domain(const double lon);

    protected:
      void XYRangeCheck(const double latitude, const double longitude);
      bool xyRangeOblique(double &minX, double &maxX,
                          double &minY, double &maxY);
      void SetXY(double x, double y);
      void SetComputedXY(double x, double y);
      double GetX() const;
      double GetY() const;

      // Convience methods for typical projection computations from Snyder
      double qCompute(const double sinPhi) const; // page 16
      double phi2Compute(const double t) const; // page 44
      double mCompute(const double sinphi, const double cosphi) const; // page 101
      double tCompute(const double phi, const double sinphi) const; //page 108
      double e4Compute() const; // page 161

    private:
      void doSearch(double minBorder, double maxBorder,
                    double &extremeVal, const double constBorder,
                    bool searchX, bool searchLongitude, bool findMin);
      void findExtreme(double &minBorder,  double &maxBorder,
                       double &minBorderX, double &minBorderY,
                       double &maxBorderX, double &maxBorderY,
                       const double constBorder, bool searchX,
                       bool searchLongitude, bool findMin);
      void setSearchGround(const double variableBorder,
                           const double constBorder, bool variableIsLat);

    protected:
      WorldMapper *m_mapper;  
      double m_latitude;   
      double m_longitude;  
      bool m_good;         
      LatitudeType m_latitudeType; 
      LongitudeDirection m_longitudeDirection; 
      int m_longitudeDomain; 
      double m_equatorialRadius;  
      double m_polarRadius;       
      double m_eccentricity;      
      bool m_sky;                 
      bool m_groundRangeGood;     
      double m_minimumLatitude;   
      double m_maximumLatitude;   
      double m_minimumLongitude;  
      double m_maximumLongitude;  
      // Convience data for XYRange virtual function
      double m_minimumX;  
      double m_maximumX;  
      double m_minimumY;  
      double m_maximumY;  
      PvlGroup m_mappingGrp; 

    private:
      double m_rotation;   

      double m_x;          
      double m_y;          
      // These are necessary for calculating oblique X/Y range with
      // discontinuity
      std::vector<double> m_specialLatCases; 
      std::vector<double> m_specialLonCases; 
      double m_pixelResolution; 
  };
};
#endif