Extracts a 2D slice of arbitrary geometry from a 3D or 4D image. More...
#include <mitkExtractDirectedPlaneImageFilter.h>
Public Types | |
| typedef ExtractDirectedPlaneImageFilter | Self |
| typedef ImageToImageFilter | Superclass |
| typedef itk::SmartPointer< Self > | Pointer |
| typedef itk::SmartPointer < const Self > | ConstPointer |
Public Member Functions | |
| virtual const char * | GetClassName () const |
| virtual void | SetWorldGeometry (Geometry2D *_arg) |
| virtual vtkImageReslice * | GetReslicer () |
| virtual void | SetTargetTimestep (unsigned int _arg) |
| virtual unsigned int | GetTargetTimestep () |
| virtual void | SetInPlaneResampleExtentByGeometry (bool _arg) |
| virtual bool | GetInPlaneResampleExtentByGeometry () |
Static Public Member Functions | |
| static Pointer | New () |
Protected Member Functions | |
| ExtractDirectedPlaneImageFilter () | |
| virtual | ~ExtractDirectedPlaneImageFilter () |
| virtual void | GenerateData () |
| A version of GenerateData() specific for image processing filters. | |
| virtual void | GenerateOutputInformation () |
| bool | CalculateClippedPlaneBounds (const Geometry3D *boundingGeometry, const PlaneGeometry *planeGeometry, vtkFloatingPointType *bounds) |
| bool | LineIntersectZero (vtkPoints *points, int p1, int p2, vtkFloatingPointType *bounds) |
Protected Attributes | |
| const Geometry2D * | m_WorldGeometry |
| vtkImageReslice * | m_Reslicer |
| unsigned int | m_TargetTimestep |
| bool | m_InPlaneResampleExtentByGeometry |
Extracts a 2D slice of arbitrary geometry from a 3D or 4D image.
This class takes a 3D or 4D mitk::Image as input and tries to extract one slice from it. This slice can be arbitrary oriented in space. The 2D slice is resliced by a vtk::ResliceImage filter if not perpendicular to the input image.
The world geometry of the plane to be extracted image must be given as an input to the filter in order to correctly calculate world coordinates of the extracted slice. Setting a timestep from which the plane should be extracted is optional.
Output will not be set if there was a problem extracting the desired slice.
Last contributor:
Definition at line 52 of file mitkExtractDirectedPlaneImageFilter.h.
| typedef itk::SmartPointer<const Self> mitk::ExtractDirectedPlaneImageFilter::ConstPointer |
Definition at line 56 of file mitkExtractDirectedPlaneImageFilter.h.
| typedef itk::SmartPointer<Self> mitk::ExtractDirectedPlaneImageFilter::Pointer |
Definition at line 56 of file mitkExtractDirectedPlaneImageFilter.h.
Definition at line 56 of file mitkExtractDirectedPlaneImageFilter.h.
Definition at line 56 of file mitkExtractDirectedPlaneImageFilter.h.
| mitk::ExtractDirectedPlaneImageFilter::ExtractDirectedPlaneImageFilter | ( | ) | [protected] |
Definition at line 34 of file mitkExtractDirectedPlaneImageFilter.cpp.
References m_InPlaneResampleExtentByGeometry, m_Reslicer, m_TargetTimestep, and New().
: m_WorldGeometry(NULL) { m_Reslicer = vtkImageReslice::New(); m_TargetTimestep = 0; m_InPlaneResampleExtentByGeometry = false; }
| mitk::ExtractDirectedPlaneImageFilter::~ExtractDirectedPlaneImageFilter | ( | ) | [protected, virtual] |
Definition at line 42 of file mitkExtractDirectedPlaneImageFilter.cpp.
{
m_WorldGeometry = NULL;
m_Reslicer->Delete();
}
| bool mitk::ExtractDirectedPlaneImageFilter::CalculateClippedPlaneBounds | ( | const Geometry3D * | boundingGeometry, |
| const PlaneGeometry * | planeGeometry, | ||
| vtkFloatingPointType * | bounds | ||
| ) | [protected] |
Definition at line 388 of file mitkExtractDirectedPlaneImageFilter.cpp.
References mitk::Geometry3D::GetBoundingBox(), mitk::Geometry3D::GetFloatSpacing(), mitk::Geometry3D::GetImageGeometry(), and mitk::Geometry3D::GetVtkTransform().
{
// Clip the plane with the bounding geometry. To do so, the corner points
// of the bounding box are transformed by the inverse transformation
// matrix, and the transformed bounding box edges derived therefrom are
// clipped with the plane z=0. The resulting min/max values are taken as
// bounds for the image reslicer.
const BoundingBox *boundingBox = boundingGeometry->GetBoundingBox();
BoundingBox::PointType bbMin = boundingBox->GetMinimum();
BoundingBox::PointType bbMax = boundingBox->GetMaximum();
BoundingBox::PointType bbCenter = boundingBox->GetCenter();
vtkPoints *points = vtkPoints::New();
if(boundingGeometry->GetImageGeometry())
{
points->InsertPoint( 0, bbMin[0]-0.5, bbMin[1]-0.5, bbMin[2]-0.5 );
points->InsertPoint( 1, bbMin[0]-0.5, bbMin[1]-0.5, bbMax[2]-0.5 );
points->InsertPoint( 2, bbMin[0]-0.5, bbMax[1]-0.5, bbMax[2]-0.5 );
points->InsertPoint( 3, bbMin[0]-0.5, bbMax[1]-0.5, bbMin[2]-0.5 );
points->InsertPoint( 4, bbMax[0]-0.5, bbMin[1]-0.5, bbMin[2]-0.5 );
points->InsertPoint( 5, bbMax[0]-0.5, bbMin[1]-0.5, bbMax[2]-0.5 );
points->InsertPoint( 6, bbMax[0]-0.5, bbMax[1]-0.5, bbMax[2]-0.5 );
points->InsertPoint( 7, bbMax[0]-0.5, bbMax[1]-0.5, bbMin[2]-0.5 );
}
else
{
points->InsertPoint( 0, bbMin[0], bbMin[1], bbMin[2] );
points->InsertPoint( 1, bbMin[0], bbMin[1], bbMax[2] );
points->InsertPoint( 2, bbMin[0], bbMax[1], bbMax[2] );
points->InsertPoint( 3, bbMin[0], bbMax[1], bbMin[2] );
points->InsertPoint( 4, bbMax[0], bbMin[1], bbMin[2] );
points->InsertPoint( 5, bbMax[0], bbMin[1], bbMax[2] );
points->InsertPoint( 6, bbMax[0], bbMax[1], bbMax[2] );
points->InsertPoint( 7, bbMax[0], bbMax[1], bbMin[2] );
}
vtkPoints *newPoints = vtkPoints::New();
vtkTransform *transform = vtkTransform::New();
transform->Identity();
transform->Concatenate(
planeGeometry->GetVtkTransform()->GetLinearInverse()
);
transform->Concatenate( boundingGeometry->GetVtkTransform() );
transform->TransformPoints( points, newPoints );
transform->Delete();
bounds[0] = bounds[2] = 10000000.0;
bounds[1] = bounds[3] = -10000000.0;
bounds[4] = bounds[5] = 0.0;
this->LineIntersectZero( newPoints, 0, 1, bounds );
this->LineIntersectZero( newPoints, 1, 2, bounds );
this->LineIntersectZero( newPoints, 2, 3, bounds );
this->LineIntersectZero( newPoints, 3, 0, bounds );
this->LineIntersectZero( newPoints, 0, 4, bounds );
this->LineIntersectZero( newPoints, 1, 5, bounds );
this->LineIntersectZero( newPoints, 2, 6, bounds );
this->LineIntersectZero( newPoints, 3, 7, bounds );
this->LineIntersectZero( newPoints, 4, 5, bounds );
this->LineIntersectZero( newPoints, 5, 6, bounds );
this->LineIntersectZero( newPoints, 6, 7, bounds );
this->LineIntersectZero( newPoints, 7, 4, bounds );
// clean up vtk data
points->Delete();
newPoints->Delete();
if ( (bounds[0] > 9999999.0) || (bounds[2] > 9999999.0)
|| (bounds[1] < -9999999.0) || (bounds[3] < -9999999.0) )
{
return false;
}
else
{
// The resulting bounds must be adjusted by the plane spacing, since we
// we have so far dealt with index coordinates
const float *planeSpacing = planeGeometry->GetFloatSpacing();
bounds[0] *= planeSpacing[0];
bounds[1] *= planeSpacing[0];
bounds[2] *= planeSpacing[1];
bounds[3] *= planeSpacing[1];
bounds[4] *= planeSpacing[2];
bounds[5] *= planeSpacing[2];
return true;
}
}
| void mitk::ExtractDirectedPlaneImageFilter::GenerateData | ( | ) | [protected, virtual] |
A version of GenerateData() specific for image processing filters.
This implementation will split the processing across multiple threads. The buffer is allocated by this method. Then the BeforeThreadedGenerateData() method is called (if provided). Then, a series of threads are spawned each calling ThreadedGenerateData(). After all the threads have completed processing, the AfterThreadedGenerateData() method is called (if provided). If an image processing filter cannot be threaded, the filter should provide an implementation of GenerateData(). That implementation is responsible for allocating the output buffer. If a filter an be threaded, it should NOT provide a GenerateData() method but should provide a ThreadedGenerateData() instead.
Reimplemented from mitk::ImageSource.
Definition at line 48 of file mitkExtractDirectedPlaneImageFilter.cpp.
References Pic2vtk::convert(), mitk::Geometry3D::GetAxisVector(), mitk::TimeSlicedGeometry::GetGeometry3D(), mitk::SlicedData::GetLargestPossibleRegion(), mitk::PlaneGeometry::GetNormal(), mitk::Geometry3D::GetOrigin(), mitk::Geometry3D::GetParametricExtent(), mitk::AbstractTransformGeometry::GetParametricExtentInMM(), mitk::AbstractTransformGeometry::GetPlane(), mitk::BaseData::GetTimeSlicedGeometry(), mitk::TimeSlicedGeometry::GetTimeSteps(), mitk::AbstractTransformGeometry::GetVtkAbstractTransform(), mitk::Image::GetVtkImageData(), int(), mitk::TimeSlicedGeometry::IsValidTime(), mitk::Image::IsVolumeSet(), mitkIpPicDescriptor, mitk::TimeSlicedGeometry::MSToTimeStep(), and mitk::SlicedData::SetRequestedRegion().
{
// A world geometry must be set...
if ( m_WorldGeometry == NULL )
{
itkWarningMacro(<<"No world geometry has been set. Returning.");
return;
}
Image *input = const_cast< ImageToImageFilter::InputImageType* >( this->GetInput() );
input->Update();
if ( input == NULL )
{
itkWarningMacro(<<"No input set.");
return;
}
const TimeSlicedGeometry *inputTimeGeometry = input->GetTimeSlicedGeometry();
if ( ( inputTimeGeometry == NULL )
|| ( inputTimeGeometry->GetTimeSteps() == 0 ) )
{
itkWarningMacro(<<"Error reading input image geometry.");
return;
}
// Get the target timestep; if none is set, use the lowest given.
unsigned int timestep = 0;
if ( ! m_TargetTimestep )
{
ScalarType time = m_WorldGeometry->GetTimeBounds()[0];
if ( time > ScalarTypeNumericTraits::NonpositiveMin() )
{
timestep = inputTimeGeometry->MSToTimeStep( time );
}
}
else timestep = m_TargetTimestep;
if ( inputTimeGeometry->IsValidTime( timestep ) == false )
{
itkWarningMacro(<<"This is not a valid timestep: "<<timestep);
return;
}
// check if there is something to display.
if ( ! input->IsVolumeSet( timestep ) )
{
itkWarningMacro(<<"No volume data existent at given timestep "<<timestep);
return;
}
Image::RegionType requestedRegion = input->GetLargestPossibleRegion();
requestedRegion.SetIndex( 3, timestep );
requestedRegion.SetSize( 3, 1 );
requestedRegion.SetSize( 4, 1 );
input->SetRequestedRegion( &requestedRegion );
input->Update();
vtkImageData* inputData = input->GetVtkImageData( timestep );
if ( inputData == NULL )
{
itkWarningMacro(<<"Could not extract vtk image data for given timestep"<<timestep);
return;
}
vtkFloatingPointType spacing[3];
inputData->GetSpacing( spacing );
// how big the area is in physical coordinates: widthInMM x heightInMM pixels
mitk::ScalarType widthInMM, heightInMM;
// where we want to sample
Point3D origin;
Vector3D right, bottom, normal;
Vector3D rightInIndex, bottomInIndex;
assert( input->GetTimeSlicedGeometry() == inputTimeGeometry );
// take transform of input image into account
Geometry3D* inputGeometry = inputTimeGeometry->GetGeometry3D( timestep );
if ( inputGeometry == NULL )
{
itkWarningMacro(<<"There is no Geometry3D at given timestep "<<timestep);
return;
}
ScalarType mmPerPixel[2];
// Bounds information for reslicing (only required if reference geometry
// is present)
vtkFloatingPointType bounds[6];
bool boundsInitialized = false;
for ( int i = 0; i < 6; ++i )
{
bounds[i] = 0.0;
}
Vector2D extent; extent.Fill( 0.0 );
// Do we have a simple PlaneGeometry?
if ( dynamic_cast< const PlaneGeometry * >( m_WorldGeometry ) != NULL )
{
const PlaneGeometry *planeGeometry =
static_cast< const PlaneGeometry * >( m_WorldGeometry );
origin = planeGeometry->GetOrigin();
right = planeGeometry->GetAxisVector( 0 );
bottom = planeGeometry->GetAxisVector( 1 );
normal = planeGeometry->GetNormal();
if ( m_InPlaneResampleExtentByGeometry )
{
// Resampling grid corresponds to the current world geometry. This
// means that the spacing of the output 2D image depends on the
// currently selected world geometry, and *not* on the image itself.
extent[0] = m_WorldGeometry->GetExtent( 0 );
extent[1] = m_WorldGeometry->GetExtent( 1 );
}
else
{
// Resampling grid corresponds to the input geometry. This means that
// the spacing of the output 2D image is directly derived from the
// associated input image, regardless of the currently selected world
// geometry.
inputGeometry->WorldToIndex( origin, right, rightInIndex );
inputGeometry->WorldToIndex( origin, bottom, bottomInIndex );
extent[0] = rightInIndex.GetNorm();
extent[1] = bottomInIndex.GetNorm();
}
// Get the extent of the current world geometry and calculate resampling
// spacing therefrom.
widthInMM = m_WorldGeometry->GetExtentInMM( 0 );
heightInMM = m_WorldGeometry->GetExtentInMM( 1 );
mmPerPixel[0] = widthInMM / extent[0];
mmPerPixel[1] = heightInMM / extent[1];
right.Normalize();
bottom.Normalize();
normal.Normalize();
origin += right * ( mmPerPixel[0] * 0.5 );
origin += bottom * ( mmPerPixel[1] * 0.5 );
widthInMM -= mmPerPixel[0];
heightInMM -= mmPerPixel[1];
// Use inverse transform of the input geometry for reslicing the 3D image
m_Reslicer->SetResliceTransform(
inputGeometry->GetVtkTransform()->GetLinearInverse() );
// Set background level to TRANSLUCENT (see Geometry2DDataVtkMapper3D)
m_Reslicer->SetBackgroundLevel( -32768 );
// Check if a reference geometry does exist (as would usually be the case for
// PlaneGeometry).
// Note: this is currently not strictly required, but could facilitate
// correct plane clipping.
if ( m_WorldGeometry->GetReferenceGeometry() )
{
// Calculate the actual bounds of the transformed plane clipped by the
// dataset bounding box; this is required for drawing the texture at the
// correct position during 3D mapping.
boundsInitialized = this->CalculateClippedPlaneBounds(
m_WorldGeometry->GetReferenceGeometry(), planeGeometry, bounds );
}
}
// Do we have an AbstractTransformGeometry?
else if ( dynamic_cast< const AbstractTransformGeometry * >( m_WorldGeometry ) )
{
const mitk::AbstractTransformGeometry* abstractGeometry =
dynamic_cast< const AbstractTransformGeometry * >(m_WorldGeometry);
extent[0] = abstractGeometry->GetParametricExtent(0);
extent[1] = abstractGeometry->GetParametricExtent(1);
widthInMM = abstractGeometry->GetParametricExtentInMM(0);
heightInMM = abstractGeometry->GetParametricExtentInMM(1);
mmPerPixel[0] = widthInMM / extent[0];
mmPerPixel[1] = heightInMM / extent[1];
origin = abstractGeometry->GetPlane()->GetOrigin();
right = abstractGeometry->GetPlane()->GetAxisVector(0);
right.Normalize();
bottom = abstractGeometry->GetPlane()->GetAxisVector(1);
bottom.Normalize();
normal = abstractGeometry->GetPlane()->GetNormal();
normal.Normalize();
// Use a combination of the InputGeometry *and* the possible non-rigid
// AbstractTransformGeometry for reslicing the 3D Image
vtkGeneralTransform *composedResliceTransform = vtkGeneralTransform::New();
composedResliceTransform->Identity();
composedResliceTransform->Concatenate(
inputGeometry->GetVtkTransform()->GetLinearInverse() );
composedResliceTransform->Concatenate(
abstractGeometry->GetVtkAbstractTransform()
);
m_Reslicer->SetResliceTransform( composedResliceTransform );
// Set background level to BLACK instead of translucent, to avoid
// boundary artifacts (see Geometry2DDataVtkMapper3D)
m_Reslicer->SetBackgroundLevel( -1023 );
composedResliceTransform->Delete();
}
else
{
itkWarningMacro(<<"World Geometry has to be a PlaneGeometry or an AbstractTransformGeometry.");
return;
}
// Make sure that the image to be resliced has a certain minimum size.
if ( (extent[0] <= 2) && (extent[1] <= 2) )
{
itkWarningMacro(<<"Image is too small to be resliced...");
return;
}
vtkImageChangeInformation * unitSpacingImageFilter = vtkImageChangeInformation::New() ;
unitSpacingImageFilter->SetOutputSpacing( 1.0, 1.0, 1.0 );
unitSpacingImageFilter->SetInput( inputData );
m_Reslicer->SetInput( unitSpacingImageFilter->GetOutput() );
unitSpacingImageFilter->Delete();
m_Reslicer->SetOutputDimensionality( 2 );
m_Reslicer->SetOutputOrigin( 0.0, 0.0, 0.0 );
Vector2D pixelsPerMM;
pixelsPerMM[0] = 1.0 / mmPerPixel[0];
pixelsPerMM[1] = 1.0 / mmPerPixel[1];
//calulate the originArray and the orientations for the reslice-filter
double originArray[3];
itk2vtk( origin, originArray );
m_Reslicer->SetResliceAxesOrigin( originArray );
double cosines[9];
// direction of the X-axis of the sampled result
vnl2vtk( right.Get_vnl_vector(), cosines );
// direction of the Y-axis of the sampled result
vnl2vtk( bottom.Get_vnl_vector(), cosines + 3 );
// normal of the plane
vnl2vtk( normal.Get_vnl_vector(), cosines + 6 );
m_Reslicer->SetResliceAxesDirectionCosines( cosines );
// Determine output extent for reslicing
ScalarType size[2];
size[0] = (bounds[1] - bounds[0]) / mmPerPixel[0];
size[1] = (bounds[3] - bounds[2]) / mmPerPixel[1];
int xMin, xMax, yMin, yMax;
if ( boundsInitialized )
{
xMin = static_cast< int >( bounds[0] / mmPerPixel[0] + 0.5 );
xMax = static_cast< int >( bounds[1] / mmPerPixel[0] + 0.5 );
yMin = static_cast< int >( bounds[2] / mmPerPixel[1] + 0.5 );
yMax = static_cast< int >( bounds[3] / mmPerPixel[1] + 0.5 );
}
else
{
// If no reference geometry is available, we also don't know about the
// maximum plane size; so the overlap is just ignored
xMin = yMin = 0;
xMax = static_cast< int >( extent[0] - pixelsPerMM[0] + 0.5 );
yMax = static_cast< int >( extent[1] - pixelsPerMM[1] + 0.5 );
}
m_Reslicer->SetOutputSpacing( mmPerPixel[0], mmPerPixel[1], 1.0 );
// xMax and yMax are meant exclusive until now, whereas
// SetOutputExtent wants an inclusive bound. Thus, we need
// to subtract 1.
m_Reslicer->SetOutputExtent( xMin, xMax-1, yMin, yMax-1, 0, 1 );
// Do the reslicing. Modified() is called to make sure that the reslicer is
// executed even though the input geometry information did not change; this
// is necessary when the input /em data, but not the /em geometry changes.
m_Reslicer->Modified();
m_Reslicer->ReleaseDataFlagOn();
m_Reslicer->Update();
// 1. Check the result
vtkImageData* reslicedImage = m_Reslicer->GetOutput();
mitkIpPicDescriptor *pic = Pic2vtk::convert( reslicedImage );
if((reslicedImage == NULL) || (reslicedImage->GetDataDimension() < 1))
{
itkWarningMacro(<<"Reslicer returned empty image");
return;
}
unsigned int dimensions[2];
dimensions[0] = (unsigned int)extent[0]; dimensions[1] = (unsigned int)extent[1];
Vector3D spacingVector;
FillVector3D(spacingVector, mmPerPixel[0], mmPerPixel[1], 1.0);
mitk::Image::Pointer resultImage = this->GetOutput();
resultImage->Initialize( pic );
resultImage->SetSpacing( spacingVector );
resultImage->SetPicVolume( pic );
mitkIpPicFree(pic);
/*unsigned int dimensions[2];
dimensions[0] = (unsigned int)extent[0]; dimensions[1] = (unsigned int)extent[1];
Vector3D spacingVector;
FillVector3D(spacingVector, mmPerPixel[0], mmPerPixel[1], 1.0);
mitk::Image::Pointer resultImage = this->GetOutput();
resultImage->Initialize(m_Reslicer->GetOutput());
resultImage->Initialize(inputImage->GetPixelType(), 2, dimensions);
resultImage->SetSpacing(spacingVector);
resultImage->SetSlice(m_Reslicer->GetOutput());*/
}
| void mitk::ExtractDirectedPlaneImageFilter::GenerateOutputInformation | ( | void | ) | [protected, virtual] |
Definition at line 381 of file mitkExtractDirectedPlaneImageFilter.cpp.
| virtual const char* mitk::ExtractDirectedPlaneImageFilter::GetClassName | ( | ) | const [virtual] |
| virtual bool mitk::ExtractDirectedPlaneImageFilter::GetInPlaneResampleExtentByGeometry | ( | ) | [virtual] |
| virtual vtkImageReslice* mitk::ExtractDirectedPlaneImageFilter::GetReslicer | ( | ) | [virtual] |
| virtual unsigned int mitk::ExtractDirectedPlaneImageFilter::GetTargetTimestep | ( | ) | [virtual] |
| bool mitk::ExtractDirectedPlaneImageFilter::LineIntersectZero | ( | vtkPoints * | points, |
| int | p1, | ||
| int | p2, | ||
| vtkFloatingPointType * | bounds | ||
| ) | [protected] |
Definition at line 481 of file mitkExtractDirectedPlaneImageFilter.cpp.
{
vtkFloatingPointType point1[3];
vtkFloatingPointType point2[3];
points->GetPoint( p1, point1 );
points->GetPoint( p2, point2 );
if ( (point1[2] * point2[2] <= 0.0) && (point1[2] != point2[2]) )
{
double x, y;
x = ( point1[0] * point2[2] - point1[2] * point2[0] ) / ( point2[2] - point1[2] );
y = ( point1[1] * point2[2] - point1[2] * point2[1] ) / ( point2[2] - point1[2] );
if ( x < bounds[0] ) { bounds[0] = x; }
if ( x > bounds[1] ) { bounds[1] = x; }
if ( y < bounds[2] ) { bounds[2] = y; }
if ( y > bounds[3] ) { bounds[3] = y; }
bounds[4] = bounds[5] = 0.0;
return true;
}
return false;
}
| static Pointer mitk::ExtractDirectedPlaneImageFilter::New | ( | ) | [static] |
Method for creation through the object factory.
Reimplemented from mitk::ImageToImageFilter.
Referenced by ExtractDirectedPlaneImageFilter().
| virtual void mitk::ExtractDirectedPlaneImageFilter::SetInPlaneResampleExtentByGeometry | ( | bool | _arg ) | [virtual] |
| virtual void mitk::ExtractDirectedPlaneImageFilter::SetTargetTimestep | ( | unsigned int | _arg ) | [virtual] |
| virtual void mitk::ExtractDirectedPlaneImageFilter::SetWorldGeometry | ( | Geometry2D * | _arg ) | [virtual] |
Definition at line 91 of file mitkExtractDirectedPlaneImageFilter.h.
Referenced by ExtractDirectedPlaneImageFilter().
vtkImageReslice* mitk::ExtractDirectedPlaneImageFilter::m_Reslicer [protected] |
Definition at line 88 of file mitkExtractDirectedPlaneImageFilter.h.
Referenced by ExtractDirectedPlaneImageFilter().
unsigned int mitk::ExtractDirectedPlaneImageFilter::m_TargetTimestep [protected] |
Definition at line 90 of file mitkExtractDirectedPlaneImageFilter.h.
Referenced by ExtractDirectedPlaneImageFilter().
const Geometry2D* mitk::ExtractDirectedPlaneImageFilter::m_WorldGeometry [protected] |
Definition at line 87 of file mitkExtractDirectedPlaneImageFilter.h.
1.7.2