Camera.h

Go to the documentation of this file.

#ifndef Camera_h
#define Camera_h

#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
      bool SetImage(const double sample, const double line);
      virtual bool SetImage(const double sample, const double line, const double deltaT); 

      bool SetUniversalGround(const double latitude, const double longitude);
      bool SetUniversalGround(const double latitude, const double longitude,
                              const double radius);
      bool SetGround(Latitude latitude, Longitude longitude);
      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);
      double Sample();
      int Band();
      double Line();

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

      double PixelResolution();
      double LineResolution();
      double SampleResolution();
      double DetectorResolution();

      double ObliqueDetectorResolution();
      double ObliqueSampleResolution();
      double ObliqueLineResolution();
      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 instrumentNameLong() const;
      QString instrumentNameShort() const;
      QString spacecraftNameLong() const;
      QString spacecraftNameShort() const;

      void SetDistortionMap(CameraDistortionMap *map);
      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       
      };

      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_instrumentNameLong;  
      QString m_instrumentNameShort; 
      QString m_spacecraftNameLong;  
      QString m_spacecraftNameShort; 


    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;            
      bool p_pointComputed;                  

      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;              
      AlphaCube *p_alphaCube;                
      double p_childSample;                  
      double p_childLine;                    
      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