Camera.h

Go to the documentation of this file.

#ifndef Camera_h
#define Camera_h

#include "Sensor.h"
#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(Pvl &lab);

      // destructor
      virtual ~Camera();

      // Methods
      bool SetImage(const double sample, const double line);
      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 IntersectsLongitudeDomain(Pvl &pvl);

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

      virtual double resolution();
      double LowestImageResolution();
      double HighestImageResolution();

      void BasicMapping(Pvl &map);

      double FocalLength() const;
      double PixelPitch() const;
      int Samples() const;
      int Lines() const;
      int Bands() const;
      int ParentLines() const;
      int ParentSamples() const;

      bool RaDecRange(double &minra, double &maxra,
                      double &mindec, double &maxdec);
      double RaDecResolution();

      CameraDistortionMap *DistortionMap();
      CameraFocalPlaneMap *FocalPlaneMap();
      CameraDetectorMap *DetectorMap();
      CameraGroundMap *GroundMap();
      CameraSkyMap *SkyMap();

      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;
      
      
    private:
      double p_focalLength;                  
      double p_pixelPitch;                   

      void GroundRangeResolution();
      double p_minlat;                       
      double p_maxlat;                       
      double p_minlon;                       
      double p_maxlon;                       
      double p_minres;                       
      double p_maxres;                       
      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;             
      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;                

      double ComputeAzimuth(Distance radius,
                            const double lat, const double lon);

      bool RawFocalPlanetoImage();

      int p_geometricTilingStartSize; 
      int p_geometricTilingEndSize;   
  };
};

#endif