Object/Programmer/_camera_8h_source.html

#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);

      bool SetRightAscensionDeclination(const double ra, const double dec);


      void LocalPhotometricAngles(Angle & phase, Angle & incidence,

                                  Angle & emission, 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;

      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();

      virtual double ObliqueSampleResolution();

      virtual double ObliqueLineResolution();

      virtual double ObliquePixelResolution();


      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