#ifdef NICE_USELIB_OPENMP
#include <omp.h>
#endif

#include "SemSegRegionBased.h"

#include <iostream>

#include "vislearning/cbaselib/CachedExample.h"
#include "vislearning/classifier/fpclassifier/randomforest/FPCRandomForests.h"
#include "vislearning/classifier/fpclassifier/logisticregression/FPCSMLR.h"

#include <objrec/iclassifier/icgeneric/CSGeneric.h>
#include "vislearning/features/fpfeatures/PixelPairFeature.h"
#include "vislearning/classifier/genericClassifierSelection.h"

#include "SemSegTools.h"

#include "objrec/segmentation/RSMeanShift.h"
#include "objrec/segmentation/RSCache.h"
#include "objrec/segmentation/RSGraphBased.h"

#include "vislearning/baselib/Globals.h"

#include <vislearning/cbaselib/VectorFeature.h>

#include "vislearning/features/fpfeatures/SparseVectorFeature.h"
#include "vislearning/features/localfeatures/LFColorWeijer.h"
#include "vislearning/features/localfeatures/LFColorSande.h"
#include "vislearning/features/localfeatures/LocalFeatureSift.h"
#include "vislearning/features/localfeatures/LocalFeatureOpponnentSift.h"
#include "vislearning/features/localfeatures/LocalFeatureLFInterface.h"
#include "vislearning/features/localfeatures/LocalFeatureRGBSift.h"
#include "vislearning/features/localfeatures/LFCache.h"

#include "objrec/features/regionfeatures/RFColor.h"
#include "objrec/features/regionfeatures/RFHoG.h"
#include "objrec/features/regionfeatures/RFBoV.h"
#include "objrec/features/regionfeatures/RFBoVCodebook.h"
#include "objrec/features/regionfeatures/RFCsurka.h"

#include "objrec/iclassifier/codebook/CodebookRandomForest.h"

#include "vislearning/math/cluster/GMM.h"

#undef DEMO
#undef WRITEFEATS

using namespace OBJREC;
using namespace std;
using namespace NICE;

#define DEBUG_PRINTS

