Polygon.h

 
#ifndef ACTIVE_GEOMETRY_POLYGON
#define ACTIVE_GEOMETRY_POLYGON
 
#include "Active/Container/List.h"
#include "Active/Container/Vector.h"
#include "Active/Geometry/Box.h"
#include "Active/Geometry/PolyPoint.h"
#include "Active/Geometry/Rotation.h"
#include "Active/Geometry/XPoint.h"
#include "Active/Utility/Cloner.h"
 
namespace active::geometry {
    
    class Arc;
    class Line;
    class LinEquation;
    class Plane;
    class PolyEdge;
    class PolyVector;
    class PolyVector;
    class XList;
 
    class Polygon : public container::Vector<PolyPoint>, public utility::Cloner, public utility::Mover {
    public:
 
        //MARK: - Types
 
        using base = container::Vector<PolyPoint>;
        using Unique = std::unique_ptr<Polygon>;
        using Shared = std::shared_ptr<Polygon>;
        using Option = std::optional<Polygon>;
 
        static const vertex_index defSize = 5;
 
        struct Index {
            part_index part = 0;
            vertex_index vertex = 0;
            const PolyPoint* point = nullptr;
        };
        
        using enum Rotation;
 
        //MARK: - Constructors
        
        Polygon(vertex_index size = defSize, part_index holeSize = 0, bool isClosed = true);
        Polygon(const std::initializer_list<PolyPoint>& points, bool isClosed = true) : base(points) { this->isClosed = isClosed; }
        Polygon(const Box& source, double angle = 0.0);
        Polygon(const Polygon& source);
        Polygon(Polygon&& source) noexcept;
        virtual ~Polygon() = default;
        
        virtual Polygon* clonePtr() const { return new Polygon(*this); }
        virtual Polygon* movePtr() { return new Polygon(std::move(*this)); }
        virtual Polygon::Unique cloneGeometry() const;
        
        // MARK: - Public variables
        
        bool isHole = false;
        bool isClosed = true;
        
        // MARK: - Operators
        
        virtual Polygon& operator= (const Polygon& source);
        virtual Polygon& operator= (Polygon&& source) noexcept;
        PolyPoint* operator[] (vertex_index index);
        const PolyPoint* operator[] (vertex_index index) const;
        Polygon operator+ (const Point& offset) const;
        Polygon& operator+= (const Point& offset);
        Polygon operator- (const Point& offset) const;
        Polygon& operator-= (const Point& offset);
        Polygon operator* (const double& mult) const;
        Polygon& operator*= (const double& mult);
        Polygon operator* (const Matrix3x3& mult) const;
        Polygon& operator*= (const Matrix3x3& mult);
        Polygon operator* (const Matrix4x4& mult) const;
        Polygon& operator*= (const Matrix4x4& mult);
        Polygon operator/ (const double& mult) const;
        Polygon& operator/= (const double& mult);
 
        //MARK: - Functions (const)
        
