#ifndef __CPPLUGINS__INTERFACE__IMAGE__HXX__
#define __CPPLUGINS__INTERFACE__IMAGE__HXX__

#include <cpPlugins/Interface/Macros.h>

#include <itkImage.h>
#include <itkImageToVTKImageFilter.h>

#include <itkCovariantVector.h>
#include <itkDiffusionTensor3D.h>
#include <itkPoint.h>
#include <itkRGBPixel.h>
#include <itkRGBAPixel.h>
#include <itkSymmetricSecondRankTensor.h>
#include <itkVector.h>

// -------------------------------------------------------------------------
#define cpPlugins_Image_Demangle( TI, T, D, o )                 \
  if( typeid( typename TI::PixelType ) == typeid( T ) )         \
    this->_ITK_2_VTK< T, D >( o )

// -------------------------------------------------------------------------
#define cpPlugins_ImageArray_Demangle( TI, T, P, DP, DI, o )           \
  if( typeid( typename TI::PixelType ) == typeid( T< P, DP > ) )       \
    this->_ITK_2_VTK< T< P, DP >, DI >( o )

// -------------------------------------------------------------------------
#define cpPlugins_Image_Demangle_Dimension( TI, D, o )                  \
  cpPlugins_Image_Demangle( TI, char, D, o );                           \
  else cpPlugins_Image_Demangle( TI, short, D, o );                     \
  else cpPlugins_Image_Demangle( TI, int, D, o );                       \
  else cpPlugins_Image_Demangle( TI, long, D, o );                      \
  else cpPlugins_Image_Demangle( TI, float, D, o );                     \
  else cpPlugins_Image_Demangle( TI, double, D, o );                    \
  else cpPlugins_Image_Demangle( TI, unsigned char, D, o );             \
  else cpPlugins_Image_Demangle( TI, unsigned short, D, o );            \
  else cpPlugins_Image_Demangle( TI, unsigned int, D, o );              \
  else cpPlugins_Image_Demangle( TI, unsigned long, D, o );             \
  else cpPlugins_Image_Demangle( TI, itk::RGBPixel< char >, D, o );     \
  else cpPlugins_Image_Demangle( TI, itk::RGBPixel< short >, D, o );    \
  else cpPlugins_Image_Demangle(                                        \
    TI, itk::RGBPixel< unsigned char >, D, o                            \
    );                                                                  \
  else cpPlugins_Image_Demangle(                                        \
    TI, itk::RGBPixel< unsigned short >, D, o                           \
    );                                                                  \
  else cpPlugins_Image_Demangle( TI, itk::RGBAPixel< char >, D, o );    \
  else cpPlugins_Image_Demangle( TI, itk::RGBAPixel< short >, D, o );   \
  else cpPlugins_Image_Demangle(                                        \
    TI, itk::RGBAPixel< unsigned char >, D, o                           \
    );                                                                  \
  else cpPlugins_Image_Demangle(                                        \
    TI, itk::RGBAPixel< unsigned short >, D, o                          \
    );                                                                  \
  else cpPlugins_ImageArray_Demangle(                                   \
    TI, itk::Vector, float, D, D, o                                     \
    );                                                                  \
  else cpPlugins_ImageArray_Demangle(                                   \
    TI, itk::Vector, double, D, D, o                                    \
    );                                                                  \
  else cpPlugins_ImageArray_Demangle(                                   \
    TI, itk::CovariantVector, float, D, D, o                            \
    );                                                                  \
  else cpPlugins_ImageArray_Demangle(                                   \
    TI, itk::CovariantVector, double, D, D, o                           \
    );                                                                  \
  else cpPlugins_ImageArray_Demangle( TI, itk::Point, float, D, D, o ); \
  else cpPlugins_ImageArray_Demangle(                                   \
    TI, itk::Point, double, D, D, o                                     \
    );                                                                  \
  else cpPlugins_ImageArray_Demangle(                                   \
    TI, itk::SymmetricSecondRankTensor, float, D, D, o                  \
    );                                                                  \
  else cpPlugins_ImageArray_Demangle(                                   \
    TI, itk::SymmetricSecondRankTensor, double, D, D, o                 \
    )

