TRectUtilities.h

#pragma once
 
 
#include <vector>
 
namespace FLImaging
{
    namespace ImageProcessing
    {
        class CTRectUtilities
        {
        private:
            CTRectUtilities() { }
 
        public:
                //FLRect Get Rect
            template<typename T>
            static EResult GetBoundaryRect(std::vector<Base::TRect<T>>*pTRect, Foundation::CFLRect<T>*pFlrResRect)
            {
                EResult er = EResult_UnknownError;
 
                do
                {
                    if(!pTRect || !pFlrResRect)
                    {
                        er = EResult_NullPointer;
                        break;
                    }
 
                    if(pTRect->size() == 0)
                    {
                        er = EResult_NoData;
                        break;
                    }
 
                    pFlrResRect->left = pTRect->at(0).left;
                    pFlrResRect->top = pTRect->at(0).top;
                    pFlrResRect->right = pTRect->at(0).right;
                    pFlrResRect->bottom = pTRect->at(0).bottom;
 
                    for(auto& iter : *pTRect)
                    {
                        pFlrResRect->left = pFlrResRect->left < iter.left ? pFlrResRect->left : iter.left;
                        pFlrResRect->top = pFlrResRect->top < iter.top ? pFlrResRect->top : iter.top;
                        pFlrResRect->right = pFlrResRect->right > iter.right ? pFlrResRect->right : iter.right;
                        pFlrResRect->bottom = pFlrResRect->bottom > iter.bottom ? pFlrResRect->bottom : iter.bottom;
                    }
 
                    er = EResult_OK;
                }
                while(false);
 
                return er;
            }
 
            template<typename T>
            static EResult GetBoundaryRect(std::vector<Base::TRect<T>>*pTRect, Foundation::CFLRect<T>&flrResRect)
            {
                return GetBoundaryRect<T>(pTRect, (Foundation::CFLRect<T>*) & flrResRect);
            }
 
            template<typename T>
            static EResult GetBoundaryRect(std::vector<Base::TRect<T>>&tRect, Foundation::CFLRect<T>*pFlrResRect)
            {
                return GetBoundaryRect<T>((std::vector<Base::TRect<T>>*) & tRect, pFlrResRect);
            }
 
            template<typename T>
            static EResult GetBoundaryRect(std::vector<Base::TRect<T>>&tRect, Foundation::CFLRect<T>&flrResRect)
            {
                return GetBoundaryRect<T>((std::vector<Base::TRect<T>>*) & tRect, (Foundation::CFLRect<T>*) & flrResRect);
            }
 
            //TRect Get Rect
            template<typename T>
            static EResult GetBoundaryRect(std::vector<Base::TRect<T> >*pTRect, Base::TRect<T>*pTrResRect)
            {
                EResult er = EResult_UnknownError;
 
                do
                {
                    if(!pTRect || !pTrResRect)
                    {
                        er = EResult_NullPointer;
                        break;
                    }
 
                    if(pTRect->size() == 0)
                    {
                        er = EResult_NoData;
                        break;
                    }
 
                    pTrResRect->left = pTRect->at(0).left;
                    pTrResRect->top = pTRect->at(0).top;
                    pTrResRect->right = pTRect->at(0).right;
                    pTrResRect->bottom = pTRect->at(0).bottom;
 
                    for(auto& iter : *pTRect)
                    {
                        pTrResRect->left = pTrResRect->left < iter.left ? pTrResRect->left : iter.left;
                        pTrResRect->top = pTrResRect->top < iter.top ? pTrResRect->top : iter.top;
                        pTrResRect->right = pTrResRect->right > iter.right ? pTrResRect->right : iter.right;
                        pTrResRect->bottom = pTrResRect->bottom > iter.bottom ? pTrResRect->bottom : iter.bottom;
                    }
 
                    er = EResult_OK;
                }
                while(false);
 
                return er;
            }
 
            template<typename T>
            static EResult GetBoundaryRect(std::vector<Base::TRect<T> >&tRect, Base::TRect<T>&trResRect)
            {
                return GetBoundaryRect<T>((std::vector<Base::TRect<T> >*) & tRect, (Base::TRect<T>*) & trResRect);
            }
 
            template<typename T>
            static EResult GetBoundaryRect(std::vector<Base::TRect<T> >&tRect, Base::TRect<T>*pTrResRect)
            {
                return GetBoundaryRect<T>((std::vector<Base::TRect<T> >*) & tRect, pTrResRect);
            }
 
