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
 
}