// -------------------------------------------------------------------------
#define cpPlugins_Image_Import( T, D )                                  \
  cpPlugins_TEMPLATE_IMPORT(                                            \
    2(class cpPlugins_Interface_EXPORT itk::Image< T, D >)              \
    )

// -------------------------------------------------------------------------
#define cpPlugins_VTKImage_Import( T, D )                               \
  cpPlugins_TEMPLATE_IMPORT(                                            \
    2(                                                                  \
      class cpPlugins_Interface_EXPORT                                  \
      itk::ImageToVTKImageFilter< itk::Image< T, D > >                  \
      )                                                                 \
    )

// -------------------------------------------------------------------------
#define cpPlugins_ImageArray_Import( A, T, DA, DI )                     \
  cpPlugins_TEMPLATE_IMPORT(                                            \
    3(                                                                  \
      class cpPlugins_Interface_EXPORT                                  \
      itk::Image< itk::A< T, DA >, DI >                                 \
      )                                                                 \
    )

// -------------------------------------------------------------------------
#define cpPlugins_VTKImageArray_Import( A, T, DA, DI )                  \
  cpPlugins_TEMPLATE_IMPORT(                                            \
    3(                                                                  \
      class cpPlugins_Interface_EXPORT                                  \
      itk::ImageToVTKImageFilter< itk::Image< itk::A< T, DA >, DI > >   \
      )                                                                 \
    )

// -------------------------------------------------------------------------
#define cpPlugins_Image_Import_AllDimensions( T )       \
  cpPlugins_Image_Import( T, 2 );                       \
  cpPlugins_Image_Import( T, 3 );                       \
  cpPlugins_Image_Import( T, 4 )

// -------------------------------------------------------------------------
#define cpPlugins_VTKImage_Import_AllDimensions( T )       \
  cpPlugins_VTKImage_Import( T, 2 );                       \
  cpPlugins_VTKImage_Import( T, 3 )

// -------------------------------------------------------------------------
#define cpPlugins_ImageArray_Import_AllDimensions( A, T )             \
  cpPlugins_ImageArray_Import( A, T, 2, 2 );                          \
  cpPlugins_ImageArray_Import( A, T, 3, 3 );                          \
  cpPlugins_ImageArray_Import( A, T, 4, 4 )

// -------------------------------------------------------------------------
#define cpPlugins_VTKImageArray_Import_AllDimensions( A, T )            \
  cpPlugins_VTKImageArray_Import( A, T, 2, 2 );                         \
  cpPlugins_VTKImageArray_Import( A, T, 3, 3 )

// -------------------------------------------------------------------------
// ITK base clases

#ifndef cpPlugins_Interface_EXPORTS

cpPlugins_Image_Import_AllDimensions( char );
cpPlugins_Image_Import_AllDimensions( short );
cpPlugins_Image_Import_AllDimensions( int );
cpPlugins_Image_Import_AllDimensions( long );
cpPlugins_Image_Import_AllDimensions( unsigned char );
cpPlugins_Image_Import_AllDimensions( unsigned short );
cpPlugins_Image_Import_AllDimensions( unsigned int );
cpPlugins_Image_Import_AllDimensions( unsigned long );
cpPlugins_Image_Import_AllDimensions( float );
cpPlugins_Image_Import_AllDimensions( double );

cpPlugins_Image_Import_AllDimensions( std::complex< float > );
cpPlugins_Image_Import_AllDimensions( std::complex< double > );

cpPlugins_Image_Import_AllDimensions( itk::RGBPixel< char > );
cpPlugins_Image_Import_AllDimensions( itk::RGBPixel< short > );
cpPlugins_Image_Import_AllDimensions( itk::RGBPixel< int > );
cpPlugins_Image_Import_AllDimensions( itk::RGBPixel< long > );
cpPlugins_Image_Import_AllDimensions( itk::RGBPixel< unsigned char > );
cpPlugins_Image_Import_AllDimensions( itk::RGBPixel< unsigned short > );
cpPlugins_Image_Import_AllDimensions( itk::RGBPixel< unsigned int > );
cpPlugins_Image_Import_AllDimensions( itk::RGBPixel< unsigned long > );

