/*
# ---------------------------------------------------------------------
#
# Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image 
#                        pour la Santé)
# Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton
# Previous Authors : Laurent Guigues, Jean-Pierre Roux
# CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil
#
#  This software is governed by the CeCILL-B license under French law and 
#  abiding by the rules of distribution of free software. You can  use, 
#  modify and/ or redistribute the software under the terms of the CeCILL-B 
#  license as circulated by CEA, CNRS and INRIA at the following URL 
#  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html 
#  or in the file LICENSE.txt.
#
#  As a counterpart to the access to the source code and  rights to copy,
#  modify and redistribute granted by the license, users are provided only
#  with a limited warranty  and the software's author,  the holder of the
#  economic rights,  and the successive licensors  have only  limited
#  liability. 
#
#  The fact that you are presently reading this means that you have had
#  knowledge of the CeCILL-B license and that you accept its terms.
# ------------------------------------------------------------------------      */                                                                    

#include "Transparency.h"


/*
* Constructor
*/
//------------------------------------------------------------
Transparency::Transparency()
{
	_image1		= NULL;
	_image2		= NULL;
	_percent	= 0;
	_newImage 	= NULL;
	_processed	= false;
}

/*
* Destructor
*/
//------------------------------------------------------------
Transparency::~Transparency()
{
	if (_newImage != NULL ) { _newImage->Delete(); }
}

//------------------------------------------------------------
void Transparency::calculateImage()
{
printf("EED  Transparency::calculateImage Start\n");
	if(_image1!=NULL && _image2!=NULL)
	{
printf("EED  Transparency::calculateImage 1\n");

		// IMAGE 1
			
		// Information from image1
		_image1->GetSpacing(spcImg1);
		_image1->GetExtent(extImg1);
		_type = _image1->GetScalarType();
		// The Z dimension is 1 for a 2D image
		dimImg1[0] = extImg1[1] - extImg1[0]+1;
		dimImg1[1] = extImg1[3] - extImg1[2]+1;
		dimImg1[2] = 1;
		//IMAGE 2
		// Information from image2
		_image2->GetSpacing(spcImg2);
		_image2->GetExtent(extImg2);
		// The Z dimension is 1 for a 2D image
		dimImg2[0] = extImg2[1] - extImg2[0]+1;
		dimImg2[1] = extImg2[3] - extImg2[2]+1;
		dimImg2[2] = 1;
		long numPixelsImg1 = dimImg1[0]*dimImg1[1];
		long numPixelsImg2 = dimImg2[0]*dimImg2[1];		
		double factorX = 1;
		double factorY = 1;
		vtkImageResample *resample = vtkImageResample::New();
		vtkImageData *result;
printf("EED  Transparency::calculateImage 2\n");
		if(numPixelsImg1<numPixelsImg2)
		{
//EED 2017-01-01 Migration VTK7
#if VTK_MAJOR_VERSION <= 5
			resample->SetInput(_image1);
#else
			resample->SetInputData(_image1);
#endif
			factorX = (double)extImg2[1]/extImg1[1];
			factorY = (double)extImg2[3]/extImg1[3];
			resample->SetAxisMagnificationFactor(0,factorX);
			resample->SetAxisMagnificationFactor(1,factorY);
			resample->SetInformationInput(_image2);
			initialize(dimImg2, spcImg2);
//EED 2017-01-01 Migration VTK7
#if VTK_MAJOR_VERSION <= 5
			//..
#else
			resample->Update();
#endif
printf("EED  Transparency::calculateImage 3\n");
			result = resample->GetOutput();
//EED 2017-01-01 Migration VTK7
#if VTK_MAJOR_VERSION <= 5
			result->Update();
#else
			//...
#endif
			createImage(result,_image2,dimImg2[0],dimImg2[1]);		
		} else if (numPixelsImg1>numPixelsImg2) {
printf("EED  Transparency::calculateImage 4\n");
//EED 2017-01-01 Migration VTK7
#if VTK_MAJOR_VERSION <= 5
			resample->SetInput(_image2);
#else
			resample->SetInputData(_image2);
#endif
			factorX = (double)extImg1[1]/extImg2[1];
			factorY = (double)extImg1[3]/extImg2[3];
			resample->SetAxisMagnificationFactor(0,factorX);
			resample->SetAxisMagnificationFactor(1,factorY);
			resample->SetInformationInput(_image1);
			initialize(dimImg1, spcImg1);
//EED 2017-01-01 Migration VTK7
#if VTK_MAJOR_VERSION <= 5
			// ...
#else
			resample->Update();
#endif
			result = resample->GetOutput();
			
//EED 2017-01-01 Migration VTK7
#if VTK_MAJOR_VERSION <= 5
			result->Update();
#else
			result->Modified();
#endif
printf("EED  Transparency::calculateImage 4.1\n");
			createImage(_image1,result,dimImg1[0],dimImg1[1]);
printf("EED  Transparency::calculateImage 4.2\n");
		} else {
printf("EED  Transparency::calculateImage 5\n");
			//If both images have the same number of pixels, the resultant image will have the 
			//properties of the first image.
//EED 2017-01-01 Migration VTK7
#if VTK_MAJOR_VERSION <= 5
			resample->SetInput(_image2);
#else
			resample->SetInputData(_image2);
#endif
			factorX = (double)extImg1[1]/extImg2[1];
			factorY = (double)extImg1[3]/extImg2[3];
			resample->SetAxisMagnificationFactor(0,factorX);
			resample->SetAxisMagnificationFactor(1,factorY);
			resample->SetInformationInput(_image1);
			initialize(dimImg1, spcImg1);
//EED 2017-01-01 Migration VTK7
#if VTK_MAJOR_VERSION <= 5
			// ...
#else
			resample->Update();
#endif
			result = resample->GetOutput();
//EED 2017-01-01 Migration VTK7
#if VTK_MAJOR_VERSION <= 5
			result->Update();
#else
			result->Modified();
#endif
			createImage(_image1,result,dimImg1[0],dimImg1[1]);
printf("EED  Transparency::calculateImage 6\n");
		} //else
		resample->Delete();		
		_processed=true;
printf("EED  Transparency::calculateImage 7\n");
	}

printf("EED  Transparency::calculateImage End\n");

}

void Transparency::initialize(int dimensions[], double spacing[])
{
	// Setting the new image
	_newImage = vtkImageData::New();
	_newImage->SetSpacing(spacing);
	_newImage->SetDimensions(dimensions);
//EED 2017-01-01 Migration VTK7
#if VTK_MAJOR_VERSION <= 5
	_newImage->SetScalarType(_type);
	_newImage->AllocateScalars();
	_newImage->Update();
#else
	_newImage->AllocateScalars(_type,1);
#endif
}

void Transparency::createImage(vtkImageData *img1, vtkImageData *img2, int sizeX, int sizeY)
{
printf("EED  Transparency::createImage Start\n");
//	int i, j;  EED ???
	if(_type == VTK_CHAR)
	{
printf("EED  Transparency::createImage 1\n");
		//POINTERS: 
		char* dataImagePointer1 		= NULL;
		char* dataImagePointer2 		= NULL;
		char* dataImageResultPointer 	= NULL;
		createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
	}
	else if(_type == VTK_SIGNED_CHAR)
	{
printf("EED  Transparency::createImage 2\n");
		//POINTERS: 
		signed char* dataImagePointer1 		= NULL;
		signed char* dataImagePointer2 		= NULL;
		signed char* dataImageResultPointer = NULL;
	
		createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
	}
	else if(_type == VTK_UNSIGNED_CHAR)
	{
printf("EED  Transparency::createImage 3\n");
		//POINTERS: 
		unsigned char* dataImagePointer1 		= NULL;
		unsigned char* dataImagePointer2 		= NULL;
		unsigned char* dataImageResultPointer 	= NULL;
	
		createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
	}
	else if(_type == VTK_SHORT)
	{
printf("EED  Transparency::createImage 4\n");
		//POINTERS: 
		short* dataImagePointer1 		= NULL;
		short* dataImagePointer2 		= NULL;
		short* dataImageResultPointer 	= NULL;
	
		createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
	}
	else if(_type == VTK_UNSIGNED_SHORT)
	{
printf("EED  Transparency::createImage 5\n");
		//POINTERS: 
		unsigned short* dataImagePointer1 		= NULL;
		unsigned short* dataImagePointer2 		= NULL;
		unsigned short* dataImageResultPointer 	= NULL;
	
		createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
	}
	else if(_type == VTK_INT)
	{
printf("EED  Transparency::createImage 6\n");
		//POINTERS: 
		int* dataImagePointer1 = NULL;
		int* dataImagePointer2 = NULL;
		int* dataImageResultPointer = NULL;
	
		createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
	}
	else if(_type == VTK_UNSIGNED_INT)
	{
printf("EED  Transparency::createImage 7\n");
		//POINTERS: 
		unsigned int* dataImagePointer1 = NULL;
		unsigned int* dataImagePointer2 = NULL;
		unsigned int* dataImageResultPointer = NULL;
	
		createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
	}
	else if(_type == VTK_LONG)
	{
printf("EED  Transparency::createImage 8\n");
		//POINTERS: 
		long* dataImagePointer1 = NULL;
		long* dataImagePointer2 = NULL;
		long* dataImageResultPointer = NULL;
	
		createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
	}
	else if(_type == VTK_UNSIGNED_LONG)
	{
printf("EED  Transparency::createImage 9\n");
		//POINTERS: 
		unsigned long* dataImagePointer1 		= NULL;
		unsigned long* dataImagePointer2 		= NULL;
		unsigned long* dataImageResultPointer 	= NULL;
	
		createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);		
	}
	else if(_type == VTK_FLOAT)
	{
printf("EED  Transparency::createImage 10\n");
		//POINTERS: 
		float* dataImagePointer1 		= NULL;
		float* dataImagePointer2 		= NULL;
		float* dataImageResultPointer 	= NULL;
	
		createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
	}
	else if(_type == VTK_DOUBLE)
	{
printf("EED  Transparency::createImage 11\n");
		//POINTERS: 
		double* dataImagePointer1 		= NULL;
		double* dataImagePointer2 		= NULL;
		double* dataImageResultPointer 	= NULL;

		createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
	}

//EED 2017-01-01 Migration VTK7
#if VTK_MAJOR_VERSION <= 5
	_newImage->Update();
#else
	_newImage->Modified();
#endif
printf("EED  Transparency::createImage End\n");
}

template <class T>
void Transparency::createImageByType(T* dataImagePointer1, T* dataImagePointer2, T* dataImageResultPointer, vtkImageData *img1, vtkImageData *img2, int sizeX, int sizeY)
{
printf("EED  Transparency::createImageByType Start %d %d\n", sizeX, sizeY);
	int i, j;
	dataImagePointer1 = (T*) img1->GetScalarPointer(0,0,0);
	dataImagePointer2 = (T*) img2->GetScalarPointer(0,0,0);
	dataImageResultPointer = (T*) _newImage->GetScalarPointer(0,0,0);
printf("EED  Transparency::createImageByType 0 %d %d\n", sizeX, sizeY);
	for(i = 0; i < sizeX; i++)
	{
		for(j = 0; j < sizeY; j++)
		{
printf("EED  Transparency::createImageByType 2 %d %d\n", sizeX, sizeY);
			dataImagePointer1 = (T*)img1->GetScalarPointer(i,j,0);
printf("EED  Transparency::createImageByType 3 %d %d\n", sizeX, sizeY);
			dataImagePointer2 = (T*)img2->GetScalarPointer(i,j,0);
printf("EED  Transparency::createImageByType 4 %d %d\n", sizeX, sizeY);
			dataImageResultPointer = (T*)_newImage->GetScalarPointer(i,j,0);
printf("EED  Transparency::createImageByType 5 %d %d\n", sizeX, sizeY);
			*dataImageResultPointer = (T)*dataImagePointer1*_percent + (T)*dataImagePointer2*(1-_percent);				
printf("EED  Transparency::createImageByType 6 %d %d\n", sizeX, sizeY);
		} // for h
	} // for i
printf("EED  Transparency::createImageByType End\n");
}
	
/*
* Get new image
*/
//------------------------------------------------------------
vtkImageData* Transparency::getImage()
{
	if(_processed){
		return _newImage;
	}
	else{
		return NULL;
	}
}

//------------------------------------------------------------
void Transparency::setImage1(vtkImageData *image)
{
	_image1=image;
}

//------------------------------------------------------------
void Transparency::setImage2(vtkImageData *image)
{
	_image2=image;
}

//------------------------------------------------------------
void Transparency::setPercent(int percent)
{
    _percent=(double)percent/100.0;	
}