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

---

LaplacianDetector.h

Go to the documentation of this file.

#ifndef Impala_Core_Feature_LaplacianDetector_h
#define Impala_Core_Feature_LaplacianDetector_h

#include "Basis/Timer.h"
#include "Core/Array/Laplacian.h"
#include "Core/Feature/PointDescriptorTable.h"
#include "Core/Table/Sort.h"


namespace Impala
{
namespace Core
{
namespace Feature
{

    
template<class SrcArrayT>
PointDescriptorTable*
LaplacianDetection(SrcArrayT* imIntensity, 
                   bool useRecGauss, Real64 precision) 
{
    ILOG_VAR(Core.Feature.LaplacianDetection);
    PointDescriptorTable* output = new PointDescriptorTable();
    using namespace Impala::Core::Array;
    std::vector<Real64> precomputeScales;
    std::vector<Array2dScalarReal64*> cache;
    for(int i = 0; i < 21; i++) 
    {
        Real64 sigma = pow(sqrt(sqrt(Real64(2))),i) * 0.8;
        precomputeScales.push_back(sigma);
        Array2dScalarReal64* tmp = 0;
        Laplacian(tmp, imIntensity, sigma, 1, useRecGauss, precision);
        cache.push_back(tmp);

        ILOG_DEBUG("Computing Laplacian scale: " << sigma);
    }
    
    int borderIgnoreSize = 5;
    for(int i = 1; i < 20; i++) 
    {
        Array2dScalarReal64* imPrev = cache[i-1]; 
        Array2dScalarReal64* im     = cache[i];
        Array2dScalarReal64* imNext = cache[i+1];
        for(int x = borderIgnoreSize; x < im->CW() - borderIgnoreSize; x++)
        {
            for(int y = borderIgnoreSize; y < im->CH() - borderIgnoreSize; y++)
            {
                Real64 v = im->Val(x, y);
                if(fabs(v) < 0.001) continue;
                if((v >= im->Val(x, y+1)) &&
                   (v >= im->Val(x+1, y)) &&
                   (v >= im->Val(x, y-1)) &&
                   (v >= im->Val(x-1, y)) &&
                   (v >= im->Val(x+1, y+1)) &&
                   (v >= im->Val(x-1, y-1)) &&
                   (v >= im->Val(x-1, y+1)) &&
                   (v >= im->Val(x+1, y-1)) &&
                   (v >= imPrev->Val(x, y)) &&
                   (v >= imPrev->Val(x, y+1)) &&
                   (v >= imPrev->Val(x+1, y)) &&
                   (v >= imPrev->Val(x, y-1)) &&
                   (v >= imPrev->Val(x-1, y)) &&
                   (v >= imPrev->Val(x+1, y+1)) &&
                   (v >= imPrev->Val(x-1, y-1)) &&
                   (v >= imPrev->Val(x-1, y+1)) &&
                   (v >= imPrev->Val(x+1, y-1)) &&
                   (v >= imNext->Val(x, y)) &&
                   (v >= imNext->Val(x, y+1)) &&
                   (v >= imNext->Val(x+1, y)) &&
                   (v >= imNext->Val(x, y-1)) &&
                   (v >= imNext->Val(x-1, y)) &&
                   (v >= imNext->Val(x+1, y+1)) &&
                   (v >= imNext->Val(x-1, y-1)) &&
                   (v >= imNext->Val(x-1, y+1)) &&
                   (v >= imNext->Val(x+1, y-1)))
                {
                    // found one
                    output->Add(x, y, precomputeScales[i], 0, v);
                } else if((v <= im->Val(x, y+1)) &&
                   (v <= im->Val(x+1, y)) &&
                   (v <= im->Val(x, y-1)) &&
                   (v <= im->Val(x-1, y)) &&
                   (v <= im->Val(x+1, y+1)) &&
                   (v <= im->Val(x-1, y-1)) &&
                   (v <= im->Val(x-1, y+1)) &&
                   (v <= im->Val(x+1, y-1)) &&
                   (v <= imPrev->Val(x, y)) &&
                   (v <= imPrev->Val(x, y+1)) &&
                   (v <= imPrev->Val(x+1, y)) &&
                   (v <= imPrev->Val(x, y-1)) &&
                   (v <= imPrev->Val(x-1, y)) &&
                   (v <= imPrev->Val(x+1, y+1)) &&
                   (v <= imPrev->Val(x-1, y-1)) &&
                   (v <= imPrev->Val(x-1, y+1)) &&
                   (v <= imPrev->Val(x+1, y-1)) &&
                   (v <= imNext->Val(x, y)) &&
                   (v <= imNext->Val(x, y+1)) &&
                   (v <= imNext->Val(x+1, y)) &&
                   (v <= imNext->Val(x, y-1)) &&
                   (v <= imNext->Val(x-1, y)) &&
                   (v <= imNext->Val(x+1, y+1)) &&
                   (v <= imNext->Val(x-1, y-1)) &&
                   (v <= imNext->Val(x-1, y+1)) &&
                   (v <= imNext->Val(x+1, y-1)))
                {
                    // found one
                    output->Add(x, y, precomputeScales[i], 0, v);
                }
            }
        }
    }
    for(int i = 0; i < cache.size(); i++) 
    {
        delete cache[i];
    }
    return output;
}


template<class SrcArrayT>
PointDescriptorTable*
LaplacianDetector(SrcArrayT* input, 
                  bool useRecGauss=true, Real64 precision=3.0)
{
    ILOG_VAR(Core.Feature.LaplacianDetector);
    using namespace Impala::Core::Array;
    Timer timer;

    // convert to grey-scale
    Array2dScalarReal64* imIntensity = 0;
    RGB2Gray(imIntensity, input);
    
    // Laplacian scale selection
    PointDescriptorTable* output = LaplacianDetection(imIntensity,
                                                      useRecGauss, precision);

    ILOG_INFO("Laplacian detector found " << output->Size() << " points; " << 
              timer.SplitTimeStr());

    delete imIntensity;

    // removing double points should not be needed for the Laplacian
    //outputPointList.sort(compare_InterestCircle);
    //outputPointList.unique(uniq_InterestCircle);
    
    //ILOG_INFO("Unique operator left " << outputPointList.size() << " points" << timer.SplitTimeStr());
    
    // now sort the points by cornerness
    SortOnColumn5(output, false);
    return output;
}

} // namespace Feature
} // namespace Core
} // namespace Impala

#endif

---