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

---

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/Geometry/InterestPointList.h"
#include "Core/Geometry/InterestRectangleZ.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& spaciality)
{
    haarSize = options.GetInt("surf-haar-size");
    subregionSize = options.GetInt("surf-subregion-size");
    spaciality = options.GetInt("surf-spaciality");
}
    
inline void
ExtractFeatureIntoVector(std::vector<Real64>& vector,
                         std::vector<Array::Array2dScalarReal64*>& features,
                         int x, int y, int spaciality)
{
    double length = 0.;
    int begin = vector.size();
    vector.reserve(begin + (features.size()*spaciality*spaciality));
    for(int f=0 ; f<features.size() ; ++f)
    {
        for(int j=y ; j<y+spaciality ; ++j)
            for(int i=x ; i<x+spaciality ; ++i)
            {
                double v = features[f]->Value(i,j);
                vector.push_back(v);
                length += v*v;
            }
    }
    // normalize the vector that we just added (so ignore the part before
    // 'begin')
    if(length != 0)
    {
        length = sqrt(length);
        for(int i=begin ; i<vector.size() ; ++i)
            vector[i] /= length;
    }
}
    
void
DSurf(Array::Array2dScalarReal64* image,
      Geometry::InterestPointList& pointList,
      int sampleRate, int numberHaarSum, int spaciality)
{
    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 * spaciality;
    /* 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(pointList.size() == 0)
    {
        for(int y=0 ; y<=h-spaciality ; ++y)
        {
            for(int x=0 ; x<=w-spaciality ; ++x)
            {
                int left=x*sampleSize;
                int top =y*sampleSize;
                Geometry::Rectangle r(left, top, left+featureSize, top+featureSize);
                Geometry::InterestRectangleZ* ir =
                    new Geometry::InterestRectangleZ(r);
                pointList.push_back(ir);
            }
        }
    }
    // 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.
    */
    Geometry::InterestPointList::iterator it = pointList.begin();
    for(int y=0 ; y<=h-spaciality ; ++y)
    {
        for(int x=0 ; x<=w-spaciality ; ++x)
        {
            Geometry::InterestPoint* ir = *it;
            it++;
            ExtractFeatureIntoVector(ir->mDescriptor, components, x, y, spaciality);
        }
    }
    for(int i=0 ; i<components.size() ; ++i)
        delete components[i];
}
 

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

#endif

---