Rect.h

//  trax track library
//  AD 2014 
//
//  "Dream On"
//
//          Aerosmith
//
// Copyright (c) 2025 Trend Redaktions- und Verlagsgesellschaft mbH
// Copyright (c) 2019 Marc-Michael Horstmann
//
// Permission is hereby granted to any person obtaining a copy of this software 
// and associated source code (the "Software"), to use, view, and study the 
// Software for personal or internal business purposes, subject to the following 
// conditions:
//
// 1. Redistribution, modification, sublicensing, or commercial use of the 
// Software is NOT permitted without prior written consent from the copyright 
// holder.
//
// 2. The Software is provided "AS IS", without warranty of any kind, express 
// or implied.
//
// 3. All copies of the Software must retain this license notice.
//
// For further information, please contact: horstmann.marc@trendverlag.de
 
#pragma once
 
#include "common/Interval.h"
 
 
namespace spat{
 
    template<typename> struct Position2D;
    template<typename> struct Vector2D;
 

    template<typename Valtype> 
    struct Rect
    {
        typedef Valtype value_type;
 
        common::Interval<Valtype>   m_Width;    
        common::Interval<Valtype>   m_Height;   

                    Rect() noexcept = default;          
                    Rect( Valtype width, Valtype height ) noexcept;
                    Rect( const common::Interval<Valtype>& width, const common::Interval<Valtype>& height ) noexcept;
        explicit    Rect( const Vector2D<Valtype>& diagonal ) noexcept;
                    Rect( const Position2D<Valtype>& lefttop, const Position2D<Valtype>& rightbottom ) noexcept;
                    Rect( Valtype left, Valtype top, Valtype right, Valtype bottom ) noexcept;
 

        Rect& Init() noexcept;
 
        Rect& Init( Valtype left, Valtype top, Valtype width, Valtype height ) noexcept;
 

        bool Normal() const noexcept;
 

        Rect& Normalize() noexcept;
 

        Valtype Left() const noexcept;
 

        Valtype Top() const noexcept;
 

        Valtype Right() const noexcept;
 

        Valtype Bottom() const noexcept;
 
 
        Rect& Left( Valtype val ) noexcept; 
        Rect& Top( Valtype val ) noexcept;  
        Rect& Right( Valtype val ) noexcept;    
        Rect& Bottom( Valtype val ) noexcept;   
 
        Position2D<Valtype> LeftTop     () const noexcept;  
        Position2D<Valtype> LeftBottom  () const noexcept;  
        Position2D<Valtype> RightBottom () const noexcept;  
        Position2D<Valtype> RightTop    () const noexcept;  
        Position2D<Valtype> Center      () const noexcept;  
 

        Valtype Width() const noexcept;
 

        Valtype Height() const noexcept;
 

        auto Area() const noexcept -> decltype(Valtype{}*Valtype{});
 

        Valtype Diagonal() const noexcept;
 

        bool IsArea() const noexcept;
 

        Rect& Union( const Rect& r1, const Rect& r2 ) noexcept;
 

        Rect& Union( const Rect& rect ) noexcept;
 

        Rect& Intersection( const Rect& r1, const Rect& r2 ) noexcept;
        
        
        Rect& Intersection( const Rect& rect ) noexcept;
 

        bool Includes( Valtype x, Valtype y ) const noexcept;
 

        bool Includes( const Position2D<Valtype>& pt ) const noexcept;
 

        Rect& Expand( Valtype x, Valtype y ) noexcept;
 

        Rect& Expand( const Position2D<Valtype>& pt ) noexcept;
 

        Rect& Inflate( Valtype dx, Valtype dy ) noexcept;
 

        Rect& Deflate( Valtype dx, Valtype dy ) noexcept;
 

        Rect& Move( Valtype dx, Valtype dy ) noexcept;
 
        Rect& Move( const Vector2D<Valtype>& offset ) noexcept;
    };
 

    template<typename Valtype>
    void            operator+=( Rect<Valtype>& r1, const Rect<Valtype>& r2 ) noexcept;
    template<typename Valtype>
    Rect<Valtype>   operator+( const Rect<Valtype>& r1, const Rect<Valtype>& r2 ) noexcept;
    template<typename Valtype> constexpr 
    bool operator==( const Rect<Valtype>& r1, const Rect<Valtype>& r2 ) noexcept;
    template<typename Valtype> constexpr 
    bool operator!=( const Rect<Valtype>& r1, const Rect<Valtype>& r2 ) noexcept;
 
 

