Projection.h

#ifndef Projection_h
#define Projection_h
 
/* SPDX-License-Identifier: CC0-1.0 */
#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);
 
      enum ProjectionType { Triaxial, 
                                RingPlane  
                              };
 
      // These are the accessors for the projection type
      void setProjectionType(const ProjectionType ptype);
      ProjectionType projectionType() const;
 
      // These return properties of the target
      bool IsSky() const;
 
      // These return or change properties of the projection, independent of calculations
      virtual QString Name() const = 0;
 
      // These return properties of the target
      virtual double LocalRadius() const = 0; // requires SetGround or SetCoordinate
 
      virtual QString Version() const = 0;
      virtual bool IsEquatorialCylindrical();
 
      // Check azimuth /longitude domain or get domain as a string
      // TODO** check implementation to see if this can be generalized to
      // work for azimuth and longitude and go in Projection
 
      // 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 or comparable
      virtual bool HasGroundRange() 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) = 0;
      virtual bool SetCoordinate(const double x, const double y) = 0;
      bool IsGood() const;
 
      // Methods that depend on successful completion
      // of SetCoordinate Get x,y
      double XCoord() const;
      double YCoord() const;
 
      // Set the universal ground coordinate (calls SetGround)
      virtual bool SetUniversalGround(const double coord1, const double coord2);
      virtual bool SetUnboundUniversalGround(const double coord1, const double coord2);
 
      // Set world position (calls SetCoordinate on projected x/y)
      virtual bool SetWorld(const double x, const double y);
 
      // Get computed world X/Y after successful SetGround
      virtual double WorldX() const;
      virtual 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;
      virtual double Scale() const = 0;
 
      // 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) = 0;
 
      // set UpperLeftCornerX and UpperLeftCornerY in mapping group
      void SetUpperLeftCorner(const Displacement &x, const Displacement &y);
 
      // get mapping information
      virtual PvlGroup Mapping() = 0;
 
      // Static conversion methods
      static double ToHours(double angle);
      static QString ToDMS(double angle);
      static QString ToHMS(double angle);
 
    protected:
      virtual void XYRangeCheck(const double latitude, const double longitude) = 0;
      //      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;
      double PixelResolution() const;
 
    private:
      // This is currently only used in triaxial projections.  In the future it may be needed by other types
      /*      virtual void doSearch(double minBorder, double maxBorder,
                    double &extremeVal, const double constBorder,
                    bool searchX, bool searchLongitude, bool findMin) = 0;
      virtual void findExtreme(double &minBorder,  double &maxBorder,
                       double &minBorderX, double &minBorderY,
                       double &maxBorderX, double &maxBorderY,
                       const double constBorder, bool searchX,
                       bool searchLongitude, bool findMin) = 0;
      virtual void setSearchGround(const double variableBorder,
                           const double constBorder, bool variableIsLat) = 0;
      */
    protected:
      WorldMapper *m_mapper;  
      bool m_good;         
      // TODO** Can this be generalized for both longitude and azimuth???
      //            int m_longitudeDomain; /**< This integer is either 180 or 360 and is read
      //                                  from the labels. It represents the longitude
      //                                  domain when returning values through Longitude
      //                                  method. The domain is either -180 to 180 or
      //                                  0 to 360.**/
 
      bool m_sky;                 
      bool m_groundRangeGood;     
      // Convenience data for XYRange virtual function
      double m_minimumX;  
      double m_maximumX;  
      double m_minimumY;  
      double m_maximumY;  
      PvlGroup m_mappingGrp; 
 
    private:
      ProjectionType m_projectionType;
      double m_rotation;   
 
      double m_x;          
      double m_y;          
      double m_pixelResolution; 
  };
};
#endif