Isis 3.0 Object Programmers' Reference

Home

---

AutoReg.h

Go to the documentation of this file.

#if !defined(AutoReg_h)
#define AutoReg_h

#include <string>
#include <vector>

#include "Statistics.h"
#include "Chip.h"
//#include "AutoRegItem.h"

namespace Isis {
  class Pvl;
  class AutoRegItem;

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

      virtual ~AutoReg();

      enum RegisterStatus{
        Success, 
        PatternChipNotEnoughValidData, 
        FitChipNoData, 
        FitChipToleranceNotMet, 
        SurfaceModelNotEnoughValidData, 
        SurfaceModelSolutionInvalid, 
        SurfaceModelDistanceInvalid, 
        PatternZScoreNotMet, 
        SurfaceModelEccentricityRatioNotMet, 
        AdaptiveAlgorithmFailed  
      };

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

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

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

      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 SetTolerance(double tolerance);
      void SetSurfaceModelWindowSize (int size);
      void SetSurfaceModelDistanceTolerance (double distance);
      void SetReductionFactor (int reductionFactor);
      void SetPatternZScoreMinimum(double minimum);
      void SetSurfaceModelEccentricityRatio(double ratioTolerance);

      double PatternValidPercent() const { return p_patternValidPercent; };

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

      AutoReg::RegisterStatus Register();

      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; };

      void ZScores(double &score1, double &score2) const {
        score1=p_ZScore1;
        score2=p_ZScore2;
      }

      Pvl RegistrationStatistics();

      virtual bool IsAdaptive() { return false; }

      virtual std::string AlgorithmName() const = 0;

      PvlGroup RegTemplate();

    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 AdaptiveRegistration(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 ModelSurface(std::vector<double> &x, std::vector<double> &y,
                       std::vector<double> &z);
      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:
      AutoReg (const AutoReg &original){};
      void Match(Chip &sChip, Chip &pChip, Chip &fChip, int ss, int es, int sl, int el);
      bool ComputeChipZScore(Chip &chip);
      void Init();

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

      bool p_subpixelAccuracy;

      //TODO: remove these after control points are refactored.
      int p_Total;
      int p_Success;
      int p_PatternChipNotEnoughValidData;
      int p_PatternZScoreNotMet;
      int p_FitChipNoData;
      int p_FitChipToleranceNotMet;
      int p_SurfaceModelNotEnoughValidData;
      int p_SurfaceModelSolutionInvalid;
      int p_SurfaceModelDistanceInvalid;
      int p_SurfaceModelEccentricityRatioNotMet;

      double p_ZScore1;
      double p_ZScore2;

      double p_minimumPatternZScore;
      double p_patternValidPercent;

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

      int p_windowSize;
      double p_distanceTolerance;

      double p_surfaceModelEccentricityTolerance;
      double p_surfaceModelEccentricity;
      double p_bestFit;
      int p_bestSamp;
      int p_bestLine;
      int p_reduceFactor;
      Isis::AutoReg::RegisterStatus p_status;

  };
};

#endif