/** 
 * @file Centrist.cpp
 * @brief Implementation of the Centrist feature published in  "CENTRIST: A Visual Descriptor for Scene Categorization" (PAMI 2011)
 * @author Alexander Lütz
 * @date 12/06/2011
*/
#include <iostream>

#include "vislearning/features/localfeatures/Centrist.h"
#include "core/vector/VVector.h"

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

/* protected methods*/

/**
 * @brief: perform centrist transformation for a single pixel 
 * @author Alexander Lütz
 * @date 12/06/2011
 */
//TODO maybe inline?
int CensusTransform(const NICE::Image & img, const int & x, const int & y)
{
	int index(0);
	if (! img.isWithinImage(x,y)) return index;
	
	if( (img.isWithinImage(x-1,y-1)) && (img.getPixelInt(x,y)<=img.getPixelInt(x-1,y-1)) ) index |= 0x80;
	if( (img.isWithinImage(x-1,y)) && (img.getPixelInt(x,y)<=img.getPixelInt(x-1,y)) ) index |= 0x40;
	if( (img.isWithinImage(x-1,y+1)) && (img.getPixelInt(x,y)<=img.getPixelInt(x-1,y+1)) ) index |= 0x20;
	if( (img.isWithinImage(x,y-1)) && (img.getPixelInt(x,y)<=img.getPixelInt(x,y-1)) ) index |= 0x10;
	if( (img.isWithinImage(x,y+1)) && (img.getPixelInt(x,y)<=img.getPixelInt(x,y+1)) ) index |= 0x08;
	if( (img.isWithinImage(x+1,y-1)) && (img.getPixelInt(x,y)<=img.getPixelInt(x+1,y-1)) ) index |= 0x04;
	if( (img.isWithinImage(x+1,y)) && (img.getPixelInt(x,y)<=img.getPixelInt(x+1,y)) ) index |= 0x02;
	if( (img.isWithinImage(x+1,y+1)) && (img.getPixelInt(x,y)<=img.getPixelInt(x+1,y+1)) ) index |= 0x01;
	return index;
}

/**
 * @brief: perform centrist transformation for a single pixel 
 * @author Alexander Lütz
 * @date 12/06/2011
 */
//TODO maybe inline?
int CensusTransform(const NICE::ColorImage & img, const int & x, const int & y, const int & channel)
{
	int index(0);
	if (! img.isWithinImage(x,y)) return index;
	
	if( (img.isWithinImage(x-1,y-1)) && (img.getPixelInt(x,y, channel)<=img.getPixelInt(x-1,y-1, channel)) ) index |= 0x80;
	if( (img.isWithinImage(x-1,y)) && (img.getPixelInt(x,y, channel)<=img.getPixelInt(x-1,y, channel)) ) index |= 0x40;
	if( (img.isWithinImage(x-1,y+1)) && (img.getPixelInt(x,y, channel)<=img.getPixelInt(x-1,y+1, channel)) ) index |= 0x20;
	if( (img.isWithinImage(x,y-1)) && (img.getPixelInt(x,y, channel)<=img.getPixelInt(x,y-1, channel)) ) index |= 0x10;
	if( (img.isWithinImage(x,y+1)) && (img.getPixelInt(x,y, channel)<=img.getPixelInt(x,y+1, channel)) ) index |= 0x08;
	if( (img.isWithinImage(x+1,y-1)) && (img.getPixelInt(x,y, channel)<=img.getPixelInt(x+1,y-1, channel)) ) index |= 0x04;
	if( (img.isWithinImage(x+1,y)) && (img.getPixelInt(x,y, channel)<=img.getPixelInt(x+1,y, channel)) ) index |= 0x02;
	if( (img.isWithinImage(x+1,y+1)) && (img.getPixelInt(x,y, channel)<=img.getPixelInt(x+1,y+1, channel)) ) index |= 0x01;
	return index;
}

/**
 * @brief: generate CT histogram for a given rectangle: pixels in [xi yi]-(xa,ya) -- including (xi,yi) but excluding (xa,ya)
 * @author Alexander Lütz
 * @date 12/06/2011
 */
void Centrist::GenerateHistForOneRect(const NICE::Image & img, const int & xi, const int & xa, const int & yi, const int & ya, NICE::Vector & feature)
{
// 	double pixelSum(0.0);
// 	double pixelSquare(0.0);
	feature.resize(256);
	feature.set(0.0);
	
	for (int j = yi; j < ya; j++)
	{
		for (int i = xi; i < xa; i++)
		{
// 			pixelSum += img.getPixelInt(i,j);
// 			pixelSquare += img.getPixelInt(i,j)*img.getPixelInt(i,j);
			feature[CensusTransform(img,i,j)]++;
		}
	}
	
// 	const double size ( (xa-xi)*(ya-yi));

	// normalize histogram to have 0 mean, remove the first and last entry, and normalize to have unit norm
	double sum(feature.Sum()/256.0);//shift more efficient?
	
	// normalize histogram to have 0 mean
	//but why?
	feature -= sum;
	
	//remove the first and last entry
	feature[0] = 0.0;
	feature[255] = 0.0;

	//normalization - here done using unit L2-norm
	feature.normalizeL2();
}

/**
 * @brief: generate CT histogram for a given rectangle: pixels in [xi yi]-(xa,ya) -- including (xi,yi) but excluding (xa,ya)
 * @author Alexander Lütz
 * @date 12/06/2011
 */
