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

---

KernelSet.h

Go to the documentation of this file.

#ifndef Impala_Core_Tracking_KernelSet_h
#define Impala_Core_Tracking_KernelSet_h

#include <vector>
#include <algorithm>
#include <assert.h>
#include "Core/Array/Arrays.h"

namespace Impala
{
namespace Core
{
namespace Tracking
{

class KernelSet
{
public:
    KernelSet(int size) : mFilterSize(size) 
    {
    }
    
    virtual ~KernelSet()
    {
        for(int i=0 ; i<mFilters.size() ; i++)
            delete mFilters[i];
    }

    void
    AddKernel(Array::Array2dScalarReal64* kernel)
    {
        assert(kernel->CW() == mFilterSize && kernel->CH() == mFilterSize);
        mFilters.push_back(kernel);
    }

    int
    GetFilterCount()
    {
        return mFilters.size();
    }

    void
    Apply(double* buffer, Array::Array2dVec3Real64& image, int posX, int posY)
    {
        // first clear result
        int i;
        for(i=0 ; i<3*mFilters.size() ; i++)
            buffer[i] = 0;

        // check for out of bounds
        int radius = mFilterSize / 2;
        if (posX-radius <= -image.BW() ||
            posY-radius <= -image.BH() ||
            posX+radius >= image.CW() + image.BW() ||
            posY+radius >= image.CH() + image.BH())
        {
            return;
        }

        posX -= radius;
        posY -= radius;
        int y;
        for(y=0 ; y<mFilterSize ; y++)
        {
            for(i=0 ; i<mFilters.size() ; i++)
            {
                double* ip; // image pointer
                double* fp; // filter pointer
                ip = image.CPB(posX, y+posY);
                fp = mFilters[i]->CPB(0, y);
                int x;
                for(x=0 ; x<mFilterSize ; x++)
                {
                    double* tp; // texture pointer
                    tp = buffer+(i*3);
                    *tp += *ip * *fp;
                    tp++;
                    ip++;
                    *tp += *ip * *fp;
                    tp++;
                    ip++;
                    *tp += *ip * *fp;
                    ip++;
                    fp++;
                }
            }
        }

        double total=0;
        for(i=0 ; i<3*mFilters.size() ; i++)
        {
            buffer[i] /= (double)mFilterSize*mFilterSize;
            total += buffer[i];
        }
    }

    
    void
    Reconstruct(Array::Array2dVec3Real64& image,
                Array::Array2dScalarReal64& texture, int posX, int posY)
    {
        Array::Array2dVec3Real64 mix(3*mFilterSize, mFilterSize, 0, 0);

        int y;
        double* ip;
        for(y=0 ; y<mFilterSize ; y++)
        {
            ip = mix.CPB(0,y);
            int x;
            for(x=0 ; x<3*mFilterSize ; x++)
            {
                *ip = 0.0;
                ip++;
            }
        }

        for(y=0 ; y<mFilterSize ; y++)
        {
            int i;
            for(i=0 ; i<mFilters.size() ; i++)
            {
                double *fp;
                ip = mix.CPB(0, y);
                fp = mFilters[i]->CPB(0, y);
                int x;
                for(x=0 ; x<mFilterSize ; x++)
                {
                    double *tp; // texture pointer
                    tp = texture.CPB(i*3, 0);
                    // red
                    *ip += *tp * *fp;
                    tp++;
                    ip++;
                    // green
                    *ip += *tp * *fp;
                    tp++;
                    ip++;
                    // blue
                    *ip += *tp * *fp;
                    ip++;
                    fp++;
                }
            }
        }

        for(y=0 ; y<mFilterSize ; y++)
        {
            ip = mix.CPB(0, y);
            int x;
            for(x=0 ; x<3*mFilterSize ; x++)
            {
                *ip /= (double)mFilters.size(); //divide by the number of filters
                ip++;
            }
        }

        //now add the images at the correct position
        for(y=0 ; y<mFilterSize ; y++)
        {
            if(y+posY>=0 && y+posY<image.CH())
            {
                double *mp = mix.CPB(0, y);
                double *ip = image.CPB(posX, y+posY);
                for(int x=0 ; x<mFilterSize ; x++)
                {
                    if(x+posX>=0 && x+posX<image.CW())
                    {
                        ip[3*x]   += mp[3*x];
                        ip[3*x+1] += mp[3*x+1];
                        ip[3*x+2] += mp[3*x+2];
                    }
                }
            }
        }
    }


    void
    ReconstructSeparate(std::vector<Array::Array2dVec3Real64*>* images,
                        Array::Array2dScalarReal64& texture)
    {
        int y;
        for(y=0 ; y<mFilterSize ; y++)
        {
            for(int i=0 ; i<mFilters.size() ; i++)
            {
                double* ip = (*images)[i]->CPB(0,y);
                int x;
                for(x=0 ; x<3*mFilterSize ; x++)
                {
                    *ip = 0.0;
                    ip++;
                }
            }
        }

        for(y=0 ; y<mFilterSize ; y++)
        {
            for(int i=0 ; i<mFilters.size() ; i++)
            {
                double *ip = (*images)[i]->CPB(0, y);
                double *fp = mFilters[i]->CPB(0, y);
                int x;
                for(x=0 ; x<mFilterSize ; x++)
                {
                    double *tp; // texture pointer
                    tp = texture.CPB(i*3, 0);
                    // red
                    *ip += *tp * *fp;
                    tp++;
                    ip++;
                    // green
                    *ip += *tp * *fp;
                    tp++;
                    ip++;
                    // blue
                    *ip += *tp * *fp;
                    ip++;
                    fp++;
                }
            }
        }
    }

private:
    std::vector<Array::Array2dScalarReal64*> mFilters;
    int mFilterSize;

    void operator= (const KernelSet&); // not allowed
};

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

#endif //Impala_Core_Tracking_KernelSet_h

---