ds_geometry.h

/* Copyright (C) 2017 - 2024, Thornwave Labs Inc - All Rights Reserved.
 * Unauthorized copying of this file, via any medium is strictly prohibited.
 * Proprietary and confidential.
 * Written by Razvan Turiac <razvan.turiac@thornwave.com>
*/
 
#ifndef _DS_GEOMETRY_H
#define _DS_GEOMETRY_H
 
 
#include <stdint.h>
 
#include <ds_math.h>
#include <ds_types.h>
 
 
class DsFPoint;
class DsSurface;
 
class DsPoint
{
public:
    DsPoint(): x(0), y(0)
    {
    }
 
    
    DsPoint(int32_t x, int32_t y): x(x), y(y)
    {
    }
 
 
    DsPoint& operator=(const DsFPoint &rhs);
 
 
    void swap(void)
    {
        const int32_t t = x;
        x = y;
        y = t;
    }
 
 
    bool operator==(const DsPoint &rhs)
    {
        return (x == rhs.x) && (y == rhs.y);
    }
 
 
    DsPoint operator-() const
    {
        DsPoint rv;
 
        rv.x = -x;
        rv.y = -y;
 
        return rv;
    }
 
    
    friend DsPoint operator+(const DsPoint &lhs, const DsPoint &rhs)
    {
        DsPoint r(lhs.x + rhs.x, lhs.y + rhs.y);
        return r;
    }
 
 
    friend DsPoint operator+(const DsPoint &lhs, int32_t rhs)
    {
        DsPoint r(lhs.x + rhs, lhs.y + rhs);
        return r;
    }
 
 
    DsPoint& operator+=(const DsPoint &rhs)
    {
        x += rhs.x;
        y += rhs.y;
 
        return *this;
    }
 
 
    DsPoint& operator+=(int32_t rhs)
    {
        x += rhs;
        y += rhs;
 
        return *this;
    }
 
 
    friend DsPoint operator-(const DsPoint &lhs, const DsPoint &rhs)
    {
        DsPoint r(lhs.x - rhs.x, lhs.y - rhs.y);
        return r;
    }
 
 
    friend DsPoint operator-(const DsPoint &lhs, int32_t rhs)
    {
        DsPoint r(lhs.x - rhs, lhs.y - rhs);
        return r;
    }
 
    
    DsPoint& operator-=(const DsPoint &rhs)
    {
        x -= rhs.x;
        y -= rhs.y;
 
        return *this;
    }
 
 
    DsPoint& operator-=(int32_t rhs)
    {
        x -= rhs;
        y -= rhs;
 
        return *this;
    }
 
    
    friend DsPoint operator*(const DsPoint &lhs, int32_t multiplier)
    {
        DsPoint r(lhs.x * multiplier, lhs.y * multiplier);
        return r;
    }
 
 
    friend DsPoint operator/(const DsPoint &lhs, int32_t divisor)
    {
        DsPoint r(lhs.x / divisor, lhs.y / divisor);
        return r;
    }
 
 
    friend DsPoint operator/(const DsPoint &lhs, float divisor)
    {
        DsPoint r(round(lhs.x / divisor), round(lhs.y / divisor));
        return r;
    }
 
 
    DsPoint saturateMin(const DsPoint &min)
    {
        DsPoint rv = *this;
 
        if (rv.x < min.x)
            rv.x = min.x;
        
        if (rv.y < min.y)
            rv.y = min.y;
 
        return rv;
    }
 
 
    DsPoint saturateMax(const DsPoint &max)
    {
        DsPoint rv = *this;
 
        if (rv.x > max.x)
            rv.x = max.x;
        
        if (rv.y > max.y)
            rv.y = max.y;
 
        return rv;
    }
 
 
    DsPoint saturate(const DsPoint &min, const DsPoint &max)
    {
        DsPoint rv = *this;
 
        if (rv.x < min.x)
            rv.x = min.x;
        else if (rv.x > max.x)
            rv.x = max.x;
        
        if (rv.y < min.y)
            rv.y = min.y;
        else if (rv.y > max.y)
            rv.y = max.y;
 
        return rv;
    }
 
 
    float distance(const DsPoint &p) const
    {
        const int32_t dx = p.x - x;
        const int32_t dy = p.y - y;
 
        return sqrt(dx * dx + dy * dy);
    }
 
 
    float distanceX(const DsPoint &p) const
    {
        return abs(p.x - x);
    }
 
    
    float distanceY(const DsPoint &p) const
    {
        return abs(p.y - y);
    }
 
 
    friend float distance(const DsPoint &p1, const DsPoint& p2)
    {
        const int32_t dx = p1.x - p2.x;
        const int32_t dy = p1.y - p2.y;
 
        return sqrt(dx * dx + dy * dy);
    }
 