SemSegRegionBased::SemSegRegionBased ( const Config *c, const MultiDataset *md )
    : SemanticSegmentation ( c, & ( md->getClassNames ( "train" ) ) )
{
#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased Constructor starts" << endl;
#endif
  conf = c;

  save_cache = conf->gB ( "SemSegRegion", "save_cache", true );
  read_cache = conf->gB ( "SemSegRegion", "read_cache", false );
  classifiercache = conf->gS ( "SemSegRegion", "cache", "classifier.data" );
  cache = conf->gS ( "cache", "root", "tmp/" );
  bool colorw = conf->gB ( "SemSegRegion", "colorw", false );
  bool bov = conf->gB ( "SemSegRegion", "bov", false );
  bool hog = conf->gB ( "SemSegRegion", "hog", false );
  bool structf = conf->gB ( "SemSegRegion", "struct", false );
  string classifiertype = conf->gS ( "SemSegRegion", "classifier", "RF" );
  bool usegcopt = conf->gB ( "SemSegRegion", "gcopt", false );
  bool bovmoosmann = conf->gB ( "SemSegRegion", "bovmoosmann", false );
  bool csurka = conf->gB ( "SemSegRegion", "csurka", false );

  if ( colorw )
  {
    LocalFeature *lfcw = new LFColorWeijer ( conf );
    rfc = new RFColor ( conf, lfcw );
  }
  else
  {
    rfc = NULL;
  }

  if ( hog )
  {
    rfhog = new RFHoG ( conf );
  }
  else
  {
    rfhog = NULL;
  }

  if ( structf )
  {
    rfstruct = new RFStruct ( conf );
  }
  else
  {
    rfstruct = NULL;
  }

  LocalFeature *lfcache = NULL;

  if ( bov || bovmoosmann || csurka )
  {
    string ftype = conf->gS ( "BOV", "feature", "sift" );

    siftFeats = NULL;

    if ( ftype == "sift" )
    {
      siftFeats = new LocalFeatureSift ( conf );
      lfcache = new LFCache ( conf, siftFeats );
    }

    if ( ftype == "osift" )
    {
      siftFeats = new LocalFeatureOpponnentSift ( conf );
      lfcache = new LFCache ( conf, siftFeats );
    }

    if ( ftype == "rsift" )
    {
      siftFeats = new LocalFeatureRGBSift ( conf );
      lfcache = new LFCache ( conf, siftFeats );
    }

    if ( ftype == "sande" )
    {
      LocalFeatureRepresentation *sande = new LFColorSande ( conf, "LFColorSandeTrain" );
      siftFeats = new LocalFeatureLFInterface ( conf, sande );

      LocalFeatureRepresentation *sande2 = new LFColorSande ( conf, "LFColorSandeTest" );
      LocalFeature *siftFeats2 = new LocalFeatureLFInterface ( conf, sande2 );
      lfcache = new LFCache ( conf, siftFeats2 );
    }

    if ( siftFeats == NULL )
    {
      throw "please choose one of the following features für BOV: osift, rsift, sift, sande";
    }
  }

  if ( csurka )
  {
    rfCsurka = new RFCsurka ( conf, lfcache );
  }
  else
  {
    rfCsurka = NULL;
  }

  if ( bov )
  {
    rfbov = new RFBoV ( conf, lfcache );
  }
  else
  {
    rfbov = NULL;
  }

  if ( bovmoosmann )
  {
    rfbovcrdf = new RFBoVCodebook ( conf, lfcache );
  }
  else
  {
    rfbovcrdf = NULL;
  }

  // setting classifier
  fpc = NULL;
  vclassifier = NULL;

  if ( classifiertype == "RF" )
  {
    fpc = new FPCRandomForests ( conf, "ClassifierForest" );
  }
  else if ( classifiertype == "SMLR" )
  {
    fpc = new FPCSMLR ( conf, "ClassifierSMLR" );
  }
  else if ( classifiertype == "VECC" )
  {
    vclassifier = CSGeneric::selectVecClassifier ( conf, "vecClassifier" );
  }
  else
  {
    throw "classifiertype not (yet) supported";
  }

  if ( fpc != NULL )
    fpc->setMaxClassNo ( classNames->getMaxClassno() );
  else if ( vclassifier != NULL )
    vclassifier->setMaxClassNo ( classNames->getMaxClassno() );

  cn = md->getClassNames ( "train" );

  // setting segmentation method
  RegionSegmentationMethod *tmprsm = new RSMeanShift ( conf );
  rsm = new RSCache ( conf, tmprsm );
  //rsm = new RSGraphBased(conf);

  // use global optimization (MRF)
  if ( usegcopt )
    gcopt = new PPGraphCut ( conf );
  else
    gcopt = NULL;

  classifiercache = cache + classifiercache;

  // read training data or start training
  if ( read_cache )
  {
    fprintf ( stderr, "SemSegRegion:: Reading classifier data from %s\n", cache.c_str() );
    if ( fpc != NULL )
      fpc->read ( classifiercache );
    else if ( vclassifier != NULL )
      vclassifier->read ( classifiercache );

    if ( rfCsurka != NULL )
    {
      bool usegmm = conf->gB ( "Csurka", "usegmm", false );
      bool usepca = conf->gB ( "Csurka", "usepca", false );

      if ( usepca || usegmm )
      {
        RFCsurka *_rfcsurka = dynamic_cast< RFCsurka * > ( rfCsurka );

        if ( usepca )
        {
          int pcadim = conf->gI ( "Csurka", "pcadim", 100 );
          PCA *pca = new PCA ( pcadim );
          string pcadst = cache + "/csurka.pca";

          if ( !FileMgt::fileExists ( pcadst ) )
          {
            throw ( pcadst + " not found" );
          }
          else
          {
            pca->read ( pcadst );
          }

          _rfcsurka->setPCA ( pca );
        }

        if ( usegmm )
        {
          int gaussians = conf->gI ( "Csurka", "gaussians", 1024 );
          GMM *g = new GMM ( conf, gaussians );
          string gmmdst = cache + "/csurka.gmm";

          if ( !g->loadData ( cache + "/gmmSIFT" ) )
          {
            throw ( gmmdst + " not found" );
          }

          _rfcsurka->setGMM ( g );
        }
      }
    }

    if ( rfbov != NULL )
    {
      RFBoV *rfbovdyn = dynamic_cast< RFBoV * > ( rfbov );

      int gaussians = conf->gI ( "SIFTTrain", "gaussians", 512 );

      GMM *g = new GMM ( conf, gaussians );
      PCA *pca = new PCA ( 100 );
      string pcadst = cache + "/bov.pca";

      if ( !g->loadData ( cache + "/gmmSIFT" ) || !FileMgt::fileExists ( pcadst ) )
      {
        throw ( "pca or gmm not found" );
      }
      else
      {
        pca->read ( pcadst );
      }
      rfbovdyn->setPCA ( pca );
      rfbovdyn->setGMM ( g );
    }

    fprintf ( stderr, "SemSegRegion:: successfully read\n" );
  }
  else
  {
    train ( md );
  }
#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased Constructor finished" << endl;
#endif
}

SemSegRegionBased::~SemSegRegionBased()
{
#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased Destructor starts" << endl;
#endif
  if ( fpc != NULL )
  {
    delete fpc;
  }
  if ( vclassifier != NULL )
  {
    delete vclassifier;
  }
#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased Destructor finished" << endl;
#endif
}

