/** * @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 #include #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, LOCALMEAN, EQUALITY, LOCALSTATMOM, UNUSED0, UNUSED1, UNUSED2, 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, LOCALMEAN_C, BIINTEGRAL, BIINTEGRAL_C, LOCALSTATMOM_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 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 (_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 *feats; /** probabilities for each region */ std::vector > *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 mean of feature values in neighborhood window **/ class LocalMean3D: 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 LocalMean3D(); o->setContext(context); return o; } /** * @brief print some infos about operation extraction type * @return string feature type **/ virtual std::string writeInfos() { std::string out = "LocalMean"; 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 LOCALMEAN_C; else return LOCALMEAN; } }; /** * @brief variance of feature values in neighborhood window **/ class LocalStatMom3D: 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 LocalStatMom3D(); o->setContext(context); return o; } /** * @brief print some infos about operation extraction type * @return string feature type **/ virtual std::string writeInfos() { std::string out = "LocalStatMom"; 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 LOCALSTATMOM_C; else return LOCALSTATMOM; } }; /** * @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