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,
  RAYDIFF,
  RAYDIST,
  RAYTHETA,
  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,
  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;
};



/**
 * @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;
    
    /** 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 _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 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()
    {
      return "(-)RegionFeat           " + 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 ( context )
        out = "(C)" + out;
      else
        out = "(R)" + out;

      return out + "                " +Operation::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 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 ( context )
          out = "(C)" + out;
        else
          out = "(R)" + out;

      return out + "             " + Operation::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 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 ( context )
          out = "(C)" + out;
        else
          out = "(R)" + out;

      return out + "             " + Operation::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 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 ( context )
          out = "(C)" + out;
        else
          out = "(R)" + out;

      return out + "                " + Operation::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 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()
    {
      std::string out = "RelXPos";

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

      return out + "              " + 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()
    {
      std::string out = "RelYPos";

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

      return out + "              " + 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()
    {
      std::string out = "RelZPos";

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

      return out + "              " + 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()
    {
      std::string out = "IntegralOps";

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

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

    /**
     * @brief return operation type (for store and restore)
     * @return OperationTypes
     **/
    virtual OperationTypes getOps()
    {
      if (context)
        return INTEGRAL_C;
      else
        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()
    {
      std::string out = "GlobalFeats";

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

      return out + "          " + Operation::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 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()
    {
      std::string out = "IntegralCenteredOps";

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

      return out + "  " + Operation::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 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()
    {
      std::string out = "BiIntegralCenteredOps";

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

      return out + Operation::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 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()
    {
      std::string out = "HaarHorizontal";

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

      return out + "       " + Operation::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 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()
    {
      std::string out = "HaarVertical";

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

      return out + "         " + Operation::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 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()
    {
      std::string out = "HaarStacked";

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

      return out + "          " + Operation::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 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()
    {
      std::string out = "HaarDiagXY";

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

      return out + "           " + Operation::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 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()
    {
      std::string out = "HaarDiagXZ";

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

      return out + "           " + Operation::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 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()
    {
      std::string out = "HaarDiagYZ";

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

      return out + "           " + Operation::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 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()
    {
      std::string out = "Haar3Horiz";

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

      return out + "           " + Operation::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 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()
    {
      std::string out = "Haar3Vert";

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

      return out + "            " + Operation::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 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()
    {
      std::string out = "Haar3Stack";

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

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

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

/**
 * @brief Ray features
 */
/**
 * @brief Ray Distance-Difference features
 */
class RayDiff: 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 RayDiff();
    }

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

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

/**
 * @brief Ray Distance features
 */
class RayDist: 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 RayDist();
    }

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

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

/**
 * @brief Ray Orientation features
 */
class RayTheta: 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 RayTheta();
    }

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

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

/**
 * @brief Ray Norm features
 */
class RayNorm: 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 RayNorm();
    }

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

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

} //end namespace