InterestOperator.h

Go to the documentation of this file.

#ifndef InterestOperator_h
#define InterestOperator_h

#include <string>
#include <vector>
#include "PvlGroup.h"
#include "Camera.h"
#include "UniversalGroundMap.h"
#include "ControlNetValidMeasure.h"
#include "ImageOverlapSet.h"

#include "geos/geom/Point.h"
#include "geos/geom/Coordinate.h"
#include "geos/geom/MultiPolygon.h"
#include "geos/util/GEOSException.h"

namespace Isis {
  class Chip;
  class Pvl;
  class Cube;
  class PvlObject;
  class ControlNet;
  class ControlPoint;
  class ControlMeasure;

  class InterestOperator : public ControlNetValidMeasure {
    public:
      InterestOperator(Pvl &pPvl);
      
      virtual ~InterestOperator();
      
      void InitInterestOptions();

      void SetPatternValidPercent(const double percent);
      void SetPatternSampling(const double percent);
      void SetSearchSampling(const double percent);
      void SetTolerance(double tolerance);
      void SetPatternReduction(std::vector<int> samples, std::vector<int> lines);

      inline QString operatorName() const {
        return mOperatorGrp["Name"];
      };

      bool Operate(Cube &pCube, UniversalGroundMap &pUnivGrndMap, int piSample, int piLine);

      void Operate(ControlNet &pNewNet, QString psSerialNumFile, QString psOverlapListFile = "");

      inline double InterestAmount() const {
        return p_interestAmount;
      };

      inline double WorstInterest() const {
        return p_worstInterest;
      }

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

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

      virtual bool CompareInterests(double int1, double int2);
      void addGroup(Isis::PvlObject &obj);  //???? check if used

      void SetClipPolygon(const geos::geom::MultiPolygon &clipPolygon);

      Isis::PvlGroup Operator();

    protected:
      void Parse(Pvl &pPvl);

      virtual double Interest(Chip &subCube) = 0;

      const geos::geom::MultiPolygon *FindOverlap(Isis::ControlPoint &pCnetPoint);

      const geos::geom::MultiPolygon *FindOverlapByImageFootPrint(Isis::ControlPoint &pCnetPoint);

      void FindCnetRef(ControlNet &pNewNet);

      void ProcessLocked_Point_Reference(ControlPoint &pCPoint, PvlObject &pPvlObj, int &piMeasuresModified);

      int InterestByPoint(ControlPoint &pCnetPoint);

      bool InterestByMeasure(int piMeasure, Isis::ControlMeasure &pCnetMeasure, Isis::Cube &pCube);

      void InitInterestResults(int piIndex);

      virtual int Padding();

      double p_worstInterest, p_interestAmount;

      geos::geom::MultiPolygon *p_clipPolygon;

      Isis::PvlGroup mOperatorGrp;        

    private:
      double p_cubeSample, p_cubeLine;    
      double p_minimumInterest;           
      Isis::ImageOverlapSet mOverlaps;    
      bool mbOverlaps;                    

      int p_deltaSamp, p_deltaLine, p_lines, p_samples;

      typedef struct {
        QString msSerialNum;     
        double mdInterest;           
        double mdBestSample;         
        double mdBestLine;           
        double mdOrigSample;         
        double mdOrigLine;           
        double mdEmission;           
        double mdIncidence;          
        double mdDn;                 
        double mdResolution;         
        bool mbValid;                
        int  miDeltaSample;          
        int  miDeltaLine;            
      } InterestResults;
      InterestResults *mtInterestResults;  
  };
};

#endif