Projection.h

Go to the documentation of this file.

#ifndef Projection_h
#define Projection_h

#include <string>
#include "Pvl.h"
#include "WorldMapper.h"

namespace Isis {
  class Displacement;

  class Projection {
    public:
      // constructor
      Projection(Isis::Pvl &label);

      virtual ~Projection() {
        if(p_mapper) delete p_mapper;
      };

      void SetWorldMapper(Isis::WorldMapper *mapper) {
        p_mapper = mapper;
      };

      // Set world position
      bool SetWorld(const double x, const double y);

      // Set ground position
      virtual bool SetGround(const double lat, const double lon);

      // Set x/y coordinate
      virtual bool SetCoordinate(const double x, const double y);

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

      inline bool IsGood() const {
        return p_good;
      };

      // Return computed world X/Y after successful SetGround
      double WorldX() const;
      double WorldY() const;

      inline double Longitude() const {
        return p_longitude;
      };

      inline double Latitude() const {
        return p_latitude;
      };

      inline double XCoord() const {
        return p_x;
      };


      inline double YCoord() const {
        return p_y;
      };

      inline double EquatorialRadius() const {
        return p_equatorialRadius;
      };

      inline double PolarRadius() const {
        return p_polarRadius;
      };


      inline double Eccentricity() const {
        return p_eccentricity;
      };

      // Obtain latitude type
      enum LatitudeType { Planetographic, Planetocentric };

      inline bool IsPlanetographic() const {
        return p_latitudeType == Planetographic;
      };


      inline bool IsPlanetocentric() const {
        return p_latitudeType == Planetocentric;
      };

      // Obtain latitude type as a string
      std::string LatitudeTypeString() const;

      // Obtain longitude directions as a string
      std::string LongitudeDirectionString() const;

      // Obtain longitude domain as a string
      std::string LongitudeDomainString() const;

      // Obtain longitude direction
      enum LongitudeDirection { PositiveEast, PositiveWest };

      inline bool IsPositiveWest() const {
        return p_longitudeDirection == PositiveWest;
      };

      inline bool IsPositiveEast() const {
        return p_longitudeDirection == PositiveEast;
      };

      inline bool Has360Domain() const {
        return p_longitudeDomain == 360;
      };


      inline bool Has180Domain() const {
        return p_longitudeDomain == 180;
      };

      inline bool HasGroundRange() const {
        return p_groundRangeGood;
      };

      inline double MinimumLatitude() const {
        return p_minimumLatitude;
      };

      inline double MaximumLatitude() const {
        return p_maximumLatitude;
      };

      inline double MinimumLongitude() const {
        return p_minimumLongitude;
      };

      inline double MaximumLongitude() const {
        return p_maximumLongitude;
      };

      // 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);


      inline double Rotation() const {
        return p_rotation;
      };

      // Return the universal ground coordinate after successful SetCoordinate
      double UniversalLatitude();
      double UniversalLongitude();

      // Set the universal ground coordinate
      bool SetUniversalGround(const double lat, const double lon);

      // Convert latitude value from Planetographic to Planetocentric and vice versa
      double ToPlanetocentric(const double lat) const;
      double ToPlanetographic(const double lat) const;

      // Convert longitude value from (0:360) to (-180:180) or vice versa
      static double To360Domain(const double lon);
      static double To180Domain(const double lon);

      // Convert longitude value from positive east to positive west or vice verse
      static double ToPositiveEast(const double lon, const int domain);
      static double ToPositiveWest(const double lon, const int domain);

      double ToWorldX(const double projectionX) const;
      double ToWorldY(const double projectionY) const;
      double ToProjectionX(const double worldX) const;
      double ToProjectionY(const double worldY) const;
      double Resolution() const;
      double Scale() const;
      virtual double TrueScaleLatitude() const;
      virtual PvlGroup Mapping();
      virtual PvlGroup MappingLatitudes();
      virtual PvlGroup MappingLongitudes();

      virtual bool operator== (const Projection &proj);
      bool operator!= (const Projection &proj);

      virtual bool IsEquatorialCylindrical() {
        return false;
      }

      virtual std::string Name() const = 0;
      virtual std::string Version() const = 0;

      double LocalRadius() const;
      double LocalRadius(double lat) const;

      bool IsSky() const {
        return p_sky;
      };

      // Static conversion methods
      static double ToHours(double angle);
      static std::string ToDMS(double angle);
      static std::string ToHMS(double angle);
      static double ToPlanetographic(double lat,
                                     double eRadius, double pRadius);
      static double ToPlanetocentric(double lat,
                                     double eRadius, double pRadius);
      static PvlGroup TargetRadii(std::string target);
      static PvlGroup TargetRadii(Pvl &cubeLab, PvlGroup &mapGroup);

    protected:
      Isis::WorldMapper *p_mapper;  
      double p_latitude;   
      double p_longitude;  
      bool p_good;         
      LatitudeType p_latitudeType;             
      LongitudeDirection p_longitudeDirection; 
      int p_longitudeDomain;                   
      double p_equatorialRadius;  
      double p_polarRadius;       
      double p_eccentricity;      
      bool p_sky;                 

      bool p_groundRangeGood;     
      double p_minimumLatitude;   
      double p_maximumLatitude;   
      double p_minimumLongitude;  
      double p_maximumLongitude;  
      // Convience data/methods for XYRange virtual function
      double p_minimumX;  
      double p_maximumX;  
      double p_minimumY;  
      double p_maximumY;  
      PvlGroup p_mappingGrp; 
      void XYRangeCheck(const double latitude, const double longitude);

      // Convience methods for typical projection computations
      double mCompute(const double sinphi, const double cosphi) const;
      double e4Compute() const;
      double tCompute(const double phi, const double sinphi) const;
      double phi2Compute(const double t) const;

      void SetXY(double x, double y);
      void SetComputedXY(double x, double y);
      double GetX() const;
      double GetY() const;

    private:
      double p_rotation;   

      double p_x;          
      double p_y;          
  };
};

#endif