//----------------------------------------------------------------------------
// Class definition include
//----------------------------------------------------------------------------

#include "pHistogram.h"
//#include "vtkJPEGReader.h"
#include "vtkImageData.h"
#include  "vtkImageCast.h"
//-----------------
// C++
//-----------------
#include <iostream>
#include <fstream>
#include <string>
#include <vector>

// ----------------------------------------------------------------------------
// WX headers inclusion.
// For compilers that support precompilation, includes <wx/wx.h>.
// ----------------------------------------------------------------------------

/*
#ifndef WX_PRECOMP
#include <wx/wx.h>
#endif
*/
//----------------------------------------------------------------------------
// Class implementation
//----------------------------------------------------------------------------

//IMPLEMENT_CLASS(pHistogram, wxObject)

//----------------------------------------------------------------------------
// Constructors
//----------------------------------------------------------------------------
pHistogram::pHistogram(std::string filePath)
{
	path=filePath;
	points= vtkImageData::New();
	size=100;
	sizeImage=0;
	buildHistogram();
}

pHistogram::pHistogram(vtkImageData* imageData)
{
	points= vtkImageData::New();
	size=100;
	sizeImage=0;
	//cast
	/*
	vtkImageCast* cast= vtkImageCast::New();
	cast->SetInput(imageData);
	cast->SetOutputScalarTypeToInt();
	cast->Update();
	*/
	//build the histogram
	buildHistogram(imageData);
}

pHistogram::~pHistogram()
{
	if(points!=NULL)points->Delete();
}
//----------------------------------------------------------------------------
// Methods
//----------------------------------------------------------------------------

void pHistogram::setImagePath(std::string filePath)
{
	path=filePath;
}

void pHistogram::buildHistogram()
{
	/*
		reader: is the reader of the image
		histogramVector:Is the image data of the original image
		imageData: vtkImageData of the image that we are reading
		range :it has the (min/max) range of the levels of grey
	*/
	points= vtkImageData::New();
	vtkMetaImageReader *reader = vtkMetaImageReader::New();
	vtkImageData* imageData=NULL;
	double range[2];
	
	//reading
	reader->SetFileName(path.c_str());
	reader->Update();

	
	// getting the data 
	imageData=reader->GetOutput();
	imageData->GetScalarRange(range);
	initializePoints(size);
	setPoints(imageData);
	
}

/*
Calculate the histogram and save it in the attribute points
it is used if the user had given the imageData
Pre: Size had to be setted if the user wants
another value that 100
*/
void pHistogram::buildHistogram(vtkImageData* imageData)
{
	initializePoints(size);
	setPoints(imageData);	
}

/*
  getting ready the points
*/
void pHistogram::initializePoints(int xDimension)
{
	//setting image data of the points
	points->SetDimensions(xDimension,1,1);
	points->SetScalarTypeToUnsignedShort();
	points->AllocateScalars();
	points->Update();
}

/*
	 constructing the histogram
*/
void pHistogram::setPoints(vtkImageData* imageData)
{
	/*
		Pointers
	*/
	unsigned short* dataImagePointer=NULL;
	unsigned short* dataHistogramPointer=NULL;

	dataImagePointer=(unsigned short*)imageData->GetScalarPointer(0,0,0);
	dataHistogramPointer=(unsigned short*)points->GetScalarPointer(0,0,0);
	
	/*
	 Range of greys
	*/
	double range[2];
	if(imageData==NULL)
		range[1]=1;
	else
		imageData->GetScalarRange(range);
	/*
	 Setting the  minimun and maximum levels of grey
	*/
	maxLevelOfGrey=(int)range[1];
	minLevelOfGrey=(int)range[0];
	//std::cout<<"maxLevelOfGrey "<<maxLevelOfGrey<<" minLevelOfGrey "<<minLevelOfGrey<<std::endl;
	/*
	 Image Size
	*/
	int ext[6];
	imageData->GetExtent(ext);
	int sx,sy,sz;
	sx=ext[1]+1;
	sy=ext[3]+1;
	sz=ext[5]+1;

	sizeImage=sx*sy*sz;

	int i;
	/*
	  getting ready the histogram
	*/
	for(i=0;i<size;i++)
	{
		dataHistogramPointer[i]=0;
	}
	
	/*
	Constructing the Histogram
	*/
	//int k=size/(maxLevelOfGrey-minLevelOfGrey);
	int j=0;
	for(i=0;i<sizeImage;i++)
	{
		/*
		 hashing the histogram
		*/
		//double p=((float)*dataImagePointer-minLevelOfGrey);
		//j=p*k;
		
		j=getIndex(*dataImagePointer);
		//std::cout<<j<<std::endl;
		dataHistogramPointer[j]++;
		dataImagePointer++;
	}
	/*
	BORRAME
	*/
	/*
	k=0;
	for(i=0;i<size;i++)
	{
		k=dataHistogramPointer[i];
	}
	*/
}
/*
Returns the poins of the histograms
*/
vtkImageData* pHistogram::getHistogram()
{
	return points;
}

/*
hash por getting the index for the histogram vector of the original
image
@gValue: Level of grey for which wants the index in the histogrram
*/
int pHistogram::getIndex(int gValue)
{

	double p=((double)gValue-minLevelOfGrey)/(maxLevelOfGrey-minLevelOfGrey);
	double k=p*(size-1);
	//std::cout<<"gValue "<<gValue<<" k "<<k<<std::endl;
	return (int)k;
}
/*
Setting the size
*/
void pHistogram::setSize(int nSize)
{
	size=nSize;
}
/*
	Get Image Size
*/
int pHistogram::getImageSize()
{ 
	return sizeImage;
}
/*
	Get Size of the histogram
*/
int pHistogram::getSize()
{
	return size;
}
/*
	Get the maximum value of grey of the histogram
*/
int pHistogram::getMaximumLevelOfGrey()
{
	return maxLevelOfGrey;
}
/*
	Get the minimum value of grey of the histogram
*/
int pHistogram::getMinimumLevelOfGrey()
{
	return minLevelOfGrey;
}
/*
		get a point of the Histogram
		given the grey value
*/
int pHistogram::getHistogramPoint(int gValue)
{
	//double p=((float)gValue-minLevelOfGrey)/(maxLevelOfGrey-minLevelOfGrey); // JPRx
	//double k=p*size;

	unsigned short* dataHistogramPointer=NULL;
	dataHistogramPointer=(unsigned short*)points->GetScalarPointer(0,0,0);

	return dataHistogramPointer[gValue];
}