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

---

Harris.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Harris_h
#define Impala_Core_Array_Harris_h

#include <vector>
#include "Core/Array/Arrays.h"
#include "Core/Array/RecGauss.h"
#include "Core/Array/GaussDerivative.h"
#include "Core/Array/Mul.h"
#include "Core/Array/Add.h"
#include "Core/Array/Norm2Sqr.h"
#include "Core/Array/ArrayListDelete.h"
#include "Core/Array/Pattern/PatM3PixOp.h"
#include "Core/Array/Trait/M3poHarris.h"
#include "Core/Array/Trait/M3poNorm2Sqr.h"
#include "Core/Array/Pattern/PatM9PixOp.h"
#include "Core/Array/Trait/M9poHx.h"
#include "Core/Array/Trait/M9poHy.h"
#include "Core/Array/Pattern/PatM9N4PixOp.h"
#include "Core/Array/Trait/M9N4poFO.h"
#include "Core/Array/Trait/M9N4poFSph.h"

namespace Impala
{
namespace Core
{
namespace Array
{


// The real thing : computes Lx2*Ly2 - LxLy*LxLy - _k*(Lx2+Ly2)*(Lx2+Ly2)
template<class DstArrayT, class SrcArrayT>
inline void
Harris(DstArrayT*& dst, SrcArrayT* Lx2, SrcArrayT* Ly2, SrcArrayT* LxLy,
       Real64 sigmaA, Real64 k, bool useRecGauss = false)
{
    DstArrayT* Lx2g = 0;
    DstArrayT* Ly2g = 0;
    DstArrayT* LxLyg = 0;
    if (useRecGauss)
    {
        RecGauss(Lx2g, Lx2, sigmaA, sigmaA, 0, 0, 3);
        RecGauss(Ly2g, Ly2, sigmaA, sigmaA, 0, 0, 3);
        RecGauss(LxLyg, LxLy, sigmaA, sigmaA, 0, 0, 3);
    }
    else
    {
        GaussDerivative(Lx2g, Lx2, sigmaA, 0, 0, 3.0);
        GaussDerivative(Ly2g, Ly2, sigmaA, 0, 0, 3.0);
        GaussDerivative(LxLyg, LxLy, sigmaA, 0, 0, 3.0);
    }

    Trait::M3poHarris<DstArrayT, SrcArrayT> mpo(k);
    Pattern::PatM3PixOp(dst, Lx2g, Ly2g, LxLyg, mpo);

    delete Lx2g;
    delete Ly2g;
    delete LxLyg;
}

// Harris on scalar images
template<class DstArrayT, class SrcArrayT>
inline void
Harris(DstArrayT*& dst, SrcArrayT* Lx, SrcArrayT* Ly,
       Real64 sigmaA, Real64 k, bool useRecGauss = false)
{
    DstArrayT* Lx2 = 0;
    Mul(Lx2, Lx, Lx);
    DstArrayT* Ly2 = 0;
    Mul(Ly2, Ly, Ly);
    DstArrayT* LxLy = 0;
    Mul(LxLy, Lx, Ly);
    Harris(dst, Lx2, Ly2, LxLy, sigmaA, k, useRecGauss);

    delete Lx2;
    delete Ly2;
    delete LxLy;
}

// Harris on vec2 images
template<class DstArrayT, class SrcArrayT>
inline void
Harris(DstArrayT*& dst, SrcArrayT* Lx, SrcArrayT* Ly, SrcArrayT* Lxd2,
       SrcArrayT* Lyd2, Real64 sigmaA, Real64 k, bool useRecGauss = false)
{
    DstArrayT* Lx2 = 0;
    Norm2Sqr(Lx2, Lx, Lxd2);
    DstArrayT* Ly2 = 0;
    Norm2Sqr(Ly2, Ly, Lyd2);
    DstArrayT* LxLy = 0;
    Mul(LxLy, Lx, Ly);
    DstArrayT* tmp = 0;
    Mul(tmp, Lxd2, Lyd2);
    Add(LxLy, LxLy, tmp);
    Harris(dst, Lx2, Ly2, LxLy, sigmaA, k, useRecGauss);

    delete tmp;
    delete Lx2;
    delete Ly2;
    delete LxLy;
}

// Harris on vec3 images
template<class DstArrayT, class SrcArrayT>
inline void
Harris(DstArrayT*& dst, SrcArrayT* Lx, SrcArrayT* Ly, SrcArrayT* Lxd2,
       SrcArrayT* Lyd2, SrcArrayT* Lxd3, SrcArrayT* Lyd3, Real64 sigmaA,
       Real64 k, bool useRecGauss = false)
{
    Trait::M3poNorm2Sqr<DstArrayT, SrcArrayT> mpo;
    DstArrayT* Lx2 = 0;
    Pattern::PatM3PixOp(Lx2, Lx, Lxd2, Lxd3, mpo);
    DstArrayT* Ly2 = 0;
    Pattern::PatM3PixOp(Ly2, Ly, Lyd2, Lyd3, mpo);
    DstArrayT* LxLy = 0;
    Mul(LxLy, Lx, Ly);
    DstArrayT* tmp = 0;
    Mul(tmp, Lxd2, Lyd2);
    Add(LxLy, LxLy, tmp);
    Mul(tmp, Lxd3, Lyd3);
    Add(LxLy, LxLy, tmp);
    Harris(dst, Lx2, Ly2, LxLy, sigmaA, k, useRecGauss);

    delete tmp;
    delete Lx2;
    delete Ly2;
    delete LxLy;
}


// relies on rgbList to contain R, Rx, Ry, G, Gx, Gy, B, Bx, By
template<class ArrayT>
inline void
HarrisObj(ArrayT*& dst, const std::vector<ArrayT*>& rgbList, double sigmaA,
          double k, bool useRecGauss = false)
{
    Trait::M9poHx<ArrayT, ArrayT> mpoHx;
    ArrayT* hx = 0;
    Pattern::PatM9PixOp(hx,
                        rgbList[0], rgbList[3], rgbList[6],
                        rgbList[1], rgbList[4], rgbList[7],
                        rgbList[2], rgbList[5], rgbList[8],
                        mpoHx);

    Trait::M9poHy<Array2dScalarReal64, Array2dScalarReal64> mpoHy;
    ArrayT* hy = 0;
    Pattern::PatM9PixOp(hy,
                        rgbList[0], rgbList[3], rgbList[6],
                        rgbList[1], rgbList[4], rgbList[7],
                        rgbList[2], rgbList[5], rgbList[8],
                        mpoHy);

    Harris(dst, hx, hy, sigmaA, k, useRecGauss);
    delete hx;
    delete hy;
}

// relies on rgbList to contain R, Rx, Ry, G, Gx, Gy, B, Bx, By
template<class ArrayT>
inline void
HarrisSperical(ArrayT*& dst, const std::vector<ArrayT*>& rgbList, double sigmaA,
               double k, bool useRecGauss = false)
{
    Trait::M9N4poFSph<ArrayT, ArrayT> mnpoFSph;
    std::vector<ArrayT*> fList;
    fList = Pattern::PatM9N4PixOp<ArrayT>(rgbList[0], rgbList[3], rgbList[6],
                                          rgbList[1], rgbList[4], rgbList[7],
                                          rgbList[2], rgbList[5], rgbList[8],
                                          mnpoFSph);

    Harris(dst, fList[0], fList[1], fList[2], fList[3], sigmaA, k, useRecGauss);
    ArrayListDelete(&fList);
}

// relies on rgbList to contain R, Rx, Ry, G, Gx, Gy, B, Bx, By
template<class ArrayT>
inline void
HarrisOpponent(ArrayT*& dst, const std::vector<ArrayT*>& rgbList, double sigmaA,
               double k, bool useRecGauss = false)
{
    Trait::M9N4poFO<ArrayT, ArrayT> mnpoFO;
    std::vector<ArrayT*> fList;
    fList = Pattern::PatM9N4PixOp<ArrayT>(rgbList[0], rgbList[3], rgbList[6],
                                          rgbList[1], rgbList[4], rgbList[7],
                                          rgbList[2], rgbList[5], rgbList[8],
                                          mnpoFO);

    Harris(dst, fList[0], fList[1], fList[2], fList[3], sigmaA, k, useRecGauss);
    ArrayListDelete(&fList);
}

// relies on rgbList to contain R, Rx, Ry, G, Gx, Gy, B, Bx, By
template<class ArrayT>
inline void
HarrisRGB(ArrayT*& dst, const std::vector<ArrayT*>& rgbList, double sigmaA,
          double k, bool useRecGauss = false)
{
    Harris(dst, rgbList[1], rgbList[2], rgbList[4], rgbList[5],
           rgbList[7], rgbList[8], sigmaA, k, useRecGauss);
}

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

#endif

---