InterestOperator.h

#ifndef InterestOperator_h
#define InterestOperator_h
 
/* SPDX-License-Identifier: CC0-1.0 */
 
#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