ProjectionFactory.h

#ifndef ProjectionFactory_h
#define ProjectionFactory_h
/* SPDX-License-Identifier: CC0-1.0 */
#include "Plugin.h"
#include "WorldMapper.h"
 
namespace Isis {
  class Camera;
  class Cube;
  class Projection;
  class RingPlaneProjection;
 
  class ProjectionFactory {
    public:
      static Isis::Projection *Create(Isis::Pvl &label, bool allowDefaults = false);
      static Isis::Projection *RingsCreate(Isis::Pvl &label, bool allowDefaults = false);
      static Isis::Projection *CreateFromCube(Isis::Cube &cube);
      static Isis::Projection *RingsCreateFromCube(Isis::Cube &cube);
      static Isis::Projection *CreateFromCube(Isis::Pvl &label); // Load Method in cm
      static Isis::Projection *RingsCreateFromCube(Isis::Pvl &label); // Load Method in cm
      static Isis::Projection *CreateForCube(Isis::Pvl &label, int &ns, int &nl,
                                             bool sizeMatch = true); // Create method in cm
      static Isis::Projection *RingsCreateForCube(Isis::Pvl &label,
                                                   int &samples, int &lines,
                                                   bool sizeMatch);
      static Isis::Projection *CreateForCube(Isis::Pvl &label,
                                             int &samples, int &lines,
                                             Camera &cam);
      static Isis::Projection *RingsCreateForCube(Isis::Pvl &label,
                                                   int &samples, int &lines,
                                                   Camera &cam);
 
 
    private:
      ProjectionFactory() {};
 
      ~ProjectionFactory() {};
      
      static Plugin m_projPlugin;
  };
 
 
  class PFPixelMapper : public Isis::WorldMapper {
    public:
      PFPixelMapper(double pixelResolution, double upperLeftX, double upperLeftY) {
        p_pixelResolution = pixelResolution;
        p_upperLeftX = upperLeftX;
        p_upperLeftY = upperLeftY;
      };
 
      double WorldX(const double projX) const {
        return (projX - p_upperLeftX) / p_pixelResolution + 0.5;
      };
 
      double WorldY(const double projY) const {
        return (p_upperLeftY - projY) / p_pixelResolution + 0.5;
      };
 
      double ProjectionX(const double sample) const {
        return (sample - 0.5) * p_pixelResolution + p_upperLeftX;
      };
 
      double ProjectionY(const double line) const {
        return p_upperLeftY - (line - 0.5) * p_pixelResolution;
      };
 
      double Resolution() const {
        return p_pixelResolution;
      }
 
    private:
      double p_pixelResolution;
      double p_upperLeftX;
      double p_upperLeftY;
  };
};
 
#endif