ControlNetValidMeasure.h

Go to the documentation of this file.

#ifndef _ControlNetValidMeasure_h_
#define _ControlNetValidMeasure_h_

#include "CubeManager.h"
#include "IString.h"
#include "Pvl.h"
#include "PvlGroup.h"
#include "Progress.h"
#include "SerialNumberList.h"

namespace Isis {
  class Camera;
  class Cube;
  class ControlNet;
  class MeasureValidationResults;
  class ControlMeasure;

  class ControlNetValidMeasure {
    public:
      ControlNetValidMeasure(Pvl *pvl = 0);
      ControlNetValidMeasure(Pvl &pvl);

      void InitStdOptions(void);         
      
      void InitStdOptionsGroup(void);    

      virtual ~ControlNetValidMeasure();

      void Parse(Pvl &pvlDef);

      virtual Pvl &GetLogPvl(void) {
        return mPvlLog;
      };

      virtual void FindCnetRef(ControlNet &pNewNet) {};

      bool ValidEmissionAngle(double pdEmissionAngle);
      
      bool ValidIncidenceAngle(double pdIncidenceAngle);
      
      bool ValidDnValue(double pdDnValue);
      
      bool ValidResolution(double pdResolution);
      
      bool ValidResidualTolerances(double pdSampleResidual, double pdLineResidual, 
                     double pdResidualMagnitude, MeasureValidationResults & pResults);

      bool ValidShiftTolerances(double sampleShift, double lineShift,
          double pixelShift, MeasureValidationResults &results);
      
      bool ValidLatLon(Isis::Camera *pCamera, int piSample, int piLine); 

      PvlGroup &GetStdOptions(void) {
        return mStdOptionsGrp;
      };

      PvlGroup &GetStatistics(void) {
        return mStatisticsGrp;
      };

      double GetMinDN(void) {
        return mdMinDN;
      };

      double GetMaxDN(void) {
        return mdMaxDN;
      };

      double GetMinEmissionAngle(void) {
        return mdMinEmissionAngle;
      };

      double GetMaxEmissionAngle(void) {
        return mdMaxEmissionAngle;
      };

      double GetMinIncidenceAngle(void) {
        return mdMinIncidenceAngle;
      };

      double GetMaxIncidenceAngle(void) {
        return mdMaxIncidenceAngle;
      };

      double GetPixelsFromEdge(void) {
        return miPixelsFromEdge;
      };

      double GetMetersFromEdge(void) {
        return mdMetersFromEdge;
      };

      QString LocationString(double pdSample, double pdLine) const {
        return toString((int)pdSample) + "," + toString((int)pdLine);
      };

      bool PixelsFromEdge(int piSample, int piLine, Cube *pCube);

      bool MetersFromEdge(int piSample, int piLine, Cube *pCube);

      MeasureValidationResults ValidStandardOptions(const ControlMeasure *pMeasure,
          Cube *pCube, PvlGroup *pMeasureGrp = NULL);

      MeasureValidationResults ValidStandardOptions(const ControlMeasure *pMeasure,
          Cube *pCube, Camera *camera, PvlGroup *pMeasureGrp = NULL);
      
      MeasureValidationResults ValidStandardOptions(double pSample, double pLine, 
          const ControlMeasure *pMeasure, Cube *pCube, PvlGroup *pMeasureGrp = NULL);

      MeasureValidationResults ValidStandardOptions(double pSample, double pLine, 
          const ControlMeasure *pMeasure, Cube *pCube, Camera *measureCamera,
          PvlGroup *pMeasureGrp = NULL);
      
      MeasureValidationResults ValidStandardOptions(double pSample, double pLine, 
                                          Cube *pCube, PvlGroup *pMeasureGrp = NULL);

      bool IsCubeRequired() {
        return IsCameraRequired() || mbValidateDN || mbValidateFromEdge;
      }

      bool IsCameraRequired() {
        return mbCameraRequired;
      }

    protected:
      void ValidatePvlDN(void);
      
      void ValidatePvlEmissionAngle(void);
      
      void ValidatePvlIncidenceAngle(void);
      
      void ValidatePvlResolution(void);
      
      void ValidatePvlFromEdge(void);
      
      void ValidatePvlResidualTolerances(void);

      void ValidatePvlShiftTolerances();
      
      void ReadSerialNumbers(QString psSerialNumfile);
      
      void SetCameraRequiredFlag(bool pbFlag){
        mbCameraRequired = pbFlag;
      }
      
      double mdMinDN;                  
      double mdMaxDN;                  
      double mdMinResolution;          
      double mdMaxResolution;          
      double mdMinEmissionAngle;       
      double mdMaxEmissionAngle;       
      double mdMinIncidenceAngle;      
      double mdMaxIncidenceAngle;      
      double mdMetersFromEdge;         
      int miPixelsFromEdge;            
      double mdSampleResTolerance;     
      double mdLineResTolerance;       
      double mdResidualTolerance;      

      double m_sampleShiftTolerance;   
      double m_lineShiftTolerance;     
      double m_pixelShiftTolerance;    

      double mdEmissionAngle;          
      double mdIncidenceAngle;         
      double mdResolution;             
      double mdDnValue;                
      double mdSampleResidual;         
      double mdLineResidual;           
      double mdResidualMagnitude;      

      double m_sampleShift;            
      double m_lineShift;              
      double m_pixelShift;             

      PvlGroup mPvlOpGrp;              
      PvlGroup mStdOptionsGrp;         
      PvlGroup mStatisticsGrp;         
      Pvl mPvlLog;                     
      Progress mStatus;                
      CubeManager mCubeMgr;            
      SerialNumberList mSerialNumbers; 

      bool mbCameraRequired;           

      bool mbValidateDN;               
      bool mbValidateFromEdge;         
  };
};
#endif