LineSegment2D.hpp

#pragma once
#ifndef __H__OCULAR_MATH_LINE_SEGMENT_2D__H__
#define __H__OCULAR_MATH_LINE_SEGMENT_2D__H__

#include "Math/MathCommon.hpp"
#include "Math/Equality.hpp"
#include "Math/Vector2.hpp"

//------------------------------------------------------------------------------------------

namespace Ocular
{
    namespace Math
    {
        enum LineSegmentSide
        {
            RightOfSegment = -1,
            OnSegment = 0,
            LeftOfSegment = 1
        };

        template<typename T>
        class LineSegment2D
        {
        public:

            LineSegment2D(Vector2<T> const& a, Vector2<T> const& b)
            {
                m_A = a;
                m_B = b;

                updateLength();
            }

            LineSegment2D()
            {
                m_Length = static_cast<T>(0);
                m_LengthSquared = static_cast<T>(0);
            }
            
            ~LineSegment2D()
            {
            
            }

            Vector2<T> const& getA() const
            {
                return m_A;
            }

            Vector2<T> const& getB() const
            {
                return m_B;
            }

            void setA(Vector2<T> const& a)
            {
                m_A = a;
                updateLength();
            }

            void setB(Vector2<T> const& b)
            {
                m_B = b;
                updateLength();
            }

            T const& getLength() const
            {
                return m_Length;
            }

            T const& getLengthSquared() const
            {
                return m_LengthSquared;
            }

            LineSegmentSide whichSide(Vector2<T> const& point) const
            {
                LineSegmentSide result;
                const T value = ((m_B.x - m_A.x) * (point.y - m_A.y)) - ((m_B.y - m_A.y) * (point.x - m_A.x));
                
                if(IsZero<T>(value))
                {
                    result = OnSegment;
                }
                else
                {
                    result = (value < static_cast<T>(0)) ? RightOfSegment : LeftOfSegment;
                }

                return result;
            }

            T distanceTo(Vector2<T> const& point) const
            {
                T result;

                if(IsZero<T>(m_LengthSquared))
                {
                    const Vector2<T> pointToA = point - m_A;
                    result = pointToA.getLength();    
                }
                else
                {
                    const Vector2<T> pointToA = point - m_A;
                    const Vector2<T> pointToB = point - m_B;
                    const Vector2<T> bToA = m_B - m_A;

                    const T t = pointToA.dot(bToA) / m_LengthSquared;

                    if(t < static_cast<T>(0))
                    {
                        result = pointToA.getLength();
                    }
                    else if(t > static_cast<T>(1))
                    {
                        result = pointToB.getLength();
                    }
                    else
                    {
                        const Vector2<T> projection = m_A + ((m_B - m_A) * t);
                        const Vector2<T> vector = point - projection;

                        result = vector.getLength();
                    }
                }

                return result;
            }

        protected:

            void updateLength() 
            {
                const Vector2<T> vector = m_B - m_A;

                m_Length = vector.getLength();
                m_LengthSquared = m_Length * m_Length;
            }

        private:

            Vector2<T> m_A;
            Vector2<T> m_B;

            T m_Length;
            T m_LengthSquared;
        };

        //--------------------------------------------
        // Common formats

        typedef LineSegment2D<float>  LineSegment2Df;
        typedef LineSegment2D<double> LineSegment2Dd;
    }
}
//------------------------------------------------------------------------------------------

#endif