NICE_SemSeg/semseg/operations/Operations.h

/**
* @file Operation.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 Operation;

/**
 * @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,
  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 */
    Operation *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, Operation *_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;

  /** node index for each pixel (width,height,depth) in each tree (channel) */
  NICE::MultiChannelImage3DT<unsigned short int> *nIndices;

  /** current tree index */
  int cTree;

  /** current tree (all nodes) */
  std::vector<TreeNode> *tree;
  
  /** probabilities for each region */
  std::vector<std::vector<double> > *rProbs;
};

#if 0
/**
 * @brief abstract values access class
 **/
class ValueAccess
{
  public:
    /**
     * @brief extract value on specific position x,y and channel;
     *
     * @param feats see struct Features
     * @param x position of feature
     * @param y position of feature
		 * @param z position of feature
     * @param channel position of feature
     * @return double value
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &z, const int &channel ) = 0;

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

    /**
     * @brief get feature type
     *
     * @return feature type
     **/
    virtual ValueTypes getType() = 0;
};

/**
 * @brief simple MultiChannelImageT access
 **/
class MCImageAccess: public ValueAccess
{

  public:
    /**
     * @brief extract value on specific position x,y,z and channel;
     *
     * @param feats see struct Features
     * @param x position of feature
     * @param y position of feature
		 * @param z position of feature
     * @param channel position of feature
     * @return double value
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &z, const int &channel )
    {
      return feats.feats->get ( x, y, z, channel );
    }

    /**
     * @brief print some infos about feature type
     *
     * @return string feature type
     **/
    virtual std::string writeInfos()
    {
      return "raw";
    }

    /**
     * @brief get feature type
     *
     * @return feature type
     **/
    virtual ValueTypes getType()
    {
      return RAWFEAT;
    }
};

class ClassificationResultAccess: public ValueAccess
{
  public:
    /**
     * @brief extract value on specific position x,y,z and channel;
     *
     * @param feats see struct Features
     * @param x position of feature
     * @param y position of feature
		 * @param z position of feature
     * @param channel position of feature
     * @return double value
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &z, const int &channel )
    {
      return ( *feats.tree ) [feats.nIndices->get ( x,y,z,feats.cTree ) ].dist[channel];
    }

    /**
     * @brief print some infos about feature type
     *
     * @return string feature type
     **/
    virtual std::string writeInfos()
    {
      return "context";
    }

    /**
     * @brief get feature type
     *
     * @return feature type
     **/
    virtual ValueTypes getType()
    {
      return CONTEXT;
    }
};


/**
 * @brief not finished yet, do we really need sparse feature representation or ClassificationResultAccess sufficient
 **/
class SparseImageAccess: public ValueAccess
{
  private:
    double scale;

  public:
    /**
     * @brief extract value on specific position x,y and channel;
     *
     * @param feats see struct Features
     * @param x position of feature
     * @param y position of feature
     * @param channel position of feature
     * @return double value
     **/
    virtual double getVal ( const Features &feats, const int &x, const int &y, const int &channel )
    {
      //MultiChannelImageT<SparseVectorInt> textonMap;
      //TODO: implement access
      return -1.0;
    }

    /**
     * @brief print some infos about feature type
     *
     * @return string feature type
     **/
    virtual std::string writeInfos()
    {
      return "context";
    }

    /**
     * @brief get feature type
     *
     * @return feature type
     **/
    virtual ValueTypes getType()
    {
      return CONTEXT;
    }
};
#endif

/**
 * @brief abstract operation class
 **/
class Operation
{
  protected:
    /** two different points (e.g. for an rectangle or two positions), channels and size  */
    int x1, y1, z1, x2, y2, z2, channel1, channel2, maxtypes;
    
    /** type of feature */
    int featType;
    
    bool init;

    bool context;

  public:

    /** simple constructor */
    Operation();

    /**
     * @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 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 type of feature
     * @param _featType type of feature
     * @return void nothing
     **/
    void setFeatType ( int _featType );

    /**
     * @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 Operation* 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 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 RegionFeat: public Operation
{
  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 Operation* clone()
    {
      return new RegionFeat();
    }

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

      if (init)
      {
        if ( featType == 4 )
          out += "context";
        else
          out += "raw";
      }
      return out + Operation::writeInfos();
    }

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

/**
 * @brief simple difference operation A-B
 **/
class Minus: public Operation
{
  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 Operation* clone()
    {
      return new Minus();
    }

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

