#ifndef __CPPLUGINS__INTERFACE__IMAGE__HXX__
#define __CPPLUGINS__INTERFACE__IMAGE__HXX__

#include <complex>

#include <itkImage.h>
#include <itkVectorImage.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_VTKImage_Demangle( TI, T, D, o )              \
  if( typeid( TI ) == typeid( itk::Image< T, D > ) )            \
    this->_ITK_2_VTK< T, D >( o )

// -------------------------------------------------------------------------
#define cpPlugins_VTKImageArray_Demangle( TI, T, P, DP, DI, o )      \
  if( typeid( TI ) == typeid( itk::Image< T< P, DP >, DI > ) )       \
    this->_ITK_2_VTK< T< P, DP >, DI >( o )

// -------------------------------------------------------------------------
#define cpPlugins_VTKImage_Demangle_AllDims( TI, T, o )         \
  cpPlugins_VTKImage_Demangle( TI, T, 2, o );                   \
  else cpPlugins_VTKImage_Demangle( TI, T, 3, o )

// -------------------------------------------------------------------------
#define cpPlugins_VTKImageArray_Demangle_AllDims( TI, T, P, o )      \
  cpPlugins_VTKImageArray_Demangle( TI, T, P, 2, 2, o );             \
  else cpPlugins_VTKImageArray_Demangle( TI, T, P, 3, 3, o )

