CameraGroundMap.h

#ifndef CameraGroundMap_h
#define CameraGroundMap_h
 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "Camera.h"
#include "CameraDistortionMap.h"
#include "SpicePosition.h"
#include "SurfacePoint.h"
 
namespace Isis {
  class CameraGroundMap {
    public:
      CameraGroundMap(Camera *parent);
 
      virtual ~CameraGroundMap() {};
 
      virtual bool SetFocalPlane(const double ux, const double uy,
                                 const double uz);
 
      enum PartialType {
        WRT_Latitude,
        WRT_Longitude,
        WRT_Radius,
        WRT_MajorAxis,
        WRT_MinorAxis,
        WRT_PolarAxis
      };
 
      virtual bool SetGround(const Latitude &lat, const Longitude &lon);
      virtual bool SetGround(const SurfacePoint &surfacePoint);
      virtual bool GetXY(const SurfacePoint &spoint, double *cudx, 
                       double *cudy, bool test=true);
      virtual bool GetXY(const double lat, const double lon,
                         const double radius, double *cudx, double *cudy);
      virtual bool GetdXYdPosition(const SpicePosition::PartialType varType,
                                   int coefIndex,
                                   double *cudx, double *cudy);
      virtual bool GetdXYdOrientation(const SpiceRotation::PartialType varType,
                                      int coefIndex,
                                      double *cudx, double *cudy);
      virtual bool GetdXYdTOrientation(const SpiceRotation::PartialType varType,
                                       int coefIndex,
                                       double *cudx, double *cudy);
      virtual bool GetdXYdPoint(std::vector<double> d_pB,
                                double *dx, double *dy);
      std::vector<double> PointPartial(SurfacePoint spoint, PartialType wrt);
      std::vector<double> EllipsoidPartial(SurfacePoint spoint, PartialType raxis);
      std::vector<double> MeanRadiusPartial(SurfacePoint spoint, Distance meanRadius);
      double DQuotient(std::vector<double> &look, std::vector<double> &dlook,
                       int index);
 
      inline double FocalPlaneX() const {
        return p_focalPlaneX;
      };
 
      inline double FocalPlaneY() const {
        return p_focalPlaneY;
      };
 
    protected:
      Camera *p_camera;     
      double p_focalPlaneX; 
      double p_focalPlaneY; 
 
      void LookCtoFocalPlaneXY();  
      std::vector<double> m_pB;
      std::vector<double> m_lookJ;
  };
};
#endif