Circle2D.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/ERightLeft.h>
#include <tracking/trackFindingCDC/numerics/ERotation.h>
#include <tracking/trackFindingCDC/numerics/ESign.h>
 
#include <cmath>
 
namespace Belle2 {
  namespace TrackFindingCDC {
 
    class Circle2D {
 
    public:
      Circle2D()
        : m_center(0.0, 0.0)
        , m_radius(0.0)
      {
      }
 
      Circle2D(const Vector2D& center, const double radius)
        : m_center(center)
        , m_radius(radius)
      {
      }
 
      Circle2D(const Vector2D& center, const double absRadius, const ERotation ccwInfo)
        : m_center(center)
        , m_radius(fabs(absRadius) * static_cast<double>(ccwInfo))
      {
      }
 
    public:
      void reverse()
      {
        m_radius *= -1;
      }
 
      Circle2D reversed() const
      {
        return Circle2D(center(), -radius());
      }
 
      void conformalTransform()
      {
        double denominator = 1 / (center().normSquared() - radius() * radius());
        m_center *= denominator;
        m_radius *= -denominator;
      }
 
      Circle2D conformalTransformed() const
      {
        double denominator = 1 / (center().normSquared() - radius() * radius());
        return Circle2D(center() * denominator, -radius() * denominator);
      }
 
    public:
      double distance(const Vector2D& point) const
      {
        return copysign(center().distance(point), radius()) - radius();
      }
 
      double impact() const
      {
        return copysign(center().norm(), radius()) - radius();
      }
 
      double absDistance(const Vector2D& point) const
      {
        return fabs(center().distance(point) - absRadius());
      }
 
      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
      {
        Vector2D connection = point - center();
        connection.normalizeTo(absRadius());
        connection += center();
        return connection;
      }
 
      Vector2D perigee() const
      {
        Vector2D connection = center();
        connection.normalizeTo(-absRadius());
        connection += center();
        return connection;
      }
 
      Vector2D tangential() const
      {
        return tangential(Vector2D(0.0, 0.0)).unit();
      }
 
      double tangentialPhi() const
      {
        return tangential().phi();
      }
 
      Vector2D gradient(const Vector2D& point) const
      {
        Vector2D connection = (point - center()) * orientation();
        return connection.unit();
      }
 
      Vector2D normal(const Vector2D& point) const
      {
        return gradient(point).unit();
      }
 
      Vector2D tangential(const Vector2D& point) const
      {
        return normal(point).orthogonal();
      }
 
      double openingAngle(const Vector2D& from, const Vector2D& to) const
      {
        return gradient(from).angleWith(gradient(to));
      } // can be optimized in the number of computations
 
      double arcLengthBetween(const Vector2D& from, const Vector2D& to) const
      {
        return openingAngle(from, to) * radius();
      }
 
      double radius() const
      {
        return m_radius;
      }
 
      double radiusSquared() const
      {
        return radius() * radius();
      }
 
      double absRadius() const
      {
        return fabs(radius());
      }
 
      ERotation orientation() const
      {
        return static_cast<ERotation>(sign(radius()));
      }
 
      Vector2D center() const
      {
        return m_center;
      }
 
      void moveBy(const Vector2D& by)
      {
        m_center += by;
      }
 
      void moveAlongFirst(const double first)
      {
        m_center.setFirst(m_center.first() + first);
      }
 
      void moveAlongSecond(const double second)
      {
        m_center.setSecond(m_center.second() + second);
      }
 
      void passiveMoveBy(const Vector2D& by)
      {
        m_center -= by;
      }
 
      void passiveMoveAlongFirst(const double first)
      {
        m_center.setFirst(m_center.first() - first);
      }
 
      void passiveMoveAlongSecond(const double second)
      {
        m_center.setSecond(m_center.second() - second);
      }
    private:
      Vector2D m_center;
 
      double m_radius;
 
    };
  }
}