NICE_SemSeg/semseg/operations/Operations3D.h

/**
* @file Operation3D.h
* @brief abstract class for any kind of feature extraction from 3d images
* @author Björn Fröhlich, Sven Sickert
* @date 24.04.2012

*/

#include <core/image/MultiChannelImageT.h>
#include <core/image/MultiChannelImage3DT.h>

#define BOUND(x,min,max) (((x)<(min))?(min):((x)>(max)?(max):(x)))

namespace OBJREC {

class Operation3D;

/**
 * @brief methods for value access
 **/
enum ValueTypes
{
    RAWFEAT,
    CONTEXT
};

/**
 * @brief feature extraction methods
 **/
enum OperationTypes {
    MINUS,
    MINUSABS,
    ADDITION,
    ONLY1,
    INTEGRAL,
    INTEGRALCENT,
    BIINTEGRALCENT,
    HAARHORIZ,
    HAARVERT,
    HAARSTACK,
    HAARDIAGXY,
    HAARDIAGXZ,
    HAARDIAGYZ,
    HAAR3HORIZ,
    HAAR3VERT,
    HAAR3STACK,
    RELATIVEXPOSITION,
    RELATIVEYPOSITION,
    RELATIVEZPOSITION,
    GLOBALFEATS,
    EQUALITY,
    RAYDIFF,
    RAYDIST,
    RAYORIENT,
    RAYNORM,
    MINUS_C,
    MINUSABS_C,
    ADDITION_C,
    ONLY1_C,
    INTEGRAL_C,
    INTEGRALCENT_C,
    BIINTEGRALCENT_C,
    HAARHORIZ_C,
    HAARVERT_C,
    HAARSTACK_C,
    HAARDIAGXY_C,
    HAARDIAGXZ_C,
    HAARDIAGYZ_C,
    HAAR3HORIZ_C,
    HAAR3VERT_C,
    HAAR3STACK_C,
    GLOBALFEATS_C,
    BIINTEGRAL,
    BIINTEGRAL_C,
    NBOPERATIONS
};

/**
 * @brief node class for context tree
 **/
class TreeNode
{

public:
    /** left child node */
    int left;

    /** right child node */
    int right;

    /** position of feat for decision */
    Operation3D *feat;

    /** decision stamp */
    double decision;

    /** is the node a leaf or not */
    bool isleaf;

    /** distribution in current node */
    std::vector<double> dist;

    /** depth of the node in the tree */
    int depth;

    /** how many pixels are in this node */
    int featcounter;

    /** unique number */
    int nodeNumber;

    /** simple constructor */
    TreeNode() : left ( -1 ), right ( -1 ), feat ( NULL ), decision ( -1.0 ), isleaf ( false ) {}

    /** standard constructor */
    TreeNode ( int _left, int _right, Operation3D *_feat, double _decision ) : left ( _left ), right ( _right ), feat ( _feat ), decision ( _decision ), isleaf ( false ) {}

    /**
     * @brief initialize node
     * @param _depth current depth in tree
     * @param _numClasses amount of classes (initialize distribution)
     * @param _nodeNumber unique node number
     */
    void init( int _depth, int _numClasses, int _nodeNumber)
    {
        depth = _depth;
        featcounter = 0;
        dist = std::vector<double> (_numClasses, 0.0);
        nodeNumber = _nodeNumber;
    }
};



/**
 * @brief holds all necessary information for feature extraction of 3d images
 **/
struct Features {
    /** simple features like RGB values */
    NICE::MultiChannelImage3DT<double> *feats;

    /** probabilities for each region */
    std::vector<std::vector<double> > *rProbs;
};



/**
 * @brief abstract operation class
 **/
class Operation3D
{
protected:
    /** two different points (e.g. for an rectangle or two positions), channels and size  */
    int x1, y1, z1, x2, y2, z2, channel1, channel2, wsize;
    
    /** type of feature */
    int featType;
    
    /** context multiplier */
    unsigned short cMultiplier;

    bool init;