void SemSegRegionBased::train ( const MultiDataset *md )
{
#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased::train starts" << endl;
#endif

  Examples examples;
  examples.filename = "training";

  const LabeledSet train = * ( *md ) ["train"];

  set<int> forbidden_classes;

  std::string forbidden_classes_s = conf->gS ( "analysis", "donttrain", "" );
  if ( forbidden_classes_s == "" )
  {
    forbidden_classes_s = conf->gS ( "analysis", "forbidden_classes", "" );
  }

  cn.getSelection ( forbidden_classes_s, forbidden_classes );

  if ( gcopt != NULL )
    gcopt->setClassNo ( cn.numClasses() );

  LabeledSet::Permutation perm;

  train.getPermutation ( perm );

  learnHighLevel ( perm );

  //FIXME:Moosmann

  int imgcounter = 0;

  vector<vector<FeatureType> > feats;
  // loop over all training images

  for ( LabeledSet::Permutation::const_iterator i = perm.begin();
        i != perm.end(); i++, imgcounter++ )
  {
    const string fn = i->second->img();
    Globals::setCurrentImgFN ( fn );
    cout << fn << endl;
    NICE::ColorImage cimg ( fn );
    NICE::Matrix mask;
    RegionGraph rg;
    rsm->getGraphRepresentation ( cimg, mask, rg );

#ifdef DEMO
    rsm->visualizeGraphRepresentation ( cimg, mask );
#endif

    // get label
    const LocalizationResult *locResult = i->second->localization();
    NICE::Image pixelLabels ( cimg.width(), cimg.height() );
    pixelLabels.set ( 0 );
    locResult->calcLabeledImage ( pixelLabels, ( *classNames ).getBackgroundClass() );
    getRegionLabel ( mask, rg, pixelLabels );

    getFeats ( cimg, mask, rg, feats );

//#pragma omp critical
    for ( int i = 0; i < rg.size(); i++ )
    {
      int classno = rg[i]->getLabel();
      Example example;
      example.position = imgcounter;
      examples.push_back ( pair<int, Example> ( classno, example ) );
    }
//#pragma omp critical
    if ( gcopt != NULL )
      gcopt->trainImage ( rg );

  }
  cout << "train classifier starts" << endl;
  trainClassifier ( feats, examples );
  cout << "train classifier finished" << endl;

  if ( gcopt != NULL )
    gcopt->finishPP ( cn );

  // clean up
  /*for(int i = 0; i < (int) examples.size(); i++)
  {
   examples[i].second.clean();
  }*/
#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased::train finished" << endl;
#endif
}

void SemSegRegionBased::getRegionLabel ( NICE::Matrix &mask, RegionGraph &rg, NICE::Image &pixelLabels )
{
#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased::getRegionLabel starts" << endl;
#endif
  vector<vector<int> > hists;
  int regionsize = rg.size();
  int xsize = pixelLabels.width();
  int ysize = pixelLabels.height();

  for ( int i = 0; i < regionsize; i++ )
  {
    vector<int> hist ( cn.numClasses(), 0 );
    hists.push_back ( hist );
  }

  for ( int x = 0; x < xsize; x++ )
  {
    for ( int y = 0; y < ysize; y++ )
    {
      int numb = mask ( x, y );
      hists[numb][pixelLabels.getPixel ( x,y ) ]++;
    }
  }

  for ( int i = 0; i < regionsize; i++ )
  {
    int maxval = -numeric_limits<int>::max();
    int smaxval = -numeric_limits<int>::max();
    int maxpos = -1;
    int secondpos = -1;
    for ( int k = 0; k < ( int ) hists[i].size(); k++ )
    {
      if ( maxval < hists[i][k] )
      {
        secondpos = maxpos;
        smaxval = maxval;
        maxval = hists[i][k];
        maxpos = k;
      }
      else
      {
        if ( smaxval < hists[i][k] )
        {
          smaxval = hists[i][k];
          secondpos = k;
        }
      }
    }

    // FIXME: das für alle verbotenen Klassen einbauen
    //if ( forbidden_classes.find ( classno ) != forbidden_classes.end() )

    if ( cn.text ( maxpos ) == "various" && smaxval > 0 )
      rg[i]->setLabel ( secondpos );
    else
      rg[i]->setLabel ( maxpos );
  }
#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased::getRegionLabel finished" << endl;
#endif
}

void SemSegRegionBased::getExample ( const vector<vector<FeatureType> > &feats, Examples &examples )
{
#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased::getExample starts" << endl;
#endif

  for ( int j = 0; j < ( int ) feats.size(); j++ )
  {
    int counter = 0;
    for ( int i = 0; i < ( int ) feats[0].size(); i++, counter++ )
    {
      if ( examples[counter].second.vec == NULL )
      {
        NICE::Vector *vec = new NICE::Vector ( feats[j][i].getVec() );
        examples[counter].second.vec = vec;
      }
      else
      {
        examples[counter].second.vec->append ( feats[j][i].getVec() );
      }
    }
  }
#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased::getExample finished" << endl;
#endif
}

void SemSegRegionBased::getFeaturePool ( const vector<vector<FeatureType> > &feats, FeaturePool &fp )
{
#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased::getFeaturePool starts" << endl;
#endif

  int olddim = 0;
  int fulldim = 0;

  for ( int j = 0; j < ( int ) feats.size(); j++ )
  {
    fulldim += feats[j][0].getDim();
  }

  for ( int j = 0; j < ( int ) feats.size(); j++ )
  {
    int dimension = feats[j][0].getDim();
    for ( int i = olddim ; i < olddim + dimension ; i++ )
    {
      VectorFeature *f = new VectorFeature ( fulldim );
      f->feature_index = i;
      fp.addFeature ( f, 1.0 / dimension );
    }
    olddim += dimension;
  }
#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased::getFeaturePool finished" << endl;
#endif
}

