cRectT.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cRectT_H
#define _INC_cRectT_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cDirectionDef.h"
#include "../Math/cVecT.h"
#include "GrayCore/include/cValT.h"
 
namespace GrayLib
{
        class cVariant;
 
        template< typename TYPE = double >
        class GRAYLIB_LINK cRectT
        {
 
                typedef cRectT<TYPE> THIS_t;
                typedef cVecT2<TYPE> POINT_t;
        public:
                typedef TYPE DVALUE_t;  
 
        public:
                TYPE left, top, right, bottom; // same order as _WIN32 RECT if <int>.
 
        public:
                cRectT() noexcept
                        : left(0)
                        , top(0)
                        , right(0)
                        , bottom(0)
                {
                }
                cRectT(TYPE x1, TYPE y1, TYPE x2, TYPE y2) noexcept
                        : left(x1)
                        , top(y1)
                        , right(x2)
                        , bottom(y2)
                {
                }
                cRectT(const THIS_t& rect) noexcept
                        : left(rect.left)
                        , top(rect.top)
                        , right(rect.right)
                        , bottom(rect.bottom)
                {
                }
 
                TYPE get_DiffX() const noexcept
                {
                        // Get Size X. Width maybe.
                        // Not assumed normalized.
                        return this->right - this->left;
                }
                TYPE get_DiffY() const noexcept
                {
                        // Get Size Y. Height maybe.
                        // Not assumed normalized.
                        return this->bottom - this->top;
                }
 
                cVecT2<TYPE> get_Center() const noexcept
                {
                        return cVecT2<TYPE>((this->left + this->right) / 2, (this->top + this->bottom) / 2);
                }
                float get_AspectRatio() const noexcept
                {
                        TYPE h = get_DiffY();
                        if (h == 0)
                                return 0.0f;
                        TYPE w = get_DiffX();
                        return(((float)w) / ((float)h));
                }
                bool IsEqual(const THIS_t& rect) const noexcept
                {
                        // exactly equal.
                        return !::memcmp(this, &rect, sizeof(THIS_t));
                }
                bool operator == (const THIS_t& rect) const noexcept
                {
                        return IsEqual(rect);
                }
                bool operator != (const THIS_t& rect) const noexcept
                {
                        return !IsEqual(rect);
                }
                bool isRectNull() const noexcept
                {
                        return this->left == 0 && this->right == 0 && this->top == 0 && this->bottom == 0;
                }
                bool isRectNormal() const noexcept
                {
                        return (this->right > this->left) && (this->bottom > this->top);
                }
                bool isRectNormalE() const noexcept
                {
                        return (this->right >= this->left) && (this->bottom >= this->top);
                }
                bool IsInRangeX(TYPE value) const noexcept
                {
                        return Calc::IsInBetween(value, this->left, this->right);
                }
                bool IsInRangeY(TYPE value) const noexcept
                {
                        return Calc::IsInBetween(value, this->top, this->bottom);
                }
 
                // Full Set operators.
                void SetRectNull() noexcept
                {
                        this->left = 0;
                        this->top = 0;
                        this->right = 0;
                        this->bottom = 0;
                }
                void SetRectWH(TYPE nLeft, TYPE nTop, TYPE nWidth, TYPE nHeight) noexcept
                {
                        this->left = nLeft;
                        this->top = nTop;
                        this->right = nLeft + nWidth;
                        this->bottom = nTop + nHeight;
                }
                void SetRectEmptyX() noexcept
                {
                        this->left = this->top = (TYPE)INT_MAX;
                        this->right = this->bottom = (TYPE)-INT_MAX;
                }
                void SetRect4(TYPE nLeft, TYPE nTop, TYPE nRight, TYPE nBottom) noexcept
                {
                        this->left = nLeft;
                        this->top = nTop;
                        this->right = nRight;
                        this->bottom = nBottom;
                }
                void SetRectAsPt(TYPE x, TYPE y) noexcept
                {
                        // Set empty rectangle at a point.
                        this->left = x;
                        this->right = x;
                        this->top = y;
                        this->bottom = y;
                }
                void SetRectAsPt(const POINT_t& pt) noexcept
                {
                        SetRectAsPt(pt.x, pt.y);
                }
                void SetRectFromSphere(TYPE x, TYPE y, TYPE nRadius) noexcept
                {
                        // set rectangle to contain a sphere.
                        this->left = x - nRadius;
                        this->top = y - nRadius;
                        this->right = x + nRadius;
                        this->bottom = y + nRadius;
                }
 
