ImagePolygon.h

#ifndef ImagePolygon_h
#define ImagePolygon_h
/* SPDX-License-Identifier: CC0-1.0 */
 
#include <string>
#include <sstream>
#include <vector>
 
#include "IException.h"
#include "Cube.h"
#include "Brick.h"
#include "Blob.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:
      ImagePolygon();
      ImagePolygon(Blob &blob);
      ImagePolygon(const ImagePolygon &other);
      ~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);
 
      void Create(std::vector<std::vector<double>> polyCoordinates);
 
      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;
      };
 
      std::string polyStr() const {
        return p_polyStr;
      };
 
      double validSampleDim();
      double validLineDim();
 
      int getSinc() const {
        return p_sampinc;
      }
 
      int getLinc() const {
        return p_lineinc;
      }
 
      int numVertices() const {
        return p_pts->getSize();
      }
 
      Blob toBlob() const;
 
    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