Chip.h

Go to the documentation of this file.

#ifndef Chip_h
#define Chip_h

#include <vector>

#include <geos/geom/MultiPolygon.h>

#include "Affine.h"
#include "Interpolator.h"
#include "Pvl.h"
#include "SpecialPixel.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 p_chipSamples;
      };

      inline int Lines() const {
        return p_chipLines;
      };

      inline QString FileName() const {
        return p_filename;
      };

      void SetAllValues(const double &d);

      void SetValue(int sample, int line, const double &value) {
        p_buf[line-1][sample-1] = value;
      }

      inline double GetValue(int sample, int line) {
        return p_buf[line-1][sample-1];
      }

      inline const double GetValue(int sample, int line) const {
        return p_buf[line-1][sample-1];
      }

      void TackCube(const double cubeSample, const double cubeLine);

      inline int TackSample() const {
        return p_tackSample;
      };

      inline int TackLine() const {
        return p_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 p_cubeSample;
      };

      inline double CubeLine() const {
        return p_cubeLine;
      };

      void SetCubePosition(const double sample, const double line);

      double ChipSample() const {
        return p_chipSample;
      };

      double ChipLine() const {
        return p_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 < p_validMinimum) return false;
        if(value > p_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 (p_affine);
      }

      void SetTransform(const Affine &affine, const bool &keepPoly = true) {
        p_affine = affine;
        if(!keepPoly) {
          delete p_clipPolygon;
          p_clipPolygon = 0;
        }
        return;
      }

      const Interpolator::interpType GetReadInterpolator() {
        return p_readInterpolator;
      }


      void SetReadInterpolator(const Interpolator::interpType type) {
        if(type == Interpolator::NearestNeighborType ||
            type == Interpolator::BiLinearType ||
            type == Interpolator::CubicConvolutionType) {
          p_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 p_chipSamples;                           
      int p_chipLines;                             
      std::vector< std::vector<double> > p_buf;    
      int p_tackSample;                            
      int p_tackLine;                              

      double p_cubeTackSample;                     
      double p_cubeTackLine;                       

      double p_validMinimum;                       
      double p_validMaximum;                       

      double p_chipSample;                         
      double p_chipLine;                           
      double p_cubeSample;                         
      double p_cubeLine;                           
      geos::geom::MultiPolygon *p_clipPolygon;     

      Affine p_affine;                             
      Interpolator::interpType p_readInterpolator; 
      QString p_filename;                           
  };
};

#endif