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

---

ImagePyramid.h

Go to the documentation of this file.

#ifndef ImagePyramid_h
#define ImagePyramid_h

#include <vector>
#include "Core/Array/Arrays.h"
#include "Core/Array/GaussDerivative.h"
#include "Core/Array/Scale.h"

#include "Core/Tracking/BasicTypes.h"

namespace Impala
{
namespace Core
{
namespace Tracking
{


class ImagePyramid
{
public:
    ImagePyramid(Array::Array2dVec3Real64* base) // the base image is stored, but not owned
    {
        // the base image is stored, but not owned
        mLevels.reserve(8);
        mLevels.push_back(base);
        mScratch = new Array::Array2dVec3Real64(base->CW(), base->CH(), base->BW(), base->BH(), 0);
            Array::Array2dScalarReal64* kernel = Array::MakeGaussian1d(1.0, 0, 1.0, 3);
        mGaussKernel = new Array::Array2dVec3Real64(kernel->CW(), kernel->CH(), kernel->BW(), kernel->BH(), 0);
        Array::Pattern::PatSet(mGaussKernel,kernel,0,0,kernel->CW(),kernel->CH(),0,0);
        delete kernel;

        int w,h;
        w = base->CW();
        h = base->CH();
        mMaxTop = 1;
        while( w>2 && h>2 && w*h>100)
        {
            w/=2;
            h/=2;
            mMaxTop++;
        }
    }

    virtual ~ImagePyramid()
    {
        //delete all levels except the bottom one which is not owned...
        while(mLevels.size()>1)
        {
            delete mLevels.back();
            mLevels.pop_back();
        }
        delete mGaussKernel;
        delete mScratch;
    }

    void ComputeLevels(int top)
    {
        if(top > mMaxTop)
            top = mMaxTop;
        if(top == 0)
            top = mMaxTop;
        while(top>Levels())
            ComputeNextLevel();
    }

    Array::Array2dVec3Real64* GetLevel(int level)
    {
        if(level>=Levels())
            throw std::invalid_argument("[ImagePyramid::GetLevel] invalid level");
        return mLevels[level];
    }

    void PropagateBaseChanges()
    {
        int i;
        for(i=0 ; i<Levels()-1 ; i++)
        {
            ScaleAndCopy(i);
        }
    }

    int Levels()
    {
        return mLevels.size();
    }

    Point GetSize(int level)
    {
        Array::Array2dVec3Real64* img;
        img = GetLevel(level);
        return Point(img->CW(), img->CH());
    }

private:
    std::vector<Array::Array2dVec3Real64*> mLevels;
    Array::Array2dVec3Real64* mScratch;
    Array::Array2dVec3Real64* mGaussKernel;
    int mMaxTop; //the level at which you can't sub sample any more

    void ComputeNextLevel()
    {
        int w,h;
        w = mLevels[Levels()-1]->CW() / 2;
        h = mLevels[Levels()-1]->CH() / 2;
        int bw,bh;
        bw = mLevels[Levels()-1]->BW() / 2;
        bh = mLevels[Levels()-1]->BH() / 2;
        mLevels.push_back(new Array::Array2dVec3Real64(w,h,bw,bh));
        ScaleAndCopy(Levels()-2);
    }

    void ScaleAndCopy(int srcLevel)
    {
        int w,h;
        w = mLevels[srcLevel]->CW();
        h = mLevels[srcLevel]->CH();
        FakeResizeScratch(w,h);

        //warning: very very dirty tricks...
        //I'm incrementing the data pointer of the arrays so the gause filter 
        //processes the red,green and bleu planes appart

        //red
        Array::GaussDerivative(mScratch, mLevels[srcLevel], 1.0, 0, 0, 2.0);

        //green
        mScratch->mData += 1;
        mLevels[srcLevel]->mData += 1;
        Array::GaussDerivative<Array::Array2dVec3Real64,Array::Array2dVec3Real64>
            (mScratch, mLevels[srcLevel], 1.0, 0, 0, 2.0);
        
        //blue
        mScratch->mData += 1;
        mLevels[srcLevel]->mData += 1;
        Array::GaussDerivative(mScratch, mLevels[srcLevel], 1.0, 0, 0, 2.0);
        
        //restore pointer
        mScratch->mData -= 2;
        mLevels[srcLevel]->mData -= 2;

        Array::Scale(mLevels[srcLevel+1], mScratch, 0.5, 0.5, Geometry::NEAREST);
    }

    void FakeResizeScratch(int w, int h)
    {
        if(w>mLevels[0]->CW() || h>mLevels[0]->CH())
            throw std::logic_error("[ImagePyramid::FakeResizeScratch] too big");
        mScratch->mCW = w;
        mScratch->mCH = h;
    }

    //disable copying
    ImagePyramid(const ImagePyramid& copy);// {}
    ImagePyramid& operator=(const ImagePyramid& copy);// {return *this;}
};

} // namespace Tracking
} // namespace Core
} // namespace Impala

#endif ImagePyramid_h

---