Chip.h

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#ifndef Chip_h
#define Chip_h
 
 
#include "Affine.h"
#include "Interpolator.h"
#include "Pvl.h"
#include "SpecialPixel.h"
 
#include <vector>
 
#include <geos/geom/MultiPolygon.h>
 
namespace Isis {
  class Cube;
  class Statistics;
 
  class Chip {
    public:
      Chip();
      Chip(const Chip &other);
      Chip(const int samples, const int lines);
      virtual ~Chip();
 
      void SetSize(const int samples, const int lines);
      bool IsInsideChip(double sample, double line);
 
      inline int Samples() const {
        return m_chipSamples;
      };
 
      inline int Lines() const {
        return m_chipLines;
      };
 
      inline QString FileName() const {
        return m_filename;
      };
 
      void SetAllValues(const double &d);
 
      void SetValue(int sample, int line, const double &value) {
        m_buf[line-1][sample-1] = value;
      }
 
      inline double GetValue(int sample, int line) {
        return m_buf[line-1][sample-1];
      }
 
      inline double GetValue(int sample, int line) const {
        return m_buf[line-1][sample-1];
      }
 
      void TackCube(const double cubeSample, const double cubeLine);
 
      inline int TackSample() const {
        return m_tackSample;
      };
 
      inline int TackLine() const {
        return m_tackLine;
      };
 
      void Load(Cube &cube, const double rotation = 0.0, const double scale = 1.0,
                const int band = 1);
      void Load(Cube &cube, Chip &match, Cube &matchChipCube,
                const double scale = 1.0, const int band = 1);
      void Load(Cube &cube, const Affine &affine, const bool &keepPoly = true,
                const int band = 1);
 
      void SetChipPosition(const double sample, const double line);
 
      inline double CubeSample() const {
        return m_cubeSample;
      };
 
      inline double CubeLine() const {
        return m_cubeLine;
      };
 
      void SetCubePosition(const double sample, const double line);
 
      double ChipSample() const {
        return m_chipSample;
      };
 
      double ChipLine() const {
        return m_chipLine;
      };
 
      void SetValidRange(const double minimum = Isis::ValidMinimum,
                         const double maximum = Isis::ValidMaximum);
 
      inline bool IsValid(int sample, int line) {
        double value = GetValue(sample, line);
        if (value < m_validMinimum) return false;
        if (value > m_validMaximum) return false;
        return true;
      }
 
      bool IsValid(double percentage);
      Chip Extract(int samples, int lines, int samp, int line);
      void Extract(int samp, int line, Chip &output);
      Isis::Statistics *Statistics();
      void Extract(Chip &output, Affine &affine);
      void Write(const QString &filename);
 
      void SetClipPolygon(const geos::geom::MultiPolygon &clipPolygon);
 
      Chip &operator=(const Chip &other);
 
      const Affine &GetTransform() const {
        return (m_affine);
      }
 
      void SetTransform(const Affine &affine, const bool &keepPoly = true) {
        m_affine = affine;
        if (!keepPoly) {
          delete m_clipPolygon;
          m_clipPolygon = 0;
        }
        return;
      }
 
      Interpolator::interpType GetReadInterpolator() {
        return m_readInterpolator;
      }
 
      void SetReadInterpolator(const Interpolator::interpType type) {
        if (type == Interpolator::NearestNeighborType ||
            type == Interpolator::BiLinearType ||
            type == Interpolator::CubicConvolutionType) {
          m_readInterpolator = type;
          return;
        }
        // Interpolator::None is not valid type
        QString msg = "Invalid Interpolator type. Cannot use [";
        msg += toString(type) + "] to read cube into chip.";
        throw IException(IException::Programmer, msg, _FILEINFO_);
      }
 
    private:
      void Init(const int samples, const int lines);
      void Read(Cube &cube, const int band);
      std::vector<int> MovePoints(int startSamp, int startLine,
                             int endSamp, int endLine);
      bool PointsColinear(double x0, double y0,
                          double x1, double y1,
                          double x2, double y2,
                          double tol);
 
      int m_chipSamples;                           
      int m_chipLines;                             
      std::vector< std::vector<double> > m_buf;    
      int m_tackSample;                            
      int m_tackLine;                              
 
      double m_cubeTackSample;                     
      double m_cubeTackLine;                       
 
      double m_validMinimum;                       
      double m_validMaximum;                       
 
      double m_chipSample;                         
      double m_chipLine;                           
      double m_cubeSample;                         
      double m_cubeLine;                           
 
      geos::geom::MultiPolygon *m_clipPolygon;     
                                                   // (line,samp)
 
      Affine m_affine;                             
                                                   // Used to load cubes into chip
 
      Interpolator::interpType m_readInterpolator; 
                                                   // SetReadInterpolator. Used to read
                                                   // cubes into chip.
 
      QString m_filename;                          
  };
};
 
#endif