ProcessRubberSheet.h

Go to the documentation of this file.

#ifndef ProcessRubberSheet_h
#define ProcessRubberSheet_h

#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
      void processPatchTransform(Transform &trans, Interpolator &interp);

      // Register a function to be called when the band number changes
      void BandChange(void (*funct)(const int band));

      void ForceTile(double Samp, double Line) {
        p_forceSamp = Samp;
        p_forceLine = Line;
      }

      void SetTiling(long long start, long long end) {
        p_startQuadSize = start;
        p_endQuadSize = end;
      }

      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