void SemSegRegionBased::trainClassifier ( vector<vector<FeatureType> > &feats, Examples & examples )
{
#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased::trainClassifier starts" << endl;
#endif
  assert ( feats.size() > 0 );
  assert ( feats[0].size() > 0 );

  // delete nonrelevant features
  for ( int i = ( int ) examples.size() - 1; i >= 0; i-- )
  {
    if ( cn.text ( examples[i].first ) == "various" )
    {
      examples.erase ( examples.begin() + i );
      for ( int k = 0; k < ( int ) feats.size(); k++ )
      {
        feats[k].erase ( feats[k].begin() + i );
      }
    }
  }

#ifdef WRITEFEATS
  // mermale in datei schreiben
  ofstream fout ( "trainfeats", ios_base::out );
  //vector<int> ccounter(cn.getMaxClassno(),0);
  //int maxv = 100;
  for ( int i = 0; i < ( int ) examples.size(); i++ )
  {
    //if(ccounter[examples[i].first]++ < maxv)
    //{
    fout << examples[i].first << " ";
    for ( int j = 0; j < ( int ) feats.size(); j++ )
    {
      for ( int k = 0; k < feats[j][i].getDim(); k++ )
      {
        fout << feats[j][i].get ( k ) << " ";
      }
    }
    fout << endl;
    //}
  }
#endif

  if ( fpc != NULL )
  {
    FeaturePool fp;
    getExample ( feats, examples );
    getFeaturePool ( feats, fp );

    fpc->train ( fp, examples );

    fp.destroy();

    if ( save_cache )
    {
      fpc->save ( classifiercache );
    }

//#pragma omp parallel for
    for ( int i = 0; i < ( int ) examples.size(); i++ )
    {
      if ( examples[i].second.vec != NULL )
      {
        delete examples[i].second.vec;
        examples[i].second.vec = NULL;
      }
    }

  }
  else if ( vclassifier != NULL )
  {
    LabeledSetVector lsv;

//#pragma omp parallel for
    for ( int i = 0; i < ( int ) feats[0].size(); i++ )
    {
      NICE::Vector *v = new NICE::Vector ( feats[0][i].getVec() );
      for ( int j = 1; j < ( int ) feats.size(); j++ )
      {
        v->append ( feats[j][i].getVec() );
      }
//#pragma omp critical
      lsv.add_reference ( examples[i].first, v );
    }

    vclassifier->teach ( lsv );
    vclassifier->finishTeaching();
    lsv.clear();
    if ( save_cache )
    {
      vclassifier->save ( classifiercache );
    }
  }
#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased::trainClassifier finished" << endl;
#endif
}

void SemSegRegionBased::classify ( const vector<vector<FeatureType> > &feats, Examples &examples, vector<vector<double> > &probs )
{
#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased::classify starts" << endl;
#endif
  for ( int i = 0; i < ( int ) feats[0].size(); i++ )
  {
    Example example;
    examples.push_back ( pair<int, Example> ( -1, example ) );
  }

  getExample ( feats, examples );

  int nbcl = classNames->getMaxClassno() + 1;

  for ( int i = 0; i < ( int ) examples.size(); i++ )
  {
    vector<double> p;
    ClassificationResult r;

    if ( fpc != NULL )
    {
      r = fpc->classify ( examples[i].second );
    }
    else if ( vclassifier != NULL )
    {
      r = vclassifier->classify ( * ( examples[i].second.vec ) );
    }

    for ( int j = 0 ; j < nbcl; j++ )
    {
      p.push_back ( r.scores[j] );
    }

    probs.push_back ( p );
  }
#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased::classify finished" << endl;
#endif
}

void SemSegRegionBased::semanticseg ( CachedExample *ce, NICE::Image & segresult, NICE::MultiChannelImageT<double> & probabilities )
{
#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased::semanticseg starts" << endl;
#endif
  int xsize, ysize;

  ce->getImageSize ( xsize, ysize );

  probabilities.reInit ( xsize, ysize, classNames->getMaxClassno() + 1);
  std::string currentFile = Globals::getCurrentImgFN();
  NICE::ColorImage cimg ( currentFile );

  NICE::Matrix mask;
  RegionGraph rg;
  rsm->getGraphRepresentation ( cimg, mask, rg );
#ifdef DEMO
  rsm->visualizeGraphRepresentation ( cimg, mask );
#endif
  vector<vector<FeatureType> > feats;

  getFeats ( cimg, mask, rg, feats );

#ifdef WRITEFEATS
  getRegionLabel ( mask, rg, segresult );
  ofstream fout ( "testfeats", ios_base::app );

  for ( int i = 0; i < ( int ) rg.size(); i++ )
  {
    fout << rg[i]->getLabel() << " ";
    for ( int j = 0; j < ( int ) feats.size(); j++ )
    {
      for ( int k = 0; k < feats[j][i].getDim(); k++ )
      {
        fout << feats[j][i].get ( k ) << " ";
      }
    }
    fout << endl;
  }
#endif

  segresult = NICE::Image ( xsize, ysize );
  segresult.set ( 0 );

  Examples examples;

  vector<vector<double> > probs;

  classify ( feats, examples, probs );

  labelRegions ( rg, probs );

  if ( gcopt != NULL )
    gcopt->optimizeImage ( rg, probs );

  labelImage ( segresult, mask, rg );
#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased::semanticseg finished" << endl;
#endif
}