            template<typename T>
            static EResult GetBoundaryRect(std::vector<Base::TRect<T> >*pTRect, Base::TRect<T>&trResRect)
            {
                return GetBoundaryRect<T>(pTRect, (Base::TRect<T>*) & trResRect);
            }
 
 
            //FLPoint Offset
            template<typename T>
            static EResult Offset(std::vector<Base::TRect<T> >*pTRect, Foundation::CFLPoint<T>*pFlpOffset)
            {
                EResult er = EResult_UnknownError;
 
                do
                {
                    if(!pTRect || !pFlpOffset)
                    {
                        er = EResult_NullPointer;
                        break;
                    }
 
                    if(pTRect->size() == 0)
                    {
                        er = EResult_NoData;
                        break;
                    }
 
                    for(auto& iter : *pTRect)
                    {
                        iter.left += pFlpOffset->x;
                        iter.top += pFlpOffset->y;
                        iter.right += pFlpOffset->x;
                        iter.bottom += pFlpOffset->y;
                    }
 
                    er = EResult_OK;
                }
                while(false);
 
                return er;
            }
 
            template<typename T>
            static EResult Offset(std::vector<Base::TRect<T> >&tRect, Foundation::CFLPoint<T>&flpOffset)
            {
                return Offset<T>((std::vector<Base::TRect<T> >*) & tRect, (Foundation::CFLPoint<T>*) & flpOffset);
            }
 
            template<typename T>
            static EResult Offset(std::vector<Base::TRect<T> >&tRect, Foundation::CFLPoint<T>*pFlpOffset)
            {
                return Offset<T>((std::vector<Base::TRect<T> >*) & tRect, pFlpOffset);
            }
 
            template<typename T>
            static EResult Offset(std::vector<Base::TRect<T> >*pTRect, Foundation::CFLPoint<T>&flpOffset)
            {
                return Offset<T>(pTRect, (Foundation::CFLPoint<T>*) & flpOffset);
            }
 
            //TPoint Offset
            template<typename T>
            static EResult Offset(std::vector<Base::TRect<T> >*pTRect, Base::TPoint<T>*pTpOffset)
            {
                EResult er = EResult_UnknownError;
 
                do
                {
                    if(!pTRect || !pTpOffset)
                    {
                        er = EResult_NullPointer;
                        break;
                    }
 
                    if(pTRect->size() == 0)
                    {
                        er = EResult_NoData;
                        break;
                    }
 
                    for(auto& iter : *pTRect)
                    {
                        iter.left += pTpOffset->x;
                        iter.top += pTpOffset->y;
                        iter.right += pTpOffset->x;
                        iter.bottom += pTpOffset->y;
                    }
 
                    er = EResult_OK;
                }
                while(false);
 
                return er;
            }
 
            template<typename T>
            static EResult Offset(std::vector<Base::TRect<T> >&tRect, Base::TPoint<T>&tpOffset)
            {
                return Offset<T>((std::vector<Base::TRect<T> >*) & tRect, (Base::TPoint<T>*) & tpOffset);
            }
 
            template<typename T>
            static EResult Offset(std::vector<Base::TRect<T> >&tRect, Base::TPoint<T>*pTpOffset)
            {
                return Offset<T>((std::vector<Base::TRect<T> >*) & tRect, pTpOffset);
            }
 
            template<typename T>
            static EResult Offset(std::vector<Base::TRect<T> >*pTRect, Base::TPoint<T>&tpOffset)
            {
                return Offset<T>(pTRect, (Base::TPoint<T>*) & tpOffset);
            }
 
 
            //Type Offset
            template<typename T>
            static EResult Offset(std::vector<Base::TRect<T> >*pTRect, T x, T y)
            {
                EResult er = EResult_UnknownError;
 
                do
                {
                    if(!pTRect)
                    {
                        er = EResult_NullPointer;
                        break;
                    }
 
                    if(pTRect->size() == 0)
                    {
                        er = EResult_NoData;
                        break;
                    }
 
                    for(auto& iter : *pTRect)
                    {
                        iter.left += x;
                        iter.top += y;
                        iter.right += x;
                        iter.bottom += y;
                    }
 
                    er = EResult_OK;
                }
                while(false);
 
                return er;
            }
 
            template<typename T>
            static EResult Offset(std::vector<Base::TRect<T> >&tRect, T x, T y)
            {
                return Offset<T>((std::vector<Base::TRect<T> >*) & tRect, x, y);
            }
        };
 
    }
}