#ifndef __fpaPlugins_ImageAlgorithms__BaseFilter__h__
#define __fpaPlugins_ImageAlgorithms__BaseFilter__h__

#include <fpaPlugins_ImageAlgorithms_Export.h>

#include <vtkPolyData.h>
#include <cpPlugins/Pipeline/ProcessObject.h>

namespace fpaPlugins_ImageAlgorithms
{
  /**
   */
  class fpaPlugins_ImageAlgorithms_EXPORT BaseFilter
    : public cpPlugins::Pipeline::ProcessObject
  {
  public:
    typedef BaseFilter                         Self;
    typedef cpPlugins::Pipeline::ProcessObject Superclass;
    typedef itk::SmartPointer< Self >          Pointer;
    typedef itk::SmartPointer< const Self >    ConstPointer;

  public:
    itkTypeMacro( BaseFilter, cpPlugins::Pipeline::ProcessObject );
    cpPlugins_Id_Macro( BaseFilter, fpaImageAlgorithm );

  protected:
    BaseFilter( );
    virtual ~BaseFilter( );

    template< class _TFilter, class _TImage >
    inline void _ConfigureFilter(
      _TFilter* filter, _TImage* image,
      std::vector< typename _TImage::IndexType >& seeds
      );

  private:
    // Purposely not implemented.
    BaseFilter( const Self& other );
    Self& operator=( const Self& other );
  };

} // ecapseman

// -------------------------------------------------------------------------
#define ITK_MANUAL_INSTANTIATION
#include <fpa/Image/Functors/SimpleNeighborhood.h>

// -------------------------------------------------------------------------
template< class _TFilter, class _TImage >
void fpaPlugins_ImageAlgorithms::BaseFilter::
_ConfigureFilter(
  _TFilter* filter, _TImage* image,
  std::vector< typename _TImage::IndexType >& seeds
  )
{
  typedef typename _TFilter::TNeighborhoodFunction _TNeighborhood;
  typedef
    fpa::Image::Functors::SimpleNeighborhood< _TImage::ImageDimension >
    _TSimpleNeigh;

  // Simple configuration
  filter->SetInput( image );
  filter->SetStopAtOneFront( this->m_Parameters.GetBool( "StopAtOneFront" ) );

  // Neighborhood function
  typename _TSimpleNeigh::Pointer sfunc = _TSimpleNeigh::New( );
  sfunc->SetOrder( this->m_Parameters.GetUint( "NeighborhoodOrder" ) );
  filter->SetNeighborhoodFunction( sfunc );

  // Assign seeds
  seeds.clear( );
  auto pnt_seeds = this->GetInputData< vtkPolyData >( "Seeds" );
  if( pnt_seeds != NULL )
  {
    typename _TImage::PointType pnt;
    typename _TImage::IndexType idx;
    unsigned int dim =
      ( _TImage::ImageDimension < 3 )? _TImage::ImageDimension: 3;

    for( int i = 0; i < pnt_seeds->GetNumberOfPoints( ); ++i )
    {
      double buf[ 3 ];
      pnt_seeds->GetPoint( i, buf );
      pnt.Fill( 0 );
      for( unsigned int d = 0; d < dim; ++d )
        pnt[ d ] = buf[ d ];

      if( image->TransformPhysicalPointToIndex( pnt, idx ) )
        seeds.push_back( idx );

    } // rof

  } // fi
}

#endif // __fpaPlugins_ImageAlgorithms__BaseFilter__h__

// eof - $RCSfile$