                HRESULT SetRectAsStr(const char* pszStr)
                {
                        TYPE adVals[4];
                        size_t iQty = StrNum::ToValArray(adVals, _countof(adVals), pszStr);
                        if (iQty == 2)
                        {
                                SetRectAsPt(adVals[0], adVals[1]);
                        }
                        else if (iQty == 4)
                        {
                                SetRect4(adVals[0], adVals[1], adVals[2], adVals[3]);
                        }
                        else
                                return E_FAIL;
                        return (HRESULT)iQty;
                }
 
                // Change operators.
                void OffsetRectX(TYPE dx) noexcept
                {
                        this->left += dx;
                        this->right += dx;
                }
                void OffsetRectY(TYPE dy) noexcept
                {
                        this->top += dy;
                        this->bottom += dy;
                }
                void OffsetRect(TYPE dx, TYPE dy) noexcept
                {
                        OffsetRectX(dx);
                        OffsetRectY(dy);
                }
 
                void UnionX(TYPE x) noexcept
                {
                        if (IsInRangeX(x))
                                return;
                        if (this->left <= this->right)
                        {
                                // Normal Rect
                                if (x < this->left)
                                        this->left = x;
                                else
                                        this->right = x;
                        }
                        else
                        {
                                if (x < this->right)
                                        this->right = x;
                                else
                                        this->left = x;
                        }
                }
                void UnionY(TYPE y) noexcept
                {
                        if (IsInRangeY(y))
                                return;
                        if (this->top <= this->bottom)
                        {
                                // Normal Rect
                                if (y < this->top)
                                        this->top = y;
                                else
                                        this->bottom = y;
                        }
                        else
                        {
                                if (y < this->bottom)
                                        this->bottom = y;
                                else
                                        this->top = y;
                        }
                }
                void Union2(TYPE x, TYPE y) noexcept
                {
                        UnionX(x);
                        UnionY(y);
                }
                void Union4(const THIS_t& rect) noexcept
                {
                        Union2(rect.left, rect.top);
                        Union2(rect.right, rect.bottom);
                }
 
                void ScrollInRangeX(TYPE value) noexcept
                {
                        if (IsInRangeX(value))
                                return;
 
                        TYPE d1 = value - this->left;
                        TYPE d2 = value - this->right;
 
                        if (Calc::Abs(d1) < Calc::Abs(d2))
                        {
                                OffsetRectX(d1);
                        }
                        else
                        {
                                OffsetRectX(d2);
                        }
                }
                void ScrollInRangeY(TYPE value)
                {
                        if (IsInRangeY(value))
                                return;
 
                        TYPE d1 = value - this->top;
                        TYPE d2 = value - this->bottom;
 
                        if (Calc::Abs(d1) < Calc::Abs(d2))
                        {
                                OffsetRectY(d1);
                        }
                        else
                        {
                                OffsetRectY(d2);
                        }
                }
 
                void SetRectNotEmpty(TYPE iMin = 10) noexcept
                {
                        if (this->left == this->right)
                        {
                                this->left -= iMin;
                                this->right += iMin;
                        }
                        if (this->top == this->bottom)
                        {
                                this->top -= iMin;
                                this->bottom += iMin;
                        }
                }
 
                void ScaleX(float mx) noexcept
                {
                        this->left = (TYPE)(this->left * mx);
                        this->right = (TYPE)(this->right * mx);
                }
                void ScaleY(float my) noexcept
                {
                        this->top = (TYPE)(this->top * my);
                        this->bottom = (TYPE)(this->bottom * my);
                }
                void Scale(float mx, float my) noexcept
                {
                        ScaleX(mx);
                        ScaleY(my);
                }
                void AddScaleY() noexcept
                {
                        if (this->top != this->bottom)
                        {
                                TYPE diff = get_DiffY() / 10;
                                this->top -= diff;
                                this->bottom += diff;
                        }
                        SetRectNotEmpty();
                }
 
                void NormalizeRect() noexcept
                {
                        if (this->bottom < this->top)
                        {
                                cMemT::Swap(this->bottom, this->top);
                        }
                        if (this->right < this->left)
                        {
                                cMemT::Swap(this->right, this->left);
                        }
                }
        };
 
        template< typename TYPE >
        class GRAYLIB_LINK cRectNT : public cRectT<TYPE>
        {
 
                typedef cRectT<TYPE> SUPER_t;
                typedef cRectNT<TYPE> THIS_t;
 
