#ifndef __FPA__VTK__IMAGE3DOBSERVER__HXX__
#define __FPA__VTK__IMAGE3DOBSERVER__HXX__

#include <itkImageBase.h>

#include <vtkCellArray.h>
#include <vtkFloatArray.h>
#include <vtkPointData.h>
#include <vtkPoints.h>
#include <vtkRenderer.h>
#include <vtkRendererCollection.h>

/*
  #include <vtkCellArray.h>
  #include <vtkProperty.h>
*/

// -------------------------------------------------------------------------
template< class F, class R >
void fpa::VTK::Image3DObserver< F, R >::
SetRenderWindow( R* rw )
{
  this->m_RenderWindow = rw;
  /*
    if( this->m_RenderWindow != NULL )
    {
    vtkRenderer* ren =
    this->m_RenderWindow->GetRenderers( )->GetFirstRenderer( );
    if( ren != NULL )
    {
    ren->AddActor( this->m_PolyDataActor );
    this->m_RenderWindow->Render( );

    } // fi

    } // fi
  */
}

// -------------------------------------------------------------------------
template< class F, class R >
void fpa::VTK::Image3DObserver< F, R >::
Execute( const itk::Object* c, const itk::EventObject& e )
{
  typedef itk::ImageBase< 3 >         _TImage;
  typedef typename F::TEvent          _TEvent;
  typedef typename F::TFrontEvent     _TFrontEvent;
  typedef typename F::TMarkEvent      _TMarkEvent;
  typedef typename F::TCollisionEvent _TCollisionEvent;
  typedef typename F::TEndEvent       _TEndEvent;

  // Check inputs
  if( this->m_RenderWindow == NULL )
    return;
  vtkRenderer* ren =
    this->m_RenderWindow->GetRenderers( )->GetFirstRenderer( );
  if( ren == NULL )
    return;
  const F* filter = dynamic_cast< const F* >( c );
  if( filter == NULL )
    return;
  const _TImage* image = filter->GetInput( );
  if( image == NULL )
    return;

  // Create actor
  _TImage::RegionType reg = image->GetLargestPossibleRegion( );
  _TImage::SizeType siz = reg.GetSize( );
  if( this->m_Data.GetPointer( ) == NULL )
  {
    this->m_Data   = vtkSmartPointer< vtkPolyData >::New( );
    this->m_Mapper = vtkSmartPointer< vtkPolyDataMapper >::New( );
    this->m_Actor  = vtkSmartPointer< vtkActor >::New( );

    vtkSmartPointer< vtkPoints > points =
      vtkSmartPointer< vtkPoints >::New( );
    vtkSmartPointer< vtkCellArray > vertices =
      vtkSmartPointer< vtkCellArray >::New( );
    vtkSmartPointer< vtkFloatArray > scalars =
      vtkSmartPointer< vtkFloatArray >::New( );
    this->m_Data->SetPoints( points );
    this->m_Data->SetVerts( vertices );
    this->m_Data->GetPointData( )->SetScalars( scalars );

    this->m_Mapper->SetInputData( this->m_Data );
    this->m_Actor->SetMapper( this->m_Mapper );
    ren->AddActor( this->m_Actor );

    this->m_Marks = TMarks::New( );
    this->m_Marks->SetLargestPossibleRegion(
      image->GetLargestPossibleRegion( )
      );
    this->m_Marks->SetRequestedRegion( image->GetRequestedRegion( ) );
    this->m_Marks->SetBufferedRegion( image->GetBufferedRegion( ) );
    this->m_Marks->SetOrigin( image->GetOrigin( ) );
    this->m_Marks->SetSpacing( image->GetSpacing( ) );
    this->m_Marks->SetDirection( image->GetDirection( ) );
    this->m_Marks->Allocate( );
    this->m_Marks->FillBuffer( -1 );

  } // fi


  // Get possible events
  const _TEvent* evt = dynamic_cast< const _TEvent* >( &e );
  _TFrontEvent fevt;
  _TMarkEvent mevt;
  _TCollisionEvent cevt;
  _TEndEvent eevt;
  if( evt != NULL )
  {
    if( fevt.CheckEvent( evt ) )
    {
      if( this->m_Marks->GetPixel( evt->Node.Vertex ) == -1 )
      {
        typename _TImage::PointType pnt;
        image->TransformIndexToPhysicalPoint( evt->Node.Vertex, pnt );

        long pId = this->m_Data->GetNumberOfPoints( );
        this->m_Data->GetVerts( )->InsertNextCell( 1 );
        this->m_Data->GetVerts( )->InsertCellPoint( pId );
        this->m_Data->GetPoints( )->
          InsertNextPoint( pnt[ 0 ], pnt[ 1 ], pnt[ 2 ] );
        this->m_Data->GetPointData( )->
          GetScalars( )->InsertNextTuple1( 0.5 );
        this->m_Data->Modified( );

        this->m_Marks->SetPixel( evt->Node.Vertex, pId );

      } // fi
      this->m_RenderWindow->Render( );

      /* TODO
         if(
         this->m_Vertices.find( evt->Node.Vertex ) == this->m_Vertices.end( )
         )
         {
         unsigned long pId = this->m_PolyData->GetPoints( )->InsertNextPoint(
         double( pnt[ 0 ] ), double( pnt[ 1 ] ), double( pnt[ 2 ] )
         );
         unsigned long cId = this->m_PolyData->GetVerts( )->InsertNextCell( 1 );
         this->m_PolyData->GetVerts( )->InsertCellPoint( pId );
         this->m_PolyData->Modified( );
         this->m_Vertices[ evt->Node.Vertex ] = TVertexIds( pId, cId );

         } // rof
      */
    }
    else if( mevt.CheckEvent( evt ) )
    {
      /*
        typename TVertices::iterator vIt =
        this->m_Vertices.find( evt->Node.Vertex );
        if( vIt != this->m_Vertices.end( ) )
        {
        std::cout << "Erase " << evt->Node.Vertex << " " << vIt->second.second << std::endl;
        } // fi
      */
    } // fi

    if( cevt.CheckEvent( evt ) )
    {
      // TODO: std::cout << "collision" << std::endl;

    } // fi
    /*
      this->SetPixel(
      evt->Node.Vertex,
      Colors[ evt->Node.FrontId ][ 0 ],
      Colors[ evt->Node.FrontId ][ 1 ],
      Colors[ evt->Node.FrontId ][ 2 ],
      Colors[ evt->Node.FrontId ][ 3 ]
      );
      else if( mevt.CheckEvent( evt ) )
      this->SetPixel( evt->Node.Vertex, 255, 0, 0, 255 );

      if( cevt.CheckEvent( evt ) )
      this->SetPixel( evt->Node.Vertex, 100, 50, 25, 255 );
    */
    
    // Update visualization
    /* TODO
       if( this->m_Number == 0 || this->m_Percentage < 0 )
       this->Render( );
       this->m_Number++;
       this->m_Number %= this->m_Percentage;
       if( eevt.CheckEvent( evt ) )
       {
       if( this->m_RenderWindow != NULL )
       {
       vtkRenderer* ren =
       this->m_RenderWindow->GetRenderers( )->GetFirstRenderer( );
       ren->RemoveActor( this->m_PolyDataActor );
       this->Render( );

       } // fi

       } // fi
    */

  } // fi
}

// -------------------------------------------------------------------------
template< class F, class R >
fpa::VTK::Image3DObserver< F, R >::
Image3DObserver( )
  : Superclass( ),
    m_RenderWindow( NULL )
{
  /*
    this->m_PolyData = vtkSmartPointer< vtkPolyData >::New( );
    this->m_PolyDataMapper = vtkSmartPointer< vtkPolyDataMapper >::New( );
    this->m_PolyDataActor = vtkSmartPointer< vtkActor >::New( );

    this->m_PolyData->SetPoints( vtkPoints::New( ) );
    this->m_PolyData->SetVerts( vtkCellArray::New( ) );

    this->m_PolyDataMapper->SetInputData( this->m_PolyData );
    this->m_PolyDataActor->SetMapper( this->m_PolyDataMapper );
    this->m_PolyDataActor->GetProperty( )->SetColor( 0, 0, 1 );
  */
}

#endif // __FPA__VTK__IMAGE3DOBSERVER__HXX__

// eof - $RCSfile$