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:
    using ValueType = T;


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


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


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


    T Left() const noexcept
    {
      return left_;
    }
    T Left() const noexcept {…}


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


    T Top() const noexcept
    {
      return top_;
    }
    T Top() const noexcept {…}


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


    T Right() const noexcept
    {
      return right_;
    }
    T Right() const noexcept {…}


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


    T Bottom() const noexcept
    {
      return bottom_;
    }
    T Bottom() const noexcept {…}


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


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


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


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


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


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


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


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


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


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


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


    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 {…}


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

    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_;
  };
  class Rect final {…};


  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())));
  }
  inline Rect<int> Round(const Rect<T> &rhs) noexcept {…}
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb