Point.h

 
#ifndef ACTIVE_GEOMETRY_POINT
#define ACTIVE_GEOMETRY_POINT
 
#include "Active/Geometry/Position.h"
#include "Active/Utility/Cloner.h"
#include "Active/Utility/MathFunctions.h"
 
#include <memory>
#include <optional>
 
namespace active::geometry {
    
    class Matrix3x3;
    class Matrix4x4;
 
    using vertex_index = int32_t;
    using vertOption = std::optional<vertex_index>;
    using part_index = int32_t;
    using partOption = std::optional<part_index>;
    
    class Point : public utility::Cloner {
    public:
        
        // MARK: - Types
        
        using enum Position;
 
        using Unique = std::unique_ptr<Point>;
        using Shared = std::shared_ptr<Point>;
        using Option = std::optional<Point>;
        
        // MARK: Constructors
            
        Point();
        Point(const double& x, const double& y, const double& z = 0.0);
        Point(const Point& source2D, double z);
        virtual ~Point() = default;
        virtual Point* clonePtr() const { return new Point(*this); }
        
        // MARK: Public variables
            
        double x;
        double y;
        double z;
        
        // MARK: - Operators
        
        virtual bool operator== (const Point& ref) const { return isEqual3D(ref); }
        virtual bool operator!= (const Point& ref) const { return !isEqual3D(ref); }
        virtual bool operator< (const Point& ref) const;
        Point& operator= (const Point& source);
        virtual Point operator+ (const Point& offset) const;
        virtual Point& operator+= (const Point& offset);
        virtual Point operator- (const Point& offset) const;
        virtual Point& operator-= (const Point& offset);
        virtual Point operator* (const double& mult) const;
        virtual Point operator* (const Matrix3x3& matrix) const;
        virtual Point operator* (const Matrix4x4& matrix) const;
        virtual Point& operator*= (const double& mult);
        virtual Point& operator*= (const Matrix3x3& matrix);
        virtual Point& operator*= (const Matrix4x4& matrix);
        virtual Point operator/ (const double& mult) const;
        virtual Point& operator/= (const double& mult);
        
        // MARK: - Functions (const)
        
        virtual bool isEqual2D(const Point& ref, double prec = math::eps) const;
        virtual bool isEqual3D(const Point& ref, double prec = math::eps) const;
        virtual double lengthFrom2D(const Point& ref) const;
        virtual double lengthFrom3D(const Point& ref) const;
        Point rounded2D(double prec = math::eps) const;
        Point rounded3D(double prec = math::eps) const;
        double azimuthAngleTo(const Point& ref) const;
        double altitudeAngleTo(const Point& ref) const;
        
        // MARK: - Functions (mutating)
        
        Point& movePolar(double len, double angle);
        Point& movePolar(double len, double azim, double alt);
    };
 
}
 
#endif  //ACTIVE_GEOMETRY_POINT