Line.hh

Go to the documentation of this file.

#pragma once
#include <boost/units/operators.hpp>

namespace boca
{

template <template<typename> class Vector_, typename Value_>
class Line
{

    using Value_Square = typename boost::units::multiply_typeof_helper<Value_, Value_>::type;

public:

    Line() {}

    Line(Vector_<Value_> const &point_1, Vector_<Value_> const &point_2) :
        point_1_(point_1),
        point_2_(point_2)
    {}


    Vector_<Value_> const &Point_1() const
    {
        return point_1_;
    }

    Vector_<Value_> Point_1()
    {
        return point_1_;
    }

    Vector_<Value_> const &Point_2() const
    {
        return point_2_;
    }

    Vector_<Value_> Point_2()
    {
        return point_2_;
    }


    Value_ DistanceToSegment(Vector_<Value_> const &point) const
    {
        if (Mag2() == Value_Square(0)) return Distance_1(point); // v == w case
        auto parameter = Paramter(point);
        if (parameter < 0) return Distance_1(point); // Beyond the 'v' end of the segment
        if (parameter > 1) return Distance_2(point); // Beyond the 'w' end of the segment
        return DistanceToLine(point); // Projection falls on the segment
    }

    Value_ DistanceToLine(Vector_<Value_> const &point) const
    {
        if (Mag2() == Value_Square(0)) return Distance_1(point); // v == w case
        return (point - Projection(point)).Mag();
    }


    Vector_<Value_> Vector() const
    {
        return point_2_ - point_1_;
    }

    Value_Square Mag2() const
    {
        return Vector().Mag2();
    }

    Value_ Mag() const
    {
        return Vector().Mag();
    }


    Vector_<Value_> Vector_1(Vector_<Value_> const &point) const
    {
        return point - point_1_;
    }

    Vector_<Value_> Vector_2(Vector_<Value_> const &point) const
    {
        return point - point_2_;
    }

    Value_ Distance_1(Vector_<Value_> const &point) const
    {
        return Vector_1(point).Mag();
    }

    Value_ Distance_2(Vector_<Value_> const &point) const
    {
        return Vector_2(point).Mag();
    }

    double Paramter(Vector_<Value_> const &point) const
    {
        // Consider the line extending the segment, parameterized as v + t (w - v).
        // We find projection of point p onto the line.
        // It falls where t = [(p-v) . (w-v)] / |w-v|^2
        return point * Vector() / Mag2();
    }

    Vector_<Value_> Projection(Vector_<Value_> const &point) const
    {
        return point_1_ + Vector() * Paramter(point);
    }


    friend auto &operator<<(std::ostream &stream, Line const &line)
    {
        stream << line.point_1_ << line.point_2_;
        return stream;
    }

private:

    Vector_<Value_> point_1_; // v

    Vector_<Value_> point_2_; // w

};

}