AutoReg.h

Go to the documentation of this file.

#ifndef AutoReg_h
#define AutoReg_h

#include <vector>

#include "Chip.h"
#include "Statistics.h"

class QString;

namespace Isis {
  class AutoRegItem;
  class Buffer;
  class Pvl;

  class AutoReg {
    public:
      AutoReg(Pvl &pvl);

      virtual ~AutoReg();

      enum RegisterStatus {
        SuccessPixel,                        
        SuccessSubPixel,                     
        PatternChipNotEnoughValidData,       
        FitChipNoData,                       
        FitChipToleranceNotMet,              
        SurfaceModelNotEnoughValidData,      
        SurfaceModelSolutionInvalid,         
        SurfaceModelDistanceInvalid,         
        PatternZScoreNotMet,                 
        AdaptiveAlgorithmFailed              
      };

      enum GradientFilterType {
        None,   
        Sobel   
      };

      inline Chip *PatternChip() {
        return &p_patternChip;
      };

      inline Chip *SearchChip() {
        return &p_searchChip;
      };

      inline Chip *FitChip() {
        return &p_fitChip;
      };

      inline Chip *RegistrationPatternChip() {
        if (p_gradientFilterType == None) {
          return &p_patternChip;
        }
        else {
          return &p_gradientPatternChip;
        }
      };

      inline Chip *RegistrationSearchChip() {
        if (p_gradientFilterType == None) {
          return &p_searchChip;
        }
        else {
          return &p_gradientSearchChip;
        }
      };

      inline Chip *ReducedPatternChip() {
        return &p_reducedPatternChip;
      };

      inline Chip *ReducedSearchChip() {
        return &p_reducedSearchChip;
      };

      inline Chip *ReducedFitChip() {
        return &p_reducedFitChip;
      };

      void SetSubPixelAccuracy(bool on);
      void SetPatternValidPercent(const double percent);
      void SetSubsearchValidPercent(const double percent);
      void SetTolerance(double tolerance);
      void SetChipInterpolator(const QString &interpolator);
      void SetSurfaceModelWindowSize(int size);
      void SetSurfaceModelDistanceTolerance(double distance);
      void SetReductionFactor(int reductionFactor);
      void SetPatternZScoreMinimum(double minimum);
      void SetGradientFilterType(const QString &gradientFilterType);

      QString GradientFilterString() const;

      bool SubPixelAccuracy() {
        return p_subpixelAccuracy;
      }

      int ReductionFactor() {
        return p_reduceFactor;
      }

      double PatternValidPercent() const {
        return p_patternValidPercent;
      };

      double SubsearchValidPercent() const {
        return p_subsearchValidPercent;
      };

      inline double Tolerance() const {
        return p_tolerance;
      };

      double WindowSize() const {
        return p_windowSize;
      };

      double DistanceTolerance() const {
        return p_distanceTolerance;
      };

      void Distance(double &sampDistance, double &lineDistance) {
        sampDistance = p_sampMovement;
        lineDistance = p_lineMovement;
      }

      AutoReg::RegisterStatus Register();

      inline bool Success() const {
        return (p_registrationStatus == SuccessPixel || p_registrationStatus == SuccessSubPixel);
      }

      inline double GoodnessOfFit() const {
        return p_goodnessOfFit;
      };

      inline bool IsIdeal(double fit);

      inline double ChipSample() const {
        return p_chipSample;
      };

      inline double ChipLine() const {
        return p_chipLine;
      };

      inline double CubeSample() const {
        return p_cubeSample;
      };

      inline double CubeLine() const {
        return p_cubeLine;
      };

      double MinimumZScore() const {
        return p_minimumPatternZScore;
      };

      void ZScores(double &score1, double &score2) const {
        score1 = p_zScoreMin;
        score2 = p_zScoreMax;
      }

      Pvl RegistrationStatistics();

      virtual double MostLenientTolerance() {
        return DBL_MIN;
      }

      virtual QString AlgorithmName() const = 0;

      PvlGroup RegTemplate();

      PvlGroup UpdatedTemplate();

    protected:
      inline void SetChipSample(double sample) {
        p_chipSample = sample;
      };

      inline void SetChipLine(double line) {
        p_chipLine = line;
      };

      inline void SetGoodnessOfFit(double fit) {
        p_bestFit = fit;
      };

      virtual AutoReg::RegisterStatus Registration(Chip &sChip, Chip &pChip,
          Chip &fChip, int startSamp, int startLine, int endSamp, int endLine,
          int bestSamp, int bestLine);

      void Parse(Pvl &pvl);
      virtual bool CompareFits(double fit1, double fit2);
      bool SetSubpixelPosition(Chip &window);
      Chip Reduce(Chip &chip, int reductionFactor);

      virtual double IdealFit() const = 0;

      virtual double MatchAlgorithm(Chip &pattern, Chip &subsearch) = 0;

      PvlObject p_template; 

      virtual Pvl AlgorithmStatistics(Pvl &pvl) {
        return (pvl);
      }

    private:
      void Match(Chip &sChip,
                 Chip &pChip,
                 Chip &fChip,
                 int startSamp,
                 int endSamp,
                 int startLine,
                 int endLine);
      bool ComputeChipZScore(Chip &chip);
      void Init();
      void ApplyGradientFilter(Chip &chip);
      void SobelGradient(Buffer &in, double &v);

      Chip p_patternChip;                                  
      Chip p_searchChip;                                   
      Chip p_fitChip;                                      
      Chip p_gradientSearchChip;                           
      Chip p_gradientPatternChip;                          
      Chip p_reducedPatternChip;                           
      Chip p_reducedSearchChip;                            
      Chip p_reducedFitChip;                               

      bool p_subpixelAccuracy;                             

      //TODO: remove these after control points are refactored.
      int p_totalRegistrations;                            
      int p_pixelSuccesses;                                
      int p_subpixelSuccesses;                             
      int p_patternChipNotEnoughValidDataCount;            
      int p_patternZScoreNotMetCount;                      
      int p_fitChipNoDataCount;                            
      int p_fitChipToleranceNotMetCount;                   
      int p_surfaceModelNotEnoughValidDataCount;           
      int p_surfaceModelSolutionInvalidCount;              
      int p_surfaceModelDistanceInvalidCount;              

      double p_zScoreMin;                                  
      double p_zScoreMax;                                  

      double p_minimumPatternZScore;                       
      double p_patternValidPercent;                        
      double p_subsearchValidPercent;                      

      double p_chipSample;                                 
      double p_chipLine;                                   
      double p_cubeSample;                                 
      double p_cubeLine;                                   
      double p_goodnessOfFit;                              
      double p_tolerance;                                  

      int p_windowSize;                                    
      double p_distanceTolerance;                          

      double p_bestFit;                                    
      int p_bestSamp;                                      
      int p_bestLine;                                      
      double p_sampMovement;                               
      double p_lineMovement;                               
      int p_reduceFactor;                                  
      Isis::AutoReg::RegisterStatus p_registrationStatus;  
      AutoReg::GradientFilterType p_gradientFilterType;    
  };
};

#endif