void Centrist::GenerateHistForOneRect(const NICE::ColorImage & img, const int & xi, const int & xa, const int & yi, const int & ya, NICE::Vector & feature)
{
// 	double pixelSum(0.0);
// 	double pixelSquare(0.0);
	int nrChannel (img.channels());
	feature.resize(256*nrChannel);
	feature.set(0.0);
	
	for (int channel = 0; channel < nrChannel; channel++)
	{
		for (int j = yi; j < ya; j++)
		{
			for (int i = xi; i < xa; i++)
			{
// 				pixelSum += img.getPixelInt(i,j, channel);
// 				pixelSquare += img.getPixelInt(i,j, channel)*img.getPixelInt(i,j, channel);
				feature[256*channel+CensusTransform(img,i,j,channel)]++;
			}
		}
	}
	
// 	const double size ( (xa-xi)*(ya-yi))

	// normalize histogram to have 0 mean, remove the first and last entry, and normalize to have unit norm
	double sum(feature.Sum()/256.0);//shift more efficient?
	
	// normalize histogram to have 0 mean
	//but why?
	feature -= sum;
	
	//remove the first and last entry
	feature[0] = 0.0;
	feature[255] = 0.0;

	//normalization - here done using unit L2-norm
	feature.normalizeL2();
}

/**
 * @brief Computes several CENTRIST descriptors for each of the given positions om a local neighborhood
 * @author Alexander Lütz
 * @date 12/06/2011
 */
void Centrist::computeDesc( const NICE::Image & img, NICE::VVector & positions, NICE::VVector & descriptors )
{
	descriptors.clear();
	for (NICE::VVector::const_iterator it = positions.begin(); it != positions.end(); it++)
	{
		NICE::Vector descriptor;
		GenerateHistForOneRect(img, (*it)[0]-sizeNeighborhood/2, (*it)[0]+sizeNeighborhood/2, (*it)[1]-sizeNeighborhood/2, (*it)[1]+sizeNeighborhood/2, descriptor);
		descriptors.push_back(descriptor);
	}
}

/**
 * @brief Computes several CENTRIST descriptors for each of the given positions om a local neighborhood
 * @author Alexander Lütz
 * @date 12/06/2011
 */
void Centrist::computeDesc( const NICE::ColorImage & img, NICE::VVector & positions, NICE::VVector & descriptors )
{
	descriptors.clear();
	for (NICE::VVector::const_iterator it = positions.begin(); it != positions.end(); it++)
	{
		NICE::Vector descriptor;
		GenerateHistForOneRect(img, (*it)[0]-sizeNeighborhood/2, (*it)[0]+sizeNeighborhood/2, (*it)[1]-sizeNeighborhood/2, (*it)[1]+sizeNeighborhood/2, descriptor);
		descriptors.push_back(descriptor);
	}
}

/* public methods*/

/**
 * @brief Default constructor
 * @author Alexander Lütz
 * @date 12/06/2011
 */
Centrist::Centrist()
{
	sizeNeighborhood = 16;
}

/**
 * @brief Recommended constructor
 * @author Alexander Lütz
 * @date 12/06/2011
 */
Centrist::Centrist( const Config *conf, const std::string & section )
{
	sizeNeighborhood = conf->gI(section, "sizeNeighborhood", 16);
}

/**
 * @brief Default destructor
 * @author Alexander Lütz
 * @date 12/06/2011
 */
Centrist::~Centrist()
{
}


/**
 * @brief Computes several CENTRIST descriptors for each of the given positions on a local neighborhood
 * @author Alexander Lütz
 * @date 12/06/2011
 */
int Centrist::getDescriptors ( const NICE::Image & img, VVector & positions, VVector & descriptors )
{
	computeDesc(img, positions, descriptors);
	return 0;
}

/**
 * @brief Computes several CENTRIST descriptors for each of the given positions on a local neighborhood
 * @author Alexander Lütz
 * @date 12/06/2011
 */
int Centrist::getDescriptors ( const NICE::ColorImage & img, NICE::VVector & positions, NICE::VVector & descriptors)
{
	computeDesc(img, positions, descriptors);
	return 0;
}

/**
 * @brief Visualizes CENTRIST descriptors, not implemented yet!
 * @author Alexander Lütz
 * @date 12/06/2011
 */
void Centrist::visualizeFeatures ( NICE::Image & mark,
				 const VVector & positions,
				 size_t color ) const
{
//     ice::Image mark_ice = ice::NewImg ( mark.width(), 
// 	mark.height(), 255 );
//     for ( size_t k = 0 ; k < positions.size() ; k++ )
//     {
// 		const NICE::Vector & pos = positions[k];
// 		ice::Matrix points ( 0, 2 );
// 		const int size = 6;
// 		points.Append ( ice::Vector(-size, -size) );
// 		points.Append ( ice::Vector(-size, size) );
// 		points.Append ( ice::Vector(size, size) );
// 		points.Append ( ice::Vector(size, -size) );
// 
// 		ice::Trafo tr;
// 
// 		tr.Scale ( 0, 0, pos[2] );
// 		tr.Rotate ( 0, 0, pos[3] );
// 		tr.Shift ( pos[0], pos[1] );
// 
// 		ice::TransformList(tr, points);
// 
// 		for ( int j = 0 ; j < points.rows(); j++ )
// 		{
// 			if (points[j][0] < 0 ) 
// 			points[j][0] = 0;
// 			if (points[j][0] >= mark_ice->xsize) 
// 			points[j][0] = mark_ice->xsize - 1;
// 			if (points[j][1] < 0 ) 
// 			points[j][1] = 0;
// 			if (points[j][1] >= mark_ice->ysize) 
// 			points[j][1] = mark_ice->ysize - 1;
// 		}
// 		ice::DrawPolygon ( points, color, mark_ice );
//     }
// 
//     for ( unsigned int y = 0 ; y < mark.height(); y++ )
// 		for ( unsigned int x = 0 ; x < mark.width(); x++ )
// 			mark.setPixel(x,y, GetVal(mark_ice,x,y));
}