Line.hpp

Go to the documentation of this file.

#pragma once
#include <fishnet/Option.hpp>
#include <fishnet/IGeometry.hpp>
#include <fishnet/LinearIntersection.hpp>
#include "Vec2D.hpp"
 
namespace fishnet::geometry{
template<fishnet::math::Number T = fishnet::math::DEFAULT_NUMERIC>
class Line{
private:
    Vec2D<T> _p;
    Vec2D<T> _q;
    constexpr static auto hasher = std::hash<fishnet::math::DEFAULT_FLOATING_POINT>{};
    const static inline Line<T> yAxis = Line<T>(Vec2D<T>(0,0),Vec2D<T>(0,1));
public:
 
    constexpr static Line<T> verticalLine(T x) noexcept {
        return Line<T>(Vec2D<T>(x,0),Vec2D<T>(x,1));
    }
 
    constexpr static Line<T> horizontalLine(T y) noexcept {
        return Line<T>(0,y);
    }
 
    using numeric_type =  T;
    constexpr static GeometryType type = GeometryType::LINE;
 
    constexpr Line(Vec2D<T> _p , Vec2D<T> _q):_p(_p),_q(_q){
        if (_p == _q) 
            throw std::invalid_argument("Coinciding Points cannot define a Line");
    }
 
    template<fishnet::math::Number U, typename = std::enable_if_t<!std::is_same_v<U,T> && std::is_same_v<T,fishnet::math::DEFAULT_NUMERIC>>>
    constexpr Line(Vec2D<T> _p, Vec2D<U> _q):Line(_p,static_cast<Vec2D<T>>(_q)){}
 
    template<fishnet::math::Number U, typename = std::enable_if_t<!std::is_same_v<U,T> && std::is_same_v<T,fishnet::math::DEFAULT_NUMERIC>>>
    constexpr Line(Vec2D<U> _p , Vec2D<T> _q):Line(static_cast<Vec2D<T>>(_p),_q){}
 
    constexpr Line(T slope, T yIntercept):_p(Vec2D<T>(0,yIntercept)),_q(Vec2D<T>(1,slope+yIntercept)){}
 
    template<fishnet::math::Number U, typename = std::enable_if_t<!std::is_same_v<U,T> && std::is_same_v<T,fishnet::math::DEFAULT_NUMERIC>>>
    constexpr Line(T slope, U yIntercept):Line(slope,fishnet::math::DEFAULT_NUMERIC(yIntercept)){}
 
    template<fishnet::math::Number U, typename = std::enable_if_t<!std::is_same_v<U,T> && std::is_same_v<T,fishnet::math::DEFAULT_NUMERIC>>>
    constexpr Line(U slope, T yIntercept):Line(fishnet::math::DEFAULT_NUMERIC(slope),yIntercept){}
 
    constexpr Vec2D<T> p() const noexcept{
        return _p;
    }
 
    constexpr Vec2D<T> q() const noexcept{
        return _q;
    }
 
    constexpr Line<T> toLine() const noexcept{
        return Line(_p,_q);
    }
 
    constexpr Vec2D<T> direction() const noexcept{
        return _q-_p;
    }
 
    constexpr bool isVertical() const noexcept{
        return _p.x == _q.x;
    }
 
    constexpr bool isHorizontal() const noexcept{
        return _p.y == _q.y;
    }
 
    constexpr fishnet::Option<fishnet::math::DEFAULT_FLOATING_POINT> yIntercept() const noexcept{
        fishnet::Option<Vec2DReal> intersectionWithY = intersection(yAxis);
        [[likely]] if (intersectionWithY){
            return fishnet::Option(intersectionWithY->y);
        }
        return std::nullopt;
    }
 
    constexpr fishnet::math::DEFAULT_FLOATING_POINT slope() const noexcept{
        [[unlikely]] if (direction().x == 0) 
            return std::numeric_limits<fishnet::math::DEFAULT_FLOATING_POINT>::max();
        return fishnet::math::DEFAULT_FLOATING_POINT(direction().y) / fishnet::math::DEFAULT_FLOATING_POINT(direction().x);
    }
 
    constexpr bool contains(IPoint auto const & point) const noexcept{
        using FLOAT_TYPE = fishnet::math::DEFAULT_FLOATING_POINT;
        auto dir = direction();
        if(dir.x == 0) { // line is vertical
            return point.x == _p.x; //or _q.x
        }
        if(dir.y == 0){ // line is horizontal
            return point.y == _p.y;
        }
        FLOAT_TYPE lX = FLOAT_TYPE(point.x - this->_p.x) / FLOAT_TYPE(dir.x);
        FLOAT_TYPE lY = FLOAT_TYPE(point.y - this->_p.y) / FLOAT_TYPE(dir.y);
        return fabs(lX-lY) < fishnet::math::EPSILON;
    }
 
    constexpr bool isLeft(IPoint auto const & point) const noexcept {
        return direction().cross(point-_p) > 0;
    }
 
    constexpr bool isRight(IPoint auto const & point) const noexcept {
        return direction().cross(point-_p) < 0;
    }
 
    constexpr bool isParallel(LinearGeometry auto const& other) const noexcept {
        return areParallel(*this,other);
    }
 
    constexpr bool intersects(LinearGeometry auto const& other) const noexcept{
        return intersect(*this,other);
    }
 
    template<fishnet::math::Number U>
    constexpr bool operator==(const Line<U> & other) const noexcept {
        if(this->isParallel(other)){
            [[unlikely]] if (isVertical()){ //other must also be vertical since both are parallel
                return this->_p.x == other.p().x;
            }
            return fabs(yIntercept().value() - other.yIntercept().value()) < fishnet::math::EPSILON;
        }
        return false;
    }
 
    constexpr fishnet::Option<Vec2DReal> intersection(LinearGeometry auto const& other) const noexcept {
        return linearIntersection(*this,other);
    }
 
    constexpr size_t hash() const noexcept {
        size_t slopeHash = hasher(this->slope());
        size_t yInterceptHash = hasher(this->yIntercept().value_or(this->_p.x));
        return fishnet::math::CantorPairing(slopeHash,yInterceptHash);
    }
 
    constexpr std::string toString() const {
        auto t = yIntercept();
        if (t){
            return "Line y = " + std::to_string(slope())+" * x + "+std::to_string(t.value());
        }
        return "Vertical Line x = "+std::to_string(_p.x);
    }
};
 
//Deduction guides
template<math::Number T>
Line(Vec2D<T>,Vec2D<T>) -> Line<T>;
 
const static inline Line<double> X_AXIS = Line<double>(0.0,0.0);
const static inline Line<double> Y_AXIS = Line<double>(Vec2D<double>(0,0),Vec2D<double>(0,1));
static_assert(ILine<Line<double>>);
static_assert(LinearGeometry<Line<double>>);
 
// Explicit template instantiation
template class Line<fishnet::math::DEFAULT_NUMERIC>;
}