#include <vtkMetaImageData.h>
#include "vtkObjectFactory.h"


//#include <vtkVolumeProperty.h>
#include <vtkImageData.h>
#include <vtksys/SystemTools.hxx>
#include <vtkErrorCode.h>


//----------------------------------------------------------------------------
vtkStandardNewMacro( vtkMetaImageData );
vtkCxxRevisionMacro(vtkMetaImageData, "$Revision: 1.4 $");


#ifdef vtkDataManagement_USE_ITK
#include <itkAnalyzeImageIOFactory.h>
#include <itkGDCMImageIOFactory.h>
#include <itkMatrix.h>
#include <itkImage.h>
#endif 

  

//----------------------------------------------------------------------------
vtkMetaImageData::vtkMetaImageData()
{
#ifdef vtkDataManagement_USE_ITK
  itk::AnalyzeImageIOFactory::RegisterOneFactory();
  itk::GDCMImageIOFactory::RegisterOneFactory();
  this->ComponentType = itk::ImageIOBase::UNKNOWNCOMPONENTTYPE;
  m_ItkImage = NULL;
  m_ItkConverter = ItkConverterType::New();
#endif
  this->Type = vtkMetaDataSet::VTK_META_IMAGE_DATA;  
}

//----------------------------------------------------------------------------
vtkMetaImageData::~vtkMetaImageData()
{
}

//----------------------------------------------------------------------------
void vtkMetaImageData::Initialize (void)
{
  //nothing to do
}

//----------------------------------------------------------------------------
vtkImageData* vtkMetaImageData::GetImageData (void) const
{
  if (!this->DataSet)
    return NULL;
  return vtkImageData::SafeDownCast (this->DataSet);
}

//----------------------------------------------------------------------------
void vtkMetaImageData::Read (const char* filename)
{

#ifndef vtkDataManagement_USE_ITK
  vtkErrorMacro(<<"cannot read file without ITK"<<endl);
  throw vtkErrorCode::UserError;
#else

  // Read image in float type
  typedef FloatImageType RealImageType;
  typedef itk::ImageFileReader<RealImageType> RealReaderType;		
  RealReaderType::Pointer reader = RealReaderType::New();		
  reader->SetFileName(filename);					
  try
  {
    std::cout<<"reading "<<filename<<"... ";			
    reader->Update();
    std::cout<<"done."<<std::endl;
  }
  catch(itk::ExceptionObject &e)  {
    std::cerr << e;
    vtkErrorMacro(<<"cannot read file : "<<filename<<endl);
    throw vtkErrorCode::CannotOpenFileError;
  }
  this->SetDataSetAsItkImage(reader->GetOutput());
  
  this->LinkFilters();

  // remember the path of the file
  this->SetFilePath ((vtksys::SystemTools::GetFilenamePath (filename)).c_str());
#endif
}


//----------------------------------------------------------------------------
void vtkMetaImageData::Write (const char* filename)
{

#ifndef vtkDataManagement_USE_ITK
  vtkErrorMacro(<<"cannot write file without ITK"<<endl);
  throw vtkErrorCode::UserError;
#else

  if (this->GetItkImage().IsNull())
  {
    vtkErrorMacro(<<"No data to save");
    throw vtkErrorCode::UserError;
  }
  
  
  // ITK stuff to be able to write analyze format
  
  itk::Matrix<double,3,3> cosines;
  cosines[0][0]= 1;
  cosines[0][1]= 0;
  cosines[0][2]= 0;
  cosines[1][0]= 0;
  cosines[1][1]=-1;
  cosines[1][2]= 0;
  cosines[2][0]= 0;
  cosines[2][1]= 0;
  cosines[2][2]= 1;
  this->GetItkImage()->SetDirection(cosines);
  
  typedef FloatImageType RealImageType;
  typedef itk::ImageFileWriter<RealImageType> RealWriterType;
  RealWriterType::Pointer writer = RealWriterType::New();
  writer->SetFileName(filename);
  writer->SetInput(this->GetItkImage());
  
  try
  {
    std::cout<<"writing "<<filename<<"... ";
    writer->Write();
    std::cout<<"done."<<std::endl;
  }
  catch(itk::ExceptionObject &e)
  {
    std::cerr << e;
    vtkErrorMacro(<<"cannot write file : "<<filename<<endl);
    throw vtkErrorCode::UserError;
  }
  

  // remember the path of the file
  this->SetFilePath ((vtksys::SystemTools::GetFilenamePath (filename)).c_str());
#endif
}