    bool context;

public:

    /** simple constructor */
    Operation3D();

    /**
     * @brief set all parameters
     * @param _x1 position 1
     * @param _y1 position 1
         * @param _z1 position 1
     * @param _x2 position 2
     * @param _y2 position 2
         * @param _z2 position 2
     * @param _channel1 channel 1
     * @param _channel2 channel 2
     * @param _ftype feature type
     * @return void nothing
     **/
    virtual void set ( int _x1, int _y1, int _z1, int _x2, int _y2, int _z2, int _channel1, int _channel2, int _featType );

    /**
     * @brief set whether it is a context feature or not
     * @param _context context boolean
     * @return void nothing
     **/
    void setContext ( bool _context );

    /**
     * @brief return context information (set by setContext(bool)
     *
     * @return bool whether context is used or not
     **/
    bool getContext();
    
    /**
     * @brief set size of feature window
     * @param _wsize window size
     * @return void nothing
     **/
    void setWSize ( int _wsize );

    /**
     * @brief return context information (set by setContext(bool)
     *
     * @return int get feature type
     **/
    int getFeatType();

    /**
     * @brief abstract interface for feature computation
     * @param feats features
     * @param x current x position
     * @param y current y position
     * @param z current z position
     * @return double distance
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &z ) = 0;

    /**
     * @brief virtual clone operation instead of copy constructor (copy constructor does not work)
     **/
    virtual Operation3D* clone() = 0;

    /**
     * @brief print some infos about operation extraction type
     * @return string feature type
     **/
    virtual std::string writeInfos();

    /**
     * @brief exctract current image boarders
     * @param feats image information
     * @param xsize width
     * @param ysize height
         * @param zsize depth
     * @return void
     **/
    inline void getXYZ ( const Features &feats, int &xsize, int &ysize, int &zsize );

    /**
     * @brief extracts RAW-Type value from INTEGRAL-Type channel
     * @param feats image information
     * @param posX x-position
     * @param posY y-position
     * @param posZ z-position
     * @return double the original RAW-value at the coordinates
     **/
    inline double intToRaw ( const Features &feats, const int &posX, const int &posY, const int &posZ, int &channel );

    /**
     * @brief return operation type (for store and restore)
     * @return OperationTypes
     **/
    virtual OperationTypes getOps() = 0;

    /**
     * @brief store all information for current operation in stream
     * @param os out stream
     * @return void
     **/
    virtual void store ( std::ostream & os );

    /**
     * @brief restore all information for current operation from stream
     * @param is in stream
     * @return void
     **/
    virtual void restore ( std::istream & is );
};

/**
 * @brief simple equality check ?(A==B)
 **/
class RegionFeat3D: public Operation3D
{
public:
    /**
     * @brief interface for feature computation
     * @param feats features
     * @param x current x position
     * @param y current y position
         * @param z current z position
     * @return double distance
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &z );

    /**
     * @brief clone operation instead of copy constructor (copy constructor does not work)
     **/
    virtual Operation3D* clone()
    {
        Operation3D* o = new RegionFeat3D();
        o->setContext(context);
        return o;
    }

    /**
     * @brief print some infos about operation extraction type
     * @return string feature type
     **/
    virtual std::string writeInfos()
    {
        return "(-)RegionFeat           " + Operation3D::writeInfos();
    }

    /**
     * @brief return operation type (for store and restore)
     * @return OperationTypes
     **/
    virtual OperationTypes getOps()
    {
        return EQUALITY;
    }
};

/**
 * @brief simple difference operation A-B
 **/
class Minus3D: public Operation3D
{
public:
    /**
     * @brief interface for feature computation
     * @param feats features
     * @param x current x position
     * @param y current y position
         * @param z current z position
     * @return double distance
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &z );

    /**
     * @brief clone operation instead of copy constructor (copy constructor does not work)
     **/
    virtual Operation3D* clone()
    {
        Operation3D* o = new Minus3D();
        o->setContext(context);
        return o;
    }

    /**
     * @brief print some infos about operation extraction type
     * @return string feature type
     **/
    virtual std::string writeInfos()
    {
        std::string out = "Minus";

        if ( context )
            out = "(C)" + out;
        else
            out = "(R)" + out;

        return out + "                " +Operation3D::writeInfos();
    }

    /**
     * @brief return operation type (for store and restore)
     * @return OperationTypes
     **/
    virtual OperationTypes getOps()
    {
        if (context)
            return MINUS_C;
        else
            return MINUS;
    }
};

/**
 * @brief simple absolute difference operation |A-B|
 **/
class MinusAbs3D: public Operation3D
{

public:
    /**
     * @brief interface for feature computation
     * @param feats features
     * @param x current x position
     * @param y current y position
         * @param z current z position
     * @return double distance
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &z );

    /**
     * @brief clone operation instead of copy constructor (copy constructor does not work)
     **/
    virtual Operation3D* clone()
    {
        Operation3D* o = new MinusAbs3D();
        o->setContext(context);
        return o;
    }

    /**
     * @brief print some infos about operation extraction type
     * @return string feature type
     **/
    virtual std::string writeInfos()
    {
        std::string out = "MinusAbs";

        if ( context )
            out = "(C)" + out;
        else
            out = "(R)" + out;

        return out + "             " + Operation3D::writeInfos();
    }

    /**
     * @brief return operation type (for store and restore)
     * @return OperationTypes
     **/
    virtual OperationTypes getOps()
    {
        if (context)
            return MINUSABS_C;
        else
            return MINUSABS;
    }
};

/**
 * @brief simple addition operation A+B
 **/
class Addition3D: public Operation3D
{

public:
    /**
     * @brief interface for feature computation
     * @param feats features
     * @param x current x position
     * @param y current y position
         * @param z current z position
     * @return double distance
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &z );

    /**
     * @brief clone operation instead of copy constructor (copy constructor does not work)
     **/
    virtual Operation3D* clone()
    {
        Operation3D* o = new Addition3D();
        o->setContext(context);
        return o;
    }

    /**
     * @brief print some infos about operation extraction type
     * @return string feature type
     **/
    virtual std::string writeInfos()
    {
        std::string out = "Addition";

        if ( context )
            out = "(C)" + out;
        else
            out = "(R)" + out;

        return out + "             " + Operation3D::writeInfos();
    }

    /**
     * @brief return operation type (for store and restore)
     * @return OperationTypes
     **/
    virtual OperationTypes getOps()
    {
        if (context)
            return ADDITION_C;
        else
            return ADDITION;
    }
};

/**
 * @brief simple single element access operation
 **/
class Only13D: public Operation3D
{
public:
    /**
     * @brief interface for feature computation
     * @param feats features
     * @param x current x position
     * @param y current y position
         * @param z current z position
     * @return double distance
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &z );

    /**
     * @brief clone operation instead of copy constructor (copy constructor does not work)
     **/
    virtual Operation3D* clone()
    {
        Operation3D* o = new Only13D();
        o->setContext(context);
        return o;
    }

    /**
     * @brief print some infos about operation extraction type
     * @return string feature type
     **/
    virtual std::string writeInfos()
    {
        std::string out = "Only1";

        if ( context )
            out = "(C)" + out;
        else
            out = "(R)" + out;

        return out + "                " + Operation3D::writeInfos();
    }

    /**
     * @brief return operation type (for store and restore)
     * @return OperationTypes
     **/
    virtual OperationTypes getOps()
    {
        if (context)
            return ONLY1_C;
        else
            return ONLY1;
    }
};

/**
 * @brief get current relative x position
 **/
class RelativeXPosition3D: public Operation3D
{
public:
    /**
     * @brief interface for feature computation
     * @param feats features
     * @param x current x position
     * @param y current y position
         * @param z current z position
     * @return double distance
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &z );

    /**
     * @brief clone operation instead of copy constructor (copy constructor does not work)
     **/
    virtual Operation3D* clone()
    {
        Operation3D* o = new RelativeXPosition3D();
        o->setContext(context);
        return o;
    }

