Chip.h

Go to the documentation of this file.

#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);
      bool IsValid(double percentage);

      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;
      }

      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