void vtkMetaImageData::LinkFilters (void)
{
  this->Superclass::LinkFilters();
  
#ifdef vtkDataManagement_USE_ITK

  vtkImageData* c_image = this->GetImageData();
  if (c_image)
  {
    m_ItkConverter->SetInput (c_image);
  }
#endif
}


//----------------------------------------------------------------------------
unsigned int vtkMetaImageData::CanReadFile (const char* filename)
{
  
#ifndef vtkDataManagement_USE_ITK
  return 0;
#else
  typedef itk::Image<short, 3>                 ShortImageType;
  typedef itk::ImageFileReader<ShortImageType> ImageReaderType;
  
  ImageReaderType::Pointer reader = ImageReaderType::New();
  reader->SetFileName (filename);
  try
  {
    reader->Update();
    return 1;
  }
  catch (itk::ExceptionObject &e)
  {
    std::cerr << e;
    return 0;
  }
#endif  

  return 0;
}

  
#ifdef vtkDataManagement_USE_ITK
void vtkMetaImageData::SetDataSetAsItkImage(vtkMetaImageData::FloatImageType::Pointer image)
{
  if (image.IsNull())
    return;

  typedef itk::ImageToVTKImageFilter<FloatImageType> ConverterType;
  ConverterType::Pointer converter = ConverterType::New();  
  converter->SetInput (image);

  try
  {
    converter->Update();
  }
  catch(itk::ExceptionObject &e)
  {
    std::cerr << e;
    vtkErrorMacro(<<"error when linking filters"<<endl);
    throw vtkErrorCode::UserError;
  }

  // we have to copy the image
  vtkImageData* input = vtkImageData::New();
  input->DeepCopy(converter->GetOutput());  
  this->SetDataSet (input);
  input->Delete();
  this->LinkFilters();
  
}

vtkMetaImageData::FloatImageType::Pointer vtkMetaImageData::GetItkImage()
{
  if (!this->GetDataSet())
    return NULL;
  
  try
  {
    m_ItkConverter->Update();
  }
  catch(itk::ExceptionObject &e)
  {
    std::cerr << e;
    vtkErrorMacro(<<"error when converting"<<endl);
    throw vtkErrorCode::UserError;
  }
  m_ItkImage = m_ItkConverter->GetOutput();

  return m_ItkImage;
}

#endif  






// //----------------------------------------------------------------------------
// void vtkMetaImageData::Read (const char* filename)
// {

// #ifndef vtkDataManagement_USE_ITK
//   std::cerr<<"ITK not used : cannot read any image..."<<std::endl;
//   return;

// #else

//   // first read the image component type
//   typedef itk::Image<short,3> d_ImageType;
//   typedef itk::ImageFileReader<d_ImageType> d_ReaderType;
//   d_ReaderType::Pointer d_reader = d_ReaderType::New();
//   d_reader->SetFileName(filename);
//   try
//   {
//     d_reader->Update();
//   }
//   catch(itk::ExceptionObject &e)
//   {
//     std::cerr << e;
//     throw itk::ExceptionObject(__FILE__,__LINE__,"Error in vtkMetaImageData::Read ");
//   }

//   // then set the component type to use
//   this->SetComponentType (d_reader->GetImageIO()->GetComponentType());

//   // check if the image can be read
//   if (this->GetComponentType() == itk::ImageIOBase::UNKNOWNCOMPONENTTYPE)
//   {
//     std::cerr << "Unknown component type !" << std::endl;
//     throw itk::ExceptionObject(__FILE__,__LINE__,"Error in vtkMetaImageData::Read ");
//   }
//   if(d_reader->GetImageIO()->GetPixelType() != itk::ImageIOBase::SCALAR)
//   {
//     std::cerr << "Only scalar images can be read" << std::endl;
//     throw itk::ExceptionObject(__FILE__,__LINE__,"Error in vtkMetaImageData::Read ");
//   }


