Camera.h

#ifndef Camera_h
#define Camera_h
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "Sensor.h"
 
#include <QList>
#include <QPointF>
#include <QString>
 
#include "AlphaCube.h"
 
namespace Isis {
  class Angle;
  class CameraDetectorMap;
  class CameraFocalPlaneMap;
  class CameraDistortionMap;
  class CameraGroundMap;
  class CameraSkyMap;
  class Distance;
  class Latitude;
  class Longitude;
  class Projection;
  class SurfacePoint;
 
  class Camera : public Sensor {
    public:
      // constructors
      Camera(Cube &cube);
 
      // destructor
      virtual ~Camera();
 
      // Methods
      virtual bool SetImage(const double sample, const double line);
      virtual bool SetImage(const double sample, const double line, const double deltaT);
 
      virtual bool SetUniversalGround(const double latitude, const double longitude);
      virtual bool SetUniversalGround(const double latitude, const double longitude,
                                      const double radius);
      virtual bool SetGround(Latitude latitude, Longitude longitude);
      virtual bool SetGround(const SurfacePoint & surfacePt);
      virtual bool SetRightAscensionDeclination(const double ra, const double dec);
 
      void LocalPhotometricAngles(Angle & phase, Angle & incidence,
                                  Angle & emission, bool &success);
      void Slope(double &slope, bool &success);
 
      void GetLocalNormal(double normal[3]);
 
      bool HasProjection();
      virtual bool IsBandIndependent();
      int ReferenceBand() const;
      bool HasReferenceBand() const;
      virtual void SetBand(const int band);
      virtual double Sample() const;
      virtual int Band() const;
      virtual double Line() const;
 
      bool GroundRange(double &minlat, double &maxlat, double &minlon,
                       double &maxlon, Pvl &pvl);
      bool ringRange(double &minRingRadius, double &maxRingRadius,
                     double &minRingLongitude, double &maxRingLongitude, Pvl &pvl);
      bool IntersectsLongitudeDomain(Pvl &pvl);
 
      virtual double PixelResolution();
      virtual double LineResolution();
      virtual double SampleResolution();
      virtual double DetectorResolution();
 
      virtual double ObliqueDetectorResolution(bool useLocal = true);
      virtual double ObliqueSampleResolution(bool useLocal = true);
      virtual double ObliqueLineResolution(bool useLocal = true);
      virtual double ObliquePixelResolution(bool useLocal = true);
 
 
      virtual double resolution();
      double LowestImageResolution();
      double HighestImageResolution();
      double LowestObliqueImageResolution();
      double HighestObliqueImageResolution();
 
      void BasicMapping(Pvl &map);
      void basicRingMapping(Pvl &map);
 
      double FocalLength() const;
      double PixelPitch() const;
      virtual double exposureDuration() const;
      virtual double exposureDuration(const double sample,
                                      const double line,
                                      const int band = -1) const;
      virtual QList<QPointF> PixelIfovOffsets();
 
      int Samples() const;
      int Lines() const;
      int Bands() const;
      int ParentLines() const;
      int ParentSamples() const;
 
      double CelestialNorthClockAngle();
 
      bool RaDecRange(double &minra, double &maxra,
                      double &mindec, double &maxdec);
      double RaDecResolution();
 
      CameraDistortionMap *DistortionMap();
      CameraFocalPlaneMap *FocalPlaneMap();
      CameraDetectorMap *DetectorMap();
      CameraGroundMap *GroundMap();
      CameraSkyMap *SkyMap();
 
      QString instrumentId();
 
      QString instrumentNameLong() const;
      QString instrumentNameShort() const;
      QString spacecraftNameLong() const;
      QString spacecraftNameShort() const;
 
      void SetDistortionMap(CameraDistortionMap *map, bool deleteExisting = true);
      void SetFocalPlaneMap(CameraFocalPlaneMap *map);
      void SetDetectorMap(CameraDetectorMap *map);
      void SetGroundMap(CameraGroundMap *map);
      void SetSkyMap(CameraSkyMap *map);
 