        virtual bool isValid(bool doIntersect = false, double prec = math::eps) const;
        bool isEqual2D(const Polygon& ref, double prec = math::eps) const;
        bool isEqual3D(const Polygon& ref, double prec = math::eps) const;
        vertex_index vertSize(bool isOuter = true) const;
        vertex_index edgeSize() const { return isClosed ? vertSize() : vertSize() - 1; }
        part_index getHoleSize() const;
        vertex_id getTopID() const { return m_topID; }
        Polygon* getHole(part_index which) const;
        PolyVector* getHoles() const { return m_hole.get(); }
        std::optional<Rotation> getDirection() const;
        Box::Option bounds() const;
        double getPerimeter2D() const;
        double getPerimeter3D() const;
        vertex_index tracePerimeter(double len, PolyPoint& endPos) const;
        double getArea(bool isNet = true, bool isResultSigned = false) const;
        double getInternalAngleAt(vertex_index index) const;
        bool isTangentialAt(vertex_index vertex, double anglePrec = math::epsAngle) const;
        bool isReflection(vertex_index index, const LinEquation& ref, double prec = math::eps) const;
        Point::Option getInternalPoint() const;
        std::optional<Index> findVertexById(vertex_id ID) const;
        std::optional<Index> findVertexByLocation(const Point& pt, double prec = math::eps) const;
        const Polygon& getShape(part_index index) const;
        Polygon& getShape(part_index index);
        base::iterator iteratorAt(vertex_index index);
        base::const_iterator iteratorAt(vertex_index index) const;
        vertex_index wrapIndex(vertex_index index) const;
        XPoint closestPointAlong3D(const Point& ref, bool withHoles, double prec = math::eps) const;
        XPoint closestPointAlong2D(const Point& ref, bool withHoles, double prec = math::eps) const;
        Position positionOf(const Point& ref, double prec = math::eps) const;
        vertex_index intersectionWith(const Line& ref, XList& inter, double prec = math::eps) const;
        vertex_index intersectionWith(const Arc& ref, XList& inter, double prec = math::eps) const;
        vertex_index intersectionWith(const PolyEdge& ref, XList& inter, double prec = math::eps) const;
        vertex_index intersectionWith(const Polygon& ref, XList& inter, double prec = math::eps) const;
        void splitWith(const LinEquation& ref, PolyVector* polyRight = nullptr, PolyVector* polyLeft = nullptr, double prec = math::eps) const;
        void splitWith(const Polygon& ref, PolyVector* polyIn = nullptr, PolyVector* polyOut = nullptr, double prec = math::eps) const;
        part_index resolveSelfIntersect(PolyVector& resolved, double prec = math::eps) const;
        bool crosses(const Line& ref, double prec = math::eps) const;
        bool encloses(const Point& ref, double prec = math::eps) const;
        bool encloses(const Polygon& ref, double prec = math::eps) const;
        bool overlaps(const Polygon& ref, double prec = math::eps) const;
 
        //MARK: - Functions (mutating)
        
        vertex_id allocateID() { return ++m_topID; }
        void setTopID(vertex_id topId) { m_topID = topId; }
        void clear(bool allVertices = true, bool allHoles = true);
        Polygon* insertHole(const Polygon& hole);
        Polygon* insertHole(Polygon* hole = nullptr);
        Polygon* emplaceHole(Polygon::Unique&& hole);
        Polygon* emplaceHole(Polygon&& hole);
        void setHoles(std::unique_ptr<PolyVector>&& holes = nullptr);
        void setHoles(PolyVector&& hole);
        void removeHole(part_index which);
        Polygon::Unique releaseHole(part_index which);
        vertex_id addNodeAlong(vertex_id ID, const Point& pos, double prec = math::eps);
        virtual bool insertUniqueVertex(PolyPoint&& pt, vertOption where = std::nullopt);
        std::unique_ptr<PolyVector> releaseHoles();
        virtual void setDirection(Rotation direct = clockwise, bool withHoles = true, bool invertHoleDir = false);
        virtual void reverse();
        bool removeDuplicates2D(double prec = math::eps);
        bool removeDuplicates3D(double prec = math::eps);
        void optimise(bool doColin = false, double prec = math::eps);
        void renumber(bool restart = false);
        void facet();
        void setBaseLevel(double z = 0);
        void alignTo(const Plane& plane);
    
    private:
        std::unique_ptr<PolyVector> m_hole;
        vertex_id m_topID = 0;
    };
    
    
    class PolyVector : public container::Vector<Polygon> {
    public:
 
        //MARK: - Types
        
        using base = container::Vector<Polygon>;
        using size_type = typename base::size_type;
        using Unique = std::unique_ptr<PolyVector>;
        using Shared = std::shared_ptr<PolyVector>;
        using Option = std::optional<PolyVector>;
 
        //MARK: - Constructors
        
        PolyVector(size_type toReserve = 0) : base(toReserve) {}
        PolyVector(const PolyVector& source) : base(source) {}
        virtual ~PolyVector() = default;
 
        //MARK: - Functions (const)
        
        const_iterator findLargest() const;
 
        //MARK: - Functions (mutating)
        
        iterator findLargest();
    };
    
}
 
#endif  //ACTIVE_GEOMETRY_POLYGON