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

---

RectanglePyramidPerDim.h

Go to the documentation of this file.

#ifndef Impala_Core_Geometry_RectanglePyramidPerDim_h
#define Impala_Core_Geometry_RectanglePyramidPerDim_h

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

namespace Impala
{
namespace Core
{
namespace Geometry
{


class RectanglePyramidPerDim
{
public:

    RectanglePyramidPerDim()
    {
        mImWidth = -1;
        mImHeight = -1;
        mBorderWidth = -1;

        mNrRectPerDimMinX = -1;
        mNrRectPerDimMaxX = -1;
        mNrRectStepSizeX = -1;

        mNrRectPerDimMinY = -1;
        mNrRectPerDimMaxY = -1;
        mNrRectStepSizeY = -1;

        mRegionOverlapRatio = -1;

    }

    RectanglePyramidPerDim(int borderWidth,
                           int nrRectPerDimMinX, int nrRectPerDimMaxX,
                           int nrRectStepSizeX,
                           int nrRectPerDimMinY, int nrRectPerDimMaxY,
                           int nrRectStepSizeY,
                           int imWidth, int imHeight,
                           double regionOverlapRatio=0.5)
    {
        mImWidth = -1;
        mImHeight = -1;
        mBorderWidth = borderWidth;
        mRegionOverlapRatio = regionOverlapRatio;

        mNrRectPerDimMinX = nrRectPerDimMinX;
        mNrRectPerDimMinY = nrRectPerDimMinY;
        mNrRectPerDimMaxX = nrRectPerDimMaxX;
        mNrRectPerDimMaxY = nrRectPerDimMaxY;
        mNrRectStepSizeX = nrRectStepSizeX;
        mNrRectStepSizeY = nrRectStepSizeY;

        int nr;
        for (nr=mNrRectPerDimMinX ; nr<=mNrRectPerDimMaxX ;
             nr+=mNrRectStepSizeX)
        {
            mNrRectsPerDimX.push_back(nr);
        }
        for (nr=mNrRectPerDimMinY ; nr<=mNrRectPerDimMaxY ;
             nr+=mNrRectStepSizeY)
        {
            mNrRectsPerDimY.push_back(nr);
        }

        for (nr=0; nr<NrLevels();nr++)
        {
            // create an empty container for each level
            mRectSet.push_back(RectangleSet());
        }

        // make sure to have equal pyramid levels, for both dimensions
        // repeat highest known level, if neccecary
        int levelDiff = mNrRectsPerDimX.size() - mNrRectsPerDimY.size();
        while (levelDiff > 0)
        {
            nr = mNrRectsPerDimY[mNrRectsPerDimY.size()-1];
            mNrRectsPerDimY.push_back(nr);
            levelDiff--;
        }
        while (levelDiff < 0)
        {
            nr = mNrRectsPerDimX[mNrRectsPerDimX.size()-1];
            mNrRectsPerDimX.push_back(nr);
            levelDiff++;
        }


        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();
            MakeSubRects(std::back_inserter(mRectSet[i]),
                         mImWidth, mImHeight, mBorderWidth,
                         mNrRectsPerDimX[i], mNrRectsPerDimY[i],
                         mRegionOverlapRatio);
        }
    }

    int
    NrLevels()
    {
        // x and y should have equal level, chose the largest
        return ( mNrRectsPerDimX.size() > mNrRectsPerDimY.size()
                 ? mNrRectsPerDimX.size() : mNrRectsPerDimY.size() );
    }

    int
    NrRectsPerDimX(int level)
    {
        return mNrRectsPerDimX[level];
    }

    int
    NrRectsPerDimY(int level)
    {
        return mNrRectsPerDimY[level];
    }

    int
    TotalNrRects()
    {
        if (mNrRectPerDimMinX == -1)
            return 0;
        int level, sum = 0;
        for (level=0 ; level<NrLevels();level++)
        {
            int nrX = (mNrRectsPerDimX[level]-1)/(1.0-mRegionOverlapRatio) + 1;
            int nrY = (mNrRectsPerDimY[level]-1)/(1.0-mRegionOverlapRatio) + 1;
            sum += nrX*nrY;
        }
        return sum;
    }

    int
    NrRects(int level)
    {
        if (mRectSet[level].size() != 0) // known image size, so exact number
            return mRectSet[level].size();

        int nrX = (mNrRectsPerDimX[level]-1)*(1.0-mRegionOverlapRatio) + 1;
        int nrY = (mNrRectsPerDimY[level]-1)*(1.0-mRegionOverlapRatio) + 1;
        return nrX*nrY; // unknown image size, but should be this
    }

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

    int
    GetBorderWidth()
    {
        return mBorderWidth;
    }

    int
    GetImWidth()
    {
        return mImWidth;
    }

    int
    GetImHeight()
    {
        return mImHeight;
    }

    String
    AsDefString()
    {
        String res;
        for (int i=0 ; i<mNrRectsPerDimX.size() ; i++)
        {
            if (i != 0)
                res += "-";
            res += MakeString(mNrRectsPerDimX[i]);
            res += "x";
            res += MakeString(mNrRectsPerDimY[i]);
        }
        return res;
    }

    void
    Dump()
    {
        std::cout << "RectanglePyramid" << std::endl;
        for (int l=0 ; l<NrLevels() ; l++)
        {
            std::cout << "l=" << l << ", nrRects=" << NrRectsPerDimX(l) << "x"
                      << NrRectsPerDimY(l) << " = " << NrRects(l) << std::endl;
            for (int r=0 ; r<NrRects(l) ; r++)
            {
                std::cout << "   r=" << r << " : " << Rect(l, r) << std::endl;
            }
        }
    }

private:

    int                       mImWidth;
    int                       mImHeight;
    int                       mBorderWidth;

    int                       mNrRectPerDimMinX;
    int                       mNrRectPerDimMaxX;
    int                       mNrRectStepSizeX;

    int                       mNrRectPerDimMinY;
    int                       mNrRectPerDimMaxY;
    int                       mNrRectStepSizeY;


    double                    mRegionOverlapRatio; // ratio of rectangle overlap

    std::vector<RectangleSet> mRectSet;  // set of rectangles for each level

    std::vector<int>          mNrRectsPerDimX; // nr rects per dim for each level
    std::vector<int>          mNrRectsPerDimY; // nr rects per dim for each level

};

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

#endif

---