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/trackFindingCDC/geometry/Vector2D.h>
 
#include <tracking/trackFindingCDC/numerics/EForwardBackward.h>
#include <tracking/trackFindingCDC/numerics/ERightLeft.h>
#include <tracking/trackFindingCDC/numerics/ESign.h>
 
#include <cmath>
 
namespace Belle2 {
  namespace TrackFindingCDC {
 
    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 Vector2D& 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 Vector2D& start, const Vector2D& end)
      {
        return Line2D(end.cross(start), (start - end).orthogonal());
      }
 
    public:
      double n0() const
      {
        return m_n0;
      }
 
      double n1() const
      {
        return m_n12.first();
      }
 
      double n2() const
      {
        return m_n12.second();
      }
 
      const Vector2D& n12() const
      {
        return m_n12;
      }
 
    public:
      void setN0(const double n0)
      {
        m_n0 = n0;
      }
 
    private:
      void setN1(const double n1)
      {
        m_n12.setFirst(n1);
      }
 
      void setN2(const double n2)
      {
        m_n12.setSecond(n2);
      }
 
      void setN12(const double n1, const double n2)
      {
        m_n12.set(n1, n2);
      }
 
      void setN12(const Vector2D& n12)
      {
        m_n12.set(n12);
      }
 
    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().normSquared();
      }
 
      double normalization() const
      {
        return sqrt(normalizationSquared());
      }
 
    public:
      double distance(const Vector2D& 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 Vector2D& point) const
      {
        return fabs(distance(point));
      }
 
      ERightLeft isRightOrLeft(const Vector2D& point) const
      {
        return static_cast<ERightLeft>(sign(distance(point)));
      }
 
      bool isLeft(const Vector2D& rhs) const
      {
        return isRightOrLeft(rhs) == ERightLeft::c_Left;
      }
 
      bool isRight(const Vector2D& rhs) const
      {
        return isRightOrLeft(rhs) == ERightLeft::c_Right;
      }
 
      Vector2D closest(const Vector2D& point) const
      {
        const double closestParallel = -n0();
        const double closestOrthgonal = point.unnormalizedOrthogonalComp(n12());
        return Vector2D(n12(), closestParallel, closestOrthgonal);
      }
 
      Vector2D closestToOrigin() const
      {
        return n12() * (-n0());
      }
 
      double lengthOnCurve(const Vector2D& from, const Vector2D& to) const
      {
        return to.unnormalizedOrthogonalComp(n12()) - from.unnormalizedOrthogonalComp(n12());
      }
 
      bool isInvalid() const
      {
        return n0() == 0.0 and n12().isNull();
      }
 
      Vector2D tangential() const
      {
        return normal().orthogonal();
      }
 
      const Vector2D& normal() const
      {
        return n12();
      }
 
      const Vector2D& gradient() const
      {
        return n12();
      }
 
      Vector2D support() const
      {
        return closestToOrigin();
      }
 
      EForwardBackward alignedWithFirst() const
      {
        return static_cast<EForwardBackward>(-sign(n2()));
      }
 
      EForwardBackward alignedWithSecond() const
      {
        return static_cast<EForwardBackward>(sign(n1()));
      }
 
      Vector2D intersection(const Line2D& line) const;
 
      void moveBy(const Vector2D& by)
      {
        m_n0 -= by.unnormalizedParallelComp(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 Vector2D& by)
      {
        m_n0 += by.unnormalizedParallelComp(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.flipFirst();
      }
 
      void flipSecond()
      {
        m_n12.flipSecond();
      }
 
      Line2D flippedFirst() const
      {
        return Line2D(n0(), n12().flippedFirst());
      }
 
      Line2D flippedSecond() const
      {
        return Line2D(n0(), n12().flippedSecond());
      }
      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.swapCoordinates();
        reverse();
      }
 
      Line2D inverted() const
      {
        return Line2D(-n0(), -n2(), -n1());
      }
    private:
      double m_n0;
 
      Vector2D m_n12;
 
    };
  }
}