#include <ITKSliceFilters/IsoResampleImageFilter.h>
#include <ITKImageInterpolators/InterpolateImageFunction.h>

#include <cpInstances/DataObjects/Image.h>
#include <itkImage.h>
#include <itkResampleImageFilter.h>
#include <itkIdentityTransform.h>

// -------------------------------------------------------------------------
cpPluginsITKSliceFilters::IsoResampleImageFilter::
IsoResampleImageFilter( )
  : Superclass( )
{
  this->_ConfigureInput< cpInstances::DataObjects::Image >( "Input", true, false );
  this->_ConfigureInput< cpPlugins::Pipeline::DataObject >( "Interpolator", false, false );
  this->_ConfigureOutput< cpInstances::DataObjects::Image >( "Output" );

  this->m_Parameters.ConfigureAsReal( "Scale", 1 );
  this->m_Parameters.ConfigureAsBool( "ScaleFromMinimumSpacing", true );
  this->m_Parameters.ConfigureAsRealTypesChoices( "PrecisionType" );
}

// -------------------------------------------------------------------------
cpPluginsITKSliceFilters::IsoResampleImageFilter::
~IsoResampleImageFilter( )
{
}

// -------------------------------------------------------------------------
void cpPluginsITKSliceFilters::IsoResampleImageFilter::
_GenerateData( )
{
  auto o = this->GetInputData( "Input" );
  cpPlugins_Demangle_Image_ScalarPixels_AllDims_1( o, _GD0 )
    this->_Error( "Invalid input image." );
}

// -------------------------------------------------------------------------
template< class _TImage >
void cpPluginsITKSliceFilters::IsoResampleImageFilter::
_GD0( _TImage* image )
{
  typedef cpPluginsITKImageInterpolators::InterpolateImageFunction _TInterpolator;

  std::string p_type = this->m_Parameters.GetSelectedChoice( "PrecisionType" );
  auto interpolator = dynamic_cast< _TInterpolator* >(
    this->GetInput( "Interpolator" )->GetSource( )
    );
  if( interpolator != NULL )
    interpolator->CreateInterpolator( image, p_type );
  if     ( p_type == "float" )  this->_GD1< _TImage, float >( image );
  else if( p_type == "double" ) this->_GD1< _TImage, double >( image );
}

// -------------------------------------------------------------------------
template< class _TImage, class _TScalar >
void cpPluginsITKSliceFilters::IsoResampleImageFilter::
_GD1( _TImage* image )
{
  typedef itk::IdentityTransform< _TScalar, _TImage::ImageDimension > _TTransform;
  typedef itk::ResampleImageFilter< _TImage, _TImage, _TScalar, _TScalar > _TFilter;
  typedef typename _TFilter::InterpolatorType _TInterpolator;

  // Initial configuration
  auto filter = this->_CreateITK< _TFilter >( );
  filter->SetInput( image );

  // Associate transform
  typename _TTransform::Pointer transform = _TTransform::New( );
  transform->SetIdentity( );
  filter->SetTransform( transform );

  // Compute new spacing
  typename _TImage::SpacingType in_spac = image->GetSpacing( );
  double val_spac = in_spac[ 0 ];
  if( this->m_Parameters.GetBool( "ScaleFromMinimumSpacing" ) )
    for( unsigned int d = 1; d < _TImage::ImageDimension; ++d )
      val_spac = ( in_spac[ d ] < val_spac )? in_spac[ d ]: val_spac;
  else
    for( unsigned int d = 1; d < _TImage::ImageDimension; ++d )
      val_spac = ( in_spac[ d ] > val_spac )? in_spac[ d ]: val_spac;
  val_spac *= this->m_Parameters.GetReal( "Scale" );
  typename _TImage::SpacingType out_spac;
  out_spac.Fill( val_spac );
  filter->SetOutputSpacing( out_spac );

  // Compute new size
  typename _TImage::SizeType in_size = image->GetRequestedRegion( ).GetSize( );
  typename _TImage::SizeType out_size;
  for( unsigned int d = 0; d < _TImage::ImageDimension; ++d )
    out_size[ d ] = ( unsigned long )(
      double( in_size[ d ] ) * double( in_spac[ d ] ) / val_spac
      );
  filter->SetSize( out_size );

  // New origin
  filter->SetOutputOrigin( image->GetOrigin( ) );

  // Set interpolator
  auto interpolator = this->GetInputData< _TInterpolator >( "Interpolator" );
  if( interpolator != NULL )
    filter->SetInterpolator( interpolator );

  // Update
  filter->Update( );
  this->GetOutput( "Output" )->SetITK( filter->GetOutput( ) );
}

// eof - $RCSfile$