Line2D.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#pragma once
 
#include <tracking/trackingUtilities/geometry/VectorUtil.h>
 
#include <tracking/trackingUtilities/numerics/EForwardBackward.h>
#include <tracking/trackingUtilities/numerics/ERightLeft.h>
#include <tracking/trackingUtilities/numerics/ESign.h>
 
#include <Math/Vector2D.h>
 
#include <cmath>
 
namespace Belle2 {
  namespace TrackingUtilities {

    class Line2D {
 
    public:
      Line2D()
        : m_n0(0.0)
        , m_n12(0.0, 0.0)
      {
      }

      Line2D(const double n0, const double n1, const double n2)
        : m_n0(n0)
        , m_n12(n1, n2)
      {
        normalize();
      }

      Line2D(const double n0, const ROOT::Math::XYVector& n12)
        : m_n0(n0)
        , m_n12(n12)
      {
        normalize();
      }

      static Line2D fromSlopeIntercept(const double slope, const double intercept)
      {
        return Line2D(intercept, slope, -EForwardBackward::c_Forward);
      }

      static Line2D fromSlopeIntercept(const double slope,
                                       const double intercept,
                                       const EForwardBackward orientation)
      {
        return Line2D(intercept * static_cast<double>(orientation), slope * static_cast<double>(orientation), -orientation);
      }

      static Line2D throughPoints(const ROOT::Math::XYVector& start, const ROOT::Math::XYVector& end)
      {
        return Line2D(VectorUtil::Cross(end, start), VectorUtil::Orthogonal(start - end));
      }
 
    public:
      double n0() const
      {
        return m_n0;
      }

      double n1() const
      {
        return m_n12.X();
      }

      double n2() const
      {
        return m_n12.Y();
      }

      const ROOT::Math::XYVector& n12() const
      {
        return m_n12;
      }
 
    public:
      void setN0(const double n0)
      {
        m_n0 = n0;
      }
 
    private:
      void setN1(const double n1)
      {
        m_n12.SetX(n1);
      }

      void setN2(const double n2)
      {
        m_n12.SetY(n2);
      }

      void setN12(const double n1, const double n2)
      {
        m_n12.SetXY(n1, n2);
      }

      void setN12(const ROOT::Math::XYVector& n12)
      {
        m_n12.SetXY(n12.X(), n12.Y());
      }
 
    public:
      void setN(const double n0, const double n1, const double n2)
      {
        setN0(n0);
        setN12(n1, n2);
        normalize();
      }

      void invalidate()
      {
        setN(0.0, 0.0, 0.0);
      }

      void setSlopeIntercept(const double slope, const double intercept)
      {
        setN0(intercept);
        setN1(slope);
        setN2(-1.0);
        normalize();
      }

      void setSlopeIntercept(const double slope,
                             const double intercept,
                             const EForwardBackward orientation)
      {
        setN0(intercept * static_cast<double>(orientation));
        setN1(slope * static_cast<double>(orientation));
        setN2(-orientation);
        normalize();
      }

      void normalize()
      {
        if (not isInvalid()) {
          scaleN(1.0 / normalization());
        }
      }

      void reverse()
      {
        scaleN(-1.0);
      }

      Line2D reversed() const
      {
        return Line2D(-n0(), -n1(), -n2());
      }
 
    private:
      void scaleN(const double factor)
      {
        m_n0 *= factor;
        m_n12 *= factor;
      }

      double normalizationSquared() const
      {
        return n12().Mag2();
      }

      double normalization() const
      {
        return sqrt(normalizationSquared());
      }
 
    public:
      double distance(const ROOT::Math::XYVector& point) const
      {
        return n0() + point.Dot(n12());
      }

      double distance(const double first, const double second) const
      {
        return n0() + first * n1() + second * n2();
      }

      double distanceToOrigin() const
      {
        return n0();
      }

      double absoluteDistance(const ROOT::Math::XYVector& point) const
      {
        return fabs(distance(point));
      }

      ERightLeft isRightOrLeft(const ROOT::Math::XYVector& point) const
      {
        return static_cast<ERightLeft>(sign(distance(point)));
      }

      bool isLeft(const ROOT::Math::XYVector& rhs) const
      {
        return isRightOrLeft(rhs) == ERightLeft::c_Left;
      }

