UT/UT_Rect.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Edward Lam
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        UT_Rect.h (C++)
 *
 * COMMENTS:
 *
 *      This file provides a bunch of integer rectangle classes.
 *
 */

#ifndef __UT_Rect_h__
#define __UT_Rect_h__

#include <math.h>
#include <SYS/SYS_Types.h>
#include <iostream.h>
#include "UT_Algorithm.h"

// Flip a particular coordinate value according to the given dimension
inline int UTinclusiveFlip( int v, int d )      { return d - 1 - v; }

class UT_DimRectImpl;
class UT_InclusiveRectImpl;
class UT_ExclusiveRectImpl;

template <typename T> class UT_Rect;

typedef UT_Rect<UT_DimRectImpl>         UT_DimRect;
typedef UT_Rect<UT_InclusiveRectImpl>   UT_InclusiveRect;
typedef UT_Rect<UT_ExclusiveRectImpl>   UT_ExclusiveRect;


// There are 3 different types of underlying rectangle implementations
// with the same interface:
//   UT_DimRect:        Stores the data as (x, y) and (width, height)
//   UT_InclusiveRect:  Stores the data as lower-left and upper-right
//                      corner positions (inclusively).
//   UT_ExclusiveRect:  Stores the data as lower-left and upper-right
//                      corner positions (exclusively).
//
// To convert internal data representations from one type to another, use
// the copy constructor and assignment operators.
//
// Otherwise, use the methods found in UT_Rect.
//