    int32_t x;      
    int32_t y;      
};
 
 
 
 
class DsFPoint
{
public:
    DsFPoint(): x(0), y(0)
    {
    }
 
    
    DsFPoint(float x, float y): x(x), y(y)
    {
    }
 
    
    DsFPoint(const DsPoint &rhs): x(rhs.x), y(rhs.y)
    {
    }
 
 
    DsFPoint& operator=(const DsPoint &rhs)
    {
        x = rhs.x;
        y = rhs.y;
        
        return *this;
    }
 
    
    void swap(void)
    {
        const float t = x;
        x = y;
        y = t;
    }
 
 
    bool operator==(const DsFPoint &rhs)
    {
        return (x == rhs.x) && (y == rhs.y);
    }
 
 
    DsFPoint operator-() const
    {
        DsFPoint rv;
 
        rv.x = -x;
        rv.y = -y;
 
        return rv;
    }
 
    
    friend DsFPoint operator+(const DsFPoint &lhs, const DsFPoint &rhs)
    {
        DsFPoint r(lhs.x + rhs.x, lhs.y + rhs.y);
        return r;
    }
 
 
    friend DsFPoint operator+(const DsFPoint &lhs, float rhs)
    {
        DsFPoint r(lhs.x + rhs, lhs.y + rhs);
        return r;
    }
 
 
    DsFPoint& operator+=(const DsFPoint &rhs)
    {
        x += rhs.x;
        y += rhs.y;
 
        return *this;
    }
 
 
    DsFPoint& operator+=(float rhs)
    {
        x += rhs;
        y += rhs;
 
        return *this;
    }
 
 
    friend DsFPoint operator-(const DsFPoint &lhs, const DsFPoint &rhs)
    {
        DsFPoint r(lhs.x - rhs.x, lhs.y - rhs.y);
        return r;
    }
 
 
    friend DsFPoint operator-(const DsFPoint &lhs, float rhs)
    {
        DsFPoint r(lhs.x - rhs, lhs.y - rhs);
        return r;
    }
 
    
    DsFPoint& operator-=(const DsFPoint &rhs)
    {
        x -= rhs.x;
        y -= rhs.y;
 
        return *this;
    }
 
 
    DsFPoint& operator-=(float rhs)
    {
        x -= rhs;
        y -= rhs;
 
        return *this;
    }
 
    
    friend DsFPoint operator*(const DsFPoint &lhs, float multiplier)
    {
        DsFPoint r(lhs.x * multiplier, lhs.y * multiplier);
        return r;
    }
 
 
    friend DsFPoint operator/(const DsFPoint &lhs, float divisor)
    {
        DsFPoint r(lhs.x / divisor, lhs.y / divisor);
        return r;
    }
 
 
    DsFPoint saturateMin(const DsFPoint &min)
    {
        DsFPoint rv = *this;
 
        if (rv.x < min.x)
            rv.x = min.x;
        
        if (rv.y < min.y)
            rv.y = min.y;
 
        return rv;
    }
 
 
    DsFPoint saturateMax(const DsFPoint &max)
    {
        DsFPoint rv = *this;
 
        if (rv.x > max.x)
            rv.x = max.x;
        
        if (rv.y > max.y)
            rv.y = max.y;
 
        return rv;
    }
 
 
    DsFPoint saturate(const DsFPoint &min, const DsFPoint &max)
    {
        DsFPoint rv = *this;
 
        if (rv.x < min.x)
            rv.x = min.x;
        else if (rv.x > max.x)
            rv.x = max.x;
        
        if (rv.y < min.y)
            rv.y = min.y;
        else if (rv.y > max.y)
            rv.y = max.y;
 
        return rv;
    }
 
 
    float distance(const DsFPoint &p) const
    {
        const int32_t dx = p.x - x;
        const int32_t dy = p.y - y;
 
        return sqrt(dx * dx + dy * dy);
    }
 
 
    float distanceX(const DsFPoint &p) const
    {
        return abs(p.x - x);
    }
 
    
    float distanceY(const DsFPoint &p) const
    {
        return abs(p.y - y);
    }
    
    friend float distance(const DsFPoint &p1, const DsFPoint& p2)
    {
        const float dx = p1.x - p2.x;
        const float dy = p1.y - p2.y;
 
        return sqrt(dx * dx + dy * dy);
    }
 
 
    operator DsPoint() const
    {
        DsPoint r(x, y);
        return r;
    }
 
    float x;        
    float y;        
};
 
 
 
class DsSize
{
public:
    DsSize(): w(0), h(0)
    {
    }
 
 
    DsSize(int32_t w, int32_t h): w(w), h(h)
    {
    }
 
    
    DsSize(const DsPoint &p): w(p.x), h(p.y)
    {
    }
 
 
    bool operator==(const DsSize &rhs) const 
    {
        return (w == rhs.w) && (h == rhs.h);
    }
 
    
    bool operator!=(const DsSize &rhs) const 
    {
        return (w != rhs.w) || (h != rhs.h);
    }
 
    
    DsSize operator-() const
    {
        DsSize rv;
 
        rv.w = -w;
        rv.h = -h;
 
        return rv;
    }
 
    friend DsSize operator+(const DsSize &lhs, const DsSize &rhs)
    {
        DsSize r(lhs.w + rhs.w, lhs.h + rhs.h);
        return r;
    }
 
 
    friend DsSize operator+(const DsSize &lhs, int32_t rhs)
    {
        DsSize r(lhs.w + rhs, lhs.h + rhs);
        return r;
    }
 
 
    DsSize& operator+=(const DsSize &rhs)
    {
        w += rhs.w;
        h += rhs.h;
        return *this;
    }
 
 
    DsSize& operator+=(int32_t rhs)
    {
        w += rhs;
        h += rhs;
        return *this;
    }
 
 
    friend DsSize operator-(const DsSize &lhs, const DsSize &rhs)
    {
        DsSize r(lhs.w - rhs.w, lhs.h - rhs.h);
        return r;
    }
 
 
    friend DsSize operator-(const DsSize &lhs, int32_t rhs)
    {
        DsSize r(lhs.w - rhs, lhs.h - rhs);
        return r;
    }
 
 
    DsSize& operator-=(const DsSize &rhs)
    {
        w -= rhs.w;
        h -= rhs.h;
        return *this;
    }
 
 
    DsSize& operator-=(int32_t rhs)
    {
        w -= rhs;
        h -= rhs;
        return *this;
    }
 
 
    friend DsSize operator*(const DsSize &lhs, float multiplier)
    {
        DsSize r(round(lhs.w * multiplier), round(lhs.h * multiplier));
        return r;
    }
 
 
    friend DsSize operator/(const DsSize &lhs, float divisor)
    {
        DsSize r(round(lhs.w / divisor), round(lhs.h / divisor));
        return r;
    }
 
 
    DsSize saturateMin(const DsSize &min)
    {
        DsSize rv = *this;
 
        if (rv.w < min.w)
            rv.w = min.w;
        
        if (rv.h < min.h)
            rv.h = min.h;
 
        return rv;
    }
 
 
    DsSize saturateMax(const DsSize &max)
    {
        DsSize rv = *this;
 
        if (rv.w > max.w)
            rv.w = max.w;
        
        if (rv.h > max.h)
            rv.h = max.h;
 
        return rv;
    }
 
 
 
    DsSize swap(void)
    {
        DsSize rv = DsSize(h, w);
        return rv;
    }
 
 
 
    DsSize saturate(const DsSize &min, const DsSize &max)
    {
        DsSize rv = *this;
 
        if (rv.w < min.w)
            rv.w = min.w;
        else if (rv.w > max.w)
            rv.w = max.w;
        
        if (rv.h < min.h)
            rv.h = min.h;
        else if (rv.h > max.h)
            rv.h = max.h;
 
        return rv;
    }
 
 
    operator DsPoint() const
    {
        DsPoint r(w, h);
        return r;
    }
 
    operator DsFPoint() const
    {
        DsFPoint r(w, h);
        return r;
    }
 
    int32_t w;      
    int32_t h;      
};
 
 
 
class DsFSize
{
public:
    DsFSize(): w(0), h(0)
    {
    }
 
 
    DsFSize(float w, float h): w(w), h(h)
    {
    }
 
    
    DsFSize(const DsPoint &p): w(p.x), h(p.y)
    {
    }
 
    
    DsFSize(const DsFPoint &p): w(p.x), h(p.y)
    {
    }
 
 
    DsFSize(const DsSize &s): w(s.w), h(s.h)
    {
    }
 
 
    bool operator==(const DsFSize &rhs) const 
    {
        return (w == rhs.w) && (h == rhs.h);
    }
 
    
    bool operator!=(const DsFSize &rhs) const 
    {
        return (w != rhs.w) || (h != rhs.h);
    }
 
    
    DsFSize operator-() const
    {
        DsFSize rv;
 
        rv.w = -w;
        rv.h = -h;
 
        return rv;
    }
 
    friend DsFSize operator+(const DsFSize &lhs, const DsFSize &rhs)
    {
        DsFSize r(lhs.w + rhs.w, lhs.h + rhs.h);
        return r;
    }
 
 
    friend DsFSize operator+(const DsFSize &lhs, float rhs)
    {
        DsFSize r(lhs.w + rhs, lhs.h + rhs);
        return r;
    }
 
 
    DsFSize& operator+=(const DsFSize &rhs)
    {
        w += rhs.w;
        h += rhs.h;
        return *this;
    }
 
 
    DsFSize& operator+=(float rhs)
    {
        w += rhs;
        h += rhs;
        return *this;
    }
 
 
    friend DsFSize operator-(const DsFSize &lhs, const DsFSize &rhs)
    {
        DsFSize r(lhs.w - rhs.w, lhs.h - rhs.h);
        return r;
    }
 
 
    friend DsFSize operator-(const DsFSize &lhs, float rhs)
    {
        DsFSize r(lhs.w - rhs, lhs.h - rhs);
        return r;
    }
 
 
    DsFSize& operator-=(const DsFSize &rhs)
    {
        w -= rhs.w;
        h -= rhs.h;
        return *this;
    }
 
 
    DsFSize& operator-=(float rhs)
    {
        w -= rhs;
        h -= rhs;
        return *this;
    }
 
 
    friend DsFSize operator*(const DsFSize &lhs, float multiplier)
    {
        return DsFSize(lhs.w * multiplier, lhs.h * multiplier);
    }
 
 
    friend DsFSize operator*(const DsFSize &lhs, const DsFSize &rhs)
    {
        return DsFSize(lhs.w * rhs.w, lhs.h * rhs.h);
    }
 
 
    friend DsFSize operator/(const DsFSize &lhs, const DsFSize &rhs)
    {
        return DsFSize(lhs.w / rhs.w, lhs.h / rhs.h);
    }
 
 
    friend DsFSize operator/(const DsFSize &lhs, float divisor)
    {
        return DsFSize(lhs.w / divisor, lhs.h / divisor);
    }
 
 
    DsFSize swap(void)
    {
        DsFSize rv = DsFSize(h, w);
        return rv;
    }
 
 
    DsFSize saturateMin(const DsFSize &min)
    {
        DsFSize rv = *this;
 
        if (rv.w < min.w)
            rv.w = min.w;
        
        if (rv.h < min.h)
            rv.h = min.h;
 
        return rv;
    }
 
 
    DsFSize saturateMax(const DsFSize &max)
    {
        DsFSize rv = *this;
 
        if (rv.w > max.w)
            rv.w = max.w;
        
        if (rv.h > max.h)
            rv.h = max.h;
 
        return rv;
    }
 
 
    DsFSize saturate(const DsFSize &min, const DsFSize &max)
    {
        DsFSize rv = *this;
 
        if (rv.w < min.w)
            rv.w = min.w;
        else if (rv.w > max.w)
            rv.w = max.w;
        
        if (rv.h < min.h)
            rv.h = min.h;
        else if (rv.h > max.h)
            rv.h = max.h;
 
        return rv;
    }
 
 
    operator DsPoint() const
    {
        DsPoint r(w, h);
        return r;
    }
 
    operator DsFPoint() const
    {
        DsFPoint r(w, h);
        return r;
    }
 
    operator DsSize() const
    {
        DsSize r(w, h);
        return r;
    }
 
    float w;        
    float h;        
};
 
 
class DsFRect;
 
class DsRegion
{
public:
    virtual pair<float, float> getVerticalRange(float x) const = 0;
    virtual pair<float, float> getHorizontalRange(float y) const = 0;
 
    virtual DsFRect getRect(void) const = 0;
 
    virtual void rotate(const DsSurface& surface) = 0;
    virtual DsFRect move(const DsFPoint& offset) = 0;
};
 
class DsRect: public DsRegion
{
public:
 
    DsRect(): x(0), y(0), w(0), h(0)
    {
    }
 
    DsRect(int32_t x, int32_t y, int32_t w, int32_t h): x(x), y(y), w(w), h(h)
    {
    }
 
    DsRect(const DsPoint &pos, const DsSize &size): x(pos.x), y(pos.y), w(size.w), h(size.h)
    {
    }
 
 
    DsPoint getPosition(void) const
    {
        return DsPoint(x, y);
    }
 
    void setPosition(const DsPoint &pos)
    {
        x = pos.x;
        y = pos.y;
    }
 
    
    void setPosition(const DsFPoint &pos)
    {
        x = round(pos.x);
        y = round(pos.y);
    }
 
 
    DsSize getSize(void) const
    {
        return DsSize(w, h);
    }
 
    void setSize(const DsSize &size)
    {
        w = size.w;
        h = size.h;
    }
 
    
    DsFPoint getCenter(void) const
    {
        DsFPoint center;
 
        center.x = x + w / 2.0;
        center.y = y + h / 2.0;
 
        return center;
    }
 
 
    uint32_t area(void) const
    {
        return w * h;
    }
 
    
    bool contains(const DsPoint &p) const
    {
        return (p.x >= x) && (p.x < (x + w)) &&
                (p.y >= y) && (p.y < (y + h));
    }
 
 
    DsRect intersect(const DsRect &r) const
    {
        const int32_t xx = max(x, r.x);
        const int32_t yy = max(y, r.y);
 
        int32_t ww = min(x + w, r.x + r.w);
        int32_t hh = min(y + h, r.y + r.h);
 
        ww = max(ww - xx, 0);
        hh = max(hh - yy, 0);
 
        return DsRect(xx, yy, ww, hh);
    }
 
    
    DsRect& move(const DsPoint &offset)
    {
        x += offset.x;
        y += offset.y;
 
        return *this;
    }
 
 
    DsFRect move(const DsFPoint& offset) override final;
 
 
    DsRect& cat(const DsRect &r)
    {
        if (area() == 0)
        {
            *this = r;
        }
        else if (r.area())
        {
            w = max(x + w, r.x + r.w);
            h = max(y + h, r.y + r.h);
 
            x = min(x, r.x);
            y = min(y, r.y);
 
            w -= x;
            h -= y;
        }
 
        return *this;
    }
 
 
    friend DsRect operator+(const DsRect &lhs, const DsRect &rhs)
    {
        DsRect result = lhs;
    
        result.w = max(lhs.x + lhs.w, rhs.x + rhs.w);
        result.h = max(lhs.y + lhs.h, rhs.y + rhs.h);
 
        result.x = min(lhs.x, rhs.x);
        result.y = min(lhs.y, rhs.y);
 
        result.w -= result.x;
        result.h -= result.y;
 
        return result;
    }
 
 
    DsRect erode(uint32_t size) const 
    {
        DsRect rect(*this);
 
        rect.x += size;
        rect.y += size;
 
        rect.w -= 2 * size;
        rect.h -= 2 * size;
 
        return rect;
    }
 
    
    DsRect erodeHorizontal(uint32_t size) const
    {
        DsRect rect(*this);
 
        rect.x += size;
        rect.w -= 2 * size;
 
        return rect;
    }
 
    DsRect erodeLeft(uint32_t size) const
    {
        DsRect rect(*this);
 
        rect.x += size;
        rect.w -= size;
 
        return rect;
    }
 
    DsRect erodeRight(uint32_t size) const
    {
        DsRect rect(*this);
 
        rect.w -= size;
 
        return rect;
    }
 
 
    DsRect erodeVertical(uint32_t size) const
    {
        DsRect rect(*this);
 
        rect.y += size;
        rect.h -= 2 * size;
 
        return rect;
    }
 
    DsRect erodeTop(uint32_t size) const
    {
        DsRect rect(*this);
 
        rect.y += size;
        rect.h -= size;
 
        return rect;
    }
 
 
    DsRect erodeBottom(uint32_t size) const
    {
        DsRect rect(*this);
 
        rect.h -= size;
 
        return rect;
    }
 
 
    DsRect dilate(uint32_t size)
    {
        DsRect rect(*this);
 
        rect.x -= size;
        rect.y -= size;
 
        rect.w += 2 * size;
        rect.h += 2 * size;
 
        return rect;
    }
 
    DsRect dilateTop(uint32_t size)
    {
        DsRect rect(*this);
 
        rect.y -= size;
        rect.h += size;
 
        return rect;
    }
 
 
    DsRect dilateBotom(uint32_t size)
    {
        DsRect rect(*this);
 
        rect.h += size;
 
        return rect;
    }
 
 
    DsRect dilateLeft(uint32_t size)
    {
        DsRect rect(*this);
 
        rect.x -= size;
        rect.w += size;
 
        return rect;
    }
 
 
    DsRect dilateRight(uint32_t size)
    {
        DsRect rect(*this);
 
        rect.w += size;
 
        return rect;
    }
 
 
    DsRect getLeftRegion(int32_t split_line)
    {
        DsRect rect(*this);
        rect.w = min(split_line, rect.w);
        return rect;
    }
 
 
    DsRect getRightRegion(int32_t split_line)
    {
        DsRect rect(*this);
        rect.x += min(split_line, rect.w);
        rect.w -= min(split_line, rect.w);
        return rect;
    }
 
 
    DsRect getTopRegion(int32_t split_line)
    {
        DsRect rect(*this);
        rect.h = min(split_line, rect.h);
        return rect;
    }
 
    
    DsRect getBottomRegion(int32_t split_line)
    {
        DsRect rect(*this);
        rect.y += min(split_line, rect.h);
        rect.h -= min(split_line, rect.h);
        return rect;
    }
 
 
    DsRect& align(const DsRect& boundary, const DsAlignment &alignment, const DsPoint &offset = DsPoint())
    {
        if (alignment.isBottom())
            y = boundary.y + boundary.h - h - offset.y;
        else if (alignment.isCenterV())
            y = boundary.y + ((boundary.h - h) >> 1) + offset.y;
        else
            y = boundary.y + offset.y;
 
        if (alignment.isRight())
            x = boundary.x + boundary.w - w - offset.x;
        else if (alignment.isCenterH())
            x = boundary.x + ((boundary.w - w) >> 1) + offset.x;
        else
            x = boundary.x + offset.x;
 
        return *this;
    }
 
    pair<float, float> getVerticalRange(float x) const override final;
    pair<float, float> getHorizontalRange(float y) const override final;
    DsFRect getRect(void) const override final;
    void rotate(const DsSurface& surface) override final;
 
 
    int32_t x;          
    int32_t y;          
    int32_t w;          
    int32_t h;          
};
 
 
 
class DsFRect: public DsRegion
{
public:
 
    DsFRect(): x(0), y(0), w(0), h(0)
    {
    }
 
 
    DsFRect(const DsRect &r): x(r.x), y(r.y), w(r.w), h(r.h)
    {
    }
 
    DsFRect(float x, float y, float w, float h): x(x), y(y), w(w), h(h)
    {
    }
 
    DsFRect(const DsFPoint &pos, const DsFSize &size): x(pos.x), y(pos.y), w(size.w), h(size.h)
    {
    }
 
 
    DsFPoint getPosition(void) const
    {
        return DsFPoint(x, y);
    }
 
    void setPosition(const DsFPoint &pos)
    {
        x = pos.x;
        y = pos.y;
    }
 
    
    DsFSize getSize(void) const
    {
        return DsFSize(w, h);
    }
 
