ControlNetValidMeasure.h

#ifndef _ControlNetValidMeasure_h_
#define _ControlNetValidMeasure_h_
 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "CubeManager.h"
#include "IString.h"
#include "Pvl.h"
#include "PvlGroup.h"
#include "Progress.h"
#include "SerialNumberList.h"
 
/* SPDX-License-Identifier: CC0-1.0 */
 
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