RadarGroundMap.h

#ifndef RadarGroundMap_h
#define RadarGroundMap_h
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "Camera.h"
#include "CameraGroundMap.h"
#include "SurfacePoint.h"
 
namespace Isis {
 
#ifndef RADAR_LOOK_DIR
  namespace Radar {
    enum LookDirection { Left, Right };
  }
#define RADAR_LOOK_DIR
#endif
 
  class RadarGroundMap : public CameraGroundMap {
    public:
      RadarGroundMap(Camera *parent, Radar::LookDirection ldir, double waveLength);
 
      virtual ~RadarGroundMap() {};
 
      virtual bool SetFocalPlane(const double ux, const double uy,
                                 const double uz);
      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=false);
      virtual bool GetdXYdPosition(const SpicePosition::PartialType varType,
                                   int coefIndex, double *cudx, double *cudy);
      virtual bool GetdXYdPoint(std::vector<double> d_lookB, double *dx,
                                double *dy);
 
      void SetRangeSigma(double rangeSigma) {
        p_rangeSigma = rangeSigma;
      };
 
      double RangeSigma() {
        return p_rangeSigma;
      };
 
      void SetDopplerSigma(double dopplerSigma) {
        p_dopplerSigma = dopplerSigma;
      };
 
      double YScale() {
        return p_dopplerSigma;
      };
 
      double WaveLength() {
        return p_waveLength;
      };
 
    private:
      double ComputeXv(SpiceDouble X[3]);
      double GetRadius(const Latitude &lat, const Longitude &lon);
 
      bool Iterate(SpiceDouble &R, const double &slantRangeSqr, const SpiceDouble c[],
                   const SpiceDouble r[], SpiceDouble X[], SpiceDouble &lat,
                   SpiceDouble &lon, const std::vector<double> &Xsc, const bool &useSlopeEqn,
                   const double &slope);
 
      Radar::LookDirection p_lookDirection;
      double p_tolerance;
      double p_slantRange;         
      double p_dopplerFreq;        
      double p_timeTolerance;
      double p_rangeSigma;         
      double p_dopplerSigma;       
      double p_waveLength;         // km/sec/hertz ??
      std::vector<double> p_lookB;
      std::vector<double> p_sB;
      //std::vector<double> p_Xsc(3); //!< body fixed position
      double p_groundSlantRange;   
      double p_groundDopplerFreq;  
 
      Camera *p_camera;
  };
};
#endif