NICE_VisLearning/features/localfeatures/LFonHSG.cpp

/** 
* @file LFonHSG.cpp
* @brief Implementation of the LocalFeatureHSG.h. See description there.
* @author Eric Bach
* @date 26.10.2011
*/

/* LocalFeatureHSG Include */

#include "vislearning/features/localfeatures/LFonHSG.h"

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

LFonHSG::LFonHSG( const Config *conf, const string section )
{	
	/** initialization **/
	this->lf = NULL;

	/** get parameters for the grid **/
	sampleScaling    = conf->gI( section, "sample_scaling", 50  );
	scales		 = conf->gS( section, "scales"        , "1" );
	// the scales are seperated by '+', like in the Van de Sande implementation
	char separator = '+';

	/** get debuginformation **/
	debug 		 = conf->gB( "debug", "show_log_HSG", false );

	/** generate the descriptor-instanz **/
	lf = GenericLocalFeatureSelection::selectLocalFeature( conf, section );

	/** parse scales string **/
	debug && clog << "[log] LocalFeatureHSG::LocalFeatureHSG" << endl;
	debug && clog << "[log] try to parse the 'scales-string': " << scales << " -> ";
		
#ifdef NICE_USELIB_BOOST
    	typedef tokenizer<boost::char_separator<char> > tokenizer;
    	char_separator<char> sep(separator);
    	tokenizer tokens(scales, sep);		// parse the string into tokens
    	for( tokenizer::iterator tok_iter = tokens.begin(); tok_iter != tokens.end(); ++tok_iter )
	{
	  debug && clog << *tok_iter << " ";	
	  scalesV.push_back( strToFloat( *tok_iter ) );
	}
#else // standard
	vector<string> temp;
	StringTools::split( scales, separator, temp );
	for( vector<string>::const_iterator it = temp.begin(); it != temp.end(); ++it )
	{
	  debug && clog << *it << " ";	
	  scalesV.push_back( strToFloat( *it ) );
	}
#endif
	debug && clog << endl;
}

LFonHSG::~LFonHSG()
{
	/** free memory of descriptors **/
}

void LFonHSG::getPositionsOnHSG ( const unsigned int imageWidth, const unsigned int imageHeight, VVector& positions ) const
{
	if( sampleScaling < 1 ){ cerr << "[err] sample-scaling (" << sampleScaling << ") musst be larger the 0!" << endl; return; }

	debug && clog << "[log] LocalFeatureHSG::getPositionsOnHSG calculate ";

	bool oddRow = true;
	NICE::Vector pos( 4 );

	/** we have to calculate the koo. for every different scale **/
	for( vector <float>::const_iterator it = scalesV.begin(); it != scalesV.end(); ++it )
	{
		oddRow = true;

		for( unsigned int j = sampleScaling; j <= ( imageHeight - sampleScaling ); j += sampleScaling )
		{
			for( unsigned int i = ( oddRow ? sampleScaling + sampleScaling / 2 : sampleScaling ); i <= ( imageWidth - sampleScaling ); i += sampleScaling )
			{
				pos[ 0] = i; pos[ 1] = j; pos[ 2] = *it; pos[ 3] = 0;
				positions.push_back( pos );
			}
			oddRow = !oddRow;
		}
	}
}

int LFonHSG::extractFeatures ( const NICE::ColorImage & cimg, VVector & features, VVector & positions ) const
{
	/** To get the keypoint descriptor, we need the positions of the keypoints. **/
	getPositionsOnHSG( cimg.width(), cimg.height(), positions );

	/** calulate the descriptor-values **/
	return lf->getDescriptors( cimg, positions, features );	
}


int LFonHSG::extractFeatures ( const NICE::Image & img, VVector & features, VVector & positions ) const
{
	/** To get the keypoint descriptor, we need the positions of the keypoints. **/
	getPositionsOnHSG( img.width(), img.height(), positions );

	/** calculate the descriptor-values **/
	return lf->getDescriptors( img, positions, features );
}

void LFonHSG::visualizeFeatures ( NICE::Image & mark, const VVector & positions, size_t color ) const
{
	// TODO: Implementierung des gewaehlten Descriptortyps aufrufen.
}

float LFonHSG::strToFloat( const string str ) const
{
	float temp;
 
	stringstream ss;
	ss << str;
	ss >> temp;

	return temp;
}