|| || || || || || || ||

---

RectZ.h

Go to the documentation of this file.

#ifndef Impala_Core_Geometry_RectZ_h
#define Impala_Core_Geometry_RectZ_h

#include <iostream>

namespace Impala
{
namespace Core
{
namespace Geometry
{

/* * Class definition for (2d) rectangle in Z (integer coordinates).
 */
/* class not up to date with naming conventions: use Rectangle
class RectZ {
public:

    int mULX;
    int mULY;
    int mLRX;
    int mLRY;

    RectZ()
    {
        mULX = mULY = mLRX = mLRY = 0;
    }

    RectZ(int upperLeftX, int upperLeftY, int lowerRightX, int lowerRightY)
        : mULX(upperLeftX), mULY(upperLeftY), mLRX(lowerRightX), mLRY(lowerRightY)
    {
    }

    RectZ(int x1, int y1, int x2, int y2, bool check)
        : mULX(x1), mULY(y1), mLRX(x2), mLRY(y2)
    {
        if (check)
        {
            mULX = (x1 < x2) ? x1 : x2;
            mULY = (y1 < y2) ? y1 : y2;
            mLRX = (x1 < x2) ? x2 : x1;
            mLRY = (y1 < y2) ? y2 : y1;
        }
    }

    bool
    Valid() const
    {
        return !((mULX==0) && (mULY==0) && (mLRX==0) && (mLRY==0));
    }

    inline int
    Width() const
    {
        return mLRX - mULX + 1;
    }

    inline int
    Height() const
    {
        return mLRY - mULY + 1;
    }

    inline int
    Left() const
    {
        return mULX;
    }

    inline int
    Top() const
    {
        return mULY;
    }

    inline int
    Right() const
    {
        return mLRX;
    }

    inline int
    Bottom() const
    {
        return mLRY;
    }

    inline int&
    Left()
    {
        return mULX;
    }

    inline int&
    Top()
    {
        return mULY;
    }

    inline int&
    Right()
    {
        return mLRX;
    }

    inline int&
    Bottom()
    {
        return mLRY;
    }

    inline bool
    IsInside(int x, int y)
    {
        if(x < Right() &&
           x > Left() &&
           y > Top() &&
           y < Bottom())
           return true;
        return false;
    }

    void
    CheckSize()
    {
        if ((mULX == mLRX) && (mULY == mLRY))
            mULX = mULY = mLRX = mLRY = 0;
    }

    int
    operator==(const RectZ& r) const
    {
        return ((mULX == r.mULX) && (mULY == r.mULY) && (mLRX == r.mLRX) &&
                (mLRY == r.mLRY));
    }

};

inline std::ostream&
operator<<(std::ostream& os, const RectZ& r)
{
    os << "\"" << r.Left() << " " << r.Top() << " ";
    os << r.Right() << " " << r.Bottom() << "\"";
    return os;
}

inline std::istream&
operator>>(std::istream& is, RectZ& r)
{
    // if the stream does not contain the correct format, the line is flushed
    char c;
    is >> c;

    if (c != '"')
    {
        while(!is.eof() && c!='\n')
            is.read(&c, 1);
    }
    else
    {
        is >> r.Left() >> r.Top() >> r.Right() >> r.Bottom() >> c;
        if (c!='"')
            while(!is.eof() && c!='\n')
                is.read(&c, 1);
    }
    return is;
}
*/

} // namespace Geometry
} // namespace Core
} // namespace Impala

#endif

---