NICE_SemSeg/semseg/SemSegSTF.cpp

/** 
* @file SemSegSTF.cpp
* @brief Localization system
* @author Erik Rodner
* @date 02/11/2008

*/
#include <iostream>

#include "SemSegSTF.h"
#include "vislearning/baselib/Globals.h"
#include "vislearning/baselib/Preprocess.h"
#include "vislearning/baselib/ProgressBar.h"
#include "core/basics/StringTools.h"
#include "vislearning/baselib/Globals.h"

#include "vislearning/cbaselib/CachedExample.h"
#include "vislearning/cbaselib/PascalResults.h"

#include "vislearning/features/fpfeatures/PixelPairFeature.h"
#include "vislearning/features/fpfeatures/SemanticFeature.h"

#include "vislearning/features/fpfeatures/FIGradients.h"

#include "FIShotton.h"

#include "SemSegTools.h"

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

SemSegSTF::SemSegSTF( const Config *conf, 
		    const MultiDataset *md )
    : SemanticSegmentation ( conf, &(md->getClassNames("train")) )
{
    use_semantic_features = conf->gB("bost", "use_semantic_features", true );
    use_pixelpair_features = conf->gB("bost", "use_pixelpair_features", true );
    subsamplex = conf->gI("bost", "subsamplex", 5);
    subsampley = conf->gI("bost", "subsampley", 5);
    numClasses = md->getClassNames("train").numClasses();

    read_pixel_cache = conf->gB("FPCPixel", "read_cache", false );
    cachepixel = conf->gS("FPCPixel", "cache", "fpc.data" );

    read_seg_cache = conf->gB("FPCSeg", "read_cache", true );
    cacheseg = conf->gS("FPCSeg", "cache", "segforest.data" );

    Examples examples;
    vector<CachedExample *> imgexamples;

    fpcPixel = new FPCRandomForests ( conf, "FPCPixel" );
    fpcPixel->setMaxClassNo ( classNames->getMaxClassno() );
    if ( !read_pixel_cache || !read_seg_cache ) 
    {
	// Generate Positioned Examples
	SemSegTools::collectTrainingExamples ( conf, "FPCPixel", *((*md)["train"]), *classNames, 
	    examples, imgexamples );
    }

    if ( ! read_pixel_cache ) 
    {	
	///////////////////////////////////
	// Train Single Pixel Classifier
	//////////////////////////////////

	FeaturePool fp;
	for ( vector<CachedExample *>::const_iterator k = imgexamples.begin(); 
			k != imgexamples.end();
			k++ )
		fillCachePixel (*k);
    
	PixelPairFeature hf (conf);
	hf.explode ( fp );

	fpcPixel->train ( fp, examples );
	fpcPixel->save ( cachepixel );

	fp.destroy();
    } else {
	fprintf (stderr, "SemSegSTF:: Reading pixel classifier data from %s\n", cachepixel.c_str() );
	fpcPixel->read ( cachepixel );
    }
    
    fpcSeg = new FPCRandomForests ( conf, "FPCSeg" );
    fpcSeg->setMaxClassNo ( classNames->getMaxClassno() );
    maxdepthSegmentationForest = conf->gI("bost", "maxdepth", 5);
    maxdepthSegmentationForestScores = conf->gI("bost", "maxdepth_scores", 9999);

    if ( ! read_seg_cache ) 
    {
	///////////////////////////////////
	// Train Segmentation Forest
	//////////////////////////////////

	fprintf (stderr, "Calculating Prior Statistics\n");
	ProgressBar pbseg ("Calculating Prior Statistics");
	pbseg.show();
	for ( vector<CachedExample *>::const_iterator k = imgexamples.begin(); 
			    k != imgexamples.end();
			    k++ )
	{
	    pbseg.update ( imgexamples.size() );
	    fillCacheSegmentation ( *k );
	}
	pbseg.hide();
	
	FeaturePool fp;

	if ( use_semantic_features )
	{
	    set<int> classnos;
	    classNames->getSelection ( conf->gS("FPCSeg", "train_selection")
		, classnos );
	    SemanticFeature sf ( conf, &classnos );
	    sf.explode ( fp );
	}

	fprintf (stderr, "Training Segmentation Forest\n");

	fpcSeg->train ( fp, examples );
	fpcSeg->save ( cacheseg );

	// clean up memory !!
	for ( vector<CachedExample *>::iterator i = imgexamples.begin();
	    	    i != imgexamples.end();
		    i++ )
	    delete ( *i );

	fp.destroy();
	
    } else {
	fprintf (stderr, "SemSegSTF:: Reading region classifier data from %s\n", cacheseg.c_str() );
	fpcSeg->read ( cacheseg );
	fprintf (stderr, "SemSegSTF:: successfully read\n" );
    }
}

SemSegSTF::~SemSegSTF()
{
}

void SemSegSTF::fillCacheSegmentation ( CachedExample *ce )
{
    FIShotton::buildSemanticMap ( ce,
		      fpcPixel,
		      subsamplex,
		      subsampley, 
		      numClasses );
}

void SemSegSTF::fillCachePixel ( CachedExample *ce )
{
}

void SemSegSTF::semanticseg ( CachedExample *ce, 
			   NICE::Image & segresult,
			   NICE::MultiChannelImageT<double> & probabilities )
{
    int xsize;
    int ysize;
    ce->getImageSize ( xsize, ysize );
    
    int numClasses = classNames->numClasses();
    
    fillCachePixel ( ce );
    fillCacheSegmentation ( ce );

    fprintf (stderr, "BoST classification !\n");

    Example pce ( ce, 0, 0 );

    int xsize_s = xsize / subsamplex;
    int ysize_s = ysize / subsampley;
    ClassificationResult *results = new ClassificationResult [xsize_s*ysize_s];

    /** classify each pixel of the image */
    FullVector prior ( classNames->getMaxClassno() );
    
    probabilities.reInit ( xsize_s, ysize_s, numClasses, true );
    probabilities.setAll ( 0 );

    long offset_s = 0;
    for ( int ys = 0 ; ys < ysize_s ; ys ++ ) 
	for ( int xs = 0 ; xs < xsize_s ; xs++,offset_s++ )  
	{
	    int x = xs * subsamplex;
	    int y = ys * subsampley;
	    pce.x = x ; pce.y = y ; 
	    results[offset_s] = fpcSeg->classify ( pce );

	    for ( int i = 0 ; i < results[offset_s].scores.size(); i++ )
		probabilities.data[i][offset_s] = results[offset_s].scores[i];

	    /*
	    if ( imagePriorMethod != IMAGE_PRIOR_NONE ) 
		prior.add ( results[offset_s].scores );
	    */
	}

   
    fprintf (stderr, "BoST classification ready\n");

    /** save results */
    segresult.resize(xsize_s, ysize_s); 
    segresult.set( classNames->classno("various") );

    long int offset = 0;
    for ( int y = 0 ; y < ysize_s ; y++ ) 
	for ( int x = 0 ; x < xsize_s ; x++,offset++ )  
	{
	    double maxvalue = - numeric_limits<double>::max();
	    int maxindex = 0;
	    for ( int i = 0 ; i < (int)probabilities.numChannels; i++ )
		if ( probabilities.data[i][offset] > maxvalue )
		{
		    maxindex = i;
		    maxvalue = probabilities.data[i][offset];
		}

	    segresult.setPixel(x,y,maxindex);
	}

}