#ifndef __FPA__VTK__IMAGE3DOBSERVER__HXX__
#define __FPA__VTK__IMAGE3DOBSERVER__HXX__
-#include <itkImageBase.h>
+#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 <vtkRenderer.h>
#include <vtkRendererCollection.h>
-/*
- #include <vtkCellArray.h>
- #include <vtkProperty.h>
-*/
-
// -------------------------------------------------------------------------
template< class F, class R >
void fpa::VTK::Image3DObserver< F, 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;
- typedef typename F::TBacktrackingEvent _TBacktrackingEvent;
- typedef typename F::TEndBacktrackingEvent _TEndBacktrackingEvent;
+ 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 )
const F* filter = dynamic_cast< const F* >( c );
if( filter == NULL )
return;
- const _TImage* image = filter->GetInput( );
- if( image == NULL )
+ 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 )
+ const _TStartEvent* startEvt = dynamic_cast< const _TStartEvent* >( &e );
+ const _TStartBacktrackingEvent* startBackEvt =
+ dynamic_cast< const _TStartBacktrackingEvent* >( &e );
+ if( startEvt != NULL || startBackEvt != NULL )
{
- this->m_Data = vtkSmartPointer< vtkPolyData >::New( );
- this->m_Mapper = vtkSmartPointer< vtkPolyDataMapper >::New( );
- this->m_Actor = vtkSmartPointer< vtkActor >::New( );
+ // 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( );
+ 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 );
- } // fi
+ 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( );
- // Get possible events
- const _TEvent* evt = dynamic_cast< const _TEvent* >( &e );
- _TFrontEvent fevt;
- _TMarkEvent mevt;
- _TCollisionEvent cevt;
- _TEndEvent eevt;
+ } // fi
+ return;
- if( evt != NULL )
+ } // fi
+
+ const _TAliveEvent* aliveEvt = dynamic_cast< const _TAliveEvent* >( &e );
+ const _TFrontEvent* frontEvt = dynamic_cast< const _TFrontEvent* >( &e );
+ if( aliveEvt != NULL || frontEvt != 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 );
- 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;
- }
- else if( mevt.CheckEvent( evt ) )
+ _TImage::IndexType vertex;
+ if( aliveEvt != NULL )
+ vertex = aliveEvt->Vertex;
+ else if( frontEvt != NULL )
+ vertex = frontEvt->Vertex;
+
+ if( this->m_Marks->GetPixel( vertex ) == -1 )
{
- // TODO: std::cout << "mark" << std::endl;
- return;
+ typename _TImage::PointType pnt;
+ image->TransformIndexToPhysicalPoint( vertex, pnt );
- } // fi
+ 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( );
- if( cevt.CheckEvent( evt ) )
- {
- // TODO: std::cout << "collision" << std::endl;
- return;
+ 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;
- if( eevt.CheckEvent( evt ) )
- {
- 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
- } // fi
- }
- else
+ 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 )
{
- const _TBacktrackingEvent* bevt =
- dynamic_cast< const _TBacktrackingEvent* >( &e );
- const _TEndBacktrackingEvent* ebevt =
- dynamic_cast< const _TEndBacktrackingEvent* >( &e );
- if( bevt != NULL )
- {
static const unsigned long nColors = 10;
- double back_id = double( bevt->BackId % nColors ) / double( nColors );
+ double back_id =
+ double( backEvt->FrontId % nColors ) / double( nColors );
typename _TImage::PointType pnt;
- image->TransformIndexToPhysicalPoint( bevt->Node, pnt );
+ image->TransformIndexToPhysicalPoint( backEvt->Vertex, pnt );
long pId = this->m_Data->GetNumberOfPoints( );
this->m_Data->GetVerts( )->InsertNextCell( 1 );
this->m_Data->GetPointData( )->
GetScalars( )->InsertNextTuple1( back_id );
this->m_Data->Modified( );
-
return;
} // fi
- if( ebevt != NULL )
+ if( endBackEvt != NULL )
{
this->m_RenderWindow->Render( );
+ std::cout << "Press enter: " << std::ends;
+ int aux;
+ std::cin >> aux;
return;
} // fi
-
- } // fi
}
// -------------------------------------------------------------------------
m_RenderPercentage( double( 0.0001 ) )
{
}
+*/
#endif // __FPA__VTK__IMAGE3DOBSERVER__HXX__