    template<typename Valtype> 
    bool Intersect( const Rect<Valtype>& r1, const Rect<Valtype>& r2 ) noexcept;

//inlines:
template<typename Valtype> inline 
Rect<Valtype>::Rect( Valtype width, Valtype height ) noexcept
    :   m_Width {-width/2,width/2},
        m_Height{-height/2,height/2}
{}
 
template<typename Valtype> inline 
Rect<Valtype>::Rect( const common::Interval<Valtype>& width, const common::Interval<Valtype>& height ) noexcept
    :   m_Width {width},
        m_Height{height}
{}
 
template<typename Valtype> inline 
Rect<Valtype>::Rect( const Vector2D<Valtype>& diagonal ) noexcept
    :   m_Width {-diagonal.dx/2,diagonal.dx/2},
        m_Height{-diagonal.dy/2,diagonal.dy/2}
{}
 
template<typename Valtype> inline 
Rect<Valtype>::Rect( const Position2D<Valtype>& lefttop, const Position2D<Valtype>& rightbottom ) noexcept
    :   m_Width {lefttop.x,rightbottom.x},
        m_Height{lefttop.y,rightbottom.y}
{}
 
template<typename Valtype> inline 
Rect<Valtype>::Rect( Valtype left, Valtype top, Valtype right, Valtype bottom ) noexcept
    :   m_Width {left,right},
        m_Height{top,bottom}
{}
 
template<typename Valtype> inline
Rect<Valtype>& Rect<Valtype>::Init() noexcept{
    m_Width.Init();
    m_Height.Init();
    return *this;
}
 
template<typename Valtype> inline
Rect<Valtype>& Rect<Valtype>::Init( Valtype left, Valtype top, Valtype width, Valtype height ) noexcept{
    m_Width.Init( left, width );
    m_Height.Init( top, height );
    return *this;
}
 
template<typename Valtype> inline
bool Rect<Valtype>::Normal() const noexcept{
    return m_Width.Normal() && m_Height.Normal();
}
 
template<typename Valtype> inline
Rect<Valtype>& Rect<Valtype>::Normalize() noexcept{
    m_Width.Normalize();
    m_Height.Normalize();
    return *this;
}
 
template<typename Valtype> inline 
Valtype Rect<Valtype>::Left() const noexcept{
    return m_Width.m_Near;
}
 
template<typename Valtype> inline 
Valtype Rect<Valtype>::Top() const noexcept{
    return m_Height.m_Near;
}
 
template<typename Valtype> inline 
Valtype Rect<Valtype>::Right() const noexcept{
    return m_Width.m_Far;
}
 
template<typename Valtype> inline 
Valtype Rect<Valtype>::Bottom() const noexcept{
    return m_Height.m_Far;
}
 
template<typename Valtype> inline 
Rect<Valtype>& Rect<Valtype>::Left( Valtype val ) noexcept{
    m_Width.Near(val);
    return *this;
}
 
template<typename Valtype> inline 
Rect<Valtype>& Rect<Valtype>::Top( Valtype val ) noexcept{
    m_Height.Near(val);
    return *this;
}
 
template<typename Valtype> inline 
Rect<Valtype>& Rect<Valtype>::Right( Valtype val ) noexcept{
    m_Width.Far(val);
    return *this;
}
 
template<typename Valtype> inline 
Rect<Valtype>& Rect<Valtype>::Bottom( Valtype val ) noexcept{
    m_Height.Far(val);
    return *this;
}
 
template<typename Valtype> inline 
Position2D<Valtype> Rect<Valtype>::LeftTop() const noexcept{
    return { m_Width.Near(), m_Height.Near() };
}
 
template<typename Valtype> inline 
Position2D<Valtype> Rect<Valtype>::LeftBottom() const noexcept{
    return { m_Width.Near(), m_Height.Far() };
}
 
template<typename Valtype> inline 
Position2D<Valtype> Rect<Valtype>::RightBottom() const noexcept{
    return { m_Width.Far(), m_Height.Far() };
}
 
template<typename Valtype> inline 
Position2D<Valtype> Rect<Valtype>::RightTop () const noexcept{
    return { m_Width.Far(), m_Height.Near() };
}
 
template<typename Valtype> inline 
Position2D<Valtype> Rect<Valtype>::Center() const noexcept{
    return { m_Width.Center(), m_Height.Center() };
}
 
template<typename Valtype> inline
Valtype Rect<Valtype>::Width() const noexcept{
    return m_Width.Length();
}
 
template<typename Valtype> inline
Valtype Rect<Valtype>::Height() const noexcept{
    return m_Height.Length();
}
 
template<typename Valtype> inline
auto Rect<Valtype>::Area() const noexcept -> decltype(Valtype{}*Valtype{}){
    return Width() * Height();
}
 
template<typename Valtype> inline
Valtype Rect<Valtype>::Diagonal() const noexcept{
    return sqrt( Square(Width()) + Square(Height()) );
}
 
template<typename Valtype> inline
bool Rect<Valtype>::IsArea() const noexcept{
    return (Normal() && Area() != 0.0f);
}
 
template<typename Valtype> inline
Rect<Valtype>& Rect<Valtype>::Union( 
        const Rect<Valtype>& r1, const Rect<Valtype>& r2 ) noexcept
{
    m_Width.Union( r1.m_Width, r2.m_Width );
    m_Height.Union( r1.m_Height, r2.m_Height );
    return *this;
}
 
template<typename Valtype> inline
Rect<Valtype>& Rect<Valtype>::Union( const Rect<Valtype>& rect ) noexcept
{
    m_Width.Union( rect.m_Width );
    m_Height.Union( rect.m_Height );
    return *this;
}
 
template<typename Valtype> inline
Rect<Valtype>& Rect<Valtype>::Intersection( 
        const Rect<Valtype>& r1, const Rect<Valtype>& r2 ) noexcept
{
    m_Width.Intersection( r1.m_Width, r2.m_Width );
    m_Height.Intersection( r1.m_Height, r2.m_Height );
    return *this;
}
 
template<typename Valtype> inline
Rect<Valtype>& Rect<Valtype>::Intersection( const Rect& rect ) noexcept
{
    m_Width.Intersection( rect.m_Width );
    m_Height.Intersection( rect.m_Height );
    return *this;
}
 
template<typename Valtype> inline
bool Rect<Valtype>::Includes( Valtype x, Valtype y ) const noexcept{
    return m_Width.Includes( x ) && m_Height.Includes( y );
}
 
template<typename Valtype> inline
bool Rect<Valtype>::Includes( const Position2D<Valtype>& pt ) const noexcept{
    return Includes( pt.x, pt.y );
}
 
template<typename Valtype> inline
Rect<Valtype>& Rect<Valtype>::Expand( Valtype x, Valtype y ) noexcept{
    m_Width.Expand( x );
    m_Height.Expand( y );
    return *this;
}
 
template<typename Valtype> inline
Rect<Valtype>& Rect<Valtype>::Expand( const Position2D<Valtype>& pt ) noexcept{
    return Expand( pt.x, pt.y );
}
 
template<typename Valtype> inline
Rect<Valtype>& Rect<Valtype>::Inflate( Valtype dx, Valtype dy ) noexcept{
    m_Width.Inflate( dx );
    m_Height.Inflate( dy );
    return *this;
}
 
template<typename Valtype> inline
Rect<Valtype>& Rect<Valtype>::Deflate( Valtype dx, Valtype dy ) noexcept{
    return Inflate( -dx, -dy );
}
 
template<typename Valtype> inline
Rect<Valtype>& Rect<Valtype>::Move( Valtype dx, Valtype dy ) noexcept{
    m_Width.Move( dx );
    m_Height.Move( dy );
    return *this;
}
 
template<typename Valtype> inline 
Rect<Valtype>& Rect<Valtype>::Move( const Vector2D<Valtype>& offset ) noexcept{
    return Move( offset.dx, offset.dy );
}
 
template<typename Valtype> inline
void operator+=( Rect<Valtype>& r1, const Rect<Valtype>& r2 ) noexcept{
    r1.Union(r2);
}
 
template<typename Valtype> inline
Rect<Valtype> operator+( const Rect<Valtype>& r1, const Rect<Valtype>& r2 ) noexcept{
    Rect<Valtype> retval;
    retval.Union( r1, r2 );
    return retval;
}
 
template<typename Valtype> inline
bool Intersect( const Rect<Valtype>& r1, const Rect<Valtype>& r2 ) noexcept{
    return Intersect( r1.m_Width, r2.m_Width ) && Intersect( r1.m_Height, r2.m_Height );
}
 
template<typename Valtype> constexpr 
inline bool operator==( const Rect<Valtype>& r1, const Rect<Valtype>& r2 ) noexcept{
    return r1.m_Width == r2.m_Width && r1.m_Height == r2.m_Height;
}
 
template<typename Valtype> constexpr 
inline bool operator!=( const Rect<Valtype>& r1, const Rect<Valtype>& r2 ) noexcept{
    return !(r1 == r2);
}
 
} // namespace spat