template <typename T> class UT_Rect
{
public:
    UT_Rect()                                       { clear(); }
    UT_Rect( int v1, int v2, int v3, int v4 )       { set( v1, v2, v3, v4 ); }

    UT_Rect( const UT_DimRect &r ) : _r( r )        { }
    UT_Rect( const UT_InclusiveRect &r ) : _r( r )  { }
    UT_Rect( const UT_ExclusiveRect &r ) : _r( r )  { }

    UT_Rect &operator=( const UT_DimRect &r )       { _r = r; return *this; }
    UT_Rect &operator=( const UT_InclusiveRect &r ) { _r = r; return *this; }
    UT_Rect &operator=( const UT_ExclusiveRect &r ) { _r = r; return *this; }

    // clear it to empty
    void clear()                                    { _r.clear(); }

    // set the elements. interpretation will differ depending on type T
    void set( int v1, int v2, int v3, int v4 )      { _r.set(v1, v2, v3, v4); }

    // Return true if rectangle is empty
    bool isEmpty() const            { return (width() == 0 || height() == 0); }

    // Return true if rectangle is valid (true if empty)
    bool isValid() const                { return _r.isValid(); }

    // Returns true if the rectangle contains the given coord.
    bool isInsideX( int px ) const      { return (x1() <= px && px <= x2()); }
    bool isInsideY( int py ) const      { return (y1() <= py && py <= y2()); }
    
    // Returns true if the given point is within the rectangle.
    bool isInside( int px, int py ) const { return isInsideX(px) &&
                                                   isInsideY(py); }

    // returns true if T is entirely contained by this rectangle.
    bool contains( const T &r) const;

    // Get relative coordinates from absolute
    void getRelative( int &px, int &py ) const      { px -= x1(); py -= y1(); }

    // Get absolute coordinates from relative
    void getAbsolute( int &px, int &py ) const      { px += x1(); py += y1(); }

    // Flip rectangle within the given width/height
    void flipX(int awidth)      { _r.flipX( awidth ); }
    void flipY(int aheight)     { _r.flipY( aheight ); }

    // Intersect this rectangle with the given one. Returns if result is valid.
    bool intersect( const T &r );

    // returns true if the given side would overlap the other
    // rectangle if projected onto it.
    bool overlapX( const T &r ) const;
    bool overlapY( const T &r ) const;

    // Enlarge this rectangle to include the given rectangle (ie. a union)
    void enlarge( const T &r );

    // Enlarge this rectangle to include the given point
    void enlarge( int x, int y );
    void enlarge( float x, float y);

    // translate by given offset
    void translate( int x, int y );

    // inset the rect by a dx and dy margins
    void inset( int dx, int dy );

    // replace by the inclusive rect (x1()+dx1, y1()+dy1, x2()-dx2, y2()-dy2)
    void inset( int dx1, int dy1, int dx2, int dy2 );

    // scale by given factor
    void scale( fpreal factor );

    // clamp the coordinates to be inclusive of this rect (ie. make it inside)
    void clamp( int &px, int &py ) const
    {
        if (px < x1())
            px = x1();
        else if (px > x2())
            px = x2();

        if (py < y1())
            py = y1();
        else if (py > y2())
            py = y2();
    }

    // Accessors
    int x() const               { return _r.x(); }      // lower-left corner
    int y() const               { return _r.y(); }
    int w() const               { return _r.width(); }
    int h() const               { return _r.height(); }
    int width() const           { return _r.width(); }
    int height() const          { return _r.height(); }

    int x1() const              { return _r.x1(); }     // lower-left corner
    int y1() const              { return _r.y1(); }
    int x2() const              { return _r.x2(); }     // upper-right corner
    int y2() const              { return _r.y2(); }     //   (inclusive)
    int x2e() const             { return _r.x2e(); }    // upper-right corner
    int y2e() const             { return _r.y2e(); }    //   (exclusive)

    // set the width/height, always maintaining the X/Y coord.
    void setWidth(int awidth)   { _r.setWidth(awidth); }
    void setHeight(int aheight) { _r.setHeight(aheight); }

    // set the position, always maintaining the size.
    void setX(int x_)           { _r.setX(x_); }
    void setY(int y_)           { _r.setY(y_); }

    // the the corners, changing the size.
    void setX1(int x_)          { _r.setX1(x_); }
    void setY1(int y_)          { _r.setY1(y_); }
    void setX2(int x_)          { _r.setX2(x_); }
    void setY2(int y_)          { _r.setY2(y_); }
    void setX2e(int x_)         { _r.setX2e(x_); }
    void setY2e(int y_)         { _r.setY2e(y_); }

        
    // Scalar <-> Rectangle conversions
    
    // specific gets for various rectangle semantics (will return you the
    // desired semantic regardless of the rectangle type)
    //
    void getDim(int &x_, int &y_, int &w_, int &h_) const
                { x_ = x(); y_ = y(); w_ = width(); h_ = height(); }
    void getIncl(int &x1_, int &y1_, int &x2_, int &y2_) const
                { x1_ = x(); y1_ = y(); x2_ = x2(); y2_ = y2(); }
    void getExcl(int &x1_, int &y1_, int &x2_, int &y2_) const
                { x1_ = x(); y1_ = y(); x2_ = x2e(); y2_ = y2e(); }

    // Regardless of the type of rectangle, these methods will set it up
    // properly using the given semantic.
    void setDim(int x_, int y_, int w_, int h_)
                { setX(x_); setY(y_); setWidth(w_); setHeight(h_); }
    void setIncl(int x1_, int y1_, int x2_, int y2_)
                { setX1(x1_); setX2(x2_); setY1(y1_); setY2(y2_); }
    void setExcl(int x1_, int y1_, int x2_, int y2_)
                { setX1(x1_); setX2e(x2_); setY1(y1_); setY2e(y2_); }


    int &operator()(int i)      { return _r(i); }       // native data access
    int operator()(int i) const { return _r(i); }

    const int *data() const     { return _r.data(); }
    int *data()                 { return _r.data(); }

private:
    T   _r;
};

//////////////////////////////////////////////////////////////////////////////
// 
// Implementation
//

class UT_BaseRectImpl
{
public:
    UT_BaseRectImpl() { }
    UT_BaseRectImpl( int v0, int v1, int v2, int v3 )
        { set( v0, v1, v2, v3 ); }
    UT_BaseRectImpl( const UT_BaseRectImpl &r )
        { set( r.myVals[0], r.myVals[1], r.myVals[2], r.myVals[3] ); }

    UT_BaseRectImpl &operator=( const UT_BaseRectImpl &r )
    {
        if( &r != this )
            set( r.myVals[0], r.myVals[1], r.myVals[2], r.myVals[3] );
        return *this;
    }

    void set( int v0, int v1, int v2, int v3 )
        { myVals[0] = v0; myVals[1] = v1; myVals[2] = v2; myVals[3] = v3; }

    int &operator()(int i)              { return myVals[i]; }
    int operator()(int i) const         { return myVals[i]; }

    const int * data() const            { return myVals; }
    int *       data()                  { return myVals; }

protected:
    // D == Dimension Rect, I == Inclusive Rect, E == Exclusive Rect
    int I2D( int v1, int v2 ) const     { return v2 - v1 + 1; }
    int D2I( int v, int d ) const       { return v + d - 1; }
    int E2D( int v1, int v2 ) const     { return v2 - v1; }
    int D2E( int v, int d ) const       { return v + d; }
    int E2I( int v2 ) const             { return v2 - 1; }
    int I2E( int v2 ) const             { return v2 + 1; }