      if (init)
      {
        if ( featType == 4 )
          out += "context";
        else
          out += "raw";
      }
      return out + Operation::writeInfos();
    }

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

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

  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 Operation* clone()
    {
      return new MinusAbs();
    }

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

      if (init)
      {
        if ( featType == 4 )
          out += "context";
        else
          out += "raw";
      }
      return out;
    }

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

/**
 * @brief simple addition operation A+B
 **/
class Addition: public Operation
{

  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 Operation* clone()
    {
      return new Addition();
    }

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

      if (init)
      {
        if ( featType == 4 )
          out += "context";
        else
          out += "raw";
      }
      return out + Operation::writeInfos();
    }

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

/**
 * @brief simple single element access operation
 **/
class Only1: public Operation
{
  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 Operation* clone()
    {
      return new Only1();
    }

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

      if (init)
      {
        if ( featType == 4 )
          out += "context";
        else
          out += "raw";
      }
      return out + Operation::writeInfos();
    }

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

/**
 * @brief get current relative x position
 **/
class RelativeXPosition: public Operation
{
  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 Operation* clone()
    {
      return new RelativeXPosition();
    }

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

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

/**
 * @brief get current relative y position
 **/
class RelativeYPosition: public Operation
{
  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 Operation* clone()
    {
      return new RelativeYPosition();
    }

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

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

/**
 * @brief get current relative z position
 **/
class RelativeZPosition: public Operation
{
  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 Operation* clone()
    {
      return new RelativeZPosition();
    }

    /**
     * @brief print some infos about operation extraction type
     * @return string feature type
     **/
    virtual std::string writeInfos()
    {
      return "RelativeZPosition" + Operation::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 IntegralOps: public Operation
{
  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 Operation* clone()
    {
      return new IntegralOps();
    }

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

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


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

  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 Operation* clone()
    {
      return new GlobalFeats();
    }

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

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

/**
 * @brief uses mean of Integral image given by x1, y1, z1 with current pixel as center
 **/
class IntegralCenteredOps: public IntegralOps
{
  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 Operation* clone()
    {
      return new IntegralCenteredOps();
    }

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

    /**
     * @brief return operation type (for store and restore)
     * @return OperationTypes
     **/
    virtual OperationTypes getOps()
    {
      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 BiIntegralCenteredOps: public IntegralCenteredOps
{
  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 Operation* clone()
    {
      return new BiIntegralCenteredOps();
    }

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

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

/**
 * @brief horizontal Haar features
 * ++
 * --
 **/
class HaarHorizontal: public IntegralCenteredOps
{
  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 Operation* clone()
    {
      return new HaarHorizontal();
    }

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

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

/**
 * @brief vertical Haar features
 * +-
 * +-
 **/
class HaarVertical: public IntegralCenteredOps
{
  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 Operation* clone()
    {
      return new HaarVertical();
    }

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

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

/**
 * @brief stacked (depth) Haar features
 * +-
 * +-
 **/
class HaarStacked: public IntegralCenteredOps
{
  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 Operation* clone()
    {
      return new HaarStacked();
    }

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

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

/**
 * @brief x-y diagonal Haar features
 * +-
 * -+
 **/
class HaarDiagXY: public IntegralCenteredOps
{
  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 Operation* clone()
    {
      return new HaarDiagXY();
    }

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

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

/**
 * @brief x-z diagonal Haar features
 * +-
 * -+
 **/
class HaarDiagXZ: public IntegralCenteredOps
{
  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 Operation* clone()
    {
      return new HaarDiagXZ();
    }

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

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

/**
 * @brief y-z diagonal Haar features
 * +-
 * -+
 **/
class HaarDiagYZ: public IntegralCenteredOps
{
  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 Operation* clone()
    {
      return new HaarDiagYZ();
    }

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

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

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

class Haar3Horiz: public BiIntegralCenteredOps
{
  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 Operation* clone()
    {
      return new Haar3Horiz();
    }

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

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

/**
 * @brief vertical Haar features
 * +-+
 * +-+
 * +-+
 */
class Haar3Vert: public BiIntegralCenteredOps
{
  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 Operation* clone()
    {
      return new Haar3Vert();
    }

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

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

/**
 * @brief stacked Haar features
 * +-+
 * +-+
 * +-+
 */
class Haar3Stack: public BiIntegralCenteredOps
{
  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 Operation* clone()
    {
      return new Haar3Stack();
    }

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

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

} //end namespace