#include <cpExtensions/Visualization/ImageSliceActors.h>
+#include <cmath>
#include <sstream>
#include <vtkAlgorithmOutput.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkStreamingDemandDrivenPipeline.h>
#include <vtkTextProperty.h>
+#include <vtkWindowLevelLookupTable.h>
// -------------------------------------------------------------------------
cpExtensions::Visualization::ImageSliceActors*
// -------------------------------------------------------------------------
void cpExtensions::Visualization::ImageSliceActors::
-AddInputConnection( vtkAlgorithmOutput* aout, int axis )
+AddInputConnection( vtkAlgorithmOutput* aout, int axis, LUTType lut )
{
+ vtkImageData* data = dynamic_cast< vtkImageData* >(
+ aout->GetProducer( )->GetOutputDataObject( aout->GetIndex( ) )
+ );
+ if( data == NULL )
+ return;
+
+ vtkImageMapToColors* new_map =
+ dynamic_cast< vtkImageMapToColors* >( aout->GetProducer( ) );
+ if( new_map == NULL )
+ {
+ // Configure LUT
+ this->_ConfigureNewLUT( data, lut );
+ new_map = *( this->ImageMaps.rbegin( ) );
+ if( new_map != NULL )
+ {
+ new_map->SetInputConnection( aout );
+ new_map->Update( );
+
+ } // fi
+ }
+ else
+ this->ImageMaps.push_back( new_map );
+
+ // Create mapper and actors
vtkSmartPointer< vtkImageSliceMapper > mapper =
vtkSmartPointer< vtkImageSliceMapper >::New( );
+ if( new_map != NULL )
+ mapper->SetInputConnection( new_map->GetOutputPort( ) );
+ else
+ mapper->SetInputConnection( aout );
this->SliceMappers.push_back( mapper );
- mapper->SetInputConnection( aout );
this->_ConfigureNewInput( axis );
}
// -------------------------------------------------------------------------
void cpExtensions::Visualization::ImageSliceActors::
-AddInputData( vtkImageData* data, int axis )
+AddInputData( vtkImageData* data, int axis, LUTType lut )
{
+ // Configure LUT
+ this->_ConfigureNewLUT( data, lut );
+ vtkImageMapToColors* new_map = *( this->ImageMaps.rbegin( ) );
+ if( new_map != NULL )
+ {
+ new_map->SetInputData( data );
+ new_map->Update( );
+
+ } // fi
+
+ // Create mapper and actors
vtkSmartPointer< vtkImageSliceMapper > mapper =
vtkSmartPointer< vtkImageSliceMapper >::New( );
+ if( new_map != NULL )
+ mapper->SetInputConnection( new_map->GetOutputPort( ) );
+ else
+ mapper->SetInputData( data );
this->SliceMappers.push_back( mapper );
- mapper->SetInputData( data );
this->_ConfigureNewInput( axis );
}
this->RemoveAllItems( );
// Delete all images
+ this->ImageMaps.clear( );
this->SliceMappers.clear( );
this->ImageActors.clear( );
this->AssociatedActors.clear( );
// Reconfigure unique objects
- this->Cursor = vtkSmartPointer< vtkPolyData >::New( );
- this->CursorMapper = vtkSmartPointer< vtkPolyDataMapper >::New( );
- this->CursorActor = vtkSmartPointer< vtkActor >::New( );
+ this->Cursor = vtkSmartPointer< vtkPolyData >::New( );
+ this->CursorMapper = vtkSmartPointer< vtkPolyDataMapper >::New( );
+ this->CursorActor = vtkSmartPointer< vtkActor >::New( );
this->PlaneFunction = vtkSmartPointer< vtkPlane >::New( );
this->PlaneSource = vtkSmartPointer< vtkPolyData >::New( );
this->PlaneMapper = vtkSmartPointer< vtkPolyDataMapper >::New( );
cursor_points->InsertNextPoint( 0, 0, 0 );
cursor_points->InsertNextPoint( 0, 0, 0 );
cursor_points->InsertNextPoint( 0, 0, 0 );
+ cursor_points->InsertNextPoint( 0, 0, 0 );
+ cursor_points->InsertNextPoint( 0, 0, 0 );
+ cursor_points->InsertNextPoint( 0, 0, 0 );
+ cursor_points->InsertNextPoint( 0, 0, 0 );
cursor_lines->InsertNextCell( 2 );
cursor_lines->InsertCellPoint( 0 );
cursor_lines->InsertCellPoint( 1 );
cursor_lines->InsertNextCell( 2 );
cursor_lines->InsertCellPoint( 2 );
cursor_lines->InsertCellPoint( 3 );
+ cursor_lines->InsertNextCell( 2 );
+ cursor_lines->InsertCellPoint( 4 );
+ cursor_lines->InsertCellPoint( 5 );
+ cursor_lines->InsertNextCell( 2 );
+ cursor_lines->InsertCellPoint( 6 );
+ cursor_lines->InsertCellPoint( 7 );
this->Cursor->SetPoints( cursor_points );
this->Cursor->SetLines( cursor_lines );
this->CursorMapper->SetInputData( this->Cursor );
// -------------------------------------------------------------------------
void cpExtensions::Visualization::ImageSliceActors::
-PushActorsInto( vtkRenderWindow* window )
+PushActorsInto( vtkRenderWindow* window, bool force_style )
{
vtkRenderWindowInteractor* rwi = window->GetInteractor( );
vtkRenderer* renderer = window->GetRenderers( )->GetFirstRenderer( );
// Update style
- if( rwi != NULL )
+ if( rwi != NULL && force_style )
{
if( rwi->GetInteractorStyle( ) != this->Style.GetPointer( ) )
+ {
rwi->SetInteractorStyle( this->Style );
+ } // fi
+
} // fi
if( renderer != NULL )
{
+ // Update actors
+ unsigned int N = this->GetNumberOfImageActors( );
+ for( unsigned int n = 0; n < N; ++n )
+ renderer->AddActor( this->GetImageActor( n ) );
+ renderer->AddActor( this->CursorActor );
+ renderer->AddActor( this->PlaneActor );
+ renderer->AddActor( this->TextActor );
+ renderer->Modified( );
+
// Configure camera
vtkCamera* camera = renderer->GetActiveCamera( );
if( camera == NULL )
return;
// Parallel projections are better when displaying 2D images
- int axis = this->GetAxis( );
- camera->ParallelProjectionOn( );
- camera->SetFocalPoint( double( 0 ), double( 0 ), double( 0 ) );
- if( axis == 0 )
+ if( force_style )
{
- camera->SetPosition( double( 1 ), double( 0 ), double( 0 ) );
- camera->SetViewUp ( double( 0 ), double( 1 ), double( 0 ) );
- }
- else if( axis == 1 )
- {
- camera->SetPosition( double( 0 ), double( 1 ), double( 0 ) );
- camera->SetViewUp ( double( 0 ), double( 0 ), double( -1 ) );
- }
- else // if( axis == 2 )
- {
- camera->SetPosition( double( 0 ), double( 0 ), double( 1 ) );
- camera->SetViewUp ( double( 0 ), double( 1 ), double( 0 ) );
+ int axis = this->GetAxis( );
+ camera->ParallelProjectionOn( );
+ camera->SetFocalPoint( double( 0 ), double( 0 ), double( 0 ) );
+ if( axis == 0 )
+ {
+ camera->SetPosition( double( 1 ), double( 0 ), double( 0 ) );
+ camera->SetViewUp ( double( 0 ), double( 1 ), double( 0 ) );
+ }
+ else if( axis == 1 )
+ {
+ camera->SetPosition( double( 0 ), double( 1 ), double( 0 ) );
+ camera->SetViewUp ( double( 0 ), double( 0 ), double( -1 ) );
+ }
+ else // if( axis == 2 )
+ {
+ camera->SetPosition( double( 0 ), double( 0 ), double( 1 ) );
+ camera->SetViewUp ( double( 0 ), double( 1 ), double( 0 ) );
+
+ } // fi
} // fi
renderer->ResetCamera( );
-
- // Update actors
- unsigned int N = this->GetNumberOfImageActors( );
- for( unsigned int n = 0; n < N; ++n )
- renderer->AddActor( this->GetImageActor( n ) );
- renderer->AddActor( this->CursorActor );
- renderer->AddActor( this->PlaneActor );
- renderer->AddActor( this->TextActor );
- renderer->Modified( );
+ rwi->Render( );
} // fi
}
void cpExtensions::Visualization::ImageSliceActors::
PopActorsFrom( vtkRenderWindow* window )
{
- /*
- unsigned int N = this->GetNumberOfImageActors( );
- for( unsigned int n = 0; n < N; ++n )
- renderer->RemoveActor( this->GetImageActor( n ) );
- renderer->RemoveActor( this->GetTextActor( ) );
- renderer->RemoveActor( this->GetPlaneActor( ) );
- renderer->Modified( );
- */
+ vtkRenderWindowInteractor* rwi = window->GetInteractor( );
+ vtkRenderer* renderer = window->GetRenderers( )->GetFirstRenderer( );
+
+ if( renderer != NULL )
+ {
+ // Update actors
+ unsigned int N = this->GetNumberOfImageActors( );
+ for( unsigned int n = 0; n < N; ++n )
+ renderer->RemoveActor( this->GetImageActor( n ) );
+ renderer->RemoveActor( this->CursorActor );
+ renderer->RemoveActor( this->PlaneActor );
+ renderer->RemoveActor( this->TextActor );
+ renderer->Modified( );
+
+ } // fi
}
// -------------------------------------------------------------------------
points->SetPoint( 1, 0, 0, 0 );
points->SetPoint( 2, 0, 0, 0 );
points->SetPoint( 3, 0, 0, 0 );
+ points->SetPoint( 4, 0, 0, 0 );
+ points->SetPoint( 5, 0, 0, 0 );
+ points->SetPoint( 6, 0, 0, 0 );
+ points->SetPoint( 7, 0, 0, 0 );
this->Cursor->Modified( );
this->CursorMapper->Modified( );
this->CursorActor->Modified( );
if( this->SliceMappers.size( ) == 0 )
return;
+ // Get ordered axes
int a0 = this->GetAxis( );
int a1 = ( a0 + 1 ) % 3;
int a2 = ( a0 + 2 ) % 3;
+ int ma0 = a0 << 1;
+ int ma1 = a1 << 1;
+ int ma2 = a2 << 1;
double bounds[ 6 ];
- this->SliceMappers[ 0 ]->GetBounds( bounds );
+ this->SliceMappers[ 0 ]->GetInput( )->GetBounds( bounds );
+
+ double
+ p0[ 3 ], p1[ 3 ], p2[ 3 ], p3[ 3 ],
+ p4[ 3 ], p5[ 3 ], p6[ 3 ], p7[ 3 ];
- double p0[ 3 ], p1[ 3 ], p2[ 3 ], p3[ 3 ];
- p0[ a0 ] = p1[ a0 ] = p2[ a0 ] = p3[ a0 ] = pos[ a0 ];
- p0[ a2 ] = p1[ a2 ] = pos[ a2 ];
- p2[ a1 ] = p3[ a1 ] = pos[ a1 ];
- p0[ a1 ] = bounds[ a1 << 1 ];
- p1[ a1 ] = bounds[ ( a1 << 1 ) + 1 ];
- p2[ a2 ] = bounds[ a2 << 1 ];
- p3[ a2 ] = bounds[ ( a2 << 1 ) + 1 ];
+ p0[ a2 ] = p1[ a2 ] = p4[ a2 ] = p5[ a2 ] = pos[ a2 ];
+ p2[ a1 ] = p3[ a1 ] = p6[ a1 ] = p7[ a1 ] = pos[ a1 ];
+ p0[ a0 ] = p1[ a0 ] = p2[ a0 ] = p3[ a0 ] = bounds[ ma0 ];
+ p4[ a0 ] = p5[ a0 ] = p6[ a0 ] = p7[ a0 ] = bounds[ ma0 + 1 ];
+ p0[ a1 ] = p4[ a1 ] = bounds[ ma1 ];
+ p1[ a1 ] = p5[ a1 ] = bounds[ ma1 + 1 ];
+ p2[ a2 ] = p6[ a2 ] = bounds[ ma2 ];
+ p3[ a2 ] = p7[ a2 ] = bounds[ ma2 + 1 ];
vtkPoints* points = this->Cursor->GetPoints( );
points->SetPoint( 0, p0 );
points->SetPoint( 1, p1 );
points->SetPoint( 2, p2 );
points->SetPoint( 3, p3 );
+ points->SetPoint( 4, p4 );
+ points->SetPoint( 5, p5 );
+ points->SetPoint( 6, p6 );
+ points->SetPoint( 7, p7 );
this->Cursor->Modified( );
this->CursorMapper->Modified( );
this->CursorActor->Modified( );
}
+// -------------------------------------------------------------------------
+vtkImageMapToColors* cpExtensions::Visualization::ImageSliceActors::
+GetImageMap( unsigned int id )
+{
+ if( id < this->ImageMaps.size( ) )
+ return( this->ImageMaps[ id ].GetPointer( ) );
+ else
+ return( NULL );
+}
+
+// -------------------------------------------------------------------------
+const vtkImageMapToColors* cpExtensions::Visualization::ImageSliceActors::
+GetImageMap( unsigned int id ) const
+{
+ if( id < this->ImageMaps.size( ) )
+ return( this->ImageMaps[ id ].GetPointer( ) );
+ else
+ return( NULL );
+}
+
+// -------------------------------------------------------------------------
+double cpExtensions::Visualization::ImageSliceActors::
+GetWindow( unsigned int id ) const
+{
+ if( this->ImageMaps[ id ].GetPointer( ) != NULL )
+ {
+ vtkWindowLevelLookupTable* lut =
+ dynamic_cast< vtkWindowLevelLookupTable* >(
+ this->ImageMaps[ id ]->GetLookupTable( )
+ );
+ if( lut != NULL )
+ return( lut->GetWindow( ) );
+ else
+ return( double( 0 ) );
+ }
+ else
+ return( double( 0 ) );
+}
+
+// -------------------------------------------------------------------------
+double cpExtensions::Visualization::ImageSliceActors::
+GetLevel( unsigned int id ) const
+{
+ if( this->ImageMaps[ id ].GetPointer( ) != NULL )
+ {
+ vtkWindowLevelLookupTable* lut =
+ dynamic_cast< vtkWindowLevelLookupTable* >(
+ this->ImageMaps[ id ]->GetLookupTable( )
+ );
+ if( lut != NULL )
+ return( lut->GetLevel( ) );
+ else
+ return( double( 0 ) );
+ }
+ else
+ return( double( 0 ) );
+}
+
+// -------------------------------------------------------------------------
+void cpExtensions::Visualization::ImageSliceActors::
+SetWindow( unsigned int id, double w )
+{
+ if( this->ImageMaps[ id ].GetPointer( ) != NULL )
+ {
+ vtkWindowLevelLookupTable* lut =
+ dynamic_cast< vtkWindowLevelLookupTable* >(
+ this->ImageMaps[ id ]->GetLookupTable( )
+ );
+ if( lut != NULL )
+ {
+ lut->SetWindow( w );
+ lut->Build( );
+ this->ImageMaps[ id ]->Modified( );
+ this->Modified( );
+
+ } // fi
+
+ } // fi
+}
+
+// -------------------------------------------------------------------------
+void cpExtensions::Visualization::ImageSliceActors::
+SetLevel( unsigned int id, double l )
+{
+ if( this->ImageMaps[ id ].GetPointer( ) != NULL )
+ {
+ vtkWindowLevelLookupTable* lut =
+ dynamic_cast< vtkWindowLevelLookupTable* >(
+ this->ImageMaps[ id ]->GetLookupTable( )
+ );
+ if( lut != NULL )
+ {
+ lut->SetLevel( l );
+ lut->Build( );
+ this->ImageMaps[ id ]->Modified( );
+ this->Modified( );
+
+ } // fi
+
+ } // fi
+}
+
+// -------------------------------------------------------------------------
+void cpExtensions::Visualization::ImageSliceActors::
+SetWindowLevel( unsigned int id, double w, double l )
+{
+ if( this->ImageMaps[ id ].GetPointer( ) != NULL )
+ {
+ vtkWindowLevelLookupTable* lut =
+ dynamic_cast< vtkWindowLevelLookupTable* >(
+ this->ImageMaps[ id ]->GetLookupTable( )
+ );
+ if( lut != NULL )
+ {
+ lut->SetWindow( w );
+ lut->SetLevel( l );
+ lut->Build( );
+ this->ImageMaps[ id ]->Modified( );
+ this->UpdateText( w, l );
+ this->Modified( );
+
+ } // fi
+
+ } // fi
+}
+
+// -------------------------------------------------------------------------
+void cpExtensions::Visualization::ImageSliceActors::
+ResetWindowLevel( unsigned int id )
+{
+}
+
// -------------------------------------------------------------------------
int cpExtensions::Visualization::ImageSliceActors::
GetAxis( ) const
else if( axId == 2 ) axis = 'Z';
int slice = this->GetSliceNumber( );
- vtkImageData* image = this->SliceMappers[ 0 ]->GetInput( );
+ vtkImageData* image;
+ if( this->ImageMaps[ 0 ] != NULL )
+ image =
+ dynamic_cast< vtkImageData* >( this->ImageMaps[ 0 ]->GetInput( ) );
+ else
+ image = this->SliceMappers[ 0 ]->GetInput( );
int ijk[ 3 ];
double pcoords[ 3 ];
: Superclass( ),
Interpolate( false )
{
+ this->Clear( );
+
// Connect this view with a controller
this->Style = vtkSmartPointer< ImageInteractorStyle >::New( );
this->Style->AssociateView( this );
this->Style->SetMouseDoubleClickCommand( Self::_MouseDoubleClickCommand );
this->Style->SetMouseWheelCommand( Self::_MouseWheelCommand );
this->Style->SetKeyCommand( Self::_KeyCommand );
-
- this->Clear( );
}
// -------------------------------------------------------------------------
{
}
+// -------------------------------------------------------------------------
+void cpExtensions::Visualization::ImageSliceActors::
+_ConfigureNewLUT( vtkImageData* data, LUTType lut_t )
+{
+ static const double _0 = double( 0 );
+ static const double _1 = double( 1 );
+ static const double _2 = double( 2 );
+ static const double _4 = double( 4 );
+ static const double _6 = double( 6 );
+ static const double _OPACITY = double( 0.6 );
+
+ // Configure LUT
+ vtkSmartPointer< vtkImageMapToColors > new_map( NULL );
+ if( data->GetNumberOfScalarComponents( ) == 1 )
+ {
+ double range[ 2 ];
+ data->GetScalarRange( range );
+ if( lut_t == Self::LUTType_WindowLevel )
+ {
+ vtkSmartPointer< vtkWindowLevelLookupTable > lut =
+ vtkSmartPointer< vtkWindowLevelLookupTable >::New( );
+ lut->SetScaleToLinear( );
+ lut->SetTableRange( range );
+ lut->SetWindow( range[ 1 ] - range[ 0 ] );
+ lut->SetLevel( ( range[ 1 ] + range[ 0 ] ) / double( 2 ) );
+ lut->Build( );
+
+ new_map = vtkSmartPointer< vtkImageMapToColors >::New( );
+ new_map->SetLookupTable( lut );
+ }
+ else if( lut_t == LUTType_Colors )
+ {
+ // Get HSV from display color
+ double r = 1, g = 0, b = 0;
+ double cmax = ( r > g )? r: g; cmax = ( b > cmax )? b: cmax;
+ double cmin = ( r < g )? r: g; cmin = ( b < cmin )? b: cmin;
+ double d = cmax - cmin;
+
+ double saturation = ( std::fabs( cmax ) > _0 )? d / cmax: _0;
+ double value = cmax;
+ double hue = _0;
+ if( d > _0 )
+ {
+ if( r == cmax )
+ hue = std::fmod( ( g - b ) / d, _6 );
+ else if( g == cmax )
+ hue = ( ( b - r ) / d ) + _2;
+ else if( b == cmax )
+ hue = ( ( r - g ) / d ) + _4;
+ hue *= _1 / _6;
+
+ } // fi
+
+ // Define new lookup table
+ vtkSmartPointer< vtkLookupTable > lut =
+ vtkSmartPointer< vtkLookupTable >::New( );
+ lut->SetScaleToLinear( );
+ lut->SetNanColor( _0, _0, _0, _0 );
+ lut->SetTableRange( range[ 0 ], range[ 1 ] );
+ lut->SetAlphaRange( _0, _OPACITY );
+ lut->SetHueRange( _0, hue );
+ lut->SetSaturationRange( _0, saturation );
+ lut->SetValueRange( _0, value );
+ lut->Build( );
+
+ new_map = vtkSmartPointer< vtkImageMapToColors >::New( );
+ new_map->SetLookupTable( lut );
+
+ } // fi
+
+ } // fi
+ this->ImageMaps.push_back( new_map );
+}
+
// -------------------------------------------------------------------------
void cpExtensions::Visualization::ImageSliceActors::
_ConfigureNewInput( int axis )
}
else if( btn == ImageInteractorStyle::ButtonID_Right )
{
+ if( !alt && !ctr && sft )
+ {
+ double bounds[ 6 ];
+ actors->SliceMappers[ 0 ]->GetBounds( bounds );
+
+ int a0 = actors->GetAxis( );
+ int a1 = ( a0 + 1 ) % 3;
+ int a2 = ( a0 + 2 ) % 3;
+ double dx = pos[ a1 ] - actors->StartWindowLevelPos[ a1 ];
+ double dy = pos[ a2 ] - actors->StartWindowLevelPos[ a2 ];
+ dx /= bounds[ ( a1 << 1 ) + 1 ] - bounds[ a1 << 1 ];
+ dy /= bounds[ ( a2 << 1 ) + 1 ] - bounds[ a2 << 1 ];
+
+ dx *= actors->StartWindowLevel[ 0 ];
+ dy *= actors->StartWindowLevel[ 1 ];
+ actors->SetWindowLevel(
+ 0,
+ actors->StartWindowLevel[ 0 ] + dx,
+ actors->StartWindowLevel[ 1 ] + dy
+ );
+
+ } // fi
+
} // fi
}
bool alt, bool ctr, bool sft
)
{
+ ImageSliceActors* actors = reinterpret_cast< ImageSliceActors* >( data );
+ if( actors == NULL )
+ return;
+
+ actors->StartWindowLevelPos[ 0 ] = pos[ 0 ];
+ actors->StartWindowLevelPos[ 1 ] = pos[ 1 ];
+ actors->StartWindowLevelPos[ 2 ] = pos[ 2 ];
+ actors->StartWindowLevel[ 0 ] = actors->GetWindow( 0 );
+ actors->StartWindowLevel[ 1 ] = actors->GetLevel( 0 );
}
// -------------------------------------------------------------------------
git://git.creatis.insa-lyon.fr / cpPlugins.git / blobdiff