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

---

DSurf.h

Go to the documentation of this file.

#ifndef Impala_Core_Feature_DSurf_h
#define Impala_Core_Feature_DSurf_h

#include "Core/Array/IntegrateReduce.h"
#include "Core/Feature/HaarResponse.h"
#include "Core/Feature/PointDescriptorTable.h"
#include "Util/TimeStats.h"

namespace Impala
{
namespace Core
{
namespace Feature
{

void
AddDSurfOptions(CmdOptions& options)
{
    options.AddOption(0, "surf-haar-size",      "int", "3");
    options.AddOption(0, "surf-subregion-size", "int", "2");
    options.AddOption(0, "surf-spaciality",     "int", "4");
}

void
GetDSurfOptions(CmdOptions& options, int& haarSize, int& subregionSize, int& spatiality)
{
    haarSize = options.GetInt("surf-haar-size");
    subregionSize = options.GetInt("surf-subregion-size");
    spatiality = options.GetInt("surf-spaciality");
}
    
inline void
ExtractFeatureIntoVector(Real64* vector,
                         std::vector<Array::Array2dScalarReal64*>& features,
                         int x, int y, int spatiality)
{
    double length = 0.;
    int begin = 0;
    for(int f=0 ; f<features.size() ; ++f)
    {
        for(int j=y ; j<y+spatiality ; ++j)
            for(int i=x ; i<x+spatiality ; ++i)
            {
                double v = features[f]->Value(i,j);
                vector[begin++] = v;
                length += v*v;
            }
    }
    // normalize the vector that we just added
    if(length != 0)
    {
        length = sqrt(length);
        for(int i=0 ; i<features.size() * spatiality * spatiality; i++)
            vector[i] /= length;
    }
}
    
Matrix::Mat*
DSurf(Array::Array2dScalarReal64* image,
      PointDescriptorTable* pointData,
      int sampleRate, int numberHaarSum, int spatiality)
{
    using namespace Matrix;

    ILOG_VAR(Impala.Core.Feature.DSurf);
    ILOG_DEBUG("image w="<< image->CW() <<", h="<< image->CH());
    /* In order to speed up processing reduce the image so one pixel has the
       same 'energy' as a block of sampleRate^2 pixels. */
    Array::Array2dScalarReal64* reduced = 0;
    IntegrateReduce(reduced, image, sampleRate);
    // haar responses
    std::vector<Array::Array2dScalarReal64*> haar = HaarResponse(reduced);
    delete reduced;
    // sum the haar responses into component of the surf feature
    std::vector<Array::Array2dScalarReal64*> components;
    int w = haar[0]->CW() / numberHaarSum;
    int h = haar[0]->CH() / numberHaarSum;
    for(int i=0 ; i<haar.size() ; ++i)
    {
        Array::Array2dScalarReal64* comp =
            new Array::Array2dScalarReal64(w, h, 0, 0);
        IntegrateReduceWeighted(comp, haar[i], numberHaarSum);
        components.push_back(comp);
        delete haar[i];
    }
    w = components[0]->CW();
    h = components[0]->CH();
    //now combine the components into actual surf features
    int nrFeatures = w*h;
    int sampleSize = sampleRate * numberHaarSum;
    int featureSize = sampleSize * spatiality;
    /* because the DSurf implementation does it's own sampling we need this loop
       to create the interest points with correct dimensions (actually only the
       middle point is needed) */
    if(pointData->Size() == 0)
    {
        for(int y=0 ; y<=h-spatiality ; ++y)
        {
            for(int x=0 ; x<=w-spatiality ; ++x)
            {
                int left=x*sampleSize;
                int top =y*sampleSize;
                int centerX = static_cast<int>(((featureSize) / 2.0 + left) + 0.5);
                int centerY = static_cast<int>(((featureSize) / 2.0 + top) + 0.5);
                // this gives the same output as the old way of doing things,
                // though the featureSize entries are not needed *twice*
                pointData->Add(centerX, centerY, featureSize+1, featureSize+1, 0);
                //Geometry::Rectangle r(left, top, left+featureSize, top+featureSize);
            }
        }
    }
    // here comes the actual creation of surf features
    /* we might speed this up as follows:
       - first allocate a double array for all features.
       - then loop over the component images sepqrately and write into the buffer.
         This might be faster because the component images are are accessed once.
       - then normalize all features and copy vectors into the point list.
    */
    int it = 0;
    Mat* descriptors = MatCreate<Mat>(pointData->Size(), components.size() * spatiality * spatiality);
    for(int y=0 ; y<=h-spatiality ; ++y)
    {
        for(int x=0 ; x<=w-spatiality ; ++x)
        {
            ExtractFeatureIntoVector(MatE(descriptors, it, 0), components, x, y, spatiality);
            it++;
        }
    }
    for(int i=0 ; i<components.size() ; ++i)
        delete components[i];
    return descriptors;
}
 

} // namespace Koen
} // namespace Sandbox
} // namespace Impala

#endif

---