void SemSegRegionBased::labelRegions ( RegionGraph &rg, vector<vector<double> > &probs )
{
#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased::labelRegions starts" << endl;
#endif
  for ( int i = 0; i < rg.size(); i++ )
  {
    int bestclass = -1;
    double bestval = -numeric_limits<int>::max();
    for ( int j = 0; j < ( int ) probs[i].size(); j++ )
    {
      if ( bestval < probs[i][j] )
      {
        bestval = probs[i][j];
        bestclass = j;
      }
    }
    rg[i]->setLabel ( bestclass );
  }
#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased::labelRegions finished" << endl;
#endif
}

void SemSegRegionBased::labelImage ( NICE::Image &segresult, NICE::Matrix &mask, RegionGraph &rg )
{
#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased::labelImage starts" << endl;
#endif
  for ( int y = 0; y < segresult.height(); y++ )
  {
    for ( int x = 0; x < segresult.width(); x++ )
    {
      int r = ( int ) mask ( x, y );
      segresult.setPixel ( x, y, rg[r]->getLabel() );
    }
  }
#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased::labelImage finished" << endl;
#endif
}

void SemSegRegionBased::getFeats ( const NICE::ColorImage &cimg, const NICE::Matrix &mask, const RegionGraph &rg, vector<vector< FeatureType> > &feats ) const
{
#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased::getFeats starts" << endl;
#endif
  string fn = Globals::getCurrentImgFN();
  NICE::Image img ( fn );
  int featnb = 0;

  const int rgcount = rg.size();
  if ( rfc != NULL )
  {
    if ( ( int ) feats.size() <= featnb )
    {
      vector<FeatureType> ftv;
      feats.push_back ( ftv );
    }

    VVector features;
    rfc->extractRGB ( cimg, rg, mask, features );

    assert ( ( int ) features.size() == rgcount );

    for ( int j = 0; j < ( int ) features.size(); j++ )
    {
      feats[featnb].push_back ( FeatureType ( features[j] ) );
    }
#ifdef DEMO
    LFColorWeijer lfc ( conf );
    lfc.visualizeFeatures ( cimg );
#endif

    featnb++;
  }

  if ( rfbov != NULL )
  {
    if ( ( int ) feats.size() <= featnb )
    {
      vector<FeatureType> ftv;
      feats.push_back ( ftv );
    }

    VVector features;
    rfbov->extractRGB ( cimg, rg, mask, features );

    assert ( ( int ) features.size() == rgcount );

    for ( int j = 0; j < ( int ) features.size(); j++ )
    {
      feats[featnb].push_back ( FeatureType ( features[j] ) );
    }

    featnb++;
  }

  if ( rfhog != NULL )
  {
    if ( ( int ) feats.size() <= featnb )
    {
      vector<FeatureType> ftv;
      feats.push_back ( ftv );
    }

    VVector features;

    rfhog->extractRGB ( cimg, rg, mask, features );

    assert ( ( int ) features.size() == rgcount );

    for ( int j = 0; j < ( int ) features.size(); j++ )
    {
      feats[featnb].push_back ( FeatureType ( features[j] ) );
    }

    featnb++;
  }

  if ( rfstruct != NULL )
  {
    if ( ( int ) feats.size() <= featnb )
    {
      vector<FeatureType> ftv;
      feats.push_back ( ftv );
    }

    VVector features;
    rfstruct->extractRGB ( cimg, rg, mask, features );

    for ( int j = 0; j < ( int ) features.size(); j++ )
    {
      feats[featnb].push_back ( FeatureType ( features[j] ) );
    }

    featnb++;
  }

  if ( rfbovcrdf != NULL )
  {
    if ( ( int ) feats.size() <= featnb )
    {
      vector<FeatureType> ftv;
      feats.push_back ( ftv );
    }

    VVector features;
    rfbovcrdf->extractRGB ( cimg, rg, mask, features );

    assert ( ( int ) features.size() == rgcount );

    for ( int j = 0; j < ( int ) features.size(); j++ )
    {
      feats[featnb].push_back ( FeatureType ( features[j] ) );
    }

    featnb++;
  }

  if ( rfCsurka != NULL )
  {
    if ( ( int ) feats.size() <= featnb )
    {
      vector<FeatureType> ftv;
      feats.push_back ( ftv );
    }

    VVector features;

    rfCsurka->extractRGB ( cimg, rg, mask, features );

    assert ( ( int ) features.size() == rgcount );

    for ( int j = 0; j < ( int ) features.size(); j++ )
    {
      feats[featnb].push_back ( FeatureType ( features[j] ) );
    }

    featnb++;

  }

  /* Dummy for new features:
  if(siftFeats != NULL)
  {
   if((int)feats.size() <= featnb)
   {
    vector<FeatureType> ftv;
    feats.push_back(ftv);
   }

   featnb++;
  }
  */

#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased::getFeats finished" << endl;
#endif
}

