#ifndef __FPAPLUGINS__BASEIMAGEFILTER__HXX__
#define __FPAPLUGINS__BASEIMAGEFILTER__HXX__

#include <cpExtensions/DataStructures/ImageIndexesContainer.h>
#include <fpa_Instances/Observers.h>

// -------------------------------------------------------------------------
template< class _TFilter >
_TFilter* fpaPlugins::BaseImageFilter::
_ConfigureFilter( )
{
  typedef typename _TFilter::TInputImage _TImage;
  static const unsigned int Dim = _TImage::ImageDimension;

  auto image = this->GetInputData< _TImage >( "Input" );
  if( image == NULL )
    return( NULL );
  auto seeds = this->GetInputData< vtkPoints >( "Seeds" );

  // Create filter and connect input
  auto filter = this->_CreateITK< _TFilter >( );
  filter->SetInput( image );

  // Set numeric parameters
  filter->SetNeighborhoodOrder(
    this->m_Parameters.GetSelectedChoice( "NeighborhoodOrder" )[ 0 ] - '0'
    );
  filter->SetStopAtOneFront( this->m_Parameters.GetBool( "StopAtOneFront" ) );

  // Assign seeds
  filter->ClearSeeds( );
  if( seeds != NULL )
  {
    typename _TImage::PointType pnt;
    typename _TImage::IndexType idx;
    unsigned int dim =
      ( _TImage::ImageDimension < 3 )? _TImage::ImageDimension: 3;
    for( unsigned 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

  // Ok!
  return( filter );
}

// -------------------------------------------------------------------------
template< class _TFilter >
void fpaPlugins::BaseImageFilter::
_ExecuteFilter( _TFilter* filter )
{
  // Go!!!
  this->_ConfigureDebugger( filter );
  filter->Update( );
  this->_DeconfigureDebugger( filter );

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

// -------------------------------------------------------------------------
template< class _TFilter >
void fpaPlugins::BaseImageFilter::
_ConfigureDebugger( _TFilter* filter )
{
  typedef typename _TFilter::TInputImage _TImage;
  typedef fpa::VTK::Image::Observer2D< _TFilter, vtkRenderWindow > _2D;
  typedef fpa::VTK::Image::Observer3D< _TFilter, vtkRenderWindow > _3D;

  this->m_Observers.clear( );
  if( this->m_Parameters.GetBool( "VisualDebug" ) )
  {
    if( this->m_MPRViewer != NULL )
    {
      if( _TImage::ImageDimension == 2 )
      {
        auto iren = this->m_MPRViewer->GetInteractor( 2 );
        if( iren != NULL )
        {
          typename _2D::Pointer debugger = _2D::New( );
          debugger->SetRenderWindow( iren->GetRenderWindow( ) );
          debugger->SetRenderPercentage( 0.01 );
          this->m_Observers.insert(
            filter->AddObserver( itk::AnyEvent( ), debugger )
            );
          filter->ThrowEventsOn( );

        } // fi
      }
      else if( _TImage::ImageDimension == 3 )
      {
        auto iren = this->m_MPRViewer->GetInteractor( 3 );
        if( iren != NULL )
        {
          typename _3D::Pointer debugger = _3D::New( );
          debugger->SetRenderWindow( iren->GetRenderWindow( ) );
          debugger->SetRenderPercentage( 0.001 );
          this->m_Observers.insert(
            filter->AddObserver( itk::AnyEvent( ), debugger )
            );
          filter->ThrowEventsOn( );

        } // fi

      } // fi

    } // fi

    if( this->m_SingleInteractor != NULL )
    {
      if( _TImage::ImageDimension == 2 )
      {
      }
      else if( _TImage::ImageDimension == 3 )
      {
      } // fi

    } // fi

  } // fi
}

// -------------------------------------------------------------------------
template< class F >
void fpaPlugins::BaseImageFilter::
_DeconfigureDebugger( F* filter )
{
  if( filter != NULL )
  {
    auto oIt = this->m_Observers.begin( );
    for( ; oIt != this->m_Observers.end( ); ++oIt )
      filter->RemoveObserver( *oIt );

  } // fi
  this->m_Observers.clear( );
}

#endif // __FPAPLUGINS__BASEIMAGEFILTER__HXX__

// eof - $RCSfile$