    /**
     * @brief print some infos about operation extraction type
     * @return string feature type
     **/
    virtual std::string writeInfos()
    {
        std::string out = "RelXPos";

        if ( context )
            out = "(C)" + out;
        else
            out = "(R)" + out;

        return out + "              " + Operation3D::writeInfos();
    }

    /**
     * @brief return operation type (for store and restore)
     * @return OperationTypes
     **/
    virtual OperationTypes getOps()
    {
        return RELATIVEXPOSITION;
    }
};

/**
 * @brief get current relative y position
 **/
class RelativeYPosition3D: public Operation3D
{
public:
    /**
     * @brief interface for feature computation
     * @param feats features
     * @param x current x position
     * @param y current y position
         * @param z current z position
     * @return double distance
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &z );

    /**
     * @brief clone operation instead of copy constructor (copy constructor does not work)
     **/
    virtual Operation3D* clone()
    {
        Operation3D* o = new RelativeYPosition3D();
        o->setContext(context);
        return o;
    }

    /**
     * @brief print some infos about operation extraction type
     * @return string feature type
     **/
    virtual std::string writeInfos()
    {
        std::string out = "RelYPos";

        if ( context )
            out = "(C)" + out;
        else
            out = "(R)" + out;

        return out + "              " + Operation3D::writeInfos();
    }

    /**
     * @brief return operation type (for store and restore)
     * @return OperationTypes
     **/
    virtual OperationTypes getOps()
    {
        return RELATIVEYPOSITION;
    }
};

/**
 * @brief get current relative z position
 **/
class RelativeZPosition3D: public Operation3D
{
public:
    /**
     * @brief interface for feature computation
     * @param feats features
     * @param x current x position
     * @param y current y position
         * @param z current z position
     * @return double distance
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &z );

    /**
     * @brief clone operation instead of copy constructor (copy constructor does not work)
     **/
    virtual Operation3D* clone()
    {
        Operation3D* o = new RelativeZPosition3D();
        o->setContext(context);
        return o;
    }

    /**
     * @brief print some infos about operation extraction type
     * @return string feature type
     **/
    virtual std::string writeInfos()
    {
        std::string out = "RelZPos";

        if ( context )
            out = "(C)" + out;
        else
            out = "(R)" + out;

        return out + "              " + Operation3D::writeInfos();
    }

    /**
     * @brief return operation type (for store and restore)
     * @return OperationTypes
     **/
    virtual OperationTypes getOps()
    {
        return RELATIVEZPOSITION;
    }
};

/**
 * @brief uses mean in a window given by (x1,y1,z1) (x2,y2,z2)
 **/
class IntegralOps3D: public Operation3D
{
public:
    /**
     * @brief set all parameters
     * @param _x1 position 1
     * @param _y1 position 1
         * @param _z1 position 1
     * @param _x2 position 2
     * @param _y2 position 2
         * @param _z2 position 2
     * @param _channel1 channel 1
     * @param _channel2 channel 2
     * @param _ftype feature type
     * @return void nothing
     **/
    virtual void set ( int _x1, int _y1, int _z1, int _x2, int _y2, int _z2, int _channel1, int _channel2, int _ftype );

    /**
     * @brief interface for feature computation
     * @param feats features
     * @param x current x position
     * @param y current y position
         * @param z current z position
     * @return double distance
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &z );

    /**
     * @brief clone operation instead of copy constructor (copy constructor does not work)
     **/
    virtual Operation3D* clone()
    {
        Operation3D* o = new IntegralOps3D();
        o->setContext(context);
        return o;
    }

    /**
     * @brief print some infos about operation extraction type
     * @return string feature type
     **/
    virtual std::string writeInfos()
    {
        std::string out = "IntegralOps";

        if ( context )
            out = "(C)" + out;
        else
            out = "(R)" + out;

        return out + "          " + Operation3D::writeInfos();
    }

    /**
     * @brief return operation type (for store and restore)
     * @return OperationTypes
     **/
    virtual OperationTypes getOps()
    {
        if (context)
            return INTEGRAL_C;
        else
            return INTEGRAL;
    }
};

/**
 * @brief uses mean in a window given by (x1,y1,z1) (x2,y2,z2) and full window
 **/
class BiIntegralOps3D: public IntegralOps3D
{
public:
    /**
     * @brief interface for feature computation
     * @param feats features
     * @param x current x position
     * @param y current y position
     * @param z current z position
     * @return double distance
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &z );

    /**
     * @brief clone operation instead of copy constructor (copy constructor does not work)
     **/
    virtual Operation3D* clone()
    {
        Operation3D* o = new BiIntegralOps3D();
        o->setContext(context);
        return o;
    }

    /**
     * @brief print some infos about operation extraction type
     * @return string feature type
     **/
    virtual std::string writeInfos()
    {
        std::string out = "BiIntegralOps";

        if ( context )
            out = "(C)" + out;
        else
            out = "(R)" + out;

        return out + "    " + Operation3D::writeInfos();
    }

    /**
     * @brief return operation type (for store and restore)
     * @return OperationTypes
     **/
    virtual OperationTypes getOps()
    {
        if (context)
            return BIINTEGRAL_C;
        else
            return BIINTEGRAL;
    }

};

/**
 * @brief like a global bag of words to model the current appearance of classes in an image without local context
 **/
class GlobalFeats3D: public IntegralOps3D
{

public:
    /**
     * @brief interface for feature computation
     * @param feats features
     * @param x current x position
     * @param y current y position
         * @param z current z position
     * @return double distance
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &z );

    /**
     * @brief clone operation instead of copy constructor (copy constructor does not work)
     **/
    virtual Operation3D* clone()
    {
        Operation3D* o = new GlobalFeats3D();
        o->setContext(context);
        return o;
    }

    /**
     * @brief print some infos about operation extraction type
     * @return string feature type
     **/
    virtual std::string writeInfos()
    {
        std::string out = "GlobalFeats";

        if ( context )
            out = "(C)" + out;
        else
            out = "(R)" + out;

        return out + "          " + Operation3D::writeInfos();
    }

    /**
     * @brief return operation type (for store and restore)
     * @return OperationTypes
     **/
    virtual OperationTypes getOps()
    {
        if ( context )
            return GLOBALFEATS_C;
        else
            return GLOBALFEATS;
    }
};

/**
 * @brief uses mean of Integral image given by x1, y1, z1 with current pixel as center
 **/
class IntegralCenteredOps3D: public IntegralOps3D
{
public:
    /**
     * @brief set all parameters
     * @param _x1 position 1
     * @param _y1 position 1
         * @param _z1 position 1
     * @param _x2 position 2
     * @param _y2 position 2
         * @param _z2 position 2
     * @param _channel1 channel 1
     * @param _channel2 channel 2
     * @param _ftype feature type
     * @return void nothing
     **/
    virtual void set ( int _x1, int _y1, int _z1, int _x2, int _y2, int _z2, int _channel1, int _channel2, int _ftype );

    /**
     * @brief interface for feature computation
     * @param feats features
     * @param x current x position
     * @param y current y position
         * @param z current z position
     * @return double distance
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &z );

    /**
     * @brief clone operation instead of copy constructor (copy constructor does not work)
     **/
    virtual Operation3D* clone()
    {
        Operation3D* o = new IntegralCenteredOps3D();
        o->setContext(context);
        return o;
    }

    /**
     * @brief print some infos about operation extraction type
     * @return string feature type
     **/
    virtual std::string writeInfos()
    {
        std::string out = "IntegralCenteredOps";

        if ( context )
            out = "(C)" + out;
        else
            out = "(R)" + out;

        return out + "  " + Operation3D::writeInfos();
    }

