PolyEdge.h

 
#ifndef ACTIVE_GEOMETRY_POLY_EDGE
#define ACTIVE_GEOMETRY_POLY_EDGE
 
#include "Active/Geometry/PolyPoint.h"
#include "Active/Geometry/Rotation.h"
#include "Active/Geometry/Vector3.h"
 
#include <memory>
 
namespace active::geometry {
    
    class Arc;
    class Matrix3x3;
    class Plane;
    class XList;
 
    class PolyEdge {
    public:
        
        // MARK: - Types
        
        using enum Rotation;
        using Unique = std::unique_ptr<PolyEdge>;
        using Shared = std::shared_ptr<PolyEdge>;
        using Option = std::optional<PolyEdge>;
        
        // MARK: - Constructors
        
        PolyEdge() {}
        PolyEdge(const Point& origin, const PolyPoint& end);
        PolyEdge(const Point& origin, const Point& end, double radius, Rotation rotation = anticlockwise, double prec = math::eps);
        PolyEdge(const Arc& arc);
        
        // MARK: - Variables
        
        Point origin;
        PolyPoint end;
        Vector3 normal = Vector3(0.0, 0.0, 1.0);    
 
        // MARK: - Operators
        
        bool operator== (const PolyEdge& ref) const { return isEqual3D(ref); }
        bool operator!= (const PolyEdge& ref) const { return !isEqual3D(ref); }
        PolyEdge& operator= (const PolyEdge& source);
        PolyEdge operator+ (const Point& offset) const;
        PolyEdge& operator+= (const Point& offset);
        PolyEdge operator- (const Point& offset) const;
        PolyEdge& operator-= (const Point& offset);
        PolyEdge operator* (double scale) const;
        PolyEdge& operator*= (double scale);
        PolyEdge operator* (const Matrix3x3& matrix) const;
        PolyEdge& operator*= (const Matrix3x3& matrix);
        
        // MARK: - Functions (const)
 
        bool isArc(double prec = math::eps) const { return end.isArc(prec); }
        bool isEqual2D(const PolyEdge& ref, double prec = math::eps) const;
        bool isEqual3D(const PolyEdge& ref, double prec = math::eps) const;
        bool isColinearTo2D(const PolyEdge& ref, double prec = math::eps) const;
        bool isColinearTo3D(const PolyEdge& ref, double prec = math::eps) const;
        bool isParallelTo2D(const PolyEdge& ref, double prec = math::eps) const;
        bool isParallelTo3D(const PolyEdge& ref, double prec = math::eps) const;
        bool isTangentialTo2D(const PolyEdge& ref, double prec = math::eps, double anglePrec = math::epsAngle) const;
        double getRadius(bool isSigned = false) const;
        double getSweep() const { return end.sweep; }
        double azimuthAngle() const;
        double altitudeAngle() const;
        double startTangent() const;
        double endTangent() const;
        double getTangentAt(const Point& ref) const;
        Point centre() const;
        Point midpoint() const;
        double getArea(bool isResultSigned = false) const;
        double length2D() const;
        double length3D() const;
        std::optional<Arc> asArc(double prec = math::eps) const;
        Point closestPointTo2D(const Point& ref, double prec = math::eps) const;
        Point closestPointTo3D(const Point& ref, double prec = math::eps) const;
        Point closestPointAlong2D(const Point& ref, double prec = math::eps) const;
        Point closestPointAlong3D(const Point& ref, double prec = math::eps) const;
        vertex_index intersectionWith2D(const PolyEdge& ref, XList& inter, double prec = math::eps) const;
        vertex_index intersectionWith3D(const PolyEdge& ref, XList& inter, double prec = math::eps) const;
        Position positionOf2D(const Point& ref, double prec = math::eps) const;
        Position positionOf3D(const Point& ref, double prec = math::eps) const;
        bool encloses2D(const Point& ref, double prec = math::eps) const;
        bool encloses3D(const Point& ref, double prec = math::eps) const;
        bool overlaps2D(const PolyEdge& ref, double prec = math::eps) const;
        
        // MARK: - Functions (mutating)
 
        void setRadius(double radius, std::optional<Rotation> rotation = std::nullopt, double prec = math::eps);
        void setSweep(double sweep) { end.sweep = sweep; }
        void stretchOrigin(const Point& pt, bool canInvert = true, double prec = math::eps);
        void stretchEnd(const Point& pt, double prec = math::eps);
        void setBaseLevel(double z = 0.0);
        void offset(double shift);
        void extend(double len, bool byEnd = true);
        void extend(const Point& ref, bool byEnd = true);
        void split(const Point& pos, PolyEdge& offcut, bool keepOrig = true);
        void movePolar(double len, double azim, double alt);
        void movePolar(double len, double angle);
        PolyEdge& flip();
    };
    
}
 
#endif  //ACTIVE_GEOMETRY_POLY_EDGE