cpPlugins_Image_Import_AllDimensions( itk::RGBAPixel< char > );
cpPlugins_Image_Import_AllDimensions( itk::RGBAPixel< short > );
cpPlugins_Image_Import_AllDimensions( itk::RGBAPixel< int > );
cpPlugins_Image_Import_AllDimensions( itk::RGBAPixel< long > );
cpPlugins_Image_Import_AllDimensions( itk::RGBAPixel< unsigned char > );
cpPlugins_Image_Import_AllDimensions( itk::RGBAPixel< unsigned short > );
cpPlugins_Image_Import_AllDimensions( itk::RGBAPixel< unsigned int > );
cpPlugins_Image_Import_AllDimensions( itk::RGBAPixel< unsigned long > );

cpPlugins_ImageArray_Import_AllDimensions( Vector, float );
cpPlugins_ImageArray_Import_AllDimensions( Vector, double );

cpPlugins_ImageArray_Import_AllDimensions( CovariantVector, float );
cpPlugins_ImageArray_Import_AllDimensions( CovariantVector, double );

cpPlugins_ImageArray_Import_AllDimensions( Point, float );
cpPlugins_ImageArray_Import_AllDimensions( Point, double );

cpPlugins_ImageArray_Import_AllDimensions(
  SymmetricSecondRankTensor, float
  );
cpPlugins_ImageArray_Import_AllDimensions(
  SymmetricSecondRankTensor, double
  );

cpPlugins_Image_Import( itk::DiffusionTensor3D< float >, 3 );
cpPlugins_Image_Import( itk::DiffusionTensor3D< double >, 3 );
cpPlugins_Image_Import( itk::Offset< 2 >, 2 );
cpPlugins_Image_Import( itk::Offset< 3 >, 3 );
cpPlugins_Image_Import( itk::Offset< 4 >, 4 );

// -------------------------------------------------------------------------
// ITK<->VTK base clases
cpPlugins_VTKImage_Import_AllDimensions( char );
cpPlugins_VTKImage_Import_AllDimensions( short );
cpPlugins_VTKImage_Import_AllDimensions( int );
cpPlugins_VTKImage_Import_AllDimensions( long );
cpPlugins_VTKImage_Import_AllDimensions( unsigned char );
cpPlugins_VTKImage_Import_AllDimensions( unsigned short );
cpPlugins_VTKImage_Import_AllDimensions( unsigned int );
cpPlugins_VTKImage_Import_AllDimensions( unsigned long );
cpPlugins_VTKImage_Import_AllDimensions( float );
cpPlugins_VTKImage_Import_AllDimensions( double );

cpPlugins_VTKImage_Import_AllDimensions( itk::RGBPixel< char > );
cpPlugins_VTKImage_Import_AllDimensions( itk::RGBPixel< short > );
cpPlugins_VTKImage_Import_AllDimensions( itk::RGBPixel< int > );
cpPlugins_VTKImage_Import_AllDimensions( itk::RGBPixel< long > );
cpPlugins_VTKImage_Import_AllDimensions( itk::RGBPixel< unsigned char > );
cpPlugins_VTKImage_Import_AllDimensions( itk::RGBPixel< unsigned short > );
cpPlugins_VTKImage_Import_AllDimensions( itk::RGBPixel< unsigned int > );
cpPlugins_VTKImage_Import_AllDimensions( itk::RGBPixel< unsigned long > );
cpPlugins_VTKImage_Import_AllDimensions( itk::RGBPixel< float > );
cpPlugins_VTKImage_Import_AllDimensions( itk::RGBPixel< double > );