// -------------------------------------------------------------------------
template< class I >
void cpPlugins::Interface::Image::
SetITK( itk::Object* 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

  // --------- TODO ---------------
  typename I::DirectionType norm_dir;
  norm_dir.SetIdentity( );
  image->SetDirection( norm_dir );
  // --------- TODO ---------------

  // Connect it to VTK
  cpPlugins_VTKImage_Demangle_AllDims( I, char, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, short, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, int, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, long, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, unsigned char, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, unsigned short, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, unsigned int, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, unsigned long, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, float, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, double, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, itk::RGBPixel< char >, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, itk::RGBPixel< short >, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, itk::RGBPixel< int >, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, itk::RGBPixel< long >, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, itk::RGBPixel< unsigned char >, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, itk::RGBPixel< unsigned short >, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, itk::RGBPixel< unsigned int >, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, itk::RGBPixel< unsigned long >, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, itk::RGBPixel< float >, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, itk::RGBPixel< double >, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, itk::RGBAPixel< char >, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, itk::RGBAPixel< short >, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, itk::RGBAPixel< int >, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, itk::RGBAPixel< long >, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, itk::RGBAPixel< unsigned char >, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, itk::RGBAPixel< unsigned short >, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, itk::RGBAPixel< unsigned int >, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, itk::RGBAPixel< unsigned long >, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, itk::RGBAPixel< float >, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, itk::RGBAPixel< double >, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, itk::DiffusionTensor3D< float >, image );
  else cpPlugins_VTKImage_Demangle_AllDims( I, itk::DiffusionTensor3D< double >, image );
  else cpPlugins_VTKImageArray_Demangle_AllDims( I, itk::Vector, float, image );
  else cpPlugins_VTKImageArray_Demangle_AllDims( I, itk::Vector, double, image );
  else cpPlugins_VTKImageArray_Demangle_AllDims( I, itk::CovariantVector, float, image );
  else cpPlugins_VTKImageArray_Demangle_AllDims( I, itk::CovariantVector, double, image );
  else cpPlugins_VTKImageArray_Demangle_AllDims( I, itk::Point, float, image );
  else cpPlugins_VTKImageArray_Demangle_AllDims( I, itk::Point, double, image );
  else cpPlugins_VTKImageArray_Demangle_AllDims( I, itk::SymmetricSecondRankTensor, float, image );
  else cpPlugins_VTKImageArray_Demangle_AllDims( I, itk::SymmetricSecondRankTensor, double, image );
  else
  {
    this->m_VTKObject = NULL;
    this->m_ITKvVTKConnection = NULL;

  } // fi

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

// -------------------------------------------------------------------------
template< class P, unsigned int D >
void cpPlugins::Interface::Image::
_ITK_2_VTK( itk::Object* 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;
}

#ifndef cpPlugins_Interface_EXPORTS

// =========================================================================
// ==========           Declare import itk::Image types           ==========
// =========================================================================

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

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

// -------------------------------------------------------------------------
#define cpPlugins_ITKImage_AllDims_Import( T )  \
  cpPlugins_ITKImage_Import( T, 2 );            \
  cpPlugins_ITKImage_Import( T, 3 );            \
  cpPlugins_ITKImage_Import( T, 4 )

// -------------------------------------------------------------------------
#define cpPlugins_ITKArrayImage_AllDims_Import( A, T )  \
  cpPlugins_ITKArrayImage_Import( A, T, 2, 2 );         \
  cpPlugins_ITKArrayImage_Import( A, T, 3, 3 );         \
  cpPlugins_ITKArrayImage_Import( A, T, 4, 4 )

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

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

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

// -------------------------------------------------------------------------
#define cpPlugins_VTKArrayImage_AllDims_Import( A, T )  \
  cpPlugins_VTKArrayImage_Import( A, T, 2, 2 );         \
  cpPlugins_VTKArrayImage_Import( A, T, 3, 3 )

// -------------------------------------------------------------------------
#define cpPlugins_Image_Import( T, D )          \
  cpPlugins_ITKImage_Import( T, D );            \
  cpPlugins_VTKImage_Import( T, D )             \
  
// -------------------------------------------------------------------------
#define cpPlugins_Image_AllDims_Import( T )     \
  cpPlugins_ITKImage_AllDims_Import( T );       \
  cpPlugins_VTKImage_AllDims_Import( T )        \
  
// -------------------------------------------------------------------------
#define cpPlugins_ArrayImage_AllDims_Import( A, T )     \
  cpPlugins_ITKArrayImage_AllDims_Import( A, T );       \
  cpPlugins_VTKArrayImage_AllDims_Import( A, T )        \
  
// -------------------------------------------------------------------------
// ITK-VTK base clases
// -------------------------------------------------------------------------

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

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

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

cpPlugins_Image_AllDims_Import( itk::DiffusionTensor3D< float > );
cpPlugins_Image_AllDims_Import( itk::DiffusionTensor3D< double > );

cpPlugins_ArrayImage_AllDims_Import( itk::Vector, float );
cpPlugins_ArrayImage_AllDims_Import( itk::Vector, double );

cpPlugins_ArrayImage_AllDims_Import( itk::CovariantVector, float );
cpPlugins_ArrayImage_AllDims_Import( itk::CovariantVector, double );

cpPlugins_ArrayImage_AllDims_Import( itk::Point, float );
cpPlugins_ArrayImage_AllDims_Import( itk::Point, double );

cpPlugins_ArrayImage_AllDims_Import( itk::SymmetricSecondRankTensor, float );
cpPlugins_ArrayImage_AllDims_Import( itk::SymmetricSecondRankTensor, double );

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

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

cpPlugins_ITKImage_Import( itk::Offset< 2 >, 2 );
cpPlugins_ITKImage_Import( itk::Offset< 3 >, 3 );
cpPlugins_ITKImage_Import( itk::Offset< 4 >, 4 );

// =========================================================================
// ==========        Declare import itk::VectorImage types        ==========
// =========================================================================

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

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

// -------------------------------------------------------------------------
#define cpPlugins_VectorImage_AllDims_Import( T )  \
  cpPlugins_VectorImage_Import( T, 2 );            \
  cpPlugins_VectorImage_Import( T, 3 );            \
  cpPlugins_VectorImage_Import( T, 4 )

// -------------------------------------------------------------------------
#define cpPlugins_ArrayVectorImage_AllDims_Import( A, T )     \
  cpPlugins_ArrayVectorImage_Import( A, T, 2, 2 );            \
  cpPlugins_ArrayVectorImage_Import( A, T, 3, 3 );            \
  cpPlugins_ArrayVectorImage_Import( A, T, 4, 4 )

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

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

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

cpPlugins_VectorImage_Import( itk::Offset< 2 >, 2 );
cpPlugins_VectorImage_Import( itk::Offset< 3 >, 3 );
cpPlugins_VectorImage_Import( itk::Offset< 4 >, 4 );

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

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

cpPlugins_VectorImage_AllDims_Import( itk::DiffusionTensor3D< float > );
cpPlugins_VectorImage_AllDims_Import( itk::DiffusionTensor3D< double > );

cpPlugins_ArrayVectorImage_AllDims_Import( itk::Vector, float );
cpPlugins_ArrayVectorImage_AllDims_Import( itk::Vector, double );

cpPlugins_ArrayVectorImage_AllDims_Import( itk::CovariantVector, float );
cpPlugins_ArrayVectorImage_AllDims_Import( itk::CovariantVector, double );

cpPlugins_ArrayVectorImage_AllDims_Import( itk::Point, float );
cpPlugins_ArrayVectorImage_AllDims_Import( itk::Point, double );

cpPlugins_ArrayVectorImage_AllDims_Import(
  itk::SymmetricSecondRankTensor, float
  );
cpPlugins_ArrayVectorImage_AllDims_Import(
  itk::SymmetricSecondRankTensor, double
  );

#endif // cpPlugins_Interface_EXPORTS

#endif // __CPPLUGINS__INTERFACE__IMAGE__HXX__

// eof - $RCSfile$