point_2d.hpp

#pragma once
 
#include <cmath>
#include <cassert>
 
#include "global.hpp"
 
#include "angle.hpp"
 
namespace Cvb
{
 
CVB_BEGIN_INLINE_NS
 
 
template< class T, class ENABLE = void>
class Point2D final
{
 
#ifndef CVB_DOXYGEN
  static_assert(std::is_arithmetic<T>::value, "CVB: Unsupported data type - must be arithmetic!");
};
 
 
template <class T>
class Point2D<T,
  typename EnableIfArithmetic<T>::type> final
{
 
#endif
 
  public:
 
 
    Point2D() noexcept = default;
 
 
 
    Point2D(T x, T y) noexcept
      : x_(x)
      , y_(y)
    {
    }
 
 
    Point2D(Angle phi, T r) noexcept
      : Point2D(static_cast<T>(static_cast<double>(r) * Cos(phi)),
        static_cast<T>(static_cast<double>(r) * Sin(phi)))
    {
    }
 
 
    template<std::size_t N>
    Point2D(const T(&list)[N]) noexcept // NOLINT
    {
      static_assert(N == 2, "CVB: Point2D must have 2 elements");
      std::copy(std::begin(list), std::end(list), &x_);
    }
 
 
    T X() const noexcept
    {
      return x_;
    }
 
 
    void SetX(T x) noexcept
    {
      x_ = x;
    }
 
 
    T Y() const noexcept
    {
      return y_;
    }
 
 
    void SetY(T y)
    {
      y_ = y;
    }
 
 
    T Length() const noexcept
    {
      return static_cast<T>(sqrt(static_cast<double>(x_) * static_cast<double>(x_)
        + static_cast<double>(y_) * static_cast<double>(y_)));
    }
 
 
    void SetLength(T length) noexcept
    {
      *this = Point2D<T>(Phi(), length);
    }
 
 
    Angle Phi() const noexcept
    {
      return Atan2(static_cast<double>(y_), static_cast<double>(x_));
    }
 
 
    void SetPhi(Angle phi) noexcept
    {
      *this = Point2D<T>(phi, Length());
    }
 
 
 
 
 
    bool operator==(const Point2D<T>& other) const noexcept
    {
      return (x_ == other.x_ && y_ == other.y_);
    }
 
 
 
    bool operator!=(const Point2D<T>& other) const noexcept
    {
      return !(*this == other);
    }
 
    template <class C>
    explicit operator Point2D<C>() const noexcept
    {
      static_assert(std::is_floating_point<C>::value,
                    "CVB: Unsupported data type - must be floating point!");
      return Point2D<C>(static_cast<C>(X()), static_cast<C>(Y()));
    }
 
 
    Point2D<T>& operator +=(const Point2D<T> & point) noexcept
    {
      x_ += point.x_;
      y_ += point.y_;
      return *this;
    }
 
 
    Point2D<T>& operator -=(const Point2D<T> & point) noexcept
    {
      x_ -= point.x_;
      y_ -= point.y_;
      return *this;
    }
 
 
    Point2D<T>& operator *=(const T & value) noexcept
    {
      x_ *= value;
      y_ *= value;
      return *this;
    }
 
 
    Point2D<T>& operator /=(const T & value) noexcept
    {
      x_ /= value;
      y_ /= value;
      return *this;
    }
 
 
 
    const T& operator[](int index) const noexcept
    {
      assert(index < 2 && index >= 0);
      return *(&x_ + index);
    }
 
 
    T& operator[](int index) noexcept
    {
      assert(index < 2 && index >= 0);
      return *(&x_ + index);
    }
 
  private:
 
    T x_ = static_cast<T>(0);
    T y_ = static_cast<T>(0);
 
 
};
 
 
template <class T>
inline Point2D<T> operator+(const Point2D<T> & lhs, const Point2D<T> & rhs)
{
  return Point2D<T>(lhs.X() + rhs.X(), lhs.Y() + rhs.Y());
}
 
 
template <class T>
inline Point2D<T> operator-(const Point2D<T> & lhs, const Point2D<T> & rhs)
{
  return Point2D<T>(lhs.X() - rhs.X(), lhs.Y() - rhs.Y());
}
 
 
template <class T>
inline T operator*(const Point2D<T> & lhs, const Point2D<T> & rhs)
{
  return lhs.X() * rhs.X() + lhs.Y() * rhs.Y();
}
 
 
template <class T>
inline Point2D<T> operator*(const Point2D<T> & lhs, const T & rhs)
{
  return Point2D<T>(lhs.X() * rhs, lhs.Y() * rhs);
}
 
 
template <class T>
inline Point2D<T> operator*(const T & lhs, const Point2D<T> & rhs)
{
  return rhs * lhs;
}
 
 
template <class T>
inline Point2D<T> operator/(const Point2D<T> & lhs, const T & rhs)
{
  return Point2D<T>(lhs.X() / rhs, lhs.Y() / rhs);
}
 
 
template <class T>
inline Point2D<int> Round(const Point2D<T> & rhs) noexcept
{
  static_assert(IsNumeric<T>::value, "CVB: Unsupported data type - must be numeric!");
  return Point2D<int>(static_cast<int>(std::round(rhs.X())), static_cast<int>(std::round(rhs.Y())));
}
 
template<class T>
using Vector2D = Point2D<T>;
 
CVB_END_INLINE_NS
 
 
}