    // Flip a particular inclusive coord value according to the given dimension
    static int  flipI( int v, int d )   { return UTinclusiveFlip( v, d ); }

protected:
    int myVals[4];
};

class UT_DimRectImpl : public UT_BaseRectImpl
{
public:
    UT_DimRectImpl()        { }
    UT_DimRectImpl( const UT_DimRect &r );
    UT_DimRectImpl( const UT_InclusiveRect &r );
    UT_DimRectImpl( const UT_ExclusiveRect &r );

    UT_DimRectImpl &operator=( const UT_DimRect &r );
    UT_DimRectImpl &operator=( const UT_InclusiveRect &r );
    UT_DimRectImpl &operator=( const UT_ExclusiveRect &r );

    // clear it to empty
    void clear()            { set( 0, 0, 0, 0 ); }

    // Return true if rectangle is valid (true if empty)
    bool isValid() const    { return width() >= 0 && height() >= 0; }

    // Flip rectangle within the given width/height
    void flipX(int w)       { myVals[0] = flipI(x2(), w); }
    void flipY(int h)       { myVals[1] = flipI(y2(), h); }

    // Accessors
    int x() const           { return myVals[0]; }
    int y() const           { return myVals[1]; }
    int width() const       { return myVals[2]; }
    int height() const      { return myVals[3]; }

    int x1() const          { return x(); }
    int y1() const          { return y(); }
    int x2() const          { return D2I(x(), width()); }
    int y2() const          { return D2I(y(), height()); }
    int x2e() const         { return I2E(x2()); }
    int y2e() const         { return I2E(y2()); }

    void setWidth(int w)        { myVals[2] = w; }
    void setHeight(int h)       { myVals[3] = h; }

    void setX(int x_)           { myVals[0] = x_; }
    void setY(int y_)           { myVals[1] = y_; }
    void setX1(int x_)          { myVals[2] += myVals[0]-x_; myVals[0] = x_; }
    void setY1(int y_)          { myVals[3] += myVals[1]-y_; myVals[1] = y_; }
    void setX2(int x_)          { myVals[2] = I2D(myVals[0], x_); }
    void setY2(int y_)          { myVals[3] = I2D(myVals[1], y_); }
    void setX2e(int x_)         { myVals[2] = E2D(myVals[0], x_); }
    void setY2e(int y_)         { myVals[3] = E2D(myVals[1], y_); }
};


class UT_InclusiveRectImpl : public UT_BaseRectImpl
{
public:
    UT_InclusiveRectImpl()  { }
    UT_InclusiveRectImpl( const UT_DimRect &r );
    UT_InclusiveRectImpl( const UT_InclusiveRect &r );
    UT_InclusiveRectImpl( const UT_ExclusiveRect &r );

    UT_InclusiveRectImpl &operator=( const UT_DimRect &r );
    UT_InclusiveRectImpl &operator=( const UT_InclusiveRect &r );
    UT_InclusiveRectImpl &operator=( const UT_ExclusiveRect &r );

    // clear it to empty
    void clear()            { set( 0, 0, -1, -1 ); }

    // Return true if rectangle is valid (true if empty)
    bool isValid() const    { return (x1() <= x2e()) && (y1() <= y2e()); }

    // Flip rectangle within the given width/height
    void flipX( int w )
    {
        myVals[0] = flipI(x1(), w);
        myVals[2] = flipI(x2(), w);
        UTswap(myVals[0], myVals[2]);
    }
    void flipY( int h )
    {
        myVals[1] = flipI(y1(), h);
        myVals[3] = flipI(y2(), h);
        UTswap(myVals[1], myVals[3]);
    }

    // Accessors
    int x1() const          { return myVals[0]; }
    int y1() const          { return myVals[1]; }
    int x2() const          { return myVals[2]; }
    int y2() const          { return myVals[3]; }
    int x2e() const         { return I2E(x2()); }
    int y2e() const         { return I2E(y2()); }

    int x() const           { return x1(); }
    int y() const           { return y1(); }
    int width() const       { return I2D(x1(), x2()); }
    int height() const      { return I2D(y1(), y2()); }
    
    void setWidth(int w)        { myVals[2] = D2I(myVals[0], w); }
    void setHeight(int h)       { myVals[3] = D2I(myVals[1], h); }

