Merge branch 'master' of /home/dbv/git/nice.git/vislearning

cbaselib/ClassificationResults.cpp

@@ -102,3 +102,18 @@ double ClassificationResults::getAverageRecognitionRate() const
   confusion.normalizeColumnsL1();
   return confusion.trace()/confusion.rows();  
 }
+
+double ClassificationResults::getOverallRecognitionRate() const
+{
+  const_iterator i = begin();
+  NICE::Matrix confusion ( i->scores.size(),i->scores.size(),0.0 );
+
+  for ( ; i != end(); i++ )
+  {
+    const ClassificationResult & r = *i;
+    uint classno_estimated = r.classno;
+    uint classno_groundtruth = r.classno_groundtruth;
+    confusion( classno_estimated, classno_groundtruth ) += 1;
+  }
+  return confusion.trace()/size();  
+}

cbaselib/ClassificationResults.h

@@ -54,6 +54,9 @@ class ClassificationResults : public std::vector<ClassificationResult>
         
         /** return average recognition rate, useful for  multi-class problems */
         double getAverageRecognitionRate() const;
+        
+        /** return overall recognition rate, useful for  multi-class problems */
+        double getOverallRecognitionRate() const;        
 };
 
 

cbaselib/LabeledSet.cpp

@@ -468,4 +468,26 @@ void LabeledSetVector::getFlatRepresentation ( VVector & vecSet, NICE::Vector &
 
 }
 
+void LabeledSetVector::removePointersToDataWithoutDeletion()
+{
+  //remove pointers in the order-struct if needed
+  if ( ! this->selection ) {
+    for ( Permutation::iterator i  = this->insertOrder.begin();
+          i != this->insertOrder.end();
+          i++ )
+    {
+      i->second = NULL;
+    }
+  }
+  
+  //remove pointers in normal map
+  for ( std::map< int, std::vector<NICE::Vector *> >::iterator iter = this->begin(); iter != this->end(); ++iter )
+  {
+    for ( int j = 0; j < (int)iter->second.size(); j++ )
+    {
+      iter->second[j] = NULL;
+    }
+  }  
+}
+
 #endif

cbaselib/LabeledSet.h

@@ -165,6 +165,11 @@ class LabeledSetVector :
      * @param vecSetLabels labels (output)
      */
     void getFlatRepresentation ( NICE::VVector & vecSet, NICE::Vector & vecSetLabels ) const;
+    
+    /**
+     * @brief set all pointers to the data to NULL, i.e., keep the data in storage, but remove the pointers of this data struct
+     */
+    void removePointersToDataWithoutDeletion();
 
     friend class LabeledSetSelection<LabeledSetVector>;
 };

cbaselib/MultiDataset.cpp

@@ -42,8 +42,12 @@ void MultiDataset::selectExamples ( const std::string & examples_command,
     vector<string> parts;
     StringTools::split ( cmd, ' ', parts );
 
-    if ( (parts.size() != 3) && ((parts.size() != 2) || (parts[0] != "all")) )
+    if ( (parts.size() != 3) && ((parts.size() != 2) || (parts[0].compare("all") != 0)) )
+    {
+      std::cerr << "parts.size(): "<<parts.size()<<std::endl;
+      std::cerr << " parts[0]: " << parts[0] << std::endl;
       fthrow( Exception, "Syntax error " << examples_command );
+    }
 
     const std::string & mode = parts[0];
     const std::string & csel = parts[1];
@@ -135,13 +139,27 @@ void MultiDataset::selectExamples ( const std::string & examples_command,
 /** MultiDataset ------- constructor */
 MultiDataset::MultiDataset( const Config *conf , LabeledSetFactory *pSetFactory)
 {
+  //read all blocks from our config file
   std::set<string> blocks;
   conf->getAllBlocks ( blocks );
+  
+#ifdef DEBUG_MultiDataset  
+  std::cerr << "found the following config blocks: " << std::endl;
+  for ( std::set<string>::const_iterator blockIt = blocks.begin(); blockIt != blocks.end(); blockIt++)
+  {
+    std::cerr << *blockIt << " ";
+  }
+  std::cerr << std::endl;
+#endif  
 
   lfl.setFactory( pSetFactory );
 
+  //for every dataset (e.g., train and test), we store a single confog file
   map<string, Config> dsconfs;
+  //for every dataset (e.g., train and test), we store the position of the file directory
   map<string, string> dirs;
+  
+  //first of all, remove all blocks which do correspond to specified datasets, i.e., that do not contain a "dataset" entry
   for ( set<string>::iterator i = blocks.begin();
         i != blocks.end();  )
   {
@@ -165,7 +183,17 @@ MultiDataset::MultiDataset( const Config *conf , LabeledSetFactory *pSetFactory)
       i++;
     }
   }
+  
+#ifdef DEBUG_MultiDataset  
+  std::cerr << "found the following datasets within all config blocks: " << std::endl;
+  for ( std::set<string>::const_iterator blockIt = blocks.begin(); blockIt != blocks.end(); blockIt++)
+  {
+    std::cerr << *blockIt << " ";
+  }
+  std::cerr << std::endl;  
+#endif
 
+  //is there a dataset specified that contains images for both, training and testing?
   if ( blocks.find("traintest") != blocks.end() )
   {
     LabeledSet ls_base;
@@ -217,11 +245,13 @@ MultiDataset::MultiDataset( const Config *conf , LabeledSetFactory *pSetFactory)
     datasets["train"] = ls_train;
   }
 
+  //now read files for every specified dataset (e.g., train and test)
   for ( set<string>::const_iterator i = blocks.begin();
         i != blocks.end();
         i++ )
   {
     std::string name = *i;
+    std::cerr << "read: " << name << std::endl;
     if ( classnames.find(name) != classnames.end() )
       continue;
 
@@ -254,8 +284,11 @@ MultiDataset::MultiDataset( const Config *conf , LabeledSetFactory *pSetFactory)
 #endif
         classnames[name].readFromConfig ( dsconfs[name], classselection );
     }
-		
-
+    
+#ifdef DEBUG_MultiDataset
+    std::cerr << "we set up everything to read this dataset - so now call lfl.get" << std::endl;
+#endif
+    
     lfl.get (   dirs[name],
                 dsconfs[name],
                 classnames[name],
@@ -270,6 +303,10 @@ MultiDataset::MultiDataset( const Config *conf , LabeledSetFactory *pSetFactory)
     fprintf (stderr, "MultiDataset: all information about %s set obtained ! (size %d)\n", name.c_str(), ls_base.count() );
 #endif
 
+#ifdef DEBUG_MultiDataset    
+    std::cerr << "we now call selectExamples to pick only a subset if desired" << std::endl;
+#endif
+    
     std::string examples = conf->gS(name, "examples", "all *" );
     selectExamples ( examples, ls_base, ls, dummy, classnames[name] );
 

classifier/classifierbase/FeaturePoolClassifier.cpp

@@ -78,3 +78,9 @@ void FeaturePoolClassifier::setComplexity ( int size )
     fprintf (stderr, "FeaturePoolClassifier::setComplexity: not yet implemented in subordinate class\n");
     exit(-1);
 }
+
+void FeaturePoolClassifier::addMultipleExamples( OBJREC::Examples & newExamples)
+{
+    fprintf (stderr, "FeaturePoolClassifier::addMultipleExamples: not yet implemented in subordinate class\n");
+    exit(-1);
+}

classifier/classifierbase/FeaturePoolClassifier.h

@@ -50,6 +50,9 @@ class FeaturePoolClassifier : public NICE::Persistent
 
 	/** set complexity for the next training process e.g. number of weak classifiers */
 	virtual void setComplexity ( int size );
+  
+  /** add multiple examples given in the OBJREC::Examples data structure*/
+  virtual void addMultipleExamples( OBJREC::Examples & newExamples);
 
 };
 

classifier/classifierbase/VecClassifier.h

@@ -15,6 +15,7 @@
 #include "vislearning/cbaselib/ClassificationResult.h"
 
 #define ROADWORKS fthrow(NICE::Exception, "clone(): not yet implemented!");
+#define ROADWORKSADD fthrow(NICE::Exception, "teach (int classno, const NICE::Vector & x ): not yet implemented!");
 
 namespace OBJREC
 {
@@ -56,6 +57,12 @@ class VecClassifier : public NICE::Persistent
     {
       ROADWORKS;
     };
+    
+    virtual void teach (int classno, const NICE::Vector & x )
+    {
+      ROADWORKSADD;
+    };
+
 };
 
 #undef ROADWORKS

classifier/classifiercombination/VCPreRandomForest.cpp

@@ -1,4 +1,4 @@
-/** 
+/**
 * @file VCPreRandomForest.cpp
 * @brief Combination of a classifier with a pre-clustering using a random forest
 * @author Erik Rodner
@@ -21,164 +21,164 @@ using namespace NICE;
 
 
 VCPreRandomForest::VCPreRandomForest( const Config *conf, const std::string & section, VecClassifier *_leafClassifierPrototype )
-	: leafClassifierPrototype(_leafClassifierPrototype), fp(conf)
+    : leafClassifierPrototype(_leafClassifierPrototype), fp(conf)
 {
-	string cluster_section = conf->gS(section, "cluster_section", "RandomForest");
-	mEx = conf->gI("DTBRandom", "min_examples", numeric_limits<int>::max());
-	mEx = 500;
-	randomforest = new FPCRandomForests ( conf, cluster_section );
+  string cluster_section = conf->gS(section, "cluster_section", "RandomForest");
+  mEx = conf->gI("DTBRandom", "min_examples", numeric_limits<int>::max());
+  mEx = 500;
+  randomforest = new FPCRandomForests ( conf, cluster_section );
 }
-  
+
 VCPreRandomForest::~VCPreRandomForest()
 {
-	// delete the random forest
-	if ( randomforest != NULL )
-		delete randomforest;
-
-	// delete all classifiers in the leafs
-	for ( map<DecisionNode *, VecClassifier *>::const_iterator i = leafClassifiers.begin();
-		i != leafClassifiers.end(); i++ )
-	{
-		VecClassifier *lc = i->second;
-		delete lc;
-	}
+  // delete the random forest
+  if ( randomforest != NULL )
+    delete randomforest;
+
+  // delete all classifiers in the leafs
+  for ( map<DecisionNode *, VecClassifier *>::const_iterator i = leafClassifiers.begin();
+        i != leafClassifiers.end(); i++ )
+  {
+    VecClassifier *lc = i->second;
+    delete lc;
+  }
 }
 
 ClassificationResult VCPreRandomForest::classify ( const NICE::Vector & x ) const
 {
-	NICE::Vector *v = new NICE::Vector(x);
-	Example example(v);
-
-	vector<DecisionNode *> leafNodes;
-	
-	// traverse the forest and obtain all involved leaf nodes
-	randomforest->getLeafNodes(example, leafNodes);
-
-	ClassificationResult r ( ClassificationResult::REJECTION_NONE, maxClassNo );
-	r.scores.set(0.0);
-
-	for ( vector<DecisionNode *>::const_iterator i = leafNodes.begin();
-		i != leafNodes.end(); i++ )
-	{
-		DecisionNode *node = *i;
-		map<DecisionNode *, VecClassifier *>::const_iterator leafClassifierIt = 
-				leafClassifiers.find ( node );
-
-		if ( leafClassifierIt == leafClassifiers.end() ) {
-			// this leaf has no associated classifier
-			// -> we will use the random forest "score" :)
-			//
-			double sum = node->distribution.sum();
-			for(uint k = 0; k < (uint)std::min(node->distribution.size(), r.scores.size());k++)
-			{
-				r.scores[k] += node->distribution[k] / sum;
-			}
-
-			//fthrow(Exception, "Unable to find this leaf node !! (implementation bug)");
-			continue;
-		}
-		
-		VecClassifier *leafClassifier = leafClassifierIt->second;
-		ClassificationResult rSingle = leafClassifier->classify ( x );
-
-		rSingle.scores.normalize();
-		for(uint k = 0; k < (uint)std::min(rSingle.scores.size(), r.scores.size());k++)
-		{
-			r.scores[k] += rSingle.scores[k];	
-		}
-	}
-
-	r.scores.multiply ( 1.0/(leafNodes.size()) );
-	r.classno = r.scores.maxElement();
-
-	if ( fabs(r.scores.sum() - 1.0) > 1e-2 )
-	{
-		//fthrow(Exception, "Ups !\n");
-		r.scores[0] = 1.0;
-	}
-
-	example.clean();
-
-	return r;
+  NICE::Vector *v = new NICE::Vector(x);
+  Example example(v);
+
+  vector<DecisionNode *> leafNodes;
+
+  // traverse the forest and obtain all involved leaf nodes
+  randomforest->getLeafNodes(example, leafNodes);
+
+  ClassificationResult r ( ClassificationResult::REJECTION_NONE, maxClassNo );
+  r.scores.set(0.0);
+
+  for ( vector<DecisionNode *>::const_iterator i = leafNodes.begin();
+        i != leafNodes.end(); i++ )
+  {
+    DecisionNode *node = *i;
+    map<DecisionNode *, VecClassifier *>::const_iterator leafClassifierIt =
+      leafClassifiers.find ( node );
+
+    if ( leafClassifierIt == leafClassifiers.end() ) {
+      // this leaf has no associated classifier
+      // -> we will use the random forest "score" :)
+      //
+      double sum = node->distribution.sum();
+      for (uint k = 0; k < (uint)std::min(node->distribution.size(), r.scores.size());k++)
+      {
+        r.scores[k] += node->distribution[k] / sum;
+      }
+
+      //fthrow(Exception, "Unable to find this leaf node !! (implementation bug)");
+      continue;
+    }
+
+    VecClassifier *leafClassifier = leafClassifierIt->second;
+    ClassificationResult rSingle = leafClassifier->classify ( x );
+
+    rSingle.scores.normalize();
+    for (uint k = 0; k < (uint)std::min(rSingle.scores.size(), r.scores.size());k++)
+    {
+      r.scores[k] += rSingle.scores[k];
+    }
+  }
+
+  r.scores.multiply ( 1.0 / (leafNodes.size()) );
+  r.classno = r.scores.maxElement();
+
+  if ( fabs(r.scores.sum() - 1.0) > 1e-2 )
+  {
+    //fthrow(Exception, "Ups !\n");
+    r.scores[0] = 1.0;
+  }
+
+  example.clean();
+
+  return r;
 }
 
 void VCPreRandomForest::teach ( const LabeledSetVector & teachSet )
 {
-	Examples examples;
-	maxClassNo = teachSet.getMaxClassno();
-
-	LOOP_ALL(teachSet)
-	{
-		EACH(classno, x);
-		NICE::Vector *v = new Vector(x);
-		examples.push_back(	pair<int, Example> (classno, Example(v)));
-	}
-
-	uint dimension = teachSet.dimension();
-	fp.clear();
-	Feature *f = new VectorFeature(dimension);
-	f->explode(fp);
-
-	// train the forest
-	randomforest->setMaxClassNo( teachSet.getMaxClassno()  );
-	randomforest->train ( fp, examples );
-	// free some useless memory, we do not need this
-	// data structure any more
-	examples.clean();
-	
-	vector<DecisionNode *> leafNodes;
-	randomforest->getAllLeafNodes ( leafNodes );
-	
-	int lsize = leafNodes.size();
-	cout << "leafnodes: " << lsize << endl;
-	int leafNo = 0;
+  Examples examples;
+  maxClassNo = teachSet.getMaxClassno();
+
+  LOOP_ALL(teachSet)
+  {
+    EACH(classno, x);
+    NICE::Vector *v = new Vector(x);
+    examples.push_back( pair<int, Example> (classno, Example(v)));
+  }
+
+  uint dimension = teachSet.dimension();
+  fp.clear();
+  Feature *f = new VectorFeature(dimension);
+  f->explode(fp);
+
+  // train the forest
+  randomforest->setMaxClassNo( teachSet.getMaxClassno()  );
+  randomforest->train ( fp, examples );
+  // free some useless memory, we do not need this
+  // data structure any more
+  examples.clean();
+
+  vector<DecisionNode *> leafNodes;
+  randomforest->getAllLeafNodes ( leafNodes );
+
+  int lsize = leafNodes.size();
+  cout << "leafnodes: " << lsize << endl;
+  int leafNo = 0;
 #pragma omp parallel for
-	for ( int l = 0; l < lsize; l++)
-	{
-		cerr << "Training classifier for leaf " << leafNo << endl;
-		leafNo++;
+  for ( int l = 0; l < lsize; l++)
+  {
+    cerr << "Training classifier for leaf " << leafNo << endl;
+    leafNo++;
+
+    DecisionNode *node = leafNodes[l];
 
-		DecisionNode *node = leafNodes[l];
+    if ( node->distribution.entropy() <= 0.0) continue;
+    if ( ! node->isLeaf() ) continue;
 
-		if ( node->distribution.entropy() <= 0.0) continue;
-		if ( ! node->isLeaf() ) continue;
+    vector<int> examplesSet = node->trainExamplesIndices;
+    assert(examplesSet.size() > 0);
 
-		vector<int> examplesSet = node->trainExamplesIndices;
-		assert(examplesSet.size() > 0);
+    sort (examplesSet.begin(), examplesSet.end());
 
-		sort (examplesSet.begin(), examplesSet.end());
+    LabeledSetVector trainSubSet;
 
-		LabeledSetVector trainSubSet;
+    vector<double> counter(maxClassNo, 0.0);
+    uint exampleIndex = 0;
+    uint c = 0;
 
-		vector<double> counter(maxClassNo,0.0);
-		uint exampleIndex = 0;
-		uint c = 0;
+    LOOP_ALL(teachSet)
+    {
+      EACH(classno, x);
+      if ( examplesSet[c] == exampleIndex )
+      {
+        c++;
+        trainSubSet.add ( classno, x );
+      }
+      exampleIndex++;
+    }
 
-		LOOP_ALL(teachSet)
-		{
-			EACH(classno, x);
-			if ( examplesSet[c] == exampleIndex )
-			{
-				c++;
-				trainSubSet.add ( classno, x );
-			}
-			exampleIndex++;
-		}
-		
-		VecClassifier *lc = leafClassifierPrototype->clone();
+    VecClassifier *lc = leafClassifierPrototype->clone();
 
-		lc->teach ( trainSubSet );
+    lc->teach ( trainSubSet );
 
-		leafClassifiers.insert ( pair<DecisionNode *, VecClassifier *> ( node, lc ) );
-	}	
+    leafClassifiers.insert ( pair<DecisionNode *, VecClassifier *> ( node, lc ) );
+  }
 }
 
 void VCPreRandomForest::clear()
 {
-	map<DecisionNode *, VecClassifier *>::iterator iter;
-	for( iter = leafClassifiers.begin(); iter != leafClassifiers.end(); ++iter ) 
-	{
-		iter->second->clear();
-	}
-	randomforest->clear();
-}
+  map<DecisionNode *, VecClassifier *>::iterator iter;
+  for ( iter = leafClassifiers.begin(); iter != leafClassifiers.end(); ++iter )
+  {
+    iter->second->clear();
+  }
+  randomforest->clear();
+}

classifier/fpclassifier/FPCGPHIK.cpp

@@ -0,0 +1,249 @@
+/** 
+* @file FPCGPHIK.cpp
+* @brief feature pool interface for our GP HIK classifier
+* @author Alexander Freytag
+* @date 02/01/2012
+
+*/
+#include <iostream>
+
+#include "core/basics/numerictools.h"
+#include <core/basics/Timer.h>
+
+#include "FPCGPHIK.h"
+
+using namespace std;
+using namespace NICE;
+using namespace OBJREC;
+
+
+FPCGPHIK::FPCGPHIK( const Config *conf, const string & confSection ) 
+{
+  this->verbose = conf->gB(confSection, "verbose", false);
+  this->useSimpleBalancing = conf->gB(confSection, "use_simple_balancing", false);
+  this->minSamples = conf->gI(confSection, "min_samples", -1);
+  this->performOptimizationAfterIncrement = conf->gB(confSection, "performOptimizationAfterIncrement", true);
+  
+  classifier = new GPHIKClassifier(conf, confSection);
+}
+
+FPCGPHIK::~FPCGPHIK()
+{
+  if ( classifier != NULL )
+    delete classifier;
+}
+
+ClassificationResult FPCGPHIK::classify ( Example & pe )
+{
+  const SparseVector *svec = pe.svec;
+
+  if ( svec == NULL )
+    fthrow(Exception, "FPCGPHIK requires example.svec (SparseVector stored in an Example struct)");
+ return this->classify( svec ); 
+}
+
+ClassificationResult FPCGPHIK::classify ( const NICE::SparseVector * example )
+{
+  NICE::SparseVector scores;
+  int result;
+  
+  double uncertainty;
+ 
+  classifier->classify ( example,  result, scores, uncertainty);
+  
+  if ( scores.size() == 0 ) {
+    fthrow(Exception, "Zero scores, something is likely to be wrong here: svec.size() = " << example->size() );
+  }
+  int classes = scores.getDim();
+  FullVector fvscores(classes);
+  
+  NICE::SparseVector::const_iterator it;
+  for(int c = 0; c < classes; c++)
+  {
+    it = scores.find(c);
+    if ( it == scores.end() )
+      fvscores[c] = -std::numeric_limits<double>::max();
+    else
+      fvscores[c] = it->second;
+  }
+
+  ClassificationResult r ( fvscores.maxElement(), fvscores );
+  r.uncertainty = uncertainty;
+  
+  if (verbose)
+  {
+    std::cerr << " FPCGPHIK::classify scores" << std::endl;
+    scores.store(std::cerr);
+    std::cerr << " FPCGPHIK::classify fvscores" << std::endl;
+    fvscores.store(std::cerr);
+  }
+
+  return r;
+}
+
+/** training process */
+void FPCGPHIK::train ( FeaturePool & fp, Examples & examples )
+{
+  // we completely ignore the feature pool :)
+  //
+  initRand(0);
+  Vector classCounts;
+  int minClass = -1;
+  
+  if (verbose) 
+    std::cerr << "FPCGPHIK::train" << std::endl;
+
+  if ( useSimpleBalancing)
+  {
+    classCounts.resize( examples.getMaxClassNo()+1 );
+    classCounts.set( 0.0 );
+    for ( uint i = 0 ; i < examples.size() ; i++ )
+      classCounts[ examples[i].first ]++;
+    // we need a probability distribution
+    //classCounts.normalizeL1();
+    // we need the class index of the class with the least non-zero examples
+    for ( uint i = 0 ; i < classCounts.size(); i++ )
+      if ( (classCounts[i] > 0) && ((minClass < 0) || (classCounts[i] < classCounts[minClass])) )
+        minClass = i;
+    if (verbose)
+    {
+      cerr << "Class distribution: " << classCounts << endl;
+      cerr << "Class with the least number of examples: " << minClass << endl;
+    }
+    if(minSamples < 0)
+      minSamples = classCounts[minClass];
+  }
+
+  // (multi-class) label vector
+  Vector y ( examples.size() /* maximum size */ );
+
+  // flat structure of our training data
+  std::vector< SparseVector * > sparseExamples;
+
+  if (verbose)
+    cerr << "Converting (and sampling) feature vectors" << endl;
+  for ( uint i = 0 ; i < examples.size() ; i++ )
+  {
+    const Example & example = examples[i].second;
+    int classno = examples[i].first;
+    
+    // simple weird balancing method
+    if ( useSimpleBalancing ) 
+    {
+      double t = randDouble() * classCounts[classno];
+      if ( t >= minSamples ) continue;
+    }
+
+    y[ sparseExamples.size() ] = classno;
+    if ( example.svec == NULL )
+      fthrow(Exception, "FPCGPHIK requires example.svec (SparseVector stored in an Example struct)");
+    sparseExamples.push_back( example.svec );    
+  }
+
+  // we only use a subset for training
+  y.resize( sparseExamples.size() );
+  
+  classifier->train(sparseExamples, y);
+}
+
+/** training process */
+void FPCGPHIK::train ( const std::vector< SparseVector *> & examples, std::map<int, NICE::Vector> & binLabels )
+{
+  classifier->train(examples, binLabels);
+}
+
+void FPCGPHIK::clear ()
+{
+  if ( classifier != NULL )
+    delete classifier;
+  classifier = NULL;
+}
+
+FeaturePoolClassifier *FPCGPHIK::clone () const
+{
+  fthrow(Exception, "FPCGPHIK: clone() not yet implemented" );
+
+  return NULL;
+}
+
+void FPCGPHIK::predictUncertainty( Example & pe, NICE::Vector & uncertainties )
+{
+  const SparseVector *svec = pe.svec;  
+  if ( svec == NULL )
+    fthrow(Exception, "FPCGPHIK requires example.svec (SparseVector stored in an Example struct)");
+  classifier->predictUncertainty(svec, uncertainties);
+}
+   
+void FPCGPHIK::predictUncertainty( const NICE::SparseVector * example, NICE::Vector & uncertainties )
+{  
+  classifier->predictUncertainty(example, uncertainties);
+}
+
+//---------------------------------------------------------------------
+//                           protected methods
+//---------------------------------------------------------------------
+void FPCGPHIK::restore ( std::istream & is, int format )
+{
+  if (is.good())
+  {
+    classifier->restore(is, format);  
+    
+    std::string tmp;
+    is >> tmp; //"performOptimizationAfterIncrement: "
+    is >> this->performOptimizationAfterIncrement;
+  }
+  else
+  {
+    std::cerr << "FPCGPHIK::restore -- InStream not initialized - restoring not possible!" << std::endl;
+  }
+}
+
+void FPCGPHIK::store ( std::ostream & os, int format ) const
+{
+  if (os.good())
+  {
+    os.precision (numeric_limits<double>::digits10 + 1);
+    
+    classifier->store(os, format);
+    
+    os << "performOptimizationAfterIncrement: " << performOptimizationAfterIncrement << std::endl;
+  }
+  else
+  {
+    std::cerr << "OutStream not initialized - storing not possible!" << std::endl;
+  }
+}
+
+void FPCGPHIK::addExample( const Example & pe, const double & label)
+{
+  const SparseVector *svec = pe.svec;
+  classifier->addExample(svec, label, this->performOptimizationAfterIncrement);
+}
+
+void FPCGPHIK::addMultipleExamples( Examples & newExamples)
+{
+  //are new examples available? If not, nothing has to be done
+  if ( newExamples.size() < 1)
+    return;
+  
+  // (multi-class) label vector
+  Vector y ( newExamples.size() );
+
+  // flat structure of our training data
+  std::vector< const SparseVector * > sparseExamples;
+
+  if (verbose)
+    cerr << "Converting (and sampling) feature vectors" << endl;
+  for ( uint i = 0 ; i < newExamples.size() ; i++ )
+  {
+    const Example & example = newExamples[i].second;
+    int classno = newExamples[i].first;
+
+    y[ i ] = classno;
+    if ( example.svec == NULL )
+      fthrow(Exception, "FPCGPHIK requires example.svec (SparseVector stored in an Example struct)");
+    sparseExamples.push_back( example.svec );    
+  }  
+  
+  classifier->addMultipleExamples(sparseExamples, y, this->performOptimizationAfterIncrement);  
+}

classifier/fpclassifier/FPCGPHIK.h

@@ -0,0 +1,99 @@
+/** 
+* @file FPCGPHIK.h
+* @author Alexander Freytag, Erik Rodner
+* @date 02/01/2012
+
+*/
+#ifndef _NICE_GPHIKCLASSIFIERNICEINCLUDE
+#define _NICE_GPHIKCLASSIFIERNICEINCLUDE
+
+#include <string>
+#include "core/basics/Config.h"
+#include "vislearning/classifier/classifierbase/FeaturePoolClassifier.h"
+
+#include <gp-hik-core/GPHIKClassifier.h>
+#include <gp-hik-core/FMKGPHyperparameterOptimization.h>
+#include <gp-hik-core/parameterizedFunctions/ParameterizedFunction.h>
+
+namespace OBJREC {
+  
+/** @class FPCGPHIK
+ * Wrapper class (feature pool interface) for our GP HIK classifier 
+ *
+ * @author Alexander Freytag, Erik Rodner
+ */
+class FPCGPHIK : public FeaturePoolClassifier
+{
+
+  protected:
+    
+    NICE::GPHIKClassifier * classifier;
+    
+    /** verbose flag for useful output*/
+    bool verbose;
+    
+    /** a simple balancing strategy: use only that many examples of each class, as the smallest class provides*/
+    bool useSimpleBalancing; 
+    int minSamples;
+    
+    /** When adding new examples, do we want to run a whole optimization of all involved hyperparameters? default: true*/
+    bool performOptimizationAfterIncrement;
+
+  public:
+
+    /** simple constructor */
+    FPCGPHIK( const NICE::Config *conf, const std::string & confSection = "GPHIKClassifier" );
+      
+    /** simple destructor */
+    virtual ~FPCGPHIK();
+   
+    /** 
+    * @brief classify a given example with the previously learnt model
+    * @param pe example to be classified given in a sparse representation
+    */
+    virtual ClassificationResult classify ( OBJREC::Example & pe );
+    /** 
+     * @brief classify a given example with the previously learnt model
+     * @date 19-06-2012 (dd-mm-yyyy)
+     * @author Alexander Freytag
+     * @param examples example to be classified given in a sparse representation
+     */    
+    ClassificationResult classify ( const NICE::SparseVector * example );
+
+    /** training process */
+    virtual void train ( OBJREC::FeaturePool & fp, OBJREC::Examples & examples );
+    /** 
+     * @brief train this classifier using a given set of examples and a given set of binary label vectors 
+     * @date 19-06-2012 (dd-mm-yyyy)
+     * @author Alexander Freytag
+     * @param examples examples to use given in a sparse data structure
+     * @param binLabels corresponding binary labels with class no. There is no need here that every examples has only on positive entry in this set (1,-1)
+     */
+    void train ( const std::vector< NICE::SparseVector *> & examples, std::map<int, NICE::Vector> & binLabels );
+    
+    /** Persistent interface */
+    virtual void restore ( std::istream & is, int format = 0 );
+    virtual void store ( std::ostream & os, int format = 0 ) const;
+    virtual void clear ();
+
+    virtual FeaturePoolClassifier *clone () const;
+    
+    /** prediction of classification uncertainty */
+    void predictUncertainty( OBJREC::Example & pe, NICE::Vector & uncertainties );
+    /** 
+     * @brief prediction of classification uncertainty
+     * @date 19-06-2012 (dd-mm-yyyy)
+     * @author Alexander Freytag
+     * @param examples example for which the classification uncertainty shall be predicted, given in a sparse representation
+     * @param uncertainties contains the resulting classification uncertainties (1 entry for standard setting, m entries for binary-balanced setting)
+     */       
+    void predictUncertainty( const NICE::SparseVector * example, NICE::Vector & uncertainties );
+    
+    void addExample( const OBJREC::Example & pe, const double & label);
+    virtual void addMultipleExamples( OBJREC::Examples & newExamples);
+    
+};
+
+}
+
+#endif

classifier/fpclassifier/libdepend.inc

@@ -1 +1,3 @@
-$(call PKG_DEPEND_INT,vislearning/classifier/classifierbase)
+$(call PKG_DEPEND_INT,vislearning/classifier/classifierbase)
+$(call PKG_DEPEND_INT,gp-hik-core/)
+

classifier/fpclassifier/tests/Makefile.inc

@@ -0,0 +1,89 @@
+# BINARY-DIRECTORY-MAKEFILE
+# conventions:
+# - there are no subdirectories, they are ignored!
+# - all ".C", ".cpp" and ".c" files in the current directory are considered
+#   independent binaries, and linked as such.
+# - the binaries depend on the library of the parent directory
+# - the binary names are created with $(BINNAME), i.e. it will be more or less
+#   the name of the .o file
+# - all binaries will be added to the default build list ALL_BINARIES
+
+# --------------------------------
+# - remember the last subdirectory
+#
+# set the variable $(SUBDIR) correctly to the current subdirectory. this
+# variable can be used throughout the current makefile.inc. The many 
+# SUBDIR_before, _add, and everything are only required so that we can recover
+# the previous content of SUBDIR before exitting the makefile.inc
+
+SUBDIR_add:=$(dir $(word $(words $(MAKEFILE_LIST)),$(MAKEFILE_LIST)))
+SUBDIR_before:=$(SUBDIR)
+SUBDIR:=$(strip $(SUBDIR_add))
+SUBDIR_before_$(SUBDIR):=$(SUBDIR_before)
+
+# ------------------------
+# - include subdirectories
+#
+# note the variables $(SUBDIRS_OF_$(SUBDIR)) are required later on to recover
+# the dependencies automatically. if you handle dependencies on your own, you
+# can also dump the $(SUBDIRS_OF_$(SUBDIR)) variable, and include the
+# makefile.inc of the subdirectories on your own...
+
+#SUBDIRS_OF_$(SUBDIR):=$(patsubst %/Makefile.inc,%,$(wildcard $(SUBDIR)*/Makefile.inc))
+#include $(SUBDIRS_OF_$(SUBDIR):%=%/Makefile.inc)
+
+# ----------------------------
+# - include local dependencies
+#
+# include the libdepend.inc file, which gives additional dependencies for the
+# libraries and binaries. additionally, an automatic dependency from the library
+# of the parent directory is added (commented out in the code below).
+
+-include $(SUBDIR)libdepend.inc
+
+PARENTDIR:=$(patsubst %/,%,$(dir $(patsubst %/,%,$(SUBDIR))))
+$(call PKG_DEPEND_INT,$(PARENTDIR))
+$(call PKG_DEPEND_EXT,CPPUNIT)
+
+# ---------------------------
+# - objects in this directory
+#
+# the use of the variable $(OBJS) is not mandatory. it is mandatory however
+# to update $(ALL_OBJS) in a way that it contains the path and name of
+# all objects. otherwise we can not include the appropriate .d files.
+
+OBJS:=$(patsubst %.cpp,$(OBJDIR)%.o,$(notdir $(wildcard $(SUBDIR)*.cpp))) \
+      $(patsubst %.C,$(OBJDIR)%.o,$(notdir $(wildcard $(SUBDIR)*.C))) \
+      $(shell grep -ls Q_OBJECT $(SUBDIR)*.h | sed -e's@^@/@;s@.*/@$(OBJDIR)moc_@;s@\.h$$@.o@') \
+      $(patsubst %.c,$(OBJDIR)%.o,$(notdir $(wildcard $(SUBDIR)*.c)))
+ALL_OBJS += $(OBJS)
+
+# ----------------------------
+# - binaries in this directory
+#
+# output of binaries in this directory. none of the variables has to be used.
+# but everything you add to $(ALL_LIBRARIES) and $(ALL_BINARIES) will be
+# compiled with `make all`. be sure again to add the files with full path.
+
+CHECKS:=$(BINDIR)$(call LIBNAME,$(SUBDIR))
+ALL_CHECKS+=$(CHECKS)
+
+# ---------------------
+# - binary dependencies
+#
+# there is no way of determining the binary dependencies automatically, so we
+# follow conventions. each binary depends on the corresponding .o file and
+# on the libraries specified by the INTLIBS/EXTLIBS. these dependencies can be
+# specified manually or they are automatically stored in a .bd file.
+
+$(foreach head,$(wildcard $(SUBDIR)*.h),$(eval $(shell grep -q Q_OBJECT $(head) && echo $(head) | sed -e's@^@/@;s@.*/\(.*\)\.h$$@$(BINDIR)\1:$(OBJDIR)moc_\1.o@')))
+$(eval $(foreach c,$(CHECKS),$(c):$(BUILDDIR)$(CPPUNIT_MAIN_OBJ) $(OBJS) $(call PRINT_INTLIB_DEPS,$(c),.a)))
+
+# -------------------
+# - subdir management
+#
+# as the last step, always add this line to correctly recover the subdirectory
+# of the makefile including this one!
+
+SUBDIR:=$(SUBDIR_before_$(SUBDIR))
+

classifier/fpclassifier/tests/TestFPCGPHIK.cpp

@@ -0,0 +1,536 @@
+#ifdef NICE_USELIB_CPPUNIT
+
+#include <string>
+#include <exception>
+#include <iostream>
+#include <fstream>
+
+//----------
+
+#include <core/basics/Timer.h>
+
+//----------
+
+#include <vislearning/cbaselib/ClassificationResults.h>
+#include <vislearning/classifier/kernelclassifier/KCGPRegOneVsAll.h>
+
+//----------
+
+#include "vislearning/classifier/fpclassifier/FPCGPHIK.h"
+
+//----------
+
+#include "TestFPCGPHIK.h"
+
+
+const bool verbose = false;
+const bool verboseStartEnd = true;
+
+using namespace OBJREC;
+using namespace NICE;
+using namespace std;
+
+CPPUNIT_TEST_SUITE_REGISTRATION( TestFPCGPHIK );
+
+void TestFPCGPHIK::setUp() {
+}
+
+void TestFPCGPHIK::tearDown() {
+}
+
+void myClassifierTest( FPCGPHIK & classifier, const Matrix & mX, const Vector & vY )
+{
+  
+  if (verboseStartEnd)
+    std::cerr << "================== TestFPCGPHIK::myClassifierTest ===================== " << std::endl;
+  
+  Examples examples;
+
+  for ( uint i = 0 ; i < vY.size() ; i++ )
+    if ( i % 2 == 1 )
+    {
+      Example example;
+      example.svec = new SparseVector;
+      example.svec->setDim(3);
+      example.svec->set ( 0, mX(i,0) );
+      example.svec->set ( 1, mX(i,1) );
+      example.svec->set ( 2, 1.0-mX(i,0)-mX(i,1) );
+      examples.push_back ( pair<int, Example> ( vY[i], example ) );
+    }
+
+  FeaturePool fp; // will be ignored
+
+  if ( verbose )
+    std::cerr << "preparation done." << std::endl;
+
+  if ( verbose ) 
+    std::cerr << "learning ..." << std::endl;
+  classifier.train ( fp, examples ); 
+
+  if ( verbose )
+    std::cerr << "testing ..." << std::endl;
+  for ( uint i = 0 ; i < vY.size() ; i++ )
+    if ( i % 2 == 0 )
+    {
+      Example example;
+      example.svec = new SparseVector;
+      example.svec->setDim(3);
+      example.svec->set ( 0, mX(i,0) );
+      example.svec->set ( 1, mX(i,1) );
+      example.svec->set ( 2, 1.0-mX(i,0)-mX(i,1) );
+      ClassificationResult r = classifier.classify ( example );
+      if (verbose)
+      {
+        r.scores >> std::cerr;
+        std::cerr << "predicted uncertainty: " << r.uncertainty << std::endl;
+      }
+    } 
+
+  examples.clean();
+  
+  if (verboseStartEnd)
+    std::cerr << "================== TestFPCGPHIK::myClassifierTest done ===================== " << std::endl;
+
+}
+
+void myClassifierStoreRestoreTest( FPCGPHIK & classifier, const Matrix & mX, const Vector & vY )
+{
+  
+  if (verboseStartEnd)
+    std::cerr << "================== TestFPCGPHIK::myClassifierStoreRestoreTest ===================== " << std::endl;
+  
+  Examples examples;
+
+  for ( uint i = 0 ; i < vY.size() ; i++ )
+    if ( i % 2 == 1 )
+    {
+      Example example;
+      example.svec = new SparseVector;
+      example.svec->setDim(3);
+      example.svec->set ( 0, mX(i,0) );
+      example.svec->set ( 1, mX(i,1) );
+      example.svec->set ( 2, 1.0-mX(i,0)-mX(i,1) );
+      examples.push_back ( pair<int, Example> ( vY[i], example ) );
+    }
+
+  FeaturePool fp; // will be ignored
+
+  if ( verbose )
+    std::cerr << "preparation done." << std::endl;
+
+  if ( verbose ) 
+    std::cerr << "learning ..." << std::endl;
+  classifier.train ( fp, examples ); 
+  
+  if ( verbose ) 
+    std::cerr << "storing ..." << std::endl;  
+  //test the store-functionality  
+  string destination("/tmp/GPHIK_store.txt");
+  
+  std::filebuf fb;
+  fb.open (destination.c_str(),ios::out);
+  std::ostream os(&fb);
+//   
+  classifier.store(os);  
+//   
+  fb.close();
+  
+  if ( verbose ) 
+    std::cerr << "loading ..." << std::endl;  
+  
+  Config confTmp;
+  FPCGPHIK classifierRestored(&confTmp);
+  
+  std::filebuf fbIn;
+  fbIn.open (destination.c_str(),ios::in);
+  std::istream is(&fbIn);
+//   
+  classifierRestored.restore(is);
+//   
+  fbIn.close();    
+
+  if ( verbose )
+    std::cerr << "testing ..." << std::endl;
+  for ( uint i = 0 ; i < vY.size() ; i++ )
+    if ( i % 2 == 0 )
+    {
+      Example example;
+      example.svec = new SparseVector;
+      example.svec->setDim(3);
+      example.svec->set ( 0, mX(i,0) );
+      example.svec->set ( 1, mX(i,1) );
+      example.svec->set ( 2, 1.0-mX(i,0)-mX(i,1) );
+      ClassificationResult rOrig = classifier.classify ( example );
+      ClassificationResult rRestored = classifierRestored.classify ( example );
+      
+      //scores are of type FullVector
+      //we use the [] operator, since there are no iterators given in FullVector.h
+      bool equal(true);
+      for (int i = 0; i< rOrig.scores.size(); i++)
+      {
+        if ( fabs(rOrig.scores[i] - rRestored.scores[i]) > 10-6)
+        {
+          equal = false;
+          break;
+        }        
+      }
+      
+      CPPUNIT_ASSERT_EQUAL ( equal, true ); 
+    } 
+
+  examples.clean();
+  
+  if (verboseStartEnd)
+    std::cerr << "================== TestFPCGPHIK::myClassifierStoreRestoreTest done ===================== " << std::endl;
+
+}
+
+void myClassifierILTest( FPCGPHIK & classifierRetrain, FPCGPHIK & classifierIL, const Matrix & mX, const Vector & vY )
+{
+ 
+  if (verboseStartEnd)
+    std::cerr << "================== TestFPCGPHIK::myClassifierILTest ===================== " << std::endl;
+  
+  Examples examples;
+  
+  if (verbose)
+    std::cerr << "vY: " << vY << std::endl;
+
+  for ( uint i = 0 ; i < vY.size() ; i++ )
+  {
+    if ( i % 4 == 1 )
+    {
+      Example example;
+      example.svec = new SparseVector;
+      example.svec->setDim(3);
+      example.svec->set ( 0, mX(i,0) );
+      example.svec->set ( 1, mX(i,1) );
+      example.svec->set ( 2, 1.0-mX(i,0)-mX(i,1) );
+      examples.push_back ( pair<int, Example> ( vY[i], example ) );
+    }
+  }
+
+  if (verbose)
+    std::cerr << "examples.size(): " << examples.size()  << std::endl;
+
+  FeaturePool fp; // will be ignored
+
+  if ( verbose )
+    std::cerr << "preparation done." << std::endl;
+
+  if ( verbose ) 
+    std::cerr << "learning ..." << std::endl;
+  classifierIL.train ( fp, examples ); 
+  
+  //choose next example(s)
+  
+  Examples newExamples;
+  for ( uint i = 0 ; i < vY.size() ; i++ )
+  {
+    if ( i % 4 == 3 )
+    {
+      Example example;
+      example.svec = new SparseVector;
+      example.svec->setDim(3);
+      example.svec->set ( 0, mX(i,0) );
+      example.svec->set ( 1, mX(i,1) );
+      example.svec->set ( 2, 1.0-mX(i,0)-mX(i,1) );
+      newExamples.push_back ( pair<int, Example> ( vY[i], example ) );
+    }  
+  }
+
+//   if ( verbose ) 
+    std::cerr << std::endl << " =============== " << std::endl << "incremental learning ..." << std::endl;
+  
+  // add them to classifierIL
+//   std::cerr << "We add several new examples" << std::endl;
+  Timer t;
+  t.start();  
+//   for (uint i = 0; i < newExamples.size(); i++)
+  for (uint i = 0; i < 1; i++)
+  {
+    classifierIL.addExample( newExamples[i].second, newExamples[i].first);      
+  }  
+  
+  t.stop();  
+  std::cerr << "Time used for incremental training: " << t.getLast() << std::endl;
+
+  //add the new features to feature pool needed for batch training
+//   for (uint i = 0; i < newExamples.size(); i++)
+  for (uint i = 0; i < 2; i++)
+  {  
+    examples.push_back( newExamples[i] );
+  }
+  
+  std::cerr << std::endl << " =============== " << std::endl << "We train the second classifier from the scratch with the additional new example" << std::endl;
+  t.start(); 
+  
+  classifierRetrain.train ( fp, examples );  
+  
+  t.stop();  
+  std::cerr << "Time used for batch training: " << t.getLast() << std::endl;  
+  
+  //evaluate both and compare the resulting scores
+//  if ( verbose )
+    std::cerr << "testing ..." << std::endl;
+  for ( uint i = 0 ; i < vY.size() ; i++ )
+    if ( i % 2 == 0 )
+    {
+      Example example;
+      example.svec = new SparseVector;
+      example.svec->setDim(3);
+      example.svec->set ( 0, mX(i,0) );
+      example.svec->set ( 1, mX(i,1) );
+      example.svec->set ( 2, 1.0-mX(i,0)-mX(i,1) );
+      ClassificationResult resultIL = classifierIL.classify ( example );
+      ClassificationResult resultBatch = classifierRetrain.classify ( example );
+      
+      if (verbose)
+      {
+        std::cerr << "result of IL classifier: " << std::endl;
+        resultIL.scores >> std::cerr;
+        
+        std::cerr << "result of batch classifier: " << std::endl;
+        resultBatch.scores >> std::cerr;
+      }
+      
+      //scores are of type FullVector
+      //we use the [] operator, since there are no iterators given in FullVector.h
+      bool equal(true);
+      for (int i = 0; i< resultIL.scores.size(); i++)
+      {
+        if ( fabs(resultIL.scores[i] - resultBatch.scores[i]) > 10e-3)
+        {
+          equal = false;
+          break;
+        }        
+      }
+      
+      CPPUNIT_ASSERT_EQUAL ( equal, true ); 
+    } 
+
+  examples.clean();
+  
+  if (verboseStartEnd)
+    std::cerr << "================== TestFPCGPHIK::myClassifierILTest done ===================== " << std::endl;
+}
+
+void TestFPCGPHIK::testFPCGPHIK() 
+{
+  if (verboseStartEnd)
+    std::cerr << "================== TestFPCGPHIK::testFPCGPHIK ===================== " << std::endl;
+
+  Config conf;
+  conf.sD( "FPCGPHIK", "noise", 0.01 );
+  conf.sD( "FPCGPHIK", "parameter_lower_bound", 0.5 );
+  conf.sD( "FPCGPHIK", "parameter_upper_bound", 3.5 );
+  conf.sI( "FPCGPHIK", "uncertaintyPrediction", 1);
+//   conf.sS( "FPCGPHIK", "optimization_method", "none");
+  conf.sS( "FPCGPHIK", "optimization_method", "downhillsimplex");
+  conf.sB( "FPCGPHIK", "uncertaintyPredictionForClassification", true);
+
+  FPCGPHIK * classifier  = new FPCGPHIK ( &conf );
+  
+  Matrix mX;
+  Vector vY;
+  Vector vY_multi;
+
+//   ifstream ifs ("toyExample1.data", ios::in);
+//   ifstream ifs ("toyExampleLargeScale.data", ios::in);
+  ifstream ifs ("toyExampleLargeLargeScale.data", ios::in);
+  CPPUNIT_ASSERT ( ifs.good() );
+  ifs >> mX;
+  ifs >> vY;
+  ifs >> vY_multi;
+  ifs.close();
+  
+  if (verbose)
+  {
+    std::cerr << "data loaded: mX" << std::endl;
+    std::cerr << mX << std::endl;
+    std::cerr << "vY: " << std::endl;
+    std::cerr << vY << std::endl;
+    std::cerr << "vY_multi: " << std::endl;
+    std::cerr << vY_multi << std::endl;
+  }
+
+  if ( verbose )
+    std::cerr << "Binary classification test " << std::endl; 
+
+  myClassifierTest ( *classifier, mX, vY );
+  
+  // ... we remove nothing here since we are only interested in store and restore :)
+  myClassifierStoreRestoreTest ( *classifier, mX, vY );
+  
+  // ... remove previously computed things and start again, this time with incremental settings
+  if (classifier != NULL)
+    delete classifier;
+  
+  classifier  = new FPCGPHIK ( &conf );
+    FPCGPHIK * classifierBatch = new FPCGPHIK ( &conf ); 
+  
+  myClassifierILTest( *classifierBatch, *classifier, mX, vY );
+  
+  if (classifier != NULL)
+    delete classifier;
+  if (classifierBatch != NULL)
+    delete classifierBatch;
+  
+  classifier  = new FPCGPHIK ( &conf );
+  classifierBatch = new FPCGPHIK ( &conf );  
+
+  if ( verbose )
+    std::cerr << "Multi-class classification test " << std::endl; 
+  myClassifierTest ( *classifier, mX, vY_multi );
+  
+  // ... we remove nothing here since we are only interested and store and restore :)
+//   
+//   myClassifierStoreRestoreTest ( classifier, mX, vY_multi );
+  
+  // ... remove previously computed things and start again, this time with incremental settings
+  if (classifier != NULL)
+    delete classifier;
+  if (classifierBatch != NULL)
+    delete classifierBatch;
+  
+  classifier  = new FPCGPHIK ( &conf, "GPHIKClassifier" /* section */);
+  classifierBatch = new FPCGPHIK ( &conf, "GPHIKClassifier" /* section */ ); 
+  
+  myClassifierILTest( *classifierBatch, *classifier, mX, vY_multi );
+  
+  if (classifier != NULL)
+    delete classifier;
+  if (classifierBatch != NULL)
+    delete classifierBatch;  
+  
+  if (verboseStartEnd)
+    std::cerr << "================== TestFPCGPHIK::testFPCGPHIK done ===================== " << std::endl;
+ 
+}
+
+void TestFPCGPHIK::testGPHIKVariance()
+{
+  if (verboseStartEnd)
+    std::cerr << "================== TestFPCGPHIK::testGPHIKVariance ===================== " << std::endl;
+
+  double noise (0.01);
+  
+  Config conf;
+  conf.sD( "GPHIKClassifier", "noise", noise );
+  conf.sD( "GPHIKClassifier", "parameter_lower_bound", 1.0 );
+  conf.sD( "GPHIKClassifier", "parameter_upper_bound", 1.0 );
+  conf.sS( "GPHIKClassifier", "varianceApproximation", "approximate_rough");
+  conf.sB( "GPHIKClassifier", "learn_balanced", true);
+  conf.sB( "GPHIKClassifier", "uncertaintyPredictionForClassification", true);
+  
+  FPCGPHIK classifier ( &conf );
+  
+  Config confVarApproxQuant(conf);
+  confVarApproxQuant.sB( "GPHIKClassifier", "use_quantization", true );
+  FPCGPHIK classifierQuant ( &confVarApproxQuant );  
+
+  Config confVarApproxFine1(conf);
+  confVarApproxFine1.sS( "GPHIKClassifier", "varianceApproximation", "approximate_fine");  
+  confVarApproxFine1.sI( "GPHIKClassifier", "nrOfEigenvaluesToConsiderForVarApprox", 1);
+  
+  FPCGPHIK classifierVarApproxFine1 ( &confVarApproxFine1 );  
+
+  Config confVarApproxFine2(conf);
+  confVarApproxFine2.sS( "GPHIKClassifier", "varianceApproximation", "approximate_fine");    
+  confVarApproxFine2.sI( "GPHIKClassifier", "nrOfEigenvaluesToConsiderForVarApprox", 2);
+  
+  FPCGPHIK classifierVarApproxFine2 ( &confVarApproxFine2 );    
+  
+  Config confExact(conf);
+  confExact.sS( "GPHIKClassifier", "varianceApproximation", "exact");   
+  
+  FPCGPHIK classifierVarExact ( &confExact );
+  
+  NICE::Matrix mX;
+  NICE::Vector vY;
+  NICE::Vector vY_multi;
+
+  ifstream ifs ("toyExample2.data", ios::in);
+  CPPUNIT_ASSERT ( ifs.good() );
+  ifs >> mX;
+  ifs >> vY;
+  ifs >> vY_multi;
+  ifs.close();
+
+  if (verbose)
+  {
+    std::cerr << "data loaded: mX" << std::endl;
+    std::cerr << mX << std::endl;
+    std::cerr << "vY: " << std::endl;
+    std::cerr << vY << std::endl;
+    std::cerr << "vY_multi: " << std::endl;
+    std::cerr << vY_multi << std::endl;
+  }
+  
+  Examples examples;
+
+  for ( uint i = 0 ; i < vY.size() ; i++ )
+    if ( i % 2 == 0 )
+    {
+      Example example;
+      example.svec = new SparseVector;
+      example.svec->setDim(3);
+      example.svec->set ( 0, mX(i,0) );
+      example.svec->set ( 1, mX(i,1) );
+      example.svec->set ( 2, 1.0-mX(i,0)-mX(i,1) );
+      examples.push_back ( pair<int, Example> ( vY_multi[i], example ) );
+    }
+
+  FeaturePool fp; // will be ignored
+
+  if ( verbose )
+    std::cerr << "preparation for variance testing done." << std::endl;
+
+  if ( verbose ) 
+    std::cerr << "learning for variance testing ..." << std::endl;
+  classifier.train ( fp, examples ); 
+  classifierQuant.train ( fp, examples );
+  classifierVarApproxFine1.train ( fp, examples ); 
+  classifierVarApproxFine2.train ( fp, examples ); 
+  classifierVarExact.train ( fp, examples ); 
+
+  if ( verbose )
+    std::cerr << "testing for variance testing ..." << std::endl;
+  
+  for ( uint i = 0 ; i < vY_multi.size() ; i++ )
+    if ( i % 2 == 1 )
+    {
+      Example example;
+      example.svec = new SparseVector;
+      example.svec->setDim(3);
+      example.svec->set ( 0, mX(i,0) );
+      example.svec->set ( 1, mX(i,1) );
+      example.svec->set ( 2, 1.0-mX(i,0)-mX(i,1) );
+      ClassificationResult r = classifier.classify ( example );
+      ClassificationResult rQuant = classifierQuant.classify ( example );
+      ClassificationResult rVarApproxFine1 = classifierVarApproxFine1.classify ( example );
+      ClassificationResult rVarApproxFine2 = classifierVarApproxFine2.classify ( example );
+      ClassificationResult rExact = classifierVarExact.classify ( example );
+      
+      if (verbose)
+      {
+        std::cerr << "approxUnc: " << r.uncertainty << " approxUncQuant: " << rQuant.uncertainty<< " approxUncFine1: " << rVarApproxFine1.uncertainty << " approxUncFine2: " << rVarApproxFine2.uncertainty << " exactUnc: " << rExact.uncertainty << std::endl;
+      }
+
+      CPPUNIT_ASSERT ( r.uncertainty <=  (1.0 + noise) ); //using the "standard" HIK, this is the upper bound
+      CPPUNIT_ASSERT ( r.uncertainty >  rVarApproxFine1.uncertainty);
+      CPPUNIT_ASSERT ( rQuant.uncertainty >  rVarApproxFine1.uncertainty);
+      CPPUNIT_ASSERT ( rVarApproxFine1.uncertainty >  rVarApproxFine2.uncertainty);
+      CPPUNIT_ASSERT ( rVarApproxFine2.uncertainty >  rExact.uncertainty);
+      
+    } 
+
+  examples.clean();  
+  
+  
+  if (verboseStartEnd)
+    std::cerr << "================== TestFPCGPHIK::testGPHIKVariance done ===================== " << std::endl;
+  
+}
+
+#endif

classifier/fpclassifier/tests/TestFPCGPHIK.h

@@ -0,0 +1,31 @@
+#ifndef _TESTFPCGPHIK_H
+#define _TESTFPCGPHIK_H
+
+#include <cppunit/extensions/HelperMacros.h>
+
+/**
+ * CppUnit-Testcase. 
+ */
+class TestFPCGPHIK : public CppUnit::TestFixture {
+
+    CPPUNIT_TEST_SUITE( TestFPCGPHIK );
+    
+    CPPUNIT_TEST(testFPCGPHIK);
+    CPPUNIT_TEST(testGPHIKVariance);
+//     CPPUNIT_TEST(testGPHIKIncrementalLearning);
+    
+    CPPUNIT_TEST_SUITE_END();
+  
+ private:
+ 
+ public:
+    void setUp();
+    void tearDown();
+
+    void testFPCGPHIK();
+    void testGPHIKVariance();
+//     void testGPHIKIncrementalLearning();
+
+};
+
+#endif // _TESTFPCGPHIK_H

classifier/fpclassifier/tests/toyExample1.data

@@ -0,0 +1,42 @@
+39 x 2
+0.1394    0.3699
+0.1210    0.3260
+0.1164    0.2588
+0.1210    0.2032
+0.1417    0.1886
+0.1624    0.2325
+0.1624    0.3319
+0.1509    0.3114
+0.1417    0.2412
+0.1417    0.2763
+0.1279    0.3173
+0.3537    0.3582
+0.3306    0.3056
+0.3306    0.2471
+0.3376    0.2061
+0.3583    0.1740
+0.3698    0.1564
+0.3790    0.2558
+0.3744    0.3173
+0.3698    0.3406
+0.3583    0.2646
+0.3629    0.1944
+0.3468    0.3173
+0.3329    0.2588
+0.3514    0.1974
+0.2224    0.3436
+0.2270    0.3348
+0.2293    0.2675
+0.2339    0.2237
+0.2316    0.1623
+0.2408    0.1857
+0.2615    0.2763
+0.2638    0.3436
+0.2592    0.3904
+0.2477    0.4284
+0.2224    0.3582
+0.2177    0.2909
+0.2224    0.2178
+0.2500    0.1213
+39 < 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 >
+39 < 0 0 0 0 0 0 0 0 0 0 0 3 3 3 3 3 3 3 3 3 3 3 3 3 3 1 1 1 1 1 1 1 1 1 1 1 1 1 1 >

classifier/fpclassifier/tests/toyExample2.data

@@ -0,0 +1,9 @@
+6 x 2
+0.1    0.3
+0.1    0.2
+0.3    0.3
+0.2    0.2
+0.4    0.1
+0.1    0.5
+6 < 0 0 0 1 1 1 >
+6 < 0 0 3 3 1 1 >

classifier/fpclassifier/tests/toyExampleLargeScale.data

@@ -0,0 +1,604 @@
+600 x 2
+0.342689 0.175671 
+0.30934 0.268245 
+0.283338 0.31431 
+0.322194 0.211048 
+0.27985 0.217818 
+0.253954 0.195404 
+0.435345 0.125535 
+0.312486 0.137852 
+0.268998 0.2357 
+0.254516 0.213503 
+0.315574 0.130796 
+0.39208 0.178418 
+0.262966 0.128216 
+0.258793 0.151603 
+0.32426 0.234761 
+0.292135 0.138279 
+0.331166 0.145197 
+0.3395 0.169078 
+0.283081 0.134257 
+0.2829 0.147042 
+0.257692 0.28673 
+0.31662 0.209292 
+0.274172 0.194507 
+0.368124 0.127353 
+0.378173 0.236568 
+0.313633 0.166162 
+0.308659 0.154215 
+0.307818 0.180172 
+0.306022 0.194493 
+0.256317 0.182305 
+0.253279 0.138247 
+0.286522 0.154934 
+0.343294 0.296202 
+0.435882 0.149799 
+0.266064 0.141986 
+0.362818 0.130809 
+0.424555 0.154075 
+0.312223 0.176338 
+0.346151 0.185167 
+0.303702 0.224405 
+0.250913 0.27087 
+0.278182 0.187886 
+0.305441 0.161418 
+0.390785 0.176948 
+0.419366 0.139879 
+0.298091 0.134676 
+0.311699 0.242829 
+0.293336 0.238481 
+0.349461 0.179128 
+0.294253 0.191256 
+0.255692 0.154904 
+0.273268 0.193811 
+0.376241 0.206254 
+0.329721 0.17215 
+0.331964 0.234789 
+0.335461 0.186645 
+0.296782 0.158248 
+0.368493 0.148484 
+0.255566 0.188169 
+0.343617 0.135276 
+0.252996 0.204645 
+0.285394 0.333677 
+0.313484 0.175742 
+0.250342 0.203408 
+0.266606 0.188748 
+0.283449 0.129172 
+0.340621 0.179734 
+0.315654 0.199744 
+0.27226 0.134784 
+0.296711 0.185527 
+0.253752 0.198492 
+0.257381 0.257684 
+0.346152 0.220506 
+0.36263 0.183317 
+0.278849 0.181596 
+0.301625 0.247397 
+0.318059 0.23282 
+0.271193 0.143659 
+0.40265 0.205326 
+0.457977 0.223787 
+0.277921 0.132572 
+0.44805 0.266026 
+0.292541 0.133553 
+0.320695 0.152126 
+0.293894 0.132603 
+0.310329 0.158675 
+0.308961 0.228526 
+0.310193 0.201196 
+0.357398 0.276934 
+0.362411 0.134546 
+0.252874 0.249074 
+0.323796 0.231816 
+0.258442 0.173894 
+0.343986 0.134667 
+0.356016 0.163639 
+0.322109 0.210639 
+0.28522 0.223836 
+0.396437 0.198424 
+0.283134 0.21192 
+0.279188 0.215173 
+0.260586 0.22736 
+0.329615 0.19164 
+0.339912 0.133774 
+0.257242 0.151432 
+0.353614 0.163562 
+0.332978 0.182046 
+0.302671 0.248665 
+0.259309 0.151224 
+0.318917 0.240108 
+0.344637 0.135684 
+0.256466 0.283143 
+0.356169 0.209122 
+0.251218 0.224075 
+0.424779 0.215246 
+0.372904 0.150395 
+0.428672 0.125709 
+0.391982 0.182144 
+0.26703 0.265749 
+0.266772 0.152864 
+0.418837 0.250821 
+0.303323 0.235758 
+0.311233 0.15944 
+0.390081 0.292144 
+0.289179 0.154131 
+0.269899 0.233753 
+0.292143 0.269953 
+0.389615 0.181187 
+0.281855 0.168289 
+0.355694 0.130023 
+0.258038 0.191685 
+0.322198 0.160255 
+0.265639 0.205397 
+0.266359 0.195618 
+0.291999 0.161498 
+0.287761 0.170072 
+0.264713 0.332262 
+0.294721 0.140154 
+0.273594 0.165844 
+0.310086 0.169887 
+0.341029 0.225881 
+0.316856 0.137035 
+0.300842 0.221668 
+0.301447 0.210899 
+0.292541 0.135141 
+0.282796 0.135598 
+0.267783 0.151061 
+0.461684 0.192769 
+0.311754 0.238481 
+0.252301 0.171746 
+0.370648 0.194599 
+0.363942 0.159229 
+0.353153 0.187895 
+0.343755 0.214295 
+0.35249 0.132681 
+0.321514 0.191171 
+0.32338 0.135597 
+0.365625 0.141555 
+0.33572 0.236221 
+0.255242 0.240287 
+0.272454 0.25177 
+0.260317 0.137604 
+0.293878 0.138076 
+0.262748 0.191504 
+0.329031 0.143135 
+0.338375 0.250212 
+0.345667 0.147506 
+0.309146 0.198383 
+0.282595 0.295251 
+0.262683 0.15159 
+0.296848 0.163558 
+0.264113 0.274616 
+0.338641 0.211817 
+0.259174 0.264645 
+0.330357 0.20687 
+0.353817 0.22874 
+0.269664 0.226656 
+0.252154 0.148463 
+0.366193 0.150144 
+0.256898 0.245194 
+0.304303 0.183618 
+0.335466 0.151312 
+0.262861 0.200441 
+0.262813 0.252586 
+0.313346 0.194787 
+0.289579 0.247262 
+0.286535 0.23699 
+0.310318 0.142124 
+0.341106 0.206294 
+0.273167 0.156972 
+0.269453 0.187743 
+0.355513 0.183233 
+0.263025 0.199449 
+0.313509 0.331514 
+0.311078 0.252023 
+0.281887 0.26323 
+0.255329 0.173521 
+0.300729 0.214255 
+0.286228 0.136099 
+0.299626 0.157784 
+0.271569 0.22316 
+0.300825 0.303776 
+0.27322 0.25126 
+0.176006 0.402724 
+0.226378 0.348555 
+0.168946 0.262155 
+0.139945 0.341302 
+0.141302 0.305834 
+0.15167 0.264065 
+0.13236 0.287971 
+0.259065 0.450122 
+0.167671 0.301213 
+0.232472 0.315405 
+0.318855 0.278831 
+0.149421 0.336895 
+0.167089 0.266261 
+0.125286 0.322987 
+0.186744 0.359308 
+0.181219 0.298146 
+0.162008 0.412922 
+0.142068 0.288868 
+0.20133 0.317385 
+0.152729 0.340693 
+0.156914 0.393993 
+0.151577 0.271511 
+0.137218 0.435257 
+0.135001 0.288495 
+0.233009 0.308706 
+0.253521 0.278079 
+0.126533 0.327627 
+0.129093 0.344601 
+0.271354 0.292011 
+0.228235 0.290139 
+0.213721 0.357127 
+0.152746 0.388868 
+0.137812 0.376055 
+0.247148 0.391889 
+0.199338 0.316814 
+0.19992 0.434137 
+0.265019 0.338816 
+0.138767 0.355017 
+0.139752 0.313471 
+0.217796 0.265376 
+0.152899 0.257636 
+0.248653 0.313653 
+0.154939 0.31371 
+0.235854 0.259526 
+0.165171 0.300912 
+0.246794 0.338431 
+0.203588 0.363351 
+0.155485 0.377965 
+0.211843 0.290398 
+0.306505 0.385808 
+0.261773 0.398547 
+0.194004 0.282203 
+0.176261 0.26052 
+0.188294 0.343489 
+0.234243 0.430868 
+0.181933 0.355282 
+0.170154 0.350051 
+0.161818 0.263494 
+0.302773 0.265246 
+0.168825 0.310823 
+0.164394 0.423268 
+0.29166 0.35488 
+0.271975 0.386961 
+0.296484 0.309649 
+0.196042 0.314222 
+0.145605 0.298324 
+0.255544 0.452838 
+0.189474 0.312347 
+0.176208 0.272894 
+0.16492 0.380216 
+0.187287 0.414524 
+0.178578 0.294622 
+0.278798 0.27663 
+0.132288 0.296908 
+0.254925 0.33015 
+0.350185 0.258513 
+0.16647 0.387784 
+0.155536 0.261762 
+0.31289 0.421124 
+0.1639 0.278125 
+0.299235 0.435447 
+0.126134 0.307695 
+0.163839 0.313053 
+0.143585 0.53421 
+0.162566 0.331135 
+0.220753 0.256421 
+0.219454 0.4336 
+0.19769 0.37137 
+0.131795 0.403685 
+0.180282 0.261803 
+0.196382 0.262449 
+0.20367 0.318381 
+0.130772 0.333474 
+0.180841 0.299823 
+0.214484 0.290828 
+0.138715 0.341963 
+0.251411 0.39227 
+0.125156 0.30578 
+0.266808 0.337032 
+0.240964 0.331971 
+0.175375 0.294612 
+0.179172 0.366302 
+0.147287 0.296443 
+0.164014 0.261311 
+0.273203 0.254742 
+0.136849 0.28521 
+0.213123 0.34695 
+0.173496 0.325799 
+0.292193 0.255454 
+0.138616 0.33484 
+0.25335 0.300546 
+0.158688 0.311034 
+0.145169 0.361547 
+0.128574 0.270011 
+0.15352 0.26367 
+0.159877 0.378762 
+0.140396 0.433171 
+0.133033 0.290889 
+0.163508 0.271152 
+0.210289 0.291615 
+0.14189 0.280736 
+0.149909 0.292447 
+0.180142 0.266672 
+0.144982 0.277738 
+0.159478 0.274755 
+0.164206 0.442762 
+0.178133 0.262889 
+0.166155 0.348706 
+0.290175 0.379262 
+0.154984 0.394628 
+0.250925 0.259417 
+0.141829 0.286385 
+0.173571 0.32318 
+0.155138 0.334199 
+0.19025 0.284642 
+0.132157 0.273714 
+0.169887 0.327512 
+0.231932 0.328859 
+0.163281 0.304052 
+0.145319 0.36004 
+0.144163 0.303037 
+0.158192 0.259722 
+0.198438 0.331068 
+0.127219 0.323939 
+0.155833 0.30954 
+0.190242 0.28389 
+0.199135 0.277733 
+0.321694 0.453193 
+0.141441 0.268926 
+0.281311 0.338708 
+0.189104 0.267739 
+0.133845 0.310823 
+0.209767 0.418156 
+0.297319 0.297564 
+0.161189 0.259427 
+0.213576 0.457596 
+0.270751 0.290435 
+0.201792 0.389826 
+0.135373 0.254834 
+0.133443 0.307913 
+0.146304 0.263914 
+0.254784 0.28866 
+0.205916 0.275338 
+0.196961 0.277155 
+0.239999 0.304274 
+0.172131 0.28929 
+0.145521 0.255641 
+0.25942 0.282277 
+0.167205 0.260999 
+0.169453 0.345352 
+0.255941 0.301047 
+0.264722 0.378455 
+0.133553 0.308037 
+0.137054 0.309238 
+0.20074 0.274192 
+0.250793 0.336116 
+0.162476 0.296901 
+0.137098 0.250421 
+0.193241 0.277141 
+0.185979 0.273677 
+0.17511 0.379876 
+0.149684 0.265748 
+0.225099 0.317336 
+0.132403 0.250674 
+0.13283 0.294247 
+0.158449 0.338396 
+0.252054 0.266546 
+0.154258 0.287316 
+0.223787 0.363484 
+0.160883 0.270353 
+0.152975 0.283687 
+0.237612 0.267854 
+0.18717 0.29144 
+0.174165 0.34938 
+0.165426 0.355092 
+0.287473 0.27884 
+0.128887 0.361068 
+0.179211 0.299544 
+0.215031 0.155091 
+0.142583 0.193322 
+0.276808 0.171428 
+0.1541 0.183927 
+0.194681 0.127557 
+0.128295 0.150629 
+0.235294 0.134568 
+0.201284 0.162832 
+0.314834 0.212242 
+0.142952 0.303737 
+0.195 0.152865 
+0.287761 0.163026 
+0.156109 0.155853 
+0.20319 0.275679 
+0.154476 0.216572 
+0.141193 0.151162 
+0.178573 0.150035 
+0.289051 0.328297 
+0.174799 0.175858 
+0.166596 0.15483 
+0.248603 0.15139 
+0.189713 0.18169 
+0.256645 0.128374 
+0.137268 0.213468 
+0.152469 0.125282 
+0.178565 0.209226 
+0.170197 0.194244 
+0.205242 0.14935 
+0.197247 0.173981 
+0.222782 0.185638 
+0.255122 0.138357 
+0.137221 0.181269 
+0.162759 0.136556 
+0.126264 0.173721 
+0.250943 0.187721 
+0.153073 0.14711 
+0.219836 0.248307 
+0.190877 0.288343 
+0.210659 0.223544 
+0.162835 0.133229 
+0.349274 0.263972 
+0.191313 0.167455 
+0.14183 0.183345 
+0.171238 0.243158 
+0.236826 0.155454 
+0.192282 0.141581 
+0.155562 0.137083 
+0.168371 0.216514 
+0.207958 0.286036 
+0.12849 0.227428 
+0.140926 0.162835 
+0.159604 0.134924 
+0.316663 0.133871 
+0.150814 0.125524 
+0.133106 0.196074 
+0.149622 0.144502 
+0.15218 0.196792 
+0.1625 0.220862 
+0.265263 0.279839 
+0.192861 0.147449 
+0.275367 0.136736 
+0.125005 0.217594 
+0.157708 0.130746 
+0.137828 0.2188 
+0.205963 0.284573 
+0.314706 0.265755 
+0.223344 0.184088 
+0.23382 0.250284 
+0.213944 0.131451 
+0.298037 0.21233 
+0.161291 0.127927 
+0.141618 0.222095 
+0.139736 0.286058 
+0.220316 0.175143 
+0.231751 0.134027 
+0.169706 0.258055 
+0.260142 0.143679 
+0.217887 0.240266 
+0.131439 0.174702 
+0.214523 0.15396 
+0.1768 0.227648 
+0.224522 0.230168 
+0.16444 0.13183 
+0.187441 0.266578 
+0.150256 0.169155 
+0.224854 0.163051 
+0.258784 0.161583 
+0.210855 0.186293 
+0.125887 0.30692 
+0.131581 0.155051 
+0.146777 0.145637 
+0.351453 0.17521 
+0.212764 0.187016 
+0.191882 0.18859 
+0.188817 0.224918 
+0.150217 0.141471 
+0.296471 0.317944 
+0.227911 0.172533 
+0.254149 0.182712 
+0.182149 0.212013 
+0.178375 0.191318 
+0.148463 0.174887 
+0.216658 0.261188 
+0.127068 0.215572 
+0.181236 0.211954 
+0.171546 0.137991 
+0.228025 0.188707 
+0.140536 0.254658 
+0.249636 0.130417 
+0.182512 0.229795 
+0.212421 0.228258 
+0.165297 0.137963 
+0.298921 0.147804 
+0.235353 0.280178 
+0.289942 0.15012 
+0.146599 0.23232 
+0.142329 0.161157 
+0.270889 0.212884 
+0.163608 0.134177 
+0.156306 0.230362 
+0.187909 0.144162 
+0.253675 0.15226 
+0.277975 0.241759 
+0.132958 0.140637 
+0.132167 0.281881 
+0.14486 0.179008 
+0.14129 0.173667 
+0.13792 0.196095 
+0.144878 0.181669 
+0.270531 0.275731 
+0.220914 0.170835 
+0.166041 0.191592 
+0.169549 0.195291 
+0.291418 0.174062 
+0.132584 0.211085 
+0.180231 0.238647 
+0.145224 0.208966 
+0.372008 0.140979 
+0.129183 0.246742 
+0.214086 0.129494 
+0.157116 0.270378 
+0.141035 0.149166 
+0.162474 0.246944 
+0.13349 0.206489 
+0.132278 0.182272 
+0.216111 0.187533 
+0.220175 0.300967 
+0.167512 0.145929 
+0.168184 0.321369 
+0.133267 0.234592 
+0.229341 0.131162 
+0.257111 0.218668 
+0.333441 0.333555 
+0.133784 0.186297 
+0.287145 0.18554 
+0.139222 0.142987 
+0.150074 0.223927 
+0.214144 0.1276 
+0.25632 0.226794 
+0.156132 0.185504 
+0.159565 0.135037 
+0.196861 0.22244 
+0.211956 0.176154 
+0.148823 0.188648 
+0.203664 0.150215 
+0.218453 0.216136 
+0.262688 0.1386 
+0.186142 0.217442 
+0.148249 0.21515 
+0.199327 0.125026 
+0.182995 0.187074 
+0.196654 0.246484 
+0.224754 0.176581 
+0.130524 0.173274 
+0.177737 0.137875 
+0.187153 0.126132 
+0.178623 0.232132 
+0.187313 0.153289 
+0.155405 0.143394 
+0.218375 0.326502 
+0.137907 0.187893 
+0.149386 0.260504 
+0.193591 0.134313 
+0.239484 0.221013 
+0.175538 0.146035 
+0.197115 0.160234 
+0.175092 0.211225 
+0.137077 0.129546 
+0.172193 0.304747 
+0.167678 0.208687 
+0.267804 0.163603 
+0.154224 0.12527 
+0.163461 0.150108 
+0.148395 0.22809 
+0.24221 0.142793 
+0.210785 0.228961 
+0.160274 0.131187 
+0.250532 0.191618 
+0.184075 0.192361 
+0.211521 0.193562 
+
+600 < 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 >
+600 < 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 >

classifier/genericClassifierSelection.h

@@ -1,8 +1,14 @@
 #ifndef _NICE_OBJREC_GENERICCLASSIFIERSELECTION_INCLUDE
 #define _NICE_OBJREC_GENERICCLASSIFIERSELECTION_INCLUDE
 
+//STL
+#include <vector>
+
+//core
 #include "core/basics/StringTools.h"
 
+
+//vislearning  -- vector classifiers
 #include "vislearning/classifier/vclassifier/VCAmitSVM.h"
 #include "vislearning/classifier/vclassifier/VCNearestClassMean.h"
 #include "vislearning/classifier/vclassifier/VCSimpleGaussian.h"
@@ -12,18 +18,9 @@
 #include "vislearning/classifier/vclassifier/VCOneVsOne.h"
 #include "vislearning/classifier/vclassifier/VCOneVsAll.h"
 #include "vislearning/classifier/vclassifier/VCDTSVM.h"
+#include "vislearning/classifier/vclassifier/VCTransform.h"
 
-
-#ifdef NICE_USELIB_SVMLIGHT
-#include "vislearning/classifier/vclassifier/VCSVMLight.h"
-#include "vislearning/classifier/kernelclassifier/KCSVMLight.h"
-#include "vislearning/classifier/vclassifier/VCSVMOneClass.h"
-#endif
-
-#ifdef NICE_USELIB_NICEDTSVM
-#include "nice-dtsvm/VCTreeBasedClassifier.h"
-#endif
-
+//vislearning -- kernel classifiers
 #include "vislearning/classifier/kernelclassifier/KCGPRegression.h"
 #include "vislearning/classifier/kernelclassifier/KCGPLaplace.h"
 #include "vislearning/classifier/kernelclassifier/KCGPLaplaceOneVsAll.h"
@@ -31,22 +28,43 @@
 #include "vislearning/classifier/kernelclassifier/KCGPRegOneVsAll.h"
 #include "vislearning/classifier/kernelclassifier/KCMinimumEnclosingBall.h"
 #include "vislearning/classifier/kernelclassifier/KCGPOneClass.h"
+
+//vislearning -- kernels
 #include "vislearning/math/kernels/KernelStd.h"
 #include "vislearning/math/kernels/KernelExp.h"
 #include "vislearning/math/kernels/KernelRBF.h"
+#include "vislearning/math/kernels/genericKernel.h"
 
-#include "vislearning/classifier/vclassifier/VCTransform.h"
-
+//vislearning -- feature pool classifier
 #include "vislearning/classifier/fpclassifier/boosting/FPCBoosting.h"
 #include "vislearning/classifier/fpclassifier/randomforest/FPCRandomForests.h"
 #include "vislearning/classifier/fpclassifier/randomforest/FPCDecisionTree.h"
 #include "vislearning/classifier/fpclassifier/logisticregression/FPCSMLR.h"
+#include "vislearning/classifier/fpclassifier/FPCGPHIK.h"
 
+//vislearning -- classifier combinations
 #include "vislearning/classifier/classifiercombination/VCPreRandomForest.h"
 
-#include "vislearning/math/kernels/genericKernel.h"
 
-#include <vector>
+//vislearning -- SVM-based classifiers (vclassifier, kernelclassifier)
+#ifdef NICE_USELIB_SVMLIGHT
+#include "vislearning/classifier/vclassifier/VCSVMLight.h"
+#include "vislearning/classifier/vclassifier/VCSVMOneClass.h"
+#include "vislearning/classifier/kernelclassifier/KCSVMLight.h"
+#endif
+
+//external stuff
+#ifdef NICE_USELIB_NICEDTSVM
+#include "nice-dtsvm/VCTreeBasedClassifier.h"
+#endif
+
+// #include "gp-hik-exp/GPHIKClassifierNICE.h"
+
+
+
+
+
+
 
 namespace OBJREC {
 
@@ -69,11 +87,21 @@ class GenericClassifierSelection
      } else if ( classifier_type == "nearest_classmean" ) {
         classifier = new VCNearestClassMean( conf, new NICE::EuclidianDistance<double>() );
 #endif
-      } else if ( classifier_type == "random_forest" ) {
+      }
+      ////////////////////////////////////////
+      //                                    //
+      //    all Feature Pool Classifiers    //
+      //                                    //
+      ////////////////////////////////////////
+      else if ( classifier_type == "GPHIK" ) {
+        FeaturePoolClassifier *fpc = new FPCGPHIK ( conf, "GPHIK" );
+        classifier = new VCFeaturePool ( conf, fpc );
+      }      
+      else if ( classifier_type == "random_forest" ) {
         FeaturePoolClassifier *fpc = new FPCRandomForests ( conf, "RandomForest" );
         classifier = new VCFeaturePool ( conf, fpc );
-
-      } else if ( classifier_type == "sparse_logistic_regression" ) {
+      }
+      else if ( classifier_type == "sparse_logistic_regression" ) {
         FeaturePoolClassifier *fpc = new FPCSMLR ( conf, "SparseLogisticRegression" );
         classifier = new VCFeaturePool ( conf, fpc );
 

classifier/kernelclassifier/KCGPRegOneVsAll.cpp

@@ -1,4 +1,4 @@
-/** 
+/**
 * @file KCGPRegOneVsAll.cpp
 * @brief One vs. All interface for kernel classifiers
 * @author Erik Rodner
@@ -32,182 +32,182 @@ using namespace std;
 using namespace OBJREC;
 
 KCGPRegOneVsAll::KCGPRegOneVsAll( const Config *conf, Kernel *kernelFunction, const string & section )
-	: KernelClassifier ( conf, kernelFunction )
+    : KernelClassifier ( conf, kernelFunction )
 {
-	this->maxClassNo = 0;
-	this->verbose = conf->gB( section, "verbose", false );
-	this->optimizeParameters = (kernelFunction == NULL) ? false : conf->gB( section, "optimize_parameters", true );
-	this->maxIterations = conf->gI( section, "optimization_maxiterations", 500 );
-	this->numSamplesCalibration = conf->gI( section, "calibrated_probabilities_numsamples", 2000 );
-	this->calibrateProbabilities = conf->gB( section, "calibrated_probabilities", false );
-	if ( verbose && this->calibrateProbabilities )
-		cerr << "KCGPRegOneVsAll: probability calibration is turned on, this can result in massive additional load!" << endl;
-
-	// we do joint optimization, therefore single classifiers (cloned from prototype)
-	// are not allowed to do optimization themselves
-	Config confNoOptimize ( *conf );
-	confNoOptimize.sB( section, "optimize_parameters", false );
-	this->prototype = new RegGaussianProcess ( &confNoOptimize, kernelFunction, section ); 
-
-	// Do not use this option, unless you know what you are doing!
-	// This function is just necessary for hyperparameter optimization with really large
-	// kernel matrices of a kronecker structure!
-	bool approximateTraceTerm = conf->gB(section, "approximate_trace_term", false);
-	if ( approximateTraceTerm ) 
-		traceApproximation = new TraceApproximation ( conf, section );
-	else
-		traceApproximation = NULL;
-
-	// select final hyperparameters according to leave-one-out
-	useLooParameters = conf->gB(section, "use_loo_parameters", false );
-	
-	// select the criterion
-	modelselcrit = NULL;
-	if ( useLooParameters ) {
-		string modelselcrit_s = conf->gS(section, "loo_crit", "loo_pred_prob" );
-		modelselcrit = GenericGPModelSelection::selectModelSel ( conf, modelselcrit_s );
-		cerr << "KCGPRegOneVsAll: using additional model selection criterion " << modelselcrit_s << endl;
-	}
-
-	// do we want to compute the uncertainty of the estimate ?
-	computeUncertainty = conf->gB(section, "compute_uncertainty", false );
+  this->maxClassNo = 0;
+  this->verbose = conf->gB( section, "verbose", false );
+  this->optimizeParameters = (kernelFunction == NULL) ? false : conf->gB( section, "optimize_parameters", true );
+  this->maxIterations = conf->gI( section, "optimization_maxiterations", 500 );
+  this->numSamplesCalibration = conf->gI( section, "calibrated_probabilities_numsamples", 2000 );
+  this->calibrateProbabilities = conf->gB( section, "calibrated_probabilities", false );
+  if ( verbose && this->calibrateProbabilities )
+    cerr << "KCGPRegOneVsAll: probability calibration is turned on, this can result in massive additional load!" << endl;
+
+  // we do joint optimization, therefore single classifiers (cloned from prototype)
+  // are not allowed to do optimization themselves
+  Config confNoOptimize ( *conf );
+  confNoOptimize.sB( section, "optimize_parameters", false );
+  this->prototype = new RegGaussianProcess ( &confNoOptimize, kernelFunction, section );
+
+  // Do not use this option, unless you know what you are doing!
+  // This function is just necessary for hyperparameter optimization with really large
+  // kernel matrices of a kronecker structure!
+  bool approximateTraceTerm = conf->gB(section, "approximate_trace_term", false);
+  if ( approximateTraceTerm )
+    traceApproximation = new TraceApproximation ( conf, section );
+  else
+    traceApproximation = NULL;
+
+  // select final hyperparameters according to leave-one-out
+  useLooParameters = conf->gB(section, "use_loo_parameters", false );
+
+  // select the criterion
+  modelselcrit = NULL;
+  if ( useLooParameters ) {
+    string modelselcrit_s = conf->gS(section, "loo_crit", "loo_pred_prob" );
+    modelselcrit = GenericGPModelSelection::selectModelSel ( conf, modelselcrit_s );
+    cerr << "KCGPRegOneVsAll: using additional model selection criterion " << modelselcrit_s << endl;
+  }
+
+  // do we want to compute the uncertainty of the estimate ?
+  computeUncertainty = conf->gB(section, "compute_uncertainty", false );
 }
 
 KCGPRegOneVsAll::KCGPRegOneVsAll( const KCGPRegOneVsAll &vcova ): KernelClassifier(vcova)
 {
-	prototype = vcova.prototype->clone();
-	optimizeParameters = vcova.optimizeParameters;
-	verbose = vcova.verbose;
-	maxIterations = vcova.maxIterations;
-	useLooParameters = vcova.useLooParameters;
-	computeUncertainty = vcova.computeUncertainty;
-	choleskyMatrix = vcova.choleskyMatrix;
-	calibrateProbabilities = vcova.calibrateProbabilities;
-	numSamplesCalibration = vcova.numSamplesCalibration;
-	
-	for(int i = 0; i < (int)vcova.classifiers.size(); i++)
-	{
-		classifiers.push_back(pair<int, RegGaussianProcess*>(vcova.classifiers[i].first,vcova.classifiers[i].second->clone()));
-	}
-
-	if ( vcova.traceApproximation == NULL )
-		traceApproximation = NULL;
-	else
-		traceApproximation = new TraceApproximation(*vcova.traceApproximation);
-
-	if ( vcova.modelselcrit == NULL )
-		modelselcrit = NULL;
-	else
-		modelselcrit = new GPMSCLooLikelihoodRegression(*vcova.modelselcrit);
+  prototype = vcova.prototype->clone();
+  optimizeParameters = vcova.optimizeParameters;
+  verbose = vcova.verbose;
+  maxIterations = vcova.maxIterations;
+  useLooParameters = vcova.useLooParameters;
+  computeUncertainty = vcova.computeUncertainty;
+  choleskyMatrix = vcova.choleskyMatrix;
+  calibrateProbabilities = vcova.calibrateProbabilities;
+  numSamplesCalibration = vcova.numSamplesCalibration;
+
+  for (int i = 0; i < (int)vcova.classifiers.size(); i++)
+  {
+    classifiers.push_back(pair<int, RegGaussianProcess*>(vcova.classifiers[i].first, vcova.classifiers[i].second->clone()));
+  }
+
+  if ( vcova.traceApproximation == NULL )
+    traceApproximation = NULL;
+  else
+    traceApproximation = new TraceApproximation(*vcova.traceApproximation);
+
+  if ( vcova.modelselcrit == NULL )
+    modelselcrit = NULL;
+  else
+    modelselcrit = new GPMSCLooLikelihoodRegression(*vcova.modelselcrit);
 }
 
 KCGPRegOneVsAll::~KCGPRegOneVsAll()
 {
-	if ( traceApproximation != NULL )
-		delete traceApproximation;
-	if ( modelselcrit != NULL )
-		delete modelselcrit;
+  if ( traceApproximation != NULL )
+    delete traceApproximation;
+  if ( modelselcrit != NULL )
+    delete modelselcrit;
 }
 
 void KCGPRegOneVsAll::teach ( KernelData *kernelData, const NICE::Vector & y )
 {
-	maxClassNo = (int)y.Max();
-
-	set<int> classesUsed;
-	for ( uint i = 0 ; i < y.size(); i++ )
-		classesUsed.insert ( (int)y[i] );
-	
-	classifiers.clear();
-
-	VVector ySet;
-	VVector ySetZeroMean;
-	for ( set<int>::const_iterator it = classesUsed.begin();
-		it != classesUsed.end(); it++)
-	{
-		int i = *it;
-
-		NICE::Vector ySub ( y.size() );
-		NICE::Vector ySubZeroMean ( y.size() );
-		for ( size_t j = 0 ; j < ySub.size() ; j++ )
-		{
-			ySub[j] = ((int)y[j] == i) ? 1 : 0;
-			ySubZeroMean[j] = ((int)y[j] == i) ? 1 : -1;
-		}
-		ySet.push_back ( ySub );
-		ySetZeroMean.push_back ( ySubZeroMean );
-	}
-
-	// Hyperparameter optimization
-	if ( optimizeParameters ) 
-	{
-		ParameterizedKernel *kernelPara = dynamic_cast< ParameterizedKernel * > ( kernelFunction );
-		if ( kernelPara == NULL ) {
-			fthrow(Exception, "KCGPRegOneVsAll: you have to specify a parameterized kernel !");
-		}
-		GPRegressionOptimizationProblem gpopt ( kernelData, ySetZeroMean, kernelPara, verbose, modelselcrit, traceApproximation );
-
-		// the trust region classifier is better for my large collection of one classification problem :)
-		// FirstOrderRasmussen optimizer;
-		FirstOrderTrustRegion optimizer;
-		optimizer.setMaxIterations ( maxIterations );
-		optimizer.setEpsilonG ( 0.01 );
-
-		cout << "KCGPRegOneVsAll: Hyperparameter optimization ..." << endl;
-		optimizer.optimizeFirst ( gpopt );
-		cout << "KCGPRegOneVsAll: Hyperparameter optimization ...done" << endl;
-	
-		if ( useLooParameters ) 
-		{
-			cerr << "KCGPRegOneVsAll: using best loo parameters" << endl;
-			gpopt.useLooParameters();
-		}
-
-		gpopt.update();
-
-		Vector parameters;
-		kernelPara->getParameters ( parameters );
-		cout << "KCGPRegOneVsAll: Optimization finished: " << parameters << endl << endl;
-	} else {
-		kernelData->updateCholeskyFactorization();
-	}
-	
-	//for binary problems
-	if(classesUsed.size() == 2 && false)
-	{
-		set<int>::const_iterator it = classesUsed.begin();
-		int classno = *it;
-		it++;
-		int classno2 = *it;
-		const Vector & ySub = ySet[0];
-		RegGaussianProcess *classifier;
-		classifier = prototype->clone();
-		if (verbose)
-			fprintf (stderr, "KCGPRegOneVsAll: training classifier class %d <-> %d\n", classno, classno2 );
-		classifier->teach ( kernelData, ySub );
-		classifiers.push_back ( pair<int, RegGaussianProcess*> (classno, classifier) );
-		classifiers.push_back ( pair<int, RegGaussianProcess*> (classno2, classifier) );
-	}
-	else
-	{
-		int i = 0;
-		for ( set<int>::const_iterator it = classesUsed.begin(); it != classesUsed.end(); it++,i++)
-		{
-			int classno = *it;
-			const Vector & ySub = ySet[i];
-			RegGaussianProcess *classifier;
-			classifier = prototype->clone();
-	
-			if (verbose)
-				fprintf (stderr, "KCGPRegOneVsAll: training classifier class %d <-> remainder\n", classno );
-	
-			classifier->teach ( kernelData, ySub );
-
-			classifiers.push_back ( pair<int, RegGaussianProcess*> (classno, classifier) );
-		}
-	}
-
-	if ( computeUncertainty || calibrateProbabilities )
-		choleskyMatrix = kernelData->getCholeskyMatrix();
+  maxClassNo = (int)y.Max();
+
+  set<int> classesUsed;
+  for ( uint i = 0 ; i < y.size(); i++ )
+    classesUsed.insert ( (int)y[i] );
+
+  classifiers.clear();
+
+  VVector ySet;
+  VVector ySetZeroMean;
+  for ( set<int>::const_iterator it = classesUsed.begin();
+        it != classesUsed.end(); it++)
+  {
+    int i = *it;
+
+    NICE::Vector ySub ( y.size() );
+    NICE::Vector ySubZeroMean ( y.size() );
+    for ( size_t j = 0 ; j < ySub.size() ; j++ )
+    {
+      ySub[j] = ((int)y[j] == i) ? 1 : 0;
+      ySubZeroMean[j] = ((int)y[j] == i) ? 1 : -1;
+    }
+    ySet.push_back ( ySub );
+    ySetZeroMean.push_back ( ySubZeroMean );
+  }
+
+  // Hyperparameter optimization
+  if ( optimizeParameters )
+  {
+    ParameterizedKernel *kernelPara = dynamic_cast< ParameterizedKernel * > ( kernelFunction );
+    if ( kernelPara == NULL ) {
+      fthrow(Exception, "KCGPRegOneVsAll: you have to specify a parameterized kernel !");
+    }
+    GPRegressionOptimizationProblem gpopt ( kernelData, ySetZeroMean, kernelPara, verbose, modelselcrit, traceApproximation );
+
+    // the trust region classifier is better for my large collection of one classification problem :)
+    // FirstOrderRasmussen optimizer;
+    FirstOrderTrustRegion optimizer;
+    optimizer.setMaxIterations ( maxIterations );
+    optimizer.setEpsilonG ( 0.01 );
+
+    cout << "KCGPRegOneVsAll: Hyperparameter optimization ..." << endl;
+    optimizer.optimizeFirst ( gpopt );
+    cout << "KCGPRegOneVsAll: Hyperparameter optimization ...done" << endl;
+
+    if ( useLooParameters )
+    {
+      cerr << "KCGPRegOneVsAll: using best loo parameters" << endl;
+      gpopt.useLooParameters();
+    }
+
+    gpopt.update();
+
+    Vector parameters;
+    kernelPara->getParameters ( parameters );
+    cout << "KCGPRegOneVsAll: Optimization finished: " << parameters << endl << endl;
+  } else {
+    kernelData->updateCholeskyFactorization();
+  }
+
+  //for binary problems
+  if (classesUsed.size() == 2 && false)
+  {
+    set<int>::const_iterator it = classesUsed.begin();
+    int classno = *it;
+    it++;
+    int classno2 = *it;
+    const Vector & ySub = ySet[0];
+    RegGaussianProcess *classifier;
+    classifier = prototype->clone();
+    if (verbose)
+      fprintf (stderr, "KCGPRegOneVsAll: training classifier class %d <-> %d\n", classno, classno2 );
+    classifier->teach ( kernelData, ySub );
+    classifiers.push_back ( pair<int, RegGaussianProcess*> (classno, classifier) );
+    classifiers.push_back ( pair<int, RegGaussianProcess*> (classno2, classifier) );
+  }
+  else
+  {
+    int i = 0;
+    for ( set<int>::const_iterator it = classesUsed.begin(); it != classesUsed.end(); it++, i++)
+    {
+      int classno = *it;
+      const Vector & ySubZeroMean = ySetZeroMean[i];
+      RegGaussianProcess *classifier;
+      classifier = prototype->clone();
+
+      if (verbose)
+        fprintf (stderr, "KCGPRegOneVsAll: training classifier class %d <-> remainder\n", classno );
+
+      classifier->teach ( kernelData, ySubZeroMean );
+
+      classifiers.push_back ( pair<int, RegGaussianProcess*> (classno, classifier) );
+    }
+  }
+
+  if ( computeUncertainty || calibrateProbabilities )
+    choleskyMatrix = kernelData->getCholeskyMatrix();
 
 }
 
@@ -218,180 +218,180 @@ void KCGPRegOneVsAll::teach ( KernelData *kernelData, const NICE::Vector & y )
  */
 void KCGPRegOneVsAll::teach ( KernelData *kernelData, const std::vector<double> & y )
 {
-	// FIXME: Do we really need this function? (erik)
-	Vector y_nice (y);
-	teach ( kernelData, y_nice );
+  // FIXME: Do we really need this function? (erik)
+  Vector y_nice (y);
+  teach ( kernelData, y_nice );
 }
 
 
 ClassificationResult KCGPRegOneVsAll::classifyKernel ( const NICE::Vector & kernelVector, double kernelSelf ) const
 {
-	if ( classifiers.size() <= 0 ) 
-		fthrow(Exception, "The classifier was not trained with training data (use teach(...))");
-
-	FullVector scores ( maxClassNo+1 );
-	scores.set(0);
-
-	//for binary problems
-	if(classifiers.size() == 2 && false)
-	{
-		int classno = classifiers[0].first;
-		int classno2 = classifiers[1].first;
-		RegGaussianProcess *classifier = classifiers[0].second;
-		double yEstimate = classifier->predictKernel(kernelVector, kernelSelf);
-		scores[classno] = yEstimate;
-		scores[classno2] = 0;//1-yEstimate;
-		//cout << "i: " << 0 << ": " << scores[classno] << endl;
-		//cout << "i: " << 1 << ": " << scores[classno2] << endl;
-	}
-	else
-	{
+  if ( classifiers.size() <= 0 )
+    fthrow(Exception, "The classifier was not trained with training data (use teach(...))");
+
+  FullVector scores ( maxClassNo + 1 );
+  scores.set(0);
+
+  //for binary problems
+  if (classifiers.size() == 2 && false)
+  {
+    int classno = classifiers[0].first;
+    int classno2 = classifiers[1].first;
+    RegGaussianProcess *classifier = classifiers[0].second;
+    double yEstimate = classifier->predictKernel(kernelVector, kernelSelf);
+    scores[classno] = yEstimate;
+    scores[classno2] = 0;//1-yEstimate;
+    //cout << "i: " << 0 << ": " << scores[classno] << endl;
+    //cout << "i: " << 1 << ": " << scores[classno2] << endl;
+  }
+  else
+  {
 #pragma omp parallel for
-		for ( int classifierIndex = 0 ; classifierIndex < (int)classifiers.size(); classifierIndex++ )
-		{
-			int classno = classifiers[(uint)classifierIndex].first;
-			RegGaussianProcess *classifier = classifiers[(uint)classifierIndex].second;
-			double yEstimate = classifier->predictKernel(kernelVector, kernelSelf);
-			scores[classno] += yEstimate;
-			//cout << "i: " << classifierIndex << ": " << scores[classno] << endl;
-		}
-	}
-
-	double uncertainty = 0.0;
-	if ( computeUncertainty || calibrateProbabilities )
-	{
-		Vector tmp;
-		choleskySolveLargeScale ( choleskyMatrix, kernelVector, tmp );
-
-		// tmp = K^{-1} k*
-		uncertainty = kernelSelf - kernelVector.scalarProduct ( tmp );
-		
-		/*if(uncertainty < 0.0)
-// 			uncertainty = 0.0;*/
-
-		if ( calibrateProbabilities )
-		{
-			/*********************************************************************
-			 * Calibration of probabilities is based on the following
-			 * idea: 
-			 *
-			 * The scores \mu_i (or scores[i]) and the uncertainty
-			 * r.uncertainty are the mean and the variance of the predictive
-			 * distribution p(y_i | ...). So actually we do not know the correct value for
-			 * y_i and therefore just taking the maximum score ignores this uncertainty 
-			 * completely! 
-			 * What we might want to have is the probability for each class k
-			 * p_k = p( k = argmax_i y_i )
-			 *
-			 * Calculating this probability for n>2 is intractable and we
-			 * have to do monte carlo estimation which is performed in the following code
-			 *
-			 * An alternative would be to approximate p_k with 
-			 * p( mu_k >= max_{i != k} y_i ) = prod_{i != k} F_i(mu_k) 
-			 * with F_i being the cumulative distribution of the normal distribution i
-			 *
-			 * Details: Erik Rodner, "Learning with Few Examples for Visual Recognition Problems", PhD thesis
-			 *
-			 ********************************************************************/
-
-			double stddev = sqrt(uncertainty);
-			FullVector calibratedScores ( maxClassNo + 1 );
-			calibratedScores.set(0.0);
-			for ( uint i = 0 ; i < numSamplesCalibration ; i++ )
-			{
-				uint cmaxClassno = 0;
-				double cmax = - std::numeric_limits<double>::max();
-				for ( int classifierIndex = 0 ; classifierIndex < (int)classifiers.size(); classifierIndex++ )
-				{
-					int classno = classifiers[(uint)classifierIndex].first;
-					double s = randGaussDouble ( stddev ) + scores[classno];
-					if ( s > cmax )
-					{
-						cmax = s;
-						cmaxClassno = classno;
-					}
-				}
-				calibratedScores[ cmaxClassno ]++;
-			}
-			calibratedScores.normalize();
-
-			// calibrating probabilities should not affect our hard
-			// decision for a specific class
-			if ( verbose ) {
-				if ( scores.maxElement() != calibratedScores.maxElement() )
-					cerr << "Calibration of probabilities affected the hard decision, you should increase calibrated_probabilities_numsamples !!" << endl;
-			}
-
-			scores = calibratedScores;
-		}
-	}
-
-	ClassificationResult r ( scores.maxElement(), scores );
-	r.uncertainty = uncertainty;
-
-	return r;
+    for ( int classifierIndex = 0 ; classifierIndex < (int)classifiers.size(); classifierIndex++ )
+    {
+      int classno = classifiers[(uint)classifierIndex].first;
+      RegGaussianProcess *classifier = classifiers[(uint)classifierIndex].second;
+      double yEstimate = classifier->predictKernel(kernelVector, kernelSelf);
+      scores[classno] += yEstimate;
+      //cout << "i: " << classifierIndex << ": " << scores[classno] << endl;
+    }
+  }
+
+  double uncertainty = 0.0;
+  if ( computeUncertainty || calibrateProbabilities )
+  {
+    Vector tmp;
+    choleskySolveLargeScale ( choleskyMatrix, kernelVector, tmp );
+
+    // tmp = K^{-1} k*
+    uncertainty = kernelSelf - kernelVector.scalarProduct ( tmp );
+
+    /*if(uncertainty < 0.0)
+    //    uncertainty = 0.0;*/
+
+    if ( calibrateProbabilities )
+    {
+      /*********************************************************************
+       * Calibration of probabilities is based on the following
+       * idea:
+       *
+       * The scores \mu_i (or scores[i]) and the uncertainty
+       * r.uncertainty are the mean and the variance of the predictive
+       * distribution p(y_i | ...). So actually we do not know the correct value for
+       * y_i and therefore just taking the maximum score ignores this uncertainty
+       * completely!
+       * What we might want to have is the probability for each class k
+       * p_k = p( k = argmax_i y_i )
+       *
+       * Calculating this probability for n>2 is intractable and we
+       * have to do monte carlo estimation which is performed in the following code
+       *
+       * An alternative would be to approximate p_k with
+       * p( mu_k >= max_{i != k} y_i ) = prod_{i != k} F_i(mu_k)
+       * with F_i being the cumulative distribution of the normal distribution i
+       *
+       * Details: Erik Rodner, "Learning with Few Examples for Visual Recognition Problems", PhD thesis
+       *
+       ********************************************************************/
+
+      double stddev = sqrt(uncertainty);
+      FullVector calibratedScores ( maxClassNo + 1 );
+      calibratedScores.set(0.0);
+      for ( uint i = 0 ; i < numSamplesCalibration ; i++ )
+      {
+        uint cmaxClassno = 0;
+        double cmax = - std::numeric_limits<double>::max();
+        for ( int classifierIndex = 0 ; classifierIndex < (int)classifiers.size(); classifierIndex++ )
+        {
+          int classno = classifiers[(uint)classifierIndex].first;
+          double s = randGaussDouble ( stddev ) + scores[classno];
+          if ( s > cmax )
+          {
+            cmax = s;
+            cmaxClassno = classno;
+          }
+        }
+        calibratedScores[ cmaxClassno ]++;
+      }
+      calibratedScores.normalize();
+
+      // calibrating probabilities should not affect our hard
+      // decision for a specific class
+      if ( verbose ) {
+        if ( scores.maxElement() != calibratedScores.maxElement() )
+          cerr << "Calibration of probabilities affected the hard decision, you should increase calibrated_probabilities_numsamples !!" << endl;
+      }
+
+      scores = calibratedScores;
+    }
+  }
+
+  ClassificationResult r ( scores.maxElement(), scores );
+  r.uncertainty = uncertainty;
+
+  return r;
 }
 
 KCGPRegOneVsAll* KCGPRegOneVsAll::clone(void) const
 {
-	KCGPRegOneVsAll *classifier = new KCGPRegOneVsAll( *this );
-	return classifier;
+  KCGPRegOneVsAll *classifier = new KCGPRegOneVsAll( *this );
+  return classifier;
 }
 
 void KCGPRegOneVsAll::clear()
 {
-	//nothing to clear
+  //nothing to clear
 }
 
 void KCGPRegOneVsAll::restore(std::istream& ifs, int type)
 {
-	ifs.precision (numeric_limits<double>::digits10 + 1);
-	ifs >> maxClassNo;
-	ifs >> computeUncertainty;
-	ifs >> calibrateProbabilities;
-
-	if(calibrateProbabilities || computeUncertainty)
-	{
-		ifs >> choleskyMatrix;
-	}
-
-	int size;
-	ifs >> size;
-
-	for(int i = 0; i < size; i++)
-	{
-		int tmp;
-		ifs >> tmp;
-		RegGaussianProcess *classifier;
-		classifier = prototype->clone();
-		classifier->restore(ifs);
-		classifiers.push_back ( pair<int, RegGaussianProcess*> (tmp, classifier) );
-	}
-
-	KernelClassifier::restore(ifs,type);
+  ifs.precision (numeric_limits<double>::digits10 + 1);
+  ifs >> maxClassNo;
+  ifs >> computeUncertainty;
+  ifs >> calibrateProbabilities;
+
+  if (calibrateProbabilities || computeUncertainty)
+  {
+    ifs >> choleskyMatrix;
+  }
+
+  int size;
+  ifs >> size;
+
+  for (int i = 0; i < size; i++)
+  {
+    int tmp;
+    ifs >> tmp;
+    RegGaussianProcess *classifier;
+    classifier = prototype->clone();
+    classifier->restore(ifs);
+    classifiers.push_back ( pair<int, RegGaussianProcess*> (tmp, classifier) );
+  }
+
+  KernelClassifier::restore(ifs, type);
 }
 
 void KCGPRegOneVsAll::store(std::ostream& ofs, int type) const
 {
-	ofs.precision (numeric_limits<double>::digits10 + 1);
-	
-	ofs << maxClassNo << endl;
-	ofs << computeUncertainty << endl;
-	ofs << calibrateProbabilities << endl;
-
-	
-	if(calibrateProbabilities || computeUncertainty)
-	{
-		ofs << choleskyMatrix << endl;
-	}
-	
-	ofs << classifiers.size() << endl;
-	for(uint i = 0; i < classifiers.size(); i++)
-	{
-		ofs << classifiers[i].first << endl;
-		classifiers[i].second->store(ofs);
-		ofs << endl;
-	}
-	KernelClassifier::store(ofs,type);
+  ofs.precision (numeric_limits<double>::digits10 + 1);
+
+  ofs << maxClassNo << endl;
+  ofs << computeUncertainty << endl;
+  ofs << calibrateProbabilities << endl;
+
+
+  if (calibrateProbabilities || computeUncertainty)
+  {
+    ofs << choleskyMatrix << endl;
+  }
+
+  ofs << classifiers.size() << endl;
+  for (uint i = 0; i < classifiers.size(); i++)
+  {
+    ofs << classifiers[i].first << endl;
+    classifiers[i].second->store(ofs);
+    ofs << endl;
+  }
+  KernelClassifier::store(ofs, type);
 }
 

classifier/kernelclassifier/progs/libdepend.inc

@@ -5,5 +5,5 @@ $(call PKG_DEPEND_INT,vislearning/baselib)
 $(call PKG_DEPEND_INT,vislearning/cbaselib)
 $(call PKG_DEPEND_INT,vislearning/classifier/kernelclassifier)
 $(call PKG_DEPEND_INT,vislearning/matlabAccessHighLevel)
-
-
+$(call PKG_DEPEND_EXT,MATIO)
+$(call PKG_DEPEND_EXT,HDF5)

classifier/vclassifier/VCNearestNeighbour.cpp

@@ -57,27 +57,27 @@ ClassificationResult VCNearestNeighbour::classify ( const NICE::Vector & x ) con
     priority_queue< pair<double, int> > examples;
     LOOP_ALL(teachSet) 
     {
-	EACH(classno,y)
-
-	double distance = distancefunc->calculate ( x, y );
-
-	if ( isnan(distance) )
-	{
-	    fprintf (stderr, "VCNearestNeighbour::classify: NAN value found !!\n");
-	    cerr << x << endl;
-	    cerr << y << endl;
-	}
-
-	if ( mindists[classno] > distance )
-	    mindists[classno] = distance;
-
-	if ( mindist > distance )
-	{
-	    minclass = classno;
-	    mindist  = distance;
-	}
-	if ( K > 1 ) 
-	    examples.push ( pair<double, int> ( -distance, classno ) );
+      EACH(classno,y)
+
+      double distance = distancefunc->calculate ( x, y );
+
+      if ( isnan(distance) )
+      {
+          fprintf (stderr, "VCNearestNeighbour::classify: NAN value found !!\n");
+          cerr << x << endl;
+          cerr << y << endl;
+      }
+
+      if ( mindists[classno] > distance )
+          mindists[classno] = distance;
+
+      if ( mindist > distance )
+      {
+          minclass = classno;
+          mindist  = distance;
+      }
+      if ( K > 1 ) 
+        examples.push ( pair<double, int> ( -distance, classno ) );
     }
 
     if ( mindist == 0.0 )
@@ -88,24 +88,28 @@ ClassificationResult VCNearestNeighbour::classify ( const NICE::Vector & x ) con
 		fprintf (stderr, "class %d : %f\n", i, mindists.get(i) );
 #endif
 
-    if ( K > 1 ) {
-		FullVector votes ( maxClassNo + 1 );
-		votes.set(0.0);
-		for ( int k = 0 ; k < K ; k++ )
-		{
-			const pair<double, int> & t = examples.top();
-			votes[ t.second ]++;
-			examples.pop();
-		}
-		votes.normalize();
-		return ClassificationResult ( votes.maxElement(), votes );
-    } else {
-		for ( int i = 0 ; i < mindists.size() ; i++ )
-		{
-			mindists[i] = 1.0 / (mindists[i] + 1.0);
-		}
-		mindists.normalize();
-		return ClassificationResult ( minclass, mindists );
+    if ( K > 1 )
+    {
+      FullVector votes ( maxClassNo + 1 );
+      votes.set(0.0);
+      for ( int k = 0 ; k < K ; k++ )
+      {
+        const pair<double, int> & t = examples.top();
+        votes[ t.second ]++;
+        examples.pop();
+      }
+      votes.normalize();
+      return ClassificationResult ( votes.maxElement(), votes );
+    }
+    else
+    {
+      //do we really want to do this? Only useful, if we want to obtain probability like scores      
+//       for ( int i = 0 ; i < mindists.size() ; i++ )
+//       {
+//         mindists[i] = 1.0 / (mindists[i] + 1.0);
+//       }
+      //mindists.normalize();
+      return ClassificationResult ( minclass, mindists );
     }
 }
 
@@ -114,24 +118,45 @@ void VCNearestNeighbour::teach ( const LabeledSetVector & _teachSet )
 {
     fprintf (stderr, "teach using all !\n");
     maxClassNo = _teachSet.getMaxClassno();
-    teachSet = _teachSet;
+    //NOTE this is crucial if we clear _teachSet afterwards!
+    //therefore, take care NOT to call _techSet.clear() somewhere out of this method
+    this->teachSet = _teachSet;
+    
+    std::cerr << "number of known training samples: " << this->teachSet.begin()->second.size() << std::endl;
+    
+//     //just for testing - remove everything but the first element
+//     map< int, vector<NICE::Vector *> >::iterator it = this->teachSet.begin();
+//     it++;
+//     this->teachSet.erase(it, this->teachSet.end());
+//     std::cerr << "keep " << this->teachSet.size() << " elements" << std::endl;
+    
+    
 }
 
 
 void VCNearestNeighbour::teach ( int classno, const NICE::Vector & x )
 {
-    fprintf (stderr, "teach!\n");
+    std::cerr << "VCNearestNeighbour::teach one new example" << std::endl;
+    
     for ( size_t i = 0 ; i < x.size() ; i++ )
-	if ( isnan(x[i]) ) 
-	{
-	    fprintf (stderr, "There is a NAN value in within this vector: x[%d] = %f\n", (int)i, x[i]);
-	    cerr << x << endl;
-	    exit(-1);
-	}
+      if ( isnan(x[i]) ) 
+      {
+          fprintf (stderr, "There is a NAN value in within this vector: x[%d] = %f\n", (int)i, x[i]);
+          cerr << x << endl;
+          exit(-1);
+      }
     
     if ( classno > maxClassNo ) maxClassNo = classno;
 
     teachSet.add ( classno, x );
+    
+    std::cerr << "adden class " << classno << " with feature " << x << std::endl;
+    int tmpCnt(0);
+    for (LabeledSetVector::const_iterator it = this->teachSet.begin(); it != this->teachSet.end(); it++)
+    {
+      tmpCnt += it->second.size();
+    }
+    std::cerr << "number of known training samples: " << tmpCnt << std::endl;
 }
 
 void VCNearestNeighbour::finishTeaching()
@@ -159,5 +184,3 @@ void VCNearestNeighbour::restore ( std::istream & is, int format )
     teachSet.restore ( is, format );
     maxClassNo = teachSet.getMaxClassno();
 }
-
-

classifier/vclassifier/VCNearestNeighbour.h

@@ -56,6 +56,7 @@ class VCNearestNeighbour : public VecClassifier
 		void store ( std::ostream & os, int format = 0 ) const;
 
 		void restore ( std::istream & is, int format = 0 );
+    
 };
 
 

featureLearning/FeatureLearningClusterBased.cpp

@@ -0,0 +1,296 @@
+
+#include "FeatureLearningClusterBased.h"
+
+//STL
+#include <iostream>
+
+//core
+#include <core/image/FilterT.h>
+#include <core/image/CircleT.h>
+#include <core/image/Convert.h>
+// 
+#include <core/vector/VectorT.h>
+
+//vislearning
+#include <vislearning/baselib/Globals.h>
+// 
+#include <vislearning/math/cluster/KMeans.h>
+#include <vislearning/math/cluster/GMM.h>
+
+
+using namespace std;
+using namespace NICE;
+using namespace OBJREC;
+
+  //**********************************************
+  //
+  //                 PROTECTED METHODS
+  //
+  //********************************************** 
+
+void FeatureLearningClusterBased::setClusterAlgo( const std::string & _clusterAlgoString, const bool & _setForInitialTraining)
+{
+  //be careful with previously allocated memory
+  if (this->clusterAlgo != NULL)
+    delete clusterAlgo;
+  
+  if (_clusterAlgoString.compare("kmeans") == 0)
+  {
+    if ( _setForInitialTraining )
+      this->clusterAlgo = new OBJREC::KMeans(this->initialNumberOfClusters);
+    else
+      this->clusterAlgo = new OBJREC::KMeans(this->numberOfClustersForNewImage);
+  }
+  else if (_clusterAlgoString.compare("GMM") == 0) 
+  {
+    if ( _setForInitialTraining )
+      this->clusterAlgo = new OBJREC::GMM(this->conf, this->initialNumberOfClusters);
+    else
+      this->clusterAlgo = new OBJREC::GMM(this->conf, this->numberOfClustersForNewImage);      
+  }
+  else
+  {
+    std::cerr << "Unknown cluster algorithm selected, use k-means instead" << std::endl;
+    if ( _setForInitialTraining )      
+      this->clusterAlgo = new OBJREC::KMeans(this->initialNumberOfClusters);
+    else
+      this->clusterAlgo = new OBJREC::KMeans(this->numberOfClustersForNewImage);
+  }    
+}
+
+
+  //**********************************************
+  //
+  //                 PUBLIC METHODS
+  //
+  //********************************************** 
+
+
+FeatureLearningClusterBased::FeatureLearningClusterBased ( const Config *_conf,
+                               const MultiDataset *_md, const std::string & _section )
+    : FeatureLearningPrototypes ( _conf, _md, _section )
+{ 
+  
+   // define the number of clusters we want to compute for an unseen image
+  numberOfClustersForNewImage = conf->gI(section, "numberOfClustersForNewImage", 10);
+   
+  //**********************************************
+  //
+  //      SET UP VARIABLES AND METHODS
+  //             - FEATURE TYPE
+  //             - CLUSTERING ALGO
+  //             - DISTANCE FUNCTION
+  //             - ...
+  //
+  //**********************************************  
+  
+   
+  //run the training to initially compute a codebook and stuff like that
+//  this->train( _md );
+   
+  // define the clustering algorithm to be used
+  std::string clusterAlgoString = conf->gS(section, "clusterAlgo", "kmeans");  
+  this->setClusterAlgo( clusterAlgoString, false /*set cluster algo for feature learning*/ );
+}
+
+FeatureLearningClusterBased::~FeatureLearningClusterBased()
+{
+  // clean-up
+}
+
+void FeatureLearningClusterBased::learnNewFeatures ( const std::string & _filename )
+{  
+  NICE::ColorImage img( _filename );
+  
+  int xsize ( img.width() );
+  int ysize ( img.height() );
+   
+  //variables to store feature information
+  NICE::VVector newFeatures;
+  NICE::VVector cfeatures;
+  NICE::VVector positions;
+
+  //compute features
+  std::cerr << " EXTRACT FEATURES FROM UNSEEN IMAGE" << std::endl;
+  Globals::setCurrentImgFN ( _filename );
+  featureExtractor->extractFeatures ( img, newFeatures, positions );  
+  
+  //normalization :)
+  for ( NICE::VVector::iterator i = newFeatures.begin();
+        i != newFeatures.end();
+        i++)
+  {              
+    i->normalizeL1();
+  }
+  
+  //cluster features
+  std::cerr << " CLUSTER FEATURES FROM UNSEEN IMAGE" << std::endl;
+  NICE::VVector prototypesForNewImage;
+  std::vector< double > weights;
+  std::vector< int > assignment;
+  clusterAlgo->cluster ( newFeatures, prototypesForNewImage, weights, assignment);
+  
+  if ( b_evaluationWhileFeatureLearning )
+  {
+    //visualize new clusters
+    int tmpProtCnt ( 0 );    
+    for (NICE::VVector::const_iterator protIt = prototypesForNewImage.begin(); protIt != prototypesForNewImage.end(); protIt++, tmpProtCnt++)
+    {
+      double distToNewCluster ( std::numeric_limits<double>::max() );
+      int indexOfMostSimFeat( 0 );
+      double tmpDist;
+      int tmpCnt ( 0 );
+      
+      for ( NICE::VVector::iterator i = newFeatures.begin();
+            i != newFeatures.end();
+            i++, tmpCnt++)
+      {
+        tmpDist = this->distFunction->calculate( *i, *protIt );
+        if ( tmpDist < distToNewCluster )
+        {
+          distToNewCluster = tmpDist;
+          indexOfMostSimFeat = tmpCnt;
+        }
+      }
+      
+      int posX ( ( positions[indexOfMostSimFeat] ) [0]  );
+      int posY ( ( positions[indexOfMostSimFeat] ) [1]  );
+      
+      NICE::Circle circ ( Coord( posX, posY), 10 /* radius*/, Color(200,0,255) );
+      img.draw(circ);       
+    }
+    
+    
+    //draw features most similar to old clusters
+    tmpProtCnt = 0;
+    for (NICE::VVector::const_iterator protIt = prototypes.begin(); protIt != prototypes.end(); protIt++, tmpProtCnt++)
+    {
+      double distToNewCluster ( std::numeric_limits<double>::max() );
+      int indexOfMostSimFeat( 0 );
+      double tmpDist;
+      int tmpCnt ( 0 );
+      
+      for ( NICE::VVector::iterator i = newFeatures.begin();
+            i != newFeatures.end();
+            i++, tmpCnt++)
+      {
+        tmpDist = this->distFunction->calculate( *i, *protIt );
+        if ( tmpDist < distToNewCluster )
+        {
+          distToNewCluster = tmpDist;
+          indexOfMostSimFeat = tmpCnt;
+        }
+      }
+      
+      int posX ( ( positions[indexOfMostSimFeat] ) [0]  );
+      int posY ( ( positions[indexOfMostSimFeat] ) [1]  );
+      NICE::Circle circ ( Coord( posX, posY), 5 /* radius*/, Color(200,255,0 ) );
+      img.draw(circ);      
+    }
+    
+    if ( b_showResults )
+      showImage(img, "Current (new) image and most similar feature for new cluster");     
+    else
+    {
+      std::vector< std::string > list2;
+      StringTools::split ( _filename, '/', list2 );      
+
+      std::string destination ( s_resultdir + NICE::intToString(this->newImageCounter) + "_" + list2.back() + "_1_oldAndNewClusters.ppm");
+      img.writePPM( destination );
+    }   
+  }
+  
+  //compute score for every cluster: #assigned features * distance to current cluster centers
+  
+  NICE::Vector distancesToCurrentClusters ( numberOfClustersForNewImage, 0.0 );
+  NICE::Vector clusterSizes ( numberOfClustersForNewImage, 0.0 ); //i.e., the number of assignments, or a derived number
+   
+  //compute "relevance" of every new cluster
+ 
+  std::cerr << " COMPUTE SIZES OF NEW CLUSTERS" << std::endl;
+  for (std::vector<int>::const_iterator assignIt = assignment.begin(); assignIt != assignment.end(); assignIt++)
+  {
+    clusterSizes[*assignIt]++;
+  }
+  clusterSizes.normalizeL1();
+  
+  std::cerr << "cluster Sizes: " << clusterSizes << std::endl;
+  
+  
+  //compute distances of new cluster centers to old cluster centers
+  std::cerr << " COMPUTE DISTANCES BETWEEN NEW AND OLD CLUSTERS" << std::endl;
+  NICE::Vector::iterator distanceIt = distancesToCurrentClusters.begin();
+  for ( NICE::VVector::const_iterator newProtIt = prototypesForNewImage.begin(); newProtIt != prototypesForNewImage.end(); newProtIt++, distanceIt++)
+  {
+    double minDist ( std::numeric_limits<double>::max() );
+    double tmpDist;
+    for ( NICE::VVector::const_iterator protIt = prototypes.begin(); protIt != prototypes.end(); protIt ++)
+    {
+        //compute distance
+        tmpDist = this->distFunction->calculate( *protIt, *newProtIt );
+        if (tmpDist < minDist)
+          minDist = tmpDist;      
+    }
+    
+    *distanceIt = minDist;
+  }
+  
+  std::cerr << "distances: " << distancesToCurrentClusters << std::endl;
+  
+  //compute final scores for the new image
+  NICE::Vector clusterScores ( numberOfClustersForNewImage, 0.0 );
+  for (uint i = 0; i < numberOfClustersForNewImage; i++)
+  {
+      clusterScores[i] = clusterSizes[i] * distancesToCurrentClusters[i];
+  }
+  
+  std::cerr << "final cluster scores for new image: " << clusterScores << std::endl;
+    
+  NICE::Vector chosenClusterCenter ( prototypesForNewImage[ clusterScores.MaxIndex()  ] );
+  
+  
+  //include the chosen information into the currently used prototypes
+  prototypes.push_back( chosenClusterCenter );
+  
+  if ( b_evaluationWhileFeatureLearning ) 
+  {
+    
+    NICE::ColorImage imgTmp( _filename );
+    
+    double distToNewCluster ( std::numeric_limits<double>::max() );
+    int indexOfMostSimFeat( 0 );
+    double tmpDist;
+    int tmpCnt ( 0 );
+    
+    for ( NICE::VVector::iterator i = newFeatures.begin();
+          i != newFeatures.end();
+          i++, tmpCnt++)
+    {
+      tmpDist = this->distFunction->calculate( *i, chosenClusterCenter );
+      if ( tmpDist < distToNewCluster )
+      {
+        distToNewCluster = tmpDist;
+        indexOfMostSimFeat = tmpCnt;
+      }
+    }
+    
+    int posX ( ( positions[indexOfMostSimFeat] ) [0]  );
+    int posY ( ( positions[indexOfMostSimFeat] ) [1]  );
+    NICE::Circle circ ( Coord( posX, posY), 10 /* radius*/, Color(200,0,255) );
+    imgTmp.draw(circ); 
+    
+    if ( b_showResults )
+      showImage(imgTmp, "Current (new) image and most similar feature for new cluster"); 
+    else 
+    {
+      std::vector< std::string > list2;
+      StringTools::split ( _filename, '/', list2 );      
+
+      std::string destination ( s_resultdir + NICE::intToString(this->newImageCounter) + "_" + list2.back() + "_2_bestNewCluster.ppm");
+      imgTmp.writePPM( destination );
+    }
+  }
+  
+  //this was a new image, so we increase our internal counter
+  (this->newImageCounter)++;  
+}

featureLearning/FeatureLearningClusterBased.h

@@ -0,0 +1,69 @@
+/**
+ * @file FeatureLearningClusterBased.h
+ * @brief compute new histogram entries by clustering new features and take centers of clusters which are relevant and novel
+ * @author Alexander Freytag
+ * @date 16-04-2013 (dd-mm-yyyy)
+*/
+#ifndef _INCLUDEFEATURELEARNINGCLUSTERBASED
+#define _INCLUDEFEATURELEARNINGCLUSTERBASED
+
+#include "FeatureLearningPrototypes.h"
+
+#include <string>
+
+
+namespace OBJREC
+{
+
+  /**
+   * @class FeatureLearningClusterBased
+   * @brief compute new histogram entries by clustering new features and take centers of clusters which are relevant and novel
+   * @author Alexander Freytag
+   * @date 16-04-2013 (dd-mm-yyyy)
+  */  
+  
+  class FeatureLearningClusterBased : public FeatureLearningPrototypes
+  {
+
+    protected:
+           
+      /************************
+       * 
+       *   protected variables
+       * 
+       **************************/       
+      
+       //! define the number of clusters we want to compute for an unseen image
+      int numberOfClustersForNewImage;      
+
+      /************************
+       * 
+       *   protected methods
+       * 
+       **************************/  
+      
+      void setClusterAlgo( const std::string & _clusterAlgoString, const bool & _setForInitialTraining);
+
+
+    public:
+
+      /** constructor
+        *  @param _conf needs a configfile
+        *  @param _md and a MultiDataset (contains images and other things)
+        */
+      FeatureLearningClusterBased ( const NICE::Config *_conf, const OBJREC::MultiDataset *_md , const std::string & _section = "featureLearning");
+
+      /** simple destructor */
+      virtual ~FeatureLearningClusterBased();
+      
+      /** this function has to be overloaded by all subclasses
+          @param imgWithNovelContent 
+      */
+      virtual void learnNewFeatures ( const std::string & filename ) ;      
+
+  };
+
+
+} // namespace
+
+#endif

featureLearning/FeatureLearningGeneric.cpp

@@ -0,0 +1,43 @@
+/**
+* @file FeatureLearningGeneric.cpp
+* @brief abstract interface for feature learning algorithms
+* @author Alexander Freytag
+* @date 16-04-2013 (dd-mm-yyyy)
+
+*/
+#include <iostream>
+
+#include <vislearning/baselib/Preprocess.h>
+
+#include "FeatureLearningGeneric.h"
+
+using namespace OBJREC;
+using namespace std;
+using namespace NICE;
+
+FeatureLearningGeneric::FeatureLearningGeneric ( const Config *_conf, const std::string & _section )
+{
+  this->section = _section;  
+  this->conf = _conf;  
+  
+  this->cacheInitialCodebook = this->conf->gS(this->section, "cacheInitialCodebook", "");
+  this-> b_loadInitialCodebook = this->conf->gB(this->section, "loadInitialCodebook", "");
+  this-> b_saveInitialCodebook = this->conf->gB(this->section, "saveInitialCodebook", "");  
+  
+  this->b_evaluationWhileFeatureLearning = this->conf->gB( this->section, "evaluationWhileFeatureLearning", false );
+  
+  this->b_showTrainingImages = conf->gB( section, "showTrainingImages", false );  
+  this->b_showResults = conf->gB( section, "showResults", false );
+  
+  this->s_resultdir = conf->gS( section, "resultdir", "/tmp/");  
+  
+  Preprocess::Init ( _conf );
+}
+
+FeatureLearningGeneric::~FeatureLearningGeneric()
+{
+}
+
+void FeatureLearningGeneric::learnNewFeatures ( const std::string & _filename )
+{
+}

featureLearning/FeatureLearningGeneric.h

@@ -0,0 +1,130 @@
+/**
+ * @file FeatureLearningGeneric.h
+ * @brief abstract interface for feature learning algorithms
+ * @author Alexander Freytag
+ * @date 16-04-2013 (dd-mm-yyyy)
+*/
+#ifndef _INCLUDEFEATURELEARNING
+#define _INCLUDEFEATURELEARNING
+
+#define ROADWORKS fthrow(NICE::Exception, "Feature Learning -- not yet implemented!");
+
+//STL
+#include <string>
+//
+//core
+#include <core/basics/Config.h>
+#include <core/image/ImageT.h>
+#include <core/vector/VVector.h>
+//
+//vislearning
+#include <vislearning/cbaselib/CachedExample.h>
+
+
+
+namespace OBJREC
+{
+
+  /**
+   * @class FeatureLearningGeneric
+   * @brief abstract interface for feature learning algorithms
+   * @author Alexander Freytag
+   * @date 16-04-2013 (dd-mm-yyyy)
+  */
+  class FeatureLearningGeneric
+  {
+
+    protected:   
+      
+      /************************
+       * 
+       *   protected variables
+       * 
+       **************************/       
+      
+      //! section information for parsing config files
+      std::string section;      
+      
+      //! Configuration File
+      const NICE::Config *conf;    
+      
+      //! where should an initial codebook be located, i.e., read from and written to?
+      std::string cacheInitialCodebook;
+      //! was an initial codebook already computed?
+      bool b_loadInitialCodebook;
+      //!shall the initially computed codebook be stored somewhere?
+      bool  b_saveInitialCodebook; 
+      
+      //! additional evaluation in the process of feature learning, e.g., visualize the most useful features in the current image
+      bool b_evaluationWhileFeatureLearning;
+      
+      bool b_showTrainingImages;
+      bool b_showResults;
+  
+      std::string s_resultdir;
+     
+      
+      /************************
+       * 
+       *   protected methods
+       * 
+       **************************/      
+      
+      /**
+       * @brief Load a previously computed codebook which serves as initial codebook
+       * @author Alexander Freytag
+       * @date 17-04-2013 (dd-mm-yyyy)
+       * @return bool (success of loading)
+       * @note This function has to be overloaded by all subclasses!
+       */
+      virtual bool loadInitialCodebook ( ) = 0;
+      
+      /**
+       * @brief Store the initially computed codebook
+       * @author Alexander Freytag
+       * @date 17-04-2013 (dd-mm-yyyy)
+       * @return bool (success of writing) 
+       * @note This function has to be overloaded by all subclasses!
+       */      
+      virtual bool writeInitialCodebook ( ) = 0;
+      
+
+    public:
+
+      /**
+       * @brief  simple constructor
+       * @author Alexander Freytag
+       * @date 16-04-2013 (dd-mm-yyyy)
+       * @param _conf global settings
+       * @param _section section information for parsing config files
+      */
+      FeatureLearningGeneric ( const NICE::Config *_conf, const std::string & _section = "featureLearning" );
+
+      /** simple destructor */
+      virtual ~FeatureLearningGeneric();
+
+      
+      /** 
+       * @brief  Learn new features to explain a previously unseen image with novel content
+       * @author Alexander Freytag
+       * @date 16-04-2013 (dd-mm-yyyy)
+       * @param _filename of the new image 
+       * @note This function has to be overloaded by all subclasses!          
+      */
+      virtual void learnNewFeatures ( const std::string & _filename) = 0;  
+      
+      virtual NICE::FloatImage evaluateCurrentCodebookByDistance ( const std::string & _filename , const bool & beforeComputingNewFeatures = true) = 0;
+      
+      virtual NICE::ImageT<int> evaluateCurrentCodebookByAssignments ( const std::string & _filename , const bool & beforeComputingNewFeatures = true, const bool & _binaryShowLatestPrototype = false) = 0;      
+      
+      virtual void evaluateCurrentCodebookByConfusionMatrix( NICE::Matrix & _confusionMat ) = 0; 
+      
+      virtual NICE::VVector * getCurrentCodebook() = 0;
+  
+
+  };
+
+
+} // namespace
+
+#endif

featureLearning/FeatureLearningPrototypes.cpp

@@ -0,0 +1,707 @@
+
+#include "FeatureLearningPrototypes.h"
+
+//STL
+#include <iostream>
+
+//core
+#include <core/image/FilterT.h>
+#include <core/image/CircleT.h>
+#include <core/image/Convert.h>
+#include <core/imagedisplay/ImageDisplay.h>
+#include <core/vector/VectorT.h>
+
+//vislearning
+#include <vislearning/features/localfeatures/LFonHSG.h>
+#include <vislearning/features/localfeatures/LFColorSande.h>
+#include <vislearning/features/localfeatures/LFColorWeijer.h>
+#include <vislearning/features/localfeatures/LFReadCache.h>
+#include <vislearning/features/localfeatures/LFWriteCache.h>
+// 
+#include <vislearning/math/cluster/KMeans.h>
+#include <vislearning/math/cluster/KMedian.h>
+#include <vislearning/math/cluster/GMM.h>
+
+using namespace std;
+using namespace NICE;
+using namespace OBJREC;
+
+  //**********************************************
+  //
+  //                 PROTECTED METHODS
+  //
+  //********************************************** 
+
+void FeatureLearningPrototypes::setClusterAlgo( const std::string & _clusterAlgoString)
+{
+  //be careful with previously allocated memory
+  if (this->clusterAlgo != NULL)
+    delete clusterAlgo;
+  
+  if (_clusterAlgoString.compare("kmeans") == 0)
+  {
+    this->clusterAlgo = new OBJREC::KMeans(this->initialNumberOfClusters);
+  }
+  else if (_clusterAlgoString.compare("kmedian") == 0)
+  {
+    this->clusterAlgo = new OBJREC::KMedian(this->initialNumberOfClusters);
+  }  
+  else if (_clusterAlgoString.compare("GMM") == 0) 
+  {
+    this->clusterAlgo = new OBJREC::GMM(this->conf, this->initialNumberOfClusters);
+  }
+  else
+  {
+    std::cerr << "Unknown cluster algorithm selected, use k-means instead" << std::endl;
+    this->clusterAlgo = new OBJREC::KMeans(this->initialNumberOfClusters);
+  }    
+}
+
+void FeatureLearningPrototypes::setFeatureExtractor( const bool & _setForTraining )
+{  
+  //be careful with previously allocated memory
+  if (this->featureExtractor != NULL)
+    delete featureExtractor;  
+  
+    //feature stuff
+  // which OpponentSIFT implementation to use {NICE, VANDESANDE}
+  std::string opSiftImpl;  
+  opSiftImpl = this->conf->gS ( "Descriptor", "implementation", "VANDESANDE" );
+  // read features?
+  bool readfeat;
+  readfeat = this->conf->gB ( "Descriptor", "read", true );
+  // write features?
+  bool writefeat;  
+  writefeat = this->conf->gB ( "Descriptor", "write", true );   
+  
+  // Welche Opponentsift Implementierung soll genutzt werden ?
+  LocalFeatureRepresentation *cSIFT = NULL;
+  LocalFeatureRepresentation *writeFeats = NULL;
+  LocalFeatureRepresentation *readFeats = NULL;
+  this->featureExtractor = NULL;
+  if ( opSiftImpl == "NICE" )
+  {
+    if ( _setForTraining )
+      cSIFT = new OBJREC::LFonHSG ( this->conf, "HSGTrain" );
+    else
+      cSIFT = new OBJREC::LFonHSG ( this->conf, "HSGTest" );
+  }
+  else if ( opSiftImpl == "VANDESANDE" )
+  {
+    if ( _setForTraining )
+      cSIFT = new OBJREC::LFColorSande ( this->conf, "LFColorSandeTrain" );
+    else
+      cSIFT = new OBJREC::LFColorSande ( this->conf, "LFColorSandeTest" );
+  }
+  else
+  {
+    fthrow ( Exception, "feattype: %s not yet supported" << opSiftImpl );
+  }
+
+  this->featureExtractor = cSIFT;
+  
+  if ( writefeat )
+  {
+    // write the features to a file, if there isn't any to read
+    writeFeats = new LFWriteCache ( this->conf, cSIFT );
+    this->featureExtractor = writeFeats;
+  }
+
+  if ( readfeat )
+  {
+    // read the features from a file
+    if ( writefeat )
+    {
+      readFeats = new LFReadCache ( this->conf, writeFeats, -1 );
+    }
+    else
+    {
+      readFeats = new LFReadCache ( this->conf, cSIFT, -1 );
+    }
+    this->featureExtractor = readFeats; 
+  }  
+  
+  //only set feature stuff to NULL, deletion of the underlying object is done in the destructor
+  if ( cSIFT != NULL )
+    cSIFT = NULL;
+  if ( writeFeats != NULL )
+    writeFeats = NULL;
+  if ( readFeats != NULL )
+    readFeats  = NULL ;   
+}
+
+void FeatureLearningPrototypes::extractFeaturesFromTrainingImages( const OBJREC::MultiDataset *_md, NICE::VVector & examplesTraining )
+{
+  examplesTraining.clear();
+  
+  int numberOfTrainImage ( 0 );
+  
+  const LabeledSet *trainFiles = (*_md)["train"]; 
+  
+  //run over all training images
+  LOOP_ALL_S( *trainFiles )
+  {
+      EACH_INFO( classno, info );
+      std::string filename = info.img();
+            
+      NICE::ColorImage img( filename );
+      if ( b_showTrainingImages )
+      {
+        showImage( img, "Input" );    
+      }
+      
+      //variables to store feature informatio
+      NICE::VVector features;
+      NICE::VVector cfeatures;
+      NICE::VVector positions;
+
+      //compute features
+      Globals::setCurrentImgFN ( filename );
+      if (featureExtractor == NULL)
+        std::cerr << "feature Extractor is NULL" << std::endl;
+      else
+        featureExtractor->extractFeatures ( img, features, positions );
+            
+      //store feature information in larger data structure
+      for ( NICE::VVector::iterator i = features.begin();
+            i != features.end();
+            i++)
+      {              
+        //normalization :)
+        i->normalizeL1();
+
+        examplesTraining.push_back(*i);
+      }
+      
+      //don't waste memory
+      features.clear();
+      positions.clear();      
+      numberOfTrainImage++;
+  }//Loop over all training images    
+}
+
+void FeatureLearningPrototypes::train ( const OBJREC::MultiDataset *_md )
+{  
+  bool loadSuccess = this->loadInitialCodebook();
+  
+  if ( !loadSuccess )
+  {
+    //**********************************************
+    //
+    //     EXTRACT FEATURES FROM TRAINING IMAGES
+    //
+    //**********************************************  
+    
+    std::cerr << " EXTRACT FEATURES FROM TRAINING IMAGES" << std::endl;
+    
+    NICE::VVector examplesTraining;  
+    this->extractFeaturesFromTrainingImages( _md, examplesTraining  );
+    
+    //**********************************************
+    //
+    //    CLUSTER FEATURES FROM TRAINING IMAGES
+    //
+    //    THIS GIVES US AN INITIAL CODEBOOK
+    //
+    //**********************************************  
+    std::cerr << " CLUSTER FEATURES FROM TRAINING IMAGES" << std::endl;
+    //go, go, go...  
+    prototypes.clear();
+    std::vector< double > weights;
+    std::vector< int > assignment;
+    clusterAlgo->cluster ( examplesTraining, prototypes, weights, assignment);
+    weights.clear();
+    assignment.clear();  
+    
+    //normalization
+    for (NICE::VVector::iterator protoIt = prototypes.begin(); protoIt != prototypes.end(); protoIt++)
+    {
+      protoIt->normalizeL1();
+    }
+  }
+  
+  this->writeInitialCodebook();
+}
+
+bool FeatureLearningPrototypes::loadInitialCodebook ( )
+{
+  if ( b_loadInitialCodebook  )
+  {
+    std::cerr << " INITIAL CODEBOOK ALREADY COMPUTED - RE-USE IT" << std::endl;    
+    std::cerr << " // WARNING - WE DO NOT VERIFY WHETHER THIS IS THE CORRECT CODEBOOK FOR THIS TRAINING SET!!!!" << std::endl;    
+    
+    prototypes.clear();
+    
+    try
+    {
+      prototypes.read(cacheInitialCodebook);
+    }
+    catch (...)
+    {
+      std::cerr << "Error while loading initial codebook from " << cacheInitialCodebook << std::endl;
+      return false;
+    }  
+    return true;
+  }
+  else
+    return false;
+}
+
+bool FeatureLearningPrototypes::writeInitialCodebook ( )
+{      
+  if (  b_saveInitialCodebook )
+  {
+    std::cerr << " SAVE INITIAL CODEBOOK " << std::endl;
+    
+    try 
+    {
+      prototypes.write( cacheInitialCodebook );
+    }
+    catch (...)
+    {
+      std::cerr << "Error while saving initial codebook" << std::endl;
+      return false;
+    }    
+    return true;
+  } 
+  else
+    return false;
+}
+
+
+void FeatureLearningPrototypes::evaluateCurrentCodebookForGivenFeatures(  const NICE::VVector & _features,
+                                                                          const NICE::VVector & _positions,
+                                                                          NICE::FloatImage & _noveltyImageGaussFiltered,
+                                                                          NICE::FloatImage * _noveltyImage                                                                        )
+{
+  bool wasNoveltyImageGiven ( true );
+  if ( _noveltyImage == NULL )
+  {
+    _noveltyImage = new FloatImage ( _noveltyImageGaussFiltered.width(), _noveltyImageGaussFiltered.height() );
+    wasNoveltyImageGiven = false;
+  }
+  
+  _noveltyImageGaussFiltered.set( 0.0 );
+  _noveltyImage->set( 0.0 );
+     
+  
+  NICE::VVector::const_iterator posIt = _positions.begin();
+  for ( NICE::VVector::const_iterator i = _features.begin();
+        i != _features.end();
+        i++, posIt++)
+  {              
+    
+    //loop over codebook representatives
+    double minDist ( std::numeric_limits<double>::max() );
+    for (NICE::VVector::const_iterator it =  prototypes.begin(); it != prototypes.end(); it++)
+    {
+      //compute distance
+      double tmpDist ( this->distFunction->calculate(*i,*it) );
+      if (tmpDist < minDist)
+        minDist = tmpDist;
+    }
+
+    //take minimum distance and store in in a float image    
+    (*_noveltyImage) ( (*posIt)[0], (*posIt)[1]  ) = minDist;
+  } 
+
+  
+  //gauss-filtering for nicer visualization
+  float sigma ( 3.0 );
+  FilterT<float, float, float> filter;
+  filter.filterGaussSigmaApproximate ( *_noveltyImage, sigma, & _noveltyImageGaussFiltered );
+    
+  if ( ! wasNoveltyImageGiven )
+    delete _noveltyImage;
+}
+
+  //**********************************************
+  //
+  //                 PUBLIC METHODS
+  //
+  //********************************************** 
+
+
+FeatureLearningPrototypes::FeatureLearningPrototypes ( const Config *_conf,
+                               const MultiDataset *_md, const std::string & _section )
+    : FeatureLearningGeneric ( _conf, _section )
+{ 
+  
+  // define the initial number of clusters our codebook shall contain
+  initialNumberOfClusters = conf->gI(section, "initialNumberOfClusters", 10);
+  
+  // define the clustering algorithm to be used
+  std::string clusterAlgoString = conf->gS(section, "clusterAlgo", "kmeans");
+  
+  // define the distance function to be used
+  std::string distFunctionString = conf->gS(section, "distFunction", "euclidian");    
+  
+  
+  //**********************************************
+  //
+  //      SET UP VARIABLES AND METHODS
+  //             - FEATURE TYPE
+  //             - CLUSTERING ALGO
+  //             - DISTANCE FUNCTION
+  //             - ...
+  //
+  //**********************************************  
+  
+  std::cerr << " SET UP VARIABLES AND METHODS " << std::endl;
+
+  //feature extraction for initial codebook
+  this->featureExtractor = NULL;
+  this->setFeatureExtractor( true /* set for training */ );  
+  
+  //clustering algorithm
+  this->clusterAlgo = NULL;
+  this->setClusterAlgo( clusterAlgoString );
+  
+  if (distFunctionString.compare("euclidian") == 0)
+  {
+    distFunction = new NICE::EuclidianDistance<double>();
+  }
+  else
+  {
+    std::cerr << "Unknown vector distance selected, use euclidian instead" << std::endl;
+    distFunction = new NICE::EuclidianDistance<double>();
+  }    
+  
+  //run the training to initially compute a codebook and stuff like that
+  this->train( _md );  
+    
+  //so far, we have not seen any new image
+  this->newImageCounter = 0;
+  
+  //TODO stupid
+  this->maxValForVisualization = conf->gD( section, "stupidMaxValForVisualization", 0.005 ) ;
+  
+  
+  //feature extraction for unseen images
+  this->setFeatureExtractor( false /* set for training */ );    
+}
+
+FeatureLearningPrototypes::~FeatureLearningPrototypes()
+{
+  // clean-up
+  if ( clusterAlgo != NULL )
+    delete clusterAlgo;
+  if ( distFunction != NULL )
+    delete distFunction;
+  if ( featureExtractor != NULL )
+    delete featureExtractor; 
+}
+
+NICE::FloatImage FeatureLearningPrototypes::evaluateCurrentCodebookByDistance ( const std::string & _filename , const bool & beforeComputingNewFeatures )
+{
+  std::cerr << " VISUALIZATION -----    maxValForVisualization: " << maxValForVisualization << std::endl;
+  
+    NICE::ColorImage img( _filename );
+    if ( b_showTrainingImages )
+    {
+      showImage( img, "Input" );    
+    }
+    
+    int xsize ( img.width() );
+    int ysize ( img.height() );
+    
+    //variables to store feature information
+    NICE::VVector features;
+    NICE::VVector cfeatures;
+    NICE::VVector positions;
+
+    //compute features
+    Globals::setCurrentImgFN ( _filename );
+    featureExtractor->extractFeatures ( img, features, positions );
+    
+    //normalization
+    for ( NICE::VVector::iterator i = features.begin();
+          i != features.end();
+          i++)
+    {              
+      //normalization :)
+      i->normalizeL1();
+    }
+    
+    FloatImage noveltyImage ( xsize, ysize );
+    FloatImage noveltyImageGaussFiltered ( xsize, ysize );
+    
+    this->evaluateCurrentCodebookForGivenFeatures( features, positions, noveltyImageGaussFiltered, &noveltyImage );
+    
+    double maxDist ( noveltyImage.max() );
+    double maxFiltered ( noveltyImageGaussFiltered.max() );
+
+    std::cerr << "maximum distance of Training images: " << maxDist << std::endl;  
+    std::cerr << "maximum distance of Training images after filtering: " << maxFiltered << std::endl;      
+    if ( beforeComputingNewFeatures )
+      this->oldMaxDist = maxFiltered;
+
+    
+    //convert float to RGB
+    NICE::ColorImage noveltyImageRGB ( xsize, ysize  );
+    if ( beforeComputingNewFeatures )
+    {
+      imageToPseudoColorWithRangeSpecification( noveltyImageGaussFiltered, noveltyImageRGB, 0 /* min */, maxValForVisualization /* maxFiltered*/ /* max */ );
+      std::cerr << "set max value to: " << noveltyImageGaussFiltered.max() << std::endl;
+    }
+    else
+    {
+      imageToPseudoColorWithRangeSpecification( noveltyImageGaussFiltered, noveltyImageRGB, 0 /* min */, maxValForVisualization /*this->oldMaxDist*/ /* max */ );
+      std::cerr << "set max value to: " << this->oldMaxDist << std::endl;
+    }
+    
+    
+    
+    if ( b_showResults )
+      showImage(noveltyImageRGB, "Novelty Image");  
+    else 
+    {
+      std::vector< std::string > list2;
+      StringTools::split ( _filename, '/', list2 );      
+
+      std::string destination ( s_resultdir + NICE::intToString(this->newImageCounter -1 ) + "_" + list2.back() + "_3_updatedNoveltyMap.ppm");
+      if ( beforeComputingNewFeatures )
+        destination  =  s_resultdir + NICE::intToString(this->newImageCounter) + "_" + list2.back() + "_0_initialNoveltyMap.ppm";
+
+      noveltyImageRGB.writePPM( destination );
+    }
+        
+    // now look where the closest features for the current cluster indices are
+    int tmpProtCnt ( 0 );
+    for (NICE::VVector::const_iterator protIt = prototypes.begin(); protIt != prototypes.end(); protIt++, tmpProtCnt++)
+    {
+      double distToCurrentCluster ( std::numeric_limits<double>::max() );
+      int indexOfMostSimFeat( 0 );
+      double tmpDist;
+      int featureCnt ( 0 );
+      
+      for ( NICE::VVector::iterator i = features.begin();
+            i != features.end();
+            i++, featureCnt++)
+      {
+        tmpDist = this->distFunction->calculate( *i, *protIt );
+        if ( tmpDist < distToCurrentCluster )
+        {
+          distToCurrentCluster = tmpDist;
+          indexOfMostSimFeat = featureCnt;
+        }
+      }
+      
+      int posX ( ( positions[indexOfMostSimFeat] ) [0]  );
+      int posY ( ( positions[indexOfMostSimFeat] ) [1]  );
+      
+      //position (for OpponentSIFT of van de Sande): x y scale orientation cornerness
+      
+      /*What is the interpretation of scale?
+
+      The scale parameter was implemented to correspond with the Gaussian filter sigma at which points were detected. Therefore, the
+      scale is not directly interpretable as the size of the region described in terms of number of pixels. However, it is linearly
+      related the radius of the circular area described. To capture the area of the Gaussian originally used, we have a 3x 
+      magnification factor. But, remember that SIFT has 4x4 cells, and this is a measure for a single cell. So, because we are 
+      working with a radius, multiply by 2. Due to the square shape of the region, we need to extend the outer radius even further 
+      by sqrt(2), otherwise the corners of the outer cells are cut off by our circle. So, the largest outer radius is 
+      Round(scale * 3 * 2 * sqrt(2)). The area from which the SIFT descriptor is computed is a square which fits within a circle 
+      of this radius. Also, due to the Gaussian weighting applied within SIFT, the area that really matters is much, much smaller: 
+      the outer parts get a low weight. 
+
+      For the default scale of 1.2, we get a outer circle radius of 10. The potential sampling area then becomes -10..10, e.g. a 
+      21x21patch. However, the square area which fits inside this circle is smaller: about 15x15. The corners of this 15x15square 
+      touch the outer circle. */
+      
+      /*Why is the direction (angle) field always 0?
+
+
+      Estimating the dominant orientation of a descriptor is useful in matching scenarios. However, in an object/scene categorization
+      setting, the additional invariance reduces accuracy. Being able to discriminate between dominant directions of up and right 
+      is very useful here, and rotated down images are quite rare in an object categorization setting. Therefore, orientation 
+      estimation is disabled in the color descriptor software. The subsequent rotation of the descriptor to achieve 
+      rotation-invariance is still possible by supplying your own regions and angles for an image (through --loadRegions). However, 
+      by default, no such rotation is performed, since the default angle is 0. */      
+      
+      
+      //adapt the pseudo color transformation as done in Convert.cpp
+        size_t seg = ( size_t ) ( tmpProtCnt/(float)prototypes.size() * 6.0 );
+        double y   = ( 6 * tmpProtCnt/(float)prototypes.size() - seg );
+
+        Color circleColor;
+        switch ( seg ) {
+          case 0:
+            circleColor = Color( 0,0,(int)round(y*255) );
+            break;
+          case 1:
+            circleColor = Color( 0,(int)round(y*255),255 );
+            break;
+          case 2:
+            circleColor = Color( 0,255,(int)round((1-y)*255) );
+            break;
+          case 3:
+            circleColor = Color( (int)round(y*255),255,0 );
+            break;
+          case 4:
+            circleColor = Color( 255,(int)round((1-y)*255),0 );
+            break;
+          case 5:
+            circleColor = Color( 255,(int)round(y*255),(int)round(y*255) );
+            break;
+          default:
+            circleColor = Color( 255,255,255 );
+            break;
+        }      
+      
+      NICE::Circle circ ( Coord( posX, posY), (int) round(2*3*sqrt(2)*( positions[indexOfMostSimFeat] )[2]) /* radius*/, circleColor );
+      img.draw(circ);  
+    }
+        
+   if ( b_showResults )
+      showImage(img, "Current image and most similar features for current prototypes"); 
+   else
+   {
+      std::vector< std::string > list2;
+      StringTools::split ( _filename, '/', list2 );      
+
+      std::string destination ( s_resultdir + NICE::intToString(this->newImageCounter-1) + "_" + list2.back() + "_3_updatedCurrentCluster.ppm");
+      if ( beforeComputingNewFeatures )
+        destination  =  s_resultdir + NICE::intToString(this->newImageCounter) + "_" + list2.back() + "_0_initialCurrentCluster.ppm";
+      
+      img.writePPM( destination );
+   }
+   
+   return noveltyImageGaussFiltered;
+}
+
+NICE::ImageT< int > FeatureLearningPrototypes::evaluateCurrentCodebookByAssignments(const std::string& _filename, const bool& beforeComputingNewFeatures, const bool & _binaryShowLatestPrototype)
+{
+  std::cerr << "evaluateCurrentCodebookByAssignments" << std::endl;
+  NICE::ColorImage img( _filename );
+  
+  int xsize ( img.width() );
+  int ysize ( img.height() );
+  
+  //variables to store feature information
+  NICE::VVector features;
+  NICE::VVector cfeatures;
+  NICE::VVector positions;
+
+  //compute features
+  Globals::setCurrentImgFN ( _filename );
+  featureExtractor->extractFeatures ( img, features, positions );
+  
+  //normalization
+  for ( NICE::VVector::iterator i = features.begin();
+        i != features.end();
+        i++)
+  {              
+    //normalization :)
+    i->normalizeL1();
+  }
+  
+  //this is the image we will return finally
+  NICE::ImageT< int > clusterImage ( xsize, ysize );
+  clusterImage.set ( 0 );
+  
+  // after iterating over all features from the new image, this vector contains
+  // distances to the most similar feature for every prototype
+  NICE::Vector minDistances ( this->prototypes.size() );
+  
+  NICE::VVector::const_iterator posIt = positions.begin();
+  for ( NICE::VVector::const_iterator i = features.begin();
+        i != features.end();
+        i++, posIt++ )
+  {              
+    
+    //loop over codebook representatives
+    double minDist ( std::numeric_limits<double>::max() );
+    int indexOfNearestPrototype ( 0 );
+    int prototypeCounter ( 0 );
+    for (NICE::VVector::const_iterator it =  this->prototypes.begin(); it != this->prototypes.end(); it++, prototypeCounter++)
+    {
+      //compute distance
+      double tmpDist ( this->distFunction->calculate(*i,*it) );
+      //check what the closest prototype is
+      if (tmpDist < minDist)
+      {
+        minDist = tmpDist;
+        indexOfNearestPrototype = prototypeCounter;
+      }
+      
+      //check whether we found a feature for the current prototype which is more similar then the previous best one
+      if ( minDistances[ prototypeCounter ] > tmpDist )
+        minDistances[ prototypeCounter ] = tmpDist;      
+    }
+    
+
+    
+    
+    //take minimum distance and store in in a float image    
+    // for nice visualization, we plot the cluster index into a square of size 3 x 3
+    //TODO currently hard coded!!!
+    int noProtoTypes ( this->prototypes.size() -1 );
+    
+    for ( int tmpY = (*posIt)[1]  - 1; tmpY < (*posIt)[1]  + 1; tmpY++)
+    {
+      for ( int tmpX = (*posIt)[0]  - 1; tmpX < (*posIt)[0]  + 1; tmpX++)
+      {
+        if ( _binaryShowLatestPrototype )
+        {
+          //just a binary image - 1 if newest prototype is nearest - 0 if not
+          if  ( indexOfNearestPrototype == noProtoTypes)
+            clusterImage ( tmpX, tmpY ) = 1;
+          else
+            clusterImage ( tmpX, tmpY ) = 0;
+        }
+        else
+          //as many different values as current prototypes available
+          clusterImage ( tmpX, tmpY ) = indexOfNearestPrototype;  
+      }
+    }
+  } 
+  
+  std::cerr << "Codebook evaluation by assignments... min distances in image for every prototype: " << std::endl << "    " << minDistances << std::endl;
+  
+  //show how many clusters we have
+  if ( !_binaryShowLatestPrototype )  
+  {
+    int tmpCnt ( 0 );
+    for (NICE::VVector::const_iterator protoIt = prototypes.begin(); protoIt != prototypes.end(); protoIt++, tmpCnt++)
+    {
+      for ( int tmpY = 1 + 2 - 2; tmpY < (2  + 2); tmpY++)
+        {
+          for ( int tmpX = 1 + 4*tmpCnt ; tmpX < (1 + 4*tmpCnt  + 3); tmpX++)
+          {
+            //Take care, this might go "over" the image
+            clusterImage ( tmpX, tmpY ) = (Ipp8u) tmpCnt;
+          }
+        }   
+    }
+  }
+  
+  return clusterImage;
+}
+
+void FeatureLearningPrototypes::evaluateCurrentCodebookByConfusionMatrix( NICE::Matrix & _confusionMat )
+{
+  _confusionMat.resize ( this->prototypes.size(), this->prototypes.size() );
+  _confusionMat.set( 0.0 );
+  
+  double tmpDist ( 0.0 );
+  NICE::VVector::const_iterator protoItJ = prototypes.begin();
+  for ( int j = 0; j < prototypes.size(); j++, protoItJ++)
+  {
+    NICE::VVector::const_iterator protoItI = protoItJ; 
+    for ( int i = j; i < prototypes.size(); i++, protoItI++)
+    {
+      tmpDist = this->distFunction->calculate( *protoItJ, *protoItI );
+      
+      //assuming symmetric distances
+      _confusionMat ( i, j ) = tmpDist;
+//       if ( i != j )
+//         _confusionMat ( j, i ) = tmpDist;  
+    }
+  }
+}
+
+NICE::VVector * FeatureLearningPrototypes::getCurrentCodebook()
+{
+  return &(this->prototypes);
+}
+

featureLearning/FeatureLearningPrototypes.h

@@ -0,0 +1,127 @@
+/**
+ * @file FeatureLearningPrototypes.h
+ * @brief compute new histogram entries somehow, represent clusters only based on representatives, no additional information like dimensionwise variances...
+ * @author Alexander Freytag
+ * @date 17-04-2013 (dd-mm-yyyy)
+*/
+#ifndef _INCLUDEFEATURELEARNINGPROTOTYPES
+#define _INCLUDEFEATURELEARNINGPROTOTYPES
+
+#include "FeatureLearningGeneric.h"
+
+
+#include <core/vector/Distance.h>
+#include <core/vector/VVector.h>
+
+#include <vislearning/cbaselib/MultiDataset.h>
+// 
+#include <vislearning/features/localfeatures/GenericLocalFeatureSelection.h>
+#include <vislearning/features/simplefeatures/CodebookPrototypes.h>
+// 
+#include <vislearning/math/cluster/ClusterAlgorithm.h>
+
+
+
+
+namespace OBJREC
+{
+
+  /**
+   * @class FeatureLearningPrototypes
+   * @brief compute new histogram entries somehow, represent clusters only based on representatives, no additional information like dimensionwise variances...
+   * @author Alexander Freytag
+   * @date 17-04-2013 (dd-mm-yyyy)
+  */  
+  
+  class FeatureLearningPrototypes : public FeatureLearningGeneric
+  {
+
+    protected:
+      
+      /************************
+       * 
+       *   protected variables
+       * 
+       **************************/       
+           
+      bool showTrainingImages;
+      
+      //! define the initial number of clusters our codebook shall contain
+      int initialNumberOfClusters;       
+      
+      OBJREC::ClusterAlgorithm * clusterAlgo;      
+  
+      NICE::VectorDistance<double> * distFunction;
+
+      LocalFeatureRepresentation * featureExtractor;
+      
+      //! The currently known "cluster" centers, which are used for BoW histogram computation 
+//       NICE::VVector prototypes;     
+      OBJREC::CodebookPrototypes prototypes;   
+            
+      int newImageCounter;
+      //just needed for visualisation
+      double oldMaxDist;
+      
+      //TODO stupid!!!
+      double maxValForVisualization;
+      
+      //! just for temporary debugging
+      int i_posXOfNewPrototype;
+      int i_posYOfNewPrototype;      
+            
+      
+      /************************
+       * 
+       *   protected methods
+       * 
+       **************************/
+            
+      void setClusterAlgo( const std::string & _clusterAlgoString);
+      void setFeatureExtractor( const bool & _setForTraining = false);
+      
+      void extractFeaturesFromTrainingImages(  const OBJREC::MultiDataset *_md,  NICE::VVector & examplesTraining  ); 
+      
+      void train ( const OBJREC::MultiDataset *_md ); 
+      
+      virtual bool loadInitialCodebook ( );
+      virtual bool writeInitialCodebook ( );      
+      
+      virtual void evaluateCurrentCodebookForGivenFeatures (  const NICE::VVector & _features,
+                                                              const NICE::VVector & _positions,
+                                                              NICE::FloatImage & _noveltyImageGaussFiltered,
+                                                              NICE::FloatImage * _noveltyImage = NULL                                                              
+                                                            );
+
+    public:
+
+      /** constructor
+        * @param _conf needs a configfile
+        * @param _md and a MultiDataset (contains images and other things)
+        * @param _section section information for parsing config files
+        */
+      FeatureLearningPrototypes ( const NICE::Config *_conf, const OBJREC::MultiDataset *_md , const std::string & _section = "featureLearning");
+
+      /** simple destructor */
+      virtual ~FeatureLearningPrototypes();
+      
+      /** this function has to be overloaded by all subclasses
+          @param imgWithNovelContent 
+      */
+      virtual void learnNewFeatures ( const std::string & _filename ) = 0 ;
+      
+      virtual NICE::FloatImage evaluateCurrentCodebookByDistance ( const std::string & _filename , const bool & beforeComputingNewFeatures = true );
+      
+      virtual NICE::ImageT<int> evaluateCurrentCodebookByAssignments ( const std::string & _filename , const bool & beforeComputingNewFeatures = true, const bool & _binaryShowLatestPrototype = false);            
+      
+      virtual void evaluateCurrentCodebookByConfusionMatrix( NICE::Matrix & _confusionMat ); 
+      
+      virtual NICE::VVector * getCurrentCodebook();
+      
+
+  };
+
+
+} // namespace
+
+#endif

featureLearning/FeatureLearningRegionBased.cpp

@@ -0,0 +1,324 @@
+
+#include "FeatureLearningRegionBased.h"
+
+//STL
+#include <iostream>
+
+//core
+#include <core/image/FilterT.h>
+#include <core/image/CircleT.h>
+#include <core/image/Convert.h>
+#include <core/vector/VectorT.h>
+
+#include <segmentation/GenericRegionSegmentationMethodSelection.h>
+
+//vislearning
+#include <vislearning/baselib/Globals.h>
+
+
+using namespace std;
+using namespace NICE;
+using namespace OBJREC;
+
+  //**********************************************
+  //
+  //                 PROTECTED METHODS
+  //
+  //********************************************** 
+
+
+  //**********************************************
+  //
+  //                 PUBLIC METHODS
+  //
+  //********************************************** 
+
+
+FeatureLearningRegionBased::FeatureLearningRegionBased ( const Config *_conf,
+                               const MultiDataset *_md, const std::string & _section )
+    : FeatureLearningPrototypes ( _conf, _md, _section )
+{ 
+
+   //save and read segmentation results from files  
+  this->reuseSegmentation = conf->gB ( "FPCPixel", "reuseSegmentation", true );  
+  
+  // select your segmentation method here
+  // currently, the following options are supported: "MarkovCluster", "GraphBased", "MeanShift", "SLIC"
+  string rsMethode = conf->gS ( section, "segmentationMethod", "MeanShift" );
+ 
+  OBJREC::RegionSegmentationMethod *tmpRegionSeg = OBJREC::GenericRegionSegmentationMethodSelection::selectRegionSegmentationMethod(conf, rsMethode);    
+  
+  if ( reuseSegmentation )
+    this->segmentationAlgo = new RSCache ( conf, tmpRegionSeg );
+  else
+    this->segmentationAlgo = tmpRegionSeg;
+  
+  this->i_gridSize = conf->gI( "LFColorSandeTest" , "grid" , 5 );
+}
+
+FeatureLearningRegionBased::~FeatureLearningRegionBased()
+{
+  // clean-up
+}
+
+void FeatureLearningRegionBased::learnNewFeatures ( const std::string & _filename )
+{  
+  NICE::ColorImage img( _filename );
+  
+  int xsize ( img.width() );
+  int ysize ( img.height() );
+   
+  //variables to store feature information
+  NICE::VVector newFeatures;
+  NICE::VVector cfeatures;
+  NICE::VVector positions;
+
+  //compute features
+  std::cerr << " EXTRACT FEATURES FROM UNSEEN IMAGE" << std::endl;
+  Globals::setCurrentImgFN ( _filename );
+  featureExtractor->extractFeatures ( img, newFeatures, positions );  
+    
+  //normalization :)
+  for ( NICE::VVector::iterator i = newFeatures.begin();
+        i != newFeatures.end();
+        i++)
+  {              
+    i->normalizeL1();
+  }
+  
+  //compute region segmentation
+  std::cerr << " COMPUTE REGION SEGMENTATION" << std::endl;
+  NICE::Matrix mask;
+  int amountRegions = segmentationAlgo->segRegions ( img, mask );
+  
+  //compute novelty scores on a feature level
+  std::cerr << " COMPUTE NOVELTY SCORES ON A FEATURE LEVEL" << std::endl;
+  FloatImage noveltyImageGaussFiltered ( xsize, ysize );    
+  this->evaluateCurrentCodebookForGivenFeatures( newFeatures, positions, noveltyImageGaussFiltered );  
+  
+  // compute scores for every region
+  std::cerr << " COMPUTE SCORES FOR EVERY REGION" << std::endl;
+  std::vector<double> regionNoveltyMeasure (amountRegions, 0.0); 
+  std::vector<int> regionSize (amountRegions, 0);
+  
+  for ( int y = 0; y < ysize; y += i_gridSize) //y++)
+  {
+    for (int x = 0; x < xsize; x += i_gridSize) //x++)
+    {
+      int r = mask(x,y);
+      regionSize[r]++;
+
+      //count the amount of "novelty" for the corresponding region
+      regionNoveltyMeasure[r] += noveltyImageGaussFiltered(x,y);
+    }
+  }
+  
+  //loop over all regions and compute averaged novelty scores
+  //NOTE this might be unuseful, since lateron we combine novelty score and region size (e.g. by multiplying)
+  // however, we do not want to settle the combination in adavance
+  for(int r = 0; r < amountRegions; r++)
+  {      
+    regionNoveltyMeasure[r] /= regionSize[r];  
+  }
+
+   //a new region should cover at least 3% of the image for not being penalized
+  double d_minimalImageAmountForAcceptableRegions ( 0.03 );
+  int minimalImageAmountForAcceptableRegions ( round( d_minimalImageAmountForAcceptableRegions * (xsize/i_gridSize) * (ysize/i_gridSize) )  );
+  
+  std::cerr << "minimalImageAmountForAcceptableRegions: " << minimalImageAmountForAcceptableRegions << std::endl;
+  
+  //compute final scores for all regions
+  NICE::Vector regionScores ( amountRegions, 0.0 );  
+  std::cerr << "used region sizes for computation: " << std::endl;
+  for(int r = 0; r < amountRegions; r++)
+  {      
+    regionScores[r] = std::min( regionSize[r], minimalImageAmountForAcceptableRegions ) * regionNoveltyMeasure[r];
+    std::cerr << " " << std::min( regionSize[r], minimalImageAmountForAcceptableRegions );
+  }
+  std::cerr << std::endl << std::endl;
+  
+  int indexOfBestRegion ( regionScores.MaxIndex() );
+  
+  
+  ////////////////////////////////////
+  //
+  //       VISUALIZE REGION SCORES
+  //
+  ////////////////////////////////////
+  
+  NICE::FloatImage regionScoreImage ( xsize, ysize );
+  NICE::FloatImage regionNoveltyImage ( xsize, ysize ); //contains novelty score averaged over region
+  NICE::FloatImage regionRelevanceImage ( xsize, ysize ); //contains higher scores for larger regions (but with upper limit)
+  
+  regionScoreImage.set( 0.0 );
+  regionNoveltyImage.set( 0.0 );
+  regionRelevanceImage.set( 0.0 );
+  
+    for ( int y = 0; y < ysize; y++)
+    {
+      for (int x = 0; x < xsize; x++)
+      {
+        int r = mask(x,y);
+
+        regionNoveltyImage(x,y) = regionNoveltyMeasure[r];
+        regionRelevanceImage(x,y) = regionSize[r];
+        regionScoreImage(x,y) = regionScores[r];
+      }
+    }  
+    
+    std::cerr << "highest region score: " << regionScoreImage.max()<< " -- smallest region score: " << regionScoreImage.min() << std::endl;
+    std::cerr << "highest region novelty score: " << regionNoveltyImage.max() << "  -- smallest region novelty score: " << regionNoveltyImage.min() << std::endl;
+    
+  NICE::ColorImage regionScoreImageRGB  ( xsize, ysize );
+  NICE::ColorImage regionNoveltyScoreImageRGB  ( xsize, ysize );
+  NICE::ColorImage regionRelevanceScoreImageRGB  ( xsize, ysize );
+  //TODO properly specify the maximum value for score visualization here :)
+  imageToPseudoColorWithRangeSpecification( regionScoreImage, regionScoreImageRGB, 0 /* min */, 2.2 /* max */ );  
+  imageToPseudoColorWithRangeSpecification( regionNoveltyImage, regionNoveltyScoreImageRGB, 0 /* min */, 0.012 /* max */ );  
+  imageToPseudoColorWithRangeSpecification( regionRelevanceImage, regionRelevanceScoreImageRGB, 0 /* min */, minimalImageAmountForAcceptableRegions /* max */ );  
+
+    if ( b_showResults )
+    {
+      showImage(regionNoveltyScoreImageRGB, "Current (new) image with region NOVELTY scores"); 
+      showImage(regionRelevanceScoreImageRGB, "Current (new) image with region RELEVANCE scores"); 
+      showImage(regionScoreImageRGB, "Current (new) image with FINAL region scores"); 
+    }
+    else 
+    {
+      std::vector< std::string > list2;
+      StringTools::split ( _filename, '/', list2 );      
+     
+      //write novelty score image
+      std::string destinationNovelty ( s_resultdir + NICE::intToString(this->newImageCounter) + "_" + list2.back() + "_1_1_regionNoveltyScores.ppm");
+      regionNoveltyScoreImageRGB.writePPM( destinationNovelty );
+      
+      //write relevance score image
+      std::string destinationRelevance ( s_resultdir + NICE::intToString(this->newImageCounter) + "_" + list2.back() + "_1_2_regionRelevanceScores.ppm");
+      regionRelevanceScoreImageRGB.writePPM( destinationRelevance );      
+
+      //write image with final scores for region
+      std::string destination ( s_resultdir + NICE::intToString(this->newImageCounter) + "_" + list2.back() + "_1_3_regionScores.ppm");
+      regionScoreImageRGB.writePPM( destination );
+    }  
+  
+  
+  //compute representative for best region
+  
+  NICE::Vector representative ( newFeatures.begin()->size(), 0.0 );
+  
+//   //FIRST TRY: average feature vectors of the "best" region
+//   NICE::VVector::const_iterator posIt = positions.begin();
+//   for ( NICE::VVector::const_iterator featIt = newFeatures.begin();
+//         featIt != newFeatures.end();
+//         featIt++, posIt++)
+//   {              
+//     
+//     //only considere features that actually belong to the best region
+//     if ( mask( (*posIt)[0], (*posIt)[1] ) != indexOfBestRegion )
+//       continue;
+//     
+//     representative += *featIt;
+//   } 
+//   
+//   //simple mean feature vector
+//   representative /= regionSize[indexOfBestRegion];
+//   //normalization
+//   representative.normalizeL1();
+  
+//   //SECOND TRY: simply take the first feature vector of the "best" region (although this one should lay on the border, and so on...)
+//   NICE::VVector::const_iterator posIt = positions.begin();
+//   for ( NICE::VVector::const_iterator featIt = newFeatures.begin();
+//         featIt != newFeatures.end();
+//         featIt++, posIt++)
+//   {              
+//     
+//     //only considere features that actually belong to the best region
+//     if ( mask( (*posIt)[0], (*posIt)[1] ) != indexOfBestRegion )
+//       continue;
+//     
+//     representative = *featIt;
+//     i_posXOfNewPrototype = (*posIt)[0];
+//     i_posYOfNewPrototype = (*posIt)[1];
+//     //break after the first positive feature
+//     break;
+//   }   
+  
+  //THIRD TRY: simply take the feature vector of the "best" region with largest novelty score within this region
+  // ... (hopefully, this is no outlier wrt to this region...)
+  
+  double maxNovelty ( 0.0 );
+  NICE::VVector::const_iterator mostNovelFeature = newFeatures.begin() ;
+  
+  NICE::VVector::const_iterator posIt = positions.begin();
+  for ( NICE::VVector::const_iterator featIt = newFeatures.begin();
+        featIt != newFeatures.end();
+        featIt++, posIt++)
+  {              
+    
+    //only considere features that actually belong to the best region
+    if ( mask( (*posIt)[0], (*posIt)[1] ) != indexOfBestRegion )
+      continue;
+    
+    //did we found a feature of the "best"region with larger novelty score then the current most novel one?
+    if ( noveltyImageGaussFiltered( (*posIt)[0], (*posIt)[1] ) > maxNovelty )
+    {
+      maxNovelty = noveltyImageGaussFiltered( (*posIt)[0], (*posIt)[1] );
+      mostNovelFeature = featIt;
+      i_posXOfNewPrototype = (*posIt)[0];
+      i_posYOfNewPrototype = (*posIt)[1];
+    }
+  }
+  representative = *mostNovelFeature;
+  
+  std::cerr << " New representative: " << std::endl << representative << std::endl;
+  
+  //include the chosen information into the currently used prototypes
+  prototypes.push_back( representative ); 
+  
+  if ( b_evaluationWhileFeatureLearning ) 
+  {
+    
+    NICE::ColorImage imgTmp( _filename );
+    
+    double distToNewCluster ( std::numeric_limits<double>::max() );
+    int indexOfMostSimFeat( 0 );
+    double tmpDist;
+    int tmpCnt ( 0 );
+    
+    for ( NICE::VVector::iterator i = newFeatures.begin();
+          i != newFeatures.end();
+          i++, tmpCnt++)
+    {
+      tmpDist = this->distFunction->calculate( *i, representative );
+      if ( tmpDist < distToNewCluster )
+      {
+        distToNewCluster = tmpDist;
+        indexOfMostSimFeat = tmpCnt;
+      }
+    }
+    
+    std::cerr << "** minDist to new cluster: " <<distToNewCluster << std::endl;
+    
+    int posX ( ( positions[indexOfMostSimFeat] ) [0]  );
+    int posY ( ( positions[indexOfMostSimFeat] ) [1]  );
+    
+    std::cerr << "position of most similar feature --- posX: " << posX << " - posY " << posY << std::endl;
+    std::cerr << "position of new prototype        --- posX: " << i_posXOfNewPrototype << " - posY " << i_posYOfNewPrototype << std::endl;
+    NICE::Circle circ ( Coord( posX, posY), 10 /* radius*/, Color(200,0,255) );
+    imgTmp.draw(circ); 
+    
+    if ( b_showResults )
+      showImage(imgTmp, "Current (new) image and most similar feature for new cluster"); 
+    else 
+    {
+      std::vector< std::string > list2;
+      StringTools::split ( _filename, '/', list2 );      
+
+      std::string destination ( s_resultdir + NICE::intToString(this->newImageCounter) + "_" + list2.back() + "_2_bestNewCluster.ppm");
+      imgTmp.writePPM( destination );
+    }
+  }  
+  
+  //this was a new image, so we increase our internal counter
+  (this->newImageCounter)++;  
+}

featureLearning/FeatureLearningRegionBased.h

@@ -0,0 +1,73 @@
+/**
+ * @file FeatureLearningRegionBased.h
+ * @brief compute new histogram entries by extracting features from (moderately large) regions which have high novelty scores
+ * @author Alexander Freytag
+ * @date 17-04-2013 (dd-mm-yyyy)
+*/
+#ifndef _INCLUDEFEATURELEARNINGREGIONBASED
+#define _INCLUDEFEATURELEARNINGREGIONBASED
+
+#include "FeatureLearningPrototypes.h"
+
+#include "segmentation/RegionSegmentationMethod.h"
+
+
+namespace OBJREC
+{
+
+  /**
+   * @class FeatureLearningRegionBased
+   * @briefcompute new histogram entries by extracting features from (moderately large) regions which have high novelty scores
+   * @author Alexander Freytag
+   * @date 17-04-2013 (dd-mm-yyyy)
+  */  
+  
+  class FeatureLearningRegionBased : public FeatureLearningPrototypes
+  {
+
+    protected:
+
+      /************************
+       * 
+       *   protected variables
+       * 
+       **************************/  
+      
+      //! low level Segmentation method
+      RegionSegmentationMethod *segmentationAlgo;      
+      
+      //! boolean whether to reuse segmentation results for single images in different runs
+      bool reuseSegmentation;      
+      
+      //! determine a grid on which we extract local features
+      int i_gridSize;
+
+      /************************
+       * 
+       *   protected methods
+       * 
+       **************************/      
+
+
+    public:
+
+      /** constructor
+        *  @param _conf needs a configfile
+        *  @param _md and a MultiDataset (contains images and other things)
+        */
+      FeatureLearningRegionBased ( const NICE::Config *_conf, const OBJREC::MultiDataset *_md , const std::string & _section = "featureLearning");
+
+      /** simple destructor */
+      virtual ~FeatureLearningRegionBased();
+      
+      /** this function has to be overloaded by all subclasses
+          @param imgWithNovelContent 
+      */
+      virtual void learnNewFeatures ( const std::string & filename );
+      
+  };
+
+
+} // namespace
+
+#endif

featureLearning/Makefile

@@ -0,0 +1,8 @@
+#TARGETS_FROM:=$(notdir $(patsubst %/,%,$(shell pwd)))/$(TARGETS_FROM)
+#$(info recursivly going up: $(TARGETS_FROM) ($(shell pwd)))
+
+all:
+
+%:
+	$(MAKE) TARGETS_FROM=$(notdir $(patsubst %/,%,$(shell pwd)))/$(TARGETS_FROM) -C .. $@
+

featureLearning/Makefile.inc

@@ -0,0 +1,103 @@
+# LIBRARY-DIRECTORY-MAKEFILE
+# conventions:
+# - all subdirectories containing a "Makefile.inc" are considered sublibraries
+#   exception: "progs/" and "tests/" subdirectories!
+# - all ".C", ".cpp" and ".c" files in the current directory are linked to a
+#   library
+# - the library depends on all sublibraries 
+# - the library name is created with $(LIBNAME), i.e. it will be somehow
+#   related to the directory name and with the extension .a
+#   (e.g. lib1/sublib -> lib1_sublib.a)
+# - the library will be added to the default build list ALL_LIBRARIES
+
+# --------------------------------
+# - remember the last subdirectory
+#
+# set the variable $(SUBDIR) correctly to the current subdirectory. this
+# variable can be used throughout the current makefile.inc. The many 
+# SUBDIR_before, _add, and everything are only required so that we can recover
+# the previous content of SUBDIR before exitting the makefile.inc
+
+SUBDIR_add:=$(dir $(word $(words $(MAKEFILE_LIST)),$(MAKEFILE_LIST)))
+SUBDIR_before:=$(SUBDIR)
+SUBDIR:=$(strip $(SUBDIR_add))
+SUBDIR_before_$(SUBDIR):=$(SUBDIR_before)
+ifeq "$(SUBDIR)" "./"
+SUBDIR:=
+endif
+
+# ------------------------
+# - include subdirectories
+#
+# note the variables $(SUBDIRS_OF_$(SUBDIR)) are required later on to recover
+# the dependencies automatically. if you handle dependencies on your own, you
+# can also dump the $(SUBDIRS_OF_$(SUBDIR)) variable, and include the
+# makefile.inc of the subdirectories on your own...
+
+SUBDIRS_OF_$(SUBDIR):=$(patsubst %/Makefile.inc,%,$(wildcard $(SUBDIR)*/Makefile.inc))
+include $(SUBDIRS_OF_$(SUBDIR):%=%/Makefile.inc)
+
+# ----------------------------
+# - include local dependencies
+#
+# you can specify libraries needed by the individual objects or by the whole
+# directory. the object specific additional libraries are only considered
+# when compiling the specific object files
+# TODO: update documentation...
+
+-include $(SUBDIR)libdepend.inc
+
+$(foreach d,$(filter-out %progs %tests,$(SUBDIRS_OF_$(SUBDIR))),$(eval $(call PKG_DEPEND_INT,$(d))))
+
+# ---------------------------
+# - objects in this directory
+#
+# the use of the variable $(OBJS) is not mandatory. it is mandatory however
+# to update $(ALL_OBJS) in a way that it contains the path and name of
+# all objects. otherwise we can not include the appropriate .d files.
+
+OBJS:=$(patsubst %.cpp,$(OBJDIR)%.o,$(notdir $(wildcard $(SUBDIR)*.cpp))) \
+      $(patsubst %.C,$(OBJDIR)%.o,$(notdir $(wildcard $(SUBDIR)*.C))) \
+	  $(shell grep -ls Q_OBJECT $(SUBDIR)*.h | sed -e's@^@/@;s@.*/@$(OBJDIR)moc_@;s@\.h$$@.o@') \
+      $(patsubst %.c,$(OBJDIR)%.o,$(notdir $(wildcard $(SUBDIR)*.c)))
+ALL_OBJS += $(OBJS)
+
+# ----------------------------
+# - binaries in this directory
+#
+# output of binaries in this directory. none of the variables has to be used.
+# but everything you add to $(ALL_LIBRARIES) and $(ALL_BINARIES) will be
+# compiled with `make all`. be sure again to add the files with full path.
+
+LIBRARY_BASENAME:=$(call LIBNAME,$(SUBDIR))
+ifneq "$(SUBDIR)" ""
+ALL_LIBRARIES+=$(LIBDIR)$(LIBRARY_BASENAME).$(LINK_FILE_EXTENSION)
+endif
+
+# ---------------------
+# - binary dependencies
+#
+# there is no way of determining the binary dependencies automatically, so we
+# follow conventions. the current library depends on all sublibraries.
+# all other dependencies have to be added manually by specifying, that the
+# current .pc file depends on some other .pc file. binaries depending on
+# libraries should exclusivelly use the .pc files as well.
+
+ifeq "$(SKIP_BUILD_$(OBJDIR))" "1"
+$(LIBDIR)$(LIBRARY_BASENAME).a:
+else
+$(LIBDIR)$(LIBRARY_BASENAME).a:$(OBJS) \
+	$(call PRINT_INTLIB_DEPS,$(PKGDIR)$(LIBRARY_BASENAME).a,.$(LINK_FILE_EXTENSION))
+endif
+
+$(PKGDIR)$(LIBRARY_BASENAME).pc: \
+	$(call PRINT_INTLIB_DEPS,$(PKGDIR)$(LIBRARY_BASENAME).pc,.pc)
+
+# -------------------
+# - subdir management
+#
+# as the last step, always add this line to correctly recover the subdirectory
+# of the makefile including this one!
+
+SUBDIR:=$(SUBDIR_before_$(SUBDIR))
+

featureLearning/libdepend.inc

@@ -0,0 +1,6 @@
+$(call PKG_DEPEND_INT,core/)
+$(call PKG_DEPEND_INT,vislearning/baselib/)
+$(call PKG_DEPEND_INT,vislearning/cbaselib/)
+$(call PKG_DEPEND_INT,vislearning/features/)
+$(call PKG_DEPEND_INT,vislearning/math/)
+$(call PKG_DEPEND_INT,segmentation/)

featureLearning/progs/Makefile

@@ -0,0 +1,8 @@
+#TARGETS_FROM:=$(notdir $(patsubst %/,%,$(shell pwd)))/$(TARGETS_FROM)
+#$(info recursivly going up: $(TARGETS_FROM) ($(shell pwd)))
+
+all:
+
+%:
+	$(MAKE) TARGETS_FROM=$(notdir $(patsubst %/,%,$(shell pwd)))/$(TARGETS_FROM) -C .. $@
+

featureLearning/progs/Makefile.inc

@@ -0,0 +1,88 @@
+# BINARY-DIRECTORY-MAKEFILE
+# conventions:
+# - there are no subdirectories, they are ignored!
+# - all ".C", ".cpp" and ".c" files in the current directory are considered
+#   independent binaries, and linked as such.
+# - the binaries depend on the library of the parent directory
+# - the binary names are created with $(BINNAME), i.e. it will be more or less
+#   the name of the .o file
+# - all binaries will be added to the default build list ALL_BINARIES
+
+# --------------------------------
+# - remember the last subdirectory
+#
+# set the variable $(SUBDIR) correctly to the current subdirectory. this
+# variable can be used throughout the current makefile.inc. The many 
+# SUBDIR_before, _add, and everything are only required so that we can recover
+# the previous content of SUBDIR before exitting the makefile.inc
+
+SUBDIR_add:=$(dir $(word $(words $(MAKEFILE_LIST)),$(MAKEFILE_LIST)))
+SUBDIR_before:=$(SUBDIR)
+SUBDIR:=$(strip $(SUBDIR_add))
+SUBDIR_before_$(SUBDIR):=$(SUBDIR_before)
+
+# ------------------------
+# - include subdirectories
+#
+# note the variables $(SUBDIRS_OF_$(SUBDIR)) are required later on to recover
+# the dependencies automatically. if you handle dependencies on your own, you
+# can also dump the $(SUBDIRS_OF_$(SUBDIR)) variable, and include the
+# makefile.inc of the subdirectories on your own...
+
+#SUBDIRS_OF_$(SUBDIR):=$(patsubst %/Makefile.inc,%,$(wildcard $(SUBDIR)*/Makefile.inc))
+#include $(SUBDIRS_OF_$(SUBDIR):%=%/Makefile.inc)
+
+# ----------------------------
+# - include local dependencies
+#
+# include the libdepend.inc file, which gives additional dependencies for the
+# libraries and binaries. additionally, an automatic dependency from the library
+# of the parent directory is added (commented out in the code below).
+
+-include $(SUBDIR)libdepend.inc
+
+PARENTDIR:=$(patsubst %/,%,$(dir $(patsubst %/,%,$(SUBDIR))))
+$(eval $(call PKG_DEPEND_INT,$(PARENTDIR)))
+
+# ---------------------------
+# - objects in this directory
+#
+# the use of the variable $(OBJS) is not mandatory. it is mandatory however
+# to update $(ALL_OBJS) in a way that it contains the path and name of
+# all objects. otherwise we can not include the appropriate .d files.
+
+OBJS:=$(patsubst %.cpp,$(OBJDIR)%.o,$(notdir $(wildcard $(SUBDIR)*.cpp))) \
+      $(patsubst %.C,$(OBJDIR)%.o,$(notdir $(wildcard $(SUBDIR)*.C))) \
+      $(shell grep -ls Q_OBJECT $(SUBDIR)*.h | sed -e's@^@/@;s@.*/@$(OBJDIR)moc_@;s@\.h$$@.o@') \
+      $(patsubst %.c,$(OBJDIR)%.o,$(notdir $(wildcard $(SUBDIR)*.c)))
+ALL_OBJS += $(OBJS)
+
+# ----------------------------
+# - binaries in this directory
+#
+# output of binaries in this directory. none of the variables has to be used.
+# but everything you add to $(ALL_LIBRARIES) and $(ALL_BINARIES) will be
+# compiled with `make all`. be sure again to add the files with full path.
+
+BINARIES:=$(patsubst %.o,$(BINDIR)%,$(filter-out moc_%,$(notdir $(OBJS))))
+ALL_BINARIES+=$(BINARIES)
+
+# ---------------------
+# - binary dependencies
+#
+# there is no way of determining the binary dependencies automatically, so we
+# follow conventions. each binary depends on the corresponding .o file and
+# on the libraries specified by the INTLIBS/EXTLIBS. these dependencies can be
+# specified manually or they are automatically stored in a .bd file.
+
+$(foreach head,$(wildcard $(SUBDIR)*.h),$(eval $(shell grep -q Q_OBJECT $(head) && echo $(head) | sed -e's@^@/@;s@.*/\(.*\)\.h$$@$(BINDIR)\1:$(OBJDIR)moc_\1.o@')))
+-include $(OBJS:%.o=%.bd)
+
+# -------------------
+# - subdir management
+#
+# as the last step, always add this line to correctly recover the subdirectory
+# of the makefile including this one!
+
+SUBDIR:=$(SUBDIR_before_$(SUBDIR))
+

featureLearning/progs/libdepend.inc

@@ -0,0 +1,6 @@
+$(call PKG_DEPEND_INT,vislearning/baselib/)
+$(call PKG_DEPEND_INT,vislearning/cbaselib/)
+$(call PKG_DEPEND_INT,vislearning/features/)
+$(call PKG_DEPEND_INT,vislearning/math/)
+$(call PKG_DEPEND_INT,vislearning/noveltyDetection/)
+$(call PKG_DEPEND_INT,segmentation/)

featureLearning/progs/testFeatureLearning.cpp

@@ -0,0 +1,346 @@
+/**
+* @file testFeatureLearning.cpp
+* @brief test the feature learning routines to incrementally increase / adapt the codebook currently used
+* @author Alexander Freytag
+* @date 11-04-2013
+*/
+
+//STL
+#include <iostream>
+#include <limits>
+
+//core
+#include <core/basics/Config.h>
+#include <core/basics/ResourceStatistics.h>
+#include <core/image/Convert.h>
+#include <core/vector/VectorT.h>
+
+//vislearning
+#include <vislearning/baselib/Globals.h>
+#include <vislearning/baselib/ICETools.h>
+#include <vislearning/cbaselib/MultiDataset.h>
+#include <vislearning/cbaselib/Example.h>
+// 
+#include "vislearning/featureLearning/FeatureLearningGeneric.h"
+#include "vislearning/featureLearning/FeatureLearningClusterBased.h"
+#include "vislearning/featureLearning/FeatureLearningRegionBased.h"
+//
+#include "vislearning/noveltyDetection/NDCodebookLevelImagePooling.h"
+
+
+using namespace std;
+using namespace NICE;
+using namespace OBJREC;
+
+
+/**
+ test feature learning routines
+*/
+int main( int argc, char **argv )
+{
+  std::set_terminate( __gnu_cxx::__verbose_terminate_handler );
+
+  Config * conf = new Config ( argc, argv );
+  
+  bool showTrainingImages = conf->gB( "featureLearning", "showTrainingImages", false );
+  bool showTestImages = conf->gB( "featureLearning", "showTestImages", false );
+  bool showResults = conf->gB( "featureLearning", "showResults", false );
+  
+  ResourceStatistics rs;
+  std::string resultdir;
+  resultdir = conf->gS( "featureLearning", "resultdir", "/tmp/");
+  
+  
+  NICE::ImageT<int> noveltyScale ( 20, 100 );
+  for (int j = 0; j < 100; j++)
+  {
+    for (int i = 0; i < 20; i++)
+      noveltyScale(i,j) = 99-j;
+  }
+  
+  NICE::ColorImage noveltyScaleRGB (noveltyScale.width(), noveltyScale.height() );
+  imageToPseudoColor( noveltyScale, noveltyScaleRGB );
+  
+  std::string destinationNoveltyScale ( resultdir + "_" + "_noveltyScale.ppm");
+  noveltyScaleRGB.writePPM( destinationNoveltyScale );   
+  
+  
+  
+  //**********************************************
+  //
+  //      READ INITIAL TRAINING SET TO COMPUTE
+  //             AN INITIAL CODEBOOK
+  //
+  //**********************************************
+  
+  std::cerr << " READ INITIAL TRAINING SET TO COMPUTE AN INITIAL CODEBOOK" << std::endl;
+  
+  MultiDataset md( conf );
+  const LabeledSet *trainFiles = md["train"];
+  
+  //**********************************************
+  //
+  //      SET UP THE FEATURE LEARNING ALGO
+  //
+  //********************************************** 
+  
+  OBJREC::FeatureLearningGeneric * featureLearning;
+  
+  std::string featureLearningMethod = conf->gS( "featureLearning", "featureLearningMethod", "clusterBased" );
+  
+  if (featureLearningMethod.compare("clusterBased") == 0)
+  {
+    featureLearning = new OBJREC::FeatureLearningClusterBased( conf, &md );
+  }
+  else if (featureLearningMethod.compare("regionBased") == 0) 
+  {
+    featureLearning = new OBJREC::FeatureLearningRegionBased( conf, &md );
+  }
+  else
+  {
+    std::cerr << "Unknown feature learning algorithm selected, use cluster based instead" << std::endl;
+    featureLearning = new OBJREC::FeatureLearningClusterBased( conf, &md );
+  }    
+  
+  //**********************************************
+  //
+  //      SET UP THE NOVELTY DECTION ALGO
+  //
+  //**********************************************   
+  
+  OBJREC::NDCodebookLevelImagePooling * novDetector;
+  novDetector = new OBJREC::NDCodebookLevelImagePooling( conf, &md, "featureLearning" );
+    
+  //evaluate how well the training images are covered with our initial codebook
+  //that is, compute these nice "novelty maps" per feature
+  
+  //NOTE we skip this currently
+  LOOP_ALL_S( *trainFiles )
+  {
+      EACH_INFO( classno, info );
+      std::string filename = info.img();
+//       
+//       featureLearning->evaluateCurrentCodebook( filename , true /* beforeComputingNewFeatures */);       
+      
+      NICE::ImageT< int > imgClusterAssignments;
+      imgClusterAssignments = featureLearning->evaluateCurrentCodebookByAssignments(filename , false /* beforeComputingNewFeatures */, false /* _binaryShowLatestPrototype*/ );
+      
+      std::cerr << "now do image To pseude color and show the initial cluster assignments" << std::endl;
+      NICE::ColorImage imgClusterAssignmentsRGB (imgClusterAssignments.width(), imgClusterAssignments.height() );
+      imageToPseudoColor( imgClusterAssignments, imgClusterAssignmentsRGB );      
+      
+      if ( showResults )
+        showImage(imgClusterAssignmentsRGB, "cluster Assignments" ) ;
+      else
+      {
+        std::vector< std::string > list2;
+        StringTools::split ( filename, '/', list2 );        
+        std::string destination ( resultdir + NICE::intToString(0) + "_" + list2.back() + "_00_initialClusterAssignments.ppm");
+        imgClusterAssignmentsRGB.writePPM( destination );        
+      }
+  }
+  
+  //**********************************************
+  //
+  //        EVALUATE INITIAL CLUSTER
+  //
+  //       COMPUTE A NICE CONFUSION MATRIX
+  //          FOR OUR INITIAL CODEBOOK
+  //
+  //**********************************************  
+  NICE::Matrix confusionMatInitial;
+  featureLearning->evaluateCurrentCodebookByConfusionMatrix( confusionMatInitial );
+  std::cerr << "initial Confusion matrix: " << std::endl << confusionMatInitial << std::endl;
+  
+  //set the initially computed codebook to the novelty detection mechanism
+  //TODO this should be done, but currently we do not care about
+//   novDetector->setCodebook( featureLearning->getCurrentCodebook() );
+  
+
+  //**********************************************
+  //
+  //        FOR-LOOP OVER UNSEEN IMAGES
+  //
+  //       EXTRACT FEATURES, CLUSTER THEM, TAKE
+  //       MOST "VALUABLE" CLUSTERS AS NEW 
+  //    REPRESENTATIVES IN AN INCREASED CODEBOK
+  //
+  //**********************************************
+  const LabeledSet *testFiles = md["test"];
+    
+  std::cerr << "start looping over all files" << std::endl;
+  int imageCnt ( 0 );
+  LOOP_ALL_S( *testFiles )
+  {
+      EACH_INFO( classno, info );
+      std::string filename = info.img();
+      
+      NICE::ColorImage orig( filename );
+      
+      NICE::ImageT< int > imgClusterAssignments;
+      imgClusterAssignments = featureLearning->evaluateCurrentCodebookByAssignments(filename , false /* beforeComputingNewFeatures */, false /* _binaryShowLatestPrototype*/ );      
+      
+      NICE::ColorImage imgClusterAssignmentsRGB (imgClusterAssignments.width(), imgClusterAssignments.height() );
+      imageToPseudoColor( imgClusterAssignments, imgClusterAssignmentsRGB );       
+      
+      NICE::FloatImage noveltyImageBefore;
+      noveltyImageBefore = featureLearning->evaluateCurrentCodebookByDistance( filename , true /* beforeComputingNewFeatures */ );
+      
+      NICE::ColorImage noveltyImageBeforeRGB (noveltyImageBefore.width(), noveltyImageBefore.height() );
+      imageToPseudoColor( noveltyImageBefore, noveltyImageBeforeRGB );        
+      
+      if ( showResults )
+        showImage(imgClusterAssignmentsRGB, "cluster Assignments" ) ;
+      else
+      {
+        std::vector< std::string > list2;
+        StringTools::split ( filename, '/', list2 );        
+        std::string destination ( resultdir + NICE::intToString(0) + "_" + list2.back() + "_00_initialClusterAssignments.ppm");
+        imgClusterAssignmentsRGB.writePPM( destination );        
+        
+        std::string destinationNovelty ( resultdir + NICE::intToString(0) + "_" + list2.back() + "_01_initialClusterDistances.ppm");
+        noveltyImageBeforeRGB.writePPM( destinationNovelty );          
+      }      
+      
+      //**********************************************
+      //
+      //             IS THIS IMAGE NOVEL?
+      //
+      //          IF NOT, GO TO THE NEXT ONE
+      //
+      //**********************************************       
+      
+      bool b_isImageNovel ( novDetector->evaluateNoveltyOfImage( noveltyImageBefore ) );
+      
+      if ( ! b_isImageNovel )
+      {
+        std::cerr << " --- NOT NOVEL --- " << std::endl << std::endl;
+        continue;
+      }
+      else
+      {
+        std::cerr << " --- NOVEL --- " << std::endl;
+      }
+      
+      while ( b_isImageNovel ) 
+      {
+              
+        //**********************************************
+        //
+        //       LEARN NEW FEATURE FOR A NOVEL IMAGE
+        //
+        //**********************************************       
+        
+        featureLearning->learnNewFeatures( filename );
+        
+        //and update the codebook pointer within our novelty detection algorithm
+        //TODO this should be done, but currently we do not care about
+  //       novDetector->setCodebook( featureLearning->getCurrentCodebook() );      
+        
+        //**********************************************
+        //
+        //       EVALUATE HOW WELL THE CURRENT IMAGE
+        //            CAN BE EXPLAINED AFTER 
+        //           COMPUTING A NEW FEATURE
+        //
+        //       SHOULD WE REPEAT THIS UNTIL THE IMAGE
+        //       IS NOT CLASSIFIED AS "NOVEL" ANYMORE?
+        //
+        //**********************************************       
+        
+        NICE::FloatImage noveltyImageAfter;
+        noveltyImageAfter = featureLearning->evaluateCurrentCodebookByDistance( filename , false /* beforeComputingNewFeatures */ );
+        
+        NICE::FloatImage noveltyImageDifference ( noveltyImageAfter.width(), noveltyImageAfter.height());
+        for ( uint y = 0 ; y < ( uint ) noveltyImageAfter.height() ; y++ )
+        {
+          for ( uint x = 0 ; x < ( uint ) noveltyImageAfter.width(); x++ )
+          {
+            noveltyImageDifference(x,y) = fabs ( noveltyImageBefore(x,y) - noveltyImageAfter(x,y) );
+          }
+        }
+        
+        std::cerr << "min diff: " << noveltyImageDifference.min() << " and max diff: " << noveltyImageDifference.max() << std::endl;
+        
+        NICE::ColorImage noveltyImageDifferenceRGB (noveltyImageAfter.width(), noveltyImageAfter.height() );
+        imageToPseudoColor( noveltyImageDifference, noveltyImageDifferenceRGB );      
+        
+        std::vector< std::string > list2;
+        StringTools::split ( filename, '/', list2 );      
+
+        if ( showResults )
+        {
+          showImage( noveltyImageDifferenceRGB, "Difference of novelty images" );
+        }
+        else
+        {          
+          std::string destination ( resultdir + NICE::intToString(imageCnt) + "_" + list2.back() + "_02_initialLoopClusterAssignments.ppm");  
+          imgClusterAssignmentsRGB.writePPM( destination );    
+
+          std::string destinationNoveltyDifference ( resultdir + NICE::intToString(imageCnt) + "_" + list2.back() + "_03_noveltyDifferences.ppm");  
+          noveltyImageDifferenceRGB.writePPM( destinationNoveltyDifference );                        
+        }
+
+        NICE::ImageT< int > imgClusterAssignmentsBinary;
+        imgClusterAssignmentsBinary = featureLearning->evaluateCurrentCodebookByAssignments(filename , true, true /* _binaryShowLatestPrototype*/ );      
+        
+        NICE::ImageT< int > imgClusterAssignments;
+        imgClusterAssignments = featureLearning->evaluateCurrentCodebookByAssignments(filename , true, false /* _binaryShowLatestPrototype*/ );
+
+        
+        NICE::ColorImage imgClusterAssignmentsBinaryRGB (imgClusterAssignmentsBinary.width(), imgClusterAssignmentsBinary.height() );
+        imageToPseudoColor( imgClusterAssignmentsBinary, imgClusterAssignmentsBinaryRGB );   
+        
+        NICE::ColorImage imgClusterAssignmentsRGB (imgClusterAssignments.width(), imgClusterAssignments.height() );
+        imageToPseudoColor( imgClusterAssignments, imgClusterAssignmentsRGB );           
+        
+        if ( showResults )
+        {
+          showImage(imgClusterAssignmentsBinaryRGB, "cluster Assignments Binary (latest prototype)" ) ;      
+          showImage(imgClusterAssignmentsRGB, "cluster Assignments" ) ;
+        }
+        else
+        {
+            std::string destination ( resultdir + NICE::intToString(imageCnt) + "_" + list2.back() + "_5_clusterAssignments.ppm");
+            std::string destinationBinary ( resultdir + NICE::intToString(imageCnt) + "_" + list2.back() + "_6_clusterAssignmentsBinary.ppm");
+            
+            imgClusterAssignmentsRGB.writePPM( destination );
+            imgClusterAssignmentsBinaryRGB.writePPM( destinationBinary );
+        }      
+        
+        //check, whether the image will still be seen as novel or not
+        // i.e., are we able to "explain" the image with the lately computed codebook entry?
+        b_isImageNovel = novDetector->evaluateNoveltyOfImage( noveltyImageAfter ) ;
+        
+        if ( ! b_isImageNovel )
+        {
+          std::cerr << " --- NOT NOVEL ANYMORE --- " << std::endl << std::endl;
+        }
+        else
+        {
+          std::cerr << " --- STILL NOVEL --- " << std::endl;
+          noveltyImageBefore = noveltyImageAfter;
+        }        
+        
+        //artifial break for the moment
+        break;
+      }
+
+      
+      imageCnt++;
+  } //Loop over all test images
+  
+  
+  //don't waste memory
+  std::cerr << "don't waste memory - cleaning up" << std::endl;
+//   if (trainFiles != NULL)
+//     delete trainFiles;
+  if (featureLearning != NULL)
+    delete featureLearning;
+  if (novDetector != NULL)
+    delete novDetector;
+  if (conf != NULL)
+    delete conf;
+  
+   return 0;
+}

features/localfeatures/GenericLFSelection.h

@@ -1,5 +1,5 @@
 /** 
-* @file GenericLocalFeatureSelection.h
+* @file GenericLFSelection.h
 * @brief This class provides a generic chooser function for different descriptors, which are derived from LocalFeatureRepresentation.
 * @date 26.10.2011
 */
@@ -19,79 +19,180 @@
 #include "vislearning/features/localfeatures/LFColorSande.h"
 #include "vislearning/features/localfeatures/LFonHSG.h"
 
-/** NOTE: This class only returns Descriptors, which NOT need any given positions. All Descriptors calculate there own positions, on DIFFERENT ways. **/
-
 
 namespace OBJREC {
 
+  /** @class GenericLFSelection
+ * @brief Select a specific LF-Type (local feature representation). LFs compute Descriptors, which DO NOT need given positions, but calculate them ON THEIR OWN!
+ * All Descriptor-Methods calculate there own positions previously, and on DIFFERENT ways.
+ */
 class GenericLFSelection
 {
     public:
+      
+      //! enum specifying for which step the feature extractor shall be used (this influences the config section which will be used)
+      enum UsageForTrainOrTest { NOTSPECIFIED = 0,
+             TRAINING,
+             TESTING
+      };
 
       /** LocalFeature Selector
        * @brief This methode switches between the different LocalFeature-Types. One has to set the "localfeature_type" on a valid value and the methode returns a LocalFeatureRepresentation derived Object.
-       * @param[in] Config* - A pointer to the given configfile, which must contain "section" - "localfeature_type"
-       * @param[in] string  - This string defines the value for "section" in the configfile.
+       * @param[in] conf - A pointer to the given configfile, which must contain "section" - "localfeature_type"
+       * @param[in] section - This string defines the value for "section" in the configfile.
+       * @param[in] useForTrainOrTest - Specify whether we use the LFRep for Training, Testing, or for both - this influences the choice of the config section that is handed over to the LFRep-method
        * @return LocalFeatureRepresentation* - The LocalFeatureRepresentation which contains the selected LocalFeature-Type.
        */
       static
-      LocalFeatureRepresentation *selectLocalFeatureRep ( const NICE::Config *conf, std::string section = "features" )
+      LocalFeatureRepresentation *selectLocalFeatureRep ( const NICE::Config *conf, std::string section = "features", const UsageForTrainOrTest & useForTrainOrTest = NOTSPECIFIED )
       {
-	  // return Value
-	  LocalFeatureRepresentation *lfrep = NULL;
-	
-	  // string which defines the localfeature_type (for Ex. Sande, ...)
-	  std::string localfeature_type = conf->gS(section, "localfeature_type", "");
-	
-	  if ( localfeature_type == "mikolajczyk" )
-	  {
-	    lfrep = new LFMikolajczyk ( conf );
-	  }
-	  else if ( localfeature_type == "color" )
-	  {
-	    lfrep = new LFColorSande ( conf );
-	  }
-	  else if ( ( localfeature_type == "sift" ) || ( localfeature_type == "siftpp" ) ) 
-	  {
-            lfrep = new LFSiftPP ( conf );
-	  }
-	  else if ( ( localfeature_type == "generic_local" ) || ( localfeature_type == "generic" ) )
-	  {
-            int numFeatures = conf->gI(section, "localfeature_count");
-	    lfrep = new LFGenericLocal ( conf, numFeatures );
-	  }
-	  else if ( ( localfeature_type == "grey" ) || ( localfeature_type == "patches" ) )
-	  {
-	    int numFeatures = conf->gI(section, "localfeature_count");
-	    lfrep = new LFPatches ( conf, numFeatures );
-	  } 
-	  else if( ( localfeature_type == "onHSG" ) )
-	  {
-	    lfrep = new LFonHSG( conf);
-	  }
-	  else 
-	  {
-		  lfrep = NULL;
-	  }
+        // return Value
+        LocalFeatureRepresentation *lfrep = NULL;
+      
+        // string which defines the localfeature_type (for Ex. Sande, ...)
+        std::string localfeature_type = conf->gS(section, "localfeature_type", "");
+      
+        if ( localfeature_type == "mikolajczyk" )
+        {
+          lfrep = new LFMikolajczyk ( conf );
+        }
+        else if ( localfeature_type == "VANDESANDE" ) //previously: "color"
+        {
+          if ( useForTrainOrTest == TRAINING )
+          {
+            lfrep = new LFColorSande ( conf, "LFColorSandeTrain" );
+          }
+          else if ( useForTrainOrTest == TESTING )
+          {
+            lfrep = new LFColorSande ( conf, "LFColorSandeTest" );
+          }
+          else //not specified whether for training or testing, so we do not care about
+          {
+            lfrep = new LFColorSande ( conf );            
+          }          
+        }
+        else if ( ( localfeature_type == "sift" ) || ( localfeature_type == "siftpp" ) ) 
+        {
+                lfrep = new LFSiftPP ( conf );
+        }
+        else if ( ( localfeature_type == "generic_local" ) || ( localfeature_type == "generic" ) )
+        {
+                int numFeatures = conf->gI(section, "localfeature_count");
+          lfrep = new LFGenericLocal ( conf, numFeatures );
+        }
+        else if ( ( localfeature_type == "grey" ) || ( localfeature_type == "patches" ) )
+        {
+          int numFeatures = conf->gI(section, "localfeature_count");
+          lfrep = new LFPatches ( conf, numFeatures );
+        } 
+        else if( ( localfeature_type == "onHSG" ) )
+        {
+          if ( useForTrainOrTest == TRAINING )
+          {
+            lfrep = new OBJREC::LFonHSG ( conf, "HSGTrain" );
+          }
+          else if ( useForTrainOrTest == TESTING )
+          {
+            lfrep = new OBJREC::LFonHSG ( conf, "HSGTest" );
+          }
+          else //not specified whether for training or testing, so we do not care about
+          {
+            lfrep = new OBJREC::LFonHSG( conf);
+          }           
+          
+        }
+        else 
+        {
+          lfrep = NULL;
+        }
+
+//         if ( conf->gB(section, "localfeature_cache_read", false) )
+//         {
+//           int numFeatures = conf->gI(section, "localfeature_count", -1);
+//           LocalFeatureRepresentation *lfrep_read = new LFReadCache ( conf, lfrep, numFeatures );
+//           lfrep = lfrep_read;
+//         }
+// 
+//         // no correct localfeature_type was given
+//         if ( lfrep == NULL )
+//           fthrow(NICE::Exception, "Local feature type not found: " << localfeature_type );
+// 
+//         if ( conf->gB(section, "localfeature_cache_write", false) )
+//         {
+//           LocalFeatureRepresentation *lfrep_write = new LFWriteCache ( conf, lfrep );
+//           lfrep = lfrep_write;
+//         }
+
+        // read features?
+        bool readfeat;
+        readfeat = conf->gB ( section, "localfeature_cache_read", true );
+        // write features?
+        bool writefeat;  
+        writefeat = conf->gB ( section, "localfeature_cache_write", true );   
 
-	  if ( conf->gB(section, "localfeature_cache_read", false) )
-	  {
-		  int numFeatures = conf->gI(section, "localfeature_count", -1);
-		  LocalFeatureRepresentation *lfrep_read = new LFReadCache ( conf, lfrep, numFeatures );
-		  lfrep = lfrep_read;
-	  }
+        LocalFeatureRepresentation *writeFeats = NULL;
+        LocalFeatureRepresentation *readFeats = NULL;
+        if ( writefeat )
+        {
+          // write the features to a file, if there isn't any to read
+          
+          if ( useForTrainOrTest == TRAINING )
+          {
+            writeFeats = new LFWriteCache ( conf, lfrep, "cacheTrain" );
+            lfrep = writeFeats;
+          }
+          else if ( useForTrainOrTest == TESTING )
+          {
+            writeFeats = new LFWriteCache ( conf, lfrep, "cacheTest" );
+            lfrep = writeFeats;
+          }
+          else //not specified whether for training or testing, so we do not care about
+          {
+            writeFeats = new LFWriteCache ( conf, lfrep );
+            lfrep = writeFeats;
+          }              
 
-	  // no correct localfeature_type was given
-	  if ( lfrep == NULL )
-		  fthrow(NICE::Exception, "Local feature type not found: " << localfeature_type );
+        }
 
-	  if ( conf->gB(section, "localfeature_cache_save", false) )
-	  {
-		  LocalFeatureRepresentation *lfrep_save = new LFWriteCache ( conf, lfrep );
-		  lfrep = lfrep_save;
-	  }
-		  
-	  return lfrep;
+//TODO add the section into constructor for readCache
+        if ( readfeat )
+        {
+          int numFeatures = conf->gI(section, "localfeature_count", -1);
+          // read the features from a file
+          if ( writefeat )
+          {
+            if ( useForTrainOrTest == TRAINING )
+            {
+              readFeats = new LFReadCache ( conf, writeFeats, numFeatures );
+            }
+            else if ( useForTrainOrTest == TESTING )
+            {
+              readFeats = new LFReadCache ( conf, writeFeats, numFeatures );
+            }
+            else //not specified whether for training or testing, so we do not care about
+            {
+              readFeats = new LFReadCache ( conf, writeFeats, numFeatures );
+            }                         
+          }
+          else
+          {
+            if ( useForTrainOrTest == TRAINING )
+            {
+              readFeats = new LFReadCache (conf, lfrep, numFeatures );
+            }
+            else if ( useForTrainOrTest == TESTING )
+            {
+              readFeats = new LFReadCache (conf, lfrep, numFeatures );
+            }
+            else //not specified whether for training or testing, so we do not care about
+            {
+              readFeats = new LFReadCache (conf, lfrep, numFeatures );
+            }
+          }
+          lfrep = readFeats; 
+        }  
+          
+        return lfrep;
       }
 };
 

features/localfeatures/GenericLocalFeatureSelection.h

@@ -21,6 +21,10 @@
 
 namespace OBJREC {
 
+  /** @class GenericLocalFeatureSelection
+ * @brief Select a specific LocalFeature-Type. LocalFeatures compute Descriptors, which DO need given positions (no internal position calculation)!
+ *
+ */  
 class GenericLocalFeatureSelection
 {
   public:

features/localfeatures/IDRandomSampling.h

@@ -18,25 +18,27 @@
 namespace OBJREC
 {
 
-/** random interest point sampling */
-class IDRandomSampling: public InterestDetector
-{
+  /** @class IDRandomSampling
+ * @brief random interest point sampling
+ */
+  class IDRandomSampling: public InterestDetector
+  {
 
-protected:
-	int numSamples;
-	double minScale;
+  protected:
+    int numSamples;
+    double minScale;
 
-public:
+  public:
 
-	IDRandomSampling(const NICE::Config *conf, int numSamples);
+    IDRandomSampling(const NICE::Config *conf, int numSamples);
 
-	virtual ~IDRandomSampling();
-	int getInterests(const NICE::Image & img,
-			std::vector<NICE::Vector> & positions) const;
-	int getInterests(const ImagePyramid & imp,
-			std::vector<NICE::Vector> & positions) const;
+    virtual ~IDRandomSampling();
+    int getInterests(const NICE::Image & img,
+        std::vector<NICE::Vector> & positions) const;
+    int getInterests(const ImagePyramid & imp,
+        std::vector<NICE::Vector> & positions) const;
 
-};
+  };
 
 } // namespace
 

features/localfeatures/LFColorSande.cpp

@@ -30,9 +30,12 @@ using namespace NICE;
 
 LFColorSande::LFColorSande ( const Config *conf, std::string section )
 {
+  std::cerr << "LF COLOR SANDE SECTION ====================== :" << section << ":"<<std::endl;
+  
   c_binaryExecutable = conf->gS ( section, "binaryExecutable", "/home/bachi/libs/van_de_sande/x86_64-linux-gcc/colorDescriptor" );
   c_params = conf->gS ( section, "params", "--descriptor opponentsift" );
   scales = conf->gS ( section, "scales", "1+1.5+3.0+4.5+6" );
+  std::cerr << "scales: " << scales << std::endl;
 
   descriptor_size = conf->gI ( section, "descriptor_size", -1 );
 
@@ -42,7 +45,7 @@ LFColorSande::LFColorSande ( const Config *conf, std::string section )
   std::ostringstream temp;
   temp << g;
   gridsize = temp.str();
-
+  
   if ( descriptor_size <= 0 )
   {
     fprintf ( stderr, "LFColorSande::LFColorSande: No descriptor size found in config -> self test\n" );
@@ -57,11 +60,11 @@ LFColorSande::LFColorSande ( const Config *conf, std::string section )
 
     fprintf ( stderr, "LFColorSande::LFColorSande Self Test features:%d dimension:%d\n", ( int ) features.size(), descriptor_size );
   }
-
+  
   if ( descriptor_size != conf->gI ( "features", "descriptor_size", descriptor_size ) )
   {
     cerr << "Warning: LFColorSande: descriptor sizes do not match !!!" << endl;
-  }
+  }  
 }
 
 LFColorSande::~LFColorSande()
@@ -205,6 +208,7 @@ int LFColorSande::extractFeatures ( const NICE::ColorImage & img, VVector & feat
   while ( ! feof ( f ) )
   {
     // <CIRCLE 119 307 1.26134 0 0.00014763>; 0 0 6 2 0 6 25 7 9 4 4 0 0 4 20 36 78 4 5 0 0
+    //<CIRCLE x y scale orientation cornerness>
     if ( fgets ( buffer, buffersize, f ) == NULL )
       break;
 

features/localfeatures/LFColorWeijer.cpp

@@ -2,6 +2,7 @@
 
 #include <fstream>
 #include <iostream>
+#include <exception>
 #include "vislearning/baselib/ColorSpace.h"
 
 using namespace OBJREC;
@@ -30,49 +31,12 @@ const int colors[11][3] =
 LFColorWeijer::LFColorWeijer( const Config *c )
 {
   conf = c;
-
-  bin[0] = conf->gI( "LFColorWeijer", "binL", 10 );
-  bin[1] = conf->gI( "LFColorWeijer", "bina", 20 );
-  bin[2] = conf->gI( "LFColorWeijer", "binb", 20 );
-
-  maxv[0] =  100.0;
-  maxv[1] =   80.0;
-  maxv[2] =   50.0;
-
-  minv[0] =    0.0;
-  minv[1] = -105.0;
-  minv[2] = -200.0;
-
-  tfile = conf->gS( "LFColorWeijer", "table", "/home/dbv/bilder/colorWeijer/color.txt" );
-
-  for ( int i = 0; i < 3; i++ )
-  {
-    interval[i] = ( maxv[i] - minv[i] ) / ( double )bin[i];
-  }
-
-  ifstream test( tfile.c_str() );
-
-  if ( test )
-  {
-    restore();
-  }
-  else
-  {
-    train();
-  }
+  tfile = conf->gS( "LFColorWeijer", "table", "/home/dbv/bilder/colorWeijer/w2c.txt");
+  restore();
 }
 
 LFColorWeijer::~LFColorWeijer()
 {
-  for ( uint i = 0; i < hist.size(); i++ )
-  {
-    for ( uint j = 0; j < hist[i].size(); j++ )
-    {
-      hist[i][j].clear();
-    }
-    hist[i].clear();
-  }
-  hist.clear();
 }
 
 int LFColorWeijer::getDescSize() const
@@ -80,105 +44,45 @@ int LFColorWeijer::getDescSize() const
   return LASTCOLOR;
 }
 
-void LFColorWeijer::store()
+void LFColorWeijer::restore()
 {
-  ofstream fout( tfile.c_str(), ios_base::app );
-
-  fout << hist.size() << " " << hist[0].size() << " " << hist[0][0].size() << " " << hist[0][0][0].size() << endl;
-
-  for ( uint i = 0; i < hist.size(); i++ )
+  ifstream fin( tfile.c_str() );
+  if(!fin.is_open())
   {
-    for ( uint i0 = 0; i0 < hist[i].size(); i0++ )
-    {
-      for ( uint i1 = 0; i1 < hist[i][i0].size(); i1++ )
-      {
-        for ( uint i2 = 0; i2 < hist[i][i0][i1].size(); i2++ )
-        {
-          fout << hist[i][i0][i1][i2] << " ";
-        }
-      }
-    }
+    fthrow(Exception,"ColorWeijer: could not find lookup table file.");
   }
-}
-
-void LFColorWeijer::smooth()
-{
-  int size0 = ( int )hist.size();
-  int size1 = ( int )hist[0].size();
-  int size2 = ( int )hist[0][0].size();
-  int size3 = ( int )hist[0][0][0].size();
-  for ( int i0 = 0; i0 < size1; i0++ )
+  
+  while(!fin.eof())
   {
-    for ( int i1 = 0; i1 < size2; i1++ )
+    double rd,gd,bd;
+    int r,g,b;
+    fin >> rd;
+    fin >> gd;
+    fin >> bd;
+        
+    r = rd/8;
+    g = gd/8;
+    b = bd/8;
+
+    for(int i = 0; i < 11; i++)
     {
-      for ( int i2 = 0; i2 < size3; i2++ )
-      {
-        double maxval = 0.0;
-        for ( int i = 0; i < size0; i++ )
-        {
-          maxval = std::max( maxval, hist[i][i0][i1][i2] );
-        }
-        if ( maxval == 0.0 )
-        {
-          for ( int i = 0; i < size0; i++ )
-          {
-            int anz = 0;
-            for ( int a0 = std::max( i0 - 1, 0 ); a0 <= std::min( i0 + 1, size1 - 1 ); a0++ )
-            {
-              for ( int a1 = std::max( i1 - 1, 0 ); a1 <= std::min( i1 + 1, size2 - 1 ); a1++ )
-              {
-                for ( int a2 = std::max( i2 - 1, 0 ); a2 <= std::min( i2 + 1, size3 - 1 ); a2++ )
-                {
-                  anz++;
-                  hist[i][i0][i1][i2] += hist[i][a0][a1][a2];
-                }
-              }
-            }
-            hist[i][i0][i1][i2] /= anz;
-          }
-        }
-      }
+      fin >> hist[r][g][b][i];
     }
   }
-}
-
-void LFColorWeijer::restore()
-{
-  int size0, size1, size2, size3;
-  ifstream fin( tfile.c_str() );
-  fin >> size0;
-  fin >> size1;
-  fin >> size2;
-  fin >> size3;
-  hist.clear();
-
-  for ( int i = 0; i < size0; i++ )
+    /*
+  for(int r = 0; r < 32; r++)
   {
-    vector<vector<vector<double> > > v2;
-
-    for ( int i0 = 0; i0 < size1; i0++ )
+    for(int g = 0; g < 32; g++)
     {
-      vector<vector<double> > v1;
-
-      for ( int i1 = 0; i1 < size2; i1++ )
+      for(int b = 0; b < 32; b++)
       {
-        vector<double> v0;
-
-        for ( int i2 = 0; i2 < size3; i2++ )
+        for(int i = 0; i < 11; i++)
         {
-          double val;
-          fin >> val;
-          v0.push_back( val );
+          fin >> hist[r][g][b][i];
         }
-
-        v1.push_back( v0 );
       }
-
-      v2.push_back( v1 );
     }
-
-    hist.push_back( v2 );
-  }
+  }  */
 }
 
 int LFColorWeijer::getDescriptors( const NICE::Image & img, VVector & positions, VVector & features ) const
@@ -189,41 +93,25 @@ int LFColorWeijer::getDescriptors( const NICE::Image & img, VVector & positions,
 
 int LFColorWeijer::getDescriptors( const NICE::ColorImage & img, VVector & positions, VVector & features ) const
 {
-  // in Lab umwandeln
-  for ( int i = 0; i < ( int )positions.size(); i++ )
-  {
-    vector<double> vals;
-    vector<int> b;
-    int x = positions[i][0];
-    int y = positions[i][1];
-
-    double R, G, B, X, Y, Z;
-    vector<double> lab( 3, 0.0 );
-
-    R = ( double )img.getPixel( x, y, 0 ) / 255.0;
-    G = ( double )img.getPixel( x, y, 1 ) / 255.0;
-    B = ( double )img.getPixel( x, y, 2 ) / 255.0;
-
-    ColorConversion::ccRGBtoXYZ( R, G, B, &X, &Y, &Z, 0 );
-    ColorConversion::ccXYZtoCIE_Lab( X, Y, Z, &lab[0], &lab[1], &lab[2], 0 );
-
-    for ( int i = 0; i < 3; i++ )
-    {
-      int val = ( int )(( lab[i] - minv[i] ) / interval[i] );
-      val = std::min( val, bin[i] - 1 );
-      val = std::max( val, 0 );
-      b.push_back( val );
-    }
-
-    Vector feat( hist.size() );
+  int width = ( int )img.width();
+  int height = ( int )img.height();
 
-    for ( uint i = 0; i < hist.size(); i++ )
+  for ( int j = 0; j < ( int )positions.size(); j++ )
+  {
+    int x = positions[j][0];
+    int y = positions[j][1];
+    int r = img(x,y,0)/8;
+    int g = img(x,y,1)/8;
+    int b = img(x,y,2)/8;
+      
+    Vector feat( 11 );
+    for ( uint i = 0; i < 11; i++ )
     {
-      feat[i] = hist[i][b[0]][b[1]][b[2]];
+      feat[i] = hist[r][g][b][i];
     }
     features.push_back( feat );
   }
-
+ 
   return 1;
 }
 
@@ -232,20 +120,6 @@ void LFColorWeijer::visualizeFeatures( NICE::Image & mark, const VVector & posit
 
 }
 
-void LFColorWeijer::add( vector<vector<vector<double> > > &dest, vector<vector<vector<double> > > &src )
-{
-  for ( uint i0 = 0; i0 < src.size(); i0++ )
-  {
-    for ( uint i1 = 0; i1 < src[i0].size(); i1++ )
-    {
-      for ( uint i2 = 0; i2 < src[i0][i1].size(); i2++ )
-      {
-        dest[i0][i1][i2] += src[i0][i1][i2];
-      }
-    }
-  }
-}
-
 int LFColorWeijer::findColor( string &fn )
 {
   if ( fn.find( "black" ) != string::npos )
@@ -274,130 +148,6 @@ int LFColorWeijer::findColor( string &fn )
   return -1;
 }
 
-vector<vector<vector<double > > > LFColorWeijer::createTable()
-{
-  vector<vector<vector<double> > > h;
-  for ( int i0 = 0; i0 < bin[0]; i0++ )
-  {
-    vector<vector< double > > vec;
-    for ( int i1 = 0; i1 < bin[1]; i1++ )
-    {
-      vector<double> v;
-      for ( int i2 = 0; i2 < bin[2]; i2++ )
-      {
-        v.push_back( 0.0 );
-      }
-      vec.push_back( v );
-    }
-    h.push_back( vec );
-  }
-  return h;
-}
-
-void LFColorWeijer::normalize( vector<vector<vector<double> > > &tab )
-{
-  double sum = 0.0;
-
-  for ( uint i0 = 0; i0 < tab.size(); i0++ )
-  {
-    for ( uint i1 = 0; i1 < tab[i0].size(); i1++ )
-    {
-      for ( uint i2 = 0; i2 < tab[i0][i1].size(); i2++ )
-      {
-        sum += tab[i0][i1][i2];
-      }
-    }
-  }
-
-  for ( uint i0 = 0; i0 < tab.size(); i0++ )
-  {
-    for ( uint i1 = 0; i1 < tab[i0].size(); i1++ )
-    {
-      for ( uint i2 = 0; i2 < tab[i0][i1].size(); i2++ )
-      {
-        tab[i0][i1][i2] /= sum;
-      }
-    }
-  }
-
-  return;
-}
-
-void LFColorWeijer::createHist( const ColorImage &cimg, vector<vector<vector<double> > > &hist, Image &mask )
-{
-  // in Lab umwandeln
-  NICE::MultiChannelImageT<double> genimg, imglab;
-
-  ColorSpace::ColorImagetoMultiChannelImage( cimg, genimg );
-  ColorSpace::convert( imglab, genimg, ColorSpace::COLORSPACE_LAB, ColorSpace::COLORSPACE_RGB );
-
-  for ( int y = 0; y < cimg.height(); y++ )
-  {
-    for ( int x = 0; x < cimg.width(); x++ )
-    {
-      if ( mask.getPixel( x, y ) == 0 )
-        continue;
-      vector<int> b;
-      for ( int i = 0; i < 3; i++ )
-      {
-        int val = ( int )(( imglab.get( x, y, i ) - minv[i] ) / interval[i] );
-        val = std::min( val, bin[i] - 1 );
-        b.push_back( val );
-      }
-      hist[b[0]][b[1]][b[2]]++;
-    }
-  }
-}
-
-void LFColorWeijer::train()
-{
-  cout << "train Starts" << endl;
-  for ( int i = 0; i < LASTCOLOR; i++ )
-  {
-    vector<vector<vector<double> > > h = createTable();
-    hist.push_back( h );
-  }
-
-  string dir = conf->gS( "LFColorWeijer", "table", "/home/dbv/bilder/colorWeijer/ebay/" );
-  string images = conf->gS( "LFColorWeijer", "table", "test_images.txt" );
-  string mask = conf->gS( "LFColorWeijer", "table", "mask_images.txt" );
-
-  string imagesfn;
-  string maskfn;
-
-  ifstream finimg(( dir + images ).c_str() );
-  ifstream finmask(( dir + mask ).c_str() );
-  cout << dir + images << endl;
-  cout << dir + mask << endl;
-  // lese bilder und masken ein
-  while ( finimg >> imagesfn && finmask >> maskfn )
-  {
-    Image mimg( dir + maskfn );
-    cout << dir + maskfn << endl;
-    ColorImage cimg( dir + imagesfn );
-
-    int col = findColor( imagesfn );
-    vector<vector<vector<double> > > tab = createTable();
-
-    createHist( cimg, tab, mimg ); // erzeuge Lab Histogramm des Bildes
-
-    normalize( tab );
-
-    add( hist[col], tab );
-  }
-  finimg.close();
-  finmask.close();
-
-  // normalisiere alle lookuptables
-  for ( uint i = 0; i < hist.size(); i++ )
-  {
-    normalize( hist[i] );
-  }
-
-  smooth();
-  store();
-}
-
 void LFColorWeijer::visualizeFeatures( NICE::ColorImage & out, const VVector & features, const VVector & position ) const
 {
   for ( int i = 0; i < ( int )position.size(); i++ )
@@ -477,28 +227,19 @@ void LFColorWeijer::getFeats( const ColorImage &img, MultiChannelImageT<double>
 {
   int width = ( int )img.width();
   int height = ( int )img.height();
-  feats.reInit( width, height, hist.size());
-
-  NICE::MultiChannelImageT<double> genimg, imglab;
-
-  ColorSpace::ColorImagetoMultiChannelImage( img, genimg );
-  ColorSpace::convert( imglab, genimg, ColorSpace::COLORSPACE_LAB, ColorSpace::COLORSPACE_RGB );
+  feats.reInit( width, height, 11);
 
   for ( int y = 0; y < height; y++ )
   {
     for ( int x = 0; x < width; x++ )
     {
-      for ( uint i = 0; i < hist.size(); i++ )
+      int r = img(x,y,0)/8;
+      int g = img(x,y,1)/8;
+      int b = img(x,y,2)/8;
+      
+      for ( uint i = 0; i < 11; i++ )
       {
-        vector<double> b( 3, 0.0 );
-        for ( int j = 0; j < 3; j++ )
-        {
-          int val = ( int )(( imglab.get( x, y, j ) - minv[j] ) / interval[j] );
-          val = std::min( val, bin[j] - 1 );
-          val = std::max( val, 0 );
-          b[j] = val;
-        }
-        feats.set( x, y, hist[i][b[0]][b[1]][b[2]], i );
+        feats.set( x, y, hist[r][g][b][i], i );
       }
     }
   }

features/localfeatures/LFColorWeijer.h

@@ -41,24 +41,12 @@ class LFColorWeijer : public LocalFeature
       LASTCOLOR
     };
 
-    //! bins for L*, a* and b* chanel of L*a*b*
-    int bin[3];
+    //! lookup table
+    double hist[32][32][32][11];
 
-    //! upper limits for L*, a* and b* chanel of L*a*b*
-    double maxv[3];
-
-    //! lower limits for L*, a* and b* chanel of L*a*b*
-    double minv[3];
-
-    //! quantization interval for L*, a* and b* chanel of L*a*b* depending on bin, maxv and minv
-    double interval[3];
-
-    //! destination of the computed lookuptable
+    //! destination of the precomputed lookuptable
     std::string tfile;
-
-    //! lookuptable for the probabilities (4d: colors, L-channel, a-channel, b-channel)
-    std::vector<std::vector<std::vector<std::vector<double> > > > hist;
-
+    
     //! configuration file
     const NICE::Config *conf;
 
@@ -123,34 +111,11 @@ class LFColorWeijer : public LocalFeature
      */
     void visualizeFeatures ( const NICE::ColorImage & cimg, NICE::ColorImage & out ) const;
 
-    /**
-     * save parameters
-     */
-    void store();
-
-
     /**
      * load parameters
      */
     void restore();
 
-    /**
-     * smooths the look up table
-     */
-    void smooth();
-
-    /**
-     * normalizes the sum of a 3d histogram to 1
-     * @param tab 3d histogram
-     */
-    void normalize ( std::vector<std::vector<std::vector<double> > > &tab );
-
-    /**
-     * creates a new and empty table
-     * @return table of the size bin[0]xbin[1]xbin[2]
-     */
-    std::vector<std::vector<std::vector<double > > > createTable();
-
     /**
      * finds a colorname in a given string
      * @param fn input string
@@ -158,27 +123,6 @@ class LFColorWeijer : public LocalFeature
      */
     int findColor ( std::string &fn );
 
-    /**
-     * creates a new Histogram for input image depending on the image mask
-     * @param cimg input image
-     * @param hist histogram
-     * @param mask which pixel should be consider
-     */
-    void createHist ( const NICE::ColorImage &cimg, std::vector<std::vector<std::vector<double> > > &hist, NICE::Image &mask );
-
-    /**
-     * train the lookuptable
-     */
-    void train();
-
-
-    /**
-     * add a 3d table to a 3d table elementwise
-     * @param dest destination table
-     * @param src source table
-     */
-    void add ( std::vector<std::vector<std::vector<double> > > &dest, std::vector<std::vector<std::vector<double> > > &src );
-
     /**
      * transform each pixel of an image
      * @param img input image

features/localfeatures/LFGenericLocal.h

@@ -1,9 +1,8 @@
 /** 
 * @file LFGenericLocal.h
-* @brief generic local features
+* @brief generic local features ( Random Sampling of POIs and SIFT as descriptor)
 * @author Erik Rodner
 * @date 02/05/2008
-
 */
 #ifndef LFGENERICLOCALINCLUDE
 #define LFGENERICLOCALINCLUDE
@@ -21,33 +20,36 @@
 
 namespace OBJREC {
 
-/** generic local features */
-class LFGenericLocal : public LocalFeatureRepresentation
-{
+  /** generic local features */
+  /** @class LFGenericLocal
+ * @brief Generic local features ( actually: Random Sampling of POIs followed by SIFT as descriptor)
+ */  
+  class LFGenericLocal : public LocalFeatureRepresentation
+  {
+
+      protected:
+    LocalFeature *lf;
+    InterestDetector *id;
+
+      public:
+    
+    /** simple constructor */
+    LFGenericLocal( const NICE::Config *conf, int numFeatures );
+        
+    /** simple destructor */
+    virtual ~LFGenericLocal();
+      
+    int getDescSize () const;
 
-    protected:
-	LocalFeature *lf;
-	InterestDetector *id;
+    int extractFeatures ( const NICE::Image & img, 
+              NICE::VVector & features, 
+              NICE::VVector & positions) const;
+              
+    void visualizeFeatures ( NICE::Image & mark,
+          const NICE::VVector & positions,
+          size_t color ) const;
 
-    public:
-  
-	/** simple constructor */
-	LFGenericLocal( const NICE::Config *conf, int numFeatures );
-      
-	/** simple destructor */
-	virtual ~LFGenericLocal();
-     
-	int getDescSize () const;
-
-	int extractFeatures ( const NICE::Image & img, 
-			      NICE::VVector & features, 
-			      NICE::VVector & positions) const;
-			      
-	void visualizeFeatures ( NICE::Image & mark,
-				 const NICE::VVector & positions,
-				 size_t color ) const;
-
-};
+  };
 
 
 } // namespace

features/localfeatures/LFReadCache.tcc

@@ -40,7 +40,9 @@ int LFReadCache::extractFeaturesTemplate ( const ImageClass & img,
     if ( lfrep == NULL )
       fthrow ( NICE::Exception, "LocalFeatureRepresentation not available, recovering is impossible!" );
 
+    std::cerr << "extract features with lfrep used in ReadCache" << std::endl;
     lfrep->extractFeatures ( img, features, positions );
+    std::cerr << "features extracted" << std::endl;
 
     features.save ( filename_desc, descFormat );
     positions.save ( filename_pos, NICE::VVector::FILEFORMAT_LINE );

features/localfeatures/LFWriteCache.cpp

@@ -29,12 +29,13 @@ using namespace NICE;
 
 
 LFWriteCache::LFWriteCache ( const Config *conf,
-                             const LocalFeatureRepresentation *_lfrep ) : lfrep ( _lfrep )
+                             const LocalFeatureRepresentation *_lfrep,
+                             const std::string & _section ) : lfrep ( _lfrep )
 {
-  cachedir = conf->gS ( "cache", "root" );
-  cachemode = Globals::getCacheMode ( conf->gS ( "cache", "mode", "cat" ) );
+  cachedir = conf->gS ( _section, "root" );
+  cachemode = Globals::getCacheMode ( conf->gS ( _section, "mode", "cat" ) );
 
-  std::string descFormat_s = conf->gS ( "cache", "descriptor_format", "binary_double" );
+  std::string descFormat_s = conf->gS ( _section, "descriptor_format", "binary_double" );
   if ( descFormat_s == "binary_double" )
     descFormat = VVector::FILEFORMAT_BINARY_DOUBLE;
   else if ( descFormat_s == "binary_uchar" )

features/localfeatures/LFWriteCache.h

@@ -1,6 +1,6 @@
 /** 
 * @file LFWriteCache.h
-* @brief write local features to file
+* @brief Write local features to file (whenever a descriptor is computed, it will be checked whether a corresponding file already exists. If not, we save the descriptor)
 * @author Erik Rodner
 * @date 02/14/2008
 
@@ -18,59 +18,64 @@
 
 namespace OBJREC {
 
-/** write local features to file */
-class LFWriteCache : public LocalFeatureRepresentation
-{
+  /** @class LFWriteCache
+  * @brief Write local features to file (whenever a descriptor is computed, it will be checked whether a corresponding file already exists. If not, we save the descriptor)
+  *
+  */  
+  class LFWriteCache : public LocalFeatureRepresentation
+  {
 
-    protected:
-	const LocalFeatureRepresentation *lfrep;
+      protected:
+        const LocalFeatureRepresentation *lfrep;
 
-	std::string cachedir;
+        std::string cachedir;
 
-	int descFormat;
-	int cachemode;
+        int descFormat;
+        int cachemode;
 
 
-    public:
-  
-		/** simple constructor */
-		LFWriteCache( const NICE::Config *conf, 
-				const LocalFeatureRepresentation *lfrep ); 
-		
-		/** simple destructor */
-		virtual ~LFWriteCache();
-	
-		int getDescSize () const;
-	
-		/**
-		* extract features for gray images
-		* @param img input image
-		* @param features output features
-		* @param positions position of the features
-		* @return 
-		*/
-		int extractFeatures ( const NICE::Image & img, 
-					NICE::VVector & features, 
-					NICE::VVector & positions ) const;
-		
-		/**
-		* extract features for color images
-		* @param img input image
-		* @param features output features
-		* @param positions position of the features
-		* @return 
-		*/
-		int extractFeatures ( const NICE::ColorImage & img, 
-					NICE::VVector & features, 
-					NICE::VVector & positions ) const;
-	
-		void visualize ( NICE::Image & img, 
-			const NICE::Vector & feature ) const;
-	
-		void visualizeFeatures ( NICE::Image & mark,
-					const NICE::VVector & positions,
-					size_t color ) const;
-};
+      public:
+    
+        /** simple constructor */
+        LFWriteCache( const NICE::Config *conf, 
+            const LocalFeatureRepresentation *lfrep,
+            const std::string & _section = "cache"
+                    ); 
+        
+        /** simple destructor */
+        virtual ~LFWriteCache();
+      
+        int getDescSize () const;
+      
+        /**
+        * extract features for gray images
+        * @param img input image
+        * @param features output features
+        * @param positions position of the features
+        * @return 
+        */
+        int extractFeatures ( const NICE::Image & img, 
+              NICE::VVector & features, 
+              NICE::VVector & positions ) const;
+        
+        /**
+        * extract features for color images
+        * @param img input image
+        * @param features output features
+        * @param positions position of the features
+        * @return 
+        */
+        int extractFeatures ( const NICE::ColorImage & img, 
+              NICE::VVector & features, 
+              NICE::VVector & positions ) const;
+      
+        void visualize ( NICE::Image & img, 
+          const NICE::Vector & feature ) const;
+      
+        void visualizeFeatures ( NICE::Image & mark,
+              const NICE::VVector & positions,
+              size_t color ) const;
+  };
 
 
 } // namespace

features/localfeatures/LocalFeature.h

@@ -1,7 +1,7 @@
 /** 
 * @file LocalFeature.h
-* @brief local feature interface
-* @author Erik Rodner
+* @brief Abstract class for Local Features ( ONLY DESCRIPTORS, NO DETECTORS )
+* @author Erik Rodner, Alexander Freytag
 * @date 02/05/2008
 
 */
@@ -17,31 +17,34 @@
 
 namespace OBJREC {
 
-/** local feature interface */
-class LocalFeature
-{
+    /** @class LocalFeature
+  * @brief Abstract class for Local Features ( ONLY DESCRIPTORS, NO DETECTORS )
+  *
+  */
+  class LocalFeature
+  {
 
-    protected:
+      protected:
 
-    public:
-  
-	/** simple constructor */
-	LocalFeature();
-      
-	/** simple destructor */
-	virtual ~LocalFeature();
-
-	virtual int getDescSize() const = 0;
-
-	virtual int getDescriptors ( const NICE::Image & img, NICE::VVector & positions, NICE::VVector & descriptors) const = 0;
-	
-	virtual int getDescriptors ( const NICE::ColorImage & img, NICE::VVector & positions, NICE::VVector & descriptors) const;
-	
-	virtual void visualizeFeatures ( NICE::Image & mark,
-				 const NICE::VVector & positions,
-				 size_t color ) const;
+      public:
     
-};
+    /** simple constructor */
+    LocalFeature();
+        
+    /** simple destructor */
+    virtual ~LocalFeature();
+
+    virtual int getDescSize() const = 0;
+
+    virtual int getDescriptors ( const NICE::Image & img, NICE::VVector & positions, NICE::VVector & descriptors) const = 0;
+    
+    virtual int getDescriptors ( const NICE::ColorImage & img, NICE::VVector & positions, NICE::VVector & descriptors) const;
+    
+    virtual void visualizeFeatures ( NICE::Image & mark,
+          const NICE::VVector & positions,
+          size_t color ) const;
+      
+  };
 
 
 } // namespace

features/localfeatures/LocalFeatureLFInterface.cpp

@@ -10,34 +10,36 @@ using namespace NICE;
 
 LocalFeatureLFInterface::LocalFeatureLFInterface( const Config *conf, LocalFeatureRepresentation *_lfpres )
 {
-	lfpres = _lfpres;
+  lfpres = _lfpres;
 }
 
 LocalFeatureLFInterface::~LocalFeatureLFInterface()
 {
-	delete lfpres;
+  delete lfpres;
 }
 
 
 int LocalFeatureLFInterface::getDescriptors ( const NICE::Image & img, VVector & positions, VVector & descriptors ) const
 {
-	lfpres->extractFeatures(img, descriptors, positions);
-	assert(descriptors.size() == positions.size());
-    return 0;
+  //TODO do we want to ignore the positions of lfrep and use the given ones, or do we indeed want to compute positions on our own? If so, why do we use the Interface to LocalFeature, and not directly LocalFeatureRepresentation?    
+  lfpres->extractFeatures(img, descriptors, positions);
+  assert(descriptors.size() == positions.size());
+  return 0;
 }
 
 int LocalFeatureLFInterface::getDescriptors ( const NICE::ColorImage & img, VVector & positions, VVector & descriptors) const
 {
-	lfpres->extractFeatures(img, descriptors, positions);
-	assert(descriptors.size() == positions.size());
-	return 0;
+  //TODO do we want to ignore the positions of lfrep and use the given ones, or do we indeed want to compute positions on our own? If so, why do we use the Interface to LocalFeature, and not directly LocalFeatureRepresentation?
+  lfpres->extractFeatures(img, descriptors, positions);
+  assert(descriptors.size() == positions.size());
+  return 0;
 }
 
 void LocalFeatureLFInterface::visualizeFeatures ( NICE::Image & mark,
-				 const VVector & positions,
-				 size_t color ) const
+        const VVector & positions,
+        size_t color ) const
 {
-	//cerr << "LocalFeatureLFInterface::visualizeFeatures(...) not yet implemented" << endl;
-	lfpres->visualizeFeatures(mark, positions, color);
+  //cerr << "LocalFeatureLFInterface::visualizeFeatures(...) not yet implemented" << endl;
+  lfpres->visualizeFeatures(mark, positions, color);
 }
 

features/localfeatures/LocalFeatureLFInterface.h

@@ -1,6 +1,6 @@
 /** 
 * @file LocalFeatureLFInterface.h
-* @brief interface to LF
+* @brief Interface to use a LocalFeature (Descriptor only) with routines of LocalFeatureRepresentations (Detector + Descriptor)
 * @author Björn Fröhlich
 * @date 09/07/2010
 
@@ -19,50 +19,53 @@
 
 namespace OBJREC {
 
-/** local feature with LF */
-class LocalFeatureLFInterface : public LocalFeature
-{
 
-    protected:
-		LocalFeatureRepresentation *lfpres;
+  /** @class LocalFeatureLFInterface
+  * @brief Interface to use a LocalFeature (Descriptor only) with routines of LocalFeatureRepresentations (Detector + Descriptor)
+  *
+  */  
+  class LocalFeatureLFInterface : public LocalFeature
+  {
 
-    public:
-  
-	/** simple constructor */
-		LocalFeatureLFInterface ( const NICE::Config *conf, LocalFeatureRepresentation *_lfpres );
-      
-	/** simple destructor */
+      protected:
+      LocalFeatureRepresentation *lfpres;
+
+      public:
+    
+    /** simple constructor */
+      LocalFeatureLFInterface ( const NICE::Config *conf, LocalFeatureRepresentation *_lfpres );
+        
+    /** simple destructor */
 
-	virtual ~LocalFeatureLFInterface();
-	
-	/**
-	 * returns the size of each the SIFT-Feature
-	 * @return 128
-	 */
-	int getDescSize() const { return lfpres->getDescSize(); };
-	
-	/** 
-	 * get the descriptor
-	 * @param img input image
-	 * @param positions positions for the SIFT features
-	 * @param descriptors output
-	 * @return 0
-	 */
-	int getDescriptors ( const NICE::Image & img, NICE::VVector & positions, NICE::VVector & descriptors ) const;
-	
-	/** 
-	 * get the descriptor
-	 * @param img input color image
-	 * @param positions positions for the SIFT features
-	 * @param descriptors output
-	 * @return 0
-	 */
-	int getDescriptors ( const NICE::ColorImage & img, NICE::VVector & positions, NICE::VVector & descriptors) const;
-				     
-	void visualizeFeatures ( NICE::Image & mark, const NICE::VVector & positions, size_t color ) const;
+    virtual ~LocalFeatureLFInterface();
+    
+    /**
+    * @brief returns the size of each the SIFT-Feature
+    */
+    int getDescSize() const { return lfpres->getDescSize(); };
+    
+    /** 
+    * @brief get the descriptor
+    * @param img input image
+    * @param positions positions for local features
+    * @param descriptors output
+    * @return 0
+    */
+    int getDescriptors ( const NICE::Image & img, NICE::VVector & positions, NICE::VVector & descriptors ) const;
+    
+    /** 
+    * @brief get the descriptor
+    * @param img input color image
+    * @param positions positions for the SIFT features
+    * @param descriptors output
+    * @return 0
+    */
+    int getDescriptors ( const NICE::ColorImage & img, NICE::VVector & positions, NICE::VVector & descriptors) const;
+              
+    void visualizeFeatures ( NICE::Image & mark, const NICE::VVector & positions, size_t color ) const;
 
-     
-};
+      
+  };
 
 
 } // namespace

features/localfeatures/LocalFeatureRepresentation.h

@@ -1,7 +1,7 @@
 /** 
 * @file LocalFeatureRepresentation.h
-* @brief absract class for the representation of an image with local feature descriptors
-* @author Erik Rodner
+* @brief Absract class for Local Feature Representations (Detector + Descriptor)
+* @author Erik Rodner, Alexander Freytag
 * @date 11/19/2007
 
 */
@@ -21,6 +21,12 @@
 namespace OBJREC {
 
 /** absract class for the representation of an image with local feature descriptors */
+/** NOTE: This class returns Descriptors, which DO NOT need any given positions. All Descriptors calculate there own positions, on DIFFERENT ways. **/
+
+  /** @class LocalFeatureRepresentation
+ * @brief Absract class for Local Feature Representations (Detector + Descriptor)
+ *
+ */
 class LocalFeatureRepresentation
 {
 

features/localfeatures/libdepend.inc

@@ -3,4 +3,4 @@ $(call PKG_DEPEND_EXT,OPENMP)
 $(call PKG_DEPEND_INT,core)
 $(call PKG_DEPEND_INT,vislearning/baselib)
 $(call PKG_DEPEND_INT,vislearning/image)
-$(call PKG_DEPEND_INT,vislearning/features/fbase)
+$(call PKG_DEPEND_INT,vislearning/features/fbase)

features/localfeatures/progs/testColorWeijer.cpp

@@ -5,24 +5,58 @@
 #include "core/imagedisplay/ImageDisplay.h"
 #include <iostream>
 #include "vislearning/features/localfeatures/LFColorWeijer.h"
+#include <getopt.h>
 
 using namespace std;
 using namespace NICE;
 using namespace OBJREC;
 
-int main(int argc, char **argv)
+
+/**
+ * @brief Printing main menu.
+ * @author Alexander Freytag
+ * @date 13-02-2013
+ * 
+ * @return void
+ **/
+void print_main_menu()
+{
+  std::cerr << "=====================================================================================" << std::endl;
+  std::cerr << "||This is a small programm demonstrating the computation of 11-dim color features.  ||" << std::endl;
+  std::cerr << "=====================================================================================" << std::endl;  
+  
+  std::cout << std::endl << "Input options:" << std::endl;
+  std::cout << "   -i <filename>  the name of the image which shall be transformed"<< std::endl;
+  return;
+}
+
+
+//post-process active learning segmentation results, such that the given images are normalized to be visualized in the same range
+int main( int argc, char* argv[] )
 {
-  if (argc < 1)
+  
+  int rc;
+  if (argc<2)
   {
-    cerr << "Bitte Bild angeben" << endl;
+    print_main_menu();
     return -1;
   }
+  
+  std::string filename("");
+  while ((rc=getopt(argc,argv,"i:h"))>=0)
+  {
+    switch(rc)
+    {
+      case 'i': filename = optarg; break;
+      default: print_main_menu();
+    }
+  }   
 
   Config *conf = new Config();
   LFColorWeijer lfc(conf);
 
   //! testen
-  ColorImage cimg(argv[1]);
+  ColorImage cimg(filename);
   ColorImage out;
   lfc.visualizeFeatures (cimg, out);
 

features/simplefeatures/BoWFeatureConverter.cpp

@@ -0,0 +1,142 @@
+/** 
+* @file BoWFeatureConverter.cpp
+* @brief Convert a set of features into a Bag of visual Words histogram (either by Vector Quantization, or Hard / Soft Assignment)
+* @author Alexander Freytag
+* @date 11-06-2013 (dd-mm-yyyy)
+*/
+#include <iostream>
+#include <fstream>
+
+#include "vislearning/features/simplefeatures/BoWFeatureConverter.h"
+
+using namespace OBJREC;
+
+using namespace std;
+using namespace NICE;
+
+
+
+BoWFeatureConverter::BoWFeatureConverter( 
+    const Config *conf, 
+    const Codebook *_codebook, const std::string _section )
+    : codebook(_codebook)
+{
+  this->s_section = _section;
+  this->p_conf = conf;
+  
+  std::string normalizationMethod = conf->gS( _section, "normalizationMethod", "sum" );
+  
+  if ( normalizationMethod == "sum" )
+    this->n_normalizationMethod = NORMALIZE_SUM;
+  else if ( normalizationMethod == "binzero" )
+    this->n_normalizationMethod = NORMALIZE_BINZERO;
+  else if ( normalizationMethod == "raw" )
+    this->n_normalizationMethod = NORMALIZE_RAW;
+  else if ( normalizationMethod == "thresh" )
+    this->n_normalizationMethod = NORMALIZE_THRESH;
+  else
+  {
+    //default: L1 normalization
+    this->n_normalizationMethod = NORMALIZE_SUM;    
+  }
+  
+  std::string n_quantizationMethod = conf->gS( _section, "n_quantizationMethod", "VQ" );
+  
+  if ( normalizationMethod == "VQ" )
+    this->n_quantizationMethod = VECTOR_QUANTIZATION;
+  else if ( normalizationMethod == "VA" )
+    this->n_quantizationMethod = VECTOR_ASSIGNMENT;
+  else
+  {
+    //default: standard vector quantization
+    this->n_quantizationMethod = VECTOR_QUANTIZATION;    
+  }  
+}
+
+BoWFeatureConverter::~BoWFeatureConverter()
+{
+}
+
+void BoWFeatureConverter::calcHistogram ( const NICE::VVector & features,
+          NICE::Vector & histogram , const bool & b_resetHistogram )
+{
+  if ( b_resetHistogram || (histogram.size() != this->codebook->getCodebookSize() ) )
+  {
+    histogram.resize( this->codebook->getCodebookSize() );
+    histogram.set(0);
+  }
+
+  int cluster_index = 0;
+  double weight = 0;
+  double distance = 0.0;
+  if ( this->n_quantizationMethod == VECTOR_QUANTIZATION )
+  {
+    for ( NICE::VVector::const_iterator featIt  = features.begin();
+            featIt != features.end();
+            featIt++ )
+    {
+      const NICE::Vector & x = *featIt;
+      this->codebook->voteVQ ( x, cluster_index, weight, distance );
+      histogram[ cluster_index ] ++;
+    }    
+  }
+  else // VECTOR_ASSIGNMENT (hard or soft can be set directly in the codebook-object)
+  {
+    
+    NICE::Vector assignment (this->codebook->getCodebookSize() );;
+    for ( NICE::VVector::const_iterator featIt  = features.begin();
+            featIt != features.end();
+            featIt++ )
+    { 
+      assignment.set(0);
+      const NICE::Vector & x = *featIt;
+      this->codebook->voteVA ( x, assignment );
+      histogram += assignment;
+    }      
+  }
+
+}
+
+void BoWFeatureConverter::normalizeHistogram ( NICE::Vector & histogram )
+{
+    if ( n_normalizationMethod == NORMALIZE_RAW ) {
+    // do nothing
+    } else if ( n_normalizationMethod == NORMALIZE_BINZERO ) {
+    for ( size_t i = 0 ; i < histogram.size() ; i++ )
+      if ( histogram[i] > 0 ) histogram[i] = 1.0; 
+    } else if ( n_normalizationMethod == NORMALIZE_SUM  ) {
+    double sum = 0.0;
+    for ( size_t i = 0 ; i < histogram.size() ; i++ )
+    {
+      assert ( histogram[i] >= 0.0 );
+      sum += histogram[i];
+    }
+
+    if ( sum < 1e-5 ) {
+      fprintf (stderr, "BoWFeatureConverter::normalizeHistogram: WARNING histogram is zero !!\n");
+      return;
+    }
+
+    for ( size_t i = 0 ; i < histogram.size() ; i++ )
+      histogram[i] /= sum;
+    } else if ( n_normalizationMethod == NORMALIZE_THRESH ) {
+    const NICE::Vector & thresholds = codebook->getThresholds();
+
+    if ( thresholds.size() <= 0 ) {
+      fprintf (stderr, "BoWFeatureConverter:: This is maybe an OLD codebook ! \n");
+      exit(-1);
+    }
+    for ( size_t i = 0 ; i < histogram.size() ; i++ )
+      histogram[i] = (histogram[i] > thresholds[i]) ? 1.0 : 0.0; 
+    }
+}
+
+int BoWFeatureConverter::getNormalizationMethod () const
+{
+    return n_normalizationMethod;
+}
+
+void BoWFeatureConverter::setNormalizationMethod ( int normalizationMethod )
+{
+    n_normalizationMethod = normalizationMethod;
+}

features/simplefeatures/BoWFeatureConverter.h

@@ -0,0 +1,101 @@
+/** 
+* @file BoWFeatureConverter.h
+* @brief Convert a set of features into a Bag of visual Words histogram (either by Vector Quantization, or Hard / Soft Assignment)
+* @author Alexander Freytag
+* @date 11-06-2013 (dd-mm-yyyy)
+*/
+#ifndef BOWFEATURECONVERTERINCLUDE
+#define BOWFEATURECONVERTERINCLUDE
+
+#include "core/vector/VectorT.h"
+#include "core/vector/VVector.h"
+#include "core/vector/MatrixT.h"
+
+#include "core/basics/Config.h"
+
+#include "Codebook.h"
+
+
+namespace OBJREC {
+
+
+  /**
+   * @class BoWFeatureConverter
+   * @brief Convert a set of features into a Bag of visual Words histogram (either by Vector Quantization, or Hard / Soft Assignment)
+   * @author Alexander Freytag
+   * @date 11-06-2013 (dd-mm-yyyy)
+  */   
+  class BoWFeatureConverter 
+  {
+
+    protected:
+      //! normalization method used (enum type)
+      int n_normalizationMethod;
+      
+      //! quantization method used (enum type)
+      int n_quantizationMethod;
+
+      //! pointer to our codebook
+      const Codebook *codebook;
+      
+      //! the section name if we want to read something from the config file lateron
+      std::string s_section;
+      
+      //! the config file to specify parameter settings
+      const NICE::Config * p_conf;
+
+
+
+    public:
+      //! enum type used for normalization method
+      enum {
+        NORMALIZE_RAW = 0,
+        NORMALIZE_BINZERO,
+        NORMALIZE_SUM,
+        NORMALIZE_THRESH
+      };
+      
+      //! enum type used to specify feature -> clusters (vector quant. , or vector assignment (either hard or soft) )
+      enum {
+        VECTOR_QUANTIZATION = 0,
+        VECTOR_ASSIGNMENT
+      };
+         
+
+      /**
+      * @brief standard constructor 
+      *
+      * @param conf pointer to a Config object with some parameter settings (currently not used)
+      * @param codebook pointer to the codebook (keep the pointer!)
+      */
+      BoWFeatureConverter( const NICE::Config *conf,
+          const Codebook *codebook, const std::string _section = "BoWFeatureConverter" );
+          
+      /** simple destructor */
+      virtual ~BoWFeatureConverter();
+      
+      void calcHistogram ( const NICE::VVector & features,
+              NICE::Vector & histogram, const bool & b_resetHistogram = true );
+
+      void normalizeHistogram ( NICE::Vector & histogram );
+
+      /**
+      * @brief set the type of the normalization method (see the enum of the class)
+      *
+      * @param normalizationMethod see enum type
+      */
+      void setNormalizationMethod ( int normalizationMethod );
+
+      /**
+      * @brief get the currently used normalization method
+      *
+      * @return see enum type
+      */
+      int getNormalizationMethod () const;
+      
+  };
+
+
+} // namespace
+
+#endif

features/simplefeatures/Codebook.cpp

@@ -1,9 +1,8 @@
 /** 
 * @file Codebook.cpp
 * @brief feature codebook
-* @author Erik Rodner
-* @date 02/15/2008
-
+* @author Erik Rodner, Alexander Freytag
+* @date 05-06-2013 (dd-mm-yyyy ) (original: 02/15/2008)
 */
 #include <iostream>
 
@@ -14,33 +13,71 @@ using namespace OBJREC;
 using namespace std;
 using namespace NICE;
 
-void Codebook::vote ( const NICE::Vector & feature, 
-			NICE::Vector & histogram, 
-			int & codebookEntry,
-			double & weight,
-			double & distance ) const
+Codebook::Codebook ( )
+{
+  this->i_noOfNearestClustersToConsidere = 1;
+}
+
+Codebook::Codebook ( const int & _noOfNearestClustersToConsidere )
+{
+  this->i_noOfNearestClustersToConsidere = _noOfNearestClustersToConsidere;
+}
+
+Codebook::Codebook( NICE::Config * _conf, const std::string & _section)
+{
+  this->p_conf = _conf;
+  this->s_section = _section;
+  
+  this->i_noOfNearestClustersToConsidere = this->p_conf->gI( _section, "noOfNearestClustersToConsidere", 1);
+}
+
+
+Codebook::~Codebook ( )
+{
+  //NOTE the config does not need to be deleted, it is just a pointer to an external data structure  
+}
+
+void Codebook::voteVQ (const NICE::Vector &feature, NICE::Vector &histogram, int &codebookEntry, double &weight, double &distance) const
+{
+    this->voteVQ ( feature, codebookEntry, weight, distance );
+    //VQ, but we directly increase the corresponding entry without setting histogram to zero before (useful if we work on multiple images)
+    histogram[codebookEntry] += weight;  
+}
+
+void Codebook::voteVQ ( const NICE::Vector & feature, NICE::SparseVector & histogram, int &codebookEntry, double &weight, double &distance ) const
 {
-    vote ( feature, codebookEntry, weight, distance );
-    histogram[codebookEntry] += weight;
+    this->voteVQ ( feature, codebookEntry, weight, distance );
+    
+    //is this cluster already non-zero in the histogram?
+    NICE::SparseVector::iterator entryIt = histogram.find( codebookEntry ) ;
+    if ( entryIt  == histogram.end() )
+    {
+      //entry does not exist
+      histogram.insert ( histogram.begin(), pair<int, double> ( codebookEntry, weight ) );
+    }
+    else
+    {
+      //entry already exists, so we increase the weight
+      entryIt->second += weight;
+    }
 }
 
-void Codebook::vote ( const NICE::Vector & feature, SparseVector & votes ) const
+bool Codebook::allowsMultipleVoting () const
 {
-    int codebookEntry;
-    double weight;
-    double distance;
-    vote ( feature, codebookEntry, weight, distance );
-    votes.insert ( votes.begin(), pair<int, double> ( codebookEntry, weight ) );
+  if ( this->i_noOfNearestClustersToConsidere > 1 )
+    return true;
+  else
+    return false;
 }
-	
+
 void Codebook::reinit ( int numCodebookEntries )
 {
-    thresholds.resize ( numCodebookEntries );
-	thresholds.set(0.0);
-    informativeMeasure.resize ( numCodebookEntries );
-	informativeMeasure.set(0.0);
-    classnos.resize ( numCodebookEntries );
-	classnos.resize(0);
+  thresholds.resize ( numCodebookEntries );
+  thresholds.set(0.0);
+  informativeMeasure.resize ( numCodebookEntries );
+  informativeMeasure.set(0.0);
+  classnos.resize ( numCodebookEntries );
+  classnos.resize(0);
 }
 
 void Codebook::clear ()
@@ -54,20 +91,61 @@ void Codebook::restore ( istream & is, int format )
 {
    is >> thresholds;
    is >> informativeMeasure;
-   is >> classnos;
+//    is >> classnos;
+   
+   //TODO use a flag for compatibility with old systems?
+/*   try
+   {
+     
+     is >> i_noOfNearestClustersToConsidere;
+     is >> s_section;
+
+     this->p_conf->restore( is, format );
+   }
+   catch( ... )
+   {
+     std::cerr << "something went wrong while Loading the codebook - use default values instead" << std::endl;
+     //TODO use suitable default values
+   }  */ 
 }
 
 void Codebook::store ( ostream & os, int format ) const
 {
-    os << thresholds << endl;
-    os << informativeMeasure << endl;
-    os << classnos << endl;
+    os << this->thresholds << endl;
+    os << this->informativeMeasure << endl;
+    os << this->classnos << endl;
+//     os << this->i_noOfNearestClustersToConsidere << endl;
+//     os << this->s_section << endl;
+//     
+//     this->p_conf->store( os, format );
 }
 
 void Codebook::copy ( const Codebook *codebook )
 {
-    reinit ( codebook->thresholds.size() );
+    this->reinit ( codebook->thresholds.size() );
     thresholds = codebook->thresholds;
     informativeMeasure = codebook->informativeMeasure;
     classnos = codebook->classnos;
+    this->p_conf = codebook->p_conf;
+    this->setNoOfNearestClustersToConsidere ( codebook->getNoOfNearestClustersToConsidere() );
 }
+
+void Codebook::setNoOfNearestClustersToConsidere ( const int & _noOfNearestClustersToConsidere )
+{
+  this->i_noOfNearestClustersToConsidere = _noOfNearestClustersToConsidere;
+}
+
+int Codebook::getNoOfNearestClustersToConsidere ( ) const
+{
+  return this->i_noOfNearestClustersToConsidere;
+}
+
+void Codebook::setHardAssignment( const bool & _hardAssignment )
+{
+  this->b_hardAssignment = _hardAssignment;
+}
+
+bool Codebook::getHardAssignment ( ) const
+{
+  return this->b_hardAssignment;
+}

features/simplefeatures/Codebook.h

@@ -1,83 +1,179 @@
 /**
 * @file Codebook.h
 * @brief feature codebook
-* @author Erik Rodner
-* @date 02/15/2008
-
+* @author Erik Rodner, Alexander Freytag
+* @date 05-06-2013 (dd-mm-yyyy ) (original: 02/15/2008)
 */
 #ifndef CODEBOOKINCLUDE
 #define CODEBOOKINCLUDE
 
-#include "core/vector/VectorT.h"
-#include "core/vector/MatrixT.h"
-#include "core/image/ImageT.h"
-#include "core/imagedisplay/ImageDisplay.h"
 
 #include <string>
 
+#include <core/basics/Config.h>
 #include "core/basics/Persistent.h"
+//
+#include "core/image/ImageT.h"
+#include "core/imagedisplay/ImageDisplay.h"
+//
+#include "core/vector/VectorT.h"
+#include "core/vector/MatrixT.h"
 #include "core/vector/SparseVectorT.h"
 
 
 namespace OBJREC {
 
-/** feature codebook */
-class Codebook : public NICE::Persistent
-{
-protected:
-    NICE::Vector thresholds;
-    NICE::Vector informativeMeasure;
-    NICE::VectorT<int> classnos;
-
-public:
-
-    /** simple destructor */
-    virtual ~Codebook() {};
-
-    virtual void vote ( const NICE::Vector & feature, int & codebookEntry,
-                        double & weight, double & distance ) const = 0;
-
-    virtual void vote ( const NICE::Vector & feature, NICE::Vector & histogram, int & codebookEntry,
-                        double & weight, double & distance ) const;
-
-    virtual void vote ( const NICE::Vector & feature, NICE::SparseVector & votes ) const;
-
-    virtual bool allowsMultipleVoting () {
-        return false;
-    };
-    virtual void add ( const Codebook *codebook ) = 0;
-    virtual void copy ( const Codebook *codebook );
-    virtual Codebook *clone () const = 0;
-
-    size_t getCodebookSize() const {
-        return informativeMeasure.size();
-    };
-    void reinit ( int numCodebookEntries );
-
-    const NICE::Vector & getThresholds () const {
-        return thresholds;
-    };
-    const NICE::Vector & getInformativeMeasure () const {
-        return informativeMeasure;
-    };
-    const NICE::VectorT<int> & getClassNos () const {
-        return classnos;
-    };
-
-    void setThresholds ( const NICE::Vector & _thresholds ) {
-        thresholds = _thresholds;
-    };
-    void setInformativeMeasure ( const NICE::Vector & _informativeMeasure ) {
-        informativeMeasure = _informativeMeasure;
-    };
-    void setClassNos ( const NICE::VectorT<int> & _classnos ) {
-        classnos = _classnos;
-    };
-
-    virtual void clear ();
-    virtual void restore ( std::istream & is, int format );
-    virtual void store ( std::ostream & os, int format ) const;
-};
+  /** feature codebook */
+  class Codebook : virtual public NICE::Persistent
+  {
+    protected:
+        NICE::Vector thresholds;
+        NICE::Vector informativeMeasure;
+        NICE::VectorT<int> classnos;
+        
+        /** if Soft Assignment or Hard Assignment instead of Vector Quantization, how many entries are allowed to be non-zero?*/
+        int i_noOfNearestClustersToConsidere;
+        
+        NICE::Config * p_conf;
+        std::string s_section;
+        
+        /** hard or soft assignment? */
+        bool b_hardAssignment;
+
+    public:
+
+        /**
+         * @brief simple constructor
+         */
+        Codebook ( );      
+      
+        /**
+         * @brief standard constructor
+         */
+        Codebook ( const int & _noOfNearestClustersToConsidere);
+
+         /**
+         * @brief recommended constructor
+         */
+        Codebook( NICE::Config * _conf, const std::string & _section);
+
+        /** simple destructor */
+        virtual ~Codebook();
+        
+
+        //vote for a single feature vector
+        /**
+         * @brief Vector Quantization for a single vector
+         * @date 11-06-2013 (dd-mm-yyyy)
+         * @author Erik Rodner, Alexander Freytag
+         * @param feature the feature that shall be quantized
+         * @param codebookEntry the corresponding cluster index for the quantized feature
+         * @param weight the weight of the nearest cluster
+         * @param distance the distance to its nearest cluster
+         */        
+        virtual void voteVQ ( const NICE::Vector & feature, int & codebookEntry,
+                            double & weight, double & distance ) const = 0;
+                            
+        /**
+         * @brief Vector Quantization for a single vector, directly increases the corresponding entry in histogram 
+         * @date 11-06-2013 (dd-mm-yyyy)
+         * @author Erik Rodner, Alexander Freytag
+         * @param feature the feature that shall be quantized
+         * @param histogram a BoW-histogram already given (does not need to be empty before) - the corresponding entry for feature will be increased
+         * @param codebookEntry  the corresponding cluster index for the quantized feature
+         * @param weight the weight of the nearest cluster
+         * @param distance the distance to its nearest cluster
+         */        
+        virtual void voteVQ (const NICE::Vector &feature, NICE::Vector &histogram, int & codebookEntry, double & weight, double & distance ) const; 
+        
+        /**
+         * @brief Vector Quantization for a single vector, directly increases the corresponding entry in histogram 
+         * @date 11-06-2013 (dd-mm-yyyy)
+         * @author Erik Rodner, Alexander Freytag
+         * @param feature the feature that shall be quantized
+         * @param histogram a BoW-histogram already given (does not need to be empty before) - the corresponding entry for feature will be increased
+         * @param codebookEntry the corresponding cluster index for the quantized feature
+         * @param weight the weight of the nearest cluster
+         * @param distance the distance to its nearest cluster
+         */        
+        virtual void voteVQ (const NICE::Vector &feature, NICE::SparseVector &histogram, int &codebookEntry, double &weight, double &distance ) const;         
+
+        
+        /**
+         * @brief Hard or Soft Assignment into NICE::Vector for a single vector
+         * @date 11-06-2013 (dd-mm-yyyy)
+         * @author Alexander Freytag
+         * @param feature the feature that shall be quantized
+         * @param votes BoW histogram adding non-zero entries at the k nearest clusters (hard or soft),  (does not need to be empty before)
+         */    
+        virtual void voteVA ( const NICE::Vector & feature, NICE::Vector & votes ) const = 0;
+
+        /**
+         * @brief Hard or Soft Assignment into NICE::SparseVector for a single vector 
+         * @date 11-06-2013 (dd-mm-yyyy)
+         * @author Erik Rodner, Alexander Freytag
+         * @param feature the feature that shall be quantized
+         * @param votes BoW histogram adding non-zero entries for the k nearest clusters (hard or soft),  (does not need to be empty before)
+         */                              
+        virtual void voteVA ( const NICE::Vector & feature, NICE::SparseVector & votes ) const = 0;
+        
+        
+        //for backward-compatibility
+        virtual void   vote (const NICE::Vector &feature, NICE::Vector &histogram, int &codebookEntry , double &weight , double &distance ) const { this->voteVQ ( feature, histogram, codebookEntry, weight, distance ); };
+        
+        virtual void   vote (const NICE::Vector &feature, NICE::SparseVector &histogram ) const {
+          int codebookEntry;
+          double weight, distance;
+          this->voteVQ ( feature, histogram, codebookEntry, weight, distance );          
+        };        
+   
+        
+        
+       
+        virtual void add ( const Codebook *codebook ) = 0;
+        virtual void copy ( const Codebook *codebook );
+        virtual Codebook *clone () const = 0;
+
+        size_t getCodebookSize() const {
+            return informativeMeasure.size();
+        };
+        void reinit ( int numCodebookEntries );
+
+        const NICE::Vector & getThresholds () const {
+            return thresholds;
+        };
+        const NICE::Vector & getInformativeMeasure () const {
+            return informativeMeasure;
+        };
+        const NICE::VectorT<int> & getClassNos () const {
+            return classnos;
+        };
+
+        void setThresholds ( const NICE::Vector & _thresholds ) {
+            thresholds = _thresholds;
+        };
+        void setInformativeMeasure ( const NICE::Vector & _informativeMeasure ) {
+            informativeMeasure = _informativeMeasure;
+        };
+        void setClassNos ( const NICE::VectorT<int> & _classnos ) {
+            classnos = _classnos;
+        };
+        
+        void setHardAssignment( const bool & _hardAssignment );
+        bool getHardAssignment ( ) const ;
+        
+        /** 
+         * @brief false, if only a single entry for soft or hard assignment can be larger than zero (=> effectively vector quantization)
+         */
+        virtual bool allowsMultipleVoting () const ;
+        
+        void setNoOfNearestClustersToConsidere ( const int & _noOfNearestClustersToConsidere );
+        int getNoOfNearestClustersToConsidere ( ) const ;
+
+        virtual void clear ();
+        virtual void restore ( std::istream & is, int format );
+        virtual void store ( std::ostream & os, int format ) const;
+  };
 
 
 } // namespace

features/simplefeatures/CodebookPrototypes.cpp

@@ -1,15 +1,16 @@
 /** 
 * @file CodebookPrototypes.cpp
 * @brief feature CodebookPrototypes
-* @author Erik Rodner
-* @date 02/15/2008
-
+* @author Erik Rodner, Alexander Freytag
+* @date 05-06-2013 (dd-mm-yyyy ) (original: 02/15/2008)
 */
-#include <core/image/Convert.h>
-
 #include <iostream>
 #include <assert.h>
 
+#include <core/image/Convert.h>
+
+#include "vislearning/math/distances/genericDistance.h"
+
 #include "CodebookPrototypes.h"
 
 using namespace OBJREC;
@@ -20,6 +21,9 @@ using namespace NICE;
 
 CodebookPrototypes::CodebookPrototypes()
 {
+  this->clear();
+  this->distanceType = "euclidean";
+  this->distancefunction = GenericDistanceSelection::selectDistance(distanceType);   
 }
 
 CodebookPrototypes::CodebookPrototypes( const std::string & filename )
@@ -27,15 +31,27 @@ CodebookPrototypes::CodebookPrototypes( const std::string & filename )
     Codebook::read(filename);
 }
 
-CodebookPrototypes::CodebookPrototypes( const VVector & vv )
+CodebookPrototypes::CodebookPrototypes( const NICE::VVector & vv )
 {
-    for ( const_iterator i = vv.begin(); i != vv.end(); i++ )
-	push_back (*i);
-    reinit ( vv.size() );
+  this->append ( vv, true /* _copyData*/ ); 
+
+  reinit ( vv.size() );
+  
+  this->distanceType = "euclidean";
+  this->distancefunction = GenericDistanceSelection::selectDistance(distanceType);     
+}
+
+CodebookPrototypes::CodebookPrototypes( NICE::Config * _conf, const std::string & _section) : Codebook ( _conf, _section )
+{    
+  this->distanceType = _conf->gS( _section, "distanceType", "euclidean" );
+  this->distancefunction = GenericDistanceSelection::selectDistance(distanceType);  
+  
+  this->clear();
 }
 
 CodebookPrototypes::~CodebookPrototypes()
 {
+  //NOTE the config does not need to be deleted, it is just a pointer to an external data structure
 }
 
 void CodebookPrototypes::copy ( const Codebook *codebook )
@@ -45,9 +61,12 @@ void CodebookPrototypes::copy ( const Codebook *codebook )
     const CodebookPrototypes *codebookp = dynamic_cast<const CodebookPrototypes *> ( codebook );
     assert ( codebookp != NULL );
     insert ( begin(), codebookp->begin(), codebookp->end() );
+    
+  this->distanceType = this->p_conf->gS( this->s_section, "distanceType", "euclidean" );
+  this->distancefunction = GenericDistanceSelection::selectDistance(distanceType);      
 }
 
-void CodebookPrototypes::vote ( const NICE::Vector & feature, int & codebookEntry, double & weight, double & distance ) const
+void CodebookPrototypes::voteVQ ( const NICE::Vector & feature, int & codebookEntry, double & weight, double & distance ) const
 {
     const double *xp = feature.getDataPointer();
     size_t k = 0;
@@ -55,34 +74,50 @@ void CodebookPrototypes::vote ( const NICE::Vector & feature, int & codebookEntr
     size_t my_cluster = 0;
     
     int len = feature.size();
-    for ( vector<Vector>::const_iterator i = begin();
-					 i != end();
-					 i++,k++ )
+    // iterate over all cluster centers
+    for ( std::vector<NICE::Vector>::const_iterator i = this->begin();
+            i != this->end();
+            i++,k++ )
     {
 
-	const NICE::Vector & cluster = *i;
-	//slow ICE variant
-	//double distance = (x - cluster).Length();
-	double distance = 0.0;
-	const double *clusterp = cluster.getDataPointer();
-	for ( int i = 0 ; i < len ; i++ )
-	{
-	    double h = clusterp[i] - xp[i];
-	    distance += h*h;
-	}
-
-	if ( distance < mindist )
-	{
-	    my_cluster = k;
-	    mindist = distance;
-	}
+      const NICE::Vector & cluster = *i;
+      //slow ICE variant
+      //double distance = (x - cluster).Length();
+      
+//       const double *clusterp = cluster.getDataPointer();
+      double distance = this->distancefunction->calculate(*i, feature);
+      
+      //old version without distance function
+//       for ( int i = 0 ; i < len ; i++ )
+//       {
+//           double h = clusterp[i] - xp[i];
+//           distance += h*h;
+//       }
+
+      if ( distance < mindist )
+      {
+          my_cluster = k;
+          mindist = distance;
+      }
     }
 
     codebookEntry = my_cluster;
     weight = 1.0;
     distance = mindist;
 }
-	
+
+void CodebookPrototypes::voteVA ( const NICE::Vector & feature, NICE::Vector & votes ) const
+{
+  votes.set( 0.0 );
+  //TODO
+}
+
+void CodebookPrototypes::voteVA ( const NICE::Vector & feature, NICE::SparseVector & votes ) const
+{
+  votes.clear(); 
+  //TODO
+}
+
 void CodebookPrototypes::add ( const Codebook *codebook )
 {
     informativeMeasure.append ( codebook->getInformativeMeasure() );
@@ -93,9 +128,10 @@ void CodebookPrototypes::add ( const Codebook *codebook )
     assert ( codebookp != NULL );
     insert ( begin(), codebookp->begin(), codebookp->end() );
 }
-	
+
 Codebook *CodebookPrototypes::clone () const
 {
+  //TODO !
     return (new CodebookPrototypes());
 }
 
@@ -109,6 +145,8 @@ void CodebookPrototypes::restore ( istream & is, int format )
 {
     Codebook::restore ( is, format );
     VVector::restore ( is, format );
+    
+    std::cerr << "initial Codebook : " << std::endl; VVector::print ( std::cerr );
 }
 
 void CodebookPrototypes::store ( ostream & os, int format ) const
@@ -119,47 +157,57 @@ void CodebookPrototypes::store ( ostream & os, int format ) const
 
 void CodebookPrototypes::displayCodebook ( int xsize, int ysize ) const
 {
-    NICE::Image bigimg ( xsize * 5 , ysize * size() );
+    NICE::Image bigimg ( xsize * 5 , ysize * this->size() );
     bigimg.set(0);
 
     NICE::Image img_s (xsize, ysize);
-    for ( int k = 0 ; k < (int)size() ; k++ )
+    for ( int k = 0 ; k < (int)this->size() ; k++ )
     {
-	NICE::Vector vimg = *(begin() + k);
-	NICE::Image img ((int)sqrt(vimg.size()), (int)sqrt(vimg.size()));
-	int i = 0;
-	double max = - numeric_limits<double>::max();
-	double min = numeric_limits<double>::min();
-	for ( int y = 0 ; y < img.height() ; y++ )
-	    for ( int x = 0 ; x < img.width() ; x++,i++ )
-	    {
-		if ( max < vimg[i] ) max = vimg[i];
-		if ( min > vimg[i] ) min = vimg[i];
-	    }
-
-	i = 0;
-	for ( int y = 0 ; y < img.height() ; y++ )
-	    for ( int x = 0 ; x < img.width() ; x++,i++ )
-	    {
-		img.setPixel( x, y, (int)((vimg[i] - min)*255/(max-min)) );
-	    }
-
-	
-	NICE::scale ( img, &img_s );
-
-	for ( int y = 0 ; y < ysize ; y++ )
-	    for ( int x = 0 ; x < xsize ; x++ )
-		bigimg.setPixel(x, y+k*ysize, img_s.getPixel(x,y) );
-
-	{
-	    std::ostringstream os;
-	    os << "no: " << k;
-	    if ( (int)informativeMeasure.size() > k ) 
-		os << " " << informativeMeasure[k];
-	    // refactor-nice.pl: check this substitution
-	    // old: Text ( os.str().c_str(), xsize+1, k*ysize + 1, 255, 0, bigimg );
-	    // REFACTOR-FIXME Unable to map this statement
-	}
+      NICE::Vector vimg = *(this->begin() + k);
+      NICE::Image img ((int)sqrt(vimg.size()), (int)sqrt(vimg.size()));
+      int i = 0;
+      double max = - numeric_limits<double>::max();
+      double min = numeric_limits<double>::min();
+      for ( int y = 0 ; y < img.height() ; y++ )
+      {
+          for ( int x = 0 ; x < img.width() ; x++,i++ )
+            {
+              if ( max < vimg[i] )
+                max = vimg[i];
+              if ( min > vimg[i] )
+                min = vimg[i];
+            }
+      }
+
+      i = 0;
+      for ( int y = 0 ; y < img.height() ; y++ )
+      {
+          for ( int x = 0 ; x < img.width() ; x++,i++ )
+          {
+            img.setPixel( x, y, (int)((vimg[i] - min)*255/(max-min)) );
+          }
+      }
+
+      
+      NICE::scale ( img, &img_s );
+
+      for ( int y = 0 ; y < ysize ; y++ )
+      {
+          for ( int x = 0 ; x < xsize ; x++ )
+          {
+            bigimg.setPixel(x, y+k*ysize, img_s.getPixel(x,y) );
+          }
+      }
+
+      {
+          std::ostringstream os;
+          os << "no: " << k;
+          if ( (int)informativeMeasure.size() > k ) 
+          os << " " << informativeMeasure[k];
+          // refactor-nice.pl: check this substitution
+          // old: Text ( os.str().c_str(), xsize+1, k*ysize + 1, 255, 0, bigimg );
+          // REFACTOR-FIXME Unable to map this statement
+      }
     }
 
     bigimg.write ("/tmp/display.bmp");

features/simplefeatures/CodebookPrototypes.h

@@ -1,9 +1,8 @@
 /** 
 * @file CodebookPrototypes.h
 * @brief feature CodebookPrototypes
-* @author Erik Rodner
-* @date 02/15/2008
-
+* @author Erik Rodner, Alexander Freytag
+* @date 05-06-2013 (dd-mm-yyyy ) (original: 02/15/2008)
 */
 #ifndef CodebookPrototypesINCLUDE
 #define CodebookPrototypesINCLUDE
@@ -15,42 +14,72 @@
 #include <string>
 
 #include "core/vector/VVector.h"
+#include <core/vector/Distance.h>
+
 #include "Codebook.h"
 
 
 namespace OBJREC {
 
-/** feature CodebookPrototypes */
-class CodebookPrototypes : public Codebook, public NICE::VVector
-{
-
-    protected:
-
-    public:
-  
-	/** simple constructor */
-	CodebookPrototypes();
-	
-	CodebookPrototypes( const std::string & filename );
-	
-	CodebookPrototypes( const NICE::VVector & vv );
-	
-	CodebookPrototypes( const CodebookPrototypes *cs );
-      
-	/** simple destructor */
-	virtual ~CodebookPrototypes();
+  /** feature CodebookPrototypes */
+  class CodebookPrototypes : public Codebook, public NICE::VVector
+  {
+
+      protected:
+        
+        //! specify which distance to use for calculating assignments
+        std::string distanceType;
+        
+        //! the actual distance metric
+        NICE::VectorDistance<double> *distancefunction;         
+
+      public:
     
-	void vote ( const NICE::Vector & feature, int & codebookEntry, double & weight, double & distance ) const;
-	void add ( const Codebook *codebook );
-	void copy ( const Codebook *codebook );
-	Codebook *clone () const;
+        /** simple constructor */
+        CodebookPrototypes();
+        
+        /** constructor reading the codebook from a file*/
+        CodebookPrototypes( const std::string & filename );
+        
+        /** constructor taking the given VVector as new codebook prototypes*/
+        CodebookPrototypes( const NICE::VVector & vv );
+        
+        /** copy constructor*/
+        CodebookPrototypes( const CodebookPrototypes *cs );
+        
+        /** recommended constructor*/
+        CodebookPrototypes( NICE::Config * _conf, const std::string & _section);
+            
+        /** simple destructor */
+        virtual ~CodebookPrototypes();
+        
+        //vote for a single feature vector
+        /**
+         * @brief Vector Quantization for a single vector
+         */        
+        void voteVQ ( const NICE::Vector & feature, int & codebookEntry, double & weight, double & distance ) const;
+
+        /**
+         * @brief Hard or Soft Assignment into NICE::Vector for a single vector
+         */        
+        virtual void voteVA ( const NICE::Vector & feature, NICE::Vector & votes ) const;
+
+        /**
+         * @brief Hard or Soft Assignment into NICE::SparseVector for a single vector
+         */                            
+        virtual void voteVA ( const NICE::Vector & feature, NICE::SparseVector & votes ) const;        
+         
+        
+        void add ( const Codebook *codebook );
+        void copy ( const Codebook *codebook );
+        Codebook *clone () const;
 
-	void clear ();
-	void restore ( std::istream & is, int format );
-	void store ( std::ostream & os, int format ) const;
+        void clear ();
+        void restore ( std::istream & is, int format );
+        void store ( std::ostream & os, int format ) const;
 
-	void displayCodebook (int xsize, int ysize) const;
-};
+        void displayCodebook (int xsize, int ysize) const;
+  };
 
 
 } // namespace

math/cluster/ClusterAlgorithm.h

@@ -16,27 +16,27 @@
 
 namespace OBJREC {
 
-/** Interface for Cluster-Algorithms */
-class ClusterAlgorithm
-{
-
-    protected:
-
-    public:
-  
-	/** simple constructor */
-	ClusterAlgorithm();
+  /** Interface for Cluster-Algorithms */
+  class ClusterAlgorithm
+  {
+
+      protected:
+
+      public:
+    
+    /** simple constructor */
+    ClusterAlgorithm();
+        
+    /** simple destructor */
+    virtual ~ClusterAlgorithm();
+
+    virtual void cluster ( 
+            const NICE::VVector & features,
+            NICE::VVector & prototypes,
+            std::vector<double> & weights,
+            std::vector<int>    & assignment ) = 0;
       
-	/** simple destructor */
-	virtual ~ClusterAlgorithm();
-
-	virtual void cluster ( 
-		       const NICE::VVector & features,
-		       NICE::VVector & prototypes,
-		       std::vector<double> & weights,
-		       std::vector<int>    & assignment ) = 0;
-     
-};
+  };
 
 
 } // namespace

math/cluster/GMM.cpp

@@ -9,7 +9,7 @@
 
 #include "vislearning/math/cluster/KMeans.h"
 
-#define DEBUGGMM
+// #define DEBUGGMM
 
 using namespace OBJREC;
 using namespace NICE;
@@ -175,16 +175,16 @@ inline NICE::Vector diagInverse ( const NICE::Vector &sparse_mat )
 void GMM::initEMkMeans ( const VVector &DataSet )
 {
   /*init GMM with k-Means*/
-  KMeans k ( gaussians );
-  VVector means;
-  vector<double> weights;
-  vector<int> assignment;
+  OBJREC::KMeans k ( gaussians );
+  NICE::VVector means;
+  std::vector<double> weights;
+  std::vector<int> assignment;
   k.cluster ( DataSet, means, weights, assignment );
 
   int nData = DataSet.size();
   this->dim = DataSet[0].size();
   cdimval = dim * log ( 2 * 3.14159 );
-  vector<int> pop ( gaussians, 0 );
+  std::vector<int> pop ( gaussians, 0 );
   priors.resize ( gaussians );
   mu = VVector ( gaussians, dim );
   log_det_sigma.clear();

math/cluster/GMM.h

@@ -104,7 +104,6 @@ class GMM : public ClusterAlgorithm
      * standard destructor
      */
     ~GMM() {
-      std::cerr << "dadada" << std::endl;
     };
 
     /**

math/cluster/GSCluster.cpp

@@ -23,23 +23,25 @@ using namespace NICE;
 
 
 
-GSCluster::GSCluster( const Config *conf ) : GenerateSignature ( conf )
+GSCluster::GSCluster( const Config *conf, const std::string & _section ) : GenerateSignature ( conf )
 {
-    c_no_clusters = conf->gI("GSCluster", "clusters", 20);
-    // refactor-nice.pl: check this substitution
-    // old: string cluster_method = conf->gS("GSCluster", "cluster_method", "kmeans");
     std::string cluster_method = conf->gS("GSCluster", "cluster_method", "kmeans");
     if ( cluster_method == "kmeans" )
     {
-	clualg = new KMeans ( c_no_clusters );
-    } else if ( cluster_method == "spectral" ) {
-	double alpha = conf->gD("GSCluster", "spectral_alpha", 1.0);
-	clualg = new SpectralCluster ( c_no_clusters, alpha );
-    } else if ( cluster_method == "kmeans_matlab" ) {
-	clualg = new KMeansMatlab ( conf, c_no_clusters );
-    } else {
-	fprintf (stderr, "FATAL ERROR GSCluster: cluster method %s unknown !\n", cluster_method.c_str());
-	exit(-1);
+      clualg = new OBJREC::KMeans ( conf );
+    }
+    else if ( cluster_method == "spectral" )
+    {
+      clualg = new SpectralCluster ( conf );
+    }
+    else if ( cluster_method == "kmeans_matlab" )
+    {
+      clualg = new KMeansMatlab ( conf );
+    }
+    else
+    {
+      fprintf (stderr, "FATAL ERROR GSCluster: cluster method %s unknown !\n", cluster_method.c_str());
+      exit(-1);
     }
 }
 

math/cluster/GSCluster.h

@@ -17,26 +17,35 @@
 
 namespace OBJREC {
 
-/** Generate Signature by Clustering Local Features */
-class GSCluster : public GenerateSignature
-{
+    /** 
+     * @class GSCluster
+     * @brief Generate Signature by Clustering Local Features (image-specific codebook!).
+     * The class can be used for the EMD kernel, but not for usual BoV approaches.
+     * @author Erik Rodner
+     */
+    class GSCluster : public GenerateSignature
+    {
 
-    protected:
-	int c_no_clusters;
+        protected:
+          int c_no_clusters;
 
-	ClusterAlgorithm *clualg;
+          ClusterAlgorithm *clualg;
 
-    public:
-  
-	/** simple constructor */
-	GSCluster( const NICE::Config *conf );
+        public:
       
-	/** simple destructor */
-	virtual ~GSCluster();
-     
-	void signature ( const NICE::VVector & features,
-			 NICE::Vector & signature );
-};
+          /** standard  constructor
+           * @param conf config file specifying all relevant variable settings.  You should specify in "section" the string "cluster_method"
+           * @param _section name of the section within the configfile where the settings can be found. Default: GSCluster
+           * @param[in] 
+           */
+          GSCluster( const NICE::Config *conf, const std::string & _section = "GSCluster" );
+              
+          /** simple destructor */
+          virtual ~GSCluster();
+            
+          void signature ( const NICE::VVector & features,
+              NICE::Vector & signature );
+    };
 
 
 } // namespace

math/cluster/GenericClusterAlgorithmSelection.h

@@ -0,0 +1,94 @@
+/** 
+* @file GenericClusterAlgorithmSelection.h
+* @brief This class provides a generic chooser function for different clustering techniques
+* @date 14-06-2013 (dd-mm-yyyy)
+* @author Alexander Freytag
+*/
+
+#ifndef _NICE_GENERICCLUSTERALGORITHMSELECTION_INCLUDE
+#define _NICE_GENERICCLUSTERALGORITHMSELECTION_INCLUDE
+
+#include <iostream>
+
+//abstract base class
+#include "vislearning/math/cluster/ClusterAlgorithm.h"
+//derived specializations
+#include "vislearning/math/cluster/GMM.h"
+#include "vislearning/math/cluster/KMeans.h"
+#include "vislearning/math/cluster/KMeansHeuristic.h"
+#include "vislearning/math/cluster/KMeansMatlab.h"
+#include "vislearning/math/cluster/KMedian.h"
+#include "vislearning/math/cluster/RandomClustering.h"
+#include "vislearning/math/cluster/SpectralCluster.h"
+
+namespace OBJREC {
+
+  /** @class GenericClusterAlgorithmSelection
+  * @brief This class provides a generic chooser function for different clustering techniques
+  * The abstract base class is ClusterAlgorithm
+  * @date 14-06-2013 (dd-mm-yyyy)
+  * @author Alexander Freytag
+  */
+  class GenericClusterAlgorithmSelection
+  {
+      public:
+
+        /** 
+        * @brief This methode switches between the different clustering techniques. 
+        * @param[in] conf - A pointer to the given configfile, which should contain "section" - "clusterTechnique"
+        * @param[in] section - This string defines the value for "section" in the configfile.
+        * @return ClusterAlgorithm* - The ClusterAlgorithm to cluster samples according to the selected clustering technique.
+        * @date 14-06-2013 (dd-mm-yyyy)
+        * @author Alexander Freytag
+        */
+        static
+        OBJREC::ClusterAlgorithm *selectClusterAlgo ( const NICE::Config *conf, std::string section = "clustering" )
+        {
+          // return value
+          OBJREC::ClusterAlgorithm *clusterAlgo = NULL;
+        
+          // string which defines the clustering technique
+          std::string clusterTechnique = conf->gS(section, "clusterTechnique", "");
+        
+          if ( clusterTechnique == "kmeans" )
+          {
+            clusterAlgo = new OBJREC::KMeans ( conf );
+          }        
+          else if ( clusterTechnique == "kmeansHeuristic" )
+          {
+            clusterAlgo = new OBJREC::KMeansHeuristic ( conf );
+          }   
+          else if ( clusterTechnique == "kmeansMatlab" )
+          {
+            clusterAlgo = new OBJREC::KMeansMatlab ( conf );
+          }            
+          else if ( clusterTechnique == "kmedian" )
+          {
+            clusterAlgo = new OBJREC::KMedian ( conf );
+          }     
+          else if ( clusterTechnique == "GMM" )
+          {
+            clusterAlgo = new OBJREC::GMM ( conf );
+          } 
+          else if ( clusterTechnique == "spectral" )
+          {
+            clusterAlgo = new OBJREC::SpectralCluster ( conf );
+          }           
+          else if ( clusterTechnique == "random" )
+          {
+            clusterAlgo = new OBJREC::RandomClustering ( conf );
+          }            
+          else 
+          {
+            //default: random clustering - it is easy, fast, does not need extra memory, and is still better than a NULL pointer
+            std::cerr << "Unknown cluster algorithm selected, use random clustering instead" << std::endl;
+            clusterAlgo = new OBJREC::RandomClustering ( conf );
+          }
+            
+          return clusterAlgo;
+        }
+  };
+
+}
+
+#endif

math/cluster/KMeans.cpp

@@ -1,9 +1,8 @@
 /**
  * @file KMeans.cpp
  * @brief K-Means
- * @author Erik Rodner
- * @date 10/29/2007
-
+ * @author Erik Rodner, Alexander Freytag
+ * @date 29-10-2007 (dd-mm-yyyy)
  */
 
 #include <iostream>
@@ -21,277 +20,293 @@ using namespace NICE;
 
 #undef DEBUG_KMEANS
 
-KMeans::KMeans(int _noClasses, string _distanceType) :
-	noClasses(_noClasses), distanceType(_distanceType)
+KMeans::KMeans(const int & _noClasses, const std::string & _distanceType) :
+        noClasses(_noClasses), distanceType(_distanceType)
 {
-	//srand(time(NULL));
-	distancefunction = GenericDistanceSelection::selectDistance(distanceType);
+    //srand(time(NULL));
+    this->distancefunction = GenericDistanceSelection::selectDistance(distanceType);
+}
+
+KMeans::KMeans( const NICE::Config *conf, const std::string & _section)
+{       
+  this->distanceType = conf->gS( _section, "distanceType", "euclidean" );
+  this->distancefunction = GenericDistanceSelection::selectDistance(distanceType);
+  
+  this->d_minDelta  = conf->gD( _section, "minDelta", 1e-5 );
+  this->i_maxIterations = conf->gI( _section, "maxIterations", 200);
+  
+  this->noClasses = conf->gI( _section, "noClasses", 20);
 }
 
 KMeans::~KMeans()
 {
 }
 
-void KMeans::initial_guess(const VVector & features, VVector & prototypes)
+void KMeans::initial_guess(const NICE::VVector & features, NICE::VVector & prototypes)
 {
-	int j = 0;
-	std::set<int, std::greater<int> > mark;
+    int j = 0;
+    std::set<int, std::greater<int> > mark;
 
-	for (VVector::iterator i = prototypes.begin(); i != prototypes.end(); i++, j++)
-	{
-		int k;
+    for (VVector::iterator i = prototypes.begin(); i != prototypes.end(); i++, j++)
+    {
+        int k;
 
-		do
-		{
-			k = rand() % features.size();
-		} while (mark.find(k) != mark.end());
+        do
+        {
+            k = rand() % features.size();
+        } while (mark.find(k) != mark.end());
 
-		mark.insert(mark.begin(), k);
+        mark.insert(mark.begin(), k);
 
-		*i = features[k];
-	}
+        *i = features[k];
+    }
 }
 
 int KMeans::compute_prototypes(const VVector & features, VVector & prototypes,
-		std::vector<double> & weights, const std::vector<int> & assignment)
+                               std::vector<double> & weights, const std::vector<int> & assignment)
 {
-	int j = 0;
-	// fprintf (stderr, "KMeans::compute_prototypes: init noClasses=%d\n", noClasses);
-	for (int k = 0; k < noClasses; k++)
-	{
-		prototypes[k].set(0);
-		weights[k] = 0;
-	}
-
-	// fprintf (stderr, "KMeans::compute_prototypes: compute means\n");
-	for (VVector::const_iterator i = features.begin(); i != features.end(); i++, j++)
-	{
-		int k = assignment[j];
-
-		NICE::Vector & p = prototypes[k];
-
-		const NICE::Vector & x = *i;
-
-#ifdef DEBUG_KMEANS
-
-		fprintf(
-				stderr,
-				"KMeans::compute_prototypes: std::vector %d has assignment %d\n",
-				j, k);
-#endif
-
-		p += x;
-
-#ifdef DEBUG_KMEANS
-		cerr << "vector was : " << x << endl;
-		cerr << "prototype for this class is now : " << p << endl;
-#endif
-		weights[k]++;
-	}
-
-	// fprintf (stderr, "KMeans::compute_prototypes: scaling\n");
-	for (int k = 0; k < noClasses; k++)
-	{
-
-		NICE::Vector & p = prototypes[k];
-
-#ifdef DEBUG_KMEANS
-		cerr << "prototype for this class before scaling : " << p << endl;
-#endif
-
-		if (weights[k] <= 0)
-		{
-			return -1;
-		}
-
-		p *= (1.0 / weights[k]);
-
-		weights[k] = weights[k] / features.size();
-
-#ifdef DEBUG_KMEANS
-		cerr << "prototype for this class after scaling with " << weights[k]
-				<< " : " << p << endl;
-#endif
-	}
-
-	return 0;
+    int j = 0;
+    // fprintf (stderr, "KMeans::compute_prototypes: init noClasses=%d\n", noClasses);
+    for (int k = 0; k < this->noClasses; k++)
+    {
+        prototypes[k].set(0);
+        weights[k] = 0;
+    }
+
+    // fprintf (stderr, "KMeans::compute_prototypes: compute means\n");
+    for (VVector::const_iterator i = features.begin(); i != features.end(); i++, j++)
+    {
+        int k = assignment[j];
+
+        NICE::Vector & p = prototypes[k];
+
+        const NICE::Vector & x = *i;
+
+        #ifdef DEBUG_KMEANS
+          fprintf(
+              stderr,
+              "KMeans::compute_prototypes: std::vector %d has assignment %d\n",
+              j, k);
+        #endif
+
+        p += x;
+
+        #ifdef DEBUG_KMEANS
+          std::cerr << "vector was : " << x << std::endl;
+          std::cerr << "prototype for this class is now : " << p << std::endl;
+        #endif
+          
+        weights[k]++;
+    }
+
+    // fprintf (stderr, "KMeans::compute_prototypes: scaling\n");
+    for (int k = 0; k < this->noClasses; k++)
+    {
+
+        NICE::Vector & p = prototypes[k];
+
+        #ifdef DEBUG_KMEANS
+          std::cerr << "prototype for this class before scaling : " << p << std::endl;
+        #endif
+
+        if (weights[k] <= 0)
+        {
+            return -1;
+        }
+
+        p *= (1.0 / weights[k]);
+
+        weights[k] = weights[k] / features.size();
+
+        #ifdef DEBUG_KMEANS
+          std::cerr << "prototype for this class after scaling with " << weights[k]
+             << " : " << p << std::endl;
+        #endif
+    }
+
+    return 0;
 }
 
-double KMeans::compute_delta(const VVector & oldprototypes,
-		const VVector & prototypes)
+double KMeans::compute_delta(const NICE::VVector & oldprototypes,
+                             const NICE::VVector & prototypes)
 {
-	double distance = 0;
-
-	for (uint k = 0; k < oldprototypes.size(); k++)
-	{
-		distance
-				+= distancefunction->calculate(oldprototypes[k], prototypes[k]);
-#ifdef DEBUG_KMEANS
-	fprintf(stderr, "KMeans::compute_delta: Distance:",
-			distancefunction->calculate(oldprototypes[k], prototypes[k]));
-#endif
-	}
-	return distance;
+    double distance = 0;
+
+    for (uint k = 0; k < oldprototypes.size(); k++)
+    {
+        distance += this->distancefunction->calculate(oldprototypes[k], prototypes[k]);
+        
+        #ifdef DEBUG_KMEANS
+          fprintf(stderr, "KMeans::compute_delta: Distance: %f",
+                distancefunction->calculate(oldprototypes[k], prototypes[k]));
+        #endif
+    }
+    return distance;
 }
 
-double KMeans::compute_assignments(const VVector & features,
-		const VVector & prototypes, std::vector<int> & assignment)
+double KMeans::compute_assignments(const NICE::VVector & features,
+                                   const NICE::VVector & prototypes, std::vector<int> & assignment)
 {
-	int index = 0;
-	for (VVector::const_iterator i = features.begin(); i != features.end(); i++, index++)
-	{
-
-		const NICE::Vector & x = *i;
-		double mindist = std::numeric_limits<double>::max();
-		int minclass = 0;
-
-		int c = 0;
-#ifdef DEBUG_KMEANS
-
-		fprintf(stderr, "computing nearest prototype for std::vector %d\n",
-				index);
-#endif
-		for (VVector::const_iterator j = prototypes.begin(); j
-				!= prototypes.end(); j++, c++)
-		{
-
-			const NICE::Vector & p = *j;
-			double distance = distancefunction->calculate(p, x);
-#ifdef DEBUG_KMEANS
-	fprintf(stderr, "KMeans::compute_delta: Distance:",
-			distancefunction->calculate(p, x));
-#endif
-
-#ifdef DEBUG_KMEANS
-			cerr << p << endl;
-			cerr << x << endl;
-			fprintf(stderr, "distance to prototype %d is %f\n", c, distance);
-#endif
-
-			if (distance < mindist)
-			{
-				minclass = c;
-				mindist = distance;
-			}
-		}
-
-		assignment[index] = minclass;
-	}
-
-	return 0.0;
+    int index = 0;
+    for (VVector::const_iterator i = features.begin(); i != features.end(); i++, index++)
+    {
+
+        const NICE::Vector & x = *i;
+        double mindist = std::numeric_limits<double>::max();
+        int minclass = 0;
+
+        int c = 0;
+        #ifdef DEBUG_KMEANS
+
+          fprintf(stderr, "computing nearest prototype for std::vector %d\n",
+                index);
+        #endif
+        for (VVector::const_iterator j = prototypes.begin(); j
+                != prototypes.end(); j++, c++)
+        {
+
+            const NICE::Vector & p = *j;
+            double distance = this->distancefunction->calculate(p, x);
+            #ifdef DEBUG_KMEANS
+              fprintf(stderr, "KMeans::compute_delta: Distance: %f",
+                    this->distancefunction->calculate(p, x));
+            #endif
+
+            #ifdef DEBUG_KMEANS
+              std::cerr << p << std::endl;
+              std::cerr << x << std::endl;
+              fprintf(stderr, "distance to prototype %d is %f\n", c, distance);
+            #endif
+
+            if (distance < mindist)
+            {
+                minclass = c;
+                mindist = distance;
+            }
+        }
+
+        assignment[index] = minclass;
+    }
+
+    return 0.0;
 }
 
-double KMeans::compute_weights(const VVector & features,
-		std::vector<double> & weights, std::vector<int> & assignment)
+double KMeans::compute_weights(const NICE::VVector & features,
+                               std::vector<double> & weights, std::vector<int> & assignment)
 {
-	for (int k = 0; k < noClasses; k++)
-		weights[k] = 0;
+    for (int k = 0; k < this->noClasses; k++)
+        weights[k] = 0;
 
-	int j = 0;
+    int j = 0;
 
-	for (VVector::const_iterator i = features.begin(); i != features.end(); i++, j++)
-	{
-		int k = assignment[j];
-		weights[k]++;
-	}
+    for (NICE::VVector::const_iterator i = features.begin(); i != features.end(); i++, j++)
+    {
+        int k = assignment[j];
+        weights[k]++;
+    }
 
-	for (int k = 0; k < noClasses; k++)
-		weights[k] = weights[k] / features.size();
+    for (int k = 0; k < this->noClasses; k++)
+        weights[k] = weights[k] / features.size();
 
-	return 0.0;
+    return 0.0;
 }
 
-void KMeans::cluster(const VVector & features, VVector & prototypes,
-		std::vector<double> & weights, std::vector<int> & assignment)
+void KMeans::cluster(const NICE::VVector & features, NICE::VVector & prototypes,
+                     std::vector<double> & weights, std::vector<int> & assignment)
 {
-	VVector oldprototypes;
-
-	prototypes.clear();
-	weights.clear();
-	assignment.clear();
-	weights.resize(noClasses, 0);
-	assignment.resize(features.size(), 0);
-
-	int dimension;
-
-	if ((int) features.size() >= noClasses)
-		dimension = features[0].size();
-	else
-	{
-		fprintf(stderr,
-				"FATAL ERROR: Not enough feature vectors provided for kMeans\n");
-		exit(-1);
-	}
-
-	for (int k = 0; k < noClasses; k++)
-	{
-		prototypes.push_back(Vector(dimension));
-		prototypes[k].set(0);
-	}
-
-	KMeans_Restart:
-
-	initial_guess(features, prototypes);
-
-	int iterations = 0;
-	double delta = std::numeric_limits<double>::max();
-	const double minDelta = 1e-5;
-	const int maxIterations = 200;
-
-	do
-	{
-		iterations++;
-		compute_assignments(features, prototypes, assignment);
-
-		if (iterations > 1)
-			oldprototypes = prototypes;
-
-#ifdef DEBUG_KMEANS
-		fprintf(stderr, "KMeans::cluster compute_prototypes\n");
-
-#endif
-		if (compute_prototypes(features, prototypes, weights, assignment) < 0)
-		{
-			fprintf(stderr, "KMeans::cluster restart\n");
-			goto KMeans_Restart;
-		}
-
-#ifdef DEBUG_KMEANS
-		fprintf(stderr, "KMeans::cluster compute_delta\n");
-
-#endif
-		if (iterations > 1)
-			delta = compute_delta(oldprototypes, prototypes);
-
-#ifdef DEBUG_KMEANS
-		print_iteration(iterations, prototypes, delta);
-
-#endif
-
-	} while ((delta > minDelta) && (iterations < maxIterations));
-
-#ifdef DEBUG_KMEANS
-	fprintf(stderr, "KMeans::cluster: iterations = %d, delta = %f\n",
-			iterations, delta);
-
-#endif
-
-	compute_weights(features, weights, assignment);
+  NICE::VVector oldprototypes;
+
+  prototypes.clear();
+  weights.clear();
+  assignment.clear();
+  weights.resize(noClasses, 0);
+  assignment.resize(features.size(), 0);
+
+  int dimension;
+
+  if ((int) features.size() >= this->noClasses)
+      dimension = features[0].size();
+  else
+  {
+      fprintf(stderr,
+              "FATAL ERROR: Not enough feature vectors provided for kMeans\n");
+      exit(-1);
+  }
+
+  for (int k = 0; k < this->noClasses; k++)
+  {
+      prototypes.push_back(Vector(dimension));
+      prototypes[k].set(0);
+  }
+
+  bool successKMeans ( false );
+  int iterations ( 0 );
+  double delta ( std::numeric_limits<double>::max() );
+  
+  while ( !successKMeans )
+  {
+    //we assume that this run will be successful
+    successKMeans = true;  
+
+    this->initial_guess(features, prototypes);
+    
+    iterations = 0;
+    delta =  std::numeric_limits<double>::max();    
+
+    do
+    {
+        iterations++;
+        this->compute_assignments(features, prototypes, assignment);
+
+        if (iterations > 1)
+            oldprototypes = prototypes;
+
+        #ifdef DEBUG_KMEANS
+        fprintf(stderr, "KMeans::cluster compute_prototypes\n");
+        #endif
+        
+        if ( this->compute_prototypes(features, prototypes, weights, assignment) < 0 )
+        {
+            fprintf(stderr, "KMeans::cluster restart\n");
+            successKMeans = false;
+            break;
+        }
+
+        #ifdef DEBUG_KMEANS
+          fprintf(stderr, "KMeans::cluster compute_delta\n");
+        #endif
+        
+        if (iterations > 1)
+            delta = this->compute_delta(oldprototypes, prototypes);
+
+        #ifdef DEBUG_KMEANS
+          print_iteration(iterations, prototypes, delta);
+        #endif
+
+    } while ((delta > d_minDelta) && (iterations < i_maxIterations));
+    
+  }
+
+  #ifdef DEBUG_KMEANS
+    fprintf(stderr, "KMeans::cluster: iterations = %d, delta = %f\n", iterations, delta);
+  #endif
+
+  this->compute_weights(features, weights, assignment);
 }
 
-void KMeans::print_iteration(int iterations, VVector & prototypes, double delta)
+void KMeans::print_iteration(int iterations, NICE::VVector & prototypes, double delta)
 {
-	if (iterations > 1)
-		fprintf(stderr, "KMeans::cluster: iteration=%d delta=%f\n", iterations,
-				delta);
-	else
-		fprintf(stderr, "KMeans::cluster: iteration=%d\n", iterations);
-
-	int k = 0;
-
-	for (VVector::const_iterator i = prototypes.begin(); i != prototypes.end(); i++, k++)
-	{
-		fprintf(stderr, "class (%d)\n", k);
-		cerr << "prototype = " << (*i) << endl;
-	}
+    if (iterations > 1)
+        fprintf(stderr, "KMeans::cluster: iteration=%d delta=%f\n", iterations,
+                delta);
+    else
+        fprintf(stderr, "KMeans::cluster: iteration=%d\n", iterations);
+
+    int k = 0;
+
+    for (NICE::VVector::const_iterator i = prototypes.begin(); i != prototypes.end(); i++, k++)
+    {
+        fprintf(stderr, "class (%d)\n", k);
+        std::cerr << "prototype = " << (*i) << std::endl;
+    }
 }

math/cluster/KMeans.h

@@ -1,13 +1,14 @@
 /** 
 * @file KMeans.h
 * @brief K-Means
-* @author Erik Rodner
-* @date 10/29/2007
-
+* @author Erik Rodner, Alexander Freytag
+* @date 29-10-2007 (dd-mm-yyyy)
 */
 #ifndef KMEANSINCLUDE
 #define KMEANSINCLUDE
 
+#include <core/basics/Config.h>
+#include <core/vector/Distance.h>
 #include "core/vector/VectorT.h"
 #include "core/vector/MatrixT.h"
   
@@ -17,51 +18,110 @@
 namespace OBJREC {
 
 /** K-Means */
-class KMeans : public ClusterAlgorithm
-{
+  /**
+   * @class K-Means
+   * @brief K-Means
+   * @author Erik Rodner, Alexander Freytag
+   * @date 29-10-2007 (dd-mm-yyyy)
+  */  
+  class KMeans : public ClusterAlgorithm
+  {
 
     protected:
-	int noClasses;
-	std::string distanceType;
-	NICE::VectorDistance<double> *distancefunction;
-	double vectorDistance(const NICE::Vector &vector1, const NICE::Vector &vector2, uint distancetype);
-	double compute_assignments ( const NICE::VVector & features,
-				     const NICE::VVector & prototypes,
-				     std::vector<int> & assignment );
+          
+        /************************
+        * 
+        *   protected variables
+        * 
+        **************************/         
+          
+          //! desired number of clusters
+          int noClasses;
+          
+          //! specify which distance to use for calculating assignments
+          std::string distanceType;
+          
+          //! the actual distance metric
+          NICE::VectorDistance<double> *distancefunction;
+          
+          //! maximum difference between prototype-solutions of two iterations for convergence
+          double d_minDelta;
+          
+          //! maximum number of iterations until convergence
+          int i_maxIterations;          
+          
+        /************************
+        * 
+        *   protected methods
+        * 
+        **************************/          
+          
+        //! compute the distance between two features using the specified distance metric
+          double vectorDistance(const NICE::Vector &vector1, const NICE::Vector &vector2, uint distancetype);
+          
+        //! compute assignments of all given features wrt to the currently known prototypes (cluster centroids) == ~ E-step
+          double compute_assignments ( const NICE::VVector & features,
+                                      const NICE::VVector & prototypes,
+                                      std::vector<int> & assignment );
 
-	double compute_weights ( const NICE::VVector & features,
-				 std::vector<double> & weights,
-				 std::vector<int>    & assignment );
+        //! compute number of assignments for every currently found cluster
+          double compute_weights ( const NICE::VVector & features,
+                                  std::vector<double> & weights,
+                                  std::vector<int>    & assignment );
 
-	double compute_delta ( const NICE::VVector & oldprototypes,
-				       const NICE::VVector & prototypes );
+        //! compute the difference between prototypes of previous iteration and those currently found
+          double compute_delta ( const NICE::VVector & oldprototypes,
+                                const NICE::VVector & prototypes );
 
-	int compute_prototypes ( const NICE::VVector & features,
-				  NICE::VVector & prototypes,
-				  std::vector<double> & weights,
-				  const std::vector<int>    & assignment );
+        //! compute (update) prototypes given the current assignments == ~ M-step
+          int compute_prototypes ( const NICE::VVector & features,
+                                  NICE::VVector & prototypes,
+                                  std::vector<double> & weights,
+                                  const std::vector<int>    & assignment );
+          
+        //! have an initial guess, i.e., randomly pick some features as initial cluster centroids
+          void initial_guess ( const NICE::VVector & features,
+                              NICE::VVector & prototypes );
+        //! give additional information for the current iteration
+          void print_iteration ( int iterations,
+                                NICE::VVector & prototypes,
+                                double delta );
 
-	void initial_guess ( const NICE::VVector & features,
-			     NICE::VVector & prototypes );
-	
-	void print_iteration ( int iterations, 
-			       NICE::VVector & prototypes,
-			       double delta );
+      public:
 
-    public:
-  
-	/** simple constructor */
-	KMeans( int noClasses , std::string distanceMode="euclidean");
+        /**
+        * @brief simple constructor
+        * @param _noClasses the number of clusters to be computed
+        * @param _distanceMode a string specifying the distance function to be used (default: euclidean)
+        */
+        KMeans( const int & _noClasses , const std::string & _distanceMode="euclidean");
       
-	/** simple destructor */
-	virtual ~KMeans();
-     
-	void cluster ( const NICE::VVector & features,
-		       NICE::VVector & prototypes,
-		       std::vector<double> & weights,
-		       std::vector<int>    & assignment );
+        /**
+        * @brief standard constructor
+        * @param conf config file specifying all relevant variable settings
+        * @param _section name of the section within the configfile where the settings can be found (default: KMeans)
+        */
+        KMeans( const NICE::Config *conf, const std::string & _section = "KMeans");      
+
+        /** simple destructor */
+        virtual ~KMeans();
+
+        
+          /**
+          *@brief this is the actual method that performs the clustering for a given set of features
+          *@author Erik Rodner, Alexander Freytag
+          *@date 29-10-2007 (dd-mm-yyyy)
+          *@param   features input features to be clustered
+          *@param   prototypes computed prototypes (cluster medoids) for the given samples
+          *@param   weights number of assignments for every cluster
+          *@param   assignment explicite assignments of features to computed cluster medoids
+          */            
+        void cluster ( const NICE::VVector & features,
+                      NICE::VVector & prototypes,
+                      std::vector<double> & weights,
+                      std::vector<int>    & assignment );
 
-};
+  };
 
 
 } // namespace

math/cluster/KMeansHeuristic.cpp

@@ -18,11 +18,19 @@ using namespace NICE;
 
 #undef DEBUG_KMeansHeuristic
 
-KMeansHeuristic::KMeansHeuristic(int _noClasses, string _distanceType) :
-	noClasses(_noClasses), distanceType(_distanceType)
+KMeansHeuristic::KMeansHeuristic(int _noClusters, string _distanceType) :
+	noClusters(_noClusters), distanceType(_distanceType)
 {
-	//srand(time(NULL));
-	distancefunction = GenericDistanceSelection::selectDistance(distanceType);
+  //srand(time(NULL));
+  distancefunction = GenericDistanceSelection::selectDistance(distanceType);
+}
+
+KMeansHeuristic::KMeansHeuristic( const NICE::Config *conf, const std::string & _section)
+{       
+  this->distanceType = conf->gS( _section, "distanceType", "euclidean" );
+  this->distancefunction = GenericDistanceSelection::selectDistance(distanceType);
+  
+  this->noClusters = conf->gI( _section, "noClusters", 20);
 }
 
 KMeansHeuristic::~KMeansHeuristic()
@@ -200,7 +208,7 @@ double KMeansHeuristic::compute_assignments(const VVector & features,
 double KMeansHeuristic::compute_weights(const VVector & features, std::vector<
 		double> & weights, std::vector<int> & assignment)
 {
-	for (int k = 0; k < noClasses; k++)
+	for (int k = 0; k < noClusters; k++)
 		weights[k] = 0;
 
 	int j = 0;
@@ -211,7 +219,7 @@ double KMeansHeuristic::compute_weights(const VVector & features, std::vector<
 		weights[k]++;
 	}
 
-	for (int k = 0; k < noClasses; k++)
+	for (int k = 0; k < noClusters; k++)
 		weights[k] = weights[k] / features.size();
 
 	return 0.0;
@@ -225,12 +233,12 @@ void KMeansHeuristic::cluster(const VVector & features, VVector & prototypes,
 	prototypes.clear();
 	weights.clear();
 	assignment.clear();
-	weights.resize(noClasses, 0);
+	weights.resize(noClusters, 0);
 	assignment.resize(features.size(), 0);
 
 	int dimension;
 
-	if ((int) features.size() >= noClasses)
+	if ((int) features.size() >= noClusters)
 		dimension = features[0].size();
 	else
 	{
@@ -239,7 +247,7 @@ void KMeansHeuristic::cluster(const VVector & features, VVector & prototypes,
 		exit(-1);
 	}
 
-	for (int k = 0; k < noClasses; k++)
+	for (int k = 0; k < noClusters; k++)
 	{
 		prototypes.push_back(Vector(dimension));
 		prototypes[k].set(0);

math/cluster/KMeansHeuristic.h

@@ -8,50 +8,61 @@
 #ifndef KMeansHeuristicINCLUDE
 #define KMeansHeuristicINCLUDE
 
+#include <core/basics/Config.h>
 #include <core/vector/Distance.h>
-#include "ClusterAlgorithm.h"
-
 #include "core/vector/VectorT.h"
 #include "core/vector/MatrixT.h"
 
+#include "ClusterAlgorithm.h"
+
 
 namespace OBJREC
 {
 
-/** K-Means */
-class KMeansHeuristic: public ClusterAlgorithm
-{
+  /** K-Means (but what does Heuristic actually mean? )*/
+  class KMeansHeuristic: public ClusterAlgorithm
+  {
 
-protected:
-	int noClasses;
-	std::string distanceType;
-	NICE::VectorDistance<double> *distancefunction;
-	double compute_assignments(const NICE::VVector & features,
-			const NICE::VVector & prototypes, std::vector<int> & assignment);
+  protected:
+    int noClusters;
+    std::string distanceType;
+    NICE::VectorDistance<double> *distancefunction;
+    
+    double compute_assignments(const NICE::VVector & features,
+        const NICE::VVector & prototypes, std::vector<int> & assignment);
 
-	double compute_weights(const NICE::VVector & features,
-			std::vector<double> & weights, std::vector<int> & assignment);
+    double compute_weights(const NICE::VVector & features,
+        std::vector<double> & weights, std::vector<int> & assignment);
 
-	double compute_delta(const NICE::VVector & oldprototypes,
-			const NICE::VVector & prototypes);
+    double compute_delta(const NICE::VVector & oldprototypes,
+        const NICE::VVector & prototypes);
 
 
-	void initial_guess(const NICE::VVector & features, NICE::VVector & prototypes);
+    void initial_guess(const NICE::VVector & features, NICE::VVector & prototypes);
 
-	void print_iteration(int iterations, NICE::VVector & prototypes, double delta);
-	int robust_prototypes(const NICE::VVector &features, NICE::VVector &prototypes, std::vector<
-			double> & weights, const std::vector<int> & assignment);
-public:
+    void print_iteration(int iterations, NICE::VVector & prototypes, double delta);
+    int robust_prototypes(const NICE::VVector &features, NICE::VVector &prototypes, std::vector<
+        double> & weights, const std::vector<int> & assignment);
+  public:
 
-	/** simple constructor */
-	KMeansHeuristic(int noClasses, std::string distanceMode = "euclidean");
+    /** simple constructor */
+    KMeansHeuristic(int noClusters, std::string distanceMode = "euclidean");
+    
+    /**
+    * @brief standard constructor
+    * @param conf config file specifying all relevant variable settings
+    * @param _section name of the section within the configfile where the settings can be found (default: KMeansHeuristic)
+    * @date 14-06-2013 (dd-mm-yyyy)
+    * @author Alexander Freytag
+    */
+    KMeansHeuristic( const NICE::Config *conf, const std::string & _section = "KMeansHeuristic");    
 
-	/** simple destructor */
-	virtual ~KMeansHeuristic();
+    /** simple destructor */
+    virtual ~KMeansHeuristic();
 
-	void cluster(const NICE::VVector & features, NICE::VVector & prototypes, std::vector<double> & weights, std::vector<int> & assignment);
+    void cluster(const NICE::VVector & features, NICE::VVector & prototypes, std::vector<double> & weights, std::vector<int> & assignment);
 
-};
+  };
 
 } // namespace
 

math/cluster/KMeansMatlab.cpp

@@ -19,23 +19,23 @@ using namespace NICE;
 
 #undef DEBUG_KMeansMatlab
 
-KMeansMatlab::KMeansMatlab( const Config *conf, 
-			    int _noClasses ) : noClasses(_noClasses)
+KMeansMatlab::KMeansMatlab( const Config *conf, const std::string & _section )
 {
-    kmeansDir = conf->gS("matlab", "source_root", "/home/rodner/osl/labor/cvs/osl/") + "/kernel/";
-    inputFN   = conf->gS("KMeansMatlab", "tmpInput", "/tmp/KMeansMatlab.input" );
-    outputFN   = conf->gS("KMeansMatlab", "tmpoutput", "/tmp/KMeansMatlab.output" );
-
-    matlabExec = conf->gS("matlab", "matlab_exec", "matlab");
-    matlabArgs = conf->gS("matlab", "matlab_args", "-nosplash -nojvm -nodesktop");
-    
+  this->noClusters = conf->gI( _section, "noClusters", 20);
+  
+    kmeansDir = conf->gS(_section, "source_root", "/home/rodner/osl/labor/cvs/osl/") + "/kernel/";
+    inputFN   = conf->gS(_section, "tmpInput", "/tmp/KMeansMatlab.input" );
+    outputFN   = conf->gS(_section, "tmpOutput", "/tmp/KMeansMatlab.output" );
+
+    matlabExec = conf->gS(_section, "matlab_exec", "matlab");
+    matlabArgs = conf->gS(_section, "matlab_args", "-nosplash -nojvm -nodesktop");   
     
 }
 
 KMeansMatlab::~KMeansMatlab()
 {
-    if ( matlabPipe != NULL )
-	pclose (matlabPipe);
+  if ( matlabPipe != NULL )
+    pclose (matlabPipe);
 }
 
 
@@ -45,8 +45,8 @@ int KMeansMatlab::compute_prototypes ( const VVector & features,
 				  const std::vector<int>    & assignment )
 {
     int j = 0;
-    // fprintf (stderr, "KMeansMatlab::compute_prototypes: init noClasses=%d\n", noClasses);
-    for ( int k = 0 ; k < noClasses ; k++ )
+    // fprintf (stderr, "KMeansMatlab::compute_prototypes: init noClusters=%d\n", noClusters);
+    for ( int k = 0 ; k < noClusters ; k++ )
     {
 	prototypes[k].set(0);
 	weights[k] = 0;
@@ -81,7 +81,7 @@ int KMeansMatlab::compute_prototypes ( const VVector & features,
     }
 
     // fprintf (stderr, "KMeansMatlab::compute_prototypes: scaling\n");
-    for ( int k = 0 ; k < noClasses ; k++ )
+    for ( int k = 0 ; k < noClusters ; k++ )
     {
 	// refactor-nice.pl: check this substitution
 	// old: Vector & p = prototypes[k];
@@ -117,7 +117,7 @@ void KMeansMatlab::cluster ( const VVector & features,
     prototypes.clear();
     weights.clear();
     assignment.clear ();
-    weights.resize ( noClasses, 0 );
+    weights.resize ( noClusters, 0 );
     assignment.resize ( features.size(), 0 );
 
     // ----------- routine argument -------------
@@ -127,7 +127,7 @@ void KMeansMatlab::cluster ( const VVector & features,
 
     int dimension;
 
-    if ( (int)features.size() >= noClasses )
+    if ( (int)features.size() >= noClusters )
 	dimension = features[0].size();
     else {
 	fprintf (stderr, "FATAL ERROR: Not enough feature vectors provided for KMeansMatlab\n");
@@ -140,7 +140,7 @@ void KMeansMatlab::cluster ( const VVector & features,
 	fprintf (stderr, "KMeansMatlab: FATAL ERROR cannot write features!\n");
 	exit(-1);
     }
-    fwrite (&noClasses, sizeof(int), 1, fi );
+    fwrite (&noClusters, sizeof(int), 1, fi );
     int n = features.size();
     fwrite (&n, sizeof(int), 1, fi );
     int d = features[0].size();
@@ -191,7 +191,7 @@ void KMeansMatlab::cluster ( const VVector & features,
     fclose(g);
 
 
-    for ( int k = 0 ; k < noClasses ; k++ )
+    for ( int k = 0 ; k < noClusters ; k++ )
     {
 	// fprintf (stderr, "KMeansMatlab::cluster prototype init constructor\n");
 	prototypes.push_back( Vector( dimension ) );

math/cluster/KMeansMatlab.h

@@ -1,6 +1,6 @@
 /** 
 * @file KMeansMatlab.h
-* @brief K-Means
+* @brief K-Means using a matlab implementation
 * @author Erik Rodner
 * @date 10/29/2007
 
@@ -17,51 +17,60 @@
 
 namespace OBJREC {
 
-/** K-Means */
-class KMeansMatlab : public ClusterAlgorithm
-{
-
-    protected:
-	int noClasses;
-	// refactor-nice.pl: check this substitution
-	// old: string kmeansDir;
-	std::string kmeansDir;
-	// refactor-nice.pl: check this substitution
-	// old: string matlabExec;
-	std::string matlabExec;
-	// refactor-nice.pl: check this substitution
-	// old: string matlabArgs;
-	std::string matlabArgs;
-
-	// refactor-nice.pl: check this substitution
-	// old: string inputFN;
-	std::string inputFN;
-	// refactor-nice.pl: check this substitution
-	// old: string outputFN;
-	std::string outputFN;
-
-	FILE *matlabPipe;
-	
-	int compute_prototypes ( const NICE::VVector & features,
-				  NICE::VVector & prototypes,
-				  std::vector<double> & weights,
-				  const std::vector<int>    & assignment );
-
-
-    public:
-  
-	/** simple constructor */
-	KMeansMatlab( const NICE::Config *conf, int noClasses );
-      
-	/** simple destructor */
-	virtual ~KMeansMatlab();
-     
-	void cluster ( const NICE::VVector & features,
-		       NICE::VVector & prototypes,
-		       std::vector<double> & weights,
-		       std::vector<int>    & assignment );
-
-};
+  /** 
+  * @class KMeansMatlab
+  * @brief K-Means using a matlab implementation
+  * @author Erik Rodner
+  */
+
+  class KMeansMatlab : public ClusterAlgorithm
+  {
+
+      protected:
+        int noClusters;
+        // refactor-nice.pl: check this substitution
+        // old: string kmeansDir;
+        std::string kmeansDir;
+        // refactor-nice.pl: check this substitution
+        // old: string matlabExec;
+        std::string matlabExec;
+        // refactor-nice.pl: check this substitution
+        // old: string matlabArgs;
+        std::string matlabArgs;
+
+        // refactor-nice.pl: check this substitution
+        // old: string inputFN;
+        std::string inputFN;
+        // refactor-nice.pl: check this substitution
+        // old: string outputFN;
+        std::string outputFN;
+
+        FILE *matlabPipe;
+        
+        int compute_prototypes ( const NICE::VVector & features,
+                NICE::VVector & prototypes,
+                std::vector<double> & weights,
+                const std::vector<int>    & assignment );
+
+
+      public:
+    
+        /** 
+        * @brief simple constructor
+        * @author Erik Rodner, Alexander Freytag
+        * Among others, you can specify for "section" the following attributes: "source_root", "tmpInput", "tmpOutput", "matlab_exec", "matlab_args"
+        */
+        KMeansMatlab( const NICE::Config *conf,  const std::string & _section = "KMeansMatlab" );
+            
+        /** simple destructor */
+        virtual ~KMeansMatlab();
+          
+        void cluster ( const NICE::VVector & features,
+                NICE::VVector & prototypes,
+                std::vector<double> & weights,
+                std::vector<int>    & assignment );
+
+  };
 
 
 } // namespace

math/cluster/KMedian.cpp

@@ -0,0 +1,430 @@
+/**
+ * @file KMedian.cpp
+ * @brief KMedian (aka K-medoid)
+ * @author Alexander Freytag
+ * @date 23-04-2013 (dd-mm-yyyy)
+ */
+
+#ifdef NICE_USELIB_OPENMP
+#include <omp.h>
+#endif
+
+#include <iostream>
+#include <map>
+#include <algorithm> //to easily find the smallest value in a map
+
+#include "vislearning/math/cluster/KMedian.h"
+#include "vislearning/math/distances/genericDistance.h"
+
+#include <set>
+
+using namespace OBJREC;
+
+using namespace std;
+
+using namespace NICE;
+
+
+typedef std::pair<int, double> MyPairType;
+struct CompareSecond
+{
+    bool operator()(const MyPairType& left, const MyPairType& right) const
+    {
+        return left.second < right.second;
+    }
+};
+
+#undef DEBUG_KMEDIAN_ASSIGNMENTS
+// #define DEBUG_KMEDIAN_ASSIGNMENTS
+
+#undef DEBUG_KMEDIAN_PROTOCOMP
+// #define DEBUG_KMEDIAN_PROTOCOMP
+
+
+KMedian::KMedian(const int & _noClusters, const std::string & _distanceType) :
+  noClusters(_noClusters), distanceType(_distanceType)
+{
+  //srand(time(NULL));
+  distancefunction = GenericDistanceSelection::selectDistance(distanceType);
+  
+  this->d_minDelta  = 1e-5;
+  this->i_maxIterations = 200;
+}
+
+KMedian::KMedian( const NICE::Config *conf, const std::string & _section)
+{       
+  this->distanceType = conf->gS( _section, "distanceType", "euclidean" );
+  this->distancefunction = GenericDistanceSelection::selectDistance(distanceType);
+  
+  this->d_minDelta  = conf->gD( _section, "minDelta", 1e-5 );
+  this->i_maxIterations = conf->gI( _section, "maxIterations", 200);
+  
+  this->noClusters = conf->gI( _section, "noClusters", 20);
+}
+
+KMedian::~KMedian()
+{
+}
+
+void KMedian::initial_guess(const VVector & features, VVector & prototypes)
+{
+  int j = 0;
+  std::set<int, std::greater<int> > mark;
+
+  for (VVector::iterator i = prototypes.begin(); i != prototypes.end(); i++, j++)
+  {
+    int k;
+
+    do
+    {
+      k = rand() % features.size();
+    } while (mark.find(k) != mark.end());
+
+    mark.insert(mark.begin(), k);
+
+    *i = features[k];
+  }
+}
+
+int KMedian::compute_prototypes(const VVector & features, VVector & prototypes,
+    std::vector<double> & weights, const std::vector<int> & assignment)
+{
+  
+  #ifdef DEBUG_KMEDIAN_PROTOCOMP  
+    std::cerr << "initial assignments: ";
+    for (std::vector<int>::const_iterator assignIt = assignment.begin(); assignIt != assignment.end(); assignIt++)
+    { 
+      std::cerr << " " << *assignIt;
+    } 
+    std::cerr << std::endl;
+  #endif
+  
+  //initialization
+  for (int k = 0; k < noClusters; k++)
+  {
+    prototypes[k].set(0);
+    weights[k] = 0;
+  }
+  
+  NICE::VectorT<int> numberOfCurrentAssignments ( noClusters ) ;
+  numberOfCurrentAssignments.set ( 0 );
+  
+  int exCnt = 0;  
+  //how many examples are assigned to the current clusters?
+  for (VVector::const_iterator i = features.begin(); i != features.end(); i++, exCnt++)
+  {
+    int k = assignment[exCnt];
+    //increase counter for assigned cluster
+    numberOfCurrentAssignments[ k ] ++;    
+  }
+    
+  #ifdef DEBUG_KMEDIAN_PROTOCOMP    
+    std::cerr << "k-median -- current assignmens: " << numberOfCurrentAssignments << std::endl << "noClusters: " << noClusters << std::endl;
+  #endif
+  
+  //compute the median for every cluster
+  #pragma omp parallel for
+  for (int clusterCnt = 0; clusterCnt < noClusters; clusterCnt++)
+  {    
+    NICE::Vector overallDistances ( numberOfCurrentAssignments[ clusterCnt ] );
+    VVector::const_iterator lastExampleWorkedOn = features.begin();
+    int i_idxOfLastExampleWorkedOn ( 0 );
+    uint i_exCntInt ( 0 );
+
+    //this map will contain overall distances of all examples within the current clusters
+    //we need separate maps for every cluster to allow parallelization
+    std::map<int,double> distancesWithinCluster;
+    for (VVector::const_iterator featIt = features.begin(); featIt != features.end(); featIt++, i_exCntInt++)
+    {
+      int k = assignment[i_exCntInt];
+      
+      //only considere examples currently assigned to cluster clusterCnt
+      if ( k != clusterCnt)
+      {
+        continue;      
+      }
+      
+      uint exCntIntTmp ( i_idxOfLastExampleWorkedOn ); //idx going over all features 
+      for (VVector::const_iterator j = lastExampleWorkedOn ; j != features.end(); j++, exCntIntTmp++)
+      {
+        int kTmp;
+        if ( exCntIntTmp < assignment.size() )
+          kTmp = assignment[exCntIntTmp];
+        else
+        {
+          //actually, this will be never be reached :)
+          std::cerr << "ERROR: exCntIntTmp >= assignment.size() " << exCntIntTmp << " " << assignment.size() << std::endl;
+        }
+        
+        //only considere examples currently assigned to cluster clusterCnt
+        if ( kTmp != clusterCnt)
+          continue;         
+       
+        
+        double dist ( distancefunction->calculate( *featIt, *j) );
+        if ( i_exCntInt < features.size() )
+        {
+          distancesWithinCluster[ i_exCntInt ] += dist;
+          #ifdef DEBUG_KMEDIAN_PROTOCOMP
+            std::cerr << "increase " << i_exCntInt << " by " << dist << " for " <<*featIt << " and " << *j << std::endl;
+          #endif
+        }
+        else
+        {
+          //actually, this will be never be reached :)          
+          std::cerr << "ERROR: i_exCntInt >= features.size() " << i_exCntInt << " " << features.size() << std::endl;
+        }
+
+        if ( i_exCntInt != exCntIntTmp )
+        {
+          if (exCntIntTmp < features.size() )
+          {
+            distancesWithinCluster[ exCntIntTmp ] += dist;
+            #ifdef DEBUG_KMEDIAN_PROTOCOMP
+              std::cerr << "increase also " << exCntIntTmp << " by " << dist << std::endl;
+            #endif
+          }
+          else
+            std::cerr << "ERROR: exCntIntTmp >= features.size() " << exCntIntTmp << " " << features.size() << std::endl;
+        }
+        
+      }      
+      
+      //inc by one to avoid calculating some distances twice
+      if ( ( featIt != features.end()) && ( (featIt +1 ) != features.end()) )
+      {
+        lastExampleWorkedOn = ( featIt + 1 );      
+        i_idxOfLastExampleWorkedOn = i_exCntInt+1;
+      }
+    }
+       
+    #ifdef DEBUG_KMEDIAN_PROTOCOMP
+      std::cerr << "distances for cluster " << clusterCnt << " ";
+      for(std::map<int,double>::const_iterator distIt = distancesWithinCluster.begin(); distIt != distancesWithinCluster.end(); distIt++)
+      {
+        std::cerr << distIt->first << " " << distIt->second << " ";
+      }
+      std::cerr << std::endl;
+    #endif
+      
+    //now compute the index of example with min overall distance
+    int idxOfClusterMedian ( (min_element(distancesWithinCluster.begin(), distancesWithinCluster.end(), CompareSecond()))->first );
+        
+    #pragma omp critical
+    prototypes[clusterCnt] = features[idxOfClusterMedian]; 
+ 
+    //finished computations for cluster k
+  }
+  
+  #ifdef DEBUG_KMEDIAN_PROTOCOMP
+    std::cerr << " ----   prototypes after current iteration:  --- " << std::endl;
+    for (NICE::VVector::const_iterator protoIt = prototypes.begin(); protoIt != prototypes.end(); protoIt++)
+    {
+      std::cerr << *protoIt << " ";
+    }
+    
+    std::cerr << std::endl;
+  #endif
+
+  return 0;
+}
+
+double KMedian::compute_delta(const VVector & oldprototypes,
+    const VVector & prototypes)
+{
+  double distance = 0;
+
+  for (uint k = 0; k < oldprototypes.size(); k++)
+  {
+    distance += distancefunction->calculate(oldprototypes[k], prototypes[k]);
+    
+    #ifdef DEBUG_KMEDIAN_ASSIGNMENTS
+      fprintf(stderr, "KMedian::compute_delta: Distance:",
+          distancefunction->calculate(oldprototypes[k], prototypes[k]));
+    #endif
+  }
+  return distance;
+}
+
+double KMedian::compute_assignments(const VVector & features,
+                                    const VVector & prototypes,
+                                    std::vector<int> & assignment)
+{
+  int index = 0;
+  for (VVector::const_iterator i = features.begin(); i != features.end(); i++, index++)
+  {
+
+    const NICE::Vector & x = *i;
+    double mindist = std::numeric_limits<double>::max();
+    int minclass = 0;
+
+    int c = 0;
+    
+    #ifdef DEBUG_KMEDIAN_ASSIGNMENTS
+
+        fprintf(stderr, "computing nearest prototype for std::vector %d\n",
+            index);
+    #endif
+        
+    for (VVector::const_iterator j = prototypes.begin(); j
+        != prototypes.end(); j++, c++)
+    {
+
+      const NICE::Vector & p = *j;
+      double distance = distancefunction->calculate(p, x);
+      
+      #ifdef DEBUG_KMEDIAN_ASSIGNMENTS
+        fprintf(stderr, "KMedian::compute_delta: Distance: %f\n",
+            distancefunction->calculate(p, x));
+      #endif
+
+      #ifdef DEBUG_KMEDIAN_ASSIGNMENTS
+            cerr << p << endl;
+            cerr << x << endl;
+            fprintf(stderr, "distance to prototype %d is %f\n", c, distance);
+      #endif
+
+      if (distance < mindist)
+      {
+        minclass = c;
+        mindist = distance;
+      }
+    }
+
+    assignment[index] = minclass;
+  }
+
+  return 0.0;
+}
+
+double KMedian::compute_weights(const VVector & features,
+                                std::vector<double> & weights,
+                                std::vector<int> & assignment)
+{
+  for (int k = 0; k < noClusters; k++)
+    weights[k] = 0;
+
+  int j = 0;
+
+  for (VVector::const_iterator i = features.begin(); i != features.end(); i++, j++)
+  {
+    int k = assignment[j];
+    weights[k]++;
+  }
+
+  for (int k = 0; k < noClusters; k++)
+    weights[k] = weights[k] / features.size();
+
+  return 0.0;
+}
+
+void KMedian::cluster(const NICE::VVector & features,
+                      NICE::VVector & prototypes,
+                      std::vector<double> & weights,
+                      std::vector<int> & assignment)
+{
+  NICE::VVector oldprototypes;
+
+  prototypes.clear();
+  weights.clear();
+  assignment.clear();
+  weights.resize(noClusters, 0);
+  assignment.resize(features.size(), 0);
+
+  int dimension;
+
+  if ((int) features.size() >= noClusters)
+    dimension = features[0].size();
+  else
+  {
+    fprintf(stderr,
+        "FATAL ERROR: Not enough feature vectors provided for kMedians -- number of Features: %i - number of clusters: %i\n", (int) features.size(), noClusters);
+    exit(-1);
+  }
+
+  for (int k = 0; k < noClusters; k++)
+  {
+    prototypes.push_back( NICE::Vector(dimension) );
+    prototypes[k].set(0);
+  }
+ 
+  bool successKMedian ( false );
+  int iterations ( 0 );
+  double delta ( std::numeric_limits<double>::max() );
+  
+  while ( !successKMedian )
+  {
+    //we assume that this run will be successful
+    successKMedian = true;
+    
+    this->initial_guess(features, prototypes);
+
+    iterations = 0;
+    delta =  std::numeric_limits<double>::max();
+
+    //until-loop over iterations
+    do
+    {
+      iterations++;
+      
+//       #ifdef DEBUG_KMEDIAN_ASSIGNMENTS
+        std::cerr << "k-median iteration " << iterations << std::endl;
+//       #endif
+        
+      this->compute_assignments( features, prototypes, assignment );
+
+      if (iterations > 1)
+        oldprototypes = prototypes;
+
+      #ifdef DEBUG_KMEDIAN_ASSIGNMENTS
+          fprintf(stderr, "KMedian::cluster compute_prototypes\n");
+      #endif
+      
+      if ( this->compute_prototypes( features, prototypes, weights, assignment ) < 0 )
+      {
+        fprintf(stderr, "KMedian::cluster restart\n");
+        successKMedian = false;
+        break;
+      }
+
+      #ifdef DEBUG_KMEDIAN_ASSIGNMENTS
+          fprintf(stderr, "KMedian::cluster compute_delta\n");
+      #endif
+      
+      if (iterations > 1)
+        delta = this->compute_delta( oldprototypes, prototypes );
+
+      #ifdef DEBUG_KMEDIAN_ASSIGNMENTS
+          this->print_iteration( iterations, prototypes, delta );
+      #endif
+
+    } while ((delta > d_minDelta) && (iterations < i_maxIterations));
+    
+  }
+
+  std::cerr << "ended optimization  -- delta: " << delta  << " of d_minDelta: " << d_minDelta << " --- and iterations: " << iterations << " of i_maxIterations: " << i_maxIterations << std::endl;
+    
+  #ifdef DEBUG_KMEDIAN_ASSIGNMENTS
+    fprintf(stderr, "KMedian::cluster: iterations = %d, delta = %f\n",
+        iterations, delta);
+  #endif
+
+  this->compute_weights( features, weights, assignment );
+}
+
+void KMedian::print_iteration( int iterations, VVector & prototypes, double delta )
+{
+  if (iterations > 1)
+    fprintf(stderr, "KMedian::cluster: iteration=%d delta=%f\n", iterations,
+        delta);
+  else
+    fprintf(stderr, "KMedian::cluster: iteration=%d\n", iterations);
+
+  int k = 0;
+
+  for (VVector::const_iterator i = prototypes.begin(); i != prototypes.end(); i++, k++)
+  {
+    fprintf(stderr, "class (%d)\n", k);
+    cerr << "prototype = " << (*i) << endl;
+  }
+}

math/cluster/KMedian.h

@@ -0,0 +1,131 @@
+/** 
+* @file KMedian.h
+ * @brief KMedian (aka K-medoid)
+* @author Alexander Freytag
+* @date 23-04-2013 (dd-mm-yyyy)
+
+*/
+#ifndef KMEDIANINCLUDE
+#define KMEDIANINCLUDE
+
+#include <core/basics/Config.h>
+#include <core/vector/Distance.h>
+#include <core/vector/MatrixT.h>
+#include <core/vector/VectorT.h>
+  
+#include "ClusterAlgorithm.h"
+
+namespace OBJREC {
+
+  /**
+   * @class KMedian
+   * @brief KMedian (aka K-medoid)
+   * @author Alexander Freytag
+   * @date 23-04-2013 (dd-mm-yyyy)
+  */    
+  class KMedian : public ClusterAlgorithm
+  {
+
+      protected:
+        
+      /************************
+       * 
+       *   protected variables
+       * 
+       **************************/ 
+      
+        //! desired number of clusters
+        int noClusters;
+        
+        //! specify which distance to use for calculating assignments
+        std::string distanceType;
+        
+        //! the actual distance metric
+        NICE::VectorDistance<double> *distancefunction;
+        
+        //! maximum difference between prototype-solutions of two iterations for convergence
+        double d_minDelta;
+        
+        //! maximum number of iterations until convergence
+        int i_maxIterations;
+        
+  
+       /************************
+       * 
+       *   protected methods
+       * 
+       **************************/  
+      
+        //! compute the distance between two features using the specified distance metric
+        double vectorDistance(const NICE::Vector &vector1, const NICE::Vector &vector2, uint distancetype);
+        
+        //! compute assignments of all given features wrt to the currently known prototypes (cluster medoids) == ~ E-step
+        double compute_assignments ( const NICE::VVector & features,
+                  const NICE::VVector & prototypes,
+                  std::vector<int> & assignment );
+
+        //! compute number of assignments for every currently found cluster
+        double compute_weights ( const NICE::VVector & features,
+              std::vector<double> & weights,
+              std::vector<int>    & assignment );
+
+        //! compute the difference between prototypes of previous iteration and those currently found
+        double compute_delta ( const NICE::VVector & oldprototypes,
+                    const NICE::VVector & prototypes );
+
+        //! compute (update) prototypes given the current assignments == ~ M-step
+        int compute_prototypes ( const NICE::VVector & features,
+                NICE::VVector & prototypes,
+                std::vector<double> & weights,
+                const std::vector<int>    & assignment );
+
+        //! have an initial guess, i.e., randomly pick some features as initial cluster centroids
+        void initial_guess ( const NICE::VVector & features,
+                NICE::VVector & prototypes );
+        
+        //! give additional information for the current iteration
+        void print_iteration ( int iterations, 
+                  NICE::VVector & prototypes,
+                  double delta );
+
+      public:
+    
+        /**
+        * @brief simple constructor
+        * @param _noClusters the number of clusters to be computed
+        * @param _distanceMode a string specifying the distance function to be used (default: euclidean)
+        */
+        KMedian( const int & _noClusters , const std::string & _distanceMode="euclidean");
+        
+        /**
+        * @brief standard constructor
+        * @param conf config file specifying all relevant variable settings
+        * @param _section name of the section within the configfile where the settings can be found (default: KMedian)
+        */
+        KMedian( const NICE::Config *conf, const std::string & _section = "KMedian");
+
+        
+            
+        /** simple destructor */
+        virtual ~KMedian();
+          
+        /**
+        *@brief this is the actual method that performs the clustering for a given set of features
+        *@author Alexander Freytag
+        *@date 25-04-2013 (dd-mm-yyyy)
+        *@param   features input features to be clustered
+        *@param   prototypes computed prototypes (cluster medoids) for the given samples
+        *@param   weights number of assignments for every cluster
+        *@param   assignment explicite assignments of features to computed cluster medoids
+        */        
+        void cluster ( const NICE::VVector & features,
+                NICE::VVector & prototypes,
+                std::vector<double> & weights,
+                std::vector<int>    & assignment );
+
+  };
+
+
+} // namespace
+
+#endif

math/cluster/RandomClustering.cpp

@@ -0,0 +1,157 @@
+/**
+ * @file RandomClustering.cpp
+* @brief Clustering by randomly picking some samples from the set of features as representatives
+* @author Alexander Freytag
+* @date 03-06-2013 (dd-mm-yyyy)
+ */
+
+#ifdef NICE_USELIB_OPENMP
+#include <omp.h>
+#endif
+
+#include <iostream>
+#include <map>
+
+#include "vislearning/math/distances/genericDistance.h"
+
+#include "vislearning/math/cluster/RandomClustering.h"
+
+#include <set>
+
+using namespace OBJREC;
+
+using namespace std;
+
+using namespace NICE;
+
+
+
+RandomClustering::RandomClustering(const int & _noClusters, const std::string & _distanceType) :
+  noClusters(_noClusters), distanceType(_distanceType)
+{
+}
+
+RandomClustering::RandomClustering( const NICE::Config *conf, const std::string & _section)
+{  
+  this->noClusters = conf->gI( _section, "noClusters", 20);
+  
+  this->distanceType = conf->gS( _section, "distanceType", "euclidean" );
+  this->distancefunction = GenericDistanceSelection::selectDistance(distanceType);  
+}
+
+RandomClustering::~RandomClustering()
+{
+}
+
+int RandomClustering::compute_prototypes(const NICE::VVector & _features, NICE::VVector & _prototypes,
+    std::vector<double> & _weights, const std::vector<int> & _assignment)
+{
+  
+  int noFeatures ( _features.size() );
+  
+  std::set<int, std::greater<int> > chosenIdx;
+  
+  //empty init
+  chosenIdx.clear();
+  
+  //pick k distinct cluster representatives randomly
+  for (int cnt = 0; cnt < this->noClusters; cnt++)
+  {
+    int idx;
+    do
+    {
+      idx = rand() % noFeatures;
+    }
+    while ( chosenIdx.find ( idx ) != chosenIdx.end() );
+                             
+    //if a new (distinct) idx was computed, insert it into the set of randomly picked indicees
+    chosenIdx.insert ( idx );
+  }
+  
+  _prototypes.resize( this->noClusters ); 
+  
+  int clusterCnt ( 0 );
+  for ( std::set<int>::const_iterator idxIt = chosenIdx.begin(); idxIt != chosenIdx.end(); idxIt++, clusterCnt++ )
+  {
+     _prototypes[clusterCnt] = _features[ *idxIt ];
+  }
+
+  return 0;
+}
+
+double RandomClustering::compute_assignments(const NICE::VVector & _features,
+                                    const NICE::VVector & _prototypes,
+                                    std::vector<int> & _assignment)
+{
+  _assignment.resize( _features.size() );
+  
+  int index = 0;
+  for (NICE::VVector::const_iterator i = _features.begin(); i != _features.end(); i++, index++)
+  {
+
+    const NICE::Vector & x = *i;
+    double mindist = std::numeric_limits<double>::max();
+    int minclass = 0;
+
+    int c = 0;
+           
+    for (NICE::VVector::const_iterator j = _prototypes.begin(); j
+        != _prototypes.end(); j++, c++)
+    {
+
+      const NICE::Vector & p = *j;
+      double distance = this->distancefunction->calculate(p, x);
+      
+      if (distance < mindist)
+      {
+        minclass = c;
+        mindist = distance;
+      }
+    }
+
+    _assignment[index] = minclass;
+  }
+
+  return 0.0;
+}
+
+double RandomClustering::compute_weights(const NICE::VVector & _features,
+                                std::vector<double> & _weights,
+                                std::vector<int> & _assignment)
+{
+  _weights.resize( this->noClusters );
+  
+  //initalization
+  for (int k = 0; k < noClusters; k++)
+    _weights[k] = 0;
+
+  int j = 0;
+
+  //increase weight for every assignment
+  for (NICE::VVector::const_iterator i = _features.begin(); i != _features.end(); i++, j++)
+  {
+    int k = _assignment[j];
+    _weights[k]++;
+  }
+
+  //normalize weights
+  for (int k = 0; k < noClusters; k++)
+    _weights[k] = _weights[k] / _features.size();
+
+  return 0.0;
+}
+
+void RandomClustering::cluster(const NICE::VVector & _features,
+                      NICE::VVector & _prototypes,
+                      std::vector<double> & _weights,
+                      std::vector<int> & _assignment)
+{
+  //randomly pick cluster centers
+  this->compute_prototypes( _features, _prototypes, _weights, _assignment );
+  
+  //compute assignments for every cluster
+  this->compute_assignments( _features, _prototypes, _assignment );
+  
+  //compute corresponding weights
+  this->compute_weights( _features, _weights, _assignment );
+}

math/cluster/RandomClustering.h

@@ -0,0 +1,112 @@
+/** 
+* @file RandomClustering.h
+* @brief Clustering by randomly picking some samples from the set of features as representatives
+* @author Alexander Freytag
+* @date 03-06-2013 (dd-mm-yyyy)
+*/
+#ifndef RANDOMCLUSTERERNINCLUDE
+#define RANDOMCLUSTERERNINCLUDE
+
+#include <core/basics/Config.h>
+#include <core/vector/Distance.h>
+#include <core/vector/MatrixT.h>
+#include <core/vector/VectorT.h>
+  
+#include "ClusterAlgorithm.h"
+
+namespace OBJREC {
+
+  /**
+   * @class RandomClustering
+   * @brief Clustering by randomly picking some samples from the set of features as representatives
+   * @author Alexander Freytag
+   * @date 03-06-2013 (dd-mm-yyyy)
+  */    
+  class RandomClustering : public ClusterAlgorithm
+  {
+
+      protected:
+        
+      /************************
+       * 
+       *   protected variables
+       * 
+       **************************/ 
+      
+        //! desired number of clusters
+        int noClusters;
+        
+        //! specify which distance to use for calculating assignments
+        std::string distanceType;
+        
+        //! the actual distance metric
+        NICE::VectorDistance<double> *distancefunction;        
+        
+  
+       /************************
+       * 
+       *   protected methods
+       * 
+       **************************/  
+      
+        
+        //! compute assignments of all given features wrt to the currently known prototypes (cluster medoids) == ~ E-step
+        double compute_assignments ( const NICE::VVector & features,
+                  const NICE::VVector & prototypes,
+                  std::vector<int> & assignment );
+
+        //! compute number of assignments for every currently found cluster
+        double compute_weights ( const NICE::VVector & features,
+              std::vector<double> & weights,
+              std::vector<int>    & assignment );
+
+
+        //! compute (update) prototypes given the current assignments == ~ M-step
+        int compute_prototypes ( const NICE::VVector & features,
+                NICE::VVector & prototypes,
+                std::vector<double> & weights,
+                const std::vector<int>    & assignment );
+
+      public:
+    
+        /**
+        * @brief simple constructor
+        * @param[in] _noClasses the number of clusters to be computed
+        * @param[in] _distanceMode a string specifying the distance function to be used (default: euclidean)* 
+        * @date 03-06-2013 (dd-mm-yyyy)
+        */
+        RandomClustering( const int & _noClasses , const std::string & _distanceMode="euclidean" );
+        
+        /**
+        * @brief standard constructor
+        * @param[in] conf config file specifying all relevant variable settings
+        * @param[in] _section name of the section within the configfile where the settings can be found (default: RandomClustering)
+        * @date 03-06-2013 (dd-mm-yyyy)
+        */
+        RandomClustering( const NICE::Config *conf, const std::string & _section = "RandomClustering");
+
+        
+            
+        /** simple destructor */
+        virtual ~RandomClustering();
+          
+        /**
+        * @brief this is the actual method that performs the clustering for a given set of features
+        * @author Alexander Freytag
+        * @date 03-06-2013 (dd-mm-yyyy)
+        * @param   features input features to be clustered
+        * @param   prototypes computed prototypes (randomly chosen) for the given samples
+        * @param   weights number of assignments for every cluster
+        * @param   assignment explicite assignments of features to computed cluster medoids
+        */        
+        void cluster ( const NICE::VVector & features,
+                NICE::VVector & prototypes,
+                std::vector<double> & weights,
+                std::vector<int>    & assignment );
+
+  };
+
+
+} // namespace
+
+#endif

math/cluster/SpectralCluster.cpp

@@ -18,18 +18,24 @@ using namespace OBJREC;
 using namespace std;
 using namespace NICE;
 
-SpectralCluster::SpectralCluster ( int _noClasses, double alpha ) : noClasses(_noClasses), kmeans(_noClasses)
+SpectralCluster::SpectralCluster ( int _noClusters, double alpha ) : noClusters(_noClusters), kmeans(_noClusters)
 {
     this->alpha = alpha;
 }
 
+SpectralCluster::SpectralCluster( const NICE::Config *conf, const std::string & _section) : kmeans(conf)
+{  
+  this->noClusters = conf->gI( _section, "noClusters", 20);
+  this->alpha = conf->gD( _section, "alpha", 1.0);
+}
+
 SpectralCluster::~SpectralCluster()
 {
 }
 
 void SpectralCluster::getSimilarityMatrix ( const VVector & features, 
-					    NICE::Matrix & laplacian,
-					    double alpha )
+                                            NICE::Matrix & laplacian,
+                                            double alpha )
 {
     NICE::Matrix distances ( laplacian );
     double mindist = numeric_limits<double>::max();
@@ -41,48 +47,53 @@ void SpectralCluster::getSimilarityMatrix ( const VVector & features,
 
     for ( int i = 0 ; i < (int)features.size() ; i++ )
     {
-	const NICE::Vector & xi = features[i];
-	for ( int j = i ; j < (int)features.size() ; j++ )
-	{
-	    const NICE::Vector & xj = features[j];
-	    // double sim = xi * xj;
-	    double dist = distance.calculate ( xi, xj );
-	    distances(i, j) = dist;
-
-	    if ( dist < mindist )
-		mindist = dist;
-	    if ( dist > maxdist )
-		maxdist = dist;
-
-	    count++;
-	    mean += dist;
-	}
+      const NICE::Vector & xi = features[i];
+      for ( int j = i ; j < (int)features.size() ; j++ )
+      {
+          const NICE::Vector & xj = features[j];
+          // double sim = xi * xj;
+          double dist = distance.calculate ( xi, xj );
+          distances(i, j) = dist;
+
+          if ( dist < mindist )
+        mindist = dist;
+          if ( dist > maxdist )
+        maxdist = dist;
+
+          count++;
+          mean += dist;
+      }
     }
     mean /= count;
 
     for ( int i = 0 ; i < (int)features.size() ; i++ )
-	for ( int j = i ; j < (int)features.size() ; j++ )
-	{
-	    double d = ( mean - distances(i, j) );
-	    stddev += d*d;
-	}
+    {
+      for ( int j = i ; j < (int)features.size() ; j++ )
+      {
+          double d = ( mean - distances(i, j) );
+          stddev += d*d;
+      }
+    }
 
     stddev /= count;
 
     double norm = alpha / (2.0 * stddev);
 
     for ( int i = 0 ; i < (int)features.size() ; i++ )
-	for ( int j = i ; j < (int)features.size() ; j++ )
-	{
-	    double sim = exp(-distances(i, j) * norm );
-	    
-	    laplacian(i, j) = - sim;
-	    laplacian(j, i) = - sim;
-	}
+    {
+      for ( int j = i ; j < (int)features.size() ; j++ )
+      {
+          double sim = exp(-distances(i, j) * norm );
+          
+          laplacian(i, j) = - sim;
+          laplacian(j, i) = - sim;
+      }
+    }
 }
 
-void SpectralCluster::computeLaplacian ( const VVector & features,
-					 NICE::Matrix & laplacian, int method, double alpha )
+void SpectralCluster::computeLaplacian ( const NICE::VVector & features,
+                                         NICE::Matrix & laplacian,
+                                         int method, double alpha )
 {
     laplacian.set(0.0);
     getSimilarityMatrix(features, laplacian, alpha);
@@ -91,8 +102,10 @@ void SpectralCluster::computeLaplacian ( const VVector & features,
     d.set(0.0);
     for ( int i = 0 ; i < (int)laplacian.rows(); i++ )
     {
-		for ( int j = 0 ; j < (int)laplacian.cols(); j++ )
-	    	d[i] -=laplacian(i, j);
+      for ( int j = 0 ; j < (int)laplacian.cols(); j++ )
+      {
+          d[i] -=laplacian(i, j);
+      }
     }
 
     // Now we got the negative weight matrix laplacian : -W
@@ -102,31 +115,40 @@ void SpectralCluster::computeLaplacian ( const VVector & features,
     // D^-1 * L
     if ( method == L_RW_NORMALIZED ) 
     {
-	// L = D^-1 L_unnormalized = I - D^-1*W
-		for ( int i = 0 ; i < (int)laplacian.rows() ; i++ )
-			for ( int j = 0 ; j < (int)laplacian.cols() ; j++ )
-				laplacian(i, j) *= (1.0/d[i]);
-
-		for ( int i = 0 ; i < (int)laplacian.rows() ; i++ )
-	    	laplacian(i, i) += 1.0;
-
-    } else if ( method == L_UNNORMALIZED ) {
-	// unnormalized version
-	// L = D - W
-		for ( int i = 0 ; i < (int)laplacian.rows() ; i++ )
-	    	laplacian(i, i) += d[i];
+    // L = D^-1 L_unnormalized = I - D^-1*W
+      for ( int i = 0 ; i < (int)laplacian.rows() ; i++ )
+      {
+        for ( int j = 0 ; j < (int)laplacian.cols() ; j++ )
+        {
+          laplacian(i, j) *= (1.0/d[i]);
+        }
+      }
+
+      for ( int i = 0 ; i < (int)laplacian.rows() ; i++ )
+      {
+          laplacian(i, i) += 1.0;
+      }
+
+    }
+    else if ( method == L_UNNORMALIZED )
+    {
+    // unnormalized version
+    // L = D - W
+      for ( int i = 0 ; i < (int)laplacian.rows() ; i++ )
+      {
+          laplacian(i, i) += d[i];
+      }
     }
 }
 
-void SpectralCluster::cluster ( const VVector & features,
-				VVector & prototypes,
-				std::vector<double> & weights,
-				std::vector<int>    & assignment )
+void SpectralCluster::cluster ( const NICE::VVector & features,
+                                NICE::VVector & prototypes,
+                                std::vector<double> & weights,
+                                std::vector<int>    & assignment )
 {
-
     if ( features.size() <= 0 ) {
-	fprintf (stderr, "FATAL ERROR: not enough features vectors provided\n");
-	exit(-1);
+      fprintf (stderr, "FATAL ERROR: not enough features vectors provided\n");
+      exit(-1);
     }
 
     const NICE::Vector & x = features[0];
@@ -141,67 +163,70 @@ void SpectralCluster::cluster ( const VVector & features,
     NICE::Vector eigvals;
     try {
       NICE::eigenvectorvalues ( laplacian, eigvect, eigvals );
-    } catch (...) {
-      cerr << "You should adjust the alpha parameter, or the features are somehow weird" << endl;
-      cerr << "Laplacian = " << laplacian(0, 0, min((int)laplacian.rows()-1, 5), min((int)laplacian.cols()-1, 5)) << endl;
+    }
+    catch (...)
+    {
+      std::cerr << "You should adjust the alpha parameter, or the features are somehow weird" << std::endl;
+      std::cerr << "Laplacian = " << laplacian(0, 0, min((int)laplacian.rows()-1, 5), min((int)laplacian.cols()-1, 5)) << std::endl;
       throw Exception ("Laplacian matrix is singular or not well-conditioned!");
     }
 
     std::map<double, int> eigvals_sorted;
-	for ( int i = 0 ; i < (int)eigvals.size(); i++ ) 
+    for ( int i = 0 ; i < (int)eigvals.size(); i++ ) 
     {
-	eigvals_sorted.insert ( make_pair( eigvals[i], i ) );
+      eigvals_sorted.insert ( make_pair( eigvals[i], i ) );
     }
 
-    VVector spectral_features;
+    NICE::VVector spectral_features;
 
-	for ( int i = 0 ; i < (int)eigvect.rows() ; i++ )
+    for ( int i = 0 ; i < (int)eigvect.rows() ; i++ )
     {
-	NICE::Vector eigvec_k ( noClasses );
-	map<double, int>::const_iterator k = eigvals_sorted.begin();
-	for ( int j = 0 ; j < noClasses ; j++ )
-	{
-	    int eigval_index = k->second;
-	    eigvec_k[j] = eigvect(i, eigval_index ) ;
-	    k++;
-	}
-
-	spectral_features.push_back ( eigvec_k );
+      NICE::Vector eigvec_k ( noClusters );
+      map<double, int>::const_iterator k = eigvals_sorted.begin();
+      for ( int j = 0 ; j < noClusters ; j++ )
+      {
+        int eigval_index = k->second;
+        eigvec_k[j] = eigvect(i, eigval_index ) ;
+        k++;
+      }
+
+      spectral_features.push_back ( eigvec_k );
     }
 
-    kmeans.cluster ( spectral_features, prototypes, weights, assignment ); 
+    this->kmeans.cluster ( spectral_features, prototypes, weights, assignment ); 
 
     // recompute prototypes
 
-    for ( int k = 0 ; k < noClasses ; k++ )
+    for ( int k = 0 ; k < noClusters ; k++ )
     {
-	prototypes[k].resize( dimension );
-	prototypes[k].set(0);
-	weights[k] = 0;
+      prototypes[k].resize( dimension );
+      prototypes[k].set(0);
+      weights[k] = 0;
     }
 
     int j = 0;
     for ( VVector::const_iterator i  = features.begin();
-                                              i != features.end();
-	                                      i++, j++ )
+                                  i != features.end();
+                                  i++, j++ )
     {
-	int k = assignment[j];
-	
-	NICE::Vector & p = prototypes[k];
-	const NICE::Vector & x = *i;
-	p += x;
-	weights[k]++;
+      int k = assignment[j];
+      
+      NICE::Vector & p = prototypes[k];
+      const NICE::Vector & x = *i;
+      p += x;
+      weights[k]++;
     }
 
-    for ( int k = 0 ; k < noClasses ; k++ )
+    for ( int k = 0 ; k < noClusters ; k++ )
     {
-	NICE::Vector & p = prototypes[k];
-	if ( weights[k] <= 0 ) {
-	    fprintf (stderr, "FATAL ERROR: spectral clustering produced empty cluster !\n");
-	    exit(-1);
-	}
-	p *= ( 1.0 / weights[k] );
-	weights[k] = weights[k] / features.size();
+      NICE::Vector & p = prototypes[k];
+      if ( weights[k] <= 0 )
+      {
+          fprintf (stderr, "FATAL ERROR: spectral clustering produced empty cluster !\n");
+          exit(-1);
+      }
+      p *= ( 1.0 / weights[k] );
+      weights[k] = weights[k] / features.size();
     }
 }
 

math/cluster/SpectralCluster.h

@@ -8,8 +8,8 @@
 #ifndef SPECTRALCLUSTERINCLUDE
 #define SPECTRALCLUSTERINCLUDE
 
-#include "core/vector/VectorT.h"
-#include "core/vector/MatrixT.h"
+#include <core/vector/VectorT.h>
+#include <core/vector/MatrixT.h>
 
 #include "ClusterAlgorithm.h"
 #include "KMeans.h"
@@ -17,42 +17,51 @@
 
 namespace OBJREC {
 
-/** spectral clustering by kmeans-clustering of eigenvectors */
-class SpectralCluster : public ClusterAlgorithm
-{
-
-    protected:
-	int noClasses;
-	double alpha;
-
-	KMeans kmeans;
-
-	enum {
-	    L_UNNORMALIZED  = 0,
-	    L_RW_NORMALIZED 
-	};
-
-	virtual void computeLaplacian ( const NICE::VVector & features,
-					 NICE::Matrix & laplacian,
-					 int method, double alpha );
-
-
-	virtual void getSimilarityMatrix ( const NICE::VVector & features, 
-					    NICE::Matrix & laplacian, double alpha );
-    public:
-  
-	/** simple constructor */
-	SpectralCluster (int _noClasses, double alpha);
-      
-	/** simple destructor */
-	virtual ~SpectralCluster();
-     
-	void cluster ( const NICE::VVector & features,
-		       NICE::VVector & prototypes,
-		       std::vector<double> & weights,
-		       std::vector<int>    & assignment );
-
-};
+  /** spectral clustering by kmeans-clustering of eigenvectors */
+  class SpectralCluster : public ClusterAlgorithm
+  {
+
+      protected:
+        int noClusters;
+        double alpha;
+
+        KMeans kmeans;
+
+        enum {
+            L_UNNORMALIZED  = 0,
+            L_RW_NORMALIZED 
+        };
+
+        virtual void computeLaplacian ( const NICE::VVector & features,
+                NICE::Matrix & laplacian,
+                int method, double alpha );
+
+
+        virtual void getSimilarityMatrix ( const NICE::VVector & features, 
+                    NICE::Matrix & laplacian, double alpha );
+      public:
+    
+        /** simple constructor */
+        SpectralCluster (int _noClusters, double alpha);
+        
+        /**
+        * @brief standard constructor
+        * @param conf config file specifying all relevant variable settings
+        * @param _section name of the section within the configfile where the settings can be found (default: SpectralCluster)
+        * @date 14-06-2013 (dd-mm-yyyy)
+        * @author Alexander Freytag
+        */
+        SpectralCluster( const NICE::Config *conf, const std::string & _section = "SpectralCluster");     
+            
+        /** simple destructor */
+        virtual ~SpectralCluster();
+          
+        void cluster ( const NICE::VVector & features,
+                NICE::VVector & prototypes,
+                std::vector<double> & weights,
+                std::vector<int>    & assignment );
+
+  };
 
 
 } // namespace

math/cluster/tests/Makefile.inc

@@ -0,0 +1,89 @@
+# BINARY-DIRECTORY-MAKEFILE
+# conventions:
+# - there are no subdirectories, they are ignored!
+# - all ".C", ".cpp" and ".c" files in the current directory are considered
+#   independent binaries, and linked as such.
+# - the binaries depend on the library of the parent directory
+# - the binary names are created with $(BINNAME), i.e. it will be more or less
+#   the name of the .o file
+# - all binaries will be added to the default build list ALL_BINARIES
+
+# --------------------------------
+# - remember the last subdirectory
+#
+# set the variable $(SUBDIR) correctly to the current subdirectory. this
+# variable can be used throughout the current makefile.inc. The many 
+# SUBDIR_before, _add, and everything are only required so that we can recover
+# the previous content of SUBDIR before exitting the makefile.inc
+
+SUBDIR_add:=$(dir $(word $(words $(MAKEFILE_LIST)),$(MAKEFILE_LIST)))
+SUBDIR_before:=$(SUBDIR)
+SUBDIR:=$(strip $(SUBDIR_add))
+SUBDIR_before_$(SUBDIR):=$(SUBDIR_before)
+
+# ------------------------
+# - include subdirectories
+#
+# note the variables $(SUBDIRS_OF_$(SUBDIR)) are required later on to recover
+# the dependencies automatically. if you handle dependencies on your own, you
+# can also dump the $(SUBDIRS_OF_$(SUBDIR)) variable, and include the
+# makefile.inc of the subdirectories on your own...
+
+#SUBDIRS_OF_$(SUBDIR):=$(patsubst %/Makefile.inc,%,$(wildcard $(SUBDIR)*/Makefile.inc))
+#include $(SUBDIRS_OF_$(SUBDIR):%=%/Makefile.inc)
+
+# ----------------------------
+# - include local dependencies
+#
+# include the libdepend.inc file, which gives additional dependencies for the
+# libraries and binaries. additionally, an automatic dependency from the library
+# of the parent directory is added (commented out in the code below).
+
+-include $(SUBDIR)libdepend.inc
+
+PARENTDIR:=$(patsubst %/,%,$(dir $(patsubst %/,%,$(SUBDIR))))
+$(call PKG_DEPEND_INT,$(PARENTDIR))
+$(call PKG_DEPEND_EXT,CPPUNIT)
+
+# ---------------------------
+# - objects in this directory
+#
+# the use of the variable $(OBJS) is not mandatory. it is mandatory however
+# to update $(ALL_OBJS) in a way that it contains the path and name of
+# all objects. otherwise we can not include the appropriate .d files.
+
+OBJS:=$(patsubst %.cpp,$(OBJDIR)%.o,$(notdir $(wildcard $(SUBDIR)*.cpp))) \
+      $(patsubst %.C,$(OBJDIR)%.o,$(notdir $(wildcard $(SUBDIR)*.C))) \
+      $(shell grep -ls Q_OBJECT $(SUBDIR)*.h | sed -e's@^@/@;s@.*/@$(OBJDIR)moc_@;s@\.h$$@.o@') \
+      $(patsubst %.c,$(OBJDIR)%.o,$(notdir $(wildcard $(SUBDIR)*.c)))
+ALL_OBJS += $(OBJS)
+
+# ----------------------------
+# - binaries in this directory
+#
+# output of binaries in this directory. none of the variables has to be used.
+# but everything you add to $(ALL_LIBRARIES) and $(ALL_BINARIES) will be
+# compiled with `make all`. be sure again to add the files with full path.
+
+CHECKS:=$(BINDIR)$(call LIBNAME,$(SUBDIR))
+ALL_CHECKS+=$(CHECKS)
+
+# ---------------------
+# - binary dependencies
+#
+# there is no way of determining the binary dependencies automatically, so we
+# follow conventions. each binary depends on the corresponding .o file and
+# on the libraries specified by the INTLIBS/EXTLIBS. these dependencies can be
+# specified manually or they are automatically stored in a .bd file.
+
+$(foreach head,$(wildcard $(SUBDIR)*.h),$(eval $(shell grep -q Q_OBJECT $(head) && echo $(head) | sed -e's@^@/@;s@.*/\(.*\)\.h$$@$(BINDIR)\1:$(OBJDIR)moc_\1.o@')))
+$(eval $(foreach c,$(CHECKS),$(c):$(BUILDDIR)$(CPPUNIT_MAIN_OBJ) $(OBJS) $(call PRINT_INTLIB_DEPS,$(c),.a)))
+
+# -------------------
+# - subdir management
+#
+# as the last step, always add this line to correctly recover the subdirectory
+# of the makefile including this one!
+
+SUBDIR:=$(SUBDIR_before_$(SUBDIR))
+

math/cluster/tests/TestKMedian.cpp

@@ -0,0 +1,89 @@
+#ifdef NICE_USELIB_CPPUNIT
+
+#include <string>
+#include <exception>
+
+#include "TestKMedian.h"
+
+#include <core/basics/Config.h>
+#include "vislearning/math/distances/genericDistance.h"
+
+
+const bool verboseStartEnd = true;
+const bool verbose = false;
+const std::string distanceType = "euclidean";
+
+using namespace OBJREC;
+using namespace NICE;
+using namespace std;
+
+CPPUNIT_TEST_SUITE_REGISTRATION( TestKMedian );
+
+void TestKMedian::setUp() {
+}
+
+void TestKMedian::tearDown() {
+}
+
+void TestKMedian::testKMedianClustering() 
+{
+  if (verboseStartEnd)
+    std::cerr << "================== TestKMedian::testKMedianClustering ===================== " << std::endl;
+  
+  Config * conf = new Config;
+  std::string section ( "KMedian" );
+  conf->sS( section, "distanceType", "euclidean" );
+  conf->sI( section, "maxIterations", 200 );
+  conf->sI( section, "noClusters", 2 );
+   
+  OBJREC::KMedian kMedian ( conf, section );
+  
+  //create some artificial data
+  NICE::VVector features;
+  NICE::Vector x1 (2); x1[0] = 1;  x1[1] = 1; features.push_back(x1);
+  NICE::Vector x2 (2); x2[0] = 4;  x2[1] = 1; features.push_back(x2);
+  NICE::Vector x3 (2); x3[0] = 2;  x3[1] = 4; features.push_back(x3);
+  NICE::Vector x4 (2); x4[0] = 10; x4[1] = 3; features.push_back(x4);
+  NICE::Vector x5 (2); x5[0] = 8;  x5[1] = 3; features.push_back(x5);
+  NICE::Vector x6 (2); x6[0] = 4;  x6[1] = 3; features.push_back(x6);
+  NICE::Vector x7 (2); x7[0] = 3;  x7[1] = 2; features.push_back(x7);
+  NICE::Vector x8 (2); x8[0] = 1;  x8[1] = 3; features.push_back(x8);
+  NICE::Vector x9 (2); x9[0] = 9;  x9[1] = 2; features.push_back(x9);
+  
+  //cluster data
+  NICE::VVector prototypes;
+  std::vector<double> weights;
+  std::vector<int> assignment;
+  
+  kMedian.cluster ( features, prototypes, weights, assignment );  
+
+  //check whether the results fits the ground truth  
+  //NOTE
+  // If no random initialization is activated, we initially grab x2 and x8.
+  // After 3 iterations, we should have converged and obtain x5 and x7.
+
+  NICE::VectorDistance<double> * distancefunction = GenericDistanceSelection::selectDistance(distanceType);
+
+  if ( verbose )
+  {
+    std::cerr << " x9: " << x9 << " cl1: " << prototypes[0] << std::endl;
+    std::cerr << " x7: " << x7 << " cl2: " << prototypes[1] << std::endl;
+  }
+  
+  double distX9Cl1 ( distancefunction->calculate( x9, prototypes[0] ) );
+  double distX7Cl2 ( distancefunction->calculate( x7, prototypes[1] ) );
+  
+  CPPUNIT_ASSERT_DOUBLES_EQUAL( distX9Cl1, 0.0, 1e-8);
+  CPPUNIT_ASSERT_DOUBLES_EQUAL( distX7Cl2, 0.0, 1e-8); 
+  
+  std::cerr << "                               successfull              " << std::endl;
+        
+  //don't waste memory
+  delete conf;
+  
+  if (verboseStartEnd)
+    std::cerr << "================== TestKMedian::testKMedianClustering done ===================== " << std::endl;
+}
+
+
+#endif

math/cluster/tests/TestKMedian.h

@@ -0,0 +1,32 @@
+#ifndef _TESTKMEDIAN_H
+#define _TESTKMEDIAN_H
+
+#include <cppunit/extensions/HelperMacros.h>
+#include "vislearning/math/cluster/KMedian.h"
+
+/**
+ * CppUnit-Testcase. 
+ * @brief CppUnit-Testcase to verify that the KMedian-clusterin works correctly
+ */
+class TestKMedian : public CppUnit::TestFixture {
+
+    CPPUNIT_TEST_SUITE( TestKMedian );
+    
+    CPPUNIT_TEST(testKMedianClustering);
+    
+    CPPUNIT_TEST_SUITE_END();
+  
+ private:
+ 
+ public:
+    void setUp();
+    void tearDown();
+
+    /**
+    * Constructor / Destructor testing 
+    */  
+    void testKMedianClustering();
+
+};
+
+#endif // _TESTKMEDIAN_H

math/kernels/KernelEXPHIK.cpp

@@ -0,0 +1,81 @@
+/** 
+* @file KernelEXPHIK.cpp
+* @brief Interface for the generalized rbf kernel with HIK metric
+* @author Paul Bodesheim
+* @date 02/07/2013
+
+*/
+
+#include <iostream>
+
+#include <math.h>
+#include "KernelEXPHIK.h"
+
+using namespace OBJREC;
+
+using namespace std;
+using namespace NICE;
+
+KernelEXPHIK::KernelEXPHIK ( double _gamma, double _alpha, double _beta ) : KernelHIK(_alpha, _beta)
+{
+        gamma = _gamma;
+}
+
+KernelEXPHIK::KernelEXPHIK ( const KernelEXPHIK & src ) : KernelHIK(src.alpha, src.beta)
+{
+        gamma = src.gamma;
+}
+
+KernelEXPHIK::KernelEXPHIK ( const KernelHIK & src, double _gamma ) : KernelHIK(src)
+{
+        gamma = _gamma;
+}
+
+KernelEXPHIK::~KernelEXPHIK()
+{
+}
+
+KernelEXPHIK *KernelEXPHIK::clone(void) const
+{
+	return new KernelEXPHIK ( *this );
+}
+
+	
+double KernelEXPHIK::K (const NICE::Vector & x, const NICE::Vector & y) const
+{
+	if ( x.size() != y.size() ) {
+		cerr << "KernelEXPHIK: dimensions: " << x.size() << " vs " << y.size() << endl;
+		fthrow(Exception, "Vector dimensions do not match!");
+	}
+
+	double dist = KernelHIK::K(x,x) + KernelHIK::K(y,y) - 2.0*KernelHIK::K(x,y);
+
+        return exp(-gamma*dist);
+}
+
+void KernelEXPHIK::updateKernelData ( KernelData *kernelData ) const
+{
+        NICE::Matrix & kernelMatrix = kernelData->getKernelMatrix();
+        fthrow(Exception, "Not yet implemented!");
+
+}
+
+void KernelEXPHIK::getKernelJacobi ( size_t parameter, const NICE::Vector & parameters, const KernelData *kernelData, NICE::Matrix & jacobiMatrix ) const
+{
+	fthrow(Exception, "Not yet implemented!");
+}
+
+void KernelEXPHIK::setParameters( const NICE::Vector & newParameters ) 
+{
+        alpha = newParameters[0];
+        beta = newParameters[1];
+        gamma = newParameters[2];
+}
+
+void KernelEXPHIK::getParameters( NICE::Vector & newParameters ) const
+{
+	newParameters.resize(3);
+        newParameters[0] = alpha;
+        newParameters[1] = beta;
+        newParameters[2] = gamma;
+}

math/kernels/KernelEXPHIK.h

@@ -0,0 +1,60 @@
+/** 
+* @file KernelEXPHIK.h
+* @brief Interface for the generalized rbf kernel with HIK metric
+* @author Paul Bodesheim
+* @date 02/07/2013
+
+*/
+#ifndef KERNELEXPHIKINCLUDE
+#define KERNELEXPHIKINCLUDE
+
+#include "Kernel.h"
+#include "KernelHIK.h"
+#include "ParameterizedKernel.h"
+
+namespace OBJREC {
+
+/** Interface for the generalized rbf kernel with HIK metric */
+class KernelEXPHIK : public KernelHIK
+{
+
+    protected:
+
+	double gamma;
+
+    public:
+  
+	/** simple constructor with HIK parameters*/
+        KernelEXPHIK ( double gamma = 1.0, double alpha = 1.0, double beta = 1.0 );
+        
+	/** copy constructor */
+	KernelEXPHIK ( const KernelEXPHIK & src );
+        
+        /** constructor with HIK kernel*/
+        KernelEXPHIK ( const KernelHIK & src, double gamma = 1.0 );
+        
+	/** simple destructor */
+	virtual ~KernelEXPHIK();
+
+	/** clone this object */
+	KernelEXPHIK *clone(void) const;
+     
+	/** compute the kernel value */
+	double K (const NICE::Vector & x, const NICE::Vector & y) const;
+
+	size_t getParameterSize () const { return 3; }; 
+        
+        void updateKernelData ( KernelData *kernelData ) const;
+
+	void getKernelJacobi ( size_t parameter, const NICE::Vector & parameters, const KernelData *kernelData, NICE::Matrix & jacobiMatrix ) const;
+
+	void setParameters( const NICE::Vector & newParameters );
+	
+	void getParameters( NICE::Vector & newParameters ) const;
+
+};
+
+
+} // namespace
+
+#endif

math/kernels/KernelHIK.cpp

@@ -0,0 +1,82 @@
+/** 
+* @file KernelHIK.cpp
+* @brief Interface for the (parameterized) histogram intersection kernel (HIK)
+* @author Paul Bodesheim
+* @date 02/07/2013
+
+*/
+
+#include <iostream>
+
+#include <math.h>
+#include "KernelHIK.h"
+
+using namespace OBJREC;
+
+using namespace std;
+using namespace NICE;
+
+
+
+KernelHIK::KernelHIK( double _alpha, double _beta )
+{
+    alpha = _alpha;
+    beta = _beta;
+}
+
+KernelHIK::KernelHIK ( const KernelHIK & src )
+{
+	alpha = src.alpha;
+	beta = src.beta;
+}
+
+KernelHIK::~KernelHIK()
+{
+}
+
+KernelHIK *KernelHIK::clone(void) const
+{
+	return new KernelHIK ( *this );
+}
+
+	
+double KernelHIK::K (const NICE::Vector & x, const NICE::Vector & y) const
+{
+	if ( x.size() != y.size() ) {
+		cerr << "KernelHIK: dimensions: " << x.size() << " vs " << y.size() << endl;
+		fthrow(Exception, "Vector dimensions do not match!");
+	}
+
+	double sim = 0.0;
+	for ( size_t i = 0 ; i < x.size() ; i++ )
+	{
+                double d = alpha*pow(min(x[i], y[i]), beta);
+		sim += d;
+	}
+        return sim;
+}
+
+void KernelHIK::updateKernelData ( KernelData *kernelData ) const
+{
+        NICE::Matrix & kernelMatrix = kernelData->getKernelMatrix();
+        fthrow(Exception, "Not yet implemented!");
+
+}
+
+void KernelHIK::getKernelJacobi ( size_t parameter, const NICE::Vector & parameters, const KernelData *kernelData, NICE::Matrix & jacobiMatrix ) const
+{
+	fthrow(Exception, "Not yet implemented!");
+}
+
+void KernelHIK::setParameters( const NICE::Vector & newParameters ) 
+{
+	alpha = newParameters[0];
+        beta = newParameters[1];
+}
+
+void KernelHIK::getParameters( NICE::Vector & newParameters ) const
+{
+	newParameters.resize(2);
+	newParameters[0] = alpha;
+        newParameters[1] = beta;
+}

math/kernels/KernelHIK.h

@@ -0,0 +1,57 @@
+/** 
+* @file KernelHIK.h
+* @brief Interface for the (generalized) histogram intersection kernel (HIK)
+* @author Paul Bodesheim
+* @date 02/07/2013
+
+*/
+#ifndef KERNELHIKINCLUDE
+#define KERNELHIKINCLUDE
+
+#include "Kernel.h"
+#include "ParameterizedKernel.h"
+
+namespace OBJREC {
+
+/** Interface for the popular exponential mercer kernel / rbf kernel */
+class KernelHIK : public ParameterizedKernel
+{
+
+    protected:
+
+	double alpha;
+	double beta;
+
+    public:
+  
+	/** simple constructor */
+	KernelHIK( double alpha = 1.0, double beta = 1.0 );
+
+	/** copy constructor */
+	KernelHIK ( const KernelHIK & src );
+      
+	/** simple destructor */
+	virtual ~KernelHIK();
+
+	/** clone this object */
+	KernelHIK *clone(void) const;
+     
+	/** compute the kernel value */
+	double K (const NICE::Vector & x, const NICE::Vector & y) const;
+
+	size_t getParameterSize () const { return 2; }; 
+        
+        void updateKernelData ( KernelData *kernelData ) const;
+
+	void getKernelJacobi ( size_t parameter, const NICE::Vector & parameters, const KernelData *kernelData, NICE::Matrix & jacobiMatrix ) const;
+
+	void setParameters( const NICE::Vector & newParameters );
+	
+	void getParameters( NICE::Vector & newParameters ) const;
+
+};
+
+
+} // namespace
+
+#endif

math/kernels/genericKernel.h

@@ -4,6 +4,8 @@
 #include <vector>
 #include "KernelRBF.h"
 #include "KernelExp.h"
+#include "KernelHIK.h"
+#include "KernelEXPHIK.h"
 
 namespace OBJREC
 {
@@ -27,6 +29,19 @@ class GenericKernelSelection
         double log_rbf_sv = conf->gD ( "Kernel","log_rbf_sv",0.0 );
         kernel = new KernelExp ( log_rbf_gamma, log_rbf_sv );
       }
+      else if ( kernel_type == "hik" )
+      {
+        double alpha = conf->gD ( "Kernel","alpha",1.0 );
+        double beta = conf->gD ( "Kernel","beta",1.0 );
+        kernel = new KernelHIK ( alpha, beta );
+      }
+      else if ( kernel_type == "exphik" )
+      {
+        double alpha = conf->gD ( "Kernel","alpha",1.0 );
+        double beta = conf->gD ( "Kernel","beta",1.0 );
+        double gamma = conf->gD ( "Kernel","gamma",1.0 );
+        kernel = new KernelEXPHIK ( gamma, alpha, beta );
+      }      
       else
       {
         fthrow ( NICE::Exception, "Kernel type " << kernel_type << " is unknown" );

math/pdf/tests/TestPDF.cpp

@@ -25,7 +25,7 @@
 #include "core/vector/VVector.h"
 #include "vislearning/math/pdf/PDFGaussian.h"
 
-#include "objrec/nice_nonvis.h"
+// #include "objrec/nice_nonvis.h"
 
 using namespace std;
 using namespace NICE;

math/progs/testPLSA.cpp

@@ -5,6 +5,9 @@
 * @date 05/21/2008
 
 */
+
+
+#if 0
 #include "core/vector/VectorT.h"
 #include "core/vector/MatrixT.h"
 #include "core/image/ImageT.h"
@@ -443,3 +446,11 @@ int main (int argc, char **argv)
     return 0;
 }
 #endif
+
+#else
+int main (int argc, char **argv)
+{   
+    throw("Not converted to new structure of our library\n");
+    return 0;
+}
+#endif

mrf/Makefile

@@ -0,0 +1,8 @@
+#TARGETS_FROM:=$(notdir $(patsubst %/,%,$(shell pwd)))/$(TARGETS_FROM)
+#$(info recursivly going up: $(TARGETS_FROM) ($(shell pwd)))
+
+all:
+
+%:
+	$(MAKE) TARGETS_FROM=$(notdir $(patsubst %/,%,$(shell pwd)))/$(TARGETS_FROM) -C .. $@
+

mrf/Makefile.inc

@@ -0,0 +1,103 @@
+# LIBRARY-DIRECTORY-MAKEFILE
+# conventions:
+# - all subdirectories containing a "Makefile.inc" are considered sublibraries
+#   exception: "progs/" and "tests/" subdirectories!
+# - all ".C", ".cpp" and ".c" files in the current directory are linked to a
+#   library
+# - the library depends on all sublibraries 
+# - the library name is created with $(LIBNAME), i.e. it will be somehow
+#   related to the directory name and with the extension .a
+#   (e.g. lib1/sublib -> lib1_sublib.a)
+# - the library will be added to the default build list ALL_LIBRARIES
+
+# --------------------------------
+# - remember the last subdirectory
+#
+# set the variable $(SUBDIR) correctly to the current subdirectory. this
+# variable can be used throughout the current makefile.inc. The many 
+# SUBDIR_before, _add, and everything are only required so that we can recover
+# the previous content of SUBDIR before exitting the makefile.inc
+
+SUBDIR_add:=$(dir $(word $(words $(MAKEFILE_LIST)),$(MAKEFILE_LIST)))
+SUBDIR_before:=$(SUBDIR)
+SUBDIR:=$(strip $(SUBDIR_add))
+SUBDIR_before_$(SUBDIR):=$(SUBDIR_before)
+ifeq "$(SUBDIR)" "./"
+SUBDIR:=
+endif
+
+# ------------------------
+# - include subdirectories
+#
+# note the variables $(SUBDIRS_OF_$(SUBDIR)) are required later on to recover
+# the dependencies automatically. if you handle dependencies on your own, you
+# can also dump the $(SUBDIRS_OF_$(SUBDIR)) variable, and include the
+# makefile.inc of the subdirectories on your own...
+
+SUBDIRS_OF_$(SUBDIR):=$(patsubst %/Makefile.inc,%,$(wildcard $(SUBDIR)*/Makefile.inc))
+include $(SUBDIRS_OF_$(SUBDIR):%=%/Makefile.inc)
+
+# ----------------------------
+# - include local dependencies
+#
+# you can specify libraries needed by the individual objects or by the whole
+# directory. the object specific additional libraries are only considered
+# when compiling the specific object files
+# TODO: update documentation...
+
+-include $(SUBDIR)libdepend.inc
+
+$(foreach d,$(filter-out %progs %tests,$(SUBDIRS_OF_$(SUBDIR))),$(eval $(call PKG_DEPEND_INT,$(d))))
+
+# ---------------------------
+# - objects in this directory
+#
+# the use of the variable $(OBJS) is not mandatory. it is mandatory however
+# to update $(ALL_OBJS) in a way that it contains the path and name of
+# all objects. otherwise we can not include the appropriate .d files.
+
+OBJS:=$(patsubst %.cpp,$(OBJDIR)%.o,$(notdir $(wildcard $(SUBDIR)*.cpp))) \
+      $(patsubst %.C,$(OBJDIR)%.o,$(notdir $(wildcard $(SUBDIR)*.C))) \
+	  $(shell grep -ls Q_OBJECT $(SUBDIR)*.h | sed -e's@^@/@;s@.*/@$(OBJDIR)moc_@;s@\.h$$@.o@') \
+      $(patsubst %.c,$(OBJDIR)%.o,$(notdir $(wildcard $(SUBDIR)*.c)))
+ALL_OBJS += $(OBJS)
+
+# ----------------------------
+# - binaries in this directory
+#
+# output of binaries in this directory. none of the variables has to be used.
+# but everything you add to $(ALL_LIBRARIES) and $(ALL_BINARIES) will be
+# compiled with `make all`. be sure again to add the files with full path.
+
+LIBRARY_BASENAME:=$(call LIBNAME,$(SUBDIR))
+ifneq "$(SUBDIR)" ""
+ALL_LIBRARIES+=$(LIBDIR)$(LIBRARY_BASENAME).$(LINK_FILE_EXTENSION)
+endif
+
+# ---------------------
+# - binary dependencies
+#
+# there is no way of determining the binary dependencies automatically, so we
+# follow conventions. the current library depends on all sublibraries.
+# all other dependencies have to be added manually by specifying, that the
+# current .pc file depends on some other .pc file. binaries depending on
+# libraries should exclusivelly use the .pc files as well.
+
+ifeq "$(SKIP_BUILD_$(OBJDIR))" "1"
+$(LIBDIR)$(LIBRARY_BASENAME).a:
+else
+$(LIBDIR)$(LIBRARY_BASENAME).a:$(OBJS) \
+	$(call PRINT_INTLIB_DEPS,$(PKGDIR)$(LIBRARY_BASENAME).a,.$(LINK_FILE_EXTENSION))
+endif
+
+$(PKGDIR)$(LIBRARY_BASENAME).pc: \
+	$(call PRINT_INTLIB_DEPS,$(PKGDIR)$(LIBRARY_BASENAME).pc,.pc)
+
+# -------------------
+# - subdir management
+#
+# as the last step, always add this line to correctly recover the subdirectory
+# of the makefile including this one!
+
+SUBDIR:=$(SUBDIR_before_$(SUBDIR))
+

mrf/mrfmin/BP-S.cpp

@@ -0,0 +1,1057 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <new>
+#include "BP-S.h"
+
+#define private public
+#include "typeTruncatedQuadratic2D.h"
+
+using namespace OBJREC;
+#undef private
+
+
+#define m_D(pix,l)  m_D[(pix)*m_nLabels+(l)]
+#define m_V(l1,l2)  m_V[(l1)*m_nLabels+(l2)]
+
+
+#define MIN(a,b)  (((a) < (b)) ? (a) : (b))
+#define MAX(a,b)  (((a) > (b)) ? (a) : (b))
+#define TRUNCATE_MIN(a,b) { if ((a) > (b)) (a) = (b); }
+#define TRUNCATE_MAX(a,b) { if ((a) < (b)) (a) = (b); }
+#define TRUNCATE TRUNCATE_MIN
+
+/////////////////////////////////////////////////////////////////////////////
+//                  Operations on vectors (arrays of size K)               //
+/////////////////////////////////////////////////////////////////////////////
+
+inline void CopyVector(BPS::REAL* to, MRF::CostVal* from, int K)
+{
+    BPS::REAL* to_finish = to + K;
+    do
+	{
+	    *to ++ = *from ++;
+	} while (to < to_finish);
+}
+
+inline void AddVector(BPS::REAL* to, BPS::REAL* from, int K)
+{
+    BPS::REAL* to_finish = to + K;
+    do
+	{
+	    *to ++ += *from ++;
+	} while (to < to_finish);
+}
+
+inline BPS::REAL SubtractMin(BPS::REAL *D, int K)
+{
+    int k;
+    BPS::REAL delta;
+	
+    delta = D[0];
+    for (k=1; k<K; k++) TRUNCATE(delta, D[k]);
+    for (k=0; k<K; k++) D[k] -= delta;
+
+    return delta;
+}
+
+// Functions UpdateMessageTYPE (see the paper for details):
+//
+// - Set Di[ki] := gamma*Di_hat[ki] - M[ki]
+// - Set M[kj] := min_{ki} (Di[ki] + V[ki,kj])
+// - Normalize message: 
+//        delta := min_{kj} M[kj]
+//        M[kj] := M[kj] - delta
+//        return delta
+//
+// If dir = 1, then the meaning of i and j is swapped.
+
+///////////////////////////////////////////
+//                  L1                   //
+///////////////////////////////////////////
+
+inline BPS::REAL UpdateMessageL1(BPS::REAL* M, BPS::REAL* Di_hat, int K, BPS::REAL gamma, MRF::CostVal lambda, MRF::CostVal smoothMax)
+{
+    int k;
+    BPS::REAL delta;
+
+    delta = M[0] = gamma*Di_hat[0] - M[0];
+    for (k=1; k<K; k++)
+	{
+	    M[k] = gamma*Di_hat[k] - M[k];
+	    TRUNCATE(delta, M[k]);
+	    TRUNCATE(M[k], M[k-1] + lambda);
+	}
+
+    M[--k] -= delta;
+    TRUNCATE(M[k], lambda*smoothMax);
+    for (k--; k>=0; k--)
+	{
+	    M[k] -= delta;
+	    TRUNCATE(M[k], M[k+1] + lambda);
+	    TRUNCATE(M[k], lambda*smoothMax);
+	}
+
+    return delta;
+}
+
+////////////////////////////////////////
+//               L2                   //
+////////////////////////////////////////
+
+inline BPS::REAL UpdateMessageL2(BPS::REAL* M, BPS::REAL* Di_hat, int K, BPS::REAL gamma, MRF::CostVal lambda, MRF::CostVal smoothMax, void *buf)
+{
+    BPS::REAL* Di = (BPS::REAL*) buf;
+    int* parabolas = (int*) ((char*)buf + K*sizeof(BPS::REAL));
+    int* intersections = parabolas + K;
+    TypeTruncatedQuadratic2D::REAL* Di_tmp = (TypeTruncatedQuadratic2D::REAL*) (intersections + K + 1);
+    TypeTruncatedQuadratic2D::REAL* M_tmp = Di_tmp + K;
+    TypeTruncatedQuadratic2D::Edge* tmp = NULL;
+
+    int k;
+    BPS::REAL delta;
+
+    assert(lambda >= 0);
+
+    Di[0] = gamma*Di_hat[0] - M[0];
+    delta = Di[0];
+    for (k=1; k<K; k++)
+	{
+	    Di[k] = gamma*Di_hat[k] - M[k];
+	    TRUNCATE(delta, Di[k]);
+	}
+
+    if (lambda == 0)
+	{
+	    for (k=0; k<K; k++) M[k] = 0;
+	    return delta;
+	}
+
+    for (k=0; k<K; k++) Di_tmp[k] = Di[k];
+    tmp->DistanceTransformL2(K, 1, lambda, Di_tmp, M_tmp, parabolas, intersections);
+    for (k=0; k<K; k++) M[k] = (BPS::REAL) M_tmp[k];
+
+    for (k=0; k<K; k++)
+	{
+	    M[k] -= delta;
+	    TRUNCATE(M[k], lambda*smoothMax);
+	}
+
+    return delta;
+}
+
+
+//////////////////////////////////////////////////
+//                FIXED_MATRIX                  //
+//////////////////////////////////////////////////
+
+inline BPS::REAL UpdateMessageFIXED_MATRIX(BPS::REAL* M, BPS::REAL* Di_hat, int K, BPS::REAL gamma, MRF::CostVal lambda, MRF::CostVal* V, void* buf)
+{
+    BPS::REAL* Di = (BPS::REAL*) buf;
+    int ki, kj;
+    BPS::REAL delta;
+
+    for (ki=0; ki<K; ki++)
+	{
+	    Di[ki] = gamma*Di_hat[ki] - M[ki];
+	}
+
+    for (kj=0; kj<K; kj++)
+	{
+	    M[kj] = Di[0] + lambda*V[0]; 
+	    V ++;
+	    for (ki=1; ki<K; ki++)
+		{
+		    TRUNCATE(M[kj], Di[ki] + lambda*V[0]);
+		    V ++;
+		}
+	}
+
+    delta = M[0];
+    for (kj=1; kj<K; kj++) TRUNCATE(delta, M[kj]);
+    for (kj=0; kj<K; kj++) M[kj] -= delta;
+
+    return delta;
+}
+
+/////////////////////////////////////////////
+//                GENERAL                  //
+/////////////////////////////////////////////
+
+inline BPS::REAL UpdateMessageGENERAL(BPS::REAL* M, BPS::REAL* Di_hat, int K, BPS::REAL gamma, int dir, MRF::CostVal* V, void* buf)
+{
+    BPS::REAL* Di = (BPS::REAL*) buf;
+    int ki, kj;
+    BPS::REAL delta;
+
+    for (ki=0; ki<K; ki++)
+	{
+	    Di[ki] = (gamma*Di_hat[ki] - M[ki]);
+	}
+
+    if (dir == 0)
+	{
+	    for (kj=0; kj<K; kj++)
+		{
+		    M[kj] = Di[0] + V[0]; 
+		    V ++;
+		    for (ki=1; ki<K; ki++)
+			{
+			    TRUNCATE(M[kj], Di[ki] + V[0]);
+			    V ++;
+			}
+		}
+	}
+    else
+	{
+	    for (kj=0; kj<K; kj++)
+		{
+		    M[kj] = Di[0] + V[0];
+		    V += K;
+		    for (ki=1; ki<K; ki++)
+			{
+			    TRUNCATE(M[kj], Di[ki] + V[0]);
+			    V += K;
+			}
+		    V -= K*K - 1;
+		}
+	}
+
+    delta = M[0];
+    for (kj=1; kj<K; kj++) TRUNCATE(delta, M[kj]);
+    for (kj=0; kj<K; kj++) M[kj] -= delta;
+
+    return delta;
+}
+
+inline BPS::REAL UpdateMessageGENERAL(BPS::REAL* M, BPS::REAL* Di_hat, int K, BPS::REAL gamma, BPS::SmoothCostGeneralFn fn, int i, int j, void* buf)
+{
+    BPS::REAL* Di = (BPS::REAL*) buf;
+    int ki, kj;
+    BPS::REAL delta;
+
+    for (ki=0; ki<K; ki++)
+	{
+	    Di[ki] = (gamma*Di_hat[ki] - M[ki]);
+	}
+
+    for (kj=0; kj<K; kj++)
+	{
+	    M[kj] = Di[0] + fn(i, j, 0, kj); 
+	    for (ki=1; ki<K; ki++)
+		{
+		    delta = Di[ki] + fn(i, j, ki, kj);
+		    TRUNCATE(M[kj], delta);
+		}
+	}
+
+    delta = M[0];
+    for (kj=1; kj<K; kj++) TRUNCATE(delta, M[kj]);
+    for (kj=0; kj<K; kj++) M[kj] -= delta;
+
+    return delta;
+}
+
+
+
+
+
+
+BPS::BPS(int width, int height, int nLabels,EnergyFunction *eng):MRF(width,height,nLabels,eng)
+{
+    Allocate();
+}
+BPS::BPS(int nPixels, int nLabels,EnergyFunction *eng):MRF(nPixels,nLabels,eng)
+{
+    Allocate();
+}
+
+BPS::~BPS()
+{ 
+    delete[] m_answer;
+    if ( m_needToFreeD ) delete [] m_D;
+    if ( m_needToFreeV ) delete [] m_V;
+    if ( m_messages ) delete [] m_messages;
+    if ( m_DBinary ) delete [] m_DBinary;
+    if ( m_horzWeightsBinary ) delete [] m_horzWeightsBinary;
+    if ( m_vertWeightsBinary ) delete [] m_vertWeightsBinary;
+}
+
+
+void BPS::Allocate()
+{
+    m_type = NONE;
+    m_needToFreeV = false;
+    m_needToFreeD = false;
+
+    m_D = NULL;
+    m_V = NULL;
+    m_horzWeights = NULL;
+    m_vertWeights = NULL;
+    m_horzWeightsBinary = NULL;
+    m_vertWeightsBinary = NULL;
+
+    m_DBinary = NULL;
+    m_messages = NULL;
+    m_messageArraySizeInBytes = 0;
+
+    m_answer = new Label[m_nPixels];
+}
+
+void BPS::clearAnswer()
+{
+    memset(m_answer, 0, m_nPixels*sizeof(Label));
+    if (m_messages)
+	{
+	    memset(m_messages, 0, m_messageArraySizeInBytes);
+	}
+}
+
+
+MRF::EnergyVal BPS::smoothnessEnergy()
+{
+    EnergyVal eng = (EnergyVal) 0;
+    EnergyVal weight;
+    int x,y,pix;
+
+    if ( m_grid_graph )
+	{
+	    if ( m_smoothType != FUNCTION  )
+		{
+		    for ( y = 0; y < m_height; y++ )
+			for ( x = 1; x < m_width; x++ )
+			    {
+				pix    = x+y*m_width;
+				weight = m_varWeights ? m_horzWeights[pix-1] :  1;
+				eng = eng + m_V(m_answer[pix],m_answer[pix-1])*weight;
+			    }
+
+		    for ( y = 1; y < m_height; y++ )
+			for ( x = 0; x < m_width; x++ )
+			    {
+				pix = x+y*m_width;
+				weight = m_varWeights ? m_vertWeights[pix-m_width] :  1;
+				eng = eng + m_V(m_answer[pix],m_answer[pix-m_width])*weight;
+			    }
+		}
+	    else
+		{
+		    for ( y = 0; y < m_height; y++ )
+			for ( x = 1; x < m_width; x++ )
+			    {
+				pix = x+y*m_width;
+				eng = eng + m_smoothFn(pix,pix-1,m_answer[pix],m_answer[pix-1]);
+			    }
+
+		    for ( y = 1; y < m_height; y++ )
+			for ( x = 0; x < m_width; x++ )
+			    {
+				pix = x+y*m_width;
+				eng = eng + m_smoothFn(pix,pix-m_width,m_answer[pix],m_answer[pix-m_width]);
+			    }
+		}
+	}
+    else
+	{
+	    // not implemented
+	}
+
+    return(eng);
+}
+
+
+
+MRF::EnergyVal BPS::dataEnergy()
+{
+    EnergyVal eng = (EnergyVal) 0;
+
+    
+    if ( m_dataType == ARRAY) 
+	{
+	    for ( int i = 0; i < m_nPixels; i++ )
+		eng = eng + m_D(i,m_answer[i]);
+	}
+    else
+	{
+	    for ( int i = 0; i < m_nPixels; i++ )
+		eng = eng + m_dataFn(i,m_answer[i]);
+	}
+    return(eng);
+
+}
+
+
+void BPS::setData(DataCostFn dcost)
+{
+    int i, k;
+
+    m_dataFn = dcost;
+    CostVal* ptr;
+    m_D = new CostVal[m_nPixels*m_nLabels];
+
+    for (ptr=m_D, i=0; i<m_nPixels; i++)
+	for (k=0; k<m_nLabels; k++, ptr++)
+	    {
+		*ptr = m_dataFn(i,k);
+	    }
+    m_needToFreeD = true;
+}
+
+void BPS::setData(CostVal* data)
+{
+    m_D = data;
+    m_needToFreeD = false;
+}
+
+
+void BPS::setSmoothness(SmoothCostGeneralFn cost)
+{
+    assert(m_horzWeights == NULL && m_vertWeights == NULL && m_V == NULL);
+
+    int x, y, i, ki, kj;
+    CostVal* ptr;
+
+    m_smoothFn = cost;
+    m_type = GENERAL;
+
+    if (!m_allocateArrayForSmoothnessCostFn) return;
+
+    // try to cache all the function values in an array for efficiency
+    m_V = new(std::nothrow) CostVal[2*m_nPixels*m_nLabels*m_nLabels];
+    if (!m_V) {
+	fprintf(stderr, "not caching smoothness cost values (not enough memory)\n");
+	return; // if not enough space, just call the function directly
+    }
+
+    m_needToFreeV = true;
+
+    for (ptr=m_V,i=0,y=0; y<m_height; y++)
+	for (x=0; x<m_width; x++, i++)
+	    {
+		if (x < m_width-1)
+		    {
+			for (kj=0; kj<m_nLabels; kj++)
+			    for (ki=0; ki<m_nLabels; ki++)
+				{
+				    *ptr++ = cost(i,i+1,ki,kj);
+				}
+		    }
+		else ptr += m_nLabels*m_nLabels;
+
+		if (y < m_height-1)
+		    {
+			for (kj=0; kj<m_nLabels; kj++)
+			    for (ki=0; ki<m_nLabels; ki++)
+				{
+				    *ptr++ = cost(i,i+m_width,ki,kj);
+				}
+		    }
+		else ptr += m_nLabels*m_nLabels;
+	    }
+}
+void BPS::setSmoothness(CostVal* V)
+{
+    m_type = FIXED_MATRIX;
+    m_V = V;
+}
+
+
+void BPS::setSmoothness(int smoothExp,CostVal smoothMax, CostVal lambda)
+{
+    assert(smoothExp == 1 || smoothExp == 2);
+    assert(lambda >= 0);
+
+    m_type = (smoothExp == 1) ? L1 : L2;
+
+    int ki, kj;
+    CostVal cost;
+
+    m_needToFreeV = true;
+
+    m_V = new CostVal[m_nLabels*m_nLabels];
+
+    for (ki=0; ki<m_nLabels; ki++)
+	for (kj=ki; kj<m_nLabels; kj++)
+	    {
+		cost = (CostVal) ((smoothExp == 1) ? kj - ki : (kj - ki)*(kj - ki));
+		if (cost > smoothMax) cost = smoothMax;
+		m_V[ki*m_nLabels + kj] = m_V[kj*m_nLabels + ki] = cost*lambda;
+	    }
+
+    m_smoothMax = smoothMax;
+    m_lambda = lambda;
+}
+
+
+void BPS::setCues(CostVal* hCue, CostVal* vCue)
+{
+    m_horzWeights = hCue;
+    m_vertWeights  = vCue;
+}
+
+
+void BPS::initializeAlg()
+{
+    assert(m_type != NONE);
+
+    int i;
+
+    // determine type
+    if (m_type == L1 && m_nLabels == 2)
+	{
+	    m_type = BINARY;
+	}
+
+    // allocate messages
+    int messageNum = (m_type == BINARY) ? 4*m_nPixels : 4*m_nPixels*m_nLabels;
+    m_messageArraySizeInBytes = messageNum*sizeof(REAL);
+    m_messages = new REAL[messageNum];
+    memset(m_messages, 0, messageNum*sizeof(REAL));
+
+    if (m_type == BINARY)
+	{
+	    assert(m_DBinary == NULL && m_horzWeightsBinary == NULL && m_horzWeightsBinary == NULL);
+	    m_DBinary = new CostVal[m_nPixels];
+	    m_horzWeightsBinary = new CostVal[m_nPixels];
+	    m_vertWeightsBinary = new CostVal[m_nPixels];
+
+	    if ( m_dataType == ARRAY)
+		{
+		    for (i=0; i<m_nPixels; i++)
+			{
+			    m_DBinary[i] = m_D[2*i+1] - m_D[2*i];
+			}
+		}
+	    else
+		{
+		    for (i=0; i<m_nPixels; i++)
+			{
+			    m_DBinary[i] = m_dataFn(i,1) - m_dataFn(i,0);
+			}
+		}
+
+	    assert(m_V[0] == 0 && m_V[1] == m_V[2] && m_V[3] == 0);
+	    for (i=0; i<m_nPixels; i++)
+		{
+		    m_horzWeightsBinary[i] = (m_varWeights) ? m_V[1]*m_horzWeights[i] : m_V[1];
+		    m_vertWeightsBinary[i] = (m_varWeights) ? m_V[1]*m_vertWeights[i] : m_V[1];
+		}
+	}
+}
+
+void BPS::optimizeAlg(int nIterations)
+{
+    assert(m_type != NONE);
+
+    if (m_grid_graph)
+	{
+	    switch (m_type)
+		{
+		case L1:            optimize_GRID_L1(nIterations);           break;
+		case L2:            optimize_GRID_L2(nIterations);           break;
+		case FIXED_MATRIX:  optimize_GRID_FIXED_MATRIX(nIterations); break;
+		case GENERAL:       optimize_GRID_GENERAL(nIterations);      break;
+		case BINARY:        optimize_GRID_BINARY(nIterations);       break;
+		default: assert(0); exit(1);
+		}
+	}
+    else {printf("\nNot implemented for general graphs yet, exiting!");exit(1);}
+
+    //	printf("lower bound = %f\n", m_lowerBound);
+
+    ////////////////////////////////////////////////
+    //          computing solution                //
+    ////////////////////////////////////////////////
+
+    if (m_type != BINARY)
+	{
+	    int x, y, n, K = m_nLabels;
+	    CostVal* D_ptr;
+	    REAL* M_ptr;
+	    REAL* Di;
+	    REAL delta;
+	    int ki, kj;
+
+	    Di = new REAL[K];
+
+	    n = 0;
+	    D_ptr = m_D;
+	    M_ptr = m_messages;
+
+	    for (y=0; y<m_height; y++)
+		for (x=0; x<m_width; x++, D_ptr+=K, M_ptr+=2*K, n++)
+		    {
+			CopyVector(Di, D_ptr, K);
+
+			if (m_type == GENERAL)
+			    {
+				if (m_V)
+				    {
+					CostVal* ptr = m_V + 2*(x+y*m_width-1)*K*K;
+					if (x > 0)
+					    {
+						kj = m_answer[n-1];
+						for (ki=0; ki<K; ki++)
+						    {
+							Di[ki] += ptr[kj + ki*K];
+						    }
+					    }
+					ptr -= (2*m_width-3)*K*K;
+					if (y > 0)
+					    {
+						kj = m_answer[n-m_width];
+						for (ki=0; ki<K; ki++)
+						    {
+							Di[ki] += ptr[kj + ki*K];
+						    }
+					    }
+				    }
+				else
+				    {
+					if (x > 0)
+					    {
+						kj = m_answer[n-1];
+						for (ki=0; ki<K; ki++)
+						    {
+							Di[ki] += m_smoothFn(n, n-1, ki, kj);
+						    }
+					    }
+					if (y > 0)
+					    {
+						kj = m_answer[n-m_width];
+						for (ki=0; ki<K; ki++)
+						    {
+							Di[ki] += m_smoothFn(n, n-m_width, ki, kj);
+						    }
+					    }
+				    }
+			    }
+			else // m_type == L1, L2 or FIXED_MATRIX
+			    {
+				if (x > 0)
+				    {
+					kj = m_answer[n-1];
+					CostVal lambda = (m_varWeights) ? m_horzWeights[n-1] : 1;
+					for (ki=0; ki<K; ki++)
+					    {
+						Di[ki] += lambda*m_V[kj*K + ki];
+					    }
+				    }
+				if (y > 0)
+				    {
+					kj = m_answer[n-m_width];
+					CostVal lambda = (m_varWeights) ? m_vertWeights[n-m_width] : 1;
+					for (ki=0; ki<K; ki++)
+					    {
+						Di[ki] += lambda*m_V[kj*K + ki];
+					    }
+				    }
+			    }
+
+			if (x < m_width-1) AddVector(Di, M_ptr, K); // message (x+1,y)->(x,y)
+			if (y < m_height-1) AddVector(Di, M_ptr+K, K); // message (x,y+1)->(x,y)
+
+			// compute min
+			delta = Di[0];
+			m_answer[n] = 0;
+			for (ki=1; ki<K; ki++)
+			    {
+				if (delta > Di[ki])
+				    {
+					delta = Di[ki];
+					m_answer[n] = ki;
+				    }
+			    }
+		    }
+
+	    delete [] Di;
+	}
+    else // m_type == BINARY
+	{
+	    int x, y, n;
+	    REAL* M_ptr;
+	    REAL Di;
+
+	    n = 0;
+	    M_ptr = m_messages;
+
+	    for (y=0; y<m_height; y++)
+		for (x=0; x<m_width; x++, M_ptr+=2, n++)
+		    {
+			Di = m_DBinary[n];
+			if (x > 0) Di += (m_answer[n-1] == 0)       ? m_horzWeightsBinary[n-1]       : -m_horzWeightsBinary[n-1];
+			if (y > 0) Di += (m_answer[n-m_width] == 0) ? m_vertWeightsBinary[n-m_width] : -m_vertWeightsBinary[n-m_width];
+
+			if (x < m_width-1)  Di += M_ptr[0]; // message (x+1,y)->(x,y)
+			if (y < m_height-1) Di += M_ptr[1]; // message (x,y+1)->(x,y)
+
+			// compute min
+			m_answer[n] = (Di >= 0) ? 0 : 1;
+		    }
+	}
+}
+
+void BPS::optimize_GRID_L1(int nIterations)
+{
+    int x, y, n, K = m_nLabels;
+    CostVal* D_ptr;
+    REAL* M_ptr;
+    REAL* Di;
+
+    Di = new REAL[K];
+
+    for ( ; nIterations > 0; nIterations --)
+	{
+	    // forward pass
+	    n = 0;
+	    D_ptr = m_D;
+	    M_ptr = m_messages;
+
+	    for (y=0; y<m_height; y++)
+		for (x=0; x<m_width; x++, D_ptr+=K, M_ptr+=2*K, n++)
+		    {
+			CopyVector(Di, D_ptr, K);
+			if (x > 0) AddVector(Di, M_ptr-2*K, K); // message (x-1,y)->(x,y)
+			if (y > 0) AddVector(Di, M_ptr-(2*m_width-1)*K, K); // message (x,y-1)->(x,y)
+			if (x < m_width-1) AddVector(Di, M_ptr, K); // message (x+1,y)->(x,y)
+			if (y < m_height-1) AddVector(Di, M_ptr+K, K); // message (x,y+1)->(x,y)
+
+			if (x < m_width-1) 
+			    {
+				CostVal lambda = (m_varWeights) ? m_lambda*m_horzWeights[n] : m_lambda;
+				UpdateMessageL1(M_ptr, Di, K, 1, lambda, m_smoothMax);
+			    }
+			if (y < m_height-1) 
+			    {
+				CostVal lambda = (m_varWeights) ? m_lambda*m_vertWeights[n] : m_lambda;
+				UpdateMessageL1(M_ptr+K, Di, K, 1, lambda, m_smoothMax);
+			    }
+		    }
+
+	    // backward pass
+	    n --;
+	    D_ptr -= K;
+	    M_ptr -= 2*K;
+
+	    for (y=m_height-1; y>=0; y--)
+		for (x=m_width-1; x>=0; x--, D_ptr-=K, M_ptr-=2*K, n--)
+		    {
+			CopyVector(Di, D_ptr, K);
+			if (x > 0) AddVector(Di, M_ptr-2*K, K); // message (x-1,y)->(x,y)
+			if (y > 0) AddVector(Di, M_ptr-(2*m_width-1)*K, K); // message (x,y-1)->(x,y)
+			if (x < m_width-1) AddVector(Di, M_ptr, K); // message (x+1,y)->(x,y)
+			if (y < m_height-1) AddVector(Di, M_ptr+K, K); // message (x,y+1)->(x,y)
+
+			SubtractMin(Di, K);
+
+			if (x > 0) 
+			    {
+				CostVal lambda = (m_varWeights) ? m_lambda*m_horzWeights[n-1] : m_lambda;
+				UpdateMessageL1(M_ptr-2*K, Di, K, 1, lambda, m_smoothMax);
+			    }
+			if (y > 0) 
+			    {
+				CostVal lambda = (m_varWeights) ? m_lambda*m_vertWeights[n-m_width] : m_lambda;
+				UpdateMessageL1(M_ptr-(2*m_width-1)*K, Di, K, 1, lambda, m_smoothMax);
+			    }
+		    }
+	}
+
+    delete [] Di;
+}
+
+void BPS::optimize_GRID_L2(int nIterations)
+{
+    int x, y, n, K = m_nLabels;
+    CostVal* D_ptr;
+    REAL* M_ptr;
+    REAL* Di;
+    void* buf;
+
+    Di = new REAL[K];
+    buf = new char[2*K*sizeof(TypeTruncatedQuadratic2D::REAL) + (2*K+1)*sizeof(int) + K*sizeof(REAL)];
+
+    for ( ; nIterations > 0; nIterations --)
+	{
+	    // forward pass
+	    n = 0;
+	    D_ptr = m_D;
+	    M_ptr = m_messages;
+
+	    for (y=0; y<m_height; y++)
+		for (x=0; x<m_width; x++, D_ptr+=K, M_ptr+=2*K, n++)
+		    {
+			CopyVector(Di, D_ptr, K);
+			if (x > 0) AddVector(Di, M_ptr-2*K, K); // message (x-1,y)->(x,y)
+			if (y > 0) AddVector(Di, M_ptr-(2*m_width-1)*K, K); // message (x,y-1)->(x,y)
+			if (x < m_width-1) AddVector(Di, M_ptr, K); // message (x+1,y)->(x,y)
+			if (y < m_height-1) AddVector(Di, M_ptr+K, K); // message (x,y+1)->(x,y)
+
+			if (x < m_width-1) 
+			    {
+				CostVal lambda = (m_varWeights) ? m_lambda*m_horzWeights[n] : m_lambda;
+				UpdateMessageL2(M_ptr, Di, K, 1, lambda, m_smoothMax, buf);
+			    }
+			if (y < m_height-1) 
+			    {
+				CostVal lambda = (m_varWeights) ? m_lambda*m_vertWeights[n] : m_lambda;
+				UpdateMessageL2(M_ptr+K, Di, K, 1, lambda, m_smoothMax, buf);
+			    }
+		    }
+
+	    // backward pass
+	    n --;
+	    D_ptr -= K;
+	    M_ptr -= 2*K;
+
+	    for (y=m_height-1; y>=0; y--)
+		for (x=m_width-1; x>=0; x--, D_ptr-=K, M_ptr-=2*K, n--)
+		    {
+			CopyVector(Di, D_ptr, K);
+			if (x > 0) AddVector(Di, M_ptr-2*K, K); // message (x-1,y)->(x,y)
+			if (y > 0) AddVector(Di, M_ptr-(2*m_width-1)*K, K); // message (x,y-1)->(x,y)
+			if (x < m_width-1) AddVector(Di, M_ptr, K); // message (x+1,y)->(x,y)
+			if (y < m_height-1) AddVector(Di, M_ptr+K, K); // message (x,y+1)->(x,y)
+
+			SubtractMin(Di, K);
+
+			if (x > 0) 
+			    {
+				CostVal lambda = (m_varWeights) ? m_lambda*m_horzWeights[n-1] : m_lambda;
+				UpdateMessageL2(M_ptr-2*K, Di, K, 1, lambda, m_smoothMax, buf);
+			    }
+			if (y > 0) 
+			    {
+				CostVal lambda = (m_varWeights) ? m_lambda*m_vertWeights[n-m_width] : m_lambda;
+				UpdateMessageL2(M_ptr-(2*m_width-1)*K, Di, K, 1, lambda, m_smoothMax, buf);
+			    }
+		    }
+	}
+
+    delete [] Di;
+    delete [] (REAL *)buf;
+}
+
+
+void BPS::optimize_GRID_BINARY(int nIterations)
+{
+    int x, y, n;
+    REAL* M_ptr;
+    REAL Di;
+
+    for ( ; nIterations > 0; nIterations --)
+	{
+	    // forward pass
+	    n = 0;
+	    M_ptr = m_messages;
+
+	    for (y=0; y<m_height; y++)
+		for (x=0; x<m_width; x++, M_ptr+=2, n++)
+		    {
+			Di = m_DBinary[n];
+			if (x > 0) Di += M_ptr[-2]; // message (x-1,y)->(x,y)
+			if (y > 0) Di += M_ptr[-2*m_width+1]; // message (x,y-1)->(x,y)
+			if (x < m_width-1) Di += M_ptr[0]; // message (x+1,y)->(x,y)
+			if (y < m_height-1) Di += M_ptr[1]; // message (x,y+1)->(x,y)
+
+			REAL DiScaled = Di * 1;
+			if (x < m_width-1) 
+			    {
+				Di = DiScaled - M_ptr[0];
+				CostVal lambda = m_horzWeightsBinary[n];
+				if (lambda < 0) { Di = -Di; lambda = -lambda; }
+				if (Di > lambda) M_ptr[0] = lambda;
+				else             M_ptr[0] = (Di < -lambda) ? -lambda : Di;
+			    }
+			if (y < m_height-1) 
+			    {
+				Di = DiScaled - M_ptr[1];
+				CostVal lambda = m_vertWeightsBinary[n];
+				if (lambda < 0) { Di = -Di; lambda = -lambda; }
+				if (Di > lambda) M_ptr[1] = lambda;
+				else             M_ptr[1] = (Di < -lambda) ? -lambda : Di;
+			    }
+		    }
+
+	    // backward pass
+	    n --;
+	    M_ptr -= 2;
+
+	    for (y=m_height-1; y>=0; y--)
+		for (x=m_width-1; x>=0; x--, M_ptr-=2, n--)
+		    {
+			Di = m_DBinary[n];
+			if (x > 0) Di += M_ptr[-2]; // message (x-1,y)->(x,y)
+			if (y > 0) Di += M_ptr[-2*m_width+1]; // message (x,y-1)->(x,y)
+			if (x < m_width-1) Di += M_ptr[0]; // message (x+1,y)->(x,y)
+			if (y < m_height-1) Di += M_ptr[1]; // message (x,y+1)->(x,y)
+
+			REAL DiScaled = Di * 1;
+			if (x > 0) 
+			    {
+				Di = DiScaled - M_ptr[-2];
+				CostVal lambda = m_horzWeightsBinary[n-1];
+				if (lambda < 0) { Di = -Di; lambda = -lambda; }
+				if (Di > lambda) M_ptr[-2] = lambda;
+				else             M_ptr[-2] = (Di < -lambda) ? -lambda : Di;
+			    }
+			if (y > 0) 
+			    {
+				Di = DiScaled - M_ptr[-2*m_width+1];
+				CostVal lambda = m_vertWeightsBinary[n-m_width];
+				if (lambda < 0) { Di = -Di; lambda = -lambda; }
+				if (Di > lambda) M_ptr[-2*m_width+1] = lambda;
+				else             M_ptr[-2*m_width+1] = (Di < -lambda) ? -lambda : Di;
+			    }
+		    }
+	}
+}
+
+void BPS::optimize_GRID_FIXED_MATRIX(int nIterations)
+{
+    int x, y, n, K = m_nLabels;
+    CostVal* D_ptr;
+    REAL* M_ptr;
+    REAL* Di;
+    void* buf;
+
+    Di = new REAL[K];
+    buf = new REAL[K];
+
+    for ( ; nIterations > 0; nIterations --)
+	{
+	    // forward pass
+	    n = 0;
+	    D_ptr = m_D;
+	    M_ptr = m_messages;
+
+	    for (y=0; y<m_height; y++)
+		for (x=0; x<m_width; x++, D_ptr+=K, M_ptr+=2*K, n++)
+		    {
+			CopyVector(Di, D_ptr, K);
+			if (x > 0) AddVector(Di, M_ptr-2*K, K); // message (x-1,y)->(x,y)
+			if (y > 0) AddVector(Di, M_ptr-(2*m_width-1)*K, K); // message (x,y-1)->(x,y)
+			if (x < m_width-1) AddVector(Di, M_ptr, K); // message (x+1,y)->(x,y)
+			if (y < m_height-1) AddVector(Di, M_ptr+K, K); // message (x,y+1)->(x,y)
+
+			if (x < m_width-1) 
+			    {
+				CostVal lambda = (m_varWeights) ? m_horzWeights[n] : 1;
+				UpdateMessageFIXED_MATRIX(M_ptr, Di, K, 1, lambda, m_V, buf);
+			    }
+			if (y < m_height-1) 
+			    {
+				CostVal lambda = (m_varWeights) ? m_vertWeights[n] : 1;
+				UpdateMessageFIXED_MATRIX(M_ptr+K, Di, K, 1, lambda, m_V, buf);
+			    }
+		    }
+
+	    // backward pass
+	    n --;
+	    D_ptr -= K;
+	    M_ptr -= 2*K;
+
+	    for (y=m_height-1; y>=0; y--)
+		for (x=m_width-1; x>=0; x--, D_ptr-=K, M_ptr-=2*K, n--)
+		    {
+			CopyVector(Di, D_ptr, K);
+			if (x > 0) AddVector(Di, M_ptr-2*K, K); // message (x-1,y)->(x,y)
+			if (y > 0) AddVector(Di, M_ptr-(2*m_width-1)*K, K); // message (x,y-1)->(x,y)
+			if (x < m_width-1) AddVector(Di, M_ptr, K); // message (x+1,y)->(x,y)
+			if (y < m_height-1) AddVector(Di, M_ptr+K, K); // message (x,y+1)->(x,y)
+
+			SubtractMin(Di, K);
+
+			if (x > 0) 
+			    {
+				CostVal lambda = (m_varWeights) ? m_horzWeights[n-1] : 1;
+				UpdateMessageFIXED_MATRIX(M_ptr-2*K, Di, K, 1, lambda, m_V, buf);
+			    }
+			if (y > 0) 
+			    {
+				CostVal lambda = (m_varWeights) ? m_vertWeights[n-m_width] : 1;
+				UpdateMessageFIXED_MATRIX(M_ptr-(2*m_width-1)*K, Di, K, 1, lambda, m_V, buf);
+			    }
+		    }
+	}
+
+    delete [] Di;
+    delete [] (REAL *)buf;
+}
+
+void BPS::optimize_GRID_GENERAL(int nIterations)
+{
+    int x, y, n, K = m_nLabels;
+    CostVal* D_ptr;
+    REAL* M_ptr;
+    REAL* Di;
+    void* buf;
+
+    Di = new REAL[K];
+    buf = new REAL[K];
+
+    for ( ; nIterations > 0; nIterations --)
+	{
+	    // forward pass
+	    n = 0;
+	    D_ptr = m_D;
+	    M_ptr = m_messages;
+	    CostVal* V_ptr = m_V;
+
+	    for (y=0; y<m_height; y++)
+		for (x=0; x<m_width; x++, D_ptr+=K, M_ptr+=2*K, V_ptr+=2*K*K, n++)
+		    {
+			CopyVector(Di, D_ptr, K);
+			if (x > 0) AddVector(Di, M_ptr-2*K, K); // message (x-1,y)->(x,y)
+			if (y > 0) AddVector(Di, M_ptr-(2*m_width-1)*K, K); // message (x,y-1)->(x,y)
+			if (x < m_width-1) AddVector(Di, M_ptr, K); // message (x+1,y)->(x,y)
+			if (y < m_height-1) AddVector(Di, M_ptr+K, K); // message (x,y+1)->(x,y)
+
+			if (x < m_width-1) 
+			    {
+				if (m_V) UpdateMessageGENERAL(M_ptr, Di, K, 1, /* forward dir*/ 0, V_ptr, buf);
+				else     UpdateMessageGENERAL(M_ptr, Di, K, 1,   m_smoothFn, n, n+1,      buf);
+			    }
+			if (y < m_height-1) 
+			    {
+				if (m_V) UpdateMessageGENERAL(M_ptr+K, Di, K, 1, /* forward dir*/ 0, V_ptr+K*K, buf);
+				else     UpdateMessageGENERAL(M_ptr+K, Di, K, 1,   m_smoothFn, n, n+m_width,    buf);
+			    }
+		    }
+
+	    // backward pass
+	    n --;
+	    D_ptr -= K;
+	    M_ptr -= 2*K;
+	    V_ptr -= 2*K*K;
+
+	    for (y=m_height-1; y>=0; y--)
+		for (x=m_width-1; x>=0; x--, D_ptr-=K, M_ptr-=2*K, V_ptr-=2*K*K, n--)
+		    {
+			CopyVector(Di, D_ptr, K);
+			if (x > 0) AddVector(Di, M_ptr-2*K, K); // message (x-1,y)->(x,y)
+			if (y > 0) AddVector(Di, M_ptr-(2*m_width-1)*K, K); // message (x,y-1)->(x,y)
+			if (x < m_width-1) AddVector(Di, M_ptr, K); // message (x+1,y)->(x,y)
+			if (y < m_height-1) AddVector(Di, M_ptr+K, K); // message (x,y+1)->(x,y)
+
+			// normalize Di, update lower bound
+			SubtractMin(Di, K);
+
+			if (x > 0) 
+			    {
+				if (m_V) UpdateMessageGENERAL(M_ptr-2*K, Di, K, 1, /* backward dir */ 1, V_ptr-2*K*K, buf);
+				else     UpdateMessageGENERAL(M_ptr-2*K, Di, K, 1,   m_smoothFn, n, n-1,              buf);
+			    }
+			if (y > 0)
+			    {
+				if (m_V) UpdateMessageGENERAL(M_ptr-(2*m_width-1)*K, Di, K, 1, /* backward dir */ 1, V_ptr-(2*m_width-1)*K*K, buf);
+				else     UpdateMessageGENERAL(M_ptr-(2*m_width-1)*K, Di, K, 1,   m_smoothFn, n, n-m_width,                    buf);
+
+			    }
+		    }
+	}
+
+    delete [] Di;
+    delete [] (REAL *)buf;
+}

mrf/mrfmin/BP-S.h

@@ -0,0 +1,94 @@
+#ifndef __BPS_H__
+#define __BPS_H__
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "mrf.h"
+
+namespace OBJREC {
+
+class BPS : public MRF {
+  public:
+    typedef CostVal REAL;
+
+    BPS(int width, int height, int nLabels, EnergyFunction *eng);
+    BPS(int nPixels, int nLabels, EnergyFunction *eng);
+    ~BPS();
+    void setNeighbors(int /*pix1*/, int /*pix2*/, CostVal /*weight*/) {
+      printf("Not implemented");
+      exit(1);
+    }
+    Label getLabel(int pixel) {
+      return(m_answer[pixel]);
+    };
+    void setLabel(int pixel, Label label) {
+      m_answer[pixel] = label;
+    };
+    Label* getAnswerPtr() {
+      return(m_answer);
+    };
+    void clearAnswer();
+    void setParameters(int /*numParam*/, void * /*param*/) {
+      printf("No optional parameters to set");
+      exit(1);
+    }
+    EnergyVal smoothnessEnergy();
+    EnergyVal dataEnergy();
+
+  protected:
+    void setData(DataCostFn dcost);
+    void setData(CostVal* data);
+    void setSmoothness(SmoothCostGeneralFn cost);
+    void setSmoothness(CostVal* V);
+    void setSmoothness(int smoothExp, CostVal smoothMax, CostVal lambda);
+    void setCues(CostVal* hCue, CostVal* vCue);
+    void Allocate();
+    void initializeAlg();
+    void optimizeAlg(int nIterations);
+
+  private:
+
+    enum
+    {
+      NONE,
+      L1,
+      L2,
+      FIXED_MATRIX,
+      GENERAL,
+      BINARY,
+    } m_type;
+
+    CostVal m_smoothMax; // used only if
+    CostVal m_lambda;    // m_type == L1 or m_type == L2
+
+    Label *m_answer;
+    CostVal *m_V; // points to array of size nLabels^2 (if type==FIXED_MATRIX) or of size nEdges*nLabels^2 (if type==GENERAL)
+    CostVal *m_D;
+    CostVal *m_DBinary; // valid if type == BINARY
+    CostVal *m_horzWeights;
+    CostVal *m_vertWeights;
+    CostVal *m_horzWeightsBinary;
+    CostVal *m_vertWeightsBinary;
+    DataCostFn m_dataFn;
+    SmoothCostGeneralFn m_smoothFn;
+    bool m_needToFreeV;
+    bool m_needToFreeD;
+
+    REAL* m_messages; // size of one message: N = 1 if m_type == BINARY, N = K otherwise
+    // message between edges (x,y)-(x+1,y): m_messages+(2*x+2*y*m_width)*N
+    // message between edges (x,y)-(x,y+1): m_messages+(2*x+2*y*m_width+1)*N
+
+    int   m_messageArraySizeInBytes;
+
+    void optimize_GRID_L1(int nIterations);
+    void optimize_GRID_L2(int nIterations);
+    void optimize_GRID_FIXED_MATRIX(int nIterations);
+    void optimize_GRID_GENERAL(int nIterations);
+    void optimize_GRID_BINARY(int nIterations);
+};
+
+}
+
+#endif /*  __BPS_H__ */

mrf/mrfmin/CHANGES.txt

@@ -0,0 +1 @@
+06/11/2006: fixed memory leak in CSoptimization.cpp

mrf/mrfmin/GCoptimization.cpp

@@ -0,0 +1,833 @@
+#include "GCoptimization.h"
+#include "LinkedBlockList.h"
+#include <stdio.h>
+#include <time.h>
+#include <stdlib.h>
+
+using namespace OBJREC;
+
+// will leave this one just for the laughs :)
+//#define olga_assert(expr) assert(!(expr))
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//   First we have functions for the base class
+/////////////////////////////////////////////////////////////////////////////////////////////////
+// Constructor for base class
+GCoptimization::GCoptimization(SiteID nSites, LabelID nLabels)
+    : m_datacostIndividual(0)
+    , m_smoothcostIndividual(0)
+    , m_smoothcostFn(0)
+    , m_datacostFn(0)
+    , m_set_up_t_links_swap(0)
+    , m_set_up_t_links_expansion(0)
+    , m_set_up_n_links_swap(0)
+    , m_set_up_n_links_expansion(0)
+    , m_giveSmoothEnergyInternal(0)
+    , m_giveDataEnergyInternal(0)
+    , m_datacostFnDelete(0)
+    , m_smoothcostFnDelete(0)
+    , m_random_label_order(false)
+{
+  assert( nLabels > 1 && nSites > 0);
+  m_num_labels = nLabels;
+  m_num_sites  = nSites;
+
+
+  m_lookupSiteVar = (SiteID *)  new SiteID[m_num_sites];
+  m_labelTable    = (LabelID *) new LabelID[m_num_labels];
+  m_labeling      = (LabelID *) new LabelID[m_num_sites];
+
+  if ( !m_lookupSiteVar || !m_labelTable || !m_labeling) {
+    if (m_lookupSiteVar) delete [] m_lookupSiteVar;
+    if (m_labelTable) delete [] m_labelTable;
+    if (m_labeling) delete [] m_labeling;
+    handleError("Not enough memory");
+
+
+  }
+
+  for ( LabelID i = 0; i < m_num_labels; i++ )
+    m_labelTable[i] = i;
+
+
+  for ( SiteID i = 0; i < m_num_sites; i++ ) {
+    m_labeling[i] = (LabelID) 0;
+    m_lookupSiteVar[i] = (SiteID) - 1;
+  }
+
+  srand((unsigned int) time(NULL));
+}
+
+//-------------------------------------------------------------------
+
+GCoptimization::~GCoptimization()
+{
+  delete [] m_labelTable;
+  delete [] m_lookupSiteVar;
+  delete [] m_labeling;
+
+  if (m_datacostFnDelete) m_datacostFnDelete(m_datacostFn);
+  if (m_smoothcostFnDelete) m_smoothcostFnDelete(m_smoothcostFn);
+
+  if (m_datacostIndividual) delete [] m_datacostIndividual;
+  if (m_smoothcostIndividual) delete [] m_smoothcostIndividual;
+}
+
+
+//------------------------------------------------------------------
+
+void GCoptimization::setDataCost(DataCostFn fn) {
+  specializeDataCostFunctor(DataCostFnFromFunction(fn));
+}
+
+
+//------------------------------------------------------------------
+
+void GCoptimization::setDataCost(DataCostFnExtra fn, void *extraData) {
+  specializeDataCostFunctor(DataCostFnFromFunctionExtra(fn, extraData));
+}
+
+//-------------------------------------------------------------------
+
+void GCoptimization::setDataCost(EnergyTermType *dataArray) {
+  specializeDataCostFunctor(DataCostFnFromArray(dataArray, m_num_labels));
+}
+
+//-------------------------------------------------------------------
+
+void GCoptimization::setDataCost(SiteID s, LabelID l, EnergyTermType e) {
+  if (!m_datacostIndividual) {
+    if ( m_datacostFn ) handleError("Data Costs are already initialized");
+    m_datacostIndividual = new EnergyTermType[m_num_sites*m_num_labels];
+    memset(m_datacostIndividual, 0, m_num_sites*m_num_labels*sizeof(EnergyTermType));
+    specializeDataCostFunctor(DataCostFnFromArray(m_datacostIndividual, m_num_labels));
+  }
+  m_datacostIndividual[s*m_num_labels + l] = e;
+}
+
+//-------------------------------------------------------------------
+
+void GCoptimization::setDataCostFunctor(DataCostFunctor* f) {
+  if ( m_datacostFn ) handleError("Data Costs are already initialized");
+
+  m_datacostFn = f;
+  m_giveDataEnergyInternal   = &GCoptimization::giveDataEnergyInternal<DataCostFunctor>;
+  m_set_up_t_links_expansion = &GCoptimization::set_up_t_links_expansion<DataCostFunctor>;
+  m_set_up_t_links_swap      = &GCoptimization::set_up_t_links_swap<DataCostFunctor>;
+}
+
+
+//-------------------------------------------------------------------
+
+void GCoptimization::setSmoothCost(SmoothCostFn fn) {
+  specializeSmoothCostFunctor(SmoothCostFnFromFunction(fn));
+}
+
+//-------------------------------------------------------------------
+
+void GCoptimization::setSmoothCost(SmoothCostFnExtra fn, void* extraData) {
+  specializeSmoothCostFunctor(SmoothCostFnFromFunctionExtra(fn, extraData));
+}
+
+//-------------------------------------------------------------------
+
+void GCoptimization::setSmoothCost(EnergyTermType *smoothArray) {
+  specializeSmoothCostFunctor(SmoothCostFnFromArray(smoothArray, m_num_labels));
+}
+
+//-------------------------------------------------------------------
+
+void GCoptimization::setSmoothCost(LabelID l1, GCoptimization::LabelID l2, EnergyTermType e) {
+  if (!m_smoothcostIndividual) {
+    if ( m_smoothcostFn ) handleError("Smoothness Costs are already initialized");
+    m_smoothcostIndividual = new EnergyTermType[m_num_labels*m_num_labels];
+    memset(m_smoothcostIndividual, 0, m_num_labels*m_num_labels*sizeof(EnergyTermType));
+    specializeSmoothCostFunctor(SmoothCostFnFromArray(m_smoothcostIndividual, m_num_labels));
+  }
+  m_smoothcostIndividual[l1*m_num_labels + l2] = e;
+}
+
+//-------------------------------------------------------------------
+
+void GCoptimization::setSmoothCostFunctor(SmoothCostFunctor* f) {
+  if ( m_smoothcostFn ) handleError("Smoothness Costs are already initialized");
+
+  m_smoothcostFn = f;
+  m_giveSmoothEnergyInternal = &GCoptimization::giveSmoothEnergyInternal<SmoothCostFunctor>;
+  m_set_up_n_links_expansion = &GCoptimization::set_up_n_links_expansion<SmoothCostFunctor>;
+  m_set_up_n_links_swap      = &GCoptimization::set_up_n_links_swap<SmoothCostFunctor>;
+}
+
+//-------------------------------------------------------------------
+
+GCoptimization::EnergyType GCoptimization::giveSmoothEnergy()
+{
+
+  if (readyToOptimise())
+    return(  (this->*m_giveSmoothEnergyInternal)() );
+  else {
+    handleError("Not ready to optimize yet. Set up data and smooth costs first");
+    return(0);
+  }
+
+}
+//-------------------------------------------------------------------
+
+GCoptimization::EnergyType GCoptimization::giveDataEnergy()
+{
+
+
+  if (readyToOptimise())
+    return( (this->*m_giveDataEnergyInternal)() );
+  else {
+    handleError("Not ready to optimize yet. Set up data and smooth costs first");
+    return(0);
+  }
+
+}
+
+//-------------------------------------------------------------------
+
+GCoptimization::EnergyType GCoptimization::compute_energy()
+{
+  if (readyToOptimise())
+    return( (this->*m_giveDataEnergyInternal)() + (this->*m_giveSmoothEnergyInternal)());
+  else {
+    handleError("Not ready to optimize yet. Set up data and smooth costs first");
+    return(0);
+  }
+}
+
+//-------------------------------------------------------------------
+
+void GCoptimization::scramble_label_table()
+{
+  LabelID r1, r2, temp;
+  LabelID num_times, cnt;
+
+  num_times = m_num_labels;
+
+  for ( cnt = 0; cnt < num_times; cnt++ )
+  {
+    r1 = rand() % m_num_labels;
+    r2 = rand() % m_num_labels;
+
+    temp             = m_labelTable[r1];
+    m_labelTable[r1] = m_labelTable[r2];
+    m_labelTable[r2] = temp;
+  }
+}
+
+
+//-------------------------------------------------------------------
+
+GCoptimization::EnergyType GCoptimization::expansion(int max_num_iterations )
+{
+  int curr_cycle = 1;
+  EnergyType new_energy, old_energy;
+
+
+  new_energy = compute_energy();
+
+  old_energy = new_energy + 1;
+
+  while ( old_energy > new_energy  && curr_cycle <= max_num_iterations)
+  {
+    old_energy = new_energy;
+    new_energy = oneExpansionIteration();
+    curr_cycle++;
+  }
+
+  return(new_energy);
+}
+
+//-------------------------------------------------------------------
+
+void GCoptimization::setLabelOrder(bool RANDOM_LABEL_ORDER)
+{
+  m_random_label_order = RANDOM_LABEL_ORDER;
+}
+
+//-------------------------------------------------------------------
+
+bool GCoptimization::readyToOptimise()
+{
+  if (!m_smoothcostFn)
+  {
+    handleError("Smoothness term is not set up yet!");
+    return(false);
+  }
+  if (!m_datacostFn)
+  {
+    handleError("Data term is not set up yet!");
+    return(false);
+  }
+  return(true);
+
+}
+
+//------------------------------------------------------------------
+
+void GCoptimization::handleError(const char *message)
+{
+  throw  GCException(message);
+}
+
+
+//-------------------------------------------------------------------//
+//                  METHODS for EXPANSION MOVES                      //
+//-------------------------------------------------------------------//
+
+void GCoptimization::set_up_expansion_energy(SiteID size, LabelID alpha_label, Energy *e,
+    VarID *variables, SiteID *activeSites )
+{
+
+
+  (this->*m_set_up_t_links_expansion)(size, alpha_label, e, variables, activeSites);
+  (this->*m_set_up_n_links_expansion)(size, alpha_label, e, variables, activeSites);
+}
+
+
+//-------------------------------------------------------------------
+// Sets up the energy and optimizes it. Also updates labels of sites, if needed. ActiveSites
+// are the sites participating in expansion. They are not labeled alpha currrently
+void GCoptimization::solveExpansion(SiteID size, SiteID *activeSites, LabelID alpha_label)
+{
+  SiteID i, site;
+
+  if ( !readyToOptimise() ) handleError("Set up data and smoothness terms first. ");
+  if ( size == 0 ) return;
+
+
+  Energy *e = new Energy();
+
+  Energy::Var *variables = (Energy::Var *) new Energy::Var[size];
+
+  for ( i = 0; i < size; i++ )
+    variables[i] = e ->add_variable();
+
+  set_up_expansion_energy(size, alpha_label, e, variables, activeSites);
+
+  Energy::TotalValue Emin = e -> minimize();
+
+  for ( i = 0; i < size; i++ )
+  {
+    site = activeSites[i];
+    if ( m_labeling[site] != alpha_label )
+    {
+      if ( e->get_var(variables[i]) == 0 )
+      {
+        m_labeling[site] = alpha_label;
+      }
+    }
+    m_lookupSiteVar[site] = -1;
+  }
+
+  delete [] variables;
+  delete e;
+}
+//-------------------------------------------------------------------
+// alpha expansion on all sites not currently labeled alpha
+void GCoptimization::alpha_expansion(LabelID alpha_label)
+{
+  SiteID i  = 0, size = 0;
+  assert( alpha_label >= 0 && alpha_label < m_num_labels);
+
+  SiteID *activeSites = new SiteID[m_num_sites];
+
+  for ( i = 0; i < m_num_sites; i++ )
+  {
+    if ( m_labeling[i] != alpha_label )
+    {
+      activeSites[size] = i;
+      m_lookupSiteVar[i] = size;
+      size++;
+    }
+  }
+
+  solveExpansion(size, activeSites, alpha_label);
+
+  delete [] activeSites;
+}
+
+//-------------------------------------------------------------------
+// alpha expansion on subset of sites in array *sites
+void GCoptimization::alpha_expansion(LabelID alpha_label, SiteID *sites, SiteID num )
+{
+  SiteID i, size = 0;
+  SiteID *activeSites = new SiteID[num];
+
+  for ( i = 0; i < num; i++ )
+  {
+    if ( m_labeling[sites[i]] != alpha_label )
+    {
+      m_lookupSiteVar[sites[i]] = size;
+      activeSites[size] = sites[i];
+      size++;
+    }
+  }
+
+  solveExpansion(size, activeSites, alpha_label);
+
+  delete [] activeSites;
+}
+
+//-------------------------------------------------------------------
+
+GCoptimization::EnergyType GCoptimization::oneExpansionIteration()
+{
+  LabelID next;
+
+  if (m_random_label_order) scramble_label_table();
+
+  for (next = 0;  next < m_num_labels;  next++ )
+  {
+    alpha_expansion(m_labelTable[next]);
+  }
+
+  return(compute_energy());
+}
+
+//-------------------------------------------------------------------//
+//                  METHODS for SWAP MOVES                           //
+//-------------------------------------------------------------------//
+
+GCoptimization::EnergyType GCoptimization::swap(int max_num_iterations )
+{
+
+  int curr_cycle = 1;
+  EnergyType new_energy, old_energy;
+
+
+  new_energy = compute_energy();
+
+  old_energy = new_energy + 1;
+
+  while ( old_energy > new_energy  && curr_cycle <= max_num_iterations)
+  {
+    old_energy = new_energy;
+    new_energy = oneSwapIteration();
+
+    curr_cycle++;
+  }
+
+  return(new_energy);
+}
+
+//--------------------------------------------------------------------------------
+
+GCoptimization::EnergyType GCoptimization::oneSwapIteration()
+{
+  LabelID next, next1;
+
+  if (m_random_label_order) scramble_label_table();
+
+
+  for (next = 0;  next < m_num_labels;  next++ )
+    for (next1 = m_num_labels - 1;  next1 >= 0;  next1-- )
+      if ( m_labelTable[next] < m_labelTable[next1] )
+        alpha_beta_swap(m_labelTable[next], m_labelTable[next1]);
+
+
+  return(compute_energy());
+}
+
+//---------------------------------------------------------------------------------
+
+void GCoptimization::alpha_beta_swap(LabelID alpha_label, LabelID beta_label)
+{
+  assert( alpha_label >= 0 && alpha_label < m_num_labels && beta_label >= 0 && beta_label < m_num_labels);
+
+  SiteID i  = 0, size = 0;
+  SiteID *activeSites = new SiteID[m_num_sites];
+
+  for ( i = 0; i < m_num_sites; i++ ) {
+    if ( m_labeling[i] == alpha_label || m_labeling[i] == beta_label ) {
+      activeSites[size] = i;
+      m_lookupSiteVar[i] = size;
+      size++;
+    }
+  }
+
+  solveSwap(size, activeSites, alpha_label, beta_label);
+
+  delete [] activeSites;
+
+}
+//-----------------------------------------------------------------------------------
+
+void GCoptimization::alpha_beta_swap(LabelID alpha_label, LabelID beta_label,
+                                     SiteID *alphaSites, SiteID alpha_size, SiteID *betaSites,
+                                     SiteID beta_size)
+
+{
+  assert( !(alpha_label < 0 || alpha_label >= m_num_labels || beta_label < 0 || beta_label >= m_num_labels) );
+  SiteID i, site, size = 0;
+
+  SiteID *activeSites = new SiteID[alpha_size+beta_size];
+
+  for ( i = 0; i < alpha_size; i++ )
+  {
+    site = alphaSites[i];
+
+    assert(site >= 0 && site < m_num_sites );
+    assert(m_labeling[site] == alpha_label);
+
+    activeSites[size]     = site;
+    m_lookupSiteVar[site] = size;
+    size++;
+
+  }
+
+  for ( i = 0; i < beta_size; i++ )
+  {
+    site = betaSites[i];
+    assert(site >= 0 && site < m_num_sites );
+    assert(m_labeling[site] == beta_label);
+
+    activeSites[size]     = site;
+    m_lookupSiteVar[site] = size;
+    size++;
+
+  }
+
+  solveSwap(size, activeSites, alpha_label, beta_label);
+
+  delete [] activeSites;
+}
+
+//-----------------------------------------------------------------------------------
+void GCoptimization::solveSwap(SiteID size, SiteID *activeSites, LabelID alpha_label,
+                               LabelID beta_label)
+{
+
+  SiteID i, site;
+
+  if ( !readyToOptimise() ) handleError("Set up data and smoothness terms first. ");
+  if ( size == 0 ) return;
+
+
+  Energy *e = new Energy();
+  Energy::Var *variables = (Energy::Var *) new Energy::Var[size];
+
+  for ( i = 0; i < size; i++ )
+    variables[i] = e ->add_variable();
+
+  set_up_swap_energy(size, alpha_label, beta_label, e, variables, activeSites);
+
+  Energy::TotalValue Emin = e -> minimize();
+
+  for ( i = 0; i < size; i++ )
+  {
+    site = activeSites[i];
+    if ( e->get_var(variables[i]) == 0 )
+      m_labeling[site] = alpha_label;
+    else m_labeling[site] = beta_label;
+    m_lookupSiteVar[site] = -1;
+  }
+
+  delete [] variables;
+  delete e;
+
+}
+//-----------------------------------------------------------------------------------
+
+void GCoptimization::set_up_swap_energy(SiteID size, LabelID alpha_label, LabelID beta_label,
+                                        Energy* e, Energy::Var *variables, SiteID *activeSites)
+{
+  (this->*m_set_up_t_links_swap)(size, alpha_label, beta_label, e, variables, activeSites);
+  (this->*m_set_up_n_links_swap)(size, alpha_label, beta_label, e, variables, activeSites);
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+// Functions for the GCoptimizationGridGraph, derived from GCoptimization
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+GCoptimizationGridGraph::GCoptimizationGridGraph(SiteID width, SiteID height, LabelID num_labels)
+    : GCoptimization(width*height, num_labels)
+{
+
+  assert( (width > 1) && (height > 1) && (num_labels > 1 ));
+
+  m_weightedGraph = 0;
+
+  for (int  i = 0; i < 4; i ++ ) m_unityWeights[i] = 1;
+
+  m_width  = width;
+  m_height = height;
+
+  m_numNeighbors = new SiteID[m_num_sites];
+  m_neighbors = new SiteID[4*m_num_sites];
+
+  SiteID indexes[4] = { -1, 1, -m_width, m_width};
+
+  SiteID indexesL[3] = {1, -m_width, m_width};
+  SiteID indexesR[3] = { -1, -m_width, m_width};
+  SiteID indexesU[3] = {1, -1, m_width};
+  SiteID indexesD[3] = {1, -1, -m_width};
+
+  SiteID indexesUL[2] = {1, m_width};
+  SiteID indexesUR[2] = { -1, m_width};
+  SiteID indexesDL[2] = {1, -m_width};
+  SiteID indexesDR[2] = { -1, -m_width};
+
+  setupNeighbData(1, m_height - 1, 1, m_width - 1, 4, indexes);
+
+  setupNeighbData(1, m_height - 1, 0, 1, 3, indexesL);
+  setupNeighbData(1, m_height - 1, m_width - 1, m_width, 3, indexesR);
+  setupNeighbData(0, 1, 1, width - 1, 3, indexesU);
+  setupNeighbData(m_height - 1, m_height, 1, m_width - 1, 3, indexesD);
+
+  setupNeighbData(0, 1, 0, 1, 2, indexesUL);
+  setupNeighbData(0, 1, m_width - 1, m_width, 2, indexesUR);
+  setupNeighbData(m_height - 1, m_height, 0, 1, 2, indexesDL);
+  setupNeighbData(m_height - 1, m_height, m_width - 1, m_width, 2, indexesDR);
+}
+
+//-------------------------------------------------------------------
+
+GCoptimizationGridGraph::~GCoptimizationGridGraph()
+{
+  delete [] m_numNeighbors;
+  delete [] m_neighbors;
+  if (m_weightedGraph) delete [] m_neighborsWeights;
+}
+
+
+//-------------------------------------------------------------------
+
+void GCoptimizationGridGraph::setupNeighbData(SiteID startY, SiteID endY, SiteID startX,
+    SiteID endX, SiteID maxInd, SiteID *indexes)
+{
+  SiteID x, y, pix;
+  SiteID n;
+
+  for ( y = startY; y < endY; y++ )
+    for ( x = startX; x < endX; x++ )
+    {
+      pix = x + y * m_width;
+      m_numNeighbors[pix] = maxInd;
+
+      for (n = 0; n < maxInd; n++ )
+        m_neighbors[pix*4+n] = pix + indexes[n];
+    }
+}
+
+//-------------------------------------------------------------------
+
+bool GCoptimizationGridGraph::readyToOptimise()
+{
+  GCoptimization::readyToOptimise();
+  return(true);
+}
+
+//-------------------------------------------------------------------
+
+void GCoptimizationGridGraph::setSmoothCostVH(EnergyTermType *smoothArray, EnergyTermType *vCosts, EnergyTermType *hCosts)
+{
+  setSmoothCost(smoothArray);
+  m_weightedGraph = 1;
+  computeNeighborWeights(vCosts, hCosts);
+}
+
+//-------------------------------------------------------------------
+
+void GCoptimizationGridGraph::giveNeighborInfo(SiteID site, SiteID *numSites, SiteID **neighbors, EnergyTermType **weights)
+{
+  *numSites  = m_numNeighbors[site];
+  *neighbors = &m_neighbors[site*4];
+
+  if (m_weightedGraph) *weights  = &m_neighborsWeights[site*4];
+  else *weights = m_unityWeights;
+}
+
+//-------------------------------------------------------------------
+
+void GCoptimizationGridGraph::computeNeighborWeights(EnergyTermType *vCosts, EnergyTermType *hCosts)
+{
+  SiteID i, n, nSite;
+  GCoptimization::EnergyTermType weight;
+
+
+  m_neighborsWeights = new EnergyTermType[m_num_sites*4];
+
+  for ( i = 0; i < m_num_sites; i++ )
+  {
+    for ( n = 0; n < m_numNeighbors[i]; n++ )
+    {
+      nSite = m_neighbors[4*i+n];
+      if ( i - nSite == 1 )            weight = hCosts[nSite];
+      else if (i - nSite == -1 )       weight = hCosts[i];
+      else if ( i - nSite == m_width ) weight = vCosts[nSite];
+      else if (i - nSite == -m_width ) weight = vCosts[i];
+
+      m_neighborsWeights[i*4+n] = weight;
+    }
+  }
+
+}
+////////////////////////////////////////////////////////////////////////////////////////////////
+// Functions for the GCoptimizationGeneralGraph, derived from GCoptimization
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+GCoptimizationGeneralGraph::GCoptimizationGeneralGraph(SiteID num_sites, LabelID num_labels): GCoptimization(num_sites, num_labels)
+{
+  assert( num_sites > 1 && num_labels > 1 );
+
+  m_neighborsIndexes = 0;
+  m_neighborsWeights = 0;
+  m_numNeighbors     = 0;
+  m_neighbors        = 0;
+
+  m_needTodeleteNeighbors        = true;
+  m_needToFinishSettingNeighbors = true;
+}
+
+//------------------------------------------------------------------
+
+GCoptimizationGeneralGraph::~GCoptimizationGeneralGraph()
+{
+
+  if ( m_neighbors ) {
+    delete [] m_neighbors;
+  }
+
+  if ( m_numNeighbors && m_needTodeleteNeighbors )
+  {
+    for ( SiteID i = 0; i < m_num_sites; i++ )
+    {
+      if (m_numNeighbors[i] != 0 )
+      {
+        delete [] m_neighborsIndexes[i];
+        delete [] m_neighborsWeights[i];
+      }
+    }
+
+    delete [] m_numNeighbors;
+    delete [] m_neighborsIndexes;
+    delete [] m_neighborsWeights;
+  }
+
+
+}
+
+//-------------------------------------------------------------------
+
+bool GCoptimizationGeneralGraph::readyToOptimise()
+{
+  GCoptimization::readyToOptimise();
+  if (m_needToFinishSettingNeighbors) finishSettingNeighbors();
+  return(true);
+}
+
+//------------------------------------------------------------------
+
+void GCoptimizationGeneralGraph::finishSettingNeighbors()
+{
+
+  Neighbor *tmp;
+  SiteID i, site, count;
+
+  m_needToFinishSettingNeighbors = false;
+
+  EnergyTermType *tempWeights = new EnergyTermType[m_num_sites];
+  SiteID *tempIndexes         = new SiteID[m_num_sites];
+
+  if ( !tempWeights || !tempIndexes ) handleError("Not enough memory");
+
+  m_numNeighbors     = new SiteID[m_num_sites];
+  m_neighborsIndexes = new SiteID*[m_num_sites];
+  m_neighborsWeights = new EnergyTermType*[m_num_sites];
+
+  if ( !m_numNeighbors || !m_neighborsIndexes || !m_neighborsWeights ) handleError("Not enough memory");
+
+  for ( site = 0; site < m_num_sites; site++ )
+  {
+    if ( !m_neighbors[site].isEmpty() )
+    {
+      m_neighbors[site].setCursorFront();
+      count = 0;
+
+      while ( m_neighbors[site].hasNext() )
+      {
+        tmp = (Neighbor *) (m_neighbors[site].next());
+        tempIndexes[count] =  tmp->to_node;
+        tempWeights[count] =  tmp->weight;
+        delete tmp;
+        count++;
+      }
+      m_numNeighbors[site]     = count;
+      m_neighborsIndexes[site] = new SiteID[count];
+      m_neighborsWeights[site] = new EnergyTermType[count];
+
+      if ( !m_neighborsIndexes[site] || !m_neighborsWeights[site] ) handleError("Not enough memory");
+
+      for ( i = 0; i < count; i++ )
+      {
+        m_neighborsIndexes[site][i] = tempIndexes[i];
+        m_neighborsWeights[site][i] = tempWeights[i];
+      }
+    }
+    else m_numNeighbors[site] = 0;
+
+  }
+
+  delete [] tempIndexes;
+  delete [] tempWeights;
+  delete [] m_neighbors;
+  m_neighbors = (LinkedBlockList *) new LinkedBlockList[1];
+  // this signals that the neibhorhood system is set, in case user calls setAllNeighbors
+}
+//------------------------------------------------------------------------------
+
+void GCoptimizationGeneralGraph::giveNeighborInfo(SiteID site, SiteID *numSites,
+    SiteID **neighbors, EnergyTermType **weights)
+{
+  (*numSites)  =  m_numNeighbors[site];
+  (*neighbors) = m_neighborsIndexes[site];
+  (*weights)   = m_neighborsWeights[site];
+}
+
+
+//------------------------------------------------------------------
+
+void GCoptimizationGeneralGraph::setNeighbors(SiteID site1, SiteID site2, EnergyTermType weight)
+{
+
+  assert( site1 < m_num_sites && site1 >= 0 && site2 < m_num_sites && site2 >= 0);
+  if ( m_needToFinishSettingNeighbors == false ) handleError("Already set up neighborhood system");
+
+  if ( !m_neighbors )
+  {
+    m_neighbors = (LinkedBlockList *) new LinkedBlockList[m_num_sites];
+    if ( !m_neighbors ) handleError("Not enough memory");
+  }
+
+  Neighbor *temp1 = (Neighbor *) new Neighbor;
+  Neighbor *temp2 = (Neighbor *) new Neighbor;
+
+  temp1->weight  = weight;
+  temp1->to_node = site2;
+
+  temp2->weight  = weight;
+  temp2->to_node = site1;
+
+  m_neighbors[site1].addFront(temp1);
+  m_neighbors[site2].addFront(temp2);
+
+}
+//------------------------------------------------------------------
+
+void GCoptimizationGeneralGraph::setAllNeighbors(SiteID *numNeighbors, SiteID **neighborsIndexes,
+    EnergyTermType **neighborsWeights)
+{
+  m_needTodeleteNeighbors = false;
+  m_needToFinishSettingNeighbors = false;
+  if ( m_neighbors ) handleError("Already set up neighborhood system");
+
+  m_numNeighbors     = numNeighbors;
+  m_neighborsIndexes = neighborsIndexes;
+  m_neighborsWeights = neighborsWeights;
+}
+

mrf/mrfmin/GCoptimization.h

@@ -0,0 +1,661 @@
+/*#########################################################################
+#                                                                       #
+#    GC_optimization - software for energy minimization with graph cuts #
+#                        Version 2.3                                    #
+#    http://www.csd.uwo.ca/faculty/olga/software.html                   #
+#                                                                       #
+#    Copyright 2007 Olga Veksler (olga@csd.uwo.ca)                      #
+#                                                                       #
+#    I would like to thank Andrew Delong for his invaluable help        #
+#    with C++ when redesigning the GC interface.  Thank you for         #
+#    helping me to make my code 5 times shorter and 100 times more      #
+#    debuggable. And not for scaring me with DLL's :)                   #
+#########################################################################
+*/
+// Copyright 2007 Olga Veksler (olga@csd.uwo.ca)
+// email olga@csd.uwo.ca for any questions, suggestions and bug reports
+
+////////////////////////////////////////////////////////////////////////////////////
+//  IMPORTANT!!!!!!
+//  If you use this software, YOU HAVE TO REFERENCE (at least) 3 papers, the citations [1]
+//  [2] and [3] below
+///////////////////////////////////////////////////////////////////////////////////
+// For description and  example usage see GC_README.TXT
+///////////////////////////////////////////////////////////////////////////////////
+/*
+ This software library implements the Graph Cuts Energy Minimization methods
+ described in
+
+
+  [1] Efficient Approximate Energy Minimization via Graph Cuts
+      Yuri Boykov, Olga Veksler, Ramin Zabih,
+      IEEE transactions on PAMI, vol. 20, no. 12, p. 1222-1239, November 2001.
+
+
+
+ This software can be used only for research purposes, you should cite
+ the aforementioned paper in any resulting publication.
+ If you wish to use this software (or the algorithms described in the aforementioned paper)
+ for commercial purposes, you should be aware that there is a US patent:
+
+  R. Zabih, Y. Boykov, O. Veksler,
+  "System and method for fast approximate energy minimization via graph cuts ",
+  United Stated Patent 6,744,923, June 1, 2004
+
+*/
+
+/* Together with the library implemented by O. Veksler, we provide, with the permission of the
+    V. Kolmogorov and Y. Boykov the following libraries:  */
+
+
+/*1) energy.h, which was developed by Vladimir Kolmogorov and  implements binary energy minimization
+ technique described in
+
+ [2] What Energy Functions can be Minimized via Graph Cuts?
+     Vladimir Kolmogorov and Ramin Zabih.
+     To appear in IEEE Transactions on Pattern Analysis and Machine Intelligence (PAMI).
+     Earlier version appeared in European Conference on Computer Vision (ECCV), May 2002.
+
+
+ We use "energy.h" to implement the binary energy minimization step
+ for the alpha-expansion and swap algorithms. The graph construction provided by "energy.h" is
+ more efficient (and slightly more general) than the original graph construction for the
+ alpha-expansion algorithm in the paper cited as [1]
+
+
+ This software can be used only for research purposes. IF YOU USE THIS SOFTWARE,
+ YOU SHOULD CITE THE AFOREMENTIONED PAPER [2] IN ANY RESULTING PUBLICATION.
+
+
+
+2)  graph.h, block.h, maxflow.cpp
+
+ This software library implements the maxflow algorithm
+ described in
+
+  [3] An Experimental Comparison of Min-Cut/Max-Flow Algorithms
+      for Energy Minimization in Vision.
+      Yuri Boykov and Vladimir Kolmogorov.
+      In IEEE Transactions on Pattern Analysis and Machine Intelligence (PAMI),
+      September 2004
+
+ This algorithm was developed by Yuri Boykov and Vladimir Kolmogorov
+ at Siemens Corporate Research. To make it available for public use,
+ it was later reimplemented by Vladimir Kolmogorov based on open publications.
+
+ If you use this software for research purposes, you should cite
+ the aforementioned paper in any resulting publication.
+*/
+
+/* These 4 files (energy.h,graph.h, block.h, maxflow.cpp) are included in the curent library with permission of
+Vladimir Kolmogorov and Yuri Boykov.
+The can  also be downloaded independently from Vladimir Kolmogorov's
+website:http://www.adastral.ucl.ac.uk/~vladkolm/software.html
+*/
+
+
+///////////////////////////////////////////////////////////////////////////////////
+/*
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+///////////////////////////////////////////////////////////////////////////////////
+
+#ifndef __GCOPTIMIZATION_H__
+#define __GCOPTIMIZATION_H__
+
+#include "energy.h"
+#include "graph.h"
+#include <memory.h>
+#include <stdio.h>
+#include <limits.h>
+
+#ifdef _MSC_EXTENSIONS
+#define OLGA_INLINE __forceinline
+#else
+#define OLGA_INLINE inline
+#endif
+
+namespace OBJREC {
+
+class LinkedBlockList;
+
+class GCoptimization
+{
+  public:
+    typedef Graph::flowtype EnergyType;     // Type for the total energy the energy function.Change it in Graph.h
+    typedef Graph::captype EnergyTermType;  // Type for the individual terms in the energy function.Change it in Graph.h
+    typedef Energy::Var VarID;
+    typedef int LabelID;                   // Type for labels
+    typedef int SiteID;                    // Type for sites
+    typedef EnergyTermType (*SmoothCostFn)(SiteID s1, SiteID s2, LabelID l1, LabelID l2);
+    typedef EnergyTermType (*DataCostFn)(SiteID s, LabelID l);
+    typedef EnergyTermType (*SmoothCostFnExtra)(SiteID s1, SiteID s2, LabelID l1, LabelID l2, void *);
+    typedef EnergyTermType (*DataCostFnExtra)(SiteID s, LabelID l, void *);
+
+
+    GCoptimization(SiteID num_sites, LabelID num_labels);
+    virtual ~GCoptimization();
+
+    // Peforms expansion algorithm. Runs the number of iterations specified by max_num_iterations
+    // If no input specified,runs until convergence. Returns total energy of labeling.
+    EnergyType expansion(int max_num_iterations = INT_MAX);
+
+    // Peforms  expansion on one label, specified by the input parameter alpha_label
+    void alpha_expansion(LabelID alpha_label);
+
+    // Peforms  expansion on label alpha_label only for sites specified by *sites.
+    // num is the size of  array "sites"
+    void alpha_expansion(LabelID alpha_label, SiteID *sites, SiteID num);
+
+    // Peforms swap algorithm. Runs it the specified number of iterations. If no
+    // input is specified,runs until convergence
+    EnergyType swap(int max_num_iterations = INT_MAX);
+
+    // Peforms  swap on a pair of labels, specified by the input parameters alpha_label, beta_label
+    void alpha_beta_swap(LabelID alpha_label, LabelID beta_label);
+
+    // Peforms  swap on a pair of labels, specified by the input parameters alpha_label, beta_label
+    // only on the sitess in the specified arrays, alphaSites and betaSitess, and the array sizes
+    // are, respectively, alpha_size and beta_size
+    void alpha_beta_swap(LabelID alpha_label, LabelID beta_label, SiteID *alphaSites,
+                         SiteID alpha_size, SiteID *betaSites, SiteID beta_size);
+
+    struct DataCostFunctor;      // use this class to pass a functor to setDataCost
+    struct SmoothCostFunctor;    // use this class to pass a functor to setSmoothCost
+
+    void setDataCost(DataCostFn fn);
+    void setDataCost(DataCostFnExtra fn, void *extraData);
+    void setDataCost(EnergyTermType *dataArray);
+    void setDataCost(SiteID s, LabelID l, EnergyTermType e);
+    void setDataCostFunctor(DataCostFunctor* f);
+    struct DataCostFunctor {
+      virtual EnergyTermType compute(SiteID s, LabelID l) = 0;
+    };
+
+    void setSmoothCost(SmoothCostFn fn);
+    void setSmoothCost(SmoothCostFnExtra fn, void *extraData);
+    void setSmoothCost(LabelID l1, LabelID l2, EnergyTermType e);
+    void setSmoothCost(EnergyTermType *smoothArray);
+    void setSmoothCostFunctor(SmoothCostFunctor* f);
+    struct SmoothCostFunctor {
+      virtual EnergyTermType compute(SiteID s1, SiteID s2, LabelID l1, LabelID l2) = 0;
+    };
+
+
+    // Returns current label assigned to input site
+    inline LabelID whatLabel(SiteID site) {
+      assert(site >= 0 && site < m_num_sites);
+      return(m_labeling[site]);
+    };
+
+    // This function can be used to change the label of any site at any time
+    inline void setLabel(SiteID site, LabelID label) {
+      assert(label >= 0 && label < m_num_labels && site >= 0 && site < m_num_sites);
+      m_labeling[site] = label;
+    };
+
+    // setLabelOrder(false) sets the order to be not random; setLabelOrder(true)
+    // sets the order to random. By default, the labels are visited in non-random order
+    // for both the swap and alpha-expansion moves
+    void setLabelOrder(bool RANDOM_LABEL_ORDER);
+
+    // returns total energy
+    EnergyType compute_energy();
+
+    // Returns Data Energy of current labeling
+    EnergyType giveDataEnergy();
+
+    // Returns Smooth Energy of current labeling
+    EnergyType giveSmoothEnergy();
+
+    // For advanced users who want to squeeze maximum performance out of
+    // their custom functors. By specializing the GCoptimization class
+    // (via this method), the compiler knows the exact class you intend
+    // to use to compute costs. The compiler then inlines your compute
+    // function in all the right places, provided it's not virtual.
+    // The functor class need not derive from anything in this case.
+    template <typename UserFunctor> void specializeDataCostFunctor(const UserFunctor f);
+    template <typename UserFunctor> void specializeSmoothCostFunctor(const UserFunctor f);
+
+  protected:
+
+    LabelID m_num_labels;
+    SiteID m_num_sites;
+    LabelID *m_labeling;
+    SiteID  *m_lookupSiteVar; // holds index of variable corresponding to site participating in a move,
+    // -1 for nonparticipating site
+    LabelID *m_labelTable;    // to figure out label order in which to do expansion/swaps
+    int m_random_label_order;
+    EnergyTermType* m_datacostIndividual;
+    EnergyTermType* m_smoothcostIndividual;
+
+    void*   m_datacostFn;
+    void*   m_smoothcostFn;
+
+    EnergyType (GCoptimization::*m_giveDataEnergyInternal)();
+    EnergyType (GCoptimization::*m_giveSmoothEnergyInternal)();
+    void (GCoptimization::*m_set_up_n_links_expansion)(SiteID, LabelID, Energy*, VarID*, SiteID*);
+    void (GCoptimization::*m_set_up_t_links_expansion)(SiteID, LabelID, Energy*, VarID*, SiteID*);
+    void (GCoptimization::*m_set_up_n_links_swap)(SiteID, LabelID, LabelID, Energy*, VarID*, SiteID*);
+    void (GCoptimization::*m_set_up_t_links_swap)(SiteID, LabelID, LabelID, Energy*, VarID*, SiteID*);
+    void (*m_datacostFnDelete)(void* f);
+    void (*m_smoothcostFnDelete)(void* f);
+
+    // returns a pointer to the neighbors of a site and the weights
+    virtual void giveNeighborInfo(SiteID site, SiteID *numSites, SiteID **neighbors, EnergyTermType **weights) = 0;
+
+    virtual bool readyToOptimise();
+
+    template <typename DataCostT>
+    void set_up_t_links_expansion(SiteID size, LabelID alpha_label, Energy *e, VarID *variables, SiteID *activeSites );
+
+    template <typename DataCostT>
+    void set_up_t_links_swap(SiteID size, LabelID alpha_label, LabelID beta_label, Energy *e, VarID *variables, SiteID *activeSites );
+
+    template <typename SmoothCostT>
+    void set_up_n_links_expansion(SiteID size, LabelID alpha_label, Energy *e, VarID *variables, SiteID *activeSites );
+
+    template <typename SmoothCostT>
+    void set_up_n_links_swap(SiteID size, LabelID alpha_label, LabelID beta_label, Energy *e, VarID *variables, SiteID *activeSites );
+
+
+    // Returns Data Energy of current labeling
+    template <typename DataCostT>
+    EnergyType giveDataEnergyInternal();
+
+    // Returns Smooth Energy of current labeling
+    template <typename SmoothCostT>
+    EnergyType giveSmoothEnergyInternal();
+
+    template <typename Functor>
+    static void deleteFunctor(void* f) {
+      delete reinterpret_cast<Functor*>(f);
+    }
+
+    struct DataCostFnFromArray {
+      DataCostFnFromArray(EnergyTermType* theArray, LabelID num_labels)
+          : m_array(theArray), m_num_labels(num_labels) {}
+      OLGA_INLINE EnergyTermType compute(SiteID s, LabelID l) {
+        return m_array[s*m_num_labels+l];
+      }
+
+    private:
+      const EnergyTermType* const m_array;
+      const LabelID m_num_labels;
+    };
+
+    struct DataCostFnFromFunction {
+      DataCostFnFromFunction(DataCostFn fn): m_fn(fn) {}
+      OLGA_INLINE EnergyTermType compute(SiteID s, LabelID l) {
+        return m_fn(s, l);
+      }
+    private:
+      const DataCostFn m_fn;
+    };
+
+    struct DataCostFnFromFunctionExtra {
+      DataCostFnFromFunctionExtra(DataCostFnExtra fn, void *extraData): m_fn(fn), m_extraData(extraData) {}
+      OLGA_INLINE EnergyTermType compute(SiteID s, LabelID l) {
+        return m_fn(s, l, m_extraData);
+      }
+    private:
+      const DataCostFnExtra m_fn;
+      void *m_extraData;
+    };
+
+    struct SmoothCostFnFromArray {
+      SmoothCostFnFromArray(EnergyTermType* theArray, LabelID num_labels)
+          : m_array(theArray), m_num_labels(num_labels) {}
+      OLGA_INLINE EnergyTermType compute(SiteID s1, SiteID s2, LabelID l1, LabelID l2) {
+        return m_array[l1*m_num_labels+l2];
+      }
+    private:
+      const EnergyTermType* const m_array;
+      const LabelID m_num_labels;
+    };
+
+    struct SmoothCostFnFromFunction {
+      SmoothCostFnFromFunction(SmoothCostFn fn)
+          : m_fn(fn) {}
+      OLGA_INLINE EnergyTermType compute(SiteID s1, SiteID s2, LabelID l1, LabelID l2) {
+        return m_fn(s1, s2, l1, l2);
+      }
+    private:
+      const SmoothCostFn m_fn;
+    };
+
+    struct SmoothCostFnFromFunctionExtra {
+      SmoothCostFnFromFunctionExtra(SmoothCostFnExtra fn, void *extraData)
+          : m_fn(fn), m_extraData(extraData) {}
+      OLGA_INLINE EnergyTermType compute(SiteID s1, SiteID s2, LabelID l1, LabelID l2) {
+        return m_fn(s1, s2, l1, l2, m_extraData);
+      }
+    private:
+      const SmoothCostFnExtra m_fn;
+      void *m_extraData;
+    };
+
+    void handleError(const char *message);
+  private:
+    void solveExpansion(SiteID size, SiteID *activeSites, LabelID alpha_label);
+    EnergyType oneExpansionIteration();
+    void set_up_expansion_energy(SiteID size, LabelID alpha_label, Energy *e, VarID *variables, SiteID *activeSites );
+
+    void solveSwap(SiteID size, SiteID *activeSites, LabelID alpha_label, LabelID beta_label);
+    // Peforms one iteration (one pass over all pairs of labels)  of swap algorithm
+    EnergyType oneSwapIteration();
+    void set_up_swap_energy(SiteID size, LabelID alpha_label, LabelID beta_label,
+                            Energy* e, Energy::Var *variables, SiteID *activeSites);
+
+    void scramble_label_table();
+};
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+// Use this derived class for grid graphs
+//////////////////////////////////////////////////////////////////////////////////////////////////
+
+class GCoptimizationGridGraph: public GCoptimization
+{
+  public:
+    GCoptimizationGridGraph(SiteID width, SiteID height, LabelID num_labels);
+    virtual ~GCoptimizationGridGraph();
+
+    void setSmoothCostVH(EnergyTermType *smoothArray, EnergyTermType *vCosts, EnergyTermType *hCosts);
+    virtual bool readyToOptimise();
+
+  protected:
+    virtual void giveNeighborInfo(SiteID site, SiteID *numSites, SiteID **neighbors, EnergyTermType **weights);
+    EnergyTermType m_unityWeights[4];
+    int m_weightedGraph;  // true if spatially varying w_pq's are present. False otherwise.
+
+  private:
+    SiteID m_width;
+    SiteID m_height;
+    SiteID *m_numNeighbors;              // holds num of neighbors
+    SiteID *m_neighbors;                 // holds neighbor indexes
+    EnergyTermType *m_neighborsWeights;    // holds neighbor weights
+
+    void setupNeighbData(SiteID startY, SiteID endY, SiteID startX, SiteID endX, SiteID maxInd, SiteID *indexes);
+    void computeNeighborWeights(EnergyTermType *vCosts, EnergyTermType *hCosts);
+
+};
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+
+class GCoptimizationGeneralGraph: public GCoptimization
+{
+
+  public:
+    // This is the constructor for non-grid graphs. Neighborhood structure must  be specified by
+    // setNeighbors()  function
+    GCoptimizationGeneralGraph(SiteID num_sites, LabelID num_labels);
+    virtual ~GCoptimizationGeneralGraph();
+
+    virtual bool readyToOptimise();
+
+    // Makes site1 and site2 neighbors of each other. Can be called only 1 time for each
+    // unordered pair of sites. Parameter weight can be used to set spacially varying terms
+    // If the desired penalty for neighboring sites site1 and site2 is
+    // V(label1,label2) = weight*SmoothnessPenalty(label1,label2), then
+    // member function setLabel should be called as: setLabel(site1,site2,weight)
+    void setNeighbors(SiteID site1, SiteID site2, EnergyTermType weight = 1);
+
+    // passes pointers to arrays storing neighbor information
+    // numNeighbors[i] is the number of neighbors for site i
+    // neighborsIndexes[i] is a pointer to the array storing the sites which are neighbors to site i
+    // neighborWeights[i] is a pointer to array storing the weights between site i and its neighbors
+    // in the same order as neighborIndexes[i] stores the indexes
+    void setAllNeighbors(SiteID *numNeighbors, SiteID **neighborsIndexes, EnergyTermType **neighborsWeights);
+
+  protected:
+    virtual void giveNeighborInfo(SiteID site, SiteID *numSites, SiteID **neighbors, EnergyTermType **weights);
+
+  private:
+
+    typedef struct NeighborStruct {
+      SiteID  to_node;
+      EnergyTermType weight;
+    } Neighbor;
+
+
+    LinkedBlockList *m_neighbors;
+    bool m_needToFinishSettingNeighbors;
+    SiteID *m_numNeighbors;
+    SiteID **m_neighborsIndexes;
+    EnergyTermType **m_neighborsWeights;
+    bool m_needTodeleteNeighbors;
+
+
+    //Call this function when you are finished setting neibhbors
+    void finishSettingNeighbors();
+
+
+};
+
+
+/////////////////////////////////////////////////////////////////////
+// Class for handling errors
+/////////////////////////////////////////////////////////////////////
+
+class GCException
+{
+  public:
+    const char* message;
+    GCException( const char* m ) {
+      message = m;
+    }
+    void Report() {
+      printf("\n%s\n", message);
+      exit(0);
+    }
+};
+
+
+
+
+////////////////////////////////////////////////////////////////////
+// Methods
+////////////////////////////////////////////////////////////////////
+
+template <typename UserFunctor>
+void GCoptimization::specializeDataCostFunctor(const UserFunctor f) {
+  if ( m_datacostFn ) handleError("Data Costs are already initialized");
+
+  m_datacostFn = new UserFunctor(f);
+  m_datacostFnDelete         = &GCoptimization::deleteFunctor<UserFunctor>;
+  m_giveDataEnergyInternal   = &GCoptimization::giveDataEnergyInternal<UserFunctor>;
+  m_set_up_t_links_expansion = &GCoptimization::set_up_t_links_expansion<UserFunctor>;
+  m_set_up_t_links_swap      = &GCoptimization::set_up_t_links_swap<UserFunctor>;
+}
+
+template <typename UserFunctor>
+void GCoptimization::specializeSmoothCostFunctor(const UserFunctor f) {
+  if ( m_smoothcostFn ) handleError("Smoothness Costs are already initialized");
+
+  m_smoothcostFn = new UserFunctor(f);
+  m_smoothcostFnDelete       = &GCoptimization::deleteFunctor<UserFunctor>;
+  m_giveSmoothEnergyInternal = &GCoptimization::giveSmoothEnergyInternal<UserFunctor>;
+  m_set_up_n_links_expansion = &GCoptimization::set_up_n_links_expansion<UserFunctor>;
+  m_set_up_n_links_swap      = &GCoptimization::set_up_n_links_swap<UserFunctor>;
+}
+
+//-------------------------------------------------------------------
+template <typename DataCostT>
+GCoptimization::EnergyType GCoptimization::giveDataEnergyInternal()
+{
+
+  EnergyType eng = (EnergyType) 0;
+
+  DataCostT* tc = (DataCostT*)m_datacostFn;
+
+  for ( SiteID i = 0; i < m_num_sites; i++ )
+  {
+    assert(m_labeling[i] >= 0 && m_labeling[i] < m_num_labels);
+    eng = eng + tc->compute(i, m_labeling[i]);
+  }
+
+  return(eng);
+}
+
+//-------------------------------------------------------------------
+template <typename SmoothCostT>
+GCoptimization::EnergyType GCoptimization::giveSmoothEnergyInternal()
+{
+
+  EnergyType eng = (EnergyType) 0;
+  SiteID i, numN, *nPointer, nSite, n;
+  EnergyTermType *weights;
+
+  SmoothCostT* sc = (SmoothCostT*) m_smoothcostFn;
+
+  for ( i = 0; i < m_num_sites; i++ )
+  {
+    giveNeighborInfo(i, &numN, &nPointer, &weights);
+
+    for ( n = 0; n < numN; n++ )
+    {
+      nSite = nPointer[n];
+      if ( nSite < i ) eng =
+          eng + weights[n] * (sc->compute(i, nSite, m_labeling[i], m_labeling[nSite]));
+    }
+  }
+
+  return(eng);
+}
+
+
+//-------------------------------------------------------------------//
+//                  METHODS for EXPANSION MOVES                      //
+//-------------------------------------------------------------------//
+
+template <typename DataCostT>
+void GCoptimization::set_up_t_links_expansion(SiteID size, LabelID alpha_label, Energy *e,
+    VarID *variables, SiteID *activeSites )
+{
+  DataCostT* dc = (DataCostT*)m_datacostFn;
+
+  for ( SiteID i = 0; i < size; i++ )
+  {
+    e -> add_term1(variables[i], dc->compute(activeSites[i], alpha_label),
+                   dc->compute(activeSites[i], m_labeling[activeSites[i]]));
+  }
+}
+
+//-------------------------------------------------------------------
+
+template <typename SmoothCostT>
+void GCoptimization::set_up_n_links_expansion(SiteID size, LabelID alpha_label, Energy *e,
+    VarID *variables, SiteID *activeSites )
+{
+  SiteID i, nSite, site, n, nNum, *nPointer;
+  EnergyTermType *weights;
+
+  SmoothCostT* sc = (SmoothCostT*)m_smoothcostFn;
+
+  for ( i = size - 1; i >= 0; i-- )
+  {
+    site = activeSites[i];
+
+    giveNeighborInfo(site, &nNum, &nPointer, &weights);
+    for ( n = 0; n < nNum; n++ )
+    {
+      nSite = nPointer[n];
+
+
+      if ( nSite < site )
+      {
+        if ( m_lookupSiteVar[nSite] != -1 )
+          e ->add_term2(variables[i], variables[m_lookupSiteVar[nSite]],
+                        sc->compute(site, nSite, alpha_label, alpha_label)*weights[n],
+                        sc->compute(site, nSite, alpha_label, m_labeling[nSite])*weights[n],
+                        sc->compute(site, nSite, m_labeling[site], alpha_label)*weights[n],
+                        sc->compute(site, nSite, m_labeling[site], m_labeling[nSite])*weights[n]);
+        else   e ->add_term1(variables[i], sc->compute(site, nSite, alpha_label, m_labeling[nSite])*weights[n],
+                               sc->compute(site, nSite, m_labeling[site], m_labeling[nSite])*weights[n]);
+      }
+      else
+      {
+        if (m_lookupSiteVar[nSite] == -1 )
+          e ->add_term1(variables[i], sc->compute(site, nSite, alpha_label, m_labeling[nSite])*weights[n],
+                        sc->compute(site, nSite, m_labeling[site], m_labeling[nSite])*weights[n]);
+      }
+    }
+  }
+}
+
+
+//-------------------------------------------------------------------//
+//                  METHODS for SWAP MOVES                           //
+//-------------------------------------------------------------------//
+
+
+template <typename DataCostT>
+void GCoptimization::set_up_t_links_swap(SiteID size, LabelID alpha_label, LabelID beta_label,
+    Energy *e, VarID *variables, SiteID *activeSites )
+{
+  DataCostT* dc = (DataCostT*)m_datacostFn;
+
+  for ( SiteID i = 0; i < size; i++ )
+  {
+    e -> add_term1(variables[i], dc->compute(activeSites[i], alpha_label),
+                   dc->compute(activeSites[i], beta_label) );
+  }
+}
+
+//-------------------------------------------------------------------
+
+template <typename SmoothCostT>
+void GCoptimization::set_up_n_links_swap(SiteID size, LabelID alpha_label, LabelID beta_label,
+    Energy *e, VarID *variables, SiteID *activeSites )
+{
+  SiteID i, nSite, site, n, nNum, *nPointer;
+  EnergyTermType *weights;
+
+  SmoothCostT* sc = (SmoothCostT*)m_smoothcostFn;
+
+  for ( i = size - 1; i >= 0; i-- )
+  {
+    site = activeSites[i];
+
+    giveNeighborInfo(site, &nNum, &nPointer, &weights);
+    for ( n = 0; n < nNum; n++ )
+    {
+      nSite = nPointer[n];
+
+      if ( nSite < site )
+      {
+        if ( m_lookupSiteVar[nSite] != -1 )
+          e ->add_term2(variables[i], variables[m_lookupSiteVar[nSite]],
+                        sc->compute(site, nSite, alpha_label, alpha_label)*weights[n],
+                        sc->compute(site, nSite, alpha_label, beta_label)*weights[n],
+                        sc->compute(site, nSite, beta_label, alpha_label)*weights[n],
+                        sc->compute(site, nSite, beta_label, beta_label)*weights[n]);
+        else   e ->add_term1(variables[i], sc->compute(site, nSite, alpha_label, m_labeling[nSite])*weights[n],
+                               sc->compute(site, nSite, beta_label, m_labeling[nSite])*weights[n]);
+      }
+      else
+      {
+        if (m_lookupSiteVar[nSite] == -1 )
+          e ->add_term1(variables[i], sc->compute(site, nSite, alpha_label, m_labeling[nSite])*weights[n],
+                        sc->compute(site, nSite, beta_label, m_labeling[nSite])*weights[n]);
+      }
+    }
+  }
+}
+
+} //namespace
+
+#endif

mrf/mrfmin/ICM.cpp

@@ -0,0 +1,328 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "ICM.h"
+
+using namespace OBJREC;
+
+#define m_D(pix,l)  m_D[(pix)*m_nLabels+(l)]
+#define m_V(l1,l2)  m_V[(l1)*m_nLabels+(l2)]
+
+
+        
+
+
+ICM::ICM(int width, int height, int nLabels,EnergyFunction *eng):MRF(width,height,nLabels,eng)
+{
+    m_needToFreeV = 0;
+    initializeAlg();
+}
+ICM::ICM(int nPixels, int nLabels,EnergyFunction *eng):MRF(nPixels,nLabels,eng)
+{
+    m_needToFreeV = 0;
+    initializeAlg();
+}
+
+ICM::~ICM()
+{ 
+    delete[] m_answer;
+    if (!m_grid_graph) delete[] m_neighbors;
+    if ( m_needToFreeV ) delete[] m_V;
+}
+
+
+void ICM::initializeAlg()
+{
+    m_answer = (Label *) new Label[m_nPixels];
+    if ( !m_answer ){printf("\nNot enough memory, exiting");exit(0);}
+
+    if (!m_grid_graph)
+    {
+        m_neighbors = (LinkedBlockList *) new LinkedBlockList[m_nPixels];
+        if (!m_neighbors) {printf("Not enough memory,exiting");exit(0);};
+    }
+}
+
+void ICM::clearAnswer()
+{
+    memset(m_answer, 0, m_nPixels*sizeof(Label));
+}
+
+void ICM::setNeighbors(int pixel1, int pixel2, CostVal weight)
+{
+    assert(!m_grid_graph);
+    assert(pixel1 < m_nPixels && pixel1 >= 0 && pixel2 < m_nPixels && pixel2 >= 0);
+
+
+    Neighbor *temp1 = (Neighbor *) new Neighbor;
+    Neighbor *temp2 = (Neighbor *) new Neighbor;
+
+    if ( !temp1 || ! temp2 ) {printf("\nNot enough memory, exiting");exit(0);}
+
+    temp1->weight  = weight;
+    temp1->to_node = pixel2;
+
+    temp2->weight  = weight;
+    temp2->to_node = pixel1;
+
+    m_neighbors[pixel1].addFront(temp1);
+    m_neighbors[pixel2].addFront(temp2);
+}
+
+
+MRF::EnergyVal ICM::smoothnessEnergy()
+{
+    EnergyVal eng = (EnergyVal) 0;
+    EnergyVal weight;
+    int x,y,pix,i;
+
+    if ( m_grid_graph )
+    {
+        if ( m_smoothType != FUNCTION  )
+        {
+            for ( y = 0; y < m_height; y++ )
+                for ( x = 1; x < m_width; x++ )
+                {
+                    pix    = x+y*m_width;
+                    weight = m_varWeights ? m_horizWeights[pix-1] :  1;
+                    eng = eng + m_V(m_answer[pix],m_answer[pix-1])*weight;
+                }
+
+            for ( y = 1; y < m_height; y++ )
+                for ( x = 0; x < m_width; x++ )
+                {
+                    pix = x+y*m_width;
+                    weight = m_varWeights ? m_vertWeights[pix-m_width] :  1;
+                    eng = eng + m_V(m_answer[pix],m_answer[pix-m_width])*weight;
+                }
+        }
+        else
+        {
+            for ( y = 0; y < m_height; y++ )
+                for ( x = 1; x < m_width; x++ )
+                {
+                    pix = x+y*m_width;
+                    eng = eng + m_smoothFn(pix,pix-1,m_answer[pix],m_answer[pix-1]);
+                }
+
+            for ( y = 1; y < m_height; y++ )
+                for ( x = 0; x < m_width; x++ )
+                {
+                    pix = x+y*m_width;
+                    eng = eng + m_smoothFn(pix,pix-m_width,m_answer[pix],m_answer[pix-m_width]);
+                }
+        }
+    }
+    else
+    {
+        
+        Neighbor *temp; 
+
+        if ( m_smoothType != FUNCTION  )
+        {
+            for ( i = 0; i < m_nPixels; i++ )
+                if ( !m_neighbors[i].isEmpty() )
+                {
+                    m_neighbors[i].setCursorFront();
+                    while ( m_neighbors[i].hasNext() )
+                    {
+                        temp = (Neighbor *) m_neighbors[i].next();
+
+                        if ( i < temp->to_node )
+                            eng = eng + m_V(m_answer[i],m_answer[temp->to_node])*(temp->weight);
+                    }
+                }
+        }
+        else
+        {
+            for ( i = 0; i < m_nPixels; i++ )
+                if ( !m_neighbors[i].isEmpty() )
+                {
+                    m_neighbors[i].setCursorFront();
+                    while ( m_neighbors[i].hasNext() )
+                    {
+                        temp = (Neighbor *) m_neighbors[i].next();
+                        if ( i < temp->to_node )
+                            eng = eng + m_smoothFn(i,temp->to_node, m_answer[i],m_answer[temp->to_node]);
+                }
+            }
+        }
+        
+    }
+
+    return(eng);
+}
+
+
+
+MRF::EnergyVal ICM::dataEnergy()
+{
+    EnergyVal eng = (EnergyVal) 0;
+
+    
+    if ( m_dataType == ARRAY) 
+    {
+        for ( int i = 0; i < m_nPixels; i++ )
+            eng = eng + m_D(i,m_answer[i]);
+    }
+    else
+    {
+        for ( int i = 0; i < m_nPixels; i++ )
+            eng = eng + m_dataFn(i,m_answer[i]);
+    }
+    return(eng);
+
+}
+
+
+void ICM::setData(DataCostFn dcost)
+{
+    m_dataFn = dcost;
+}
+
+void ICM::setData(CostVal* data)
+{
+    m_D = data;
+}
+
+
+void ICM::setSmoothness(SmoothCostGeneralFn cost)
+{
+    m_smoothFn = cost;
+}
+void ICM::setSmoothness(CostVal* V)
+{
+    m_V = V;
+}
+
+
+void ICM::setSmoothness(int smoothExp,CostVal smoothMax, CostVal lambda)
+{
+    int i, j;
+    CostVal cost;
+
+
+    m_needToFreeV = 1;
+
+    m_V = (CostVal *) new CostVal[m_nLabels*m_nLabels*sizeof(CostVal)];
+    if (!m_V) { fprintf(stderr, "Not enough memory!\n"); exit(1); }
+
+
+    for (i=0; i<m_nLabels; i++)
+        for (j=i; j<m_nLabels; j++)
+        {
+            cost = (CostVal) ((smoothExp == 1) ? j - i : (j - i)*(j - i));
+            if (cost > smoothMax) cost = smoothMax;
+            m_V[i*m_nLabels + j] = m_V[j*m_nLabels + i] = cost*lambda;
+        }
+
+}
+
+
+void ICM::setCues(CostVal* hCue, CostVal* vCue)
+{
+    m_horizWeights = hCue;
+    m_vertWeights  = vCue;
+}
+
+
+void ICM::optimizeAlg(int nIterations)
+{
+    int x, y, i, j, n;
+    Label* l;
+    CostVal* dataPtr;
+    CostVal *D = (CostVal *) new CostVal[m_nLabels];
+    if ( !D ) {printf("\nNot enough memory, exiting");exit(0);}
+
+    if ( !m_grid_graph) {printf("\nICM is not implemented for nongrids yet!");exit(1);}
+
+    for ( ; nIterations > 0; nIterations --)
+    {
+        n = 0;
+        l = m_answer;
+        dataPtr = m_D;
+
+        for (y=0; y<m_height; y++)
+        for (x=0; x<m_width; x++, l++, dataPtr+=m_nLabels, n++)
+        {
+            // set array D
+            if (m_dataType == FUNCTION)
+            {
+                for (i=0; i<m_nLabels; i++)
+                {
+                    D[i] = m_dataFn(x+y*m_width, i);
+                }
+            }
+            else memcpy(D, dataPtr, m_nLabels*sizeof(CostVal));
+            
+
+            // add smoothness costs
+            if (m_smoothType == FUNCTION)
+            {
+                if (x > 0)
+                {
+                    j = *(l-1);
+                    for (i=0; i<m_nLabels; i++) D[i] += m_smoothFn(x+y*m_width-1, x+y*m_width, j, i);
+                }
+                if (y > 0)
+                {
+                    j = *(l-m_width);
+                    for (i=0; i<m_nLabels; i++) D[i] += m_smoothFn(x+y*m_width-m_width,x+y*m_width , j, i);
+                }
+                if (x < m_width-1)
+                {
+                    j = *(l+1);
+                    for (i=0; i<m_nLabels; i++) D[i] += m_smoothFn(x+y*m_width+1, x+y*m_width, i, j);
+                }
+                if (y < m_height-1)
+                {
+                    j = *(l+m_width);
+                    for (i=0; i<m_nLabels; i++) D[i] += m_smoothFn(x+y*m_width+m_width, x+y*m_width, i, j);
+                }
+            }
+            else
+            {
+                if (x > 0)
+                {
+                    j = *(l-1);
+                    CostVal lambda = (m_varWeights) ? m_horizWeights[n-1] : 1;
+                    for (i=0; i<m_nLabels; i++) D[i] += lambda * m_V[j*m_nLabels + i];
+                }
+                if (y > 0)
+                {
+                    j = *(l-m_width);
+                    CostVal lambda = (m_varWeights) ? m_vertWeights[n-m_width] : 1;
+                    for (i=0; i<m_nLabels; i++) D[i] += lambda * m_V[j*m_nLabels + i];
+                }
+                if (x < m_width-1)
+                {
+                    j = *(l+1);
+                    CostVal lambda = (m_varWeights) ? m_horizWeights[n] : 1;
+                    for (i=0; i<m_nLabels; i++) D[i] += lambda * m_V[j*m_nLabels + i];
+                }
+                if (y < m_height-1)
+                {
+                    j = *(l+m_width);
+                    CostVal lambda = (m_varWeights) ? m_vertWeights[n] : 1;
+                    for (i=0; i<m_nLabels; i++) D[i] += lambda * m_V[j*m_nLabels + i];
+                }
+            }
+
+            // compute minimum of D, set new label for (x,y)
+            CostVal D_min = D[0];
+            *l = 0;
+            for (i=1; i<m_nLabels; i++)
+            {
+                if (D_min > D[i])
+                {
+                    D_min = D[i];
+                    *l = i;
+                }
+            }
+        }
+    }
+
+    delete[] D;
+}
+