ImagePolygon.h

Go to the documentation of this file.

#ifndef ImagePolygon_h
#define ImagePolygon_h

#include <string>
#include <sstream>
#include <vector>

#include "IException.h"
#include "Cube.h"
#include "Brick.h"
#include "Camera.h"
#include "Projection.h"
#include "UniversalGroundMap.h"
#include "Blob.h"
#include "geos/geom/Coordinate.h"
#include "geos/geom/MultiPolygon.h"
#include "geos/geom/CoordinateSequence.h"

namespace Isis {

  class ImagePolygon : public Isis::Blob {

    public:
      ImagePolygon();
      ~ImagePolygon();

      void Create(Cube &cube, int sinc = 1, int linc = 1,
          int ss = 1, int sl = 1, int ns = 0, int nl = 0, int band = 1,
          bool increasePrecision = false);

      Camera * initCube(Cube &cube, int ss = 1, int sl = 1,
                        int ns = 0, int nl = 0, int band = 1);

      void Emission(double emission) {
        p_emission = emission;
      }
      void Incidence(double incidence) {
        p_incidence = incidence;
      }

      void EllipsoidLimb(bool ellip) {
        p_ellipsoid = ellip;
      }

      void SubpixelAccuracy(int div) {
        p_subpixelAccuracy = div;
      }

      geos::geom::MultiPolygon *Polys() {
        return p_polygons;
      };

      double validSampleDim();
      double validLineDim();

      int getSinc() const {
        return p_sampinc;
      }

      int getLinc() const {
        return p_lineinc;
      }

    protected:
      void ReadData(std::istream &is);
      void WriteInit();
      void WriteData(std::fstream &os);

    private:
      // Please do not add new polygon manipulation methods to this class.
      // Polygon manipulation should be done in the PolygonTools class.
      bool SetImage(const double sample, const double line);

      geos::geom::Coordinate FindFirstPoint();
      void WalkPoly();
      geos::geom::Coordinate FindNextPoint(geos::geom::Coordinate *currentPoint,
                                           geos::geom::Coordinate lastPoint,
                                           int recursionDepth = 0);

      double DistanceSquared(const geos::geom::Coordinate *p1, const geos::geom::Coordinate *p2);

      void MoveBackInsideImage(double &sample, double &line, double sinc, double linc);
      bool InsideImage(double sample, double line);
      void Fix360Poly();
      void FixPolePoly(std::vector<geos::geom::Coordinate> *crossingPoints);

      bool IsLimb();
      geos::geom::Coordinate FindBestPoint(geos::geom::Coordinate *currentPoint,
                                           geos::geom::Coordinate newPoint,
                                           geos::geom::Coordinate lastPoint);
      geos::geom::Coordinate FixCornerSkip(geos::geom::Coordinate *currentPoint,
                                           geos::geom::Coordinate newPoint);

      void FindSubpixel(std::vector<geos::geom::Coordinate> & points);

      void calcImageBorderCoordinates();

      Cube *p_cube;       
      bool p_isProjected; 

      Brick *p_brick;     

      geos::geom::CoordinateSequence *p_pts; 

      geos::geom::MultiPolygon *p_polygons;  

      std::string p_polyStr; 

      UniversalGroundMap *p_gMap; 

      geos::geom::Coordinate *m_leftCoord; 
      geos::geom::Coordinate *m_rightCoord; 
      geos::geom::Coordinate *m_topCoord; 
      geos::geom::Coordinate *m_botCoord; 

      int p_cubeStartSamp; 
      int p_cubeStartLine; 
      int p_cubeSamps;     
      int p_cubeLines;     

      int p_sampinc; 
      int p_lineinc; 

      double p_emission;  
      double p_incidence; 
      bool p_ellipsoid;   

      int p_subpixelAccuracy; 

  };
};

#endif