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

---

Functors.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Trait_Functors_h
#define Impala_Core_Array_Trait_Functors_h

#include "Core/Array/Element/E0LargeVal.h"
#include "Core/Array/Element/E0SmallVal.h"
#include "Core/Array/Pattern/Categories.h"
#include "Core/Tracking/BasicTypes.h"
#include "Core/Geometry/PointZ.h"

namespace Impala
{
namespace Core
{
namespace Array
{
namespace Trait
{

class FuncBpoMulPtr
{
public:
    typedef Pattern::TagTransInVar TransVarianceCategory;
    typedef Pattern::TagCallPointer CallCategory;

    FuncBpoMulPtr()
        {
        }

    void
        DoIt(double* res, double* x, double* y)
        {
        for(int i=0 ; i<3 ; i++)
            res[i] = x[i] * y[i];
        }

};

class FuncBpoAddAssignPtr
{
public:
    typedef Pattern::TagTransInVar TransVarianceCategory;
    typedef Pattern::TagCallPointer CallCategory;

        FuncBpoAddAssignPtr()
        {
        }

    void
        DoIt(double* x, double* y)
        {
        for(int i=0 ; i<3 ; i++)
            x[i] += y[i];
        }

    static void
        NeutralElement(double* x)
        {
        for(int i=0 ; i<3 ; i++)
            x[i] += 0;
        }
};


class FuncUpoRGB2OOO
{
public:
    typedef Pattern::TagTransInVar TransVarianceCategory;
    typedef Pattern::TagCallValue CallCategory;

        typedef Vec3Int32 DstArithT;
        typedef Vec3Int32 SrcArithT;

        FuncUpoRGB2OOO()
        {
        }

    Vec3Int32
        DoIt(const Vec3Int32& p)
        {
        int o1,o2,o3; //static to prevent allocation and cleanup every iteration
        o1 = (p.X()+p.Y()+p.Z())/3;
        if(o1>255)
            o1=255;
        if(o1<0)
            o1=0;
        o2 = 127+(p.X()-p.Y())/2;
        if(o2>255)
            o2=255;
        if(o2<0)
            o2=0;
        o3 = 127+(2*p.Z()-p.X()-p.Y())/4;
        if(o3>255)
            o3=255;
        if(o3<0)
            o3=0;
        return Vec3Int32(o1, o2, o3);
        }
};


class FuncUpoRGB2OOOPtr
{
public:
    typedef Pattern::TagTransInVar TransVarianceCategory;
    typedef Pattern::TagCallPointer CallCategory;

        typedef Vec3Int32 DstArithT;
        typedef Vec3Int32 SrcArithT;

        FuncUpoRGB2OOOPtr()
        {
        }

        void DoIt(double *ooo, unsigned char* rgb)
        {
        ooo[0] = ((double)(rgb[0]+rgb[1]+rgb[2]))/3.0;
        ooo[1] = ((double)rgb[0]-rgb[1])/2.0;
        ooo[2] = ((double)2.0*rgb[2]-rgb[0]-rgb[1])/4.0;
        }
};


class FuncUpoOOO2RGB
{
public:
    typedef Pattern::TagTransInVar TransVarianceCategory;
    typedef Pattern::TagCallValue CallCategory;

        typedef Vec3Int32 DstArithT;
        typedef Vec3Int32 SrcArithT;

        FuncUpoOOO2RGB()
        {
        }

    Vec3Int32
        DoIt(const Vec3Int32& p)
        {
        int o2,o3,r,g,b; //static to prevent allocation and cleanup every iteration
        o2 = p.Y() - 127;
        o3 = p.Z() - 127;
        r = p.X()+o2-(0.666666666666*o3);
        if(r<0)
            r=0;
        if(r>255)
            r=255;
        g = p.X()-o2-(0.666666666666*o3);
        if(g<0)
            g=0;
        if(g>255)
            g=255;
        b = p.X()+(1.3333333333*o3);
        if(b<0)
            b=0;
        if(b>255)
            b=255;
        return Vec3Int32(r, g, b);
        }
};


class FuncBpoManhatDist
{
public:
    typedef Pattern::TagTransInVar TransVarianceCategory;
    typedef Pattern::TagCallPointer CallCategory;

        typedef Vec3Int32 DstArithT;
        typedef Vec3Int32 Src1ArithT;
        typedef Vec3Int32 Src2ArithT;

    FuncBpoManhatDist() {}

    void
        DoIt(double* res, double* p1, double* p2)
        {
        int i;
        double t,dist=0;
        for(i=0 ; i<3 ; i++)
        {
            t = p1[i] - p2[i];
            dist += t*t;
        }
        for(i=0 ; i<3 ; i++)
        {
            res[i] = dist;
        }
        }
};


class FuncExportDifference
{
public:
    typedef Pattern::TagTransInVar TransVarianceCategory;
    typedef Pattern::TagCallPointer CallCategory;

        typedef Vec3Int32 DstArithT;
        typedef Vec3Int32 Src1ArithT;
        typedef Vec3Int32 Src2ArithT;

    double mError;

    FuncExportDifference() {mError = 0;}

    void
        DoIt(double* res, double* p1, double* p2)
        {
        for(int i=0 ; i<3 ; i++)
        {
            double d;
            d = p1[0] - p2[0];
            mError += d*d;
        }
        }
};

template<class ArithT, class DataT>
class FuncExportMinMax
{
public:
    typedef Pattern::TagPixOpOut   DirectionCategory;
    typedef Pattern::TagTransVar   TransVarianceCategory;
    typedef Pattern::Tag1Phase     PhaseCategory;

        FuncExportMinMax()
        {
        Reset();
        }

    void
        DoIt(const ArithT& v, int x, int y)
        {
        if(v<minVal)
        {
            minVal = v;
            minPos.mX = x;
            minPos.mY = y;
        }
        else
            if(v>maxVal)
            {
                maxVal = v;
                maxPos.mX = x;
                maxPos.mY = y;
            }
        }

    void Reset()
    {
        minVal = Element::E0LargeVal<ArithT>(ArithT());
                maxVal = Element::E0SmallVal<ArithT>(ArithT());
    }

    ArithT minVal;
        ArithT maxVal;
    Geometry::PointZ minPos;
    Geometry::PointZ maxPos;
};


class FuncUpoColorCode
{
public:
    typedef Pattern::TagTransInVar TransVarianceCategory;
    typedef Pattern::TagCallPointer CallCategory;

    double mStep;
        FuncUpoColorCode(double maxColor)
        {
        mStep = 255.0 / maxColor;
        }

    void
        DoIt(unsigned char* out, unsigned char* in)
        {
        if(*in)
        {
            out[0] = 255;
            out[1] = 255 - (*in-1) * mStep;
            out[2] = 255 - (*in-1) * mStep;
        }
        else
        {
            out[0] = out[1] = out[2] = 0;
        }
        }

    void
        DoIt(unsigned char* out, double* in)
        {
        out[0] = (*in) * mStep;
        out[1] = (*in) * mStep;
        out[2] = (*in) * mStep;
        }

};

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

#endif //Impala_Core_Array_Trait_Functors_h

---