    void setX(int x_)           { myVals[2] = x_ + width()-1; myVals[0] = x_; }
    void setY(int y_)           { myVals[3] = y_ +height()-1; myVals[1] = y_; }
    void setX1(int x_)          { myVals[0] = x_; }
    void setY1(int y_)          { myVals[1] = y_; }
    void setX2(int x_)          { myVals[2] = x_; }
    void setY2(int y_)          { myVals[3] = y_; }
    void setX2e(int x_)         { myVals[2] = E2I(x_); }
    void setY2e(int y_)         { myVals[3] = E2I(y_); }
};

class UT_ExclusiveRectImpl : public UT_BaseRectImpl
{
public:
    UT_ExclusiveRectImpl()  { }
    UT_ExclusiveRectImpl( const UT_DimRect &r );
    UT_ExclusiveRectImpl( const UT_InclusiveRect &r );
    UT_ExclusiveRectImpl( const UT_ExclusiveRect &r );

    UT_ExclusiveRectImpl &operator=( const UT_DimRect &r );
    UT_ExclusiveRectImpl &operator=( const UT_InclusiveRect &r );
    UT_ExclusiveRectImpl &operator=( const UT_ExclusiveRect &r );

    // clear it to empty
    void clear()            { set( 0, 0, 0, 0 ); }

    // Return true if rectangle is valid (true if empty)
    bool isValid() const    { return x1() <= x2e() && y1() <= y2e(); }

    // Flip rectangle within the given width/height
    void flipX( int w )
    {
        myVals[0] = I2E(flipI(x1(), w));    // convert to exclusive for swap
        myVals[2] = flipI(x2(), w);
        UTswap(myVals[0], myVals[2]);
    }
    void flipY( int h )
    {
        myVals[1] = I2E(flipI(y1(), h));    // convert to exclusive for swap
        myVals[3] = flipI(y2(), h);
        UTswap(myVals[1], myVals[3]);
    }

    // Accessors
    int x1() const          { return myVals[0]; }
    int y1() const          { return myVals[1]; }
    int x2e() const         { return myVals[2]; }
    int y2e() const         { return myVals[3]; }
    int x2() const          { return E2I(x2e()); }
    int y2() const          { return E2I(y2e()); }

    int x() const           { return x1(); }
    int y() const           { return y1(); }
    int width() const       { return E2D(x1(), x2e()); }
    int height() const      { return E2D(y1(), y2e()); }

    void setWidth(int w)        { myVals[2] = D2E(myVals[0], w); }
    void setHeight(int h)       { myVals[3] = D2E(myVals[1], h); }
    
    void setX(int x_)           { myVals[2] = x_ +  width(); myVals[0] = x_; }
    void setY(int y_)           { myVals[3] = y_ + height(); myVals[1] = y_; }
    void setX1(int x_)          { myVals[0] = x_; }
    void setY1(int y_)          { myVals[1] = y_; }
    void setX2(int x_)          { myVals[2] = I2E(x_); }
    void setY2(int y_)          { myVals[3] = I2E(y_); }
    void setX2e(int x_)         { myVals[2] = x_; }
    void setY2e(int y_)         { myVals[3] = y_; }
};

inline ostream  &operator<<(ostream &os, const UT_DimRect &r)
{
    os << "[" << r.x() << ","<< r.y() << "]-[" << r.x2() << "," << r.y2()
       << "] (" << r.w() << "x" << r.h() << ")";
    return os;
}
inline ostream  &operator<<(ostream &os, const UT_InclusiveRect &r)
{
    os << "[" << r.x() << ","<< r.y() << "]-[" << r.x2() << "," << r.y2()
       << "] (" << r.w() << "x" << r.h() << ")";
    return os;
}
inline ostream  &operator<<(ostream &os, const UT_ExclusiveRect &r)
{
    os << "[" << r.x() << ","<< r.y() << "]-[" << r.x2() << "," << r.y2()
       << "] (" << r.w() << "x" << r.h() << ")";
    return os;
}

//////////////////////////////////////////////////////////////////////////
// Inline Implementations
//////////////////////////////////////////////////////////////////////////

