NICE_SemSeg/semseg/SemSegContextTree.h

/**
* @file SemSegContextTree.h
* @brief Context Trees -> Combination of decision tree and context information
* @author Björn Fröhlich
* @date 29.11.2011

*/
#ifndef SemSegContextTreeINCLUDE
#define SemSegContextTreeINCLUDE

#include "SemanticSegmentation.h"
#include <core/vector/VVector.h>
#include "vislearning/features/localfeatures/LFColorWeijer.h"
#include "objrec/segmentation/RegionSegmentationMethod.h"

namespace OBJREC {

class Operation;

class TreeNode
{

public:
  /** probabilities for each class */
  std::vector<double> probs;

  /** 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;

  /** 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 ) {}
};

struct Features {
  NICE::MultiChannelImageT<double> *feats;
  MultiChannelImageT<int> *cfeats;
  int cTree;
  std::vector<TreeNode> *tree;
  NICE::MultiChannelImageT<double> *integralImg;
};

class ValueAccess
{

public:
  virtual double getVal( const Features &feats, const int &x, const int &y, const int &channel ) = 0;
  virtual std::string writeInfos() = 0;
};

enum OperationTypes {
  MINUS,
  MINUSABS,
  ADDITION,
  ONLY1,
  INTEGRAL,
  INTEGRALCENT,
  BIINTEGRALCENT,
  HAARHORIZ,
  HAARVERT,
  HAARDIAG,
  HAAR3HORIZ,
  HAAR3VERT,
  RELATIVEXPOSITION,
  RELATIVEYPOSITION,
  GLOBALFEATS,
  NBOPERATIONS
};

class Operation
{

protected:
  int x1, y1, x2, y2, channel1, channel2;
  ValueAccess *values;

public:

  Operation()
  {
    values = NULL;
  }

  virtual void set( int _x1, int _y1, int _x2, int _y2, int _channel1, int _channel2, ValueAccess *_values )
  {
    x1 = _x1;
    y1 = _y1;
    x2 = _x2;
    y2 = _y2;
    channel1 = _channel1;
    channel2 = _channel2;
    values = _values;
  }

  /**
   * @brief abstract interface for feature computation
   * @param feats features
   * @param cfeats number of tree node for each pixel
   * @param tree current tree
   * @param x current x position
   * @param y current y position
   * @return double distance
   **/
  virtual double getVal( const Features &feats, const int &x, const int &y ) = 0;
  virtual Operation* clone() = 0;
  virtual std::string writeInfos() = 0;

  inline void getXY( const Features &feats, int &xsize, int &ysize )
  {
    xsize = feats.feats->width();
    ysize = feats.feats->height();
  }

  virtual OperationTypes getOps() = 0;
};

/** Localization system */

class SemSegContextTree : public SemanticSegmentation
{
  /** Segmentation Method */
  RegionSegmentationMethod *segmentation;

  /** tree -> saved as vector of nodes */
  std::vector<std::vector<TreeNode> > forest;

  /** local features */
  LFColorWeijer *lfcw;

  /** number of featuretype -> currently: local and context features = 2 */
  int ftypes;

  /** distance between features */
  int grid;

  /** maximum samples for tree  */
  int maxSamples;

  /** size for neighbourhood */
  int windowSize;

  /** how many feats should be considered for a split */
  int featsPerSplit;

  /** count samples per label */
  std::map<int, int> labelcounter;

  /** map of labels */
  std::map<int, int> labelmap;

  /** map of labels inverse*/
  std::map<int, int> labelmapback;

  /** scalefactor for balancing for each class */
  std::vector<double> a;

  /** counter for used operations */
  std::vector<int> opOverview;

  /** the minimum number of features allowed in a leaf */
  int minFeats;

  /** maximal depth of tree */
  int maxDepth;

  /** operations for pairwise features */
  std::vector<Operation*> ops;

  /** operations for pairwise context features */
  std::vector<Operation*> cops;

  std::vector<ValueAccess*> calcVal;

  /** vector of all possible features */
  std::vector<Operation*> featsel;

  /** use alternative calculation for information gain */
  bool useShannonEntropy;

  /** Classnames */
  ClassNames classnames;

  /** train selection */
  std::set<int> forbidden_classes;

  /** Configfile */
  const Config *conf;

  /** use pixelwise labeling or regionlabeling with additional segmenation */
  bool pixelWiseLabeling;

  /** use Gaussian distributed features based on the feature position */
  bool useGaussian;

  /** Number of trees used for the forest */
  int nbTrees;

public:
  /** simple constructor */
  SemSegContextTree( const NICE::Config *conf, const MultiDataset *md );

  /** simple destructor */
  virtual ~SemSegContextTree();

  /**
   * test a single image
   * @param ce input data
   * @param segresult segmentation results
   * @param probabilities probabilities for each pixel
   */
  void semanticseg( CachedExample *ce,   NICE::Image & segresult,  NICE::MultiChannelImageT<double> & probabilities );

  /**
   * the main training method
   * @param md training data
   */
  void train( const MultiDataset *md );


  /**
   * @brief computes integral image of given feats
   *
   * @param currentfeats input features
   * @param integralImage output image (must be initilized)
   * @return void
   **/
  void computeIntegralImage( const NICE::MultiChannelImageT<int> &currentfeats, const NICE::MultiChannelImageT<double> &lfeats, NICE::MultiChannelImageT<double> &integralImage );

  /**
   * compute best split for current settings
   * @param feats features
   * @param currentfeats matrix with current node for each feature
   * @param labels labels for each feature
   * @param node current node
   * @param splitfeat output feature position
   * @param splitval
   * @return best information gain
   */
  double getBestSplit( std::vector<NICE::MultiChannelImageT<double> > &feats, std::vector<NICE::MultiChannelImageT<int> > &currentfeats, std::vector<NICE::MultiChannelImageT<double> > &integralImgs, const std::vector<NICE::MatrixT<int> > &labels, int node, Operation *&splitop, double &splitval, const int &tree );

  /**
   * @brief computes the mean probability for a given class over all trees
   * @param x x position
   * @param y y position
   * @param channel current class
   * @param currentfeats information about the nodes
   * @return double mean value
   **/
  inline double getMeanProb( const int &x, const int &y, const int &channel, const MultiChannelImageT<int> &currentfeats );

};


} // namespace

#endif