        public:
                cRectNT() noexcept
                {
                }
                cRectNT(TYPE x1, TYPE y1, TYPE x2, TYPE y2) noexcept
                        : cRectT<TYPE>(x1, y1, x2, y2)
                {
                }
                cRectNT(const SUPER_t& rect) noexcept
                        : cRectT<TYPE>(rect)
                {
                }
 
                // const operations
                TYPE get_X() const noexcept
                {
                        return this->left;
                }
                TYPE X() const noexcept
                {
                        return this->left;
                }
                TYPE get_Y() const noexcept
                {
                        return this->top;
                }
                TYPE Y() const noexcept
                {
                        return this->top;
                }
 
                TYPE get_Width() const noexcept
                {
                        // get_DiffX assumed normalized.
                        return this->right - this->left;
                }
                TYPE Width() const noexcept // MFC compatible
                {
                        // get_DiffX assumed normalized.
                        return this->right - this->left;
                }
 
                TYPE get_Height() const noexcept
                {
                        // get_DiffY assumed normalized.
                        return this->bottom - this->top;
                }
                TYPE Height() const noexcept // MFC compatible
                {
                        // get_DiffY assumed normalized.
                        return this->bottom - this->top;
                }
 
                TYPE get_Radius() const noexcept
                {
                        TYPE nDistX = get_Width();
                        TYPE nDistY = get_Height();
                        return Calc::Max(nDistX, nDistY) / 2;
                }
 
                bool IsRectEmpty() const noexcept
                {
                        return !this->isRectNormal();
                }
 
                // Change operators.
 
                void SetLT(TYPE nLeft2, TYPE nTop2) noexcept
                {
                        this->OffsetRect(nLeft2 - this->left, nTop2 - this->top);
                }
                void SetWidth(TYPE cx) noexcept
                {
                        this->right = this->left + cx;
                }
                void SetHeight(TYPE cy) noexcept
                {
                        this->bottom = this->top + cy;
                }
                void SetWH(TYPE nWidth = 0, TYPE nHeight = 0) noexcept
                {
                        SetWidth(nWidth);
                        SetHeight(nHeight);
                }
 
                void InflateRectX(TYPE dx) noexcept
                {
                        this->left -= dx;
                        this->right += dx;
                }
                void InflateRectY(TYPE dy) noexcept
                {
                        this->top -= dy;
                        this->bottom += dy;
                }
                void InflateRectBoth(TYPE dx, TYPE dy) noexcept
                {
                        InflateRectX(dx);
                        InflateRectY(dy);
                }
 
                void UnionRect(const THIS_t& rect) noexcept
                {
                        if (rect.left < this->left)
                                this->left = rect.left;
                        if (rect.top < this->top)
                                this->top = rect.top;
                        if (rect.right > this->right)
                                this->right = rect.right;
                        if (rect.bottom > this->bottom)
                                this->bottom = rect.bottom;
                }
                void UnionRectE(const THIS_t& rect) noexcept
                {
                        if (rect.IsRectEmpty())
                                return;
                        if (IsRectEmpty())
                        {
                                *this = rect;
                                return;
                        }
                        UnionRect(rect);
                }
 
                bool IntersectRect(const THIS_t& rect) noexcept
                {
                        if (IsRectEmpty())
                                return false;
                        if (rect.IsRectEmpty())
                        {
                                this->SetRectEmptyX();
                                return false;
                        }
                        if (rect.left > this->left)
                                this->left = rect.left;
                        if (rect.top > this->top)
                                this->top = rect.top;
                        if (rect.right < this->right)
                                this->right = rect.right;
                        if (rect.bottom < this->bottom)
                                this->bottom = rect.bottom;
                        return !IsRectEmpty();
                }
 
                void RectClamp(TYPE cx = (TYPE)INT_MAX, TYPE cy = (TYPE)INT_MAX) noexcept
                {
                        if (this->left < 0)
                                this->left = 0;
                        if (this->top < 0)
                                this->top = 0;
                        if (this->right < 0)
                                this->right = 0;
                        if (this->bottom < 0)
                                this->bottom = 0;
 
                        if (this->right > cx)
                                this->right = cx;// left> right??
                        if (this->bottom > cy)
                                this->bottom = cy;
                }
                void NormalizeRectClamp(TYPE cx = (TYPE)INT_MAX, TYPE cy = (TYPE)INT_MAX) noexcept
                {
                        this->NormalizeRect();
                        RectClamp(cx, cy);
                }
        };
 
        template < typename TYPE = float >
        class GRAYLIB_LINK cRectFT : public cRectNT<TYPE>
        {
 
