#include <plugins/ImageMeshFilters/TriangleMeshToBinaryImageFilter.h>
#include <cpPlugins/BoundingBox.h>
#include <cpPlugins/Image.h>
#include <cpPlugins/Mesh.h>

#include <cpPlugins_Instances_ImageMeshFilters.h>

// -------------------------------------------------------------------------
cpPluginsImageMeshFilters::TriangleMeshToBinaryImageFilter::
TriangleMeshToBinaryImageFilter( )
  : Superclass( )
{
  this->_AddInput( "Input" );
  this->_AddInput( "BoundingBox", false );
  this->_AddOutput< cpPlugins::Image >( "Output" );

  this->m_Parameters.ConfigureAsUint( "InsideValue" );
  this->m_Parameters.ConfigureAsUint( "OutsideValue" );
  this->m_Parameters.ConfigureAsUint( "MinimumSize" );

  this->m_Parameters.SetUint( "InsideValue", 1 );
  this->m_Parameters.SetUint( "OutsideValue", 0 );
  this->m_Parameters.SetUint( "MinimumSize", 100 );
}

// -------------------------------------------------------------------------
cpPluginsImageMeshFilters::TriangleMeshToBinaryImageFilter::
~TriangleMeshToBinaryImageFilter( )
{
}

// -------------------------------------------------------------------------
void cpPluginsImageMeshFilters::TriangleMeshToBinaryImageFilter::
_GenerateData( )
{
  typedef itk::Mesh< float, 3 >  _3F;
  typedef itk::Mesh< double, 3 > _3D;

  auto _3f = this->GetInputData< _3F >( "Input" );
  auto _3d = this->GetInputData< _3D >( "Input" );
  if     ( _3f != NULL ) this->_GD0( _3f );
  else if( _3d != NULL ) this->_GD0( _3d );
  else this->_Error( "No valid input mesh." );
}

// -------------------------------------------------------------------------
template< class _TMesh >
void cpPluginsImageMeshFilters::TriangleMeshToBinaryImageFilter::
_GD0( _TMesh* mesh )
{
  this->_GD1< _TMesh, unsigned char >( mesh );
}

// -------------------------------------------------------------------------
template< class _TMesh, class _TPixel >
void cpPluginsImageMeshFilters::TriangleMeshToBinaryImageFilter::
_GD1( _TMesh* mesh )
{
  typedef cpPlugins::BoundingBox _TBB;
  typedef itk::Image< _TPixel, _TMesh::PointDimension > _TImage;
  typedef itk::TriangleMeshToBinaryImageFilter< _TMesh, _TImage > _TFilter;
  typedef typename _TImage::PointType _TPoint;

  static const unsigned int PAD = 10;

  _TFilter* filter = this->_CreateITK< _TFilter >( );

  auto in_bb = dynamic_cast< _TBB* >( this->GetInput( "BoundingBox" ) );
  _TPoint minBB, maxBB;
  if( in_bb == NULL )
  {
    auto bb = mesh->GetBoundingBox( );
    minBB = bb->GetMinimum( );
    maxBB = bb->GetMaximum( );
  }
  else
  {
    minBB = in_bb->GetMinimum< _TPoint >( );
    maxBB = in_bb->GetMaximum< _TPoint >( );

  } // fi

  double lx = double( maxBB[ 0 ] - minBB[ 0 ] );
  double ly = double( maxBB[ 1 ] - minBB[ 1 ] );
  double lz = double( maxBB[ 2 ] - minBB[ 2 ] );
  double lm = ( lx < ly )? lx: ly;
  lm = ( lm < lz )? lm: lz;

  // Compute spacing
  double mSpac = lm / double( this->m_Parameters.GetUint( "MinimumSize" ) );
  typename _TImage::SpacingType spac;
  spac.Fill( mSpac );
  filter->SetSpacing( spac );

  // Compute size
  typename _TImage::SizeType size;
  size[ 0 ] = ( unsigned long )( std::ceil( lx / mSpac ) );
  size[ 1 ] = ( unsigned long )( std::ceil( ly / mSpac ) );
  size[ 2 ] = ( unsigned long )( std::ceil( lz / mSpac ) );

  // ... add some padding pixels
  size[ 0 ] += PAD;
  size[ 1 ] += PAD;
  size[ 2 ] += PAD;
  filter->SetSize( size );

  // Set origin
  typename _TImage::PointType origin = minBB;
  origin[ 0 ] -= double( PAD >> 1 ) * spac[ 0 ];
  origin[ 1 ] -= double( PAD >> 1 ) * spac[ 1 ];
  origin[ 2 ] -= double( PAD >> 1 ) * spac[ 2 ];
  filter->SetOrigin( origin );

  // Remaining values
  typename _TImage::DirectionType direction;
  direction.SetIdentity( );
  filter->SetDirection( direction );

  typename _TImage::IndexType index;
  index.Fill( 0 );
  filter->SetIndex( index );

  // Execute
  filter->SetInput( mesh );
  filter->SetInsideValue( this->m_Parameters.GetUint( "InsideValue" ) );
  filter->SetOutsideValue( this->m_Parameters.GetUint( "OutsideValue" ) );
  filter->Update( );

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

// eof - $RCSfile$