#ifndef __fpaPluginsImageAlgorithms__BaseFilter__h__
#define __fpaPluginsImageAlgorithms__BaseFilter__h__

#include <fpaPluginsImageAlgorithms_Export.h>
#include <cpPlugins/BaseObjects/ProcessObject.h>
#include <vtkPolyData.h>
#include <fpa/Image/Functors/SimpleNeighborhood.h>

namespace fpaPluginsImageAlgorithms
{
  /**
   */
  class fpaPluginsImageAlgorithms_EXPORT BaseFilter
    : public cpPlugins::BaseObjects::ProcessObject
  {
  public:
    typedef BaseFilter                            Self;
    typedef cpPlugins::BaseObjects::ProcessObject Superclass;
    typedef itk::SmartPointer< Self >             Pointer;
    typedef itk::SmartPointer< const Self >       ConstPointer;

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

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

    template< class _TFilter, class _TImage >
    inline void _ConfigureFilter( _TFilter* filter, _TImage* image );

    /* TODO

       template< class _TFilter >
       inline void _ExecuteFilter( _TFilter* filter );

       template< class _TFilter >
       inline void _ConfigureDebugger( _TFilter* filter );

       template< class _TFilter >
       inline void _DeconfigureDebugger( _TFilter* filter );
    */

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

} // ecapseman

// -------------------------------------------------------------------------
    template< class _TFilter, class _TImage >
void fpaPluginsImageAlgorithms::BaseFilter::
_ConfigureFilter( _TFilter* filter, _TImage* image )
{
  typedef typename _TFilter::TNeighborhoodFunction _TNeighborhood;
  typedef fpa::Image::Functors::SimpleNeighborhood< _TImage > _TSimpleNeigh;

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

  // Neighborhood function
  auto neig = this->GetInputData< _TNeighborhood >( "Neighborhood" );
  if( neig == NULL )
  {
    typename _TSimpleNeigh::Pointer sfunc = _TSimpleNeigh::New( );
    sfunc->SetOrder( this->m_Parameters.GetUint( "NeighborhoodOrder" ) );
    filter->SetNeighborhoodFunction( sfunc );
  }
  else
    filter->SetNeighborhoodFunction( neig );

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

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

      if( image->TransformPhysicalPointToIndex( pnt, idx ) )
        filter->AddSeed( idx, 0 );

    } // rof

  } // fi
}

#endif // __fpaPluginsImageAlgorithms__BaseFilter__h__

// eof - $RCSfile$