rect_lt.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 RectLT final
  {
 
#ifndef CVB_DOXYGEN
    static_assert(IsNumeric<T>::value, "CVB: Unsupported data type - must be numeric!");
  };
 
  template <class T>
  class RectLT<T, typename EnableIfNumeric<T>::type> final
  {
 
#endif
  public:
    using ValueType = T;


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


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


    RectLT(Point2D<T> location, Size2D<T> size) noexcept
    {
      SetLocation(location);
      SetSize(size);
    }
    RectLT(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_;
    }
    T Width() const noexcept {…}


    void SetWidth(T width) noexcept
    {
      right_ = left_ + width;
    }
    void SetWidth(T width) noexcept {…}


    T Height() const noexcept
    {
      return bottom_ - top_;
    }
    T Height() const noexcept {…}


    void SetHeight(T height) noexcept
    {
      bottom_ = top_ + height;
    }
    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 IsValid() const noexcept
    {
      return Width() > static_cast<T>(0.0) && Height() > static_cast<T>(0.0);
    }
    bool IsValid() const 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 RectLT<T> &rect) const noexcept
    {
      return (top_ == rect.top_ && left_ == rect.left_ && bottom_ == rect.bottom_ && right_ == rect.right_);
    }
    bool operator==(const RectLT<T> &rect) const noexcept {…}


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

    template <class C>
    explicit operator RectLT<C>() const noexcept
    {
      return RectLT<C>(static_cast<C>(Left()), static_cast<C>(Top()), static_cast<C>(Right()),
                       static_cast<C>(Bottom()));
    }
    explicit operator RectLT<C>() const noexcept {…}
 
  private:
    T left_;
    T top_;
    T right_;
    T bottom_;
  };
  class RectLT final {…};


  template <class T>
  inline RectLT<int> Round(const RectLT<T> &rhs) noexcept
  {
    static_assert(IsNumeric<T>::value, "CVB: Unsupported data type - must be numeric!");
    return RectLT<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 RectLT<int> Round(const RectLT<T> &rhs) noexcept {…}
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb