Object/Developer/_projection_8h_source.html

#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