Rotater.h

 
#ifndef ACTIVE_GEOMETRY_ROTATER
#define ACTIVE_GEOMETRY_ROTATER
 
#include "Active/Geometry/Point.h"
 
namespace active::geometry {
    
    class Arc;
    class Line;
    class Polygon;
    class PolyEdge;
    class Plane;
    class Vector3;
    class Vector4;
 
    class Rotater : public utility::Cloner {
    public:
        
        // MARK: - Types
        
        using Unique = std::unique_ptr<Rotater>;
        using Shared = std::shared_ptr<Rotater>;
        using Option = std::optional<Rotater>;
        
        // MARK: - Constructors
        
        Rotater(double angle = 0.0, double prec = math::eps) { setAngle(angle, prec); }
        Rotater(const Rotater& source);
        virtual ~Rotater() = default;
        
        virtual Rotater* clonePtr() const = 0;
        
        // MARK: - Operators
        
        Rotater& operator= (const Rotater& source);
        
        // MARK: - Functions (const)
        
        virtual double getAngle() const { return m_angle; }
        virtual bool isActive() const { return m_isActive; }
        virtual Point& transformPt(Point& target) const = 0;
        virtual void transform(Arc& target) const;
        virtual void transform(Line& target) const;
        virtual void transform(PolyEdge& target) const;
        virtual void transform(Vector3& target) const;
        virtual void transform(Vector4& target) const;
        virtual void transform(Plane& target) const;
        virtual void transform(Polygon& target) const;
        
        // MARK: - Functions (mutating)
        
        virtual void setAngle(double angle, double prec = math::eps);
        virtual Rotater& reverse() { if (m_isActive) setAngle(-getAngle()); return *this; }
        
    protected:
        const double& k1() const { return m_k1; }
        const double& k2() const { return m_k2; }
        
    private:
        bool m_isActive;
        double m_angle;
        double m_k1;
        double m_k2;
    };
 
 
    class XRotater : public Rotater {
    public:
        
        // MARK: - Constructors
        
        XRotater(double angle = 0.0, double prec = math::eps)   : Rotater(angle, prec) {}
        XRotater(const Rotater& source) : Rotater(source) {}
        virtual ~XRotater() = default;
        
        virtual Rotater* clonePtr() const { return new XRotater(*this); }
        
        // MARK: - Operators
        
        XRotater& operator= (const XRotater& source) { Rotater::operator=(source); return *this; }
        
        // MARK: - Functions (const)
        
        virtual Point& transformPt(Point& target) const;
    };
 
 
    class YRotater : public Rotater {
    public:
        
        // MARK: - Constructors
        
        YRotater(double angle = 0.0, double prec = math::eps)   : Rotater(-angle, prec) {}
        YRotater(const Rotater& source) : Rotater(source) {}
        virtual ~YRotater() = default;
        
        virtual Rotater* clonePtr() const { return new YRotater(*this); }
        
        // MARK: - Operators
        
        YRotater& operator= (const YRotater& source) { Rotater::operator=(source); return *this; }
        
        // MARK: - Functions (const)
        
        virtual double getAngle() const { return -Rotater::getAngle(); }
        virtual Point& transformPt(Point& target) const;
        
        // MARK: - Functions (mutating)
        
        virtual void setAngle(double angle, double prec = math::eps) { Rotater::setAngle(-angle, prec); }
    };
 
 
    class ZRotater : public Rotater {
    public:
        
        // MARK: - Constructors
        
        ZRotater(double angle = 0.0, double prec = math::eps)   : Rotater(angle, prec) {}
        ZRotater(const Rotater& source) : Rotater(source) {}
        virtual ~ZRotater() = default;
        
        virtual Rotater* clonePtr() const { return new ZRotater(*this); }
        
        // MARK: - Operators
        
        ZRotater& operator= (const ZRotater& source) { Rotater::operator=(source); return *this; }
        
        // MARK: - Functions (const)
        
        virtual Point& transformPt(Point& target) const;
    };
    
}
 
#endif  //ACTIVE_GEOMETRY_ROTATER