cel_geom.h

Go to the documentation of this file.

//----------------------------------------------------------------------------
//
// (C) 2003-2006 Celartem Technology Inc. All rights reserved.
//----------------------------------------------------------------------------

#ifndef _cel_geom_h_
#define _cel_geom_h_

#include "cel_types.h"
#include <algorithm>

namespace Celartem
{
    struct Rect;

    //------------------------------------------------------------------------
    struct Point
    {
        ssize_t x; 
        ssize_t y; 

        Point(ssize_t inX = 0, ssize_t inY = 0)
            : x(inX), y(inY)
        {
        }

        inline void zeroReset()
        {
            x = y = 0;
        }

        inline bool operator==(const Point& r) const
        {
            return (x == r.x && y == r.y);
        }

        inline bool operator!=(const Point& r) const
        {
            return (x != r.x || y != r.y);
        }
        
        bool isInside(const Rect& inRect) const;
    };

    //------------------------------------------------------------------------
    struct Size
    {
        ssize_t width;  
        ssize_t height; 

        Size(ssize_t inWidth = 0, ssize_t inHeight = 0)
            : width(inWidth), height(inHeight)
        {
        }

        explicit Size(const Rect& inRect);

        inline bool operator==(const Size& r) const
        {
            return (width == r.width && height == r.height);
        }

        inline bool operator!=(const Size& r) const
        {
            return (width != r.width || height != r.height);
        }
    };

    //------------------------------------------------------------------------
    struct Rect
    {
        ssize_t left;   
        ssize_t top;    
        ssize_t width;  
        ssize_t height; 

        inline ssize_t right() const {return left + width;}

        inline ssize_t bottom() const {return top + height;}
        
        inline Point leftTop() const {return Point(left, top);}
        
        inline Point leftBottom() const {return Point(left, bottom());}

        inline Point rightTop() const {return Point(right(), top);}

        inline Point rightBottom() const {return Point(right(), bottom());}

        Rect(
            ssize_t inLeft = 0, ssize_t inTop = 0,
            ssize_t inWidth = 0, ssize_t inHeight = 0) :
            left(inLeft), top(inTop), width(inWidth), height(inHeight)
        {
        }

        Rect(const Rect& inRect)
        {
            left = inRect.left;
            top = inRect.top;
            width = inRect.width;
            height = inRect.height;
        }

        Rect& operator=(const Rect& inRect)
        {
            left = inRect.left;
            top = inRect.top;
            width = inRect.width;
            height = inRect.height;
            return *this;
        }

        bool operator==(const Rect& inRect) const
        {
            return
                (inRect.left == left) && (inRect.top == top) &&
                (inRect.width == width) && (inRect.height == height);
        }

        inline bool operator!=(const Rect& inRect) const
        {
            return (left != inRect.left || top != inRect.top
                || width != inRect.width || height != inRect.height);
        }

        inline void zeroReset()
        {
            left = top = 0;
            width = height = 0;
        }

        inline bool isValid() const
        {
            return (width > 0 && height > 0);
        }

        inline bool isInside(const Rect& inRect) const
        {
            if(inRect.left > left || inRect.top > top
            || right() > inRect.right() || bottom() > inRect.bottom())
                return false;
            return true;
        }

        static void
        unionRects(Rect& outRect, const Rect& inRect1, const Rect& inRect2)
        {
            Rect rc;
            rc.left   = std::min<ssize_t>(inRect1.left, inRect2.left);
            rc.top    = std::min<ssize_t>(inRect1.top, inRect2.top);
            rc.width  = std::max<ssize_t>(
                inRect1.right(), inRect2.right()) - rc.left;
            rc.height = std::max<ssize_t>(
                inRect1.bottom(), inRect2.bottom()) - rc.top;
            outRect = rc;
        }

        static void
        unionRects(Rect& outRect, const Rect* inRects, size_t inCount)
        {
            ssize_t left = SSIZE_MAX;
            ssize_t top = SSIZE_MAX;
            ssize_t right = SSIZE_MIN;
            ssize_t bottom = SSIZE_MIN;
            for(size_t i = 0; i < inCount; i++)
            {
                const Rect& rect = inRects[i];
                if(rect.left < left) left = rect.left;
                if(rect.top < top) top = rect.top;
                if(rect.right() > right) right = rect.right();
                if(rect.bottom() > bottom) bottom = rect.bottom();
            }
            outRect.left = left;
            outRect.top = top;
            outRect.width = right - left;
            outRect.height = bottom - top;
        }

        static bool
        intersection(Rect& outRect, const Rect& inRect1, const Rect& inRect2)
        {
            // NOTE
            // We firstly calculate on a temporary buffer; it reduces the
            // risk when outRect is same to either inRect1 or inRect2.
            Rect rc;
            
            rc.left   = std::max<ssize_t>(inRect1.left, inRect2.left);
            rc.top    = std::max<ssize_t>(inRect1.top, inRect2.top);
            rc.width  = std::min<ssize_t>(
                inRect1.right(), inRect2.right()) - rc.left;
            rc.height = std::min<ssize_t>(
                inRect1.bottom(), inRect2.bottom()) - rc.top;
            
            outRect = rc;
            return outRect.isValid();
        }
        
        bool intersectWith(const Rect& inRect) const
        {
            Rect dummy;
            return intersection(dummy, *this, inRect);
        }

        void
        offset(ssize_t inHorzOffset, ssize_t inVertOffset)
        {
            left += inHorzOffset;
            top += inVertOffset;
        }

        void
        offset(const Point& inOffset)
        {
            offset(inOffset.x, inOffset.y);
        }

        void inflate(ssize_t size)
        {
            left -= size;
            top -= size;
            width += size * 2;
            height += size * 2;
        }
        
        void deflate(ssize_t size)
        {
            inflate(-size);
        }
    };
    
    //------------------------------------------------------------------------
    inline Size::Size(const Rect& inRect)
        : width(inRect.width), height(inRect.height)
    {
    }
    
    //------------------------------------------------------------------------
    inline bool Point::isInside(const Rect& inRect) const
    {
        if(x >= inRect.left && x < inRect.right() &&
            y >= inRect.top && y < inRect.bottom())
            return true;
        return false;
    }

} // namespace Celartem

#endif // _cel_geom_h_

---

This document is automatically generated using doxygen 1.5.4 at Fri Jun 27 18:21:54 2008.