PushFrameCameraDetectorMap.h

Go to the documentation of this file.

#ifndef PushFrameCameraDetectorMap_h
#define PushFrameCameraDetectorMap_h

#include "CameraDetectorMap.h"

namespace Isis {
  class PushFrameCameraDetectorMap : public CameraDetectorMap {
    public:
      PushFrameCameraDetectorMap(Camera *parent, const double etStart,
                                 const double frameletRate, int frameletHeight) :
        CameraDetectorMap(parent) {
        p_etStart = etStart;
        p_exposureDuration = 0.0;
        p_frameletRate = frameletRate;
        p_frameletHeight = frameletHeight;
        p_frameletOffset = 0;
        p_flippedFramelets = true;
        p_timeAscendingFramelets = true;
        p_nframelets = 0;
        p_bandStartDetector = 0;
      }

      virtual ~PushFrameCameraDetectorMap() {};

      void SetStartTime(const double etStart) {
        p_etStart = etStart;
      };


      void SetExposureDuration(double exposureDuration) {
        p_exposureDuration = exposureDuration;
      }


      void SetFrameletRate(const double frameletRate) {
        p_frameletRate = frameletRate;
      };

      double FrameletRate() const {
        return p_frameletRate;
      };

      void SetFrameletOffset(int frameletOffset) {
        p_frameletOffset = frameletOffset;
      };

      int FrameletOffset() const {
        return p_frameletOffset;
      };

      virtual bool SetParent(const double sample, const double line);

      virtual bool SetDetector(const double sample, const double line);

      void SetFramelet(int framelet);

      int Framelet() {
        return p_framelet;
      }


      void SetBandFirstDetectorLine(int firstLine) {
        p_bandStartDetector = firstLine;
      }

      int GetBandFirstDetectorLine() {
        return p_bandStartDetector;
      }

      void SetFlippedFramelets(bool frameletsFlipped, int nframelets) {
        p_timeAscendingFramelets = !frameletsFlipped;
        p_nframelets = nframelets;
      }

      void SetGeometricallyFlippedFramelets(bool frameletsFlipped) {
        p_flippedFramelets = frameletsFlipped;
      }

      double StartEphemerisTime() const {
        return p_etStart;
      };

      int TotalFramelets() const {
        return (int)(p_camera->ParentLines() / (p_frameletHeight / LineScaleFactor()));
      };


      double frameletSample() const {
        return p_frameletSample;
      };

      double frameletLine() const {
        return p_frameletLine;
      };

      int frameletHeight() const {
        return p_frameletHeight;
      };

      bool timeAscendingFramelets() {
        return p_timeAscendingFramelets;
      }

    private:
      double p_etStart;      
      double p_exposureDuration; 
      double p_frameletRate;    
      int    p_frameletHeight; 
      int    p_bandStartDetector; 
      int    p_frameletOffset; 
      int    p_framelet;  
      int    p_nframelets; 

      double p_frameletSample; 
      double p_frameletLine; 

      bool   p_flippedFramelets;  
      bool   p_timeAscendingFramelets;  

  };
};
#endif