#define UT_RECT_OP_EQUALS(T1,T2) \
    inline bool operator==( const T1 &r1, const T2 &r2 ) \
        { return (r1.x() == r2.x() && r1.y() == r2.y() \
                && r1.width() == r2.width() \
                && r1.height() == r2.height()); }

    UT_RECT_OP_EQUALS(UT_DimRect,UT_DimRect)
    UT_RECT_OP_EQUALS(UT_DimRect,UT_InclusiveRect)
    UT_RECT_OP_EQUALS(UT_DimRect,UT_ExclusiveRect)
    UT_RECT_OP_EQUALS(UT_InclusiveRect,UT_DimRect)
    UT_RECT_OP_EQUALS(UT_InclusiveRect,UT_InclusiveRect)
    UT_RECT_OP_EQUALS(UT_InclusiveRect,UT_ExclusiveRect)
    UT_RECT_OP_EQUALS(UT_ExclusiveRect,UT_DimRect)
    UT_RECT_OP_EQUALS(UT_ExclusiveRect,UT_InclusiveRect)
    UT_RECT_OP_EQUALS(UT_ExclusiveRect,UT_ExclusiveRect)
#undef UT_RECT_OP_EQUALS

#define UT_RECT_OP_NOT_EQUALS(T1,T2) \
    inline bool operator!=( const T1 &r1, const T2 &r2 ) \
        { return !(r1 == r2); }

    UT_RECT_OP_NOT_EQUALS(UT_DimRect,UT_DimRect)
    UT_RECT_OP_NOT_EQUALS(UT_DimRect,UT_InclusiveRect)
    UT_RECT_OP_NOT_EQUALS(UT_DimRect,UT_ExclusiveRect)
    UT_RECT_OP_NOT_EQUALS(UT_InclusiveRect,UT_DimRect)
    UT_RECT_OP_NOT_EQUALS(UT_InclusiveRect,UT_InclusiveRect)
    UT_RECT_OP_NOT_EQUALS(UT_InclusiveRect,UT_ExclusiveRect)
    UT_RECT_OP_NOT_EQUALS(UT_ExclusiveRect,UT_DimRect)
    UT_RECT_OP_NOT_EQUALS(UT_ExclusiveRect,UT_InclusiveRect)
    UT_RECT_OP_NOT_EQUALS(UT_ExclusiveRect,UT_ExclusiveRect)
#undef UT_RECT_OP_NOT_EQUALS

#define UT_RECT_COPY_TO_DIM(T1,T2) \
    inline T1::T1( const T2 &r ) \
        : UT_BaseRectImpl( r.x(), r.y(), r.width(), r.height() ) { } \
    inline T1 & T1::operator=(const T2 &r) \
                { set( r.x(), r.y(), r.width(), r.height() ); return *this; }
#define UT_RECT_COPY_TO_INCLUSIVE(T1,T2) \
    inline T1::T1( const T2 &r ) \
        : UT_BaseRectImpl( r.x1(), r.y1(), r.x2(), r.y2() ) { } \
    inline T1 & T1::operator=(const T2 &r) \
                { set( r.x1(), r.y1(), r.x2(), r.y2() ); return *this; }
#define UT_RECT_COPY_TO_EXCLUSIVE(T1,T2) \
    inline T1::T1( const T2 &r ) \
        : UT_BaseRectImpl( r.x1(), r.y1(), r.x2e(), r.y2e() ) { } \
    inline T1 & T1::operator=(const T2 &r) \
                { set( r.x1(), r.y1(), r.x2e(), r.y2e() ); return *this; }

    UT_RECT_COPY_TO_DIM(UT_DimRectImpl,UT_DimRect)
    UT_RECT_COPY_TO_DIM(UT_DimRectImpl,UT_InclusiveRect)
    UT_RECT_COPY_TO_DIM(UT_DimRectImpl,UT_ExclusiveRect)
    UT_RECT_COPY_TO_INCLUSIVE(UT_InclusiveRectImpl,UT_DimRect)
    UT_RECT_COPY_TO_INCLUSIVE(UT_InclusiveRectImpl,UT_InclusiveRect)
    UT_RECT_COPY_TO_INCLUSIVE(UT_InclusiveRectImpl,UT_ExclusiveRect)
    UT_RECT_COPY_TO_EXCLUSIVE(UT_ExclusiveRectImpl,UT_DimRect)
    UT_RECT_COPY_TO_EXCLUSIVE(UT_ExclusiveRectImpl,UT_InclusiveRect)
    UT_RECT_COPY_TO_EXCLUSIVE(UT_ExclusiveRectImpl,UT_ExclusiveRect)
#undef UT_RECT_COPY_TO_DIM
#undef UT_RECT_COPY_TO_INCLUSIVE
#undef UT_RECT_COPY_TO_EXCLUSIVE

// include the templated implementation
#if defined( WIN32 ) || defined( LINUX ) || defined( MBSD ) || defined(GAMEOS)
    #include "UT_Rect.C"
#endif

#endif // __UT_Rect_h__

---