TProjection.h

#ifndef TProjection_h
#define TProjection_h
 
/* SPDX-License-Identifier: CC0-1.0 */
#include <vector>
 
#include "Projection.h"  
#include "PvlGroup.h" // protected data member object (m_mappingGrp) 
 
namespace Isis {
  class Displacement;
  class Pvl;
  class WorldMapper;
  class TProjection : public Projection {
    public:
      // constructor
      TProjection(Pvl &label);
      virtual ~TProjection();
      virtual bool operator== (const Projection &proj);
 
      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;
 
      // Get min/max lat/lon
      virtual double MinimumLatitude() const;
      virtual double MaximumLatitude() const;
      virtual double MinimumLongitude() const;
      virtual double MaximumLongitude() const;
 
      //  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);
 
      // Methods that depend on successful completion
      // of SetGround/SetCoordinate Get lat,lon, x,y
      virtual double Latitude() const;
      virtual double Longitude() const;
 
      // Set the universal ground coordinate (calls SetGround)
      virtual bool SetUniversalGround(const double lat, const double lon);
      bool SetUnboundUniversalGround(const double coord1, const double coord2);
 
      // Return the universal ground coordinate after successful SetCoordinate
      virtual double UniversalLatitude();
      virtual double UniversalLongitude();
 
      // get scale for mapping world coordinates
      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);
 
      // get mapping information
      virtual PvlGroup Mapping();
      virtual PvlGroup MappingLatitudes();
      virtual PvlGroup MappingLongitudes();
 
      // 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 inLongitudeRange(double longitude);
      bool inLongitudeRange(double minLon, double maxLon, double longitude);
      bool inLatitudeRange(double latitude);
      bool xyRangeOblique(double &minX, double &maxX, 
                          double &minY, double &maxY);
 
      // 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:
      double m_latitude;   
      double m_longitude;  
 
      LatitudeType m_latitudeType; 
 
      LongitudeDirection m_longitudeDirection; 
 
      // TODO** Can this be generalized for both longitude and azimuth???
      int m_longitudeDomain; 
 
      double m_equatorialRadius;  
      double m_polarRadius;       
 
      double m_eccentricity;      
 
      double m_minimumLatitude;   
      double m_maximumLatitude;   
      double m_minimumLongitude;  
      double m_maximumLongitude;  
    private:
      // These are necessary for calculating oblique X/Y range with 
      // discontinuity
      std::vector<double> m_specialLatCases; 
      std::vector<double> m_specialLonCases; 
  };
};
#endif