//   // finally read the image : try all types
//   if (this->GetComponentType() == itk::ImageIOBase::UCHAR)
//   {
//     typedef itk::Image<unsigned char,3> RealImageType;
//     ITK_READ_IMAGE;
//   }
//   else if (this->GetComponentType() ==  itk::ImageIOBase::CHAR)
//   {
//     typedef itk::Image<char,3> RealImageType;
//     ITK_READ_IMAGE;
//   }
//   else if (this->GetComponentType() == itk::ImageIOBase::USHORT)
//   {
//     typedef itk::Image<unsigned short,3> RealImageType;
//     ITK_READ_IMAGE;
//   }
//   else if (this->GetComponentType() == itk::ImageIOBase::SHORT)
//   {
//     typedef itk::Image<short,3> RealImageType;
//     ITK_READ_IMAGE;
//   }
//   else if (this->GetComponentType() == itk::ImageIOBase::UINT)
//   {
//     typedef itk::Image<unsigned int,3> RealImageType;
//     ITK_READ_IMAGE;
//   }
//   else if (this->GetComponentType() == itk::ImageIOBase::INT)
//   {
//     typedef itk::Image<int,3> RealImageType;
//     ITK_READ_IMAGE;
//   }
//   else if (this->GetComponentType() == itk::ImageIOBase::ULONG)
//   {
//     typedef itk::Image<unsigned long,3> RealImageType;
//     ITK_READ_IMAGE;
//   }
//   else if (this->GetComponentType() == itk::ImageIOBase::LONG)
//   {
//     typedef itk::Image<long,3> RealImageType;
//     ITK_READ_IMAGE;
//   }
//   else if (this->GetComponentType() == itk::ImageIOBase::FLOAT)
//   {
//     typedef itk::Image<float,3> RealImageType;
//     ITK_READ_IMAGE;
//   }
//   else if (this->GetComponentType() == itk::ImageIOBase::DOUBLE)
//   {
//     typedef itk::Image<float,3> RealImageType;
//     ITK_READ_IMAGE;
//   }
//   else
//   {
//     typedef itk::Image<float,3> RealImageType;
//     ITK_READ_IMAGE;
//   }  
// #endif
  
//   // remember the path of the file
//   this->SetFilePath ((vtksys::SystemTools::GetFilenamePath (filename)).c_str());
  
// }

// //----------------------------------------------------------------------------
// void vtkMetaImageData::Write (const char* filename)
// {

// #ifndef vtkDataManagement_USE_ITK
//   std::cout<<"ITK not used : cannot write any image..."<<std::endl;
//   return;

// #else

//   // check if there is actually any image to save
//   if (!this->GetImageData())
//   {
//     std::cerr << "no image in metadataset !" <<std::endl;
//     throw itk::ExceptionObject(__FILE__,__LINE__,"Error in vtkMetaImageData::Write ");
//   }
  
//   // check if the image can be written
//   if (this->GetComponentType() == itk::ImageIOBase::UNKNOWNCOMPONENTTYPE)
//   {
//     std::cerr << "Unknown component type !" << std::endl;
//     throw itk::ExceptionObject(__FILE__,__LINE__,"Error in vtkMetaImageData::Write ");
//   }

//   // finally save it in the right type.
//   if (this->GetComponentType() == itk::ImageIOBase::UCHAR)
//   {
//     typedef itk::Image<unsigned char,3> RealImageType;
//     ITK_WRITE_IMAGE;
//   }
//   else if (this->GetComponentType() ==  itk::ImageIOBase::CHAR)
//   {
//     typedef itk::Image<char,3> RealImageType;
//     ITK_WRITE_IMAGE;
//   }
//   else if (this->GetComponentType() == itk::ImageIOBase::USHORT)
//   {
//     typedef itk::Image<unsigned short,3> RealImageType;
//     ITK_WRITE_IMAGE;
//   }
//   else if (this->GetComponentType() == itk::ImageIOBase::SHORT)
//   {
//     typedef itk::Image<short,3> RealImageType;
//     ITK_WRITE_IMAGE;
//   }
//   else if (this->GetComponentType() == itk::ImageIOBase::UINT)
//   {
//     typedef itk::Image<unsigned int,3> RealImageType;
//     ITK_WRITE_IMAGE;
//   }
//   else if (this->GetComponentType() == itk::ImageIOBase::INT)
//   {
//     typedef itk::Image<int,3> RealImageType;
//     ITK_WRITE_IMAGE;
//   }
//   else if (this->GetComponentType() == itk::ImageIOBase::ULONG)
//   {
//     typedef itk::Image<unsigned long,3> RealImageType;
//     ITK_WRITE_IMAGE;
//   }
//   else if (this->GetComponentType() == itk::ImageIOBase::LONG)
//   {
//     typedef itk::Image<long,3> RealImageType;
//     ITK_WRITE_IMAGE;
//   }
//   else if (this->GetComponentType() == itk::ImageIOBase::FLOAT)
//   {
//     typedef itk::Image<float,3> RealImageType;
//     ITK_WRITE_IMAGE;
//   }
//   else if (this->GetComponentType() == itk::ImageIOBase::DOUBLE)
//   {
//     typedef itk::Image<float,3> RealImageType;
//     ITK_WRITE_IMAGE;
//   }
//   else
//   {
//     typedef itk::Image<float,3> RealImageType;
//     ITK_WRITE_IMAGE;
//   }
  

// #endif

//   // remember the path of the file
//   this->SetFilePath ((vtksys::SystemTools::GetFilenamePath (filename)).c_str());
// }