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

#include "MyGridOnImageGenerator.h"

//----------------------------------------------------------------------------
// Class implementation
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
// Builder
//----------------------------------------------------------------------------

MyGridOnImageGenerator::MyGridOnImageGenerator( vtkImageData* nImage, double nScpX, double nScpY, double nScpZ)
{
	spcX = nScpX;
	spcY = nScpY;
	spcZ = nScpZ;
	image = nImage;
}

//----------------------------------------------------------------------------
// Destructor
//----------------------------------------------------------------------------

MyGridOnImageGenerator::~MyGridOnImageGenerator( )
{

}
//----------------------------------------------------------------------------
// Methods
//----------------------------------------------------------------------------


void MyGridOnImageGenerator::setScpX(double nScpX)
{
	spcX = nScpX;
}

void MyGridOnImageGenerator::setScpY(double nScpY)
{
	spcY = nScpY;
}

void MyGridOnImageGenerator::setScpZ(double nScpZ)
{
	spcZ = nScpZ;
}


void MyGridOnImageGenerator::setImage(vtkImageData* nImage)
{
	image = nImage;
}

vtkImageData* MyGridOnImageGenerator::getGridOnImage( )
{
	//Variables
	double spc[3];
	int dims[3];
	int sizeX = 0, sizeY = 0, sizeZ = 0;
	double minMaxValue[2];
	double minValue = 0, maxValue = 0;
	int spcVoxelX = 0, spcVoxelY = 0, spcVoxelZ = 0;

	vtkImageData* gridImage = vtkImageData::New();
	gridImage->ShallowCopy(image);
	gridImage->Update();

	//Get image spacing, size and mix and max values
	gridImage->GetSpacing(spc);
	gridImage->GetDimensions(dims);
	sizeX = dims[0];
	sizeY = dims[1];
	sizeZ = dims[2];
	gridImage->GetScalarRange(minMaxValue);
	minValue = minMaxValue[0];
	maxValue = minMaxValue[1];

	//Grid spacing in voxels
	spcVoxelX = spcX / spc[0];
	spcVoxelY = spcY / spc[1];
	spcVoxelZ = spcZ / spc[2];

	std::cout << "spcVoxelX:" << spcVoxelX << ", spcVoxelY:" << spcVoxelY << ", spcVoxelZ:" << spcVoxelZ <<std::endl;
	std::cout << "minValue:" << minValue << ", maxValue:" << maxValue << std::endl;
	std::cout << "sizeX:" << sizeX << ", sizeY:" << sizeY << ", sizeZ:" << sizeZ <<std::endl;

	for(int px = 0; px < sizeX; px++)
	{
		for(int py = 0; py < sizeY; py++)
		{
			for(int pz = 0; pz < sizeZ; pz++)
			{
				if(px % spcVoxelX == 0 || py % spcVoxelY == 0 || pz % spcVoxelZ == 0)
				{
					//std::cout << "In" ;
					unsigned char* pointer = (unsigned char*) gridImage->GetScalarPointer(px, py, pz);
					if( (*pointer - minValue) < (maxValue - *pointer) )
						*pointer = maxValue;
					else
						*pointer = minValue;
				}
			}
		}
	}


	return gridImage;
}