ProcessRubberSheet.h

#ifndef ProcessRubberSheet_h
#define ProcessRubberSheet_h
/* SPDX-License-Identifier: CC0-1.0 */
#include "Process.h"
#include "Buffer.h"
#include "Transform.h"
#include "Interpolator.h"
#include "Portal.h"
#include "TileManager.h"
 
namespace Isis {
  class Brick;
 
  class ProcessRubberSheet : public Process {
    public:
 
      ProcessRubberSheet(int startSize = 128, int endSize = 8);
 
      virtual ~ProcessRubberSheet() {};
 
      using Isis::Process::StartProcess;
      // Output driven processing method for one input and output cube
      virtual void StartProcess(Transform &trans, Interpolator &interp);
 
      // Input driven processing method for one input and output cube
      virtual void processPatchTransform(Transform &trans, Interpolator &interp);
 
      // Register a function to be called when the band number changes
      virtual void BandChange(void (*funct)(const int band));
 
      virtual void ForceTile(double Samp, double Line) {
        p_forceSamp = Samp;
        p_forceLine = Line;
      }
 
      virtual void SetTiling(long long start, long long end) {
        p_startQuadSize = start;
        p_endQuadSize = end;
      }
 
      virtual void setPatchParameters(int startSample, int startLine,
                                int samples, int lines,
                                int sampleIncrement, int lineIncrement);
 
 
    private:
 
      class Quad {
        public:
          int slineTile; 
          int ssampTile; 
          int sline;     
          int ssamp;     
          int eline;     
          int esamp;     
      };
 
      void ProcessQuad(std::vector<Quad *> &quadTree, Transform &trans,
                       std::vector< std::vector<double> > &lineMap,
                       std::vector< std::vector<double> > &sampMap);
 
      void SplitQuad(std::vector<Quad *> &quadTree);
      void SlowQuad(std::vector<Quad *> &quadTree, Transform &trans,
                    std::vector< std::vector<double> > &lineMap,
                    std::vector< std::vector<double> > &sampMap);
      double Det4x4(double m[4][4]);
      double Det3x3(double m[3][3]);
 
      // SlowGeom method is never used but saved for posterity
      void SlowGeom(TileManager &otile, Portal &iportal,
                    Transform &trans, Interpolator &interp);
      void QuadTree(TileManager &otile, Portal &iportal,
                    Transform &trans, Interpolator &interp,
                    bool useLastTileMap);
 
      bool TestLine(Transform &trans, int ssamp, int esamp, int sline,
                    int eline, int increment);
 
      void (*p_bandChangeFunct)(const int band);
 
      void transformPatch (double startingSample, double endingSample,
                           double startingLine, double endingLine,
                           Portal &iportal, Transform &trans, Interpolator &interp);
 
      void splitPatch (double startingSample, double endingSample,
                       double startingLine, double endingLine,
                       Portal &iportal, Transform &trans, Interpolator &interp);
#if 0
      void transformPatch (double startingSample, double endingSample,
                           double startingLine, double endingLine);
 
      void splitPatch (double startingSample, double endingSample,
                       double startingLine, double endingLine);
#endif
 
      std::vector< std::vector<double> > p_sampMap; 
      std::vector< std::vector<double> > p_lineMap; 
 
      double p_forceSamp; 
      double p_forceLine; 
 
      long long p_startQuadSize; 
      long long p_endQuadSize;   
 
      int m_patchStartSample;
      int m_patchStartLine;
      int m_patchSamples;
      int m_patchLines;
      int m_patchSampleIncrement;
      int m_patchLineIncrement;
 
#if 0
      Portal *m_iportal;
      Brick *m_obrick;
      Transform *m_transform;
      Interpolator *m_interpolator;
#endif
  };
};
 
#endif