#include "bbvtkUnaryOperations.h"
#include "bbvtkPackage.h"
namespace bbvtk
{


BBTK_ADD_BLACK_BOX_TO_PACKAGE(vtk,UnaryOperations)
BBTK_BLACK_BOX_IMPLEMENTATION(UnaryOperations,bbtk::AtomicBlackBox);
void UnaryOperations::Process()
{

// THE MAIN PROCESSING METHOD BODY
//   Here we simply set the input 'In' value to the output 'Out'
//   And print out the output value
// INPUT/OUTPUT ACCESSORS ARE OF THE FORM :
//    void bbSet{Input|Output}NAME(const TYPE&)
//    const TYPE& bbGet{Input|Output}NAME() const
//    Where :
//    * NAME is the name of the input/output
//      (the one provided in the attribute 'name' of the tag 'input')
//    * TYPE is the C++ type of the input/output
//      (the one provided in the attribute 'type' of the tag 'input')

	if (bbGetInputIn1() == NULL)
	{
		std::cout << "Set In1 at least" << std::endl;
		return;
	}

	ope->SetInput1((vtkDataObject*)bbGetInputIn1());


	ope->SetConstantK(bbGetInputInConstant());
	ope->SetConstantC(bbGetInputInConstant());

	switch (bbGetInputOperation())
	{
		case 0:
				ope->SetOperationToAddConstant();

		break;
		case 1:
//EED Borrame				crearPredeterminado();
				ope->SetInput2((vtkDataSet*) constante);
				ope->SetOperationToSubtract();
		break;
		case 2:
                ope->SetInput2((vtkDataSet*) constante);
				ope->SetOperationToMultiply();

		break;
		case 3:

				ope->SetOperationToDivide();
		break;
		case 4:
			 ope->SetOperationToInvert();
		break;
		case 9:
			 ope->SetOperationToAbsoluteValue();
		break;
		case 5:

				ope->SetOperationToSin();
		break;
		case 6:

			ope->SetOperationToCos();

		break;
		case 7:

				ope->SetOperationToExp();
		break;
		case 8:

				ope->SetOperationToLog();
		break;
		case 10:
			substractWithMinimum();
			bbSetOutputOut(constante);
			return;
		break;
		case 11:
			MultiplyBy();
			bbSetOutputOut(constante);
			return;
		break;
		default:
			std::cout << "Invalid Operation" << std::endl;
			return;
		break;
	}

	ope->Update();
	vtkImageData* salida = ope->GetOutput();

	bbSetOutputOut(salida);
	bbSignalOutputModification();

}
	
/* Borrame Eduardo - Juan Pablo
void UnaryOperations::crearPredeterminado()
{
	int ext[6];
	vtkImageData* inicial = bbGetInputIn1();


	if (constante == NULL)
	{
		inicial->GetExtent(ext);
		constante = vtkImageData::New();
		constante->SetExtent(ext);
		constante->SetScalarType(inicial->GetScalarType());
		constante->AllocateScalars();
		constante->Update();
	}

	for (int i=ext[0]; i<=ext[1]; i++)
	{
		for (int j=ext[2]; j<=ext[3]; j++)
		{
			for (int k=ext[4]; k<=ext[5]; k++)
			{
				unsigned short* value = (unsigned short*)constante->GetScalarPointer(i,j,k);
				*value = bbGetInputInConstant();
			}
		}
	}
}
*/

	
void UnaryOperations::substractWithMinimum()
{
	int ext[6];
	double spc[3];
	vtkImageData* inicial = bbGetInputIn1();


	if (constante == NULL)
	{
		inicial->GetExtent(ext);
		inicial->GetSpacing(spc);
		constante = vtkImageData::New();
		constante->SetExtent(ext);
		constante->SetSpacing(spc);
		constante->SetOrigin(inicial->GetOrigin());
		constante->SetScalarType(inicial->GetScalarType());
		constante->AllocateScalars();
		constante->Update();
	}

	for (int i=ext[0]; i<=ext[1]; i++)
	{
		for (int j=ext[2]; j<=ext[3]; j++)
		{
			for (int k=ext[4]; k<=ext[5]; k++)
			{
				double temp1 = lector.getPixelValue(i,j,k,inicial);
				double temp = temp1 - bbGetInputInConstant();
				if (temp < 0)
					temp = 0;
				lector.setPixelValue(i,j,k,constante,temp);
			}
		}
	}
}

void UnaryOperations::MultiplyBy()
{
	int ext[6];
	double spc[3];
	vtkImageData* inicial = bbGetInputIn1();


	if (constante == NULL)
	{
		inicial->GetExtent(ext);
		inicial->GetSpacing(spc);
		constante = vtkImageData::New();
		constante->SetExtent(ext);
		constante->SetSpacing(spc);
		constante->SetOrigin(inicial->GetOrigin());
		constante->SetScalarType(inicial->GetScalarType());
		constante->AllocateScalars();
		constante->Update();
	}

	for (int i=ext[0]; i<=ext[1]; i++)
	{
		for (int j=ext[2]; j<=ext[3]; j++)
		{
			for (int k=ext[4]; k<=ext[5]; k++)
			{
				double temp1 = lector.getPixelValue(i,j,k,inicial);
				double temp = temp1 * bbGetInputInConstant();
				if (temp < 0)
					temp = 0;
				lector.setPixelValue(i,j,k,constante,temp);
			}
		}
	}
}

void UnaryOperations::bbUserSetDefaultValues()
{

//  SET HERE THE DEFAULT INPUT/OUTPUT VALUES OF YOUR BOX
//    Here we initialize the input 'In' to 0
   bbSetInputIn1(NULL);
//   bbSetInputIn2(NULL);
   bbSetOutputOut(NULL);
   bbSetInputInConstant(0);
   bbSetInputOperation(0);
   ope = vtkImageMathematics::New();
   constante = NULL;
}
void UnaryOperations::bbUserInitializeProcessing()
{

//  THE INITIALIZATION METHOD BODY :
//    Here does nothing
//    but this is where you should allocate the internal/output pointers
//    if any


}
void UnaryOperations::bbUserFinalizeProcessing()
{

//  THE FINALIZATION METHOD BODY :
//    Here does nothing
//    but this is where you should desallocate the internal/output pointers
//    if any

}
}
// EO namespace bbvtk