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

---

RectanglePyramid.h

Go to the documentation of this file.

#ifndef Impala_Core_Geometry_RectanglePyramid_h
#define Impala_Core_Geometry_RectanglePyramid_h

#include "Core/Geometry/RectangleSet.h"
#include "Core/Geometry/MakeOverlappingRects.h"

namespace Impala
{
namespace Core
{
namespace Geometry
{


class RectanglePyramid
{
public:

    RectanglePyramid()
    {
        mImWidth = -1;
        mImHeight = -1;
        mBorderWidth = -1;
        mNrRectPerDimMin = -1;
        mNrRectPerDimMax = -1;
        mNrRectStepSize = -1;
    }

    RectanglePyramid(int borderWidth, int nrRectPerDimMin, int nrRectPerDimMax,
                     int nrRectStepSize, int imWidth, int imHeight)
    {
        mImWidth = -1;
        mImHeight = -1;
        mBorderWidth = borderWidth;
        mNrRectPerDimMin = nrRectPerDimMin;
        mNrRectPerDimMax = nrRectPerDimMax;
        mNrRectStepSize = nrRectStepSize;
        int curR = 0;
        for (int nr=mNrRectPerDimMin ; nr<=mNrRectPerDimMax ;
             nr+=mNrRectStepSize)
        {
            mRectSet.push_back(RectangleSet());
            mNrRectsPerDim.push_back(nr);
        }
        if((imWidth >=0) && (imHeight >= 0)) {
            /* do something with the passed imWidth and imHeight */
            SetImageSize(imWidth, imHeight);
        }
    }

    void
    SetImageSize(int imWidth, int imHeight)
    {
        if (mBorderWidth == -1)
            return;
        if ((imWidth == mImWidth) && (imHeight == mImHeight))
            return;
        mImWidth = imWidth;
        mImHeight = imHeight;
        for (int i=0 ; i<mRectSet.size() ; i++)
        {
            mRectSet[i].clear();
            MakeOverlappingRects(std::back_inserter(mRectSet[i]),
                                 mImWidth, mImHeight, mBorderWidth,
                                 mNrRectsPerDim[i], mNrRectsPerDim[i], 1);
        }
    }

    int
    NrLevels() const
    {
        return mNrRectsPerDim.size();
    }

    int
    NrRectsPerDim(int level) const
    {
        return mNrRectsPerDim[level];
    }

    int
    TotalNrRects() const
    {
        if (mNrRectPerDimMin == -1)
            return 0;
        int sum = 0;
        for (int nr=mNrRectPerDimMin ; nr<=mNrRectPerDimMax ;
             nr+=mNrRectStepSize)
        {
            sum += (nr+(nr-1))*(nr+(nr-1));
        }
        return sum;
    }

    int
    NrRects(int level) const
    {
        if (mRectSet[level].size() != 0) // known image size, so exact number
            return mRectSet[level].size();
        int r = NrRectsPerDim(level);
        return (r+(r-1))*(r+(r-1)); // unknown image size, but should be this
    }

    /* DK: obsolete and wrong?
    int
    FirstRect(int level) const
    {
        if (level == 0)
            return 0;
        int res = 0;
        for (int i=0 ; i<level ; i++)
            res += mRectSet[i].size();
        return res;
    }
    */

    Rectangle
    Rect(int level, int nr) const
    {
        return mRectSet[level][nr];
    }

    int
    GetBorderWidth() const
    {
        return mBorderWidth;
    }

    int
    GetImWidth() const
    {
        return mImWidth;
    }

    int
    GetImHeight() const
    {
        return mImHeight;
    }

private:

    int                       mImWidth;
    int                       mImHeight;
    int                       mBorderWidth;
    int                       mNrRectPerDimMin;
    int                       mNrRectPerDimMax;
    int                       mNrRectStepSize;
    std::vector<RectangleSet> mRectSet;  // set of rectangles for each level
    std::vector<int>          mNrRectsPerDim; // nr rects per dim for each level

};

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

#endif

---