void SemSegRegionBased::computeLF ( LabeledSet::Permutation perm, VVector &feats, vector<int> &label, Examples &examples, int mode )
{
#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased::computeLF starts" << endl;
#endif
  string sscales = conf->gS ( "SIFTTrain", "scales", "1+2.0+3.0" );
  int grid = conf->gI ( "SIFTTrain", "grid", 20 );
  double fraction = conf->gD ( "SIFTTrain", "fraction", 1.0 );

  set<int> forbidden_classes;

  std::string forbidden_classes_s = conf->gS ( "analysis", "donttrain", "" );
  if ( forbidden_classes_s == "" )
  {
    forbidden_classes_s = conf->gS ( "analysis", "forbidden_classes", "" );
  }
  cn.getSelection ( forbidden_classes_s, forbidden_classes );
  cerr << "forbidden: " << forbidden_classes_s << endl;

  vector<double> scales;
  string::size_type pos = 0;
  string::size_type oldpos = 0;
  while ( pos != string::npos )
  {
    pos = sscales.find ( "+", oldpos );
    string val;
    if ( pos == string::npos )
      val = sscales.substr ( oldpos );
    else
      val = sscales.substr ( oldpos, pos - oldpos );
    double d = atof ( val.c_str() );
    scales.push_back ( d );
    oldpos = pos + 1;
  }

  int fsize = 0;

  string save = cache + "/siftTRAIN.dat";
  string savep = cache + "/siftPostions.dat";

  if ( !FileMgt::fileExists ( save ) || !FileMgt::fileExists ( savep ) )
  {
//FIXME: entfernen
//  vector<int> counter(9,0);
    for ( LabeledSet::Permutation::const_iterator i = perm.begin();
          i != perm.end(); i++ )
    {
      const string fn = i->second->img();
      Globals::setCurrentImgFN ( fn );

      NICE::Image img ( fn );
      NICE::ColorImage cimg ( fn );
      VVector features;
      VVector positions;

      int x0 = grid / 2;
      for ( int y = 0; y < ( int ) img.height(); y += grid )
      {
        for ( int x = x0; x < ( int ) img.width(); x += grid )
        {
          for ( int s = 0; s < ( int ) scales.size(); s++ )
          {
            double r = ( double ) rand() / ( double ) RAND_MAX;
            if ( r < fraction )
            {
              fsize++;
              NICE::Vector vec ( 3 );
              vec[0] = x;
              vec[1] = y;
              vec[2] = scales[s];
              positions.push_back ( vec );
            }
          }
        }
        if ( x0 == 0 )
        {
          x0 = grid / 2;
        }
        else
        {
          x0 = 0;
        }
      }

      siftFeats->getDescriptors ( cimg, positions, features );

      assert ( positions.size() == features.size() );

      const LocalizationResult *locResult = i->second->localization();
      NICE::Image pixelLabels ( cimg.width(), cimg.height() );
      pixelLabels.set ( 0 );
      locResult->calcLabeledImage ( pixelLabels, ( *classNames ).getBackgroundClass() );

      for ( int i = 0; i < ( int ) features.size(); i++ )
      {
        int classno = pixelLabels ( positions[i][0], positions[i][1] );
//    if ( cn.text ( classno ) == "various")
//     continue;

        if ( forbidden_classes.find ( classno ) != forbidden_classes.end() )
          continue;

//    counter[classno]++;
        label.push_back ( classno );
        feats.push_back ( features[i] );
      }
      assert ( label.size() == feats.size() );
    }
    /*  cout << "samples for class: " << endl;
      for(int i = 0; i < 9; i++)
      {
       cout << i << ": " << counter[i] << endl;
      }
    */
    feats.save ( save, 1 );
    ofstream lout ( savep.c_str(), ios_base::out );
    for ( uint i = 0; i < label.size(); i++ )
    {
      lout << label[i] << " ";
    }
    lout.close();
  }
  else
  {
    feats.read ( save, 1 );

    ifstream lin ( savep.c_str(), ios_base::in );
    label.clear();
    for ( int i = 0; i < ( int ) feats.size(); i++ )
    {
      int l;
      lin >> l;
      label.push_back ( l );
    }
  }

  if ( mode == 1 )
  {
    convertVVectorToExamples ( feats, examples, label );
  }
#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased::computeLF finished" << endl;
#endif
}

