rect.hpp

#pragma once

#include <cmath>

#include "global.hpp"
#include "size_2d.hpp"
#include "point_2d.hpp"



namespace Cvb
{

CVB_BEGIN_INLINE_NS


template< class T, class ENABLE = void>
class Rect final
{

#ifndef CVB_DOXYGEN
  static_assert (IsNumeric<T>::value, "CVB: Unsupported data type - must be numeric!");
};


template <class T>
class Rect<T,
  typename EnableIfNumeric<T>::type> final
{

#endif
  public:



    Rect() noexcept
      : left_(static_cast<T>(0))
      , top_(static_cast<T>(0))
      , right_(static_cast<T>(-1))
      , bottom_(static_cast<T>(-1))
    {};

    


    Rect(T left, T top, T right, T bottom) noexcept
    {
      SetLeft(left);
      SetTop(top);
      SetRight(right);
      SetBottom(bottom);
    }


    Rect(Point2D<T> location, Size2D<T> size) noexcept
    {
      SetLocation(location);
      SetSize(size);
    }


    T Left() const noexcept
    {
      return left_;
    }


    void SetLeft(T left) noexcept
    {
      left_ = left;
    }


    T Top() const noexcept
    {
      return top_;
    }


    void SetTop(T top) noexcept
    {
      top_ = top;
    }


    T Right() const noexcept
    {
      return right_;
    }


    void SetRight(T right) noexcept
    {
      right_ = right;
    }


    T Bottom() const noexcept
    {
      return bottom_;
    }


    void SetBottom(T bottom) noexcept
    {
      bottom_ = bottom;
    }


    T Width() const noexcept
    {
      return right_ - left_ + static_cast<T>(1);
    }


    void SetWidth(T width) noexcept
    {
      right_ = left_ + width - static_cast<T>(1);
    }


    T Height() const noexcept
    {
      return bottom_ - top_ + static_cast<T>(1);
    }


    void SetHeight(T height) noexcept
    {
      bottom_ = top_ + height - static_cast<T>(1);
    }


    Size2D<T> Size() const noexcept
    {
      return Size2D<T>(Width(), Height());
    }


    void SetSize(Size2D<T> size) noexcept
    {
      SetWidth(size.Width());
      SetHeight(size.Height());
    }


    Point2D<T> Location() const noexcept
    {
      return Point2D<T>(left_, top_);
    }


    void SetLocation(Point2D<T> location) noexcept
    {
      right_ = location.X() + Width();
      bottom_ = location.Y() + Height();
      left_ = location.X();
      top_ = location.Y();
    }


    bool Contains(Point2D<T> point) const noexcept
    {
      return (point.X() >= Left()) && (point.Y() >= Top()) && (point.X() <= Right()) && (point.Y() <= Bottom());
    }



    CoordinateSystemType CoordinateSystem() const noexcept
    {
      return CoordinateSystemType::PixelCoordinates;
    }


    bool operator==(const Rect<T>& rect) const noexcept
    {
      return (top_ == rect.top_
        && left_ == rect.left_
        && bottom_ == rect.bottom_
        && right_ == rect.right_);
    }



    bool operator!=(const Rect<T>& rect) const noexcept
    {
      return !(*this == rect);
    }

    template<class C>
    explicit operator Rect<C, typename std::enable_if<std::is_integral<C>::value>::type>() const noexcept
    {
      return Rect<C>(
        static_cast<C>(Left()),
        static_cast<C>(Top()),
        static_cast<C>(Right()),
        static_cast<C>(Bottom())
      );
    }

    template<class C>
    explicit operator Rect<C, typename std::enable_if<!std::is_integral<C>::value>::type>() const noexcept
    {
      return Rect<C>(
        static_cast<C>(Left()),
        static_cast<C>(Top()),
        static_cast<C>(Right()),
        static_cast<C>(Bottom())
      );
    }

  private:

    T left_;
    T top_;
    T right_;
    T bottom_;
};



template <class T>
inline Rect<int> Round(const Rect<T> & rhs) noexcept
{
  static_assert(IsNumeric<T>::value, "CVB: Unsupported data type - must be numeric!");
  return Rect<int>(static_cast<int>(std::round(rhs.Left())),
    static_cast<int>(std::round(rhs.Top())),
    static_cast<int>(std::round(rhs.Right())),
    static_cast<int>(std::round(rhs.Bottom())));
}

CVB_END_INLINE_NS

}