Rect.h

#pragma once

#include <fsdk/Types/Vector2.h>

namespace fsdk
{
    template <typename Type>
    struct BaseRect {
        typedef Type ElementType;
        
        Type x;             
        Type y;             
        Type width;         
        Type height;        

        BaseRect() noexcept
            : x(0)
            , y(0)
            , width(0)
            , height(0)
        {}

        BaseRect(
            Type x_,
            Type y_,
            Type w_,
            Type h_) noexcept
            : x(x_)
            , y(y_)
            , width(w_)
            , height(h_)
        {}

        BaseRect(
            const Vector2<Type>& topLeft,
            const Vector2<Type>& bottomRight) noexcept
        {
            set(topLeft, bottomRight);
        }

        BaseRect(const BaseRect& other) noexcept {
            *this = other;
        }
        
        template <typename OtherType>
        BaseRect(const BaseRect<OtherType>& other) noexcept {
            *this = other;
        }

        void setLeft(Type l) noexcept {
            const auto r = right();
            x = l;
            setRight(r);
        }

        void setTop(Type t) noexcept {
            const auto b = bottom();
            y = t;
            setBottom(b);
        }

        void setRight(Type r) noexcept {
            width = r - x;
        }

        void setBottom(Type b) noexcept {
            height = b - y;
        }

        static BaseRect coords(Type x0, Type y0, Type x1, Type y1) noexcept {
            return BaseRect(x0, y0, x1-x0, y1-y0);
        }
        
        static float intersectionOverFirstRect(const BaseRect &rect1, const BaseRect &rect2) {
            const float inter = (rect1 & rect2).getArea();
            return inter / rect1.getArea();
        }

        static float intersectionOverUnion(const BaseRect& rect1, const BaseRect& rect2) {
            const float inter = (rect1 & rect2).getArea();
            return inter / (rect1.getArea() + rect2.getArea() - inter);
        }

        static float intersectionOverForeground(const BaseRect &rect1, const BaseRect &rect2) {
            if (rect1.getArea() < rect2.getArea()) {
                return intersectionOverFirstRect(rect1, rect2);
            }
            return intersectionOverFirstRect(rect2, rect1);
        }

        template <typename OtherType>
        BaseRect& operator = (const BaseRect<OtherType>& other) noexcept {
            if(reinterpret_cast<const void*>(this) != reinterpret_cast<const void*>(&other)) {
                x = static_cast<Type>(other.x);
                y = static_cast<Type>(other.y);
                width = static_cast<Type>(other.width);
                height = static_cast<Type>(other.height);
            }
            return *this;
        }

        template <typename OtherType>
        bool operator == (const BaseRect<OtherType>& other) const noexcept {
            return
                x == other.x &&
                y == other.y &&
                width == other.width &&
                height == other.height;
        }

        template <typename OtherType>
        bool operator != (const BaseRect<OtherType>& other) const noexcept {
            return !(*this == other);
        }

        BaseRect operator & (const BaseRect& other) const noexcept {
            BaseRect newRect;
            newRect.x = x > other.x ? x : other.x;
            newRect.y = y > other.y ? y : other.y;
            newRect.width = (x + width < other.x + other.width ? x + width : other.x + other.width) - newRect.x;
            newRect.height = (y + height < other.y + other.height ? y + height : other.y + other.height) - newRect.y;
            if (newRect.width <= 0 || newRect.height <= 0)
                newRect = BaseRect();
            return newRect;
        }

        BaseRect operator &= (const BaseRect& other) noexcept {
            if(this != &other)
                *this = *this & other;

            return *this;
        }

        BaseRect operator | (const BaseRect& other) const noexcept {
            BaseRect newRect;
            newRect.x = x < other.x ? x : other.x;
            newRect.y = y < other.y ? y : other.y;
            newRect.width = (x + width > other.x + other.width ? x + width : other.x + other.width) - newRect.x;
            newRect.height = (y + height > other.y + other.height ? y + height : other.y + other.height) - newRect.y;

            return newRect;
        }

        BaseRect operator |= (const BaseRect& other) noexcept {
            if(this != &other)
                *this = *this & other;

            return *this;
        }

        BaseRect operator * (float scaleFactor) const noexcept {
            BaseRect newRect;
            newRect.x = static_cast<Type>(x * scaleFactor);
            newRect.y = static_cast<Type>(y * scaleFactor);
            newRect.width = static_cast<Type>(width * scaleFactor);
            newRect.height = static_cast<Type>(height * scaleFactor);

            return newRect;
        }

        BaseRect operator / (float scaleFactor) const noexcept {
            BaseRect newRect;
            newRect.x = static_cast<Type>(x / scaleFactor);
            newRect.y = static_cast<Type>(y / scaleFactor);
            newRect.width = static_cast<Type>(width / scaleFactor);
            newRect.height = static_cast<Type>(height / scaleFactor);

            return newRect;
        }
        
        BaseRect operator + (Vector2<typename BaseRect::ElementType> vec) {
            BaseRect newRect = *this;
            newRect.x += vec.x;
            newRect.y += vec.y;
            
            return newRect;
        }
        
        BaseRect operator - (Vector2<typename BaseRect::ElementType> vec) {
            BaseRect newRect = *this;
            newRect.x -= vec.x;
            newRect.y -= vec.y;
            
            return newRect;
        }
        
        Vector2<Type> size() const noexcept {
            return Vector2<Type>(width, height);
        }

        Vector2<Type> topLeft() const noexcept {
            return Vector2<Type>(x, y);
        }

        Vector2<Type> center() const noexcept {
            return Vector2<Type>(
                x + width / 2,
                y + height / 2);
        }

        Vector2<Type> bottomRight() const noexcept {
            return Vector2<Type>(x + width, y + height);
        }

        Type top() const noexcept { return y; }

        Type bottom() const noexcept { return y + height; }

        Type left() const noexcept { return x; }

        Type right() const noexcept { return x + width; }

        void set(const Vector2<Type>& topLeft,
            const Vector2<Type>& bottomRight) noexcept {
            x = topLeft.x;
            y = topLeft.y;
            width = bottomRight.x - x;
            height = bottomRight.y - y;
        }

        void adjust(Type dx, Type dy, Type dw, Type dh) noexcept {
            x += dx;
            y += dy;
            width += dw;
            height += dh;
        }

        BaseRect adjusted(Type dx, Type dy, Type dw, Type dh) const noexcept {
            BaseRect rect(*this);
            rect.adjust(dx, dy, dw, dh);
            return rect;
        }

        Type getArea() const noexcept { return width * height; }

        bool inside(const BaseRect& other) const noexcept {
            return
                topLeft() >= other.topLeft() &&
                bottomRight() <= other.bottomRight();
        }


        bool isValid() const noexcept {
            return width > 0 && height > 0;
        }
    };
    
    template <typename Type>
    BaseRect<Type> centerScale(const BaseRect<Type>& in, float scaleFactor) noexcept {
        BaseRect<Type> out;
        out.x = in.x - 0.5*(scaleFactor-1)*in.width;
        out.y = in.y - 0.5*(scaleFactor-1)*in.height;
        out.width = in.width * scaleFactor;
        out.height = in.height * scaleFactor;
        return out;
    }
    
    using Rect = BaseRect<int>;
    using FloatRect = BaseRect<float>;
}