Arc.h

 
#ifndef ACTIVE_GEOMETRY_ARC
#define ACTIVE_GEOMETRY_ARC
 
#include "Active/Geometry/Box.h"
#include "Active/Geometry/Plane.h"
#include "Active/Geometry/Point.h"
#include "Active/Geometry/PolyPoint.h"
#include "Active/Geometry/Vector3.h"
 
#include <memory>
 
namespace active::geometry {
    
    class Leveller;
    class Line;
    class Matrix3x3;
    class XList;
 
    class Arc : public utility::Cloner {
    public:
 
        // MARK: - Types
        
        using enum Position;
        
        using Unique = std::unique_ptr<Arc>;
        using Shared = std::shared_ptr<Arc>;
        using Option = std::optional<Arc>;
 
        // MARK: - Constructors
        
        Arc();
        Arc(const Point& centre, double radius, double sweep = 2.0 * math::pi, double start = 0, const Vector3& norm = Vector3(0, 0, 1));
        Arc(const Point& centre, const Point& pt1, const Point& pt2, bool isClockwise);
        Arc(const Point& pt1, const Point& pt2, const Point& pt3);
        Arc(const Point& origin, const PolyPoint& end);
        
        Arc* clonePtr() const { return new Arc(*this); }
 
        // MARK: - Variables
        
            //The arc centre
        Point centre;
            //The normal of the plane the arc lies along
        Vector3 normal;
            //The arc radius
        double radius;
            //The arc start angle
        double startAngle;
            //The arc sweep angle
        double sweep;
 
        // MARK: - Operators
        
        bool operator== (const Arc& ref) const { return isEqual3D(ref); }
        bool operator!= (const Arc& ref) const { return !isEqual3D(ref); }
        Arc& operator= (const Arc& source);
        Arc operator+ (const Point& offset) const;
        Arc& operator+= (const Point& offset);
        Arc operator- (const Point& offset) const;
        Arc& operator-= (const Point& offset);
        Arc operator* (double scale) const;
        Arc& operator*= (double scale);
        Arc operator* (const Matrix3x3& matrix) const;
        Arc& operator*= (const Matrix3x3& matrix);
 
        // MARK: - Functions (const)
        
        double isValid(double prec = math::eps) const;
        bool isEqual2D(const Arc& ref, double prec = math::eps) const;
        bool isEqual3D(const Arc& ref, double prec = math::eps) const;
        Point getOrigin() const;
        PolyPoint getEnd() const;
        Point midpoint() const;
        double getEndAngle() const { return startAngle + sweep; }
        Plane getPlane() const;
        Box::Unique bounds() const;
        double length2D() const;
        double length3D() const;
        double getArea(bool isArcOnly = true, bool isResultSigned = false) const;
        bool isColinearTo2D(const Arc& ref, double prec = math::eps) const;
        bool isColinearTo3D(const Arc& ref, double prec = math::eps) const;
        bool isParallelTo2D(const Arc& ref, double prec = math::eps) const;
        bool isParallelTo3D(const Arc& 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;
        Point closestPointTo2D(const Point& ref, double prec = math::eps) const;
        Point closestPointTo3D(const Point& ref, double prec = math::eps) const;
        vertex_index intersectionWith(const Plane& ref, XList& inter, double prec = math::eps) const;
        vertex_index intersectionWith2D(const Line& ref, XList& inter, double prec = math::eps) const;
        vertex_index intersectionWith2D(const Arc& ref, XList& inter, double prec = math::eps) const;
        vertex_index intersectionWith3D(const Line& ref, XList& inter, double prec = math::eps) const;
        vertex_index intersectionWith3D(const Arc& 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;
        
        // MARK: - Functions (mutating)
        
        void setEndAngle(double end) { sweep = end - startAngle; }
        void movePolar(double len, double azim, double alt);
        void movePolar(double len, double angle);
        void expand(double inc) { radius += inc; }
        void spin(double rotAngle) { startAngle += rotAngle; }
        void flip();
        
    protected:
        void initLevel(Leveller& level, double prec = math::eps) const;
        bool createIntersect(const Point& pt, const Arc& arc, const Arc& ref,
                XList& inter, double prec = math::eps) const;
        bool createIntersect(const Point& pt, const Arc& arc, const Line& ref,
                XList& inter, double prec = math::eps) const;
        vertex_index intersectionWithLevel(const Line& ref, XList& inter, double prec = math::eps) const;
        vertex_index intersectionWithLevel(const Arc& ref, XList& inter, double prec = math::eps) const;
    };
    
}
 
#endif  //ACTIVE_GEOMETRY_ARC