#include <cpPlugins/Plugins/ImageReader.h>
#include <cpPlugins/Interface/Image.h>

#include <itkImageFileReader.h>

#define ITK_MANUAL_INSTANTIATION
#include <itkImage.h>
#include <itkRGBPixel.h>

// -------------------------------------------------------------------------
cpPlugins::Plugins::ImageReader::
ImageReader( )
  : Superclass( )
{
  this->SetNumberOfOutputs( 1 );
  this->_MakeOutput< cpPlugins::Interface::Image >( 0 );

  this->m_DefaultParameters[ "FileName" ] =
    TParameter( "string", "no_file_name" );
  this->m_DefaultParameters[ "PixelType" ] = TParameter( "type", "uchar" );
  this->m_DefaultParameters[ "ImageDimension" ] = TParameter( "int", "2" );
  this->m_DefaultParameters[ "IsColorImage" ] = TParameter( "bool", "0" );
}

// -------------------------------------------------------------------------
cpPlugins::Plugins::ImageReader::
~ImageReader( )
{
}

// -------------------------------------------------------------------------
std::string cpPlugins::Plugins::ImageReader::
GetClassName( ) const
{
  return( "cpPlugins::Plugins::ImageReader" );
}

// -------------------------------------------------------------------------
std::string cpPlugins::Plugins::ImageReader::
_GenerateData( )
{
  TParameters::const_iterator dIt;

  // Get image dimension
  dIt = this->m_Parameters.find( "ImageDimension" );
  if( dIt == this->m_Parameters.end( ) )
    dIt = this->m_DefaultParameters.find( "ImageDimension" );

  std::string r = "itk::Image dimension not supported.";
  if     ( dIt->second.second == "1" ) r = this->_GD0< 1 >( );
  else if( dIt->second.second == "2" ) r = this->_GD0< 2 >( );
  else if( dIt->second.second == "3" ) r = this->_GD0< 3 >( );
  else if( dIt->second.second == "4" ) r = this->_GD0< 4 >( );

  return( r );
}

// -------------------------------------------------------------------------
template< unsigned int D >
std::string cpPlugins::Plugins::ImageReader::
_GD0( )
{
  TParameters::const_iterator tIt, cIt;

  // Get image pixel type
  tIt = this->m_Parameters.find( "PixelType" );
  if( tIt == this->m_Parameters.end( ) )
    tIt = this->m_DefaultParameters.find( "PixelType" );
  cIt = this->m_Parameters.find( "IsColorImage" );
  if( cIt == this->m_Parameters.end( ) )
    cIt = this->m_DefaultParameters.find( "IsColorImage" );

  std::string r = "itk::Image pixel type not supported";
  if( cIt->second.second == "0" )
  {
    if( tIt->second.second == "char" )
      r = this->_GD1< char, D >( );
    else if( tIt->second.second == "short" )
      r = this->_GD1< short, D >( );
    else if( tIt->second.second == "int" )
      r = this->_GD1< int, D >( );
    else if( tIt->second.second == "long" )
      r = this->_GD1< long, D >( );
    else if( tIt->second.second == "uchar" )
      r = this->_GD1< unsigned char, D >( );
    else if( tIt->second.second == "ushort" )
      r = this->_GD1< unsigned short, D >( );
    else if( tIt->second.second == "uint" )
      r = this->_GD1< unsigned int, D >( );
    else if( tIt->second.second == "ulong" )
      r = this->_GD1< unsigned long, D >( );
    else if( tIt->second.second == "float" )
      r = this->_GD1< float, D >( );
    else if( tIt->second.second == "double" )
      r = this->_GD1< double, D >( );
  }
  else if( cIt->second.second == "1" )
  {
    if( tIt->second.second == "char" )
      r = this->_GD1< itk::RGBPixel< char >, D >( );
    else if( tIt->second.second == "short" )
      r = this->_GD1< itk::RGBPixel< short >, D >( );
    else if( tIt->second.second == "int" )
      r = this->_GD1< itk::RGBPixel< int >, D >( );
    else if( tIt->second.second == "long" )
      r = this->_GD1< itk::RGBPixel< long >, D >( );
    else if( tIt->second.second == "uchar" )
      r = this->_GD1< itk::RGBPixel< unsigned char >, D >( );
    else if( tIt->second.second == "ushort" )
      r = this->_GD1< itk::RGBPixel< unsigned short >, D >( );
    else if( tIt->second.second == "uint" )
      r = this->_GD1< itk::RGBPixel< unsigned int >, D >( );
    else if( tIt->second.second == "ulong" )
      r = this->_GD1< itk::RGBPixel< unsigned long >, D >( );
    else if( tIt->second.second == "float" )
      r = this->_GD1< itk::RGBPixel< float >, D >( );
    else if( tIt->second.second == "double" )
      r = this->_GD1< itk::RGBPixel< double >, D >( );
  } // fi
  return( r );
}

// -------------------------------------------------------------------------
template< class P, unsigned int D >
std::string cpPlugins::Plugins::ImageReader::
_GD1( )
{
  TParameters::const_iterator fIt;

  // Get filename
  fIt = this->m_Parameters.find( "FileName" );
  if( fIt == this->m_Parameters.end( ) )
    fIt = this->m_DefaultParameters.find( "FileName" );

  typedef itk::Image< P, D > _TImage;
  typedef itk::ImageFileReader< _TImage > _TImageReader;

  _TImageReader* reader =
    dynamic_cast< _TImageReader* >( this->m_Reader.GetPointer( ) );
  if( reader == NULL )
  {
    this->m_Reader = _TImageReader::New( );
    reader = dynamic_cast< _TImageReader* >( this->m_Reader.GetPointer( ) );

  } // fi
  reader->SetFileName( fIt->second.second );
  try
  {
    reader->Update( );
  }
  catch( itk::ExceptionObject& err )
  {
    return( err.GetDescription( ) );

  } // yrt
  this->_SetOutput( 0, reader->GetOutput( ) );
  return( "" );
}

// eof - $RCSfile$