#ifndef __FPA__VTK__IMAGE3DOBSERVER__H__
#define __FPA__VTK__IMAGE3DOBSERVER__H__

#include <map>

#include <itkCommand.h>

#include <vtkActor.h>
#include <vtkPolyData.h>
#include <vtkPolyDataMapper.h>
#include <vtkSmartPointer.h>

namespace fpa
{
  namespace VTK
  {
    /**
     */
    template< class F, class R >
    class Image3DObserver
      : public itk::Command
    {
    public:
      typedef Image3DObserver                 Self;
      typedef itk::Command                    Superclass;
      typedef itk::SmartPointer< Self >       Pointer;
      typedef itk::SmartPointer< const Self > ConstPointer;

      typedef F                             TFilter;
      typedef R                             TRenderWindow;
      typedef typename TFilter::TInputImage TImage;
      typedef typename TFilter::TVertex     TVertex;

      typedef std::pair< unsigned long, unsigned long > TVertexIds;

      struct TVertexCmp
      {
        bool operator()( const TVertex& a, const TVertex& b ) const
          {
            unsigned int d = 0;
            while( d < TVertex::Dimension && a[ d ] == b[ d ] )
              d++;
            if( d < TVertex::Dimension )
              return( a[ d ] < b[ d ] );
            else
              return( false );
          }
      };
      typedef std::map< TVertex, TVertexIds, TVertexCmp > TVertices;

    public:
      itkNewMacro( Self );
      itkTypeMacro( Image3DObserver, itkCommand );

    public:
      void SetImage( const TImage* img, R* rw );
      void Render( );
      void Execute( itk::Object* c, const itk::EventObject& e )
        { this->Execute( ( const itk::Object* )( c ), e ); }
      void Execute( const itk::Object* c, const itk::EventObject& e );

    protected:
      Image3DObserver( );
      virtual ~Image3DObserver( )
        { }

    private:
      Image3DObserver( const Self& ); // Not impl.
      void operator=( const Self& );  // Not impl.

    protected:
      typename TImage::ConstPointer m_Image;

      R*            m_RenderWindow;
      unsigned long m_Number;
      unsigned long m_Percentage;

      vtkSmartPointer< vtkPolyData > m_PolyData;
      vtkSmartPointer< vtkPolyDataMapper > m_PolyDataMapper;
      vtkSmartPointer< vtkActor > m_PolyDataActor;

      TVertices m_Vertices;
    };

  } // ecapseman

} // ecapseman

#include <fpa/VTK/Image3DObserver.hxx>

#endif // __FPA__VTK__IMAGE3DOBSERVER__H__

// eof - $RCSfile$