      double NorthAzimuth();
      double SunAzimuth();
      double SpacecraftAzimuth();
      double OffNadirAngle();
 
      static double GroundAzimuth(double glat, double glon, double slat,
                                  double slon);
 
      void IgnoreProjection(bool ignore);
 
      void LoadCache();
      std::pair< double, double > StartEndEphemerisTimes();
      int CacheSize(double startTime, double endTime);
 
 
      void GetGeometricTilingHint(int &startSize, int &endSize);
 
      bool InCube();
 
      enum CameraType {
        Framing,        
        PushFrame,      
        LineScan,       
        Radar,          
        Point,          
        RollingShutter, 
        Csm             
      };
 
      virtual CameraType GetCameraType() const = 0;
 
      virtual int CkFrameId() const = 0;
 
      virtual int CkReferenceId() const = 0;
 
      virtual int SpkReferenceId() const = 0;
      virtual int SpkTargetId() const;
      virtual int SpkCenterId() const;
 
 
    protected:
 
      void SetFocalLength(double v);
      void SetPixelPitch(double v);
 
      void SetFocalLength();
      void SetPixelPitch();
 
      void SetGeometricTilingHint(int startSize = 128, int endSize = 8);
 
      // These 2 classes need to be friends of the Camera class because
      // of the way Radar works - there is no set focal length for the
      // instrument, so the focal length needs to be set each time the
      // slant range changes.
      friend class RadarGroundMap;      
      friend class RadarSlantRangeMap;  
 
      QString m_instrumentId;        
 
      QString m_instrumentNameLong;  
      QString m_instrumentNameShort; 
      QString m_spacecraftNameLong;  
      QString m_spacecraftNameShort; 
 
      double p_childSample;                  
      double p_childLine;                    
      AlphaCube *p_alphaCube;                
 
      bool p_pointComputed;                  
 
    private:
      void GroundRangeResolution();
      void ringRangeResolution();
      double ComputeAzimuth(const double lat, const double lon);
      bool RawFocalPlanetoImage();
      // SetImage helper functions:
      // bool SetImageNoProjection(const double sample, const double line);
      bool SetImageMapProjection(const double sample, const double line, ShapeModel *shape);
      bool SetImageSkyMapProjection(const double sample, const double line, ShapeModel *shape);
 
 
      double p_focalLength;                  
      double p_pixelPitch;                   
 
      double p_minlat;                       
      double p_maxlat;                       
      double p_minlon;                       
      double p_maxlon;                       
      double p_minres;                       
      double p_maxres;                       
      double p_minobliqueres;                
      double p_maxobliqueres;                
      double p_minlon180;                    
      double p_maxlon180;                    
      bool p_groundRangeComputed;
 
 
      int p_samples;                         
      int p_lines;                           
      int p_bands;                           
 
      int p_referenceBand;                   
 
      Projection *p_projection;              
      bool p_ignoreProjection;               
 
      double p_mindec;                       
      double p_maxdec;                       
      double p_minra;                        
      double p_maxra;                        
      double p_minra180;                     
      double p_maxra180;                     
      bool p_raDecRangeComputed;
 
      double p_minRingRadius;                
      double p_maxRingRadius;                
      double p_minRingLongitude;             
      double p_maxRingLongitude;             
      double p_minRingLongitude180;          
      double p_maxRingLongitude180;          
      bool p_ringRangeComputed;
 
 
      int p_childBand;                       
      CameraDistortionMap *p_distortionMap;  
      CameraFocalPlaneMap *p_focalPlaneMap;  
      CameraDetectorMap *p_detectorMap;      
      CameraGroundMap *p_groundMap;          
      CameraSkyMap *p_skyMap;                
 
      int p_geometricTilingStartSize;
      int p_geometricTilingEndSize;
 
  };
};
 
#endif