/*
# ---------------------------------------------------------------------
#
# Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image
#                        pour la Sante)
# 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 "creaVtkFromVtk4DToItk4D.h"
#include "itkImage.h"
#include "itkImageLinearConstIteratorWithIndex.h"
#include "itkImageRegionConstIterator.h"
#include "itkImageRegionIterator.h"
#include "itkImageFileReader.h"
#include <vector>

template <class TImage>
creaVtkFromVtk4DToItk4D<TImage>::creaVtkFromVtk4DToItk4D()
{
}

template <class TImage>
creaVtkFromVtk4DToItk4D<TImage>::~creaVtkFromVtk4DToItk4D()
{
}

template <class TImage>
void creaVtkFromVtk4DToItk4D<TImage>::SetImage4D(TImage *image)
{
   _image4D = image;
}

template <class TImage>
void creaVtkFromVtk4DToItk4D<TImage>::SetImage4Dvtk(std::vector<vtkImageData*> image)
{
	image4Dvtk = image;
}

template <class TImage>
std::vector<itk::Image< unsigned char > >  creaVtkFromVtk4DToItk4D<TImage>::Process()
{
	/*	
	int dir;	
	double pv[65];
	int count = 0;
	typedef itk::ImageLinearConstIteratorWithIndex< TImage > ConstIteratorType;	
	const unsigned int Dimension = 4;
  typedef unsigned char PixelType;
  typedef itk::Image< PixelType, Dimension > ImageType;
	
	ConstIteratorType inputIt( _image4D, inputRegion );	
	inputIt.SetDirection(3);	
	inputIt.GoToBegin();

  ImageType::RegionType outputRegion;
  ImageType::RegionType::IndexType outputStart;
  outputStart[0] = 0;
  outputStart[1] = 0;
  outputRegion.SetSize( size );
  outputRegion.SetIndex( outputStart );

	while( !inputIt.IsAtEnd() )
	{
			inputIt.GoToBeginOfLine();
			count = 0;
			while( !inputIt.IsAtEndOfLine() )
			{	
				pv[count] = inputIt.Get();
				++inputIt;
				++count;				
			}
	}
*/
	const unsigned int Dimension = 4;
  typedef unsigned char PixelType;
  typedef itk::Image< PixelType, Dimension > ImageType;
  typedef itk::ImageRegionConstIterator< ImageType > ConstIteratorType;
  typedef itk::ImageRegionIterator< ImageType> IteratorType;
	
  //typedef itk::ImageFileReader< ImageType > ReaderType;
  //typedef itk::ImageFileWriter< ImageType > WriterType;
  
  ImageType::RegionType inputRegion;
  ImageType::RegionType::IndexType inputStart;
  ImageType::RegionType::SizeType  size;
  inputStart[0] = ::atoi( "20" );
  inputStart[1] = ::atoi( "70" );
  size[0]  = ::atoi( "210" );
  size[1]  = ::atoi( "140" );
  inputRegion.SetSize( size );
  inputRegion.SetIndex( inputStart );

  ImageType::RegionType outputRegion;
  ImageType::RegionType::IndexType outputStart;
  outputStart[0] = 0;
  outputStart[1] = 0;
	outputStart[2] = 0;
  outputStart[3] = 0;
  outputRegion.SetSize( size );
  outputRegion.SetIndex( outputStart );

	/*
  ReaderType::Pointer reader = ReaderType::New();
 	reader->SetFileName( "foo.vtk" );
  try
    {
    reader->Update();
    }
 	catch ( itk::ExceptionObject &err)
    {
    std::cerr << "ExceptionObject caught !" << std::endl;
    std::cerr << err << std::endl;
    return -1;
    }

  if ( ! reader->GetOutput()->GetRequestedRegion().IsInside( inputRegion ) )
    {
    std::cerr << "Error" << std::endl;
    std::cerr << "The region " << inputRegion << "is not contained within the input image region "
              << reader->GetOutput()->GetRequestedRegion() << std::endl;
    return -1;
    }*/
	std::vector<ImageType::Pointer> outputImage4D;
 	for(int k = 0 ; k < image4Dvtk.size() ; k++){
			ImageType::Pointer outputImage = ImageType::New();
			outputImage->SetRegions( outputRegion );
			const ImageType::SpacingType& spacing = image4Dvtk[k]->GetSpacing();
			const ImageType::PointType& inputOrigin = image4Dvtk[k]->GetOrigin();
			double outputOrigin[ Dimension ];
			for(unsigned int i=0; i< Dimension; i++)
				{
				outputOrigin[i] = inputOrigin[i] + spacing[i] * inputStart[i];
				}
			outputImage->SetSpacing( spacing );
			outputImage->SetOrigin(  outputOrigin );
			outputImage->Allocate();

			ConstIteratorType inputIt( image4Dvtk[k], inputRegion  );
			IteratorType outputIt( outputImage, outputRegion );
			inputIt.GoToBegin();
			outputIt.GoToBegin();
			
			while( !outputIt.IsAtEnd() )
				{
				outputIt.Set( inputIt.Get() );
			 	++inputIt;
				++outputIt;
				}
			outputImage4D[k]=outputImage;
	}
	return outputImage4D;
}
//---------------------------------------------
//Method template
//---------------------------------------------
/*
void creaVtkFromVtk4DToItk4D::FunctionName(int& parameterA)
{
  parameterA = 2 * parameterA;
  return;
}
*/