    void setSize(const DsFSize &size)
    {
        w = size.w;
        h = size.h;
    }
 
    
    DsFPoint getCenter(void) const
    {
        DsFPoint center;
 
        center.x = x + w / 2.0;
        center.y = y + h / 2.0;
 
        return center;
    }
 
 
    float area(void) const
    {
        return w * h;
    }
 
    
    bool contains(const DsFPoint &p) const
    {
        return (p.x >= x) && (p.x < (x + w)) &&
                (p.y >= y) && (p.y < (y + h));
    }
 
 
    DsFRect intersect(const DsFRect &r) const
    {
        const float xx = max(x, r.x);
        const float yy = max(y, r.y);
 
        float ww = min(x + w, r.x + r.w);
        float hh = min(y + h, r.y + r.h);
 
        ww = max(ww - xx, 0);
        hh = max(hh - yy, 0);
 
        return DsFRect(xx, yy, ww, hh);
    }
 
    
    DsFRect move(const DsFPoint &offset) override final
    {
        x += offset.x;
        y += offset.y;
 
        return *this;
    }
 
 
    DsFRect& cat(const DsFRect &r)
    {
        if (area() == 0)
        {
            *this = r;
        }
        else if (r.area())
        {
            w = max(x + w, r.x + r.w);
            h = max(y + h, r.y + r.h);
 
            x = min(x, r.x);
            y = min(y, r.y);
 
            w -= x;
            h -= y;
        }
 
        return *this;
    }
 
 
    friend DsFRect operator+(const DsFRect &lhs, const DsFRect &rhs)
    {
        DsFRect result = lhs;
    
        result.w = max(lhs.x + lhs.w, rhs.x + rhs.w);
        result.h = max(lhs.y + lhs.h, rhs.y + rhs.h);
 
        result.x = min(lhs.x, rhs.x);
        result.y = min(lhs.y, rhs.y);
 
        result.w -= result.x;
        result.h -= result.y;
 
        return result;
    }
 
 
    DsFRect erode(float size) const 
    {
        DsFRect rect(*this);
 
        if (size > 0)
        {
            rect.x += size;
            rect.y += size;
            rect.w -= 2 * size;
            rect.h -= 2 * size;
        }
 
        return rect;
    }
 
    
    DsFRect erodeHorizontal(float size) const
    {
        DsFRect rect(*this);
 
        if (size > 0)
        {
            rect.x += size;
            rect.w -= 2 * size;
        }
 
        return rect;
    }
 
    DsFRect erodeLeft(float size) const
    {
        DsFRect rect(*this);
 
        if (size > 0)
        {
            rect.x += size;
            rect.w -= size;
        }
 
        return rect;
    }
 
    DsFRect erodeRight(float size) const
    {
        DsFRect rect(*this);
 
        if (size > 0)
            rect.w -= size;
 
        return rect;
    }
 
 
    DsFRect erodeVertical(float size) const
    {
        DsFRect rect(*this);
 
        if (size > 0)
        {
            rect.y += size;
            rect.h -= 2 * size;
        }
 
        return rect;
    }
 
    DsFRect erodeTop(float size) const
    {
        DsFRect rect(*this);
 
        if (size > 0)
        {
            rect.y += size;
            rect.h -= size;
        }
 
        return rect;
    }
 
 
    DsFRect erodeBottom(float size) const
    {
        DsFRect rect(*this);
 
        if (size > 0)
            rect.h -= size;
 
        return rect;
    }
 
 
    DsFRect dilate(float size)
    {
        DsFRect rect(*this);
 
        if (size > 0)
        {
            rect.x -= size;
            rect.y -= size;
            rect.w += 2 * size;
            rect.h += 2 * size;
        }
 
        return rect;
    }
 
    DsFRect dilateTop(float size)
    {
        DsFRect rect(*this);
 
        if (size > 0)
        {
            rect.y -= size;
            rect.h += size;
        }
 
        return rect;
    }
 
 
    DsFRect dilateBotom(float size)
    {
        DsFRect rect(*this);
 
        if (size > 0)
            rect.h += size;
 
        return rect;
    }
 
 
    DsFRect dilateLeft(float size)
    {
        DsFRect rect(*this);
 
        if (size > 0)
        {
            rect.x -= size;
            rect.w += size;
        }
 
        return rect;
    }
 
 
    DsFRect dilateRight(float size)
    {
        DsFRect rect(*this);
 
        if (size > 0)
            rect.w += size;
 
        return rect;
    }
 
 
    DsFRect getLeftRegion(float split_line)
    {
        DsFRect rect(*this);
        rect.w = min(split_line, rect.w);
        return rect;
    }
 
 
    DsFRect getRightRegion(float split_line)
    {
        DsFRect rect(*this);
        rect.x += min(split_line, rect.w);
        rect.w -= min(split_line, rect.w);
        return rect;
    }
 
 
    DsFRect getTopRegion(float split_line)
    {
        DsFRect rect(*this);
        rect.h = min(split_line, rect.h);
        return rect;
    }
 
    
    DsFRect getBottomRegion(float split_line)
    {
        DsFRect rect(*this);
        rect.y += min(split_line, rect.h);
        rect.h -= min(split_line, rect.h);
        return rect;
    }
 
 
    DsFRect& align(const DsFRect& boundary, const DsAlignment &alignment, const DsFPoint &offset = DsFPoint())
    {
        if (alignment.isBottom())
            y = boundary.y + boundary.h - h - offset.y;
        else if (alignment.isCenterV())
            y = boundary.y + ((boundary.h - h) / 2.0) + offset.y;
        else
            y = boundary.y + offset.y;
 
        if (alignment.isRight())
            x = boundary.x + boundary.w - w - offset.x;
        else if (alignment.isCenterH())
            x = boundary.x + ((boundary.w - w) / 2.0) + offset.x;
        else
            x = boundary.x + offset.x;
 
        return *this;
    }
 
    operator DsRect() const
    {
        return DsRect(round(x), round(y), round(w), round(h));
    }
 
 
    pair<float, float> getVerticalRange(float x) const override final;
    pair<float, float> getHorizontalRange(float y) const override final;
    DsFRect getRect(void) const override final;
    void rotate(const DsSurface& surface) override final;
 
    float x;            
    float y;            
    float w;            
    float h;            
};
 
 
 
class DsEllipse: public DsRegion
{
public:
    DsEllipse()
    {
    }
 
    DsEllipse(float xc, float yc, float rx, float ry): center(xc, yc), radius(rx, ry), 
                                                    mRhRh(rx * rx), mRvRv(ry * ry), 
                                                    mRhRhDivRyRy(mRhRh / mRvRv), mRvRvDivRxRx(mRvRv / mRhRh)
    {
    }
 
 
    DsEllipse(DsFPoint center, DsFSize radius): center(center), radius(radius), 
                                                    mRhRh(radius.w * radius.w), mRvRv(radius.h * radius.h), 
                                                    mRhRhDivRyRy(mRhRh / mRvRv), mRvRvDivRxRx(mRvRv / mRhRh)
    {
    }
 
 
 
    DsEllipse(DsFSize radius): radius(radius),
                            mRhRh(this->radius.w * this->radius.w), mRvRv(this->radius.h * this->radius.h), 
                            mRhRhDivRyRy(mRhRh / mRvRv), mRvRvDivRxRx(mRvRv / mRhRh)
    {
    }
 
 
 
    DsEllipse(float radius): radius(radius, radius),
                            mRhRh(this->radius.w * this->radius.w), mRvRv(this->radius.h * this->radius.h), 
                            mRhRhDivRyRy(mRhRh / mRvRv), mRvRvDivRxRx(mRvRv / mRhRh)
    {
    }
 
 
    DsEllipse(DsFPoint center, float radius): center(center), radius(radius, radius),
                                                    mRhRh(this->radius.w * this->radius.w), mRvRv(this->radius.h * this->radius.h), 
                                                    mRhRhDivRyRy(mRhRh / mRvRv), mRvRvDivRxRx(mRvRv / mRhRh)
    {
    }
 
 
    DsFRect move(const DsFPoint& offset) override final
    {
        center += offset;
        return getRect();
    }
 
 
    pair<float, float> getVerticalRange(float x) const override final;
    pair<float, float> getHorizontalRange(float y) const override final;
    DsFRect getRect(void) const override final;
    void rotate(const DsSurface& surface) override final;
 
    void setRadius(DsFSize radius);
    void setRect(const DsFRect &rect);
 
    float getRadiusAtAngle(float angle);
    DsFPoint getPointAtAngle(float angle);
 
    static void computeArcBoundary(float start_angle, float end_angle, bool include_center, float &left, float &right, float &top, float &bottom);
    DsFRect computeArcBoundary(float start_angle, float end_angle, bool include_center);
 
    DsFPoint center;        
    DsFSize radius;         
 
private:
    float mRhRh;
    float mRvRv;
    float mRhRhDivRyRy;
    float mRvRvDivRxRx;
};
 
 
#endif