      bool isRight(const ROOT::Math::XYVector& rhs) const
      {
        return isRightOrLeft(rhs) == ERightLeft::c_Right;
      }

      ROOT::Math::XYVector closest(const ROOT::Math::XYVector& point) const
      {
        const double closestParallel = -n0();
        const double closestOrthgonal = VectorUtil::unnormalizedOrthogonalComp(point, n12());
        return VectorUtil::compose(n12(), closestParallel, closestOrthgonal);
      }

      ROOT::Math::XYVector closestToOrigin() const
      {
        return n12() * (-n0());
      }

      double lengthOnCurve(const ROOT::Math::XYVector& from, const ROOT::Math::XYVector& to) const
      {
        return VectorUtil::unnormalizedOrthogonalComp(to, n12()) - VectorUtil::unnormalizedOrthogonalComp(from, n12());
      }

      bool isInvalid() const
      {
        return n0() == 0.0 and VectorUtil::isNull(n12());
      }

      ROOT::Math::XYVector tangential() const
      {
        return VectorUtil::Orthogonal(normal());
      }

      const ROOT::Math::XYVector& normal() const
      {
        return n12();
      }

      const ROOT::Math::XYVector& gradient() const
      {
        return n12();
      }

      ROOT::Math::XYVector support() const
      {
        return closestToOrigin();
      }

      EForwardBackward alignedWithFirst() const
      {
        return static_cast<EForwardBackward>(-sign(n2()));
      }

      EForwardBackward alignedWithSecond() const
      {
        return static_cast<EForwardBackward>(sign(n1()));
      }

      ROOT::Math::XYVector intersection(const Line2D& line) const;

      void moveBy(const ROOT::Math::XYVector& by)
      {
        m_n0 -= VectorUtil::unnormalizedParallelComp(by, n12());
      }

      void moveAlongFirst(const double first)
      {
        m_n0 -= n1() * first;
      }

      void moveAlongSecond(const double second)
      {
        m_n0 -= n2() * second;
      }

      Line2D movedAlongFirst(const double first) const
      {
        return Line2D(n0() - n1() * first, n1(), n2());
      }

      Line2D movedAlongSecond(const double second) const
      {
        return Line2D(n0() - n2() * second, n1(), n2());
      }

      void passiveMoveBy(const ROOT::Math::XYVector& by)
      {
        m_n0 += VectorUtil::unnormalizedParallelComp(by, n12());
      }

      void passiveMoveAlongFirst(const double first)
      {
        m_n0 += n1() * first;
      }

      void passiveMoveAlongSecond(const double second)
      {
        m_n0 += n2() * second;
      }

      Line2D passiveMovedAlongFirst(const double first) const
      {
        return Line2D(n0() + n1() * first, n1(), n2());
      }

      Line2D passiveMovedAlongSecond(const double second) const
      {
        return Line2D(n0() + n2() * second, n1(), n2());
      }

      void flipFirst()
      {
        m_n12.SetX(-m_n12.X());
      }

      void flipSecond()
      {
        m_n12.SetY(-m_n12.Y());
      }

      Line2D flippedFirst() const
      {
        return Line2D(n0(), ROOT::Math::XYVector(-n12().X(), n12().Y()));
      }

      Line2D flippedSecond() const
      {
        return Line2D(n0(), ROOT::Math::XYVector(n12().X(), -n12().Y()));
      }


      double slope() const
      {
        return -n1() / n2();
      }

      double inverseSlope() const
      {
        return -n2() / n1();
      }

      double intercept() const
      {
        return -n0() / n2();
      }

      double zero() const
      {
        return -n0() / n1();
      }

      double map(const double first) const
      {
        return -(n0() + n1() * first) / n2();
      }

      double operator()(const double first) const
      {
        return map(first);
      }

      double inverseMap(const double second) const
      {
        return -(n0() + n2() * second) / n1();
      }

      void invert()
      {
        m_n12.SetXY(m_n12.Y(), m_n12.X());
        reverse();
      }

      Line2D inverted() const
      {
        return Line2D(-n0(), -n2(), -n1());
      }

 
    private:
      double m_n0;

      ROOT::Math::XYVector m_n12;
 
    };
  }
}