    /**
     * @brief return operation type (for store and restore)
     * @return OperationTypes
     **/
    virtual OperationTypes getOps()
    {
        if ( context )
            return INTEGRALCENT_C;
        else
            return INTEGRALCENT;
    }
};

/**
 * @brief uses different of mean of Integral image given by two windows, where (x1,y1,z1) is the width, height & depth of window1 and (x2,y2,z2) of window 2
 **/
class BiIntegralCenteredOps3D: public IntegralCenteredOps3D
{
public:
    /**
     * @brief set all parameters
     * @param _x1 position 1
     * @param _y1 position 1
         * @param _z1 position 1
     * @param _x2 position 2
     * @param _y2 position 2
         * @param _z2 position 2
     * @param _channel1 channel 1
     * @param _channel2 channel 2
     * @param _ftype feature type
     * @return void nothing
     **/
    virtual void set ( int _x1, int _y1, int _z1, int _x2, int _y2, int _z2, int _channel1, int _channel2, int ftype );

    /**
     * @brief interface for feature computation
     * @param feats features
     * @param x current x position
     * @param y current y position
         * @param z current z position
     * @return double distance
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &z );

    /**
     * @brief clone operation instead of copy constructor (copy constructor does not work)
     **/
    virtual Operation3D* clone()
    {
        Operation3D* o = new BiIntegralCenteredOps3D();
        o->setContext(context);
        return o;
    }

    /**
     * @brief print some infos about operation extraction type
     * @return string feature type
     **/
    virtual std::string writeInfos()
    {
        std::string out = "BiIntegralCenteredOps";

        if ( context )
            out = "(C)" + out;
        else
            out = "(R)" + out;

        return out + Operation3D::writeInfos();
    }

    /**
     * @brief return operation type (for store and restore)
     * @return OperationTypes
     **/
    virtual OperationTypes getOps()
    {
        if ( context )
            return BIINTEGRALCENT_C;
        else
            return BIINTEGRALCENT;
    }
};

/**
 * @brief horizontal Haar features
 * ++
 * --
 **/
class HaarHorizontal3D: public IntegralCenteredOps3D
{
public:
    /**
     * @brief interface for feature computation
     * @param feats features
     * @param x current x position
     * @param y current y position
         * @param z current z position
     * @return double distance
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &z );

    /**
     * @brief clone operation instead of copy constructor (copy constructor does not work)
     **/
    virtual Operation3D* clone()
    {
        Operation3D* o = new HaarHorizontal3D();
        o->setContext(context);
        return o;
    }

    /**
     * @brief print some infos about operation extraction type
     * @return string feature type
     **/
    virtual std::string writeInfos()
    {
        std::string out = "HaarHorizontal";

        if ( context )
            out = "(C)" + out;
        else
            out = "(R)" + out;

        return out + "       " + Operation3D::writeInfos();
    }

    /**
     * @brief return operation type (for store and restore)
     * @return OperationTypes
     **/
    virtual OperationTypes getOps()
    {
        if ( context )
            return HAARHORIZ_C;
        else
            return HAARHORIZ;
    }
};

/**
 * @brief vertical Haar features
 * +-
 * +-
 **/
class HaarVertical3D: public IntegralCenteredOps3D
{
public:
    /**
     * @brief interface for feature computation
     * @param feats features
     * @param x current x position
     * @param y current y position
         * @param z current z position
     * @return double distance
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &z );

    /**
     * @brief clone operation instead of copy constructor (copy constructor does not work)
     **/
    virtual Operation3D* clone()
    {
        Operation3D* o = new HaarVertical3D();
        o->setContext(context);
        return o;
    }

    /**
     * @brief print some infos about operation extraction type
     * @return string feature type
     **/
    virtual std::string writeInfos()
    {
        std::string out = "HaarVertical";

        if ( context )
            out = "(C)" + out;
        else
            out = "(R)" + out;

        return out + "         " + Operation3D::writeInfos();
    }

