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 <objrec/math/mathbase/VVector.h>
#include "objrec/features/localfeatures/LFColorWeijer.h"

namespace OBJREC {

class Operation
{
protected:
	int x1, y1, x2, y2, channel1, channel2;
public:
	void set(int _x1, int _y1, int _x2, int _y2, int _channel1, int _channel2)
	{
		x1 = _x1;
		y1 = _y1;
		x2 = _x2;
		y2 = _y2;
		channel1 = _channel1;
		channel2 = _channel2;
	}
	virtual double getVal(const vector<vector<vector<double> > > &feats, const int &x, const int &y) = 0;
	virtual Operation* clone() = 0;
};
  
/** Localization system */
class SemSegContextTree : public SemanticSegmentation
{
    protected:
 
	class Node
	{
	public:
		/** probabilities for each class */
		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 */
		vector<double> dist;
		
		/** depth of the node in the tree */
		int depth;
		
		/** simple constructor */
		Node():left(-1),right(-1),feat(NULL), decision(-1.0), isleaf(false){}
		
		/** standard constructor */
		Node(int _left, int _right, Operation *_feat, double _decision):left(_left),right(_right),feat(_feat), decision(_decision),isleaf(false){}
	};
	
	/** store features */
	VVector currentfeats;
	
	/** store the positions of the features */
	VVector positions;
	
	/** tree -> saved as vector of nodes */
	vector<Node> tree;
	
	/** local features */
	LFColorWeijer *lfcw;
	
	/** 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 */
	map<int,int> labelcounter;
	
	/** map of labels */
	map<int,int> labelmap;
	
	/** map of labels inverse*/
	map<int,int> labelmapback;
	
	/** scalefactor for balancing for each class */
	vector<double> a;
	
	/** the minimum number of features allowed in a leaf */
	int minFeats;
	
	/** maximal depth of tree */
	int maxDepth;
	
	/** operations for pairwise features */
	vector<Operation*> ops;
	
	/** vector of all possible features */
	vector<Operation*> featsel;
	
	/** use alternative calculation for information gain */
	bool useShannonEntropy;
	
	/** Classnames */
	ClassNames classnames;

	/** train selection */
	set<int> forbidden_classes;
	
	/** Configfile */
	const Config *conf;

	
    public:
	/** simple constructor */
	SemSegContextTree( const 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 );
	
	/**
	 * 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 
	 */
	void getBestSplit(const vector<vector<vector<vector<double> > > > &feats, vector<vector<vector<int> > > &currentfeats,const vector<vector<vector<int> > > &labels, int node, Operation *&splitfeat, double &splitval);

};


} // namespace

#endif