                typedef cRectNT<TYPE> SUPER_t;
                typedef cVecT2<TYPE> POINT_t;
                typedef cRectNT<TYPE> RECT_t;
 
        public:
                cRectFT(TYPE nleft = 0, TYPE ntop = 0, TYPE nright = 0, TYPE nbottom = 0) noexcept
                        : cRectNT<TYPE>(nleft, ntop, nright, nbottom)
                {
                        this->NormalizeRect();
                }
                cRectFT(const POINT_t& ptCenter, TYPE nSizeX = 0, TYPE nSizeY = 0) noexcept
                        : cRectNT<TYPE>(ptCenter.x - nSizeX, ptCenter.y - nSizeY, ptCenter.x + nSizeX, ptCenter.y + nSizeY)
                {
                        this->NormalizeRect();
                }
                cRectFT(const SUPER_t& rect) noexcept
                        : cRectNT<TYPE>(rect)
                {
                        this->NormalizeRect();
                }
 
                bool IsInsideX(TYPE x) const noexcept
                {
                        return x >= this->left && x <= this->right;
                }
                bool IsInsideY(TYPE y) const noexcept
                {
                        return(y >= this->top && y <= this->bottom);
                }
                bool PtInRect(TYPE x, TYPE y) const noexcept
                {
                        return IsInsideX(x) && IsInsideY(y);
                }
                bool PtInRect(const POINT_t& pt) const noexcept
                {
                        return PtInRect(pt.x, pt.y);
                }
 
                bool IsInsideMe(const RECT_t& rect) const
                {
                        if (rect.left < this->left)
                                return false;
                        if (rect.top < this->top)
                                return false;
                        if (rect.right > this->right)
                                return false;
                        if (rect.bottom > this->bottom)
                                return false;
                        return true;    // inside or equal.
                }
                bool IsOverlapped(const RECT_t& rect) const
                {
                        if (rect.left > this->right)
                                return false;
                        if (rect.top > this->bottom)
                                return false;
                        if (rect.right < this->left)
                                return false;
                        if (rect.bottom < this->top)
                                return false;
                        return true;
                }
 
                bool ClampPtInRect(OUT POINT_t& pt) const
                {
 
                        bool bChange = false;
                        // x
                        if (pt.x < this->left)
                        {
                                pt.x = this->left;
                                bChange = true;
                        }
                        if (pt.x > this->right)
                        {
                                pt.x = this->right;
                                bChange = true;
                        }
                        // y
                        if (pt.y < this->top)
                        {
                                pt.y = this->top;
                                bChange = true;
                        }
                        if (pt.y > this->bottom)
                        {
                                pt.y = this->bottom;
                                bChange = true;
                        }
                        return bChange;
                }
 
#if 0
                void SnapToGrid(TYPE fSizeXY)
                {
                        fSizeXY--;
                        this->left &= ~iSizeXY;
                        this->right = (right | iSizeXY) + 1;
                        this->top &= ~iSizeXY;
                        this->bottom = (bottom | iSizeXY) + 1;
                }
#endif
 
                void UnionPoint(TYPE x, TYPE y)
                {
                        if (x < this->left)
                                this->left = x;
                        if (y < this->top)
                                this->top = y;
                        if (x > this->right)
                                this->right = x;
                        if (y > this->bottom)
                                this->bottom = y;
                }
 
                // POINT_t GetRectCorner( DIR_TYPE eDir ) const;
                // float SetRectStr( const GChar_t* pVal );
 
                cString get_RectStr(void) const
                {
                        return cString::GetFormatf(_GT("%f,%f,%f,%f"), // TODO USE StrArg
                                (float)this->left,
                                (float)this->top,
                                (float)this->right,
                                (float)this->bottom);
                }
 
                ITERATE_t v_SetRect(const cVariant& vVal);
                void v_GetRect(cVariant& vVal) const;
        };
 
        typedef cRectFT<float> cRectf;
        typedef cRectFT<double> cRectd;
 
#ifdef GRAY_DLL // force implementation/instantiate for DLL/SO.
        template class GRAYLIB_LINK cRectT<double>;
        template class GRAYLIB_LINK cRectT<float>;
        template class GRAYLIB_LINK cRectT<int>;
        template class GRAYLIB_LINK cRectNT<double>;
        template class GRAYLIB_LINK cRectNT<float>;
        template class GRAYLIB_LINK cRectNT<int>;
#endif
 
};
 
#endif // _INC_cRectT_H