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

---

InvWiccest.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_InvWiccest_h
#define Impala_Core_Array_InvWiccest_h

#include <vector>
#include "Core/Array/Arrays.h"
#include "Core/Array/ArraySet.h"
#include "Core/Array/InvCompDer.h"
#include "Core/Array/InvCxy.h"
#include "Core/Array/Rgb2Ooo.h"
#include "Core/Array/Add.h"
#include "Core/Array/Sub.h"
#include "Core/Array/Div.h"
#include "Core/Array/DivVal.h"
#include "Core/Array/Norm2Sqr.h"
#include "Core/Array/ArrayListDelete.h"
#include "Core/Array/Pattern/PatM9N4PixOp.h"
#include "Core/Array/Trait/M9N4poCxy.h"

namespace Impala
{
namespace Core
{
namespace Array
{


/*
input is an rgb image output is a list of:
- gradient (Ex*Ex + Ey*Ey)
- Wx
- W 45
- Wy
- W 135
- Clx
- Cl 45
- Cly
- Cl 135
- Cllx
- Cll 45
- Clly
- Cll 135

perhaps it would be better to return gradient through another parameter??
*/

inline std::vector<Array2dScalarReal64*>
InvWiccest(Array2dVec3UInt8* rgb, double derivativeSigma)
{
    std::vector<Array2dScalarReal64*> result;
    result.resize(13);
    for(int i=0 ; i<13 ; ++i)
        result[i] = new Array2dScalarReal64(rgb->CW(), rgb->CH(), rgb->BW(),
                                            rgb->BH());

    // convert to ooo
    Array2dVec3Real64* ooo = new Array2dVec3Real64(rgb->mCW, rgb->mCH, 0, 0);
    Rgb2Ooo(ooo, rgb);
    std::vector<Array2dScalarReal64*> listDer = InvCompDer(ooo, derivativeSigma,
                                                           3);
    delete ooo;

    // compute Wx and Wy
    Div(result[1], listDer[1], listDer[0]);
    Div(result[3], listDer[2], listDer[0]);

    // compute {Cl,Cll}{x,y}
    Trait::M9N4poCxy<Array2dScalarReal64, Array2dScalarReal64> mnpoConFeat;
    Pattern::PatM9N4PixOp(result[5], result[7], result[9], result[11],
                          listDer[0], listDer[1], listDer[2],
                          listDer[3], listDer[4], listDer[5],
                          listDer[6], listDer[7], listDer[8], mnpoConFeat);

    // compute the rest
    Norm2Sqr(result[0], listDer[1], listDer[2]); //gradient
    Add(result[ 2], result[1], result[3]); //W 45
    Sub(result[ 4], result[1], result[3]); //W 135
    Add(result[ 6], result[5], result[7]); //Cl 45
    Sub(result[ 8], result[5], result[7]); //Cl 135
    Add(result[10], result[9], result[11]); //Cll 45
    Sub(result[12], result[9], result[11]); //Cll 135

    for(int i=0 ; i<listDer.size() ; i++)
        delete listDer[i];

    return result;
}

inline void
InvWiccest(ArraySet<Array2dScalarReal64>& res, Array2dVec3Real64* ooo,
           Array2dVec3Real64* ooot, bool doRotation, bool doC, double sigma,
           double precision, bool useRecGauss)
{
    // this will keep arrays in a specific order if the set is empty:
    res.Array("Wx");
    if (doRotation)
        res.Array("W45");
    res.Array("Wy");
    if (doRotation)
        res.Array("W135");
    res.Array("Wlx");
    if (doRotation)
        res.Array("Wl45");
    res.Array("Wly");
    if (doRotation)
        res.Array("Wl135");
    res.Array("Wllx");
    if (doRotation)
        res.Array("Wll45");
    res.Array("Wlly");
    if (doRotation)
        res.Array("Wll135");

    if (doC)
    {
        res.Array("Clx");
        res.Array("Cly");
        res.Array("Cllx");
        res.Array("Clly");
    }

    if (ooot) {
        res.Array("Et");
        res.Array("Elt");
        res.Array("Ellt");
        res.Array("Wxt");
        res.Array("Wyt");
        res.Array("Wlxt");
        res.Array("Wlyt");
        res.Array("Wllxt");
        res.Array("Wllyt");
    }

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

    std::vector<Array2dScalarReal64*> oooList;
    oooList = InvCompDer(ooo, sigma, precision, useRecGauss);

    /* no invariance
    DivVal(res.Array("Wx"), oooList[1], 255.0);
    DivVal(res.Array("Wy"), oooList[2], 255.0);
    DivVal(res.Array("Wlx"), oooList[4], 255.0);
    DivVal(res.Array("Wly"), oooList[5], 255.0);
    DivVal(res.Array("Wllx"), oooList[7], 255.0);
    DivVal(res.Array("Wlly"), oooList[8], 255.0);
    */
    Div(res.Array("Wx"), oooList[1], oooList[0]);
    Div(res.Array("Wy"), oooList[2], oooList[0]);
    Div(res.Array("Wlx"), oooList[4], oooList[0]);
    Div(res.Array("Wly"), oooList[5], oooList[0]);
    Div(res.Array("Wllx"), oooList[7], oooList[0]);
    Div(res.Array("Wlly"), oooList[8], oooList[0]);
    if (doRotation)
    {
                Add(res.Array("W45"), res.Array("Wx"), res.Array("Wy"));
                Sub(res.Array("W135"), res.Array("Wx"), res.Array("Wy"));
                Add(res.Array("Wl45"), res.Array("Wlx"), res.Array("Wly"));
                Sub(res.Array("Wl135"), res.Array("Wlx"), res.Array("Wly"));
                Add(res.Array("Wll45"), res.Array("Wllx"), res.Array("Wlly"));
                Sub(res.Array("Wll135"), res.Array("Wllx"), res.Array("Wlly"));
    }

    if (doC)
        InvCxy<Array2dScalarReal64>(res.Array("Clx"), res.Array("Cly"),
                                    res.Array("Cllx"), res.Array("Clly"),
                                    oooList);

    if (!ooot)
    {
        ArrayListDelete(&oooList);
        return;
    }

    std::vector<Array2dScalarReal64*> oootList;
    oootList = InvCompDer(ooot, sigma, precision, useRecGauss);
    Div(res.Array("Et"),    oootList[0], oooList[0]);
    Div(res.Array("Elt"),   oootList[3], oooList[0]);
    Div(res.Array("Ellt"),  oootList[6], oooList[0]);
    Div(res.Array("Wxt"),   oootList[1], oooList[0]);
    Div(res.Array("Wyt"),   oootList[2], oooList[0]);
    Div(res.Array("Wlxt"),  oootList[4], oooList[0]);
    Div(res.Array("Wlyt"),  oootList[5], oooList[0]);
    Div(res.Array("Wllxt"), oootList[7], oooList[0]);
    Div(res.Array("Wllyt"), oootList[8], oooList[0]);

    ArrayListDelete(&oooList);
    ArrayListDelete(&oootList);
}

inline void 
InvWiccest(ArraySet<Array2dScalarReal64>& res, Array2dVec3UInt8* rgb,
           bool doRotation, bool doC, double sigma, double precision,
           bool useRecGauss)
{
    Array2dVec3Real64* ooo = 0;
    if (rgb)
        Rgb2Ooo(ooo, rgb);
    InvWiccest(res, ooo, 0, doRotation, doC, sigma, precision, useRecGauss);
    if (ooo)
        delete ooo;
}

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

#endif

---