    /**
     * @brief return operation type (for store and restore)
     * @return OperationTypes
     **/
    virtual OperationTypes getOps()
    {
        if ( context )
            return HAARVERT_C;
        else
            return HAARVERT;
    }
};

/**
 * @brief stacked (depth) Haar features
 * +-
 * +-
 **/
class HaarStacked3D: public IntegralCenteredOps3D
{
public:
    /**
     * @brief interface for feature computation
     * @param feats features
     * @param x current x position
     * @param y current y position
         * @param z current z position
     * @return double distance
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &z );

    /**
     * @brief clone operation instead of copy constructor (copy constructor does not work)
     **/
    virtual Operation3D* clone()
    {
        Operation3D* o = new HaarStacked3D();
        o->setContext(context);
        return o;
    }

    /**
     * @brief print some infos about operation extraction type
     * @return string feature type
     **/
    virtual std::string writeInfos()
    {
        std::string out = "HaarStacked";

        if ( context )
            out = "(C)" + out;
        else
            out = "(R)" + out;

        return out + "          " + Operation3D::writeInfos();
    }

    /**
     * @brief return operation type (for store and restore)
     * @return OperationTypes
     **/
    virtual OperationTypes getOps()
    {
        if ( context )
            return HAARSTACK_C;
        else
            return HAARSTACK;
    }
};

/**
 * @brief x-y diagonal Haar features
 * +-
 * -+
 **/
class HaarDiagXY3D: public IntegralCenteredOps3D
{
public:
    /**
     * @brief interface for feature computation
     * @param feats features
     * @param x current x position
     * @param y current y position
         * @param z current z position
     * @return double distance
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &z );

    /**
     * @brief clone operation instead of copy constructor (copy constructor does not work)
     **/
    virtual Operation3D* clone()
    {
        Operation3D* o = new HaarDiagXY3D();
        o->setContext(context);
        return o;
    }

    /**
     * @brief print some infos about operation extraction type
     * @return string feature type
     **/
    virtual std::string writeInfos()
    {
        std::string out = "HaarDiagXY";

        if ( context )
            out = "(C)" + out;
        else
            out = "(R)" + out;

        return out + "           " + Operation3D::writeInfos();
    }

    /**
     * @brief return operation type (for store and restore)
     * @return OperationTypes
     **/
    virtual OperationTypes getOps()
    {
        if ( context )
            return HAARDIAGXY_C;
        else
            return HAARDIAGXY;
    }
};

/**
 * @brief x-z diagonal Haar features
 * +-
 * -+
 **/
class HaarDiagXZ3D: public IntegralCenteredOps3D
{
public:
    /**
     * @brief interface for feature computation
     * @param feats features
     * @param x current x position
     * @param y current y position
         * @param z current z position
     * @return double distance
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &z );

    /**
     * @brief clone operation instead of copy constructor (copy constructor does not work)
     **/
    virtual Operation3D* clone()
    {
        Operation3D* o = new HaarDiagXZ3D();
        o->setContext(context);
        return o;
    }

    /**
     * @brief print some infos about operation extraction type
     * @return string feature type
     **/
    virtual std::string writeInfos()
    {
        std::string out = "HaarDiagXZ";

        if ( context )
            out = "(C)" + out;
        else
            out = "(R)" + out;

        return out + "           " + Operation3D::writeInfos();
    }

    /**
     * @brief return operation type (for store and restore)
     * @return OperationTypes
     **/
    virtual OperationTypes getOps()
    {
        if ( context )
            return HAARDIAGXZ_C;
        else
            return HAARDIAGXZ;
    }
};

/**
 * @brief y-z diagonal Haar features
 * +-
 * -+
 **/
class HaarDiagYZ3D: public IntegralCenteredOps3D
{
public:
    /**
     * @brief interface for feature computation
     * @param feats features
     * @param x current x position
     * @param y current y position
         * @param z current z position
     * @return double distance
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &z );

    /**
     * @brief clone operation instead of copy constructor (copy constructor does not work)
     **/
    virtual Operation3D* clone()
    {
        Operation3D* o = new HaarDiagYZ3D();
        o->setContext(context);
        return o;
    }

    /**
     * @brief print some infos about operation extraction type
     * @return string feature type
     **/
    virtual std::string writeInfos()
    {
        std::string out = "HaarDiagYZ";

        if ( context )
            out = "(C)" + out;
        else
            out = "(R)" + out;

        return out + "           " + Operation3D::writeInfos();
    }

    /**
     * @brief return operation type (for store and restore)
     * @return OperationTypes
     **/
    virtual OperationTypes getOps()
    {
        if ( context )
            return HAARDIAGYZ_C;
        else
            return HAARDIAGYZ;
    }
};

/**
 * @brief horizontal Haar features
 * +++
 * ---
 * +++
 */

class Haar3Horiz3D: public BiIntegralCenteredOps3D
{
public:
    /**
     * @brief interface for feature computation
     * @param feats features
     * @param x current x position
     * @param y current y position
         * @param z current z position
     * @return double distance
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &z );

    /**
     * @brief clone operation instead of copy constructor (copy constructor does not work)
     **/
    virtual Operation3D* clone()
    {
        Operation3D* o = new Haar3Horiz3D();
        o->setContext(context);
        return o;
    }

    /**
     * @brief print some infos about operation extraction type
     * @return string feature type
     **/
    virtual std::string writeInfos()
    {
        std::string out = "Haar3Horiz";

        if ( context )
            out = "(C)" + out;
        else
            out = "(R)" + out;

        return out + "           " + Operation3D::writeInfos();
    }

    /**
     * @brief return operation type (for store and restore)
     * @return OperationTypes
     **/
    virtual OperationTypes getOps()
    {
        if ( context )
            return HAAR3HORIZ_C;
        else
            return HAAR3HORIZ;
    }
};

/**
 * @brief vertical Haar features
 * +-+
 * +-+
 * +-+
 */
class Haar3Vert3D: public BiIntegralCenteredOps3D
{
public:
    /**
     * @brief interface for feature computation
     * @param feats features
     * @param x current x position
     * @param y current y position
         * @param z current z position
     * @return double distance
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &z );

    /**
     * @brief clone operation instead of copy constructor (copy constructor does not work)
     **/
    virtual Operation3D* clone()
    {
        Operation3D* o = new Haar3Vert3D();
        o->setContext(context);
        return o;
    }

    /**
     * @brief print some infos about operation extraction type
     * @return string feature type
     **/
    virtual std::string writeInfos()
    {
        std::string out = "Haar3Vert";

        if ( context )
            out = "(C)" + out;
        else
            out = "(R)" + out;

        return out + "            " + Operation3D::writeInfos();
    }

    /**
     * @brief return operation type (for store and restore)
     * @return OperationTypes
     **/
    virtual OperationTypes getOps()
    {
        if ( context )
            return HAAR3VERT_C;
        else
            return HAAR3VERT;
    }
};

/**
 * @brief stacked Haar features
 * +-+
 * +-+
 * +-+
 */
class Haar3Stack3D: public BiIntegralCenteredOps3D
{
public:
    /**
     * @brief interface for feature computation
     * @param feats features
     * @param x current x position
     * @param y current y position
         * @param z current z position
     * @return double distance
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &z );

    /**
     * @brief clone operation instead of copy constructor (copy constructor does not work)
     **/
    virtual Operation3D* clone()
    {
        Operation3D* o = new Haar3Stack3D();
        o->setContext(context);
        return o;
    }

    /**
     * @brief print some infos about operation extraction type
     * @return string feature type
     **/
    virtual std::string writeInfos()
    {
        std::string out = "Haar3Stack";

        if ( context )
            out = "(C)" + out;
        else
            out = "(R)" + out;

        return out + "           " + Operation3D::writeInfos();
    }

    /**
     * @brief return operation type (for store and restore)
     * @return OperationTypes
     **/
    virtual OperationTypes getOps()
    {
        if ( context )
            return HAAR3STACK_C;
        else
            return HAAR3STACK;
    }
};

} //end namespace