#ifndef __FPA__VTK__IMAGE3DOBSERVER__HXX__
#define __FPA__VTK__IMAGE3DOBSERVER__HXX__

#include <vtkCellArray.h>
#include <vtkPolyDataMapper.h>
#include <vtkPoints.h>
#include <vtkPointData.h>
#include <vtkProperty.h>
#include <vtkRenderer.h>
#include <vtkRendererCollection.h>

// -------------------------------------------------------------------------
template< class F, class R >
void fpa::VTK::Image3DObserver< F, R >::
SetRenderWindow( R* rw )
{
  this->m_RenderWindow = rw;
}

// -------------------------------------------------------------------------
template< class F, class R >
void fpa::VTK::Image3DObserver< F, R >::
SetPixel(
  typename TImage::IndexType idx,
  unsigned char red,
  unsigned char green,
  unsigned char blue,
  unsigned char alpha
  )
{
  std::cout << idx << std::endl;
  this->m_Stencil->SetScalarComponentFromDouble
    ( idx[ 0 ], idx[ 1 ], idx[ 2 ], 0, red );
  this->m_Stencil->SetScalarComponentFromDouble
    ( idx[ 0 ], idx[ 1 ], idx[ 2 ], 1, green );
  this->m_Stencil->SetScalarComponentFromDouble
    ( idx[ 0 ], idx[ 1 ], idx[ 2 ], 2, blue );
  this->m_Stencil->SetScalarComponentFromDouble
    ( idx[ 0 ], idx[ 1 ], idx[ 2 ], 3, alpha );

  int ijk[ 3 ];
  ijk[ 0 ] = idx[ 0 ];
  ijk[ 1 ] = idx[ 1 ];
  ijk[ 2 ] = idx[ 2 ];
  long id = this->m_Stencil->ComputePointId( ijk );
  vtkUnsignedCharArray* pd_data =
    dynamic_cast< vtkUnsignedCharArray* >(
      this->m_PolyData->GetPointData( )->GetScalars( )
      );
  pd_data->SetTuple4( id, red, green, blue, alpha );
  this->m_Stencil->Modified( );
  this->m_PolyData->Modified( );
  this->m_PolyDataMapper->Modified( );
  this->m_PolyDataActor->Modified( );
}

// -------------------------------------------------------------------------
template< class F, class R >
void fpa::VTK::Image3DObserver< F, R >::
Render( )
{
  if( this->m_RenderWindow != NULL )
    this->m_RenderWindow->Render( );
}