cpPlugins_VTKImage_Import_AllDimensions( itk::RGBAPixel< char > );
cpPlugins_VTKImage_Import_AllDimensions( itk::RGBAPixel< short > );
cpPlugins_VTKImage_Import_AllDimensions( itk::RGBAPixel< int > );
cpPlugins_VTKImage_Import_AllDimensions( itk::RGBAPixel< long > );
cpPlugins_VTKImage_Import_AllDimensions( itk::RGBAPixel< unsigned char > );
cpPlugins_VTKImage_Import_AllDimensions( itk::RGBAPixel< unsigned short > );
cpPlugins_VTKImage_Import_AllDimensions( itk::RGBAPixel< unsigned int > );
cpPlugins_VTKImage_Import_AllDimensions( itk::RGBAPixel< unsigned long > );
cpPlugins_VTKImage_Import_AllDimensions( itk::RGBAPixel< float > );
cpPlugins_VTKImage_Import_AllDimensions( itk::RGBAPixel< double > );

cpPlugins_VTKImageArray_Import_AllDimensions( Vector, float );
cpPlugins_VTKImageArray_Import_AllDimensions( Vector, double );

cpPlugins_VTKImageArray_Import_AllDimensions( CovariantVector, float );
cpPlugins_VTKImageArray_Import_AllDimensions( CovariantVector, double );

cpPlugins_VTKImageArray_Import_AllDimensions( Point, float );
cpPlugins_VTKImageArray_Import_AllDimensions( Point, double );

cpPlugins_VTKImageArray_Import_AllDimensions(
  SymmetricSecondRankTensor, float
  );
cpPlugins_VTKImageArray_Import_AllDimensions(
  SymmetricSecondRankTensor, double
  );

cpPlugins_VTKImage_Import( itk::DiffusionTensor3D< float >, 3 );
cpPlugins_VTKImage_Import( itk::DiffusionTensor3D< double >, 3 );

#endif // cpPlugins_Interface_EXPORTS

// -------------------------------------------------------------------------
template< class I >
void cpPlugins::Interface::Image::
SetITKImage( itk::DataObject* object )
{
  // Check if input object has the desired type
  I* image = dynamic_cast< I* >( object );
  if( image == NULL )
  {
    this->m_ITKObject = NULL;
    this->m_VTKObject = NULL;
    this->m_ITKvVTKConnection = NULL;
    this->Modified( );

  } // fi

  // Connect it to VTK
  if( I::ImageDimension == 2 )
  {
    cpPlugins_Image_Demangle_Dimension( I, 2, object );
    else
    {
      this->m_VTKObject = NULL;
      this->m_ITKvVTKConnection = NULL;

    } // fi
  }
  else if( I::ImageDimension == 3 )
  {
    cpPlugins_Image_Demangle_Dimension( I, 3, object );
    else cpPlugins_Image_Demangle(
      I, itk::DiffusionTensor3D< float >, 3, object
      );
    else cpPlugins_Image_Demangle(
      I, itk::DiffusionTensor3D< double >, 3, object
      );
    else
    {
      this->m_VTKObject = NULL;
      this->m_ITKvVTKConnection = NULL;

    } // fi
  }
  else
  {
    this->m_VTKObject = NULL;
    this->m_ITKvVTKConnection = NULL;

  } // fi

  // Keep objects
  this->m_ITKObject = object;
  this->Modified( );
}

// -------------------------------------------------------------------------
template< class I >
I* cpPlugins::Interface::Image::
GetITKImage( )
{
  return( dynamic_cast< I* >( this->m_ITKObject.GetPointer( ) ) );
}

// -------------------------------------------------------------------------
template< class I >
const I* cpPlugins::Interface::Image::
GetITKImage( ) const
{
  return( dynamic_cast< const I* >( this->m_ITKObject.GetPointer( ) ) );
}

// -------------------------------------------------------------------------
template< class P, unsigned int D >
void cpPlugins::Interface::Image::
_ITK_2_VTK( itk::DataObject* object )
{
  typedef itk::Image< P, D > _I;

  // Check if input object has the desired type
  _I* image = dynamic_cast< _I* >( object );
  if( image == NULL )
    return;

  // Connect it to VTK
  typename itk::ImageToVTKImageFilter< _I >::Pointer f =
    itk::ImageToVTKImageFilter< _I >::New( );
  f->SetInput( image );
  f->Update( );

  // Keep objects
  this->m_VTKObject = f->GetOutput( );
  this->m_ITKvVTKConnection = f;
}

#endif // __CPPLUGINS__INTERFACE__IMAGE__HXX__

// eof - $RCSfile$