void SemSegRegionBased::learnHighLevel ( LabeledSet::Permutation perm )
{
#ifdef DEBUG_PRINTS
  cout << "SemSegRegionBased::learnHighLevel starts" << endl;
#endif
  srand ( time ( NULL ) );

  if ( rfbov != NULL || rfbovcrdf != NULL || rfCsurka != NULL )
  {
    if ( rfbov != NULL )
    {
      RFBoV *rfbovdyn = dynamic_cast< RFBoV * > ( rfbov );

      int gaussians = conf->gI ( "SIFTTrain", "gaussians", 512 );
      int pcadim = conf->gI ( "SIFTTrain", "pcadim", 50 );

      GMM *g = new GMM ( conf, gaussians );
      PCA *pca = new PCA ( pcadim );
      string pcadst = cache + "/pca.txt";

      if ( !g->loadData ( cache + "/gmmSIFT" ) || !FileMgt::fileExists ( pcadst ) )
      {
        VVector feats;
        vector<int> label;

        Examples ex;

        computeLF ( perm, feats, label, ex, 0 );

        assert ( feats.size() > 0 );
        initializePCA ( feats, *pca, pcadim, pcadst );

        transformFeats ( feats, *pca );
        cout << "nb of feats for learning gmm: " << feats.size() << endl;
        g->computeMixture ( feats );

        if ( save_cache )
          g->saveData ( cache + "/gmmSIFT" );
      }
      else
      {
        pca->read ( pcadst );
      }

      rfbovdyn->setPCA ( pca );
      rfbovdyn->setGMM ( g );
    }

    if ( rfbovcrdf != NULL || rfCsurka != NULL )
    {
      Examples examples;
      VVector feats;
      vector<int> label;

      computeLF ( perm, feats, label, examples , 1 );

      FeaturePool fp;
      FeaturePool fpsparse;

      int dimension = examples[0].second.vec->size();

      for ( int i = 0 ; i < dimension ; i++ )
      {
        VectorFeature *f = new VectorFeature ( dimension, i );
        fp.addFeature ( f, 1.0 / dimension );

        SparseVectorFeature *fs = new SparseVectorFeature ( dimension, i );
        //fs->feature_index = i;

        fpsparse.addFeature ( fs, 1.0 / dimension );
      }

      if ( rfbovcrdf != NULL )
      {
        RFBoVCodebook *rfbovdyn = dynamic_cast< RFBoVCodebook * > ( rfbovcrdf );

        int maxDepth = conf->gI ( "BoVMoosmann", "maxdepth", 10 );
        int csize = conf->gI ( "BoVMoosmann", "codebooksize", 1024 );

        CodebookRandomForest *crdf = new CodebookRandomForest ( maxDepth, csize );

        //RF anlernen
        FPCRandomForests *fpcrfmoos = new FPCRandomForests ( conf, "MoosForest" );

        fpcrfmoos->train ( fp, examples );

        crdf->setClusterForest ( fpcrfmoos );

        for ( int i = 0; i < ( int ) examples.size(); i++ )
        {
          if ( examples[i].second.vec != NULL )
          {
            delete examples[i].second.vec;
            examples[i].second.vec = NULL;
          }
        }
        rfbovdyn->setCodebook ( crdf );
      }

      if ( rfCsurka != NULL )
      {

        bool usegmm = conf->gB ( "Csurka", "usegmm", false );
        bool usepca = conf->gB ( "Csurka", "usepca", false );

        PCA *pca = NULL;
        GMM *g = NULL;

        string classifierdst = cache + "/csurka.";

        if ( usepca || usegmm )
        {

          RFCsurka *_rfcsurka = dynamic_cast< RFCsurka * > ( rfCsurka );

          bool create = false;
          string gmmdst = cache + "/csurka.gmm";
          string pcadst = cache + "/csurka.pca";

          int pcadim = conf->gI ( "Csurka", "pcadim", 100 );

          if ( usepca )
          {
            pca = new PCA ( pcadim );

            if ( !FileMgt::fileExists ( pcadst ) )
            {
              create = true;
            }
            else
            {
              pca->read ( pcadst );
            }
          }

          if ( usegmm )
          {
            int gaussians = conf->gI ( "Csurka", "gaussians", 1024 );
            g = new GMM ( conf, gaussians );

            if ( !g->loadData ( gmmdst ) )
            {
              create = true;
            }
          }

          if ( create )
          {
            if ( usepca )
            {
              convertExamplesToVVector ( feats, examples, label );
              initializePCA ( feats, *pca, pcadim, pcadst );
              transformFeats ( feats, *pca );
              convertVVectorToExamples ( feats, examples, label );
            }

            if ( usegmm )
            {
              g->computeMixture ( examples );
              if ( save_cache )
                g->saveData ( gmmdst );
            }
          }


          if ( usepca )
            _rfcsurka->setPCA ( pca );


          if ( usegmm )
            _rfcsurka->setGMM ( g );

        }


        string classifiertype = conf->gS ( "Csurka", "classifier", "SMLR" );
        FeaturePoolClassifier *fpcrfCs = NULL;
        VecClassifier *vecClassifier = NULL;

        if ( classifiertype == "SMLR" )
        {
          fpcrfCs = new FPCSMLR ( conf, "CsurkaSMLR" );
          classifierdst += "smlr";
        }
        else if ( classifiertype == "RF" )
        {
          fpcrfCs = new FPCRandomForests ( conf, "CsurkaForest" );
          classifierdst += "rf";
        }
        else
        {
          vecClassifier = GenericClassifierSelection::selectVecClassifier ( conf, classifiertype );
          classifierdst += "other";
        }

        RFCsurka *rfcsurka = dynamic_cast< RFCsurka * > ( rfCsurka );

        if ( usepca )
        {
          assert ( examples.size() > 0 );
          if ( ( int ) examples[0].second.vec->size() != pca->getTargetDim() )
          {
            for ( int i = 0; i < ( int ) examples.size(); ++i )
            {
              *examples[i].second.vec = pca->getFeatureVector ( *examples[i].second.vec, true );
            }
          }
        }


        if ( !FileMgt::fileExists ( classifierdst ) )
        {
          if ( usegmm )
          {
            if ( classifiertype == "SMLR" )
            {
              for ( int i = 0; i < ( int ) examples.size(); ++i )
              {
                examples[i].second.svec = new SparseVector();
                g->getProbs ( *examples[i].second.vec, *examples[i].second.svec );
                delete examples[i].second.vec;
                examples[i].second.vec = NULL;
              }
            }
            else
            {
              for ( int i = 0; i < ( int ) examples.size(); ++i )
              {
                g->getProbs ( *examples[i].second.vec, *examples[i].second.vec );
              }
            }
            if ( fpcrfCs != NULL )
            {
              fpcrfCs->train ( fpsparse, examples );
            }
            else
            {
              LabeledSetVector lvec;
              convertExamplesToLSet ( examples, lvec );
              vecClassifier->teach ( lvec );
              convertLSetToExamples ( examples, lvec );
              vecClassifier->finishTeaching();
            }
          }
          else
          {
            if ( fpcrfCs != NULL )
            {
              fpcrfCs->train ( fp, examples );
            }
            else
            {
              LabeledSetVector lvec;
              convertExamplesToLSet ( examples, lvec );
              vecClassifier->teach ( lvec );
              convertLSetToExamples ( examples, lvec );
              vecClassifier->finishTeaching();
            }
          }

          if ( fpcrfCs != NULL )
          {
            fpcrfCs->setMaxClassNo ( classNames->getMaxClassno() );
            fpcrfCs->save ( classifierdst );
          }
          else
          {
            vecClassifier->setMaxClassNo ( classNames->getMaxClassno() );
            vecClassifier->save ( classifierdst );
          }

        }
        else
        {
          if ( fpcrfCs != NULL )
          {
            fpcrfCs->setMaxClassNo ( classNames->getMaxClassno() );
            fpcrfCs->read ( classifierdst );
          }
          else
          {
            vecClassifier->setMaxClassNo ( classNames->getMaxClassno() );
            vecClassifier->read ( classifierdst );
          }


        }

        if ( fpcrfCs != NULL )
        {
          rfcsurka->setClassifier ( fpcrfCs );
        }
        else
        {
          rfcsurka->setClassifier ( vecClassifier );
        }
      }
      fp.destroy();
      for ( int i = 0; i < ( int ) examples.size(); i++ )
      {
        if ( examples[i].second.vec != NULL )
        {
          delete examples[i].second.vec;
          examples[i].second.vec = NULL;
        }
      }
    }
  }
#ifdef DEBUG_PRINTS
  cerr << "SemSegRegionBased::learnHighLevel finished" << endl;
#endif
}

void SemSegRegionBased::transformFeats ( VVector &feats, PCA &pca )
{
#ifdef DEBUG_PRINTS
  cerr << "SemSegRegionBased::transformFeats starts" << endl;
#endif
  for ( int i = 0; i < ( int ) feats.size(); i++ )
  {
    feats[i] = pca.getFeatureVector ( feats[i], true );
  }
#ifdef DEBUG_PRINTS
  cerr << "SemSegRegionBased::transformFeats finished" << endl;
#endif
}

void SemSegRegionBased::initializePCA ( const VVector &feats, PCA &pca, int dim, string &fn )
{
#ifdef DEBUG_PRINTS
  cerr << "SemSegRegionBased::initializePCA starts" << endl;
#endif
  pca = PCA ( dim );

  if ( !FileMgt::fileExists ( fn ) )
  {
    srand ( time ( NULL ) );

    int featsize = ( int ) feats.size();
    int maxfeatures = std::min ( dim * 20, featsize );

    NICE::Matrix features ( maxfeatures, ( int ) feats[0].size() );

    for ( int i = 0; i < maxfeatures; i++ )
    {
      int k = rand() % featsize;

      int vsize = ( int ) feats[k].size();
      for ( int j = 0; j < vsize; j++ )
      {
        features ( i, j ) = feats[k][j];
      }
    }
    pca.calculateBasis ( features, dim );

    if ( save_cache )
      pca.save ( fn );

  }
  else
  {
    pca.read ( fn );
  }
#ifdef DEBUG_PRINTS
  cerr << "SemSegRegionBased::initializePCA finished" << endl;
#endif
}