// -------------------------------------------------------------------------
template< class F, class R >
void fpa::VTK::Image3DObserver< F, R >::
Execute( const itk::Object* c, const itk::EventObject& e )
{
  typedef typename F::TStartEvent     _TStartEvent;
  typedef typename F::TStartLoopEvent _TStartLoopEvent;
  typedef typename F::TEndEvent       _TEndEvent;
  typedef typename F::TEndLoopEvent   _TEndLoopEvent;
  typedef typename F::TAliveEvent     _TAliveEvent;
  typedef typename F::TFrontEvent     _TFrontEvent;
  typedef typename F::TFreezeEvent    _TFreezeEvent;

  typedef typename F::TStartBacktrackingEvent _TStartBacktrackingEvent;
  typedef typename F::TEndBacktrackingEvent   _TEndBacktrackingEvent;
  typedef typename F::TBacktrackingEvent      _TBacktrackingEvent;

  static unsigned char Colors[][4] =
    {
      {   0,   0, 127, 127 },
      {   0, 127, 127, 127 },
      { 127,   0, 127, 127 },
      { 127, 127,   0, 127 },
      {   0,   0,  63, 127 },
      {   0,  63,  63, 127 },
      {  63,   0,  63, 127 },
      {  63,  63,   0, 127 },
      {  63,  63, 127, 127 },
      {  63, 127, 127, 127 },
      { 127,  63, 127, 127 },
      { 127, 127,  63, 127 },
      { 127, 127,  63, 127 },
      { 127,  63,  63, 127 },
      {  63, 127,  63, 127 },
      {  63,  63, 127, 127 }
    };

  const F* filter = dynamic_cast< const F* >( c );
  if( this->m_RenderWindow == NULL || filter == NULL )
    return;

  const _TStartEvent* startEvt = dynamic_cast< const _TStartEvent* >( &e );
  const _TStartBacktrackingEvent* startBackEvt =
    dynamic_cast< const _TStartBacktrackingEvent* >( &e );
  if( startEvt != NULL || startBackEvt != NULL )
  {
    const typename F::TInputImage* img = filter->GetInput( );
    unsigned int minD = F::TInputImage::ImageDimension;
    minD = ( minD < 3 )? minD: 3;

    int e[ 6 ] = { 0 };
    typename F::TInputImage::RegionType reg = img->GetRequestedRegion( );
    for( unsigned int i = 0; i < minD; i++ )
    {
      e[ ( i << 1 ) + 0 ] = reg.GetIndex( )[ i ];
      e[ ( i << 1 ) + 1 ] = reg.GetIndex( )[ i ] + reg.GetSize( )[ i ] - 1;

    } // rof

    typename F::TInputImage::SpacingType spac = img->GetSpacing( );
    double s[ 3 ] = { 1, 1, 1 };
    for( unsigned int i = 0; i < minD; i++ )
      s[ i ] = double( spac[ i ] );

    typename F::TInputImage::PointType orig = img->GetOrigin( );
    double o[ 3 ] = { 0 };
    for( unsigned int i = 0; i < minD; i++ )
      o[ i ] = double( orig[ i ] );

    this->m_Stencil->SetExtent( e );
    this->m_Stencil->SetSpacing( s );
    this->m_Stencil->SetOrigin( o );
    this->m_Stencil->AllocateScalars( VTK_UNSIGNED_CHAR, 4 );
    for( unsigned int i = 0; i < 3; i++ )
      this->m_Stencil->GetPointData( )->
        GetScalars( )->FillComponent( i, 255 );
    this->m_Stencil->GetPointData( )->GetScalars( )->FillComponent( 3, 0 );

    vtkSmartPointer< vtkPoints > pd_points =
      vtkSmartPointer< vtkPoints >::New( );
    vtkSmartPointer< vtkCellArray > pd_verts =
      vtkSmartPointer< vtkCellArray >::New( );
    vtkSmartPointer< vtkUnsignedCharArray > pd_data =
      vtkSmartPointer< vtkUnsignedCharArray >::New( );
    long nPoints = this->m_Stencil->GetNumberOfPoints( );

    pd_data->SetNumberOfComponents( 4 );
    pd_data->SetNumberOfTuples( nPoints );
    pd_points->SetNumberOfPoints( nPoints );
    double point[ 3 ];
    for( long pId = 0; pId < nPoints; ++pId )
    {
      this->m_Stencil->GetPoint( pId, point );
      pd_points->InsertNextPoint( point );
      pd_verts->InsertNextCell( 1 );
      pd_verts->InsertCellPoint( pId );
      pd_data->SetTuple4( pId, 0, 0, 0, 0 );

    } // rof
    this->m_PolyData->SetPoints( pd_points );
    this->m_PolyData->SetVerts( pd_verts );
    this->m_PolyData->GetPointData( )->SetScalars( pd_data );

    this->m_PolyDataMapper->SetInputData( this->m_PolyData );
    this->m_PolyDataActor->SetMapper( this->m_PolyDataMapper );

    this->m_Count = 0;
    this->m_RenderCount = reg.GetNumberOfPixels( );

    vtkRenderer* ren =
      this->m_RenderWindow->GetRenderers( )->GetFirstRenderer( );
    ren->AddActor( this->m_PolyDataActor );
    return;

  } // fi

  const _TAliveEvent* aliveEvt = dynamic_cast< const _TAliveEvent* >( &e );
  const _TFrontEvent* frontEvt = dynamic_cast< const _TFrontEvent* >( &e );
  if( aliveEvt != NULL || frontEvt != NULL )
  {
    if( aliveEvt != NULL )
      this->SetPixel(
        aliveEvt->Vertex,
        Colors[ aliveEvt->FrontId ][ 0 ],
        Colors[ aliveEvt->FrontId ][ 1 ],
        Colors[ aliveEvt->FrontId ][ 2 ],
        Colors[ aliveEvt->FrontId ][ 3 ]
        );
    else if( frontEvt != NULL )
      this->SetPixel( frontEvt->Vertex, 255, 0, 0, 255 );
    this->m_Count++;

    // Render visual debug
    double per = double( this->m_RenderCount ) * this->m_RenderPercentage;
    if( double( this->m_Count ) >= per )
      this->Render( );
    if( double( this->m_Count ) >= per )
      this->m_Count = 0;

    return;

  } // fi

  const _TEndEvent* endEvt = dynamic_cast< const _TEndEvent* >( &e );
  if( endEvt != NULL )
  {
    vtkRenderer* ren =
      this->m_RenderWindow->GetRenderers( )->GetFirstRenderer( );
    ren->RemoveActor( this->m_PolyDataActor );
    this->Render( );
    return;

  } // fi

  const _TBacktrackingEvent* backEvt =
    dynamic_cast< const _TBacktrackingEvent* >( &e );
  const _TEndBacktrackingEvent* endBackEvt =
    dynamic_cast< const _TEndBacktrackingEvent* >( &e );
  if( backEvt != NULL )
  {
    this->SetPixel( backEvt->Vertex, 0, 0, 255, 255 );
    return;

  } // fi

  if( endBackEvt != NULL )
  {
    this->m_RenderWindow->Render( );
    /* TODO: DEBUG
       std::cout << "Press enter: " << std::ends;
       int aux;
       std::cin >> aux;
    */
    return;

  } // fi
}

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

// -------------------------------------------------------------------------
template< class F, class R >
fpa::VTK::Image3DObserver< F, R >::
~Image3DObserver( )
{
}

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

// -------------------------------------------------------------------------
template< class F, class R >
void fpa::VTK::Image3DObserver< F, R >::
SetRenderWindow( R* rw )
{
  this->m_RenderWindow = rw;
}

// -------------------------------------------------------------------------
template< class F, class R >
void fpa::VTK::Image3DObserver< F, R >::
Execute( const itk::Object* c, const itk::EventObject& e )
{
  typedef typename F::TStartEvent     _TStartEvent;
  typedef typename F::TStartLoopEvent _TStartLoopEvent;
  typedef typename F::TEndEvent       _TEndEvent;
  typedef typename F::TEndLoopEvent   _TEndLoopEvent;
  typedef typename F::TAliveEvent     _TAliveEvent;
  typedef typename F::TFrontEvent     _TFrontEvent;
  typedef typename F::TFreezeEvent    _TFreezeEvent;

  typedef typename F::TStartBacktrackingEvent _TStartBacktrackingEvent;
  typedef typename F::TEndBacktrackingEvent   _TEndBacktrackingEvent;
  typedef typename F::TBacktrackingEvent      _TBacktrackingEvent;

  // 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;

  const _TStartEvent* startEvt = dynamic_cast< const _TStartEvent* >( &e );
  const _TStartBacktrackingEvent* startBackEvt =
    dynamic_cast< const _TStartBacktrackingEvent* >( &e );
  if( startEvt != NULL || startBackEvt != NULL )
  {
    // 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 );
      this->m_Count = 0;
      this->m_RenderCount = reg.GetNumberOfPixels( );

    } // fi
    return;

  } // fi

  const _TAliveEvent* aliveEvt = dynamic_cast< const _TAliveEvent* >( &e );
  const _TFrontEvent* frontEvt = dynamic_cast< const _TFrontEvent* >( &e );
  if( aliveEvt != NULL || frontEvt != NULL )
  {
    _TImage::IndexType vertex;
    if( aliveEvt != NULL )
      vertex = aliveEvt->Vertex;
    else if( frontEvt != NULL )
      vertex = frontEvt->Vertex;

    if( this->m_Marks->GetPixel( vertex ) == -1 )
    {
      typename _TImage::PointType pnt;
      image->TransformIndexToPhysicalPoint( 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( vertex, pId );
      this->m_Count++;

      // Render visual debug
      double per = double( this->m_RenderCount ) * this->m_RenderPercentage;
      if( double( this->m_Count ) >= per )
        this->m_RenderWindow->Render( );
      if( double( this->m_Count ) >= per )
        this->m_Count = 0;

    } // fi
    return;

  } // fi

  const _TEndEvent* endEvt = dynamic_cast< const _TEndEvent* >( &e );
  if( endEvt != NULL )
  {
    this->m_RenderWindow->Render( );
    ren->RemoveActor( this->m_Actor );
    this->m_RenderWindow->Render( );
    this->m_Marks = NULL;
    this->m_Data = NULL;
    this->m_Mapper = NULL;
    this->m_Actor = NULL;
    return;

  } // fi

  const _TBacktrackingEvent* backEvt =
    dynamic_cast< const _TBacktrackingEvent* >( &e );
  const _TEndBacktrackingEvent* endBackEvt =
    dynamic_cast< const _TEndBacktrackingEvent* >( &e );
  if( backEvt != NULL )
  {
      static const unsigned long nColors = 10;
      double back_id =
        double( backEvt->FrontId % nColors ) / double( nColors );
      typename _TImage::PointType pnt;
      image->TransformIndexToPhysicalPoint( backEvt->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( back_id );
      this->m_Data->Modified( );
      return;

    } // fi

    if( endBackEvt != NULL )
    {
      this->m_RenderWindow->Render( );
         std::cout << "Press enter: " << std::ends;
         int aux;
         std::cin >> aux;
      return;

    } // fi
}

// -------------------------------------------------------------------------
template< class F, class R >
fpa::VTK::Image3DObserver< F, R >::
Image3DObserver( )
  : Superclass( ),
    m_RenderWindow( NULL ),
    m_RenderPercentage( double( 0.0001 ) )
{
}
*/

#endif // __FPA__VTK__IMAGE3DOBSERVER__HXX__

// eof - $RCSfile$