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

---

VisSemGabor.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_VisSemGabor_h
#define Impala_Core_Array_VisSemGabor_h

#include <vector>
#include "Core/Array/Arrays.h"
#include "Core/Array/ArraySet.h"
#include "Core/Array/Rgb2Ooo.h"
#include "Core/Array/Set.h"
#include "Core/Array/Add.h"
#include "Core/Array/Sub.h"
#include "Core/Array/Div.h"
#include "Core/Array/Mul.h"
#include "Core/Array/Norm2.h"
#include "Core/Array/Threshold.h"
#include "Core/Array/RecGabor.h"
#include "Core/Array/RecGauss.h"
#include "Core/Array/PixStat.h"
#include "Core/Array/ProjectRange.h"

namespace Impala
{
namespace Core
{
namespace Array
{


inline void 
VisSemGabor(ArraySet<Array2dScalarReal64>& res, Array2dVec3UInt8* rgb,
            double scale, double freq, int nrOrient)
{

    // hack : hard coded for nrOrient == 4
    // this will keep arrays in a specific order if the set is empty:
    res.Array("gaborW0");
    res.Array("gaborWl0");
    res.Array("gaborWll0");
    res.Array("gaborW45");
    res.Array("gaborWl45");
    res.Array("gaborWll45");
    res.Array("gaborW90");
    res.Array("gaborWl90");
    res.Array("gaborWll90");
    res.Array("gaborW135");
    res.Array("gaborWl135");
    res.Array("gaborWll135");
    res.Array("Wl");
    res.Array("Wll");

    if (!rgb)
        return; // call was to figure out what would be the result

    // set the different orientations
    double* orients = new double[nrOrient];
    orients[0] = 0;
    for (int i=1 ; i<nrOrient; i++)
        orients[i] = orients[i-1] + M_PI/nrOrient;

    // convert to opponent color space
    Array2dVec3Real64* ooo = 0;
    Rgb2Ooo(ooo, rgb);

    // declare and initialize temporary images
    Array2dScalarReal64* E_0_SR64 = 0;
    Array2dComplex64* E_0_C64 = 0;
    Array2dComplex64* gabor = 0;
    Array2dScalarReal64* tmp_SR64 = 0;
    Array2dComplex64* tmp_C64 = 0;

    // init each color channel
    Array2dScalarReal64* imOOO_SR64[3];
    Array2dComplex64* imOOO_C64[3];
    for (int ii=0 ; ii<3 ; ii++) {
        imOOO_SR64[ii] = 0;
        ProjectRange(imOOO_SR64[ii], ooo, ii+1);
        imOOO_C64[ii] = 0;
        Set(imOOO_C64[ii], imOOO_SR64[ii]);
    }

    // creat a smooth intensity image
    RecGauss(E_0_SR64, imOOO_SR64[0], scale, scale, 0, 0, 3);

    // create a threshold image, since we divide by intensity, threshold on low intensity
    int thresholdVal = 15;
    Array2dScalarReal64* threshE_0_SR64 = 0;
    Threshold(threshE_0_SR64, E_0_SR64, thresholdVal);
    //Real64 sum;
    //Real64 nr;
    //PixStatBasic(threshE_0_SR64, &nr, &sum, (Real64*) 0, (Real64*) 0);
    //std::cout << "threshold: nr = " << nr << ", sum = " << sum << std::endl;

    // get a list of all gabor responses
    //std::vector<CxArray2dScalarReal64*> imList;
    int cur = 0;

    // first, texture
    for (int oi=0; oi<nrOrient; oi++)
    {
        // with W invariant, use the intensity channel
        for (int pixDim=0;pixDim<3 ; pixDim++)
        {
            //std::cout << "gabor pixdim " << pixDim << ", orient " << oi << std::endl;
            Set(tmp_C64, imOOO_SR64[pixDim]);
            RecGabor(gabor, tmp_C64, scale, freq, orients[oi]);

            // convert complex nr. to real nr, by the magnitude
            //Array2dScalarReal64* res = 0;
            Norm2(res.Array(cur), gabor);

            // with  W invariant divide by smooth intensity E_0 after Gabor filtering
            Div(res.Array(cur), res.Array(cur), E_0_SR64);

            //smooth
            //RecGauss(res.Array(cur), res.Array(cur), 1.95*scale, 1.95*scale,0, 0, 3);

            // threshold the low intensity values, since we divide by intensity
            Mul(res.Array(cur), res.Array(cur), threshE_0_SR64);

            // add to result-list
            //imList.push_back(res);
            cur++;

        } // end for pixDim
    } // end for(orientation)

    // now, add color information.

    // dividing by E makes the intensity for the W invariant E/E =1,
    // so we can leave E out.
    for (int pixDim=1 ; pixDim<3 ; pixDim++)
    {
        //Array2dScalarReal64* res = 0;

        RecGauss(res.Array(cur), imOOO_SR64[pixDim], scale, scale, 0, 0, 3);

        // with W invariant divide by smooth intensity E_0
        Div(res.Array(cur), res.Array(cur), E_0_SR64);

        // threshold the low intensity values, since we divide by intensity
        Mul(res.Array(cur), res.Array(cur), threshE_0_SR64);

        //imList.push_back(res);
        cur++;
    } // end for pixDim

    // clean up
    delete orients;
    for (int j=0 ; j<3 ; j++) {
        delete imOOO_SR64[j];
        delete imOOO_C64[j];
    }
    delete E_0_SR64;
    delete E_0_C64;
    delete gabor;
    delete tmp_SR64;
    delete tmp_C64;
    delete threshE_0_SR64;
    delete ooo;
}

} // namespace Array
} // namespace Core
} // namespace Impala

#endif

---