diff --git a/Core/Code/Algorithms/mitkExtractSliceFilter.cpp b/Core/Code/Algorithms/mitkExtractSliceFilter.cpp
index aeb92fcffb..8993f58780 100644
--- a/Core/Code/Algorithms/mitkExtractSliceFilter.cpp
+++ b/Core/Code/Algorithms/mitkExtractSliceFilter.cpp
@@ -1,486 +1,486 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkExtractSliceFilter.h"
#include <vtkImageData.h>
#include <vtkSmartPointer.h>
#include <vtkLinearTransform.h>
#include <vtkImageChangeInformation.h>
#include <mitkAbstractTransformGeometry.h>
#include <vtkGeneralTransform.h>
#include <mitkPlaneClipping.h>
mitk::ExtractSliceFilter::ExtractSliceFilter(vtkImageReslice* reslicer ){
if(reslicer == NULL){
m_Reslicer = vtkSmartPointer<vtkImageReslice>::New();
}
else
{
m_Reslicer = reslicer;
}
m_TimeStep = 0;
m_Reslicer->ReleaseDataFlagOn();
m_InterpolationMode = ExtractSliceFilter::RESLICE_NEAREST;
m_ResliceTransform = NULL;
m_InPlaneResampleExtentByGeometry = false;
m_OutPutSpacing = new mitk::ScalarType[2];
m_OutputDimension = 2;
m_ZSpacing = 1.0;
m_ZMin = 0;
m_ZMax = 0;
m_VtkOutputRequested = false;
}
mitk::ExtractSliceFilter::~ExtractSliceFilter(){
m_ResliceTransform = NULL;
m_WorldGeometry = NULL;
delete [] m_OutPutSpacing;
}
void mitk::ExtractSliceFilter::GenerateOutputInformation(){
Superclass::GenerateOutputInformation();
//TODO try figure out how to set the specs of the slice before it is actually extracted
/*Image::Pointer output = this->GetOutput();
Image::ConstPointer input = this->GetInput();
if (input.IsNull()) return;
unsigned int dimensions[2];
dimensions[0] = m_WorldGeometry->GetExtent(0);
dimensions[1] = m_WorldGeometry->GetExtent(1);
output->Initialize(input->GetPixelType(), 2, dimensions, 1);*/
}
void mitk::ExtractSliceFilter::GenerateInputRequestedRegion(){
//As we want all pixel information fo the image in our plane, the requested region
//is set to the largest possible region in the image.
//This is needed because an oblique plane has a larger extent then the image
//and the in pipeline it is checked via PropagateResquestedRegion(). But the
//extent of the slice is actually fitting because it is oblique within the image.
ImageToImageFilter::InputImagePointer input = const_cast< ImageToImageFilter::InputImageType* > ( this->GetInput() );
input->SetRequestedRegionToLargestPossibleRegion();
}
mitk::ScalarType* mitk::ExtractSliceFilter::GetOutputSpacing(){
return m_OutPutSpacing;
}
void mitk::ExtractSliceFilter::GenerateData(){
mitk::Image *input = const_cast< mitk::Image * >( this->GetInput() );
if (!input)
{
MITK_ERROR << "mitk::ExtractSliceFilter: No input image available. Please set the input!" << std::endl;
itkExceptionMacro("mitk::ExtractSliceFilter: No input image available. Please set the input!");
return;
}
if(!m_WorldGeometry)
{
MITK_ERROR << "mitk::ExtractSliceFilter: No Geometry for reslicing available." << std::endl;
itkExceptionMacro("mitk::ExtractSliceFilter: No Geometry for reslicing available.");
return;
}
const TimeGeometry* inputTimeGeometry = this->GetInput()->GetTimeGeometry();
if ( ( inputTimeGeometry == NULL )
- || ( inputTimeGeometry->GetNumberOfTimeSteps() <= 0 ) )
+ || ( inputTimeGeometry->CountTimeSteps() <= 0 ) )
{
itkWarningMacro(<<"Error reading input image TimeGeometry.");
return;
}
// is it a valid timeStep?
if ( inputTimeGeometry->IsValidTimeStep( m_TimeStep ) == false )
{
itkWarningMacro(<<"This is not a valid timestep: "<< m_TimeStep );
return;
}
// check if there is something to display.
if ( ! input->IsVolumeSet( m_TimeStep ) )
{
itkWarningMacro(<<"No volume data existent at given timestep "<< m_TimeStep );
return;
}
/*================#BEGIN setup vtkImageRslice properties================*/
Point3D origin;
Vector3D right, bottom, normal;
double widthInMM, heightInMM;
Vector2D extent;
const PlaneGeometry* planeGeometry = dynamic_cast<const PlaneGeometry*>(m_WorldGeometry);
if ( planeGeometry != NULL )
{
//if the worldGeomatry is a PlaneGeometry everthing is straight forward
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.
Vector3D rightInIndex, bottomInIndex;
inputTimeGeometry->GetGeometryForTimeStep( m_TimeStep )->WorldToIndex( right, rightInIndex );
inputTimeGeometry->GetGeometryForTimeStep( m_TimeStep )->WorldToIndex( 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 );
m_OutPutSpacing[0] = widthInMM / extent[0];
m_OutPutSpacing[1] = heightInMM / extent[1];
right.Normalize();
bottom.Normalize();
normal.Normalize();
/*
* Transform the origin to center based coordinates.
* Note:
* This is needed besause vtk's origin is center based too (!!!) ( see 'The VTK book' page 88 )
* and the worldGeometry surrouding the image is no imageGeometry. So the worldGeometry
* has its origin at the corner of the voxel and needs to be transformed.
*/
origin += right * ( m_OutPutSpacing[0] * 0.5 );
origin += bottom * ( m_OutPutSpacing[1] * 0.5 );
//set the tranform for reslicing.
// Use inverse transform of the input geometry for reslicing the 3D image.
// This is needed if the image volume already transformed
if(m_ResliceTransform.IsNotNull())
m_Reslicer->SetResliceTransform(m_ResliceTransform->GetVtkTransform()->GetLinearInverse());
// Set background level to TRANSLUCENT (see Geometry2DDataVtkMapper3D),
// else the background of the image turns out gray
m_Reslicer->SetBackgroundLevel( -32768 );
}
else{
//Code for curved planes, mostly taken 1:1 from imageVtkMapper2D and not tested yet.
// Do we have an AbstractTransformGeometry?
// This is the case for AbstractTransformGeometry's (e.g. a ThinPlateSplineCurvedGeometry )
const mitk::AbstractTransformGeometry* abstractGeometry =
dynamic_cast< const AbstractTransformGeometry * >(m_WorldGeometry);
if(abstractGeometry != NULL)
{
m_ResliceTransform = abstractGeometry;
extent[0] = abstractGeometry->GetParametricExtent(0);
extent[1] = abstractGeometry->GetParametricExtent(1);
widthInMM = abstractGeometry->GetParametricExtentInMM(0);
heightInMM = abstractGeometry->GetParametricExtentInMM(1);
m_OutPutSpacing[0] = widthInMM / extent[0];
m_OutPutSpacing[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
vtkSmartPointer<vtkGeneralTransform> composedResliceTransform = vtkSmartPointer<vtkGeneralTransform>::New();
composedResliceTransform->Identity();
composedResliceTransform->Concatenate(
inputTimeGeometry->GetGeometryForTimeStep( m_TimeStep )->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 );
}
else
{
itkExceptionMacro("mitk::ExtractSliceFilter: No fitting geometry for reslice axis!");
return;
}
}
if(m_ResliceTransform.IsNotNull()){
//if the resliceTransform is set the reslice axis are recalculated.
//Thus the geometry information is not fitting. Therefor a unitSpacingFilter
//is used to set up a global spacing of 1 and compensate the transform.
vtkSmartPointer<vtkImageChangeInformation> unitSpacingImageFilter = vtkSmartPointer<vtkImageChangeInformation>::New() ;
unitSpacingImageFilter->ReleaseDataFlagOn();
unitSpacingImageFilter->SetOutputSpacing( 1.0, 1.0, 1.0 );
unitSpacingImageFilter->SetInput( input->GetVtkImageData(m_TimeStep) );
m_Reslicer->SetInput(unitSpacingImageFilter->GetOutput() );
}
else
{
//if no tranform is set the image can be used directly
m_Reslicer->SetInput(input->GetVtkImageData(m_TimeStep));
}
/*setup the plane where vktImageReslice extracts the slice*/
//ResliceAxesOrigin is the ancor point of the plane
double originInVtk[3];
itk2vtk(origin, originInVtk);
m_Reslicer->SetResliceAxesOrigin(originInVtk);
//the cosines define the plane: x and y are the direction vectors, n is the planes normal
//this specifies a matrix 3x3
// x1 y1 n1
// x2 y2 n2
// x3 y3 n3
double cosines[9];
vnl2vtk(right.GetVnlVector(), cosines);//x
vnl2vtk(bottom.GetVnlVector(), cosines + 3);//y
vnl2vtk(normal.GetVnlVector(), cosines + 6);//n
m_Reslicer->SetResliceAxesDirectionCosines(cosines);
//we only have one slice, not a volume
m_Reslicer->SetOutputDimensionality(m_OutputDimension);
//set the interpolation mode for slicing
switch(this->m_InterpolationMode){
case RESLICE_NEAREST:
m_Reslicer->SetInterpolationModeToNearestNeighbor();
break;
case RESLICE_LINEAR:
m_Reslicer->SetInterpolationModeToLinear();
break;
case RESLICE_CUBIC:
m_Reslicer->SetInterpolationModeToCubic();
break;
default:
//the default interpolation used by mitk
m_Reslicer->SetInterpolationModeToNearestNeighbor();
}
/*========== BEGIN setup extent of the slice ==========*/
int xMin, xMax, yMin, yMax;
xMin = yMin = 0;
xMax = static_cast< int >( extent[0]);
yMax = static_cast< int >( extent[1]);
vtkFloatingPointType sliceBounds[6];
if (m_WorldGeometry->GetReferenceGeometry())
{
for ( int i = 0; i < 6; ++i )
{
sliceBounds[i] = 0.0;
}
if (this->GetClippedPlaneBounds( m_WorldGeometry->GetReferenceGeometry(), planeGeometry, sliceBounds ))
{
// Calculate output extent (integer values)
xMin = static_cast< int >( sliceBounds[0] / m_OutPutSpacing[0] + 0.5 );
xMax = static_cast< int >( sliceBounds[1] / m_OutPutSpacing[0] + 0.5 );
yMin = static_cast< int >( sliceBounds[2] / m_OutPutSpacing[1] + 0.5 );
yMax = static_cast< int >( sliceBounds[3] / m_OutPutSpacing[1] + 0.5 );
} // ELSE we use the default values
}
// Set the output extents! First included pixel index and last included pixel index
// xMax and yMax are one after the last pixel. so they have to be decremented by 1.
// In case we have a 2D image, xMax or yMax might be 0. in this case, do not decrement, but take 0.
m_Reslicer->SetOutputExtent(xMin, std::max(0, xMax-1), yMin, std::max(0, yMax-1), m_ZMin, m_ZMax );
/*========== END setup extent of the slice ==========*/
m_Reslicer->SetOutputOrigin( 0.0, 0.0, 0.0 );
m_Reslicer->SetOutputSpacing( m_OutPutSpacing[0], m_OutPutSpacing[1], m_ZSpacing );
//TODO check the following lines, they are responsible wether vtk error outputs appear or not
m_Reslicer->UpdateWholeExtent(); //this produces a bad allocation error for 2D images
//m_Reslicer->GetOutput()->UpdateInformation();
//m_Reslicer->GetOutput()->SetUpdateExtentToWholeExtent();
//start the pipeline
m_Reslicer->Update();
/*================ #END setup vtkImageRslice properties================*/
if(m_VtkOutputRequested){
return;
//no converting to mitk
//no mitk geometry will be set, as the output is vtkImageData only!!!
}
else
{
/*================ #BEGIN Get the slice from vtkImageReslice and convert it to mit::Image================*/
vtkImageData* reslicedImage;
reslicedImage = m_Reslicer->GetOutput();
if(!reslicedImage)
{
itkWarningMacro(<<"Reslicer returned empty image");
return;
}
mitk::Image::Pointer resultImage = this->GetOutput();
//initialize resultimage with the specs of the vtkImageData object returned from vtkImageReslice
if (reslicedImage->GetDataDimension() == 1)
{
// If original image was 2D, the slice might have an y extent of 0.
// Still i want to ensure here that Image is 2D
resultImage->Initialize(reslicedImage,1,-1,-1,1);
}
else
{
resultImage->Initialize(reslicedImage);
}
//transfer the voxel data
resultImage->SetVolume(reslicedImage->GetScalarPointer());
//set the geometry from current worldgeometry for the reusultimage
//this is needed that the image has the correct mitk geometry
//the originalGeometry is the Geometry of the result slice
// mitk::AffineGeometryFrame3D::Pointer originalGeometryAGF = m_WorldGeometry->Clone();
// Geometry2D::Pointer originalGeometry = dynamic_cast<Geometry2D*>( originalGeometryAGF.GetPointer() );
Geometry2D::Pointer originalGeometry = m_WorldGeometry->Clone();
originalGeometry->GetIndexToWorldTransform()->SetMatrix(m_WorldGeometry->GetIndexToWorldTransform()->GetMatrix());
//the origin of the worldGeometry is transformed to center based coordinates to be an imageGeometry
Point3D sliceOrigin = originalGeometry->GetOrigin();
sliceOrigin += right * ( m_OutPutSpacing[0] * 0.5 );
sliceOrigin += bottom * ( m_OutPutSpacing[1] * 0.5 );
//a worldGeometry is no imageGeometry, thus it is manually set to true
originalGeometry->ImageGeometryOn();
/*At this point we have to adjust the geometry because the origin isn't correct.
The wrong origin is related to the rotation of the current world geometry plane.
This causes errors on transfering world to index coordinates. We just shift the
origin in each direction about the amount of the expanding (needed while rotating
the plane).
*/
Vector3D axis0 = originalGeometry->GetAxisVector(0);
Vector3D axis1 = originalGeometry->GetAxisVector(1);
axis0.Normalize();
axis1.Normalize();
//adapt the origin. Note that for orthogonal planes the minima are '0' and thus the origin stays the same.
sliceOrigin += (axis0 * (xMin * m_OutPutSpacing[0])) + (axis1 * (yMin * m_OutPutSpacing[1]));
originalGeometry->SetOrigin(sliceOrigin);
originalGeometry->Modified();
resultImage->SetGeometry( originalGeometry );
/*the bounds as well as the extent of the worldGeometry are not adapted correctly during crosshair rotation.
This is only a quick fix and has to be evaluated.
The new bounds are set via the max values of the calcuted slice extent. It will look like [ 0, x, 0, y, 0, 1].
*/
mitk::BoundingBox::BoundsArrayType boundsCopy;
boundsCopy[0] = boundsCopy[2] = boundsCopy[4] = 0;
boundsCopy[5] = 1;
boundsCopy[1] = xMax - xMin;
boundsCopy[3] = yMax - yMin;
resultImage->GetGeometry()->SetBounds(boundsCopy);
/*================ #END Get the slice from vtkImageReslice and convert it to mitk Image================*/
}
}
bool mitk::ExtractSliceFilter::GetClippedPlaneBounds(vtkFloatingPointType bounds[6]){
if(!m_WorldGeometry || !this->GetInput())
return false;
return this->GetClippedPlaneBounds(m_WorldGeometry->GetReferenceGeometry(), dynamic_cast< const PlaneGeometry * >( m_WorldGeometry ), bounds);
}
bool mitk::ExtractSliceFilter::GetClippedPlaneBounds( const Geometry3D *boundingGeometry,
const PlaneGeometry *planeGeometry, vtkFloatingPointType *bounds )
{
bool b = mitk::PlaneClipping::CalculateClippedPlaneBounds(boundingGeometry, planeGeometry, bounds);
return b;
}
diff --git a/Core/Code/Controllers/mitkRenderingManager.cpp b/Core/Code/Controllers/mitkRenderingManager.cpp
index 9b3d20cd88..e4296c3d76 100644
--- a/Core/Code/Controllers/mitkRenderingManager.cpp
+++ b/Core/Code/Controllers/mitkRenderingManager.cpp
@@ -1,974 +1,974 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkRenderingManager.h"
#include "mitkRenderingManagerFactory.h"
#include "mitkBaseRenderer.h"
#include "mitkGlobalInteraction.h"
#include <vtkRenderWindow.h>
#include <itkCommand.h>
#include "mitkVector.h"
#include <itkAffineGeometryFrame.h>
#include <itkScalableAffineTransform.h>
#include <mitkVtkPropRenderer.h>
#include <algorithm>
namespace mitk
{
RenderingManager::Pointer RenderingManager::s_Instance = 0;
RenderingManagerFactory *RenderingManager::s_RenderingManagerFactory = 0;
RenderingManager
::RenderingManager()
: m_UpdatePending( false ),
m_MaxLOD( 1 ),
m_LODIncreaseBlocked( false ),
m_LODAbortMechanismEnabled( false ),
m_ClippingPlaneEnabled( false ),
m_TimeNavigationController( SliceNavigationController::New("dummy") ),
m_DataStorage( NULL ),
m_ConstrainedPaddingZooming ( true )
{
m_ShadingEnabled.assign( 3, false );
m_ShadingValues.assign( 4, 0.0 );
m_GlobalInteraction = mitk::GlobalInteraction::GetInstance();
InitializePropertyList();
}
RenderingManager
::~RenderingManager()
{
// Decrease reference counts of all registered vtkRenderWindows for
// proper destruction
RenderWindowVector::iterator it;
for ( it = m_AllRenderWindows.begin(); it != m_AllRenderWindows.end(); ++it )
{
(*it)->UnRegister( NULL );
RenderWindowCallbacksList::iterator callbacks_it = this->m_RenderWindowCallbacksList.find(*it);
if (callbacks_it != this->m_RenderWindowCallbacksList.end())
{
(*it)->RemoveObserver(callbacks_it->second.commands[0u]);
(*it)->RemoveObserver(callbacks_it->second.commands[1u]);
(*it)->RemoveObserver(callbacks_it->second.commands[2u]);
}
}
}
void
RenderingManager
::SetFactory( RenderingManagerFactory *factory )
{
s_RenderingManagerFactory = factory;
}
const RenderingManagerFactory *
RenderingManager
::GetFactory()
{
return s_RenderingManagerFactory;
}
bool
RenderingManager
::HasFactory()
{
if ( RenderingManager::s_RenderingManagerFactory )
{
return true;
}
else
{
return false;
}
}
RenderingManager::Pointer
RenderingManager
::New()
{
const RenderingManagerFactory* factory = GetFactory();
if(factory == NULL)
return NULL;
return factory->CreateRenderingManager();
}
RenderingManager *
RenderingManager
::GetInstance()
{
if ( !RenderingManager::s_Instance )
{
if ( s_RenderingManagerFactory )
{
s_Instance = s_RenderingManagerFactory->CreateRenderingManager();
}
}
return s_Instance;
}
bool
RenderingManager
::IsInstantiated()
{
if ( RenderingManager::s_Instance )
return true;
else
return false;
}
void
RenderingManager
::AddRenderWindow( vtkRenderWindow *renderWindow )
{
if ( renderWindow
&& (m_RenderWindowList.find( renderWindow ) == m_RenderWindowList.end()) )
{
m_RenderWindowList[renderWindow] = RENDERING_INACTIVE;
m_AllRenderWindows.push_back( renderWindow );
if ( m_DataStorage.IsNotNull() )
mitk::BaseRenderer::GetInstance( renderWindow )->SetDataStorage( m_DataStorage.GetPointer() );
// Register vtkRenderWindow instance
renderWindow->Register( NULL );
// Add callbacks for rendering abort mechanism
//BaseRenderer *renderer = BaseRenderer::GetInstance( renderWindow );
vtkCallbackCommand *startCallbackCommand = vtkCallbackCommand::New();
startCallbackCommand->SetCallback(
RenderingManager::RenderingStartCallback );
renderWindow->AddObserver( vtkCommand::StartEvent, startCallbackCommand );
vtkCallbackCommand *progressCallbackCommand = vtkCallbackCommand::New();
progressCallbackCommand->SetCallback(
RenderingManager::RenderingProgressCallback );
renderWindow->AddObserver( vtkCommand::AbortCheckEvent, progressCallbackCommand );
vtkCallbackCommand *endCallbackCommand = vtkCallbackCommand::New();
endCallbackCommand->SetCallback(
RenderingManager::RenderingEndCallback );
renderWindow->AddObserver( vtkCommand::EndEvent, endCallbackCommand );
RenderWindowCallbacks callbacks;
callbacks.commands[0u] = startCallbackCommand;
callbacks.commands[1u] = progressCallbackCommand;
callbacks.commands[2u] = endCallbackCommand;
this->m_RenderWindowCallbacksList[renderWindow] = callbacks;
//Delete vtk variables correctly
startCallbackCommand->Delete();
progressCallbackCommand->Delete();
endCallbackCommand->Delete();
}
}
void
RenderingManager
::RemoveRenderWindow( vtkRenderWindow *renderWindow )
{
if (m_RenderWindowList.erase( renderWindow ))
{
RenderWindowCallbacksList::iterator callbacks_it = this->m_RenderWindowCallbacksList.find(renderWindow);
if(callbacks_it != this->m_RenderWindowCallbacksList.end())
{
renderWindow->RemoveObserver(callbacks_it->second.commands[0u]);
renderWindow->RemoveObserver(callbacks_it->second.commands[1u]);
renderWindow->RemoveObserver(callbacks_it->second.commands[2u]);
this->m_RenderWindowCallbacksList.erase(callbacks_it);
}
RenderWindowVector::iterator rw_it = std::find( m_AllRenderWindows.begin(), m_AllRenderWindows.end(), renderWindow );
if(rw_it != m_AllRenderWindows.end())
{
// Decrease reference count for proper destruction
(*rw_it)->UnRegister(NULL);
m_AllRenderWindows.erase( rw_it );
}
}
}
const RenderingManager::RenderWindowVector&
RenderingManager
::GetAllRegisteredRenderWindows()
{
return m_AllRenderWindows;
}
void
RenderingManager
::RequestUpdate( vtkRenderWindow *renderWindow )
{
// If the renderWindow is not valid, we do not want to inadvertantly create
// an entry in the m_RenderWindowList map. It is possible if the user is
// regularly calling AddRenderer and RemoveRenderer for a rendering update
// to come into this method with a renderWindow pointer that is valid in the
// sense that the window does exist within the application, but that
// renderWindow has been temporarily removed from this RenderingManager for
// performance reasons.
if (m_RenderWindowList.find( renderWindow ) == m_RenderWindowList.end())
{
return;
}
m_RenderWindowList[renderWindow] = RENDERING_REQUESTED;
if ( !m_UpdatePending )
{
m_UpdatePending = true;
this->GenerateRenderingRequestEvent();
}
}
void
RenderingManager
::ForceImmediateUpdate( vtkRenderWindow *renderWindow )
{
// If the renderWindow is not valid, we do not want to inadvertantly create
// an entry in the m_RenderWindowList map. It is possible if the user is
// regularly calling AddRenderer and RemoveRenderer for a rendering update
// to come into this method with a renderWindow pointer that is valid in the
// sense that the window does exist within the application, but that
// renderWindow has been temporarily removed from this RenderingManager for
// performance reasons.
if (m_RenderWindowList.find( renderWindow ) == m_RenderWindowList.end())
{
return;
}
// Erase potentially pending requests for this window
m_RenderWindowList[renderWindow] = RENDERING_INACTIVE;
m_UpdatePending = false;
// Immediately repaint this window (implementation platform specific)
// If the size is 0 it crahses
int *size = renderWindow->GetSize();
if ( 0 != size[0] && 0 != size[1] )
{
//prepare the camera etc. before rendering
//Note: this is a very important step which should be called before the VTK render!
//If you modify the camera anywhere else or after the render call, the scene cannot be seen.
mitk::VtkPropRenderer *vPR =
dynamic_cast<mitk::VtkPropRenderer*>(mitk::BaseRenderer::GetInstance( renderWindow ));
if(vPR)
vPR->PrepareRender();
// Execute rendering
renderWindow->Render();
}
}
void
RenderingManager
::RequestUpdateAll( RequestType type )
{
RenderWindowList::iterator it;
for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
{
int id = BaseRenderer::GetInstance(it->first)->GetMapperID();
if ( (type == REQUEST_UPDATE_ALL)
|| ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1))
|| ((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2)) )
{
this->RequestUpdate( it->first );
}
}
}
void
RenderingManager
::ForceImmediateUpdateAll( RequestType type )
{
RenderWindowList::iterator it;
for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
{
int id = BaseRenderer::GetInstance(it->first)->GetMapperID();
if ( (type == REQUEST_UPDATE_ALL)
|| ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1))
|| ((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2)) )
{
// Immediately repaint this window (implementation platform specific)
// If the size is 0, it crashes
this->ForceImmediateUpdate(it->first);
}
}
}
//TODO_GOETZ
// Remove old function, so only this one is working.
bool
RenderingManager
::InitializeViews( const Geometry3D * dataGeometry, RequestType type, bool preserveRoughOrientationInWorldSpace )
{
ProportionalTimeGeometry::Pointer propTimeGeometry = ProportionalTimeGeometry::New();
propTimeGeometry->Initialize(dynamic_cast<Geometry3D *>(dataGeometry->Clone().GetPointer()), 1);
return InitializeViews(propTimeGeometry,type, preserveRoughOrientationInWorldSpace);
}
bool
RenderingManager
::InitializeViews( const TimeGeometry * dataGeometry, RequestType type, bool preserveRoughOrientationInWorldSpace )
{
MITK_DEBUG << "initializing views";
bool boundingBoxInitialized = false;
TimeGeometry::ConstPointer timeGeometry = dataGeometry;
TimeGeometry::Pointer modifiedGeometry = NULL;
if (dataGeometry!=NULL)
{
modifiedGeometry = dataGeometry->Clone();
}
// //TODO_GOETZ previously this code section has been disabled by
// a later asignment to geometry (e.g. timeGeometry)
// This has been fixed during Geometry-1-Plattform Project
// Propably this code is not working anymore, test!!
/*
if (dataGeometry && preserveRoughOrientationInWorldSpace)
{
// clone the input geometry
assert(modifiedGeometry.IsNotNull());
// construct an affine transform from it
Geometry3D::TransformType::Pointer transform = Geometry3D::TransformType::New();
assert( modifiedGeometry->GetGeometryForTimeStep(0)->GetIndexToWorldTransform() );
transform->SetMatrix( modifiedGeometry->GetGeometryForTimeStep(0)->GetIndexToWorldTransform()->GetMatrix() );
transform->SetOffset( modifiedGeometry->GetGeometryForTimeStep(0)->GetIndexToWorldTransform()->GetOffset() );
// get transform matrix
Geometry3D::TransformType::MatrixType::InternalMatrixType& oldMatrix =
const_cast< Geometry3D::TransformType::MatrixType::InternalMatrixType& > ( transform->GetMatrix().GetVnlMatrix() );
Geometry3D::TransformType::MatrixType::InternalMatrixType newMatrix(oldMatrix);
// get offset and bound
Vector3D offset = modifiedGeometry->GetIndexToWorldTransform()->GetOffset();
Geometry3D::BoundsArrayType oldBounds = modifiedGeometry->GetBounds();
Geometry3D::BoundsArrayType newBounds = modifiedGeometry->GetBounds();
// get rid of rotation other than pi/2 degree
for ( unsigned int i = 0; i < 3; ++i )
{
// i-th column of the direction matrix
Vector3D currentVector;
currentVector[0] = oldMatrix(0,i);
currentVector[1] = oldMatrix(1,i);
currentVector[2] = oldMatrix(2,i);
// matchingRow will store the row that holds the biggest
// value in the column
unsigned int matchingRow = 0;
// maximum value in the column
float max = std::numeric_limits<float>::min();
// sign of the maximum value (-1 or 1)
int sign = 1;
// iterate through the column vector
for (unsigned int dim = 0; dim < 3; ++dim)
{
if ( fabs(currentVector[dim]) > max )
{
matchingRow = dim;
max = fabs(currentVector[dim]);
if(currentVector[dim]<0)
sign = -1;
else
sign = 1;
}
}
// in case we found a negative maximum,
// we negate the column and adjust the offset
// (in order to run through the dimension in the opposite direction)
if(sign == -1)
{
currentVector *= sign;
offset += modifiedGeometry->GetAxisVector(i);
}
// matchingRow is now used as column index to place currentVector
// correctly in the new matrix
vnl_vector<ScalarType> newMatrixColumn(3);
newMatrixColumn[0] = currentVector[0];
newMatrixColumn[1] = currentVector[1];
newMatrixColumn[2] = currentVector[2];
newMatrix.set_column( matchingRow, newMatrixColumn );
// if a column is moved, we also have to adjust the bounding
// box accordingly, this is done here
newBounds[2*matchingRow ] = oldBounds[2*i ];
newBounds[2*matchingRow+1] = oldBounds[2*i+1];
}
// set the newly calculated bounds array
modifiedGeometry->SetBounds(newBounds);
// set new offset and direction matrix
Geometry3D::TransformType::MatrixType newMatrixITK( newMatrix );
transform->SetMatrix( newMatrixITK );
transform->SetOffset( offset );
modifiedGeometry->SetIndexToWorldTransform( transform );
geometry = modifiedGeometry;
}*/
int warningLevel = vtkObject::GetGlobalWarningDisplay();
vtkObject::GlobalWarningDisplayOff();
if ( (timeGeometry.IsNotNull() ) && (const_cast< mitk::BoundingBox * >(
timeGeometry->GetBoundingBoxInWorld())->GetDiagonalLength2() > mitk::eps) )
{
boundingBoxInitialized = true;
}
if (timeGeometry.IsNotNull() )
{// make sure bounding box has an extent bigger than zero in any direction
// clone the input geometry
//Old Geometry3D::Pointer modifiedGeometry = dynamic_cast<Geometry3D*>( dataGeometry->Clone().GetPointer() );
assert(modifiedGeometry.IsNotNull());
- for (TimeStepType step = 0; step < modifiedGeometry->GetNumberOfTimeSteps(); ++step)
+ for (TimeStepType step = 0; step < modifiedGeometry->CountTimeSteps(); ++step)
{
Geometry3D::BoundsArrayType newBounds = modifiedGeometry->GetGeometryForTimeStep(step)->GetBounds();
for( unsigned int dimension = 0; ( 2 * dimension ) < newBounds.Size() ; dimension++ )
{
//check for equality but for an epsilon
if( Equal( newBounds[ 2 * dimension ], newBounds[ 2 * dimension + 1 ] ) )
{
newBounds[ 2 * dimension + 1 ] += 1;
}
}
modifiedGeometry->GetGeometryForTimeStep(step)->SetBounds(newBounds);
}
}
timeGeometry = modifiedGeometry;
RenderWindowList::iterator it;
for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
{
mitk::BaseRenderer *baseRenderer =
mitk::BaseRenderer::GetInstance( it->first );
baseRenderer->GetDisplayGeometry()->SetConstrainZoomingAndPanning(m_ConstrainedPaddingZooming);
int id = baseRenderer->GetMapperID();
if ( ((type == REQUEST_UPDATE_ALL)
|| ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1))
|| ((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2)))
)
{
this->InternalViewInitialization( baseRenderer, timeGeometry,
boundingBoxInitialized, id );
}
}
if ( boundingBoxInitialized )
{
m_TimeNavigationController->SetInputWorldTimeGeometry( timeGeometry );
}
m_TimeNavigationController->Update();
this->RequestUpdateAll( type );
vtkObject::SetGlobalWarningDisplay( warningLevel );
// Inform listeners that views have been initialized
this->InvokeEvent( mitk::RenderingManagerViewsInitializedEvent() );
return boundingBoxInitialized;
}
bool
RenderingManager
::InitializeViews( RequestType type )
{
RenderWindowList::iterator it;
for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
{
mitk::BaseRenderer *baseRenderer =
mitk::BaseRenderer::GetInstance( it->first );
int id = baseRenderer->GetMapperID();
if ( (type == REQUEST_UPDATE_ALL)
|| ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1))
|| ((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2)) )
{
mitk::SliceNavigationController *nc =
baseRenderer->GetSliceNavigationController();
// Re-initialize view direction
nc->SetViewDirectionToDefault();
// Update the SNC
nc->Update();
}
}
this->RequestUpdateAll( type );
return true;
}
bool RenderingManager::InitializeView( vtkRenderWindow * renderWindow, const Geometry3D * geometry, bool initializeGlobalTimeSNC )
{
ProportionalTimeGeometry::Pointer propTimeGeometry = ProportionalTimeGeometry::New();
propTimeGeometry->Initialize(dynamic_cast<Geometry3D *>(geometry->Clone().GetPointer()), 1);
return InitializeView(renderWindow, propTimeGeometry, initializeGlobalTimeSNC );
}
bool RenderingManager::InitializeView( vtkRenderWindow * renderWindow, const TimeGeometry * geometry, bool initializeGlobalTimeSNC )
{
bool boundingBoxInitialized = false;
int warningLevel = vtkObject::GetGlobalWarningDisplay();
vtkObject::GlobalWarningDisplayOff();
if ( (geometry != NULL ) && (const_cast< mitk::BoundingBox * >(
geometry->GetBoundingBoxInWorld())->GetDiagonalLength2() > mitk::eps) )
{
boundingBoxInitialized = true;
}
mitk::BaseRenderer *baseRenderer =
mitk::BaseRenderer::GetInstance( renderWindow );
int id = baseRenderer->GetMapperID();
this->InternalViewInitialization( baseRenderer, geometry,
boundingBoxInitialized, id );
if ( boundingBoxInitialized && initializeGlobalTimeSNC )
{
m_TimeNavigationController->SetInputWorldTimeGeometry( geometry );
}
m_TimeNavigationController->Update();
this->RequestUpdate( renderWindow );
vtkObject::SetGlobalWarningDisplay( warningLevel );
return boundingBoxInitialized;
}
bool RenderingManager::InitializeView( vtkRenderWindow * renderWindow )
{
mitk::BaseRenderer *baseRenderer =
mitk::BaseRenderer::GetInstance( renderWindow );
mitk::SliceNavigationController *nc =
baseRenderer->GetSliceNavigationController();
// Re-initialize view direction
nc->SetViewDirectionToDefault();
// Update the SNC
nc->Update();
this->RequestUpdate( renderWindow );
return true;
}
void RenderingManager::InternalViewInitialization(mitk::BaseRenderer *baseRenderer, const mitk::TimeGeometry *geometry, bool boundingBoxInitialized, int mapperID )
{
mitk::SliceNavigationController *nc = baseRenderer->GetSliceNavigationController();
// Re-initialize view direction
nc->SetViewDirectionToDefault();
if ( boundingBoxInitialized )
{
// Set geometry for NC
nc->SetInputWorldTimeGeometry( geometry );
nc->Update();
if ( mapperID == 1 )
{
// For 2D SNCs, steppers are set so that the cross is centered
// in the image
nc->GetSlice()->SetPos( nc->GetSlice()->GetSteps() / 2 );
}
// Fit the render window DisplayGeometry
baseRenderer->GetDisplayGeometry()->Fit();
baseRenderer->GetCameraController()->SetViewToAnterior();
}
else
{
nc->Update();
}
}
const SliceNavigationController* RenderingManager::GetTimeNavigationController() const
{
return m_TimeNavigationController.GetPointer();
}
SliceNavigationController* RenderingManager::GetTimeNavigationController()
{
return m_TimeNavigationController.GetPointer();
}
void RenderingManager::ExecutePendingRequests()
{
m_UpdatePending = false;
// Satisfy all pending update requests
RenderWindowList::iterator it;
int i = 0;
for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it, ++i )
{
if ( it->second == RENDERING_REQUESTED )
{
this->ForceImmediateUpdate( it->first );
}
}
}
void RenderingManager::RenderingStartCallback( vtkObject *caller, unsigned long , void *, void * )
{
vtkRenderWindow *renderWindow = dynamic_cast< vtkRenderWindow * >( caller );
mitk::RenderingManager* renman = mitk::BaseRenderer::GetInstance(renderWindow)->GetRenderingManager();
RenderWindowList &renderWindowList = renman->m_RenderWindowList;
if ( renderWindow )
{
renderWindowList[renderWindow] = RENDERING_INPROGRESS;
}
renman->m_UpdatePending = false;
}
void
RenderingManager
::RenderingProgressCallback( vtkObject *caller, unsigned long , void *, void * )
{
vtkRenderWindow *renderWindow = dynamic_cast< vtkRenderWindow * >( caller );
mitk::RenderingManager* renman = mitk::BaseRenderer::GetInstance(renderWindow)->GetRenderingManager();
if ( renman->m_LODAbortMechanismEnabled )
{
vtkRenderWindow *renderWindow = dynamic_cast< vtkRenderWindow * >( caller );
if ( renderWindow )
{
BaseRenderer *renderer = BaseRenderer::GetInstance( renderWindow );
if ( renderer && (renderer->GetNumberOfVisibleLODEnabledMappers() > 0) )
{
renman->DoMonitorRendering();
}
}
}
}
void
RenderingManager
::RenderingEndCallback( vtkObject *caller, unsigned long , void *, void * )
{
vtkRenderWindow *renderWindow = dynamic_cast< vtkRenderWindow * >( caller );
mitk::RenderingManager* renman = mitk::BaseRenderer::GetInstance(renderWindow)->GetRenderingManager();
RenderWindowList &renderWindowList = renman->m_RenderWindowList;
RendererIntMap &nextLODMap = renman->m_NextLODMap;
if ( renderWindow )
{
BaseRenderer *renderer = BaseRenderer::GetInstance( renderWindow );
if ( renderer )
{
renderWindowList[renderer->GetRenderWindow()] = RENDERING_INACTIVE;
// Level-of-Detail handling
if ( renderer->GetNumberOfVisibleLODEnabledMappers() > 0 )
{
if(nextLODMap[renderer]==0)
renman->StartOrResetTimer();
else
nextLODMap[renderer] = 0;
}
}
}
}
bool
RenderingManager
::IsRendering() const
{
RenderWindowList::const_iterator it;
for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
{
if ( it->second == RENDERING_INPROGRESS )
{
return true;
}
}
return false;
}
void
RenderingManager
::AbortRendering()
{
RenderWindowList::iterator it;
for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
{
if ( it->second == RENDERING_INPROGRESS )
{
it->first->SetAbortRender( true );
m_RenderingAbortedMap[BaseRenderer::GetInstance(it->first)] = true;
}
}
}
int
RenderingManager
::GetNextLOD( BaseRenderer *renderer )
{
if ( renderer != NULL )
{
return m_NextLODMap[renderer];
}
else
{
return 0;
}
}
void
RenderingManager
::ExecutePendingHighResRenderingRequest()
{
RenderWindowList::iterator it;
for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
{
BaseRenderer *renderer = BaseRenderer::GetInstance( it->first );
if(renderer->GetNumberOfVisibleLODEnabledMappers()>0)
{
if(m_NextLODMap[renderer]==0)
{
m_NextLODMap[renderer]=1;
RequestUpdate( it->first );
}
}
}
}
void
RenderingManager
::SetMaximumLOD( unsigned int max )
{
m_MaxLOD = max;
}
//enable/disable shading
void
RenderingManager
::SetShading(bool state, unsigned int lod)
{
if(lod>m_MaxLOD)
{
itkWarningMacro(<<"LOD out of range requested: " << lod << " maxLOD: " << m_MaxLOD);
return;
}
m_ShadingEnabled[lod] = state;
}
bool
RenderingManager
::GetShading(unsigned int lod)
{
if(lod>m_MaxLOD)
{
itkWarningMacro(<<"LOD out of range requested: " << lod << " maxLOD: " << m_MaxLOD);
return false;
}
return m_ShadingEnabled[lod];
}
//enable/disable the clipping plane
void
RenderingManager
::SetClippingPlaneStatus(bool status)
{
m_ClippingPlaneEnabled = status;
}
bool
RenderingManager
::GetClippingPlaneStatus()
{
return m_ClippingPlaneEnabled;
}
void
RenderingManager
::SetShadingValues(float ambient, float diffuse, float specular, float specpower)
{
m_ShadingValues[0] = ambient;
m_ShadingValues[1] = diffuse;
m_ShadingValues[2] = specular;
m_ShadingValues[3] = specpower;
}
RenderingManager::FloatVector &
RenderingManager
::GetShadingValues()
{
return m_ShadingValues;
}
void RenderingManager::SetDepthPeelingEnabled( bool enabled )
{
RenderWindowList::iterator it;
for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
{
mitk::BaseRenderer *baseRenderer = mitk::BaseRenderer::GetInstance( it->first );
baseRenderer->SetDepthPeelingEnabled(enabled);
}
}
void RenderingManager::SetMaxNumberOfPeels( int maxNumber )
{
RenderWindowList::iterator it;
for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
{
mitk::BaseRenderer *baseRenderer = mitk::BaseRenderer::GetInstance( it->first );
baseRenderer->SetMaxNumberOfPeels(maxNumber);
}
}
void RenderingManager::InitializePropertyList()
{
if (m_PropertyList.IsNull())
{
m_PropertyList = PropertyList::New();
}
this->SetProperty("coupled-zoom", BoolProperty::New(false));
this->SetProperty("coupled-plane-rotation", BoolProperty::New(false));
this->SetProperty("MIP-slice-rendering", BoolProperty::New(false));
}
PropertyList::Pointer RenderingManager::GetPropertyList() const
{
return m_PropertyList;
}
BaseProperty* RenderingManager::GetProperty(const char *propertyKey) const
{
return m_PropertyList->GetProperty(propertyKey);
}
void RenderingManager::SetProperty(const char *propertyKey, BaseProperty* propertyValue)
{
m_PropertyList->SetProperty(propertyKey, propertyValue);
}
void RenderingManager::SetDataStorage( DataStorage* storage )
{
if ( storage != NULL )
{
m_DataStorage = storage;
RenderingManager::RenderWindowVector::iterator iter;
for ( iter = m_AllRenderWindows.begin(); iter<m_AllRenderWindows.end(); iter++ )
{
mitk::BaseRenderer::GetInstance( (*iter) )->SetDataStorage( m_DataStorage.GetPointer() );
}
}
}
mitk::DataStorage* RenderingManager::GetDataStorage()
{
return m_DataStorage;
}
void RenderingManager::SetGlobalInteraction( mitk::GlobalInteraction* globalInteraction )
{
if ( globalInteraction != NULL )
{
m_GlobalInteraction = globalInteraction;
}
}
mitk::GlobalInteraction* RenderingManager::GetGlobalInteraction()
{
return m_GlobalInteraction;
}
// Create and register generic RenderingManagerFactory.
TestingRenderingManagerFactory renderingManagerFactory;
} // namespace
diff --git a/Core/Code/Controllers/mitkSliceNavigationController.cpp b/Core/Code/Controllers/mitkSliceNavigationController.cpp
index 8f7e8d95ca..becba66ed4 100644
--- a/Core/Code/Controllers/mitkSliceNavigationController.cpp
+++ b/Core/Code/Controllers/mitkSliceNavigationController.cpp
@@ -1,830 +1,830 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkSliceNavigationController.h"
#include "mitkBaseRenderer.h"
#include "mitkSlicedGeometry3D.h"
#include "mitkPlaneGeometry.h"
#include "mitkOperation.h"
#include "mitkOperationActor.h"
#include "mitkStateEvent.h"
#include "mitkCrosshairPositionEvent.h"
#include "mitkPositionEvent.h"
#include "mitkProportionalTimeGeometry.h"
#include "mitkInteractionConst.h"
#include "mitkAction.h"
#include "mitkGlobalInteraction.h"
#include "mitkEventMapper.h"
#include "mitkFocusManager.h"
#include "mitkVtkPropRenderer.h"
#include "mitkRenderingManager.h"
#include "mitkInteractionConst.h"
#include "mitkPointOperation.h"
#include "mitkPlaneOperation.h"
#include "mitkUndoController.h"
#include "mitkOperationEvent.h"
#include "mitkNodePredicateDataType.h"
#include "mitkStatusBar.h"
#include "mitkMemoryUtilities.h"
#include <itkCommand.h>
namespace mitk {
SliceNavigationController::SliceNavigationController( const char *type )
: BaseController( type ),
m_InputWorldGeometry3D( NULL ),
m_InputWorldTimeGeometry( NULL ),
m_CreatedWorldGeometry( NULL ),
m_ViewDirection( Axial ),
m_DefaultViewDirection( Axial ),
m_RenderingManager( NULL ),
m_Renderer( NULL ),
m_Top( false ),
m_FrontSide( false ),
m_Rotated( false ),
m_BlockUpdate( false ),
m_SliceLocked( false ),
m_SliceRotationLocked( false ),
m_OldPos(0)
{
typedef itk::SimpleMemberCommand< SliceNavigationController > SNCCommandType;
SNCCommandType::Pointer sliceStepperChangedCommand, timeStepperChangedCommand;
sliceStepperChangedCommand = SNCCommandType::New();
timeStepperChangedCommand = SNCCommandType::New();
sliceStepperChangedCommand->SetCallbackFunction(
this, &SliceNavigationController::SendSlice );
timeStepperChangedCommand->SetCallbackFunction(
this, &SliceNavigationController::SendTime );
m_Slice->AddObserver( itk::ModifiedEvent(), sliceStepperChangedCommand );
m_Time->AddObserver( itk::ModifiedEvent(), timeStepperChangedCommand );
m_Slice->SetUnitName( "mm" );
m_Time->SetUnitName( "ms" );
m_Top = false;
m_FrontSide = false;
m_Rotated = false;
}
SliceNavigationController::~SliceNavigationController()
{
}
void
SliceNavigationController::SetInputWorldGeometry3D( const Geometry3D *geometry )
{
if ( geometry != NULL )
{
if ( const_cast< BoundingBox * >( geometry->GetBoundingBox())
->GetDiagonalLength2() < eps )
{
itkWarningMacro( "setting an empty bounding-box" );
geometry = NULL;
}
}
if ( m_InputWorldGeometry3D != geometry )
{
m_InputWorldGeometry3D = geometry;
m_InputWorldTimeGeometry = NULL;
this->Modified();
}
}
void
SliceNavigationController::SetInputWorldTimeGeometry( const TimeGeometry *geometry )
{
if ( geometry != NULL )
{
if ( const_cast< BoundingBox * >( geometry->GetBoundingBoxInWorld())
->GetDiagonalLength2() < eps )
{
itkWarningMacro( "setting an empty bounding-box" );
geometry = NULL;
}
}
if ( m_InputWorldTimeGeometry != geometry )
{
m_InputWorldTimeGeometry = geometry;
m_InputWorldGeometry3D = NULL;
this->Modified();
}
}
RenderingManager *
SliceNavigationController::GetRenderingManager() const
{
mitk::RenderingManager* renderingManager = m_RenderingManager.GetPointer();
if (renderingManager != NULL)
return renderingManager;
if ( m_Renderer != NULL )
{
renderingManager = m_Renderer->GetRenderingManager();
if (renderingManager != NULL)
return renderingManager;
}
return mitk::RenderingManager::GetInstance();
}
void SliceNavigationController::SetViewDirectionToDefault()
{
m_ViewDirection = m_DefaultViewDirection;
}
const char* SliceNavigationController::GetViewDirectionAsString()
{
const char* viewDirectionString;
switch(m_ViewDirection)
{
case 0:
viewDirectionString = "Axial";
break;
case 1:
viewDirectionString = "Sagittal";
break;
case 2:
viewDirectionString = "Frontal";
break;
case 3:
viewDirectionString = "Original";
break;
default:
viewDirectionString = "No View Direction Available";
break;
}
return viewDirectionString;
}
void SliceNavigationController::Update()
{
if ( !m_BlockUpdate )
{
if ( m_ViewDirection == Axial )
{
this->Update( Axial, false, false, true );
}
else
{
this->Update( m_ViewDirection );
}
}
}
void
SliceNavigationController::Update(
SliceNavigationController::ViewDirection viewDirection,
bool top, bool frontside, bool rotated )
{
TimeGeometry::ConstPointer worldTimeGeometry = m_InputWorldTimeGeometry;
if( m_BlockUpdate ||
( m_InputWorldTimeGeometry.IsNull() && m_InputWorldGeometry3D.IsNull() ) ||
- ( (worldTimeGeometry.IsNotNull()) && (worldTimeGeometry->GetNumberOfTimeSteps() == 0) )
+ ( (worldTimeGeometry.IsNotNull()) && (worldTimeGeometry->CountTimeSteps() == 0) )
)
{
return;
}
m_BlockUpdate = true;
if ( m_InputWorldTimeGeometry.IsNotNull() &&
m_LastUpdateTime < m_InputWorldTimeGeometry->GetMTime() )
{
Modified();
}
if ( m_InputWorldGeometry3D.IsNotNull() &&
m_LastUpdateTime < m_InputWorldGeometry3D->GetMTime() )
{
Modified();
}
this->SetViewDirection( viewDirection );
this->SetTop( top );
this->SetFrontSide( frontside );
this->SetRotated( rotated );
if ( m_LastUpdateTime < GetMTime() )
{
m_LastUpdateTime = GetMTime();
// initialize the viewplane
SlicedGeometry3D::Pointer slicedWorldGeometry = NULL;
Geometry3D::ConstPointer currentGeometry = NULL;
if (m_InputWorldTimeGeometry.IsNotNull())
if (m_InputWorldTimeGeometry->IsValidTimeStep(GetTime()->GetPos()))
currentGeometry = m_InputWorldTimeGeometry->GetGeometryForTimeStep(GetTime()->GetPos());
else
currentGeometry = m_InputWorldTimeGeometry->GetGeometryForTimeStep(0);
else
currentGeometry = m_InputWorldGeometry3D;
m_CreatedWorldGeometry = NULL;
switch ( viewDirection )
{
case Original:
if ( worldTimeGeometry.IsNotNull())
{
m_CreatedWorldGeometry = worldTimeGeometry->Clone();
worldTimeGeometry = m_CreatedWorldGeometry.GetPointer();
slicedWorldGeometry = dynamic_cast< SlicedGeometry3D * >(
m_CreatedWorldGeometry->GetGeometryForTimeStep( this->GetTime()->GetPos() ).GetPointer() );
if ( slicedWorldGeometry.IsNotNull() )
{
break;
}
}
else
{
const SlicedGeometry3D *worldSlicedGeometry =
dynamic_cast< const SlicedGeometry3D * >(
currentGeometry.GetPointer());
if ( worldSlicedGeometry != NULL )
{
slicedWorldGeometry = static_cast< SlicedGeometry3D * >(
currentGeometry->Clone().GetPointer());
break;
}
}
//else: use Axial: no "break" here!!
case Axial:
slicedWorldGeometry = SlicedGeometry3D::New();
slicedWorldGeometry->InitializePlanes(
currentGeometry, PlaneGeometry::Axial,
top, frontside, rotated );
slicedWorldGeometry->SetSliceNavigationController( this );
break;
case Frontal:
slicedWorldGeometry = SlicedGeometry3D::New();
slicedWorldGeometry->InitializePlanes( currentGeometry,
PlaneGeometry::Frontal, top, frontside, rotated );
slicedWorldGeometry->SetSliceNavigationController( this );
break;
case Sagittal:
slicedWorldGeometry = SlicedGeometry3D::New();
slicedWorldGeometry->InitializePlanes( currentGeometry,
PlaneGeometry::Sagittal, top, frontside, rotated );
slicedWorldGeometry->SetSliceNavigationController( this );
break;
default:
itkExceptionMacro("unknown ViewDirection");
}
m_Slice->SetPos( 0 );
m_Slice->SetSteps( (int)slicedWorldGeometry->GetSlices() );
if ( m_CreatedWorldGeometry.IsNull() )
{
// initialize TimeGeometry
m_CreatedWorldGeometry = ProportionalTimeGeometry::New();
}
if ( worldTimeGeometry.IsNull())
{
m_CreatedWorldGeometry = ProportionalTimeGeometry::New();
dynamic_cast<ProportionalTimeGeometry *>(m_CreatedWorldGeometry.GetPointer())->Initialize(slicedWorldGeometry, 1);
m_Time->SetSteps( 0 );
m_Time->SetPos( 0 );
m_Time->InvalidateRange();
}
else
{
m_BlockUpdate = true;
- m_Time->SetSteps( worldTimeGeometry->GetNumberOfTimeSteps() );
+ m_Time->SetSteps( worldTimeGeometry->CountTimeSteps() );
m_Time->SetPos( 0 );
const TimeBounds &timeBounds = worldTimeGeometry->GetTimeBounds();
m_Time->SetRange( timeBounds[0], timeBounds[1] );
m_BlockUpdate = false;
assert( worldTimeGeometry->GetGeometryForTimeStep( this->GetTime()->GetPos() ).IsNotNull() );
slicedWorldGeometry->SetTimeBounds(
worldTimeGeometry->GetGeometryForTimeStep( this->GetTime()->GetPos() )->GetTimeBounds() );
//@todo implement for non-evenly-timed geometry!
m_CreatedWorldGeometry = ProportionalTimeGeometry::New();
- dynamic_cast<ProportionalTimeGeometry *>(m_CreatedWorldGeometry.GetPointer())->Initialize(slicedWorldGeometry, worldTimeGeometry->GetNumberOfTimeSteps());
+ dynamic_cast<ProportionalTimeGeometry *>(m_CreatedWorldGeometry.GetPointer())->Initialize(slicedWorldGeometry, worldTimeGeometry->CountTimeSteps());
}
}
// unblock update; we may do this now, because if m_BlockUpdate was already
// true before this method was entered, then we will never come here.
m_BlockUpdate = false;
// Send the geometry. Do this even if nothing was changed, because maybe
// Update() was only called to re-send the old geometry and time/slice data.
this->SendCreatedWorldGeometry();
this->SendSlice();
this->SendTime();
// Adjust the stepper range of slice stepper according to geometry
this->AdjustSliceStepperRange();
}
void
SliceNavigationController::SendCreatedWorldGeometry()
{
// Send the geometry. Do this even if nothing was changed, because maybe
// Update() was only called to re-send the old geometry.
if ( !m_BlockUpdate )
{
this->InvokeEvent( GeometrySendEvent(m_CreatedWorldGeometry, 0) );
}
}
void
SliceNavigationController::SendCreatedWorldGeometryUpdate()
{
if ( !m_BlockUpdate )
{
this->InvokeEvent(
GeometryUpdateEvent(m_CreatedWorldGeometry, m_Slice->GetPos()) );
}
}
void
SliceNavigationController::SendSlice()
{
if ( !m_BlockUpdate )
{
if ( m_CreatedWorldGeometry.IsNotNull() )
{
this->InvokeEvent(
GeometrySliceEvent(m_CreatedWorldGeometry, m_Slice->GetPos()) );
// send crosshair event
crosshairPositionEvent.Send();
// Request rendering update for all views
this->GetRenderingManager()->RequestUpdateAll();
}
}
}
void
SliceNavigationController::SendTime()
{
if ( !m_BlockUpdate )
{
if ( m_CreatedWorldGeometry.IsNotNull() )
{
this->InvokeEvent(
GeometryTimeEvent(m_CreatedWorldGeometry, m_Time->GetPos()) );
// Request rendering update for all views
this->GetRenderingManager()->RequestUpdateAll();
}
}
}
void
SliceNavigationController::SetGeometry( const itk::EventObject & )
{
}
void
SliceNavigationController
::SetGeometryTime( const itk::EventObject &geometryTimeEvent )
{
const SliceNavigationController::GeometryTimeEvent *timeEvent =
dynamic_cast< const SliceNavigationController::GeometryTimeEvent * >(
&geometryTimeEvent);
assert( timeEvent != NULL );
TimeGeometry *timeGeometry = timeEvent->GetTimeGeometry();
assert( timeGeometry != NULL );
if ( m_CreatedWorldGeometry.IsNotNull() )
{
int timeStep = (int) timeEvent->GetPos();
ScalarType timeInMS;
timeInMS = timeGeometry->TimeStepToTimePoint( timeStep );
timeStep = m_CreatedWorldGeometry->TimePointToTimeStep( timeInMS );
this->GetTime()->SetPos( timeStep );
}
}
void
SliceNavigationController
::SetGeometrySlice(const itk::EventObject & geometrySliceEvent)
{
const SliceNavigationController::GeometrySliceEvent* sliceEvent =
dynamic_cast<const SliceNavigationController::GeometrySliceEvent *>(
&geometrySliceEvent);
assert(sliceEvent!=NULL);
this->GetSlice()->SetPos(sliceEvent->GetPos());
}
void
SliceNavigationController::SelectSliceByPoint( const Point3D &point )
{
//@todo add time to PositionEvent and use here!!
SlicedGeometry3D* slicedWorldGeometry = dynamic_cast< SlicedGeometry3D * >(
m_CreatedWorldGeometry->GetGeometryForTimeStep( this->GetTime()->GetPos() ).GetPointer() );
if ( slicedWorldGeometry )
{
int bestSlice = -1;
double bestDistance = itk::NumericTraits<double>::max();
int s, slices;
slices = slicedWorldGeometry->GetSlices();
if ( slicedWorldGeometry->GetEvenlySpaced() )
{
mitk::Geometry2D *plane = slicedWorldGeometry->GetGeometry2D( 0 );
const Vector3D &direction = slicedWorldGeometry->GetDirectionVector();
Point3D projectedPoint;
plane->Project( point, projectedPoint );
// Check whether the point is somewhere within the slice stack volume;
// otherwise, the defualt slice (0) will be selected
if ( direction[0] * (point[0] - projectedPoint[0])
+ direction[1] * (point[1] - projectedPoint[1])
+ direction[2] * (point[2] - projectedPoint[2]) >= 0 )
{
bestSlice = (int)(plane->Distance( point )
/ slicedWorldGeometry->GetSpacing()[2] + 0.5);
}
}
else
{
Point3D projectedPoint;
for ( s = 0; s < slices; ++s )
{
slicedWorldGeometry->GetGeometry2D( s )->Project( point, projectedPoint );
Vector3D distance = projectedPoint - point;
ScalarType currentDistance = distance.GetSquaredNorm();
if ( currentDistance < bestDistance )
{
bestDistance = currentDistance;
bestSlice = s;
}
}
}
if ( bestSlice >= 0 )
{
this->GetSlice()->SetPos( bestSlice );
}
else
{
this->GetSlice()->SetPos( 0 );
}
this->SendCreatedWorldGeometryUpdate();
}
}
void
SliceNavigationController::ReorientSlices( const Point3D &point,
const Vector3D &normal )
{
PlaneOperation op( OpORIENT, point, normal );
m_CreatedWorldGeometry->ExecuteOperation( &op );
this->SendCreatedWorldGeometryUpdate();
}
void SliceNavigationController::ReorientSlices(const mitk::Point3D &point,
const mitk::Vector3D &axisVec0, const mitk::Vector3D &axisVec1 )
{
PlaneOperation op( OpORIENT, point, axisVec0, axisVec1 );
m_CreatedWorldGeometry->ExecuteOperation( &op );
this->SendCreatedWorldGeometryUpdate();
}
mitk::TimeGeometry *
SliceNavigationController::GetCreatedWorldGeometry()
{
return m_CreatedWorldGeometry;
}
const mitk::Geometry3D *
SliceNavigationController::GetCurrentGeometry3D()
{
if ( m_CreatedWorldGeometry.IsNotNull() )
{
return m_CreatedWorldGeometry->GetGeometryForTimeStep( this->GetTime()->GetPos() );
}
else
{
return NULL;
}
}
const mitk::PlaneGeometry *
SliceNavigationController::GetCurrentPlaneGeometry()
{
const mitk::SlicedGeometry3D *slicedGeometry =
dynamic_cast< const mitk::SlicedGeometry3D * >
( this->GetCurrentGeometry3D() );
if ( slicedGeometry )
{
const mitk::PlaneGeometry *planeGeometry =
dynamic_cast< mitk::PlaneGeometry * >
( slicedGeometry->GetGeometry2D(this->GetSlice()->GetPos()) );
return planeGeometry;
}
else
{
return NULL;
}
}
void
SliceNavigationController::SetRenderer( BaseRenderer *renderer )
{
m_Renderer = renderer;
}
BaseRenderer *
SliceNavigationController::GetRenderer() const
{
return m_Renderer;
}
void
SliceNavigationController::AdjustSliceStepperRange()
{
const mitk::SlicedGeometry3D *slicedGeometry =
dynamic_cast< const mitk::SlicedGeometry3D * >
( this->GetCurrentGeometry3D() );
const Vector3D &direction = slicedGeometry->GetDirectionVector();
int c = 0;
int i, k = 0;
for ( i = 0; i < 3; ++i )
{
if ( fabs( (float) direction[i] ) < 0.000000001 ) { ++c; }
else { k = i; }
}
if ( c == 2 )
{
ScalarType min = slicedGeometry->GetOrigin()[k];
ScalarType max = min + slicedGeometry->GetExtentInMM( k );
m_Slice->SetRange( min, max );
}
else
{
m_Slice->InvalidateRange();
}
}
void
SliceNavigationController::ExecuteOperation( Operation *operation )
{
// switch on type
// - select best slice for a given point
// - rotate created world geometry according to Operation->SomeInfo()
if ( !operation )
{
return;
}
switch ( operation->GetOperationType() )
{
case OpMOVE: // should be a point operation
{
if ( !m_SliceLocked ) //do not move the cross position
{
// select a slice
PointOperation *po = dynamic_cast< PointOperation * >( operation );
if ( po && po->GetIndex() == -1 )
{
this->SelectSliceByPoint( po->GetPoint() );
}
else if ( po && po->GetIndex() != -1 ) // undo case because index != -1, index holds the old position of this slice
{
this->GetSlice()->SetPos( po->GetIndex() );
}
}
break;
}
case OpRESTOREPLANEPOSITION:
{
m_CreatedWorldGeometry->ExecuteOperation( operation );
this->SendCreatedWorldGeometryUpdate();
break;
}
default:
{
// do nothing
break;
}
}
}
mitk::DataNode::Pointer SliceNavigationController::GetTopLayerNode(mitk::DataStorage::SetOfObjects::ConstPointer nodes,mitk::Point3D worldposition)
{
mitk::DataNode::Pointer node;
int maxlayer = -32768;
bool isHelper (false);
if(nodes.IsNotNull())
{
for (unsigned int x = 0; x < nodes->size(); x++)
{
nodes->at(x)->GetBoolProperty("helper object", isHelper);
if(nodes->at(x)->GetData()->GetGeometry()->IsInside(worldposition) && isHelper == false)
{
int layer = 0;
if(!(nodes->at(x)->GetIntProperty("layer", layer))) continue;
if(layer > maxlayer)
{
if(static_cast<mitk::DataNode::Pointer>(nodes->at(x))->IsVisible(m_Renderer))
{
node = nodes->at(x);
maxlayer = layer;
}
}
}
}
}
return node;
}
// Relict from the old times, when automous decisions were accepted
// behavior. Remains in here, because some RenderWindows do exist outside
// of StdMultiWidgets.
bool
SliceNavigationController
::ExecuteAction( Action* action, StateEvent const* stateEvent )
{
bool ok = false;
const PositionEvent* posEvent = dynamic_cast< const PositionEvent * >(
stateEvent->GetEvent() );
if ( posEvent != NULL )
{
if ( m_CreatedWorldGeometry.IsNull() )
{
return true;
}
switch (action->GetActionId())
{
case AcMOVE:
{
BaseRenderer *baseRenderer = posEvent->GetSender();
if ( !baseRenderer )
{
baseRenderer = const_cast<BaseRenderer *>(
GlobalInteraction::GetInstance()->GetFocus() );
}
if ( baseRenderer )
if ( baseRenderer->GetMapperID() == 1 )
{
PointOperation doOp(OpMOVE, posEvent->GetWorldPosition());
this->ExecuteOperation( &doOp );
// If click was performed in this render window than we have to update the status bar information about position and pixel value.
if(baseRenderer == m_Renderer)
{
{
std::string statusText;
TNodePredicateDataType<mitk::Image>::Pointer isImageData = TNodePredicateDataType<mitk::Image>::New();
mitk::DataStorage::SetOfObjects::ConstPointer nodes = baseRenderer->GetDataStorage()->GetSubset(isImageData).GetPointer();
mitk::Point3D worldposition = posEvent->GetWorldPosition();
//int maxlayer = -32768;
mitk::Image::Pointer image3D;
mitk::DataNode::Pointer node;
mitk::DataNode::Pointer topSourceNode;
bool isBinary (false);
node = this->GetTopLayerNode(nodes,worldposition);
if(node.IsNotNull())
{
node->GetBoolProperty("binary", isBinary);
if(isBinary)
{
mitk::DataStorage::SetOfObjects::ConstPointer sourcenodes = baseRenderer->GetDataStorage()->GetSources(node, NULL, true);
if(!sourcenodes->empty())
{
topSourceNode = this->GetTopLayerNode(sourcenodes,worldposition);
}
if(topSourceNode.IsNotNull())
{
image3D = dynamic_cast<mitk::Image*>(topSourceNode->GetData());
}
else
{
image3D = dynamic_cast<mitk::Image*>(node->GetData());
}
}
else
{
image3D = dynamic_cast<mitk::Image*>(node->GetData());
}
}
std::stringstream stream;
stream.imbue(std::locale::classic());
// get the position and gray value from the image and build up status bar text
if(image3D.IsNotNull())
{
Index3D p;
image3D->GetGeometry()->WorldToIndex(worldposition, p);
stream.precision(2);
stream<<"Position: <" << std::fixed <<worldposition[0] << ", " << std::fixed << worldposition[1] << ", " << std::fixed << worldposition[2] << "> mm";
stream<<"; Index: <"<<p[0] << ", " << p[1] << ", " << p[2] << "> ";
mitk::ScalarType pixelValue = image3D->GetPixelValueByIndex(p, baseRenderer->GetTimeStep());
if (fabs(pixelValue)>1000000 || fabs(pixelValue) < 0.01)
{
stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: " << std::scientific<< pixelValue <<" ";
}
else
{
stream<<"; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: "<< pixelValue <<" ";
}
}
else
{
stream << "No image information at this position!";
}
statusText = stream.str();
mitk::StatusBar::GetInstance()->DisplayGreyValueText(statusText.c_str());
}
}
ok = true;
break;
}
}
default:
ok = true;
break;
}
return ok;
}
const DisplayPositionEvent *displPosEvent =
dynamic_cast< const DisplayPositionEvent * >( stateEvent->GetEvent() );
if ( displPosEvent != NULL )
{
return true;
}
return false;
}
} // namespace
diff --git a/Core/Code/DataManagement/mitkBaseData.cpp b/Core/Code/DataManagement/mitkBaseData.cpp
index 18159dbd98..cd84eb203f 100644
--- a/Core/Code/DataManagement/mitkBaseData.cpp
+++ b/Core/Code/DataManagement/mitkBaseData.cpp
@@ -1,295 +1,295 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkBaseData.h"
#include <mitkProportionalTimeGeometry.h>
#include <itkObjectFactoryBase.h>
#include <mitkException.h>
mitk::BaseData::BaseData() :
m_RequestedRegionInitialized(false),
m_SourceOutputIndexDuplicate(0), m_Initialized(true)
{
m_TimeGeometry = mitk::ProportionalTimeGeometry::New();
m_PropertyList = PropertyList::New();
}
mitk::BaseData::BaseData( const BaseData &other ):
itk::DataObject(), mitk::OperationActor(),
m_RequestedRegionInitialized(other.m_RequestedRegionInitialized),
m_SourceOutputIndexDuplicate(other.m_SourceOutputIndexDuplicate),
m_Initialized(other.m_Initialized)
{
m_TimeGeometry = dynamic_cast<TimeGeometry *>(other.m_TimeGeometry->Clone().GetPointer());
m_PropertyList = other.m_PropertyList->Clone();
}
mitk::BaseData::~BaseData()
{
}
void mitk::BaseData::InitializeTimeGeometry(unsigned int timeSteps)
{
mitk::Geometry3D::Pointer g3d = mitk::Geometry3D::New();
g3d->Initialize();
if ( timeSteps > 1 )
{
mitk::ScalarType timeBounds[] = {0.0, 1.0};
g3d->SetTimeBounds( timeBounds );
}
// The geometry is propagated automatically to the other items,
// if EvenlyTimed is true...
//Old timeGeometry->InitializeEvenlyTimed( g3d.GetPointer(), timeSteps );
TimeGeometry::Pointer timeGeometry = this->GetTimeGeometry();
timeGeometry->Expand(timeSteps);
for (TimeStepType step = 0; step < timeSteps; ++step)
{
timeGeometry->SetTimeStepGeometry(g3d.GetPointer(),step);
}
}
void mitk::BaseData::UpdateOutputInformation()
{
if ( this->GetSource() )
{
this->GetSource()->UpdateOutputInformation();
}
if (m_TimeGeometry.IsNotNull())
{
m_TimeGeometry->UpdateBoundingBox();
}
}
const mitk::TimeGeometry* mitk::BaseData::GetUpdatedTimeGeometry()
{
SetRequestedRegionToLargestPossibleRegion();
UpdateOutputInformation();
return GetTimeGeometry();
}
void mitk::BaseData::Expand( unsigned int timeSteps )
{
if (m_TimeGeometry.IsNotNull() )
{
ProportionalTimeGeometry * propTimeGeometry = dynamic_cast<ProportionalTimeGeometry*> (m_TimeGeometry.GetPointer());
if (propTimeGeometry)
{
propTimeGeometry->Expand(timeSteps);
return;
}
mitkThrow() << "TimeGeometry is of an unkown Type. Could not expand it. ";
}
else
{
this->InitializeTimeGeometry(timeSteps);
}
}
const mitk::Geometry3D* mitk::BaseData::GetUpdatedGeometry(int t)
{
SetRequestedRegionToLargestPossibleRegion();
UpdateOutputInformation();
return GetGeometry(t);
}
void mitk::BaseData::SetGeometry(Geometry3D* geometry)
{
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
if(geometry!=NULL)
{
timeGeometry->Initialize(geometry, 1);
}
SetTimeGeometry(timeGeometry);
return;
}
void mitk::BaseData::SetTimeGeometry(TimeGeometry* geometry)
{
m_TimeGeometry = geometry;
this->Modified();
}
void mitk::BaseData::SetClonedGeometry(const Geometry3D* aGeometry3D)
{
SetGeometry(static_cast<mitk::Geometry3D*>(aGeometry3D->Clone().GetPointer()));
}
void mitk::BaseData::SetClonedTimeGeometry(const TimeGeometry* geometry)
{
TimeGeometry::Pointer clonedGeometry = geometry->Clone();
SetTimeGeometry(clonedGeometry.GetPointer());
}
void mitk::BaseData::SetClonedGeometry(const Geometry3D* aGeometry3D, unsigned int time)
{
if (m_TimeGeometry)
{
m_TimeGeometry->SetTimeStepGeometry(static_cast<mitk::Geometry3D*>(aGeometry3D->Clone().GetPointer()),time);
}
}
bool mitk::BaseData::IsEmptyTimeStep(unsigned int) const
{
return IsInitialized() == false;
}
bool mitk::BaseData::IsEmpty() const
{
if(IsInitialized() == false)
return true;
const TimeGeometry* timeGeometry = const_cast<BaseData*>(this)->GetUpdatedTimeGeometry();
if(timeGeometry == NULL)
return true;
- unsigned int timeSteps = timeGeometry->GetNumberOfTimeSteps();
+ unsigned int timeSteps = timeGeometry->CountTimeSteps();
for ( unsigned int t = 0 ; t < timeSteps ; ++t )
{
if(IsEmptyTimeStep(t) == false)
return false;
}
return true;
}
itk::SmartPointer<mitk::BaseDataSource> mitk::BaseData::GetSource() const
{
return static_cast<mitk::BaseDataSource*>(Superclass::GetSource().GetPointer());
}
mitk::PropertyList::Pointer mitk::BaseData::GetPropertyList() const
{
return m_PropertyList;
}
mitk::BaseProperty::Pointer mitk::BaseData::GetProperty(const char *propertyKey) const
{
return m_PropertyList->GetProperty(propertyKey);
}
void mitk::BaseData::SetProperty(const char *propertyKey,
BaseProperty* propertyValue)
{
m_PropertyList->SetProperty(propertyKey, propertyValue);
}
void mitk::BaseData::SetPropertyList(PropertyList *pList)
{
m_PropertyList = pList;
}
void mitk::BaseData::SetOrigin(const mitk::Point3D& origin)
{
TimeGeometry* timeGeom = GetTimeGeometry();
assert (timeGeom != NULL);
Geometry3D* geometry;
- TimeStepType steps = timeGeom->GetNumberOfTimeSteps();
+ TimeStepType steps = timeGeom->CountTimeSteps();
for (TimeStepType timestep = 0; timestep < steps; ++timestep)
{
geometry = GetGeometry(timestep);
if (geometry != NULL)
{
geometry->SetOrigin(origin);
}
}
}
unsigned long mitk::BaseData::GetMTime() const
{
unsigned long time = Superclass::GetMTime();
if(m_TimeGeometry.IsNotNull())
{
if((time < m_TimeGeometry->GetMTime()))
{
Modified();
return Superclass::GetMTime();
}
}
return time;
}
void mitk::BaseData::Graft(const itk::DataObject*)
{
itkExceptionMacro(<< "Graft not implemented for mitk::BaseData subclass " << this->GetNameOfClass())
}
void mitk::BaseData::CopyInformation( const itk::DataObject* data )
{
const Self* bd = dynamic_cast<const Self*>(data);
if (bd != NULL)
{
m_PropertyList = bd->GetPropertyList()->Clone();
if (bd->GetTimeGeometry()!=NULL)
{
m_TimeGeometry = bd->GetTimeGeometry()->Clone();
}
}
else
{
// pointer could not be cast back down; this can be the case if your filters input
// and output objects differ in type; then you have to write your own GenerateOutputInformation method
itkExceptionMacro(<< "mitk::BaseData::CopyInformation() cannot cast "
<< typeid(data).name() << " to "
<< typeid(Self*).name() );
}
}
bool mitk::BaseData::IsInitialized() const
{
return m_Initialized;
}
void mitk::BaseData::Clear()
{
this->ClearData();
this->InitializeEmpty();
}
void mitk::BaseData::ClearData()
{
if(m_Initialized)
{
ReleaseData();
m_Initialized = false;
}
}
void mitk::BaseData::ExecuteOperation(mitk::Operation* /*operation*/)
{
//empty by default. override if needed!
}
void mitk::BaseData::PrintSelf(std::ostream& os, itk::Indent indent) const
{
os << std::endl;
os << indent << " TimeGeometry: ";
if(GetTimeGeometry() == NULL)
os << "NULL" << std::endl;
else
GetTimeGeometry()->Print(os, indent);
}
diff --git a/Core/Code/DataManagement/mitkBaseData.h b/Core/Code/DataManagement/mitkBaseData.h
index fb3306d35f..9a5ad84c6c 100644
--- a/Core/Code/DataManagement/mitkBaseData.h
+++ b/Core/Code/DataManagement/mitkBaseData.h
@@ -1,429 +1,429 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef BASEDATA_H_HEADER_INCLUDED_C1EBB6FA
#define BASEDATA_H_HEADER_INCLUDED_C1EBB6FA
#include <itkDataObject.h>
#include "mitkBaseProcess.h"
#include "mitkTimeGeometry.h"
#include <MitkExports.h>
#include "mitkOperationActor.h"
#include "mitkPropertyList.h"
namespace mitk {
//class BaseProcess;
//##Documentation
//## @brief Base of all data objects
//##
//## Base of all data objects, e.g., images, contours, surfaces etc. Inherits
//## from itk::DataObject and thus can be included in a pipeline.
//## Inherits also from OperationActor and can be used as a destination for Undo
//## @ingroup Data
class MITK_CORE_EXPORT BaseData : public itk::DataObject, public OperationActor
{
public:
mitkClassMacro(BaseData,itk::DataObject)
/**
* \brief Return the TimeGeometry of the data as const pointer.
*
* \warning No update will be called. Use GetUpdatedGeometry() if you cannot
* be sure that the geometry is up-to-date.
*
* Normally used in GenerateOutputInformation of subclasses of BaseProcess.
*/
const mitk::TimeGeometry* GetTimeGeometry() const
{
return m_TimeGeometry.GetPointer();
}
/**
* \brief Return the TimeGeometry of the data as const pointer.
*
* \warning No update will be called. Use GetUpdatedGeometry() if you cannot
* be sure that the geometry is up-to-date.
*
* Normally used in GenerateOutputInformation of subclasses of BaseProcess.
* \deprecatedSince{2013_06} Please use GetTimeGeometry instead: For additional information see @TimeGeometryGuide@
*/
DEPRECATED(const mitk::TimeGeometry* GetTimeSlicedGeometry() const)
{
return GetTimeGeometry();
}
/**
* @brief Return the TimeGeometry of the data as pointer.
*
* \warning No update will be called. Use GetUpdatedGeometry() if you cannot
* be sure that the geometry is up-to-date.
*
* Normally used in GenerateOutputInformation of subclasses of BaseProcess.
*/
mitk::TimeGeometry* GetTimeGeometry()
{
return m_TimeGeometry.GetPointer();
}
/**
* @brief Return the Geometry3D of the data.
*
* The method does not simply return the value of the m_TimeGeometry
* member. Before doing this, it makes sure that the TimeGeometry
* is up-to-date (by setting the update extent to largest possible and
* calling UpdateOutputInformation).
*/
const mitk::TimeGeometry* GetUpdatedTimeGeometry();
/**
* @brief Return the Geometry3D of the data.
*
* The method does not simply return the value of the m_TimeGeometry
* member. Before doing this, it makes sure that the TimeGeometry
* is up-to-date (by setting the update extent to largest possible and
* calling UpdateOutputInformation).
* \deprecatedSince{2013_06} Please use GetUpdatedTimeGeometry instead: For additional information see @TimeGeometryGuide@
*/
DEPRECATED(const mitk::TimeGeometry* GetUpdatedTimeSliceGeometry())
{
return GetUpdatedTimeGeometry();
}
/**
* \brief Expands the TimeGeometry to a number of TimeSteps.
*
* The method expands the TimeGeometry to the given number of TimeSteps,
* filling newly created elements with empty geometries. Sub-classes should override
* this method to handle the elongation of their data vectors, too.
* Note that a shrinking is neither possible nor intended.
*/
virtual void Expand( unsigned int timeSteps );
/**
* \brief Return the Geometry3D of the data at time \a t.
*
* The method does not simply return
* m_TimeGeometry->GetGeometry(t).
* Before doing this, it makes sure that the Geometry3D is up-to-date
* (by setting the update extent appropriately and calling
* UpdateOutputInformation).
*
* @todo Appropriate setting of the update extent is missing.
*/
const mitk::Geometry3D* GetUpdatedGeometry(int t=0);
//##Documentation
//## @brief Return the geometry, which is a TimeGeometry, of the data
//## as non-const pointer.
//##
//## \warning No update will be called. Use GetUpdatedGeometry() if you cannot
//## be sure that the geometry is up-to-date.
//##
//## Normally used in GenerateOutputInformation of subclasses of BaseProcess.
mitk::Geometry3D* GetGeometry(int t=0) const
{
if(m_TimeGeometry.IsNull())
return NULL;
return m_TimeGeometry->GetGeometryForTimeStep(t);
}
//##Documentation
//## @brief Update the information for this BaseData (the geometry in particular)
//## so that it can be used as an output of a BaseProcess.
//##
//## This method is used in the pipeline mechanism to propagate information and
//## initialize the meta data associated with a BaseData. Any implementation
//## of this method in a derived class is assumed to call its source's
//## BaseProcess::UpdateOutputInformation() which determines modified
//## times, LargestPossibleRegions, and any extra meta data like spacing,
//## origin, etc. Default implementation simply call's it's source's
//## UpdateOutputInformation().
//## \note Implementations of this methods in derived classes must take care
//## that the geometry is updated by calling
//## GetTimeGeometry()->UpdateInformation()
//## \em after calling its source's BaseProcess::UpdateOutputInformation().
void UpdateOutputInformation();
//##Documentation
//## @brief Set the RequestedRegion to the LargestPossibleRegion.
//##
//## This forces a filter to produce all of the output in one execution
//## (i.e. not streaming) on the next call to Update().
virtual void SetRequestedRegionToLargestPossibleRegion()=0;
//##Documentation
//## @brief Determine whether the RequestedRegion is outside of the BufferedRegion.
//##
//## This method returns true if the RequestedRegion
//## is outside the BufferedRegion (true if at least one pixel is
//## outside). This is used by the pipeline mechanism to determine
//## whether a filter needs to re-execute in order to satisfy the
//## current request. If the current RequestedRegion is already
//## inside the BufferedRegion from the previous execution (and the
//## current filter is up to date), then a given filter does not need
//## to re-execute
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion()=0;
//##Documentation
//## @brief Verify that the RequestedRegion is within the LargestPossibleRegion.
//##
//## If the RequestedRegion is not within the LargestPossibleRegion,
//## then the filter cannot possibly satisfy the request. This method
//## returns true if the request can be satisfied (even if it will be
//## necessary to process the entire LargestPossibleRegion) and
//## returns false otherwise. This method is used by
//## PropagateRequestedRegion(). PropagateRequestedRegion() throws a
//## InvalidRequestedRegionError exception if the requested region is
//## not within the LargestPossibleRegion.
virtual bool VerifyRequestedRegion() = 0;
//##Documentation
//## @brief Copy information from the specified data set.
//##
//## This method is part of the pipeline execution model. By default, a
//## BaseProcess will copy meta-data from the first input to all of its
//## outputs. See ProcessObject::GenerateOutputInformation(). Each
//## subclass of DataObject is responsible for being able to copy
//## whatever meta-data it needs from another DataObject.
//## The default implementation of this method copies the time sliced geometry
//## and the property list of an object. If a subclass overrides this
//## method, it should always call its superclass' version.
void CopyInformation(const itk::DataObject* data);
//##Documentation
//## @brief Check whether the data has been initialized, i.e.,
//## at least the Geometry and other header data has been set
//##
//## \warning Set to \a true by default for compatibility reasons.
//## Set m_Initialized=false in constructors of sub-classes that
//## support distinction between initialized and uninitialized state.
virtual bool IsInitialized() const;
//##Documentation
//## @brief Calls ClearData() and InitializeEmpty();
//## \warning Only use in subclasses that reimplemented these methods.
//## Just calling Clear from BaseData will reset an object to a not initialized,
//## invalid state.
virtual void Clear();
//##Documentation
//## @brief Check whether object contains data (at
//## a specified time), e.g., a set of points may be empty
//##
//## \warning Returns IsInitialized()==false by default for
//## compatibility reasons. Override in sub-classes that
//## support distinction between empty/non-empty state.
virtual bool IsEmptyTimeStep(unsigned int t) const;
//##Documentation
//## @brief Check whether object contains data (at
//## least at one point in time), e.g., a set of points
//## may be empty
//##
//## \warning Returns IsInitialized()==false by default for
//## compatibility reasons. Override in sub-classes that
//## support distinction between empty/non-empty state.
virtual bool IsEmpty() const;
//##Documentation
//## @brief Set the requested region from this data object to match the requested
//## region of the data object passed in as a parameter.
//##
//## This method is implemented in the concrete subclasses of BaseData.
virtual void SetRequestedRegion(const itk::DataObject *data)=0;
//##Documentation
//##@brief overwrite if the Data can be called by an Interactor (StateMachine).
//##
//## Empty by default. Overwrite and implement all the necessary operations here
//## and get the necessary information from the parameter operation.
void ExecuteOperation(Operation* operation);
/**
* \brief Set the Geometry3D of the data, which will be referenced (not copied!).
* Assumes the data object has only 1 time step ( is a 3D object ) and creates a
* new TimeGeometry which saves the given Geometry3D. If an TimeGeometry has already
* been set for the object, it will be replaced after calling this function.
*
* @warning This method will normally be called internally by the sub-class of BaseData
* during initialization.
* \sa SetClonedGeometry
*/
virtual void SetGeometry(Geometry3D* aGeometry3D);
/**
* \brief Set the TimeGeometry of the data, which will be referenced (not copied!).
*
* @warning This method will normally be called internally by the sub-class of BaseData
* during initialization.
* \sa SetClonedTimeGeometry
*/
virtual void SetTimeGeometry (TimeGeometry* geometry);
/**
* \brief Set a clone of the provided TimeGeometry as TimeGeometry of the data.
* Assumes the data object has only 1 time step ( is a 3D object ) and
* creates a new TimeGeometry. If an TimeGeometry has already
* been set for the object, it will be replaced after calling this function.
*
* \sa SetGeometry
*/
virtual void SetClonedGeometry(const Geometry3D* aGeometry3D);
/**
* \brief Set a clone of the provided TimeGeometry as TimeGeometry of the data.
*
* \sa SetGeometry
*/
virtual void SetClonedTimeGeometry (const TimeGeometry* geometry);
//##Documentation
//## @brief Set a clone of the provided geometry as Geometry3D of a given time step.
//##
//## \sa SetGeometry
virtual void SetClonedGeometry(const Geometry3D* aGeometry3D, unsigned int time);
//##Documentation
//## @brief Get the data's property list
//## @sa GetProperty
//## @sa m_PropertyList
mitk::PropertyList::Pointer GetPropertyList() const;
//##Documentation
//## @brief Set the data's property list
//## @sa SetProperty
//## @sa m_PropertyList
void SetPropertyList(PropertyList* propertyList);
//##Documentation
//## @brief Get the property (instance of BaseProperty) with key @a propertyKey from the PropertyList,
//## and set it to this, respectively;
//## @sa GetPropertyList
//## @sa m_PropertyList
//## @sa m_MapOfPropertyLists
mitk::BaseProperty::Pointer GetProperty(const char *propertyKey) const;
void SetProperty(const char *propertyKey, BaseProperty* property);
//##Documentation
//## @brief Convenience method for setting the origin of
//## the Geometry3D instances of all time steps
//##
//## \warning Geometries contained in the Geometry3D will
//## \em not be changed, e.g. in case the Geometry3D is a
//## SlicedGeometry3D the origin will \em not be propagated
//## to the contained slices. The sub-class SlicedData
//## does this for the case that the SlicedGeometry3D is
//## evenly spaced.
virtual void SetOrigin(const Point3D& origin);
/** \brief Get the process object that generated this data object.
*
* If there is no process object, then the data object has
* been disconnected from the pipeline, or the data object
* was created manually. (Note: we cannot use the GetObjectMacro()
* defined in itkMacro because the mutual dependency of
* DataObject and ProcessObject causes compile problems. Also,
* a forward reference smart pointer is returned, not a smart pointer,
* because of the circular dependency between the process and data object.)
*
* GetSource() returns a SmartPointer and not a WeakPointer
* because it is assumed the code calling GetSource() wants to hold a
* long term reference to the source. */
itk::SmartPointer<mitk::BaseDataSource> GetSource() const;
//##Documentation
//## @brief Get the number of time steps from the TimeGeometry
//## As the base data has not a data vector given by itself, the number
//## of time steps is defined over the time sliced geometry. In sub classes,
//## a better implementation could be over the length of the data vector.
unsigned int GetTimeSteps() const
{
- return m_TimeGeometry->GetNumberOfTimeSteps();
+ return m_TimeGeometry->CountTimeSteps();
}
//##Documentation
//## @brief Get the modified time of the last change of the contents
//## this data object or its geometry.
virtual unsigned long GetMTime() const;
/**
* \sa itk::ProcessObject::Graft
*/
virtual void Graft(const DataObject*);
protected:
BaseData();
BaseData(const BaseData &other);
~BaseData();
//##Documentation
//## \brief Initialize the TimeGeometry for a number of time steps.
//## The TimeGeometry is initialized empty and evenly timed.
//## In many cases it will be necessary to overwrite this in sub-classes.
virtual void InitializeTimeGeometry( unsigned int timeSteps = 1 );
/**
* \brief Initialize the TimeGeometry for a number of time steps.
* The TimeGeometry is initialized empty and evenly timed.
* In many cases it will be necessary to overwrite this in sub-classes.
* \deprecatedSince{2013_06} Please use GetUpdatedTimeGeometry instead: For additional information see @TimeGeometryGuide@
*/
DEPRECATED(virtual void InitializeTimeSlicedGeometry( unsigned int timeSteps = 1 ))
{
InitializeTimeGeometry(timeSteps);
}
//##Documentation
//## @brief reset to non-initialized state, release memory
virtual void ClearData();
//##Documentation
//## @brief Pure virtual; Must be used in subclasses to get a data object to a
//## valid state. Should at least create one empty object and call
//## Superclass::InitializeTimeGeometry() to ensure an existing valid geometry
virtual void InitializeEmpty(){}
virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
bool m_RequestedRegionInitialized;
bool m_LastRequestedRegionWasOutsideOfTheBufferedRegion;
mutable unsigned int m_SourceOutputIndexDuplicate;
bool m_Initialized;
private:
//##Documentation
//## @brief PropertyList, f.e. to hold pic-tags, tracking-data,..
//##
PropertyList::Pointer m_PropertyList;
TimeGeometry::Pointer m_TimeGeometry;
};
} // namespace mitk
#endif /* BASEDATA_H_HEADER_INCLUDED_C1EBB6FA */
diff --git a/Core/Code/DataManagement/mitkDataStorage.cpp b/Core/Code/DataManagement/mitkDataStorage.cpp
index cfac5776ec..c72e6c95fa 100644
--- a/Core/Code/DataManagement/mitkDataStorage.cpp
+++ b/Core/Code/DataManagement/mitkDataStorage.cpp
@@ -1,504 +1,504 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkDataStorage.h"
#include "mitkDataNode.h"
#include "mitkProperties.h"
#include "mitkNodePredicateBase.h"
#include "mitkNodePredicateProperty.h"
#include "mitkGroupTagProperty.h"
#include "itkMutexLockHolder.h"
#include "itkCommand.h"
mitk::DataStorage::DataStorage() : itk::Object()
, m_BlockNodeModifiedEvents(false)
{
}
mitk::DataStorage::~DataStorage()
{
///// we can not call GetAll() in destructor, because it is implemented in a subclass
//SetOfObjects::ConstPointer all = this->GetAll();
//for (SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
// this->RemoveListeners(it->Value());
//m_NodeModifiedObserverTags.clear();
//m_NodeDeleteObserverTags.clear();
}
void mitk::DataStorage::Add(mitk::DataNode* node, mitk::DataNode* parent)
{
mitk::DataStorage::SetOfObjects::Pointer parents = mitk::DataStorage::SetOfObjects::New();
if (parent != NULL) //< Return empty set if parent is null
parents->InsertElement(0, parent);
this->Add(node, parents);
}
void mitk::DataStorage::Remove(const mitk::DataStorage::SetOfObjects* nodes)
{
if (nodes == NULL)
return;
for (mitk::DataStorage::SetOfObjects::ConstIterator it = nodes->Begin(); it != nodes->End(); it++)
this->Remove(it.Value());
}
mitk::DataStorage::SetOfObjects::ConstPointer mitk::DataStorage::GetSubset(const NodePredicateBase* condition) const
{
mitk::DataStorage::SetOfObjects::ConstPointer result = this->FilterSetOfObjects(this->GetAll(), condition);
return result;
}
mitk::DataNode* mitk::DataStorage::GetNamedNode(const char* name) const
{
if (name == NULL)
return NULL;
mitk::StringProperty::Pointer s(mitk::StringProperty::New(name));
mitk::NodePredicateProperty::Pointer p = mitk::NodePredicateProperty::New("name", s);
mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetSubset(p);
if (rs->Size() >= 1)
return rs->GetElement(0);
else
return NULL;
}
mitk::DataNode* mitk::DataStorage::GetNode(const NodePredicateBase* condition) const
{
if (condition == NULL)
return NULL;
mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetSubset(condition);
if (rs->Size() >= 1)
return rs->GetElement(0);
else
return NULL;
}
mitk::DataNode* mitk::DataStorage::GetNamedDerivedNode(const char* name, const mitk::DataNode* sourceNode, bool onlyDirectDerivations) const
{
if (name == NULL)
return NULL;
mitk::StringProperty::Pointer s(mitk::StringProperty::New(name));
mitk::NodePredicateProperty::Pointer p = mitk::NodePredicateProperty::New("name", s);
mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDerivations(sourceNode, p, onlyDirectDerivations);
if (rs->Size() >= 1)
return rs->GetElement(0);
else
return NULL;
}
void mitk::DataStorage::PrintSelf(std::ostream& os, itk::Indent indent) const
{
//Superclass::PrintSelf(os, indent);
mitk::DataStorage::SetOfObjects::ConstPointer all = this->GetAll();
os << indent << "DataStorage " << this << " is managing " << all->Size() << " objects. List of objects:" << std::endl;
for (mitk::DataStorage::SetOfObjects::ConstIterator allIt = all->Begin(); allIt != all->End(); allIt++)
{
std::string name;
allIt.Value()->GetName(name);
std::string datatype;
if (allIt.Value()->GetData() != NULL)
datatype = allIt.Value()->GetData()->GetNameOfClass();
os << indent << " " << allIt.Value().GetPointer() << "<" << datatype << ">: " << name << std::endl;
mitk::DataStorage::SetOfObjects::ConstPointer parents = this->GetSources(allIt.Value());
if (parents->Size() > 0)
{
os << indent << " Direct sources: ";
for (mitk::DataStorage::SetOfObjects::ConstIterator parentIt = parents->Begin(); parentIt != parents->End(); parentIt++)
os << parentIt.Value().GetPointer() << ", ";
os << std::endl;
}
mitk::DataStorage::SetOfObjects::ConstPointer derivations = this->GetDerivations(allIt.Value());
if (derivations->Size() > 0)
{
os << indent << " Direct derivations: ";
for (mitk::DataStorage::SetOfObjects::ConstIterator derivationIt = derivations->Begin(); derivationIt != derivations->End(); derivationIt++)
os << derivationIt.Value().GetPointer() << ", ";
os << std::endl;
}
}
os << std::endl;
}
mitk::DataStorage::SetOfObjects::ConstPointer mitk::DataStorage::FilterSetOfObjects(const SetOfObjects* set, const NodePredicateBase* condition) const
{
if (set == NULL)
return NULL;
mitk::DataStorage::SetOfObjects::Pointer result = mitk::DataStorage::SetOfObjects::New();
for (mitk::DataStorage::SetOfObjects::ConstIterator it = set->Begin(); it != set->End(); it++)
if (condition == NULL || condition->CheckNode(it.Value()) == true) //alway copy the set, otherwise the iterator in mitk::DataStorage::Remove() will crash
result->InsertElement(result->Size(), it.Value());
return mitk::DataStorage::SetOfObjects::ConstPointer(result);
}
const mitk::DataNode::GroupTagList mitk::DataStorage::GetGroupTags() const
{
DataNode::GroupTagList result;
SetOfObjects::ConstPointer all = this->GetAll();
if (all.IsNull())
return result;
for (mitk::DataStorage::SetOfObjects::ConstIterator nodeIt = all->Begin(); nodeIt != all->End(); nodeIt++) // for each node
{
mitk::PropertyList* pl = nodeIt.Value()->GetPropertyList();
for (mitk::PropertyList::PropertyMap::const_iterator propIt = pl->GetMap()->begin(); propIt != pl->GetMap()->end(); propIt++)
if (dynamic_cast<mitk::GroupTagProperty*>(propIt->second.GetPointer()) != NULL)
result.insert(propIt->first);
}
return result;
}
void mitk::DataStorage::EmitAddNodeEvent(const mitk::DataNode* node)
{
AddNodeEvent.Send(node);
}
void mitk::DataStorage::EmitRemoveNodeEvent(const mitk::DataNode* node)
{
RemoveNodeEvent.Send(node);
}
void mitk::DataStorage::OnNodeInteractorChanged( itk::Object *caller, const itk::EventObject& )
{
const mitk::DataNode* _Node = dynamic_cast<const mitk::DataNode*>(caller);
if(_Node)
{
InteractorChangedNodeEvent.Send( _Node );
}
}
void mitk::DataStorage::OnNodeModifiedOrDeleted( const itk::Object *caller, const itk::EventObject &event )
{
if( m_BlockNodeModifiedEvents )
return;
const mitk::DataNode* _Node = dynamic_cast<const mitk::DataNode*>(caller);
if(_Node)
{
const itk::ModifiedEvent* modEvent = dynamic_cast<const itk::ModifiedEvent*>(&event);
if(modEvent)
ChangedNodeEvent.Send(_Node);
else
DeleteNodeEvent.Send(_Node);
}
}
void mitk::DataStorage::AddListeners( const mitk::DataNode* _Node )
{
itk::MutexLockHolder<itk::SimpleFastMutexLock> locked(m_MutexOne);
// node must not be 0 and must not be yet registered
mitk::DataNode* NonConstNode = const_cast<mitk::DataNode*>(_Node);
if(_Node && m_NodeModifiedObserverTags
.find(NonConstNode) == m_NodeModifiedObserverTags.end())
{
itk::MemberCommand<mitk::DataStorage>::Pointer nodeModifiedCommand =
itk::MemberCommand<mitk::DataStorage>::New();
nodeModifiedCommand->SetCallbackFunction(this
, &mitk::DataStorage::OnNodeModifiedOrDeleted);
m_NodeModifiedObserverTags[NonConstNode]
= NonConstNode->AddObserver(itk::ModifiedEvent(), nodeModifiedCommand);
itk::MemberCommand<mitk::DataStorage>::Pointer interactorChangedCommand = itk::MemberCommand<mitk::DataStorage>::New();
interactorChangedCommand->SetCallbackFunction(this, &mitk::DataStorage::OnNodeInteractorChanged);
m_NodeInteractorChangedObserverTags[NonConstNode] = NonConstNode->AddObserver( mitk::DataNode::InteractorChangedEvent(), interactorChangedCommand);
// add itk delete listener on datastorage
itk::MemberCommand<mitk::DataStorage>::Pointer deleteCommand =
itk::MemberCommand<mitk::DataStorage>::New();
deleteCommand->SetCallbackFunction(this, &mitk::DataStorage::OnNodeModifiedOrDeleted);
// add observer
m_NodeDeleteObserverTags[NonConstNode]
= NonConstNode->AddObserver(itk::DeleteEvent(), deleteCommand);
}
}
void mitk::DataStorage::RemoveListeners( const mitk::DataNode* _Node )
{
itk::MutexLockHolder<itk::SimpleFastMutexLock> locked(m_MutexOne) ;
// node must not be 0 and must be registered
mitk::DataNode* NonConstNode = const_cast<mitk::DataNode*>(_Node);
if(_Node && m_NodeModifiedObserverTags
.find(NonConstNode) != m_NodeModifiedObserverTags.end())
{
// const cast is bad! but sometimes it is necessary. removing an observer does not really
// touch the internal state
NonConstNode->RemoveObserver(m_NodeModifiedObserverTags
.find(NonConstNode)->second);
NonConstNode->RemoveObserver(m_NodeDeleteObserverTags
.find(NonConstNode)->second);
NonConstNode->RemoveObserver(m_NodeInteractorChangedObserverTags
.find(NonConstNode)->second);
m_NodeModifiedObserverTags.erase(NonConstNode);
m_NodeDeleteObserverTags.erase(NonConstNode);
m_NodeInteractorChangedObserverTags.erase(NonConstNode);
}
}
mitk::TimeGeometry::Pointer mitk::DataStorage::ComputeBoundingGeometry3D( const SetOfObjects* input, const char* boolPropertyKey, mitk::BaseRenderer* renderer, const char* boolPropertyKey2)
{
if (input == NULL)
throw std::invalid_argument("DataStorage: input is invalid");
BoundingBox::PointsContainer::Pointer pointscontainer=BoundingBox::PointsContainer::New();
BoundingBox::PointIdentifier pointid=0;
Point3D point;
Vector3D minSpacing;
minSpacing.Fill(ScalarTypeNumericTraits::max());
ScalarType stmin, stmax;
stmin= ScalarTypeNumericTraits::NonpositiveMin();
stmax= ScalarTypeNumericTraits::max();
ScalarType minimalIntervallSize = stmax;
ScalarType minimalTime = stmax;
ScalarType maximalTime = 0;
// Needed for check of zero bounding boxes
mitk::ScalarType nullpoint[]={0,0,0,0,0,0};
BoundingBox::BoundsArrayType itkBoundsZero(nullpoint);
for (SetOfObjects::ConstIterator it = input->Begin(); it != input->End(); ++it)
{
DataNode::Pointer node = it->Value();
if((node.IsNotNull()) && (node->GetData() != NULL) &&
(node->GetData()->IsEmpty()==false) &&
node->IsOn(boolPropertyKey, renderer) &&
node->IsOn(boolPropertyKey2, renderer)
)
{
const TimeGeometry* timeGeometry = node->GetData()->GetUpdatedTimeGeometry();
if (timeGeometry != NULL )
{
// bounding box (only if non-zero)
BoundingBox::BoundsArrayType itkBounds = timeGeometry->GetBoundingBoxInWorld()->GetBounds();
if (itkBounds == itkBoundsZero)
{
continue;
}
unsigned char i;
for(i=0; i<8; ++i)
{
point = timeGeometry->GetCornerPointInWorld(i);
if(point[0]*point[0]+point[1]*point[1]+point[2]*point[2] < large)
pointscontainer->InsertElement( pointid++, point);
else
{
itkGenericOutputMacro( << "Unrealistically distant corner point encountered. Ignored. Node: " << node );
}
}
try
{
// time bounds
// iterate over all time steps
// Attention: Objects with zero bounding box are not respected in time bound calculation
- for (TimeStepType i=0; i<timeGeometry->GetNumberOfTimeSteps(); i++)
+ for (TimeStepType i=0; i<timeGeometry->CountTimeSteps(); i++)
{
Vector3D spacing = node->GetData()->GetGeometry(i)->GetSpacing();
for (int axis = 0; axis < 3; ++ axis)
{
if (spacing[axis] < minSpacing[axis]) minSpacing[axis] = spacing[axis];
}
const TimeBounds & curTimeBounds = node->GetData()->GetGeometry(i)->GetTimeBounds();
// get the minimal time of all objects in the DataStorage
if ((curTimeBounds[0]<minimalTime)&&(curTimeBounds[0]>stmin))
{
minimalTime=curTimeBounds[0];
}
// get the maximal time of all objects in the DataStorage
if ((curTimeBounds[1]>maximalTime)&&(curTimeBounds[1]<stmax))
{
maximalTime = curTimeBounds[1];
}
// get the minimal TimeBound of all time steps of the current DataNode
if (curTimeBounds[1]-curTimeBounds[0]<minimalIntervallSize)
{
minimalIntervallSize = curTimeBounds[1]-curTimeBounds[0];
}
}
}
catch(itk::ExceptionObject e)
{
MITK_ERROR << e << std::endl;
}
}
}
}
BoundingBox::Pointer result = BoundingBox::New();
result->SetPoints(pointscontainer);
result->ComputeBoundingBox();
// minimal time bounds of a single time step for all geometries
TimeBounds minTimeBounds;
minTimeBounds[0] = 0;
minTimeBounds[1] = 1;
// compute the number of time steps
unsigned int numberOfTimeSteps = 1;
if (maximalTime!=0) // make sure that there is at least one time sliced geometry in the data storage
{
minTimeBounds[0] = minimalTime;
minTimeBounds[1] = minimalTime + minimalIntervallSize;
numberOfTimeSteps = static_cast<unsigned int>((maximalTime-minimalTime)/minimalIntervallSize);
}
TimeGeometry::Pointer timeGeometry = NULL;
if ( result->GetPoints()->Size()>0 )
{
// Initialize a geometry of a single time step
Geometry3D::Pointer geometry = Geometry3D::New();
geometry->Initialize();
// correct bounding-box (is now in mm, should be in index-coordinates)
// according to spacing
BoundingBox::BoundsArrayType bounds = result->GetBounds();
int i;
for(i = 0; i < 6; ++i)
{
bounds[i] /= minSpacing[i/2];
}
geometry->SetBounds(bounds);
geometry->SetSpacing(minSpacing);
geometry->SetTimeBounds(minTimeBounds);
// Initialize the time sliced geometry
timeGeometry = ProportionalTimeGeometry::New();
dynamic_cast<ProportionalTimeGeometry*>(timeGeometry.GetPointer())->Initialize(geometry,numberOfTimeSteps);
}
return timeGeometry;
}
mitk::TimeGeometry::Pointer mitk::DataStorage::ComputeBoundingGeometry3D( const char* boolPropertyKey, mitk::BaseRenderer* renderer, const char* boolPropertyKey2)
{
return this->ComputeBoundingGeometry3D(this->GetAll(), boolPropertyKey, renderer, boolPropertyKey2);
}
mitk::TimeGeometry::Pointer mitk::DataStorage::ComputeVisibleBoundingGeometry3D( mitk::BaseRenderer* renderer, const char* boolPropertyKey )
{
return ComputeBoundingGeometry3D( "visible", renderer, boolPropertyKey );
}
mitk::BoundingBox::Pointer mitk::DataStorage::ComputeBoundingBox( const char* boolPropertyKey, mitk::BaseRenderer* renderer, const char* boolPropertyKey2)
{
BoundingBox::PointsContainer::Pointer pointscontainer=BoundingBox::PointsContainer::New();
BoundingBox::PointIdentifier pointid=0;
Point3D point;
// Needed for check of zero bounding boxes
mitk::ScalarType nullpoint[]={0,0,0,0,0,0};
BoundingBox::BoundsArrayType itkBoundsZero(nullpoint);
SetOfObjects::ConstPointer all = this->GetAll();
for (SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
{
DataNode::Pointer node = it->Value();
if((node.IsNotNull()) && (node->GetData() != NULL) &&
(node->GetData()->IsEmpty()==false) &&
node->IsOn(boolPropertyKey, renderer) &&
node->IsOn(boolPropertyKey2, renderer)
)
{
const TimeGeometry* geometry = node->GetData()->GetUpdatedTimeGeometry();
if (geometry != NULL )
{
// bounding box (only if non-zero)
BoundingBox::BoundsArrayType itkBounds = geometry->GetBoundingBoxInWorld()->GetBounds();
if (itkBounds == itkBoundsZero)
{
continue;
}
unsigned char i;
for(i=0; i<8; ++i)
{
point = geometry->GetCornerPointInWorld(i);
if(point[0]*point[0]+point[1]*point[1]+point[2]*point[2] < large)
pointscontainer->InsertElement( pointid++, point);
else
{
itkGenericOutputMacro( << "Unrealistically distant corner point encountered. Ignored. Node: " << node );
}
}
}
}
}
BoundingBox::Pointer result = BoundingBox::New();
result->SetPoints(pointscontainer);
result->ComputeBoundingBox();
return result;
}
mitk::TimeBounds mitk::DataStorage::ComputeTimeBounds( const char* boolPropertyKey, mitk::BaseRenderer* renderer, const char* boolPropertyKey2)
{
TimeBounds timeBounds;
ScalarType stmin, stmax, cur;
stmin= ScalarTypeNumericTraits::NonpositiveMin();
stmax= ScalarTypeNumericTraits::max();
timeBounds[0]=stmax; timeBounds[1]=stmin;
SetOfObjects::ConstPointer all = this->GetAll();
for (SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
{
DataNode::Pointer node = it->Value();
if((node.IsNotNull()) && (node->GetData() != NULL) &&
(node->GetData()->IsEmpty()==false) &&
node->IsOn(boolPropertyKey, renderer) &&
node->IsOn(boolPropertyKey2, renderer)
)
{
const TimeGeometry* geometry = node->GetData()->GetUpdatedTimeGeometry();
if (geometry != NULL )
{
const TimeBounds & curTimeBounds = geometry->GetTimeBounds();
cur=curTimeBounds[0];
//is it after -infinity, but before everything else that we found until now?
if((cur > stmin) && (cur < timeBounds[0]))
timeBounds[0] = cur;
cur=curTimeBounds[1];
//is it before infinity, but after everything else that we found until now?
if((cur < stmax) && (cur > timeBounds[1]))
timeBounds[1] = cur;
}
}
}
if(!(timeBounds[0] < stmax))
{
timeBounds[0] = stmin;
timeBounds[1] = stmax;
}
return timeBounds;
}
void mitk::DataStorage::BlockNodeModifiedEvents( bool block )
{
m_BlockNodeModifiedEvents = block;
}
diff --git a/Core/Code/DataManagement/mitkGeometry3D.h b/Core/Code/DataManagement/mitkGeometry3D.h
index 19c97b45be..fb951a9d8e 100644
--- a/Core/Code/DataManagement/mitkGeometry3D.h
+++ b/Core/Code/DataManagement/mitkGeometry3D.h
@@ -1,762 +1,762 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef GEOMETRY3D_H_HEADER_INCLUDED_C1EBD0AD
#define GEOMETRY3D_H_HEADER_INCLUDED_C1EBD0AD
#include <MitkExports.h>
#include <mitkCommon.h>
#include "mitkVector.h"
#include "mitkOperationActor.h"
#include <itkIndex.h>
#include <itkBoundingBox.h>
#include <itkQuaternionRigidTransform.h>
#include <itkAffineGeometryFrame.h>
#include "itkScalableAffineTransform.h"
#include "itkBoundingBox.h"
class vtkLinearTransform;
class vtkMatrixToLinearTransform;
class vtkMatrix4x4;
namespace mitk {
//##Documentation
//## @brief Standard 3D-BoundingBox typedef
//##
//## Standard 3D-BoundingBox typedef to get rid of template arguments (3D, type).
typedef itk::BoundingBox<unsigned long, 3, ScalarType> BoundingBox;
//##Documentation
//## @brief Standard typedef for time-bounds
typedef itk::FixedArray<ScalarType,2> TimeBounds;
typedef itk::FixedArray<ScalarType, 3> FixedArrayType;
typedef itk::AffineGeometryFrame<ScalarType, 3> AffineGeometryFrame3D;
//##Documentation
//## @brief Describes the geometry of a data object
//##
//## At least, it can return the bounding box of the data object.
//##
//## The class holds
//## \li a bounding box which is axes-parallel in intrinsic coordinates
//## (often integer indices of pixels), to be accessed by
//## GetBoundingBox()
//## \li a transform to convert intrinsic coordinates into a
//## world-coordinate system with coordinates in millimeters
//## and milliseconds (all are floating point values), to
//## be accessed by GetIndexToWorldTransform()
//## \li a life span, i.e. a bounding box in time in ms (with
//## start and end time), to be accessed by GetTimeBounds().
//## The default is minus infinity to plus infinity.
//##
//## Geometry3D and its sub-classes allow converting between
//## intrinsic coordinates (called index or unit coordinates)
//## and world-coordinates (called world or mm coordinates),
//## e.g. WorldToIndex.
//## In case you need integer index coordinates, provide an
//## mitk::Index3D (or itk::Index) as target variable to
//## WorldToIndex, otherwise you will get a continuous index
//## (floating point values).
//##
//## An important sub-class is SlicedGeometry3D, which descibes
//## data objects consisting of slices, e.g., objects of type Image.
//## Conversions between world coordinates (in mm) and unit coordinates
//## (e.g., pixels in the case of an Image) can be performed.
//##
//## For more information on related classes, see \ref Geometry.
//##
//## Geometry3D instances referring to an Image need a slightly
//## different definition of corners, see SetImageGeometry. This
//## is usualy automatically called by Image.
//##
//## Geometry3D have to be initialized in the method GenerateOutputInformation()
//## of BaseProcess (or CopyInformation/ UpdateOutputInformation of BaseData,
//## if possible, e.g., by analyzing pic tags in Image) subclasses. See also
//## itk::ProcessObject::GenerateOutputInformation(),
//## itk::DataObject::CopyInformation() and
//## itk::DataObject::UpdateOutputInformation().
//##
//## Rule: everything is in mm (ms) if not stated otherwise.
//## @ingroup Geometry
class MITK_CORE_EXPORT Geometry3D : public itk::Object, public OperationActor
{
public:
mitkClassMacro(Geometry3D, itk::Object);
typedef itk::QuaternionRigidTransform< ScalarType > QuaternionTransformType;
typedef QuaternionTransformType::VnlQuaternionType VnlQuaternionType;
/** Method for creation through the object factory. */
itkNewMacro(Self);
typedef itk::ScalableAffineTransform<ScalarType, 3> TransformType;
typedef itk::BoundingBox<unsigned long, 3, ScalarType> BoundingBoxType;
typedef BoundingBoxType::BoundsArrayType BoundsArrayType;
typedef BoundingBoxType::Pointer BoundingBoxPointer;
// a bit of a misuse, but we want only doxygen to see the following:
#ifdef DOXYGEN_SKIP
//##Documentation
//## @brief Get the transformation used to convert from index
//## to world coordinates
itkGetObjectMacro(IndexToWorldTransform, AffineTransform3D);
#endif
//## @brief Set the transformation used to convert from index
//## to world coordinates
virtual void SetIndexToWorldTransform(mitk::AffineTransform3D* transform);
//##Documentation
//## @brief Convenience method for setting the ITK transform
//## (m_IndexToWorldTransform) via an vtkMatrix4x4
//## \sa SetIndexToWorldTransform
virtual void SetIndexToWorldTransformByVtkMatrix(vtkMatrix4x4* vtkmatrix);
#ifdef DOXYGEN_SKIP
//##Documentation
//## @brief Get bounding box (in index/unit coordinates)
itkGetConstObjectMacro(BoundingBox, BoundingBoxType);
//##Documentation
//## @brief Get bounding box (in index/unit coordinates) as a BoundsArrayType
const BoundsArrayType GetBounds() const
{
assert(m_BoundingBox.IsNotNull());
return m_BoundingBox->GetBounds();
}
#endif
//##Documentation
//## \brief Set the bounding box (in index/unit coordinates)
//##
//## Only possible via the BoundsArray to make clear that a
//## copy of the bounding-box is stored, not a reference to it.
virtual void SetBounds(const BoundsArrayType& bounds);
//##Documentation
//## @brief Set the bounding box (in index/unit coordinates) via a float array
virtual void SetFloatBounds(const float bounds[6]);
//##Documentation
//## @brief Set the bounding box (in index/unit coordinates) via a double array
virtual void SetFloatBounds(const double bounds[6]);
//##Documentation
//## @brief When switching from an Image Geometry to a normal Geometry (and the other way around), you have to change the origin as well (See Geometry Documentation)! This function will change the "isImageGeometry" bool flag and changes the origin respectively.
virtual void ChangeImageGeometryConsideringOriginOffset( const bool isAnImageGeometry );
//##Documentation
//## @brief Checks, if the given geometry can be converted to 2D without information loss
//## e.g. when a 2D image is saved, the matrix is usually cropped to 2x2, and when you load it back to MITK
//## it will be filled with standard values. This function checks, if information would be lost during this
//## procedure
virtual bool Is2DConvertable();
//##Documentation
//## @brief Get the time bounds (in ms)
itkGetConstReferenceMacro(TimeBounds, TimeBounds);
//##Documentation
//## @brief Set the time bounds (in ms)
virtual void SetTimeBounds(const TimeBounds& timebounds);
//##Documentation
//## @brief Get the position of the corner number \a id (in world coordinates)
//##
//## See SetImageGeometry for how a corner is defined on images.
Point3D GetCornerPoint(int id) const;
//##Documentation
//## @brief Get the position of a corner (in world coordinates)
//##
//## See SetImageGeometry for how a corner is defined on images.
Point3D GetCornerPoint(bool xFront=true, bool yFront=true, bool zFront=true) const;
//##Documentation
//## @brief Get vector along bounding-box in the specified @a direction in mm
//##
//## The length of the vector is the size of the bounding-box in the
//## specified @a direction in mm
//## \sa GetMatrixColumn
Vector3D GetAxisVector(unsigned int direction) const
{
Vector3D frontToBack;
frontToBack.SetVnlVector(m_IndexToWorldTransform->GetMatrix().GetVnlMatrix().get_column(direction));
frontToBack *= GetExtent(direction);
return frontToBack;
}
//##Documentation
//## @brief Get the center of the bounding-box in mm
//##
Point3D GetCenter() const
{
assert(m_BoundingBox.IsNotNull());
return m_IndexToWorldTransform->TransformPoint(m_BoundingBox->GetCenter());
}
//##Documentation
//## @brief Get the squared length of the diagonal of the bounding-box in mm
//##
double GetDiagonalLength2() const
{
Vector3D diagonalvector = GetCornerPoint()-GetCornerPoint(false, false, false);
return diagonalvector.GetSquaredNorm();
}
//##Documentation
//## @brief Get the length of the diagonal of the bounding-box in mm
//##
double GetDiagonalLength() const
{
return sqrt(GetDiagonalLength2());
}
//##Documentation
//## @brief Get a VnlVector along bounding-box in the specified
//## @a direction, length is spacing
//##
//## \sa GetAxisVector
VnlVector GetMatrixColumn(unsigned int direction) const
{
return m_IndexToWorldTransform->GetMatrix().GetVnlMatrix().get_column(direction);
}
#ifdef DOXYGEN_SKIP
//##Documentation
//## @brief Get the extent of the bounding box (in index/unit coordinates)
//##
//## To access the extent in mm use GetExtentInMM
ScalarType GetExtent(unsigned int direction) const;
#endif
//##Documentation
//## @brief Get the extent of the bounding-box in the specified @a direction in mm
//##
//## Equals length of GetAxisVector(direction).
ScalarType GetExtentInMM(int direction) const
{
return m_IndexToWorldTransform->GetMatrix().GetVnlMatrix().get_column(direction).magnitude()*GetExtent(direction);
}
//##Documentation
//## @brief Set the extent of the bounding-box in the specified @a direction in mm
//##
//## @note This changes the matrix in the transform, @a not the bounds, which are given in units!
virtual void SetExtentInMM(int direction, ScalarType extentInMM);
//##Documentation
//## @brief Get the m_IndexToWorldTransform as a vtkLinearTransform
vtkLinearTransform* GetVtkTransform() const
{
return (vtkLinearTransform*)m_VtkIndexToWorldTransform;
}
//##Documentation
//## @brief Set the origin, i.e. the upper-left corner of the plane
//##
virtual void SetOrigin(const Point3D& origin);
//##Documentation
//## @brief Translate the origin by a vector
//##
virtual void Translate(const Vector3D& vector);
//##Documentation
//## @brief Set the transform to identity
//##
virtual void SetIdentity();
//##Documentation
//## @brief Compose new IndexToWorldTransform with a given transform.
//##
//## This method composes m_IndexToWorldTransform with another transform,
//## modifying self to be the composition of self and other.
//## If the argument pre is true, then other is precomposed with self;
//## that is, the resulting transformation consists of first applying
//## other to the source, followed by self. If pre is false or omitted,
//## then other is post-composed with self; that is the resulting
//## transformation consists of first applying self to the source,
//## followed by other.
virtual void Compose( const Geometry3D::TransformType * other, bool pre = 0 );
//##Documentation
//## @brief Compose new IndexToWorldTransform with a given vtkMatrix4x4.
//##
//## Converts the vtkMatrix4x4 into a itk-transform and calls the previous method.
virtual void Compose( const vtkMatrix4x4 * vtkmatrix, bool pre = 0 );
//##Documentation
//## @brief Get the origin, e.g. the upper-left corner of the plane
const Point3D& GetOrigin() const
{
return m_Origin;
}
//##Documentation
//## @brief Get the origin as VnlVector
//##
//## \sa GetOrigin
VnlVector GetOriginVnl() const
{
return const_cast<Self*>(this)->m_Origin.GetVnlVector();
}
//##Documentation
//## @brief Convert world coordinates (in mm) of a \em point to (continuous!) index coordinates
//## \warning If you need (discrete) integer index coordinates (e.g., for iterating easily over an image),
//## use WorldToIndex(const mitk::Point3D& pt_mm, itk::Index<VIndexDimension> &index).
//## For further information about coordinates types, please see the Geometry documentation
void WorldToIndex(const mitk::Point3D& pt_mm, mitk::Point3D& pt_units) const;
//##Documentation
//## @brief Convert (continuous or discrete) index coordinates of a \em point to world coordinates (in mm)
//## For further information about coordinates types, please see the Geometry documentation
void IndexToWorld(const mitk::Point3D& pt_units, mitk::Point3D& pt_mm) const;
//##Documentation
//## @brief Convert world coordinates (in mm) of a \em vector
//## \a vec_mm to (continuous!) index coordinates.
//## @deprecated First parameter (Point3D) is not used. If possible, please use void WorldToIndex(const mitk::Vector3D& vec_mm, mitk::Vector3D& vec_units) const.
//## For further information about coordinates types, please see the Geometry documentation
void WorldToIndex(const mitk::Point3D& atPt3d_mm, const mitk::Vector3D& vec_mm, mitk::Vector3D& vec_units) const;
//##Documentation
//## @brief Convert world coordinates (in mm) of a \em vector
//## \a vec_mm to (continuous!) index coordinates.
//## For further information about coordinates types, please see the Geometry documentation
void WorldToIndex(const mitk::Vector3D& vec_mm, mitk::Vector3D& vec_units) const;
//##Documentation
//## @brief Convert (continuous or discrete) index coordinates of a \em vector
//## \a vec_units to world coordinates (in mm)
//## @deprecated First parameter (Point3D) is not used. If possible, please use void IndexToWorld(const mitk::Vector3D& vec_units, mitk::Vector3D& vec_mm) const.
//## For further information about coordinates types, please see the Geometry documentation
void IndexToWorld(const mitk::Point3D& atPt3d_units, const mitk::Vector3D& vec_units, mitk::Vector3D& vec_mm) const;
//##Documentation
//## @brief Convert (continuous or discrete) index coordinates of a \em vector
//## \a vec_units to world coordinates (in mm)
//## For further information about coordinates types, please see the Geometry documentation
void IndexToWorld(const mitk::Vector3D& vec_units, mitk::Vector3D& vec_mm) const;
//##Documentation
//## @brief Convert world coordinates (in mm) of a \em point to (discrete!) index coordinates.
//## This method rounds to integer indices!
//## For further information about coordinates types, please see the Geometry documentation
template <unsigned int VIndexDimension>
void WorldToIndex(const mitk::Point3D& pt_mm, itk::Index<VIndexDimension> &index) const
{
typedef itk::Index<VIndexDimension> IndexType;
mitk::Point3D pt_units;
this->WorldToIndex(pt_mm, pt_units);
int i, dim=index.GetIndexDimension();
if(dim>3)
{
index.Fill(0);
dim=3;
}
for(i=0;i<dim;++i){
index[i]=itk::Math::RoundHalfIntegerUp<typename IndexType::IndexValueType>( pt_units[i] );
}
}
//##Documentation
//## @brief Deprecated for use with ITK version 3.10 or newer.
//## Convert world coordinates (in mm) of a \em point to
//## ITK physical coordinates (in mm, but without a possible rotation)
//##
//## This method is useful if you have want to access an mitk::Image
//## via an itk::Image. ITK v3.8 and older did not support rotated (tilted)
//## images, i.e., ITK images are always parallel to the coordinate axes.
//## When accessing a (possibly rotated) mitk::Image via an itk::Image
//## the rotational part of the transformation in the Geometry3D is
//## simply discarded; in other word: only the origin and spacing is
//## used by ITK, not the complete matrix available in MITK.
//## With WorldToItkPhysicalPoint you can convert an MITK world
//## coordinate (including the rotation) into a coordinate that
//## can be used with the ITK image as a ITK physical coordinate
//## (excluding the rotation).
template<class TCoordRep>
void WorldToItkPhysicalPoint(const mitk::Point3D& pt_mm,
itk::Point<TCoordRep, 3>& itkPhysicalPoint) const
{
mitk::vtk2itk(pt_mm, itkPhysicalPoint);
}
//##Documentation
//## @brief Deprecated for use with ITK version 3.10 or newer.
//## Convert ITK physical coordinates of a \em point (in mm,
//## but without a rotation) into MITK world coordinates (in mm)
//##
//## For more information, see WorldToItkPhysicalPoint.
template<class TCoordRep>
void ItkPhysicalPointToWorld(const itk::Point<TCoordRep, 3>& itkPhysicalPoint,
mitk::Point3D& pt_mm) const
{
mitk::vtk2itk(itkPhysicalPoint, pt_mm);
}
//##Documentation
//## @brief Initialize the Geometry3D
virtual void Initialize();
//##Documentation
//## @brief Is this an ImageGeometry?
//##
//## For more information, see SetImageGeometry
itkGetConstMacro(ImageGeometry, bool);
//##Documentation
//## @brief Define that this Geometry3D is refering to an Image
//##
//## A geometry referring to an Image needs a slightly different
//## definition of the position of the corners (see GetCornerPoint).
//## The position of a voxel is defined by the position of its center.
//## If we would use the origin (position of the (center of) the first
//## voxel) as a corner and display this point, it would seem to be
//## \em not at the corner but a bit within the image. Even worse for
//## the opposite corner of the image: here the corner would appear
//## outside the image (by half of the voxel diameter). Thus, we have
//## to correct for this and to be able to do that, we need to know
//## that the Geometry3D is referring to an Image.
itkSetMacro(ImageGeometry, bool);
itkBooleanMacro(ImageGeometry);
//##Documentation
//## @brief Is this Geometry3D in a state that is valid?
virtual bool IsValid() const
{
return m_Valid;
}
//##Documentation
//## @brief Test whether the point \a p (world coordinates in mm) is
//## inside the bounding box
bool IsInside(const mitk::Point3D& p) const
{
mitk::Point3D index;
WorldToIndex(p, index);
return IsIndexInside(index);
}
//##Documentation
//## @brief Test whether the point \a p ((continous!)index coordinates in units) is
//## inside the bounding box
bool IsIndexInside(const mitk::Point3D& index) const
{
bool inside = false;
//if it is an image geometry, we need to convert the index to discrete values
//this is done by applying the rounding function also used in WorldToIndex (see line 323)
if (m_ImageGeometry)
{
mitk::Point3D discretIndex;
discretIndex[0]=itk::Math::RoundHalfIntegerUp<mitk::ScalarType>( index[0] );
discretIndex[1]=itk::Math::RoundHalfIntegerUp<mitk::ScalarType>( index[1] );
discretIndex[2]=itk::Math::RoundHalfIntegerUp<mitk::ScalarType>( index[2] );
inside = m_BoundingBox->IsInside(discretIndex);
//we have to check if the index is at the upper border of each dimension,
// because the boundingbox is not centerbased
if (inside)
{
const BoundingBox::BoundsArrayType& bounds = m_BoundingBox->GetBounds();
if((discretIndex[0] == bounds[1]) ||
(discretIndex[1] == bounds[3]) ||
(discretIndex[2] == bounds[5]))
inside = false;
}
}
else
inside = m_BoundingBox->IsInside(index);
return inside;
}
//##Documentation
//## @brief Convenience method for working with ITK indices
template <unsigned int VIndexDimension>
bool IsIndexInside(const itk::Index<VIndexDimension> &index) const
{
int i, dim=index.GetIndexDimension();
Point3D pt_index;
pt_index.Fill(0);
for ( i = 0; i < dim; ++i )
{
pt_index[i] = index[i];
}
return IsIndexInside(pt_index);
}
//##Documentation
//## @brief Get the spacing (size of a pixel).
//##
itkGetConstReferenceMacro(Spacing, mitk::Vector3D);
//##Documentation
//## @brief Get the spacing as a float[3] array.
const float* GetFloatSpacing() const;
//##Documentation
//## @brief Set the spacing (m_Spacing)
virtual void SetSpacing(const mitk::Vector3D& aSpacing);
//##Documentation
//## @brief Get the DICOM FrameOfReferenceID referring to the
//## used world coordinate system
itkGetConstMacro(FrameOfReferenceID, unsigned int);
//##Documentation
//## @brief Set the DICOM FrameOfReferenceID referring to the
//## used world coordinate system
itkSetMacro(FrameOfReferenceID, unsigned int);
//##Documentation
//## @brief Copy the ITK transform
//## (m_IndexToWorldTransform) to the VTK transform
//## \sa SetIndexToWorldTransform
void TransferItkToVtkTransform();
//##Documentation
//## @brief Copy the VTK transform
//## to the ITK transform (m_IndexToWorldTransform)
//## \sa SetIndexToWorldTransform
void TransferVtkToItkTransform();
//##Documentation
//## @brief Get the parametric bounding-box
//##
//## See AbstractTransformGeometry for an example usage of this.
itkGetConstObjectMacro(ParametricBoundingBox, BoundingBox);
//##Documentation
//## @brief Get the parametric bounds
//##
//## See AbstractTransformGeometry for an example usage of this.
const BoundingBox::BoundsArrayType& GetParametricBounds() const
{
assert(m_ParametricBoundingBox.IsNotNull());
return m_ParametricBoundingBox->GetBounds();
}
//##Documentation
//## @brief Get the parametric extent
//##
//## See AbstractTransformGeometry for an example usage of this.
mitk::ScalarType GetParametricExtent(int direction) const
{
if (direction < 0 || direction>=3)
mitkThrow() << "Invalid direction. Must be between either 0, 1 or 2. ";
assert(m_ParametricBoundingBox.IsNotNull());
BoundingBoxType::BoundsArrayType bounds = m_ParametricBoundingBox->GetBounds();
return bounds[direction*2+1]-bounds[direction*2];
}
//##Documentation
//## @brief Get the parametric extent in mm
//##
//## See AbstractTransformGeometry for an example usage of this.
virtual mitk::ScalarType GetParametricExtentInMM(int direction) const
{
return GetExtentInMM(direction);
}
//##Documentation
//## @brief Get the parametric transform
//##
//## See AbstractTransformGeometry for an example usage of this.
virtual const Transform3D* GetParametricTransform() const
{
return m_IndexToWorldTransform;
}
//##Documentation
//## @brief Calculates a bounding-box around the geometry relative
//## to a coordinate system defined by a transform
//##
mitk::BoundingBox::Pointer CalculateBoundingBoxRelativeToTransform(const mitk::AffineTransform3D* transform) const;
//##Documentation
//## @brief clones the geometry
//##
//## Overwrite in all sub-classes.
//## Normally looks like:
//## \code
//## Self::Pointer newGeometry = new Self(*this);
//## newGeometry->UnRegister();
//## return newGeometry.GetPointer();
//## \endcode
virtual itk::LightObject::Pointer InternalClone() const;
//##Documentation
//##@brief executes affine operations (translate, rotate, scale)
virtual void ExecuteOperation(Operation* operation);
/** Set/Get the IndexToWorldTransform */
itkGetConstObjectMacro(IndexToWorldTransform, AffineTransform3D);
itkGetObjectMacro(IndexToWorldTransform, AffineTransform3D);
/** Get the bounding box */
itkGetConstObjectMacro(BoundingBox, BoundingBoxType);
const BoundsArrayType GetBounds() const
{
assert(m_BoundingBox.IsNotNull());
return m_BoundingBox->GetBounds();
}
/** Get the extent of the bounding box */
ScalarType GetExtent(unsigned int direction) const
{
assert(m_BoundingBox.IsNotNull());
if (direction>=NDimensions)
- mitkThrow() << "Direction is too big. This geometry is for " << NDimensions << " Data";
+ mitkThrow() << "Direction is too big. This geometry is for 3D Data";
BoundsArrayType bounds = m_BoundingBox->GetBounds();
return bounds[direction*2+1]-bounds[direction*2];
}
protected:
Geometry3D();
Geometry3D(const Geometry3D& other);
virtual void InitializeGeometry(Self * newGeometry) const;
static const std::string GetTransformAsString( TransformType* transformType );
static const unsigned int NDimensions = 3;
virtual ~Geometry3D();
virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
virtual void BackTransform(const mitk::Point3D& in, mitk::Point3D& out) const;
//##Documentation
//## @brief Deprecated
virtual void BackTransform(const mitk::Point3D& at, const mitk::Vector3D& in, mitk::Vector3D& out) const;
//Without redundant parameter Point3D
virtual void BackTransform(const mitk::Vector3D& in, mitk::Vector3D& out) const;
//##Documentation
//## @brief Set the parametric bounds
//##
//## Protected in this class, made public in some sub-classes, e.g.,
//## ExternAbstractTransformGeometry.
virtual void SetParametricBounds(const BoundingBox::BoundsArrayType& bounds);
/** Resets sub-transforms that compose m_IndexToWorldTransform, by using
* the current value of m_IndexToWorldTransform and setting the rotation
* component to zero. */
virtual void ResetSubTransforms();
mutable mitk::BoundingBox::Pointer m_ParametricBoundingBox;
mutable mitk::TimeBounds m_TimeBounds;
vtkMatrix4x4* m_VtkMatrix;
bool m_ImageGeometry;
AffineTransform3D::Pointer m_IndexToWorldTransform;
mutable BoundingBoxPointer m_BoundingBox;
//##Documentation
//## @brief Spacing of the data. Only significant if the geometry describes
//## an Image (m_ImageGeometry==true).
mitk::Vector3D m_Spacing;
bool m_Valid;
unsigned int m_FrameOfReferenceID;
static const std::string INDEX_TO_OBJECT_TRANSFORM;
static const std::string OBJECT_TO_NODE_TRANSFORM;
static const std::string INDEX_TO_NODE_TRANSFORM;
static const std::string INDEX_TO_WORLD_TRANSFORM;
private:
mutable TransformType::Pointer m_InvertedTransform;
mutable unsigned long m_IndexToWorldTransformLastModified;
VnlQuaternionType m_RotationQuaternion;
float m_FloatSpacing[3];
vtkMatrixToLinearTransform* m_VtkIndexToWorldTransform;
//##Documentation
//## @brief Origin, i.e. upper-left corner of the plane
//##
Point3D m_Origin;
};
//
// Static compare functions mainly for testing
//
/**
* @brief Equal A function comparing two geometries for beeing identical.
*
* @ingroup MITKTestingAPI
*
* The function compares the spacing, origin, axisvectors, extents, the matrix of the
* IndexToWorldTransform (elementwise), the bounding (elementwise) and the ImageGeometry flag.
*
* The parameter eps is a tolarence value for all methods which are internally used for comparion.
* If you want to use different tolarance values for different parts of the geometry, feel free to use
* the other comparison methods and write your own implementation of Equal.
* @param rightHandSide Compare this against leftHandSide.
* @param leftHandSide Compare this against rightHandSide.
* @param eps Tolarence for comparison. You can use mitk::eps in most cases.
* @param verbose Flag indicating if the user wants detailed console output or not.
* @return True, if all comparison are true. False in any other case.
*/
MITK_CORE_EXPORT bool Equal(const mitk::Geometry3D* leftHandSide, const mitk::Geometry3D* rightHandSide, ScalarType eps, bool verbose);
/**
* @brief Equal A function comparing two transforms (TransformType) for beeing identical.
*
* @ingroup MITKTestingAPI
*
* The function compares the IndexToWorldTransform (elementwise).
*
* The parameter eps is a tolarence value for all methods which are internally used for comparion.
* @param rightHandSide Compare this against leftHandSide.
* @param leftHandSide Compare this against rightHandSide.
* @param eps Tolarence for comparison. You can use mitk::eps in most cases.
* @param verbose Flag indicating if the user wants detailed console output or not.
* @return True, if all comparison are true. False in any other case.
*/
MITK_CORE_EXPORT bool Equal(const mitk::Geometry3D::TransformType *leftHandSide, const mitk::Geometry3D::TransformType *rightHandSide, ScalarType eps, bool verbose);
/**
* @brief Equal A function comparing two bounding boxes (BoundingBoxType) for beeing identical.
*
* @ingroup MITKTestingAPI
*
* The function compares the bounds (elementwise).
*
* The parameter eps is a tolarence value for all methods which are internally used for comparion.
* @param rightHandSide Compare this against leftHandSide.
* @param leftHandSide Compare this against rightHandSide.
* @param eps Tolarence for comparison. You can use mitk::eps in most cases.
* @param verbose Flag indicating if the user wants detailed console output or not.
* @return True, if all comparison are true. False in any other case.
*/
MITK_CORE_EXPORT bool Equal( const mitk::Geometry3D::BoundingBoxType *leftHandSide, const mitk::Geometry3D::BoundingBoxType *rightHandSide, ScalarType eps, bool verbose);
} // namespace mitk
#endif /* GEOMETRY3D_H_HEADER_INCLUDED_C1EBD0AD */
diff --git a/Core/Code/DataManagement/mitkImage.cpp b/Core/Code/DataManagement/mitkImage.cpp
index a657bb0c66..fee317f520 100644
--- a/Core/Code/DataManagement/mitkImage.cpp
+++ b/Core/Code/DataManagement/mitkImage.cpp
@@ -1,1383 +1,1383 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
//MITK
#include "mitkImage.h"
#include "mitkImageStatisticsHolder.h"
#include "mitkPixelTypeMultiplex.h"
#include <mitkProportionalTimeGeometry.h>
#include "mitkCompareImageFilter.h"
//VTK
#include <vtkImageData.h>
//Other
#include <cmath>
#define FILL_C_ARRAY( _arr, _size, _value) for(unsigned int i=0u; i<_size; i++) \
{ _arr[i] = _value; }
mitk::Image::Image() :
m_Dimension(0), m_Dimensions(NULL), m_ImageDescriptor(NULL), m_OffsetTable(NULL), m_CompleteData(NULL),
m_ImageStatistics(NULL)
{
m_Dimensions = new unsigned int[MAX_IMAGE_DIMENSIONS];
FILL_C_ARRAY( m_Dimensions, MAX_IMAGE_DIMENSIONS, 0u);
m_Initialized = false;
}
mitk::Image::Image(const Image &other) : SlicedData(other), m_Dimension(0), m_Dimensions(NULL),
m_ImageDescriptor(NULL), m_OffsetTable(NULL), m_CompleteData(NULL), m_ImageStatistics(NULL)
{
m_Dimensions = new unsigned int[MAX_IMAGE_DIMENSIONS];
FILL_C_ARRAY( m_Dimensions, MAX_IMAGE_DIMENSIONS, 0u);
this->Initialize( other.GetPixelType(), other.GetDimension(), other.GetDimensions());
//Since the above called "Initialize" method doesn't take the geometry into account we need to set it
//here manually
TimeGeometry::Pointer cloned = other.GetTimeGeometry()->Clone();
this->SetTimeGeometry(cloned.GetPointer());
if (this->GetDimension() > 3)
{
const unsigned int time_steps = this->GetDimension(3);
for (unsigned int i = 0u; i < time_steps; ++i)
{
ImageDataItemPointer volume = const_cast<Image&>(other).GetVolumeData(i);
this->SetVolume(volume->GetData(), i);
}
}
else
{
ImageDataItemPointer volume = const_cast<Image&>(other).GetVolumeData(0);
this->SetVolume(volume->GetData(), 0);
}
}
mitk::Image::~Image()
{
Clear();
m_ReferenceCountLock.Lock();
m_ReferenceCount = 3;
m_ReferenceCountLock.Unlock();
m_ReferenceCountLock.Lock();
m_ReferenceCount = 0;
m_ReferenceCountLock.Unlock();
if(m_OffsetTable != NULL)
delete [] m_OffsetTable;
if(m_ImageStatistics != NULL)
delete m_ImageStatistics;
}
const mitk::PixelType mitk::Image::GetPixelType(int n) const
{
return this->m_ImageDescriptor->GetChannelTypeById(n);
}
unsigned int mitk::Image::GetDimension() const
{
return m_Dimension;
}
unsigned int mitk::Image::GetDimension(int i) const
{
if((i>=0) && (i<(int)m_Dimension))
return m_Dimensions[i];
return 1;
}
void* mitk::Image::GetData()
{
if(m_Initialized==false)
{
if(GetSource().IsNull())
return NULL;
if(GetSource()->Updating()==false)
GetSource()->UpdateOutputInformation();
}
m_CompleteData=GetChannelData();
// update channel's data
// if data was not available at creation point, the m_Data of channel descriptor is NULL
// if data present, it won't be overwritten
m_ImageDescriptor->GetChannelDescriptor(0).SetData(m_CompleteData->GetData());
return m_CompleteData->GetData();
}
template <class T>
void AccessPixel( const mitk::PixelType ptype, void* data, const unsigned int offset, double& value )
{
value = 0.0;
if( data == NULL ) return;
if(ptype.GetBpe() != 24)
{
value = (double) (((T*) data)[ offset ]);
}
else
{
const unsigned int rgboffset = 3 * offset;
double returnvalue = (((T*) data)[rgboffset ]);
returnvalue += (((T*) data)[rgboffset + 1]);
returnvalue += (((T*) data)[rgboffset + 2]);
value = returnvalue;
}
}
double mitk::Image::GetPixelValueByIndex(const mitk::Index3D &position, unsigned int timestep)
{
double value = 0;
if (this->GetTimeSteps() < timestep)
{
timestep = this->GetTimeSteps();
}
value = 0.0;
const unsigned int* imageDims = this->m_ImageDescriptor->GetDimensions();
const mitk::PixelType ptype = this->m_ImageDescriptor->GetChannelTypeById(0);
// Comparison ?>=0 not needed since all position[i] and timestep are unsigned int
// (position[0]>=0 && position[1] >=0 && position[2]>=0 && timestep>=0)
// bug-11978 : we still need to catch index with negative values
if ( position[0] < 0 ||
position[1] < 0 ||
position[2] < 0 )
{
MITK_WARN << "Given position ("<< position << ") is out of image range, returning 0." ;
}
// check if the given position is inside the index range of the image, the 3rd dimension needs to be compared only if the dimension is not 0
else if ( (unsigned int)position[0] >= imageDims[0] ||
(unsigned int)position[1] >= imageDims[1] ||
( imageDims[2] && (unsigned int)position[2] >= imageDims[2] ))
{
MITK_WARN << "Given position ("<< position << ") is out of image range, returning 0." ;
}
else
{
const unsigned int offset = position[0] + position[1]*imageDims[0] + position[2]*imageDims[0]*imageDims[1] + timestep*imageDims[0]*imageDims[1]*imageDims[2];
mitkPixelTypeMultiplex3( AccessPixel, ptype, this->GetData(), offset, value );
}
return value;
}
double mitk::Image::GetPixelValueByWorldCoordinate(const mitk::Point3D& position, unsigned int timestep)
{
double value = 0.0;
if (this->GetTimeSteps() < timestep)
{
timestep = this->GetTimeSteps();
}
Index3D itkIndex;
this->GetGeometry()->WorldToIndex(position, itkIndex);
value = this->GetPixelValueByIndex( itkIndex, timestep);
return value;
}
mitk::ImageVtkAccessor* mitk::Image::GetVtkImageData(int t, int n)
{
if(m_Initialized==false)
{
if(GetSource().IsNull())
return NULL;
if(GetSource()->Updating()==false)
GetSource()->UpdateOutputInformation();
}
ImageDataItemPointer volume=GetVolumeData(t, n);
if(volume.GetPointer()==NULL || volume->GetVtkImageData(this) == NULL)
return NULL;
SlicedGeometry3D* geom3d = GetSlicedGeometry(t);
float *fspacing = const_cast<float *>(geom3d->GetFloatSpacing());
double dspacing[3] = {fspacing[0],fspacing[1],fspacing[2]};
volume->GetVtkImageData(this)->SetSpacing( dspacing );
return volume->GetVtkImageData(this);
}
mitk::Image::ImageDataItemPointer mitk::Image::GetSliceData(int s, int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
{
if(IsValidSlice(s,t,n)==false) return NULL;
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
// slice directly available?
int pos=GetSliceIndex(s,t,n);
if(m_Slices[pos].GetPointer()!=NULL)
return m_Slices[pos];
// is slice available as part of a volume that is available?
ImageDataItemPointer sl, ch, vol;
vol=m_Volumes[GetVolumeIndex(t,n)];
if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
{
sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*m_OffsetTable[2]*(ptypeSize));
sl->SetComplete(true);
return m_Slices[pos]=sl;
}
// is slice available as part of a channel that is available?
ch=m_Channels[n];
if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
{
sl=new ImageDataItem(*ch, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, (((size_t) s)*m_OffsetTable[2]+((size_t) t)*m_OffsetTable[3])*(ptypeSize));
sl->SetComplete(true);
return m_Slices[pos]=sl;
}
// slice is unavailable. Can we calculate it?
if((GetSource().IsNotNull()) && (GetSource()->Updating()==false))
{
// ... wir mussen rechnen!!! ....
m_RequestedRegion.SetIndex(0, 0);
m_RequestedRegion.SetIndex(1, 0);
m_RequestedRegion.SetIndex(2, s);
m_RequestedRegion.SetIndex(3, t);
m_RequestedRegion.SetIndex(4, n);
m_RequestedRegion.SetSize(0, m_Dimensions[0]);
m_RequestedRegion.SetSize(1, m_Dimensions[1]);
m_RequestedRegion.SetSize(2, 1);
m_RequestedRegion.SetSize(3, 1);
m_RequestedRegion.SetSize(4, 1);
m_RequestedRegionInitialized=true;
GetSource()->Update();
if(IsSliceSet(s,t,n))
//yes: now we can call ourselves without the risk of a endless loop (see "if" above)
return GetSliceData(s,t,n,data,importMemoryManagement);
else
return NULL;
}
else
{
ImageDataItemPointer item = AllocateSliceData(s,t,n,data,importMemoryManagement);
item->SetComplete(true);
return item;
}
}
mitk::Image::ImageDataItemPointer mitk::Image::GetVolumeData(int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
{
if(IsValidVolume(t,n)==false) return NULL;
ImageDataItemPointer ch, vol;
// volume directly available?
int pos=GetVolumeIndex(t,n);
vol=m_Volumes[pos];
if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
return vol;
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
// is volume available as part of a channel that is available?
ch=m_Channels[n];
if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
{
vol=new ImageDataItem(*ch, m_ImageDescriptor, 3, data, importMemoryManagement == ManageMemory, (((size_t) t)*m_OffsetTable[3])*(ptypeSize));
vol->SetComplete(true);
return m_Volumes[pos]=vol;
}
// let's see if all slices of the volume are set, so that we can (could) combine them to a volume
bool complete=true;
unsigned int s;
for(s=0;s<m_Dimensions[2];++s)
{
if(m_Slices[GetSliceIndex(s,t,n)].GetPointer()==NULL)
{
complete=false;
break;
}
}
if(complete)
{
// if there is only single slice we do not need to combine anything
if(m_Dimensions[2]<=1)
{
ImageDataItemPointer sl;
sl=GetSliceData(0,t,n,data,importMemoryManagement);
vol=new ImageDataItem(*sl, m_ImageDescriptor, 3, data, importMemoryManagement == ManageMemory);
vol->SetComplete(true);
}
else
{
mitk::PixelType chPixelType = this->m_ImageDescriptor->GetChannelTypeById(n);
vol=m_Volumes[pos];
// ok, let's combine the slices!
if(vol.GetPointer()==NULL)
vol=new ImageDataItem( chPixelType, 3, m_Dimensions, NULL, true);
vol->SetComplete(true);
size_t size=m_OffsetTable[2]*(ptypeSize);
for(s=0;s<m_Dimensions[2];++s)
{
int posSl;
ImageDataItemPointer sl;
posSl=GetSliceIndex(s,t,n);
sl=m_Slices[posSl];
if(sl->GetParent()!=vol)
{
// copy data of slices in volume
size_t offset = ((size_t) s)*size;
std::memcpy(static_cast<char*>(vol->GetData())+offset, sl->GetData(), size);
// FIXME mitkIpPicDescriptor * pic = sl->GetPicDescriptor();
// replace old slice with reference to volume
sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*size);
sl->SetComplete(true);
//mitkIpFuncCopyTags(sl->GetPicDescriptor(), pic);
m_Slices[posSl]=sl;
}
}
//if(vol->GetPicDescriptor()->info->tags_head==NULL)
// mitkIpFuncCopyTags(vol->GetPicDescriptor(), m_Slices[GetSliceIndex(0,t,n)]->GetPicDescriptor());
}
return m_Volumes[pos]=vol;
}
// volume is unavailable. Can we calculate it?
if((GetSource().IsNotNull()) && (GetSource()->Updating()==false))
{
// ... wir muessen rechnen!!! ....
m_RequestedRegion.SetIndex(0, 0);
m_RequestedRegion.SetIndex(1, 0);
m_RequestedRegion.SetIndex(2, 0);
m_RequestedRegion.SetIndex(3, t);
m_RequestedRegion.SetIndex(4, n);
m_RequestedRegion.SetSize(0, m_Dimensions[0]);
m_RequestedRegion.SetSize(1, m_Dimensions[1]);
m_RequestedRegion.SetSize(2, m_Dimensions[2]);
m_RequestedRegion.SetSize(3, 1);
m_RequestedRegion.SetSize(4, 1);
m_RequestedRegionInitialized=true;
GetSource()->Update();
if(IsVolumeSet(t,n))
//yes: now we can call ourselves without the risk of a endless loop (see "if" above)
return GetVolumeData(t,n,data,importMemoryManagement);
else
return NULL;
}
else
{
ImageDataItemPointer item = AllocateVolumeData(t,n,data,importMemoryManagement);
item->SetComplete(true);
return item;
}
}
mitk::Image::ImageDataItemPointer mitk::Image::GetChannelData(int n, void *data, ImportMemoryManagementType importMemoryManagement)
{
if(IsValidChannel(n)==false) return NULL;
ImageDataItemPointer ch, vol;
ch=m_Channels[n];
if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
return ch;
// let's see if all volumes are set, so that we can (could) combine them to a channel
if(IsChannelSet(n))
{
// if there is only one time frame we do not need to combine anything
if(m_Dimensions[3]<=1)
{
vol=GetVolumeData(0,n,data,importMemoryManagement);
ch=new ImageDataItem(*vol, m_ImageDescriptor, m_ImageDescriptor->GetNumberOfDimensions(), data, importMemoryManagement == ManageMemory);
ch->SetComplete(true);
}
else
{
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
ch=m_Channels[n];
// ok, let's combine the volumes!
if(ch.GetPointer()==NULL)
ch=new ImageDataItem(this->m_ImageDescriptor, NULL, true);
ch->SetComplete(true);
size_t size=m_OffsetTable[m_Dimension-1]*(ptypeSize);
unsigned int t;
ImageDataItemPointerArray::iterator slicesIt = m_Slices.begin()+n*m_Dimensions[2]*m_Dimensions[3];
for(t=0;t<m_Dimensions[3];++t)
{
int posVol;
ImageDataItemPointer vol;
posVol=GetVolumeIndex(t,n);
vol=GetVolumeData(t,n,data,importMemoryManagement);
if(vol->GetParent()!=ch)
{
// copy data of volume in channel
size_t offset = ((size_t) t)*m_OffsetTable[3]*(ptypeSize);
std::memcpy(static_cast<char*>(ch->GetData())+offset, vol->GetData(), size);
// REVEIW FIX mitkIpPicDescriptor * pic = vol->GetPicDescriptor();
// replace old volume with reference to channel
vol=new ImageDataItem(*ch, m_ImageDescriptor, 3, data, importMemoryManagement == ManageMemory, offset);
vol->SetComplete(true);
//mitkIpFuncCopyTags(vol->GetPicDescriptor(), pic);
m_Volumes[posVol]=vol;
// get rid of slices - they may point to old volume
ImageDataItemPointer dnull=NULL;
for(unsigned int i = 0; i < m_Dimensions[2]; ++i, ++slicesIt)
{
assert(slicesIt != m_Slices.end());
*slicesIt = dnull;
}
}
}
// REVIEW FIX
// if(ch->GetPicDescriptor()->info->tags_head==NULL)
// mitkIpFuncCopyTags(ch->GetPicDescriptor(), m_Volumes[GetVolumeIndex(0,n)]->GetPicDescriptor());
}
return m_Channels[n]=ch;
}
// channel is unavailable. Can we calculate it?
if((GetSource().IsNotNull()) && (GetSource()->Updating()==false))
{
// ... wir muessen rechnen!!! ....
m_RequestedRegion.SetIndex(0, 0);
m_RequestedRegion.SetIndex(1, 0);
m_RequestedRegion.SetIndex(2, 0);
m_RequestedRegion.SetIndex(3, 0);
m_RequestedRegion.SetIndex(4, n);
m_RequestedRegion.SetSize(0, m_Dimensions[0]);
m_RequestedRegion.SetSize(1, m_Dimensions[1]);
m_RequestedRegion.SetSize(2, m_Dimensions[2]);
m_RequestedRegion.SetSize(3, m_Dimensions[3]);
m_RequestedRegion.SetSize(4, 1);
m_RequestedRegionInitialized=true;
GetSource()->Update();
// did it work?
if(IsChannelSet(n))
//yes: now we can call ourselves without the risk of a endless loop (see "if" above)
return GetChannelData(n,data,importMemoryManagement);
else
return NULL;
}
else
{
ImageDataItemPointer item = AllocateChannelData(n,data,importMemoryManagement);
item->SetComplete(true);
return item;
}
}
bool mitk::Image::IsSliceSet(int s, int t, int n) const
{
if(IsValidSlice(s,t,n)==false) return false;
if(m_Slices[GetSliceIndex(s,t,n)].GetPointer()!=NULL)
return true;
ImageDataItemPointer ch, vol;
vol=m_Volumes[GetVolumeIndex(t,n)];
if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
return true;
ch=m_Channels[n];
if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
return true;
return false;
}
bool mitk::Image::IsVolumeSet(int t, int n) const
{
if(IsValidVolume(t,n)==false) return false;
ImageDataItemPointer ch, vol;
// volume directly available?
vol=m_Volumes[GetVolumeIndex(t,n)];
if((vol.GetPointer()!=NULL) && (vol->IsComplete()))
return true;
// is volume available as part of a channel that is available?
ch=m_Channels[n];
if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
return true;
// let's see if all slices of the volume are set, so that we can (could) combine them to a volume
unsigned int s;
for(s=0;s<m_Dimensions[2];++s)
if(m_Slices[GetSliceIndex(s,t,n)].GetPointer()==NULL)
return false;
return true;
}
bool mitk::Image::IsChannelSet(int n) const
{
if(IsValidChannel(n)==false) return false;
ImageDataItemPointer ch, vol;
ch=m_Channels[n];
if((ch.GetPointer()!=NULL) && (ch->IsComplete()))
return true;
// let's see if all volumes are set, so that we can (could) combine them to a channel
unsigned int t;
for(t=0;t<m_Dimensions[3];++t)
if(IsVolumeSet(t,n)==false)
return false;
return true;
}
bool mitk::Image::SetSlice(const void *data, int s, int t, int n)
{
// const_cast is no risk for ImportMemoryManagementType == CopyMemory
return SetImportSlice(const_cast<void*>(data), s, t, n, CopyMemory);
}
bool mitk::Image::SetVolume(const void *data, int t, int n)
{
// const_cast is no risk for ImportMemoryManagementType == CopyMemory
return SetImportVolume(const_cast<void*>(data), t, n, CopyMemory);
}
bool mitk::Image::SetChannel(const void *data, int n)
{
// const_cast is no risk for ImportMemoryManagementType == CopyMemory
return SetImportChannel(const_cast<void*>(data), n, CopyMemory);
}
bool mitk::Image::SetImportSlice(void *data, int s, int t, int n, ImportMemoryManagementType importMemoryManagement)
{
if(IsValidSlice(s,t,n)==false) return false;
ImageDataItemPointer sl;
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
if(IsSliceSet(s,t,n))
{
sl=GetSliceData(s,t,n,data,importMemoryManagement);
if(sl->GetManageMemory()==false)
{
sl=AllocateSliceData(s,t,n,data,importMemoryManagement);
if(sl.GetPointer()==NULL) return false;
}
if ( sl->GetData() != data )
std::memcpy(sl->GetData(), data, m_OffsetTable[2]*(ptypeSize));
sl->Modified();
//we have changed the data: call Modified()!
Modified();
}
else
{
sl=AllocateSliceData(s,t,n,data,importMemoryManagement);
if(sl.GetPointer()==NULL) return false;
if ( sl->GetData() != data )
std::memcpy(sl->GetData(), data, m_OffsetTable[2]*(ptypeSize));
//we just added a missing slice, which is not regarded as modification.
//Therefore, we do not call Modified()!
}
return true;
}
bool mitk::Image::SetImportVolume(void *data, int t, int n, ImportMemoryManagementType importMemoryManagement)
{
if(IsValidVolume(t,n)==false) return false;
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
ImageDataItemPointer vol;
if(IsVolumeSet(t,n))
{
vol=GetVolumeData(t,n,data,importMemoryManagement);
if(vol->GetManageMemory()==false)
{
vol=AllocateVolumeData(t,n,data,importMemoryManagement);
if(vol.GetPointer()==NULL) return false;
}
if ( vol->GetData() != data )
std::memcpy(vol->GetData(), data, m_OffsetTable[3]*(ptypeSize));
vol->Modified();
vol->SetComplete(true);
//we have changed the data: call Modified()!
Modified();
}
else
{
vol=AllocateVolumeData(t,n,data,importMemoryManagement);
if(vol.GetPointer()==NULL) return false;
if ( vol->GetData() != data )
{
std::memcpy(vol->GetData(), data, m_OffsetTable[3]*(ptypeSize));
}
vol->SetComplete(true);
this->m_ImageDescriptor->GetChannelDescriptor(n).SetData( vol->GetData() );
//we just added a missing Volume, which is not regarded as modification.
//Therefore, we do not call Modified()!
}
return true;
}
bool mitk::Image::SetImportChannel(void *data, int n, ImportMemoryManagementType importMemoryManagement)
{
if(IsValidChannel(n)==false) return false;
// channel descriptor
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
ImageDataItemPointer ch;
if(IsChannelSet(n))
{
ch=GetChannelData(n,data,importMemoryManagement);
if(ch->GetManageMemory()==false)
{
ch=AllocateChannelData(n,data,importMemoryManagement);
if(ch.GetPointer()==NULL) return false;
}
if ( ch->GetData() != data )
std::memcpy(ch->GetData(), data, m_OffsetTable[4]*(ptypeSize));
ch->Modified();
ch->SetComplete(true);
//we have changed the data: call Modified()!
Modified();
}
else
{
ch=AllocateChannelData(n,data,importMemoryManagement);
if(ch.GetPointer()==NULL) return false;
if ( ch->GetData() != data )
std::memcpy(ch->GetData(), data, m_OffsetTable[4]*(ptypeSize));
ch->SetComplete(true);
this->m_ImageDescriptor->GetChannelDescriptor(n).SetData( ch->GetData() );
//we just added a missing Channel, which is not regarded as modification.
//Therefore, we do not call Modified()!
}
return true;
}
void mitk::Image::Initialize()
{
ImageDataItemPointerArray::iterator it, end;
for( it=m_Slices.begin(), end=m_Slices.end(); it!=end; ++it )
{
(*it)=NULL;
}
for( it=m_Volumes.begin(), end=m_Volumes.end(); it!=end; ++it )
{
(*it)=NULL;
}
for( it=m_Channels.begin(), end=m_Channels.end(); it!=end; ++it )
{
(*it)=NULL;
}
m_CompleteData = NULL;
if( m_ImageStatistics == NULL)
{
m_ImageStatistics = new mitk::ImageStatisticsHolder( this );
}
SetRequestedRegionToLargestPossibleRegion();
}
void mitk::Image::Initialize(const mitk::ImageDescriptor::Pointer inDesc)
{
// store the descriptor
this->m_ImageDescriptor = inDesc;
// initialize image
this->Initialize( inDesc->GetChannelDescriptor(0).GetPixelType(), inDesc->GetNumberOfDimensions(), inDesc->GetDimensions(), 1 );
}
void mitk::Image::Initialize(const mitk::PixelType& type, unsigned int dimension, const unsigned int *dimensions, unsigned int channels)
{
Clear();
m_Dimension=dimension;
if(!dimensions)
itkExceptionMacro(<< "invalid zero dimension image");
unsigned int i;
for(i=0;i<dimension;++i)
{
if(dimensions[i]<1)
itkExceptionMacro(<< "invalid dimension[" << i << "]: " << dimensions[i]);
}
// create new array since the old was deleted
m_Dimensions = new unsigned int[MAX_IMAGE_DIMENSIONS];
// initialize the first four dimensions to 1, the remaining 4 to 0
FILL_C_ARRAY(m_Dimensions, 4, 1u);
FILL_C_ARRAY((m_Dimensions+4), 4, 0u);
// copy in the passed dimension information
std::memcpy(m_Dimensions, dimensions, sizeof(unsigned int)*m_Dimension);
this->m_ImageDescriptor = mitk::ImageDescriptor::New();
this->m_ImageDescriptor->Initialize( this->m_Dimensions, this->m_Dimension );
for(i=0;i<4;++i)
{
m_LargestPossibleRegion.SetIndex(i, 0);
m_LargestPossibleRegion.SetSize (i, m_Dimensions[i]);
}
m_LargestPossibleRegion.SetIndex(i, 0);
m_LargestPossibleRegion.SetSize(i, channels);
if(m_LargestPossibleRegion.GetNumberOfPixels()==0)
{
delete [] m_Dimensions;
m_Dimensions = NULL;
return;
}
for( unsigned int i=0u; i<channels; i++)
{
this->m_ImageDescriptor->AddNewChannel( type );
}
PlaneGeometry::Pointer planegeometry = PlaneGeometry::New();
planegeometry->InitializeStandardPlane(m_Dimensions[0], m_Dimensions[1]);
SlicedGeometry3D::Pointer slicedGeometry = SlicedGeometry3D::New();
slicedGeometry->InitializeEvenlySpaced(planegeometry, m_Dimensions[2]);
if(dimension>=4)
{
TimeBounds timebounds;
timebounds[0] = 0.0;
timebounds[1] = 1.0;
slicedGeometry->SetTimeBounds(timebounds);
}
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
timeGeometry->Initialize(slicedGeometry, m_Dimensions[3]);
- for (TimeStepType step = 0; step < timeGeometry->GetNumberOfTimeSteps(); ++step)
+ for (TimeStepType step = 0; step < timeGeometry->CountTimeSteps(); ++step)
{
timeGeometry->GetGeometryForTimeStep(step)->ImageGeometryOn();
}
SetTimeGeometry(timeGeometry);
ImageDataItemPointer dnull=NULL;
m_Channels.assign(GetNumberOfChannels(), dnull);
m_Volumes.assign(GetNumberOfChannels()*m_Dimensions[3], dnull);
m_Slices.assign(GetNumberOfChannels()*m_Dimensions[3]*m_Dimensions[2], dnull);
ComputeOffsetTable();
Initialize();
m_Initialized = true;
}
void mitk::Image::Initialize(const mitk::PixelType& type, const mitk::Geometry3D& geometry, unsigned int channels, int tDim )
{
mitk::ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
Geometry3D::Pointer geometry3D = geometry.Clone();
timeGeometry->Initialize(geometry3D.GetPointer(), tDim);
this->Initialize(type, *timeGeometry, channels, tDim);
}
void mitk::Image::Initialize(const mitk::PixelType& type, const mitk::TimeGeometry& geometry, unsigned int channels, int tDim )
{
unsigned int dimensions[5];
dimensions[0] = (unsigned int)(geometry.GetGeometryForTimeStep(0)->GetExtent(0)+0.5);
dimensions[1] = (unsigned int)(geometry.GetGeometryForTimeStep(0)->GetExtent(1)+0.5);
dimensions[2] = (unsigned int)(geometry.GetGeometryForTimeStep(0)->GetExtent(2)+0.5);
- dimensions[3] = (tDim > 0) ? tDim : geometry.GetNumberOfTimeSteps();
+ dimensions[3] = (tDim > 0) ? tDim : geometry.CountTimeSteps();
dimensions[4] = 0;
unsigned int dimension = 2;
if ( dimensions[2] > 1 )
dimension = 3;
if ( dimensions[3] > 1 )
dimension = 4;
Initialize( type, dimension, dimensions, channels );
- if (geometry.GetNumberOfTimeSteps() > 1)
+ if (geometry.CountTimeSteps() > 1)
{
TimeGeometry::Pointer cloned = geometry.Clone();
SetTimeGeometry(cloned.GetPointer());
}
else
Superclass::SetGeometry(geometry.GetGeometryForTimeStep(0));
/* //Old //TODO_GOETZ Really necessary?
mitk::BoundingBox::BoundsArrayType bounds = geometry.GetBoundingBoxInWorld()->GetBounds();
if( (bounds[0] != 0.0) || (bounds[2] != 0.0) || (bounds[4] != 0.0) )
{
SlicedGeometry3D* slicedGeometry = GetSlicedGeometry(0);
mitk::Point3D origin; origin.Fill(0.0);
slicedGeometry->IndexToWorld(origin, origin);
bounds[1]-=bounds[0]; bounds[3]-=bounds[2]; bounds[5]-=bounds[4];
bounds[0] = 0.0; bounds[2] = 0.0; bounds[4] = 0.0;
this->m_ImageDescriptor->Initialize( this->m_Dimensions, this->m_Dimension );
slicedGeometry->SetBounds(bounds);
slicedGeometry->GetIndexToWorldTransform()->SetOffset(origin.GetVnlVector().data_block());
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
timeGeometry->Initialize(slicedGeometry, m_Dimensions[3]);
SetTimeGeometry(timeGeometry);
}*/
}
void mitk::Image::Initialize(const mitk::PixelType& type, int sDim, const mitk::Geometry2D& geometry2d, bool flipped, unsigned int channels, int tDim )
{
SlicedGeometry3D::Pointer slicedGeometry = SlicedGeometry3D::New();
slicedGeometry->InitializeEvenlySpaced(static_cast<Geometry2D*>(geometry2d.Clone().GetPointer()), sDim, flipped);
Initialize(type, *slicedGeometry, channels, tDim);
}
void mitk::Image::Initialize(const mitk::Image* image)
{
Initialize(image->GetPixelType(), *image->GetTimeGeometry());
}
void mitk::Image::Initialize(vtkImageData* vtkimagedata, int channels, int tDim, int sDim, int pDim)
{
if(vtkimagedata==NULL) return;
m_Dimension=vtkimagedata->GetDataDimension();
unsigned int i, *tmpDimensions=new unsigned int[m_Dimension>4?m_Dimension:4];
for(i=0;i<m_Dimension;++i) tmpDimensions[i]=vtkimagedata->GetDimensions()[i];
if(m_Dimension<4)
{
unsigned int *p;
for(i=0,p=tmpDimensions+m_Dimension;i<4-m_Dimension;++i, ++p)
*p=1;
}
if(pDim>=0)
{
tmpDimensions[1]=pDim;
if(m_Dimension < 2)
m_Dimension = 2;
}
if(sDim>=0)
{
tmpDimensions[2]=sDim;
if(m_Dimension < 3)
m_Dimension = 3;
}
if(tDim>=0)
{
tmpDimensions[3]=tDim;
if(m_Dimension < 4)
m_Dimension = 4;
}
switch ( vtkimagedata->GetScalarType() )
{
case VTK_BIT:
case VTK_CHAR:
//pixelType.Initialize(typeid(char), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<char>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_UNSIGNED_CHAR:
//pixelType.Initialize(typeid(unsigned char), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<unsigned char>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_SHORT:
//pixelType.Initialize(typeid(short), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<short>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_UNSIGNED_SHORT:
//pixelType.Initialize(typeid(unsigned short), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<unsigned short>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_INT:
//pixelType.Initialize(typeid(int), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<int>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_UNSIGNED_INT:
//pixelType.Initialize(typeid(unsigned int), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<unsigned int>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_LONG:
//pixelType.Initialize(typeid(long), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<long>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_UNSIGNED_LONG:
//pixelType.Initialize(typeid(unsigned long), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<unsigned long>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_FLOAT:
//pixelType.Initialize(typeid(float), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<float>(), m_Dimension, tmpDimensions, channels);
break;
case VTK_DOUBLE:
//pixelType.Initialize(typeid(double), vtkimagedata->GetNumberOfScalarComponents());
Initialize(mitk::MakeScalarPixelType<double>(), m_Dimension, tmpDimensions, channels);
break;
default:
break;
}
/*
Initialize(pixelType,
m_Dimension,
tmpDimensions,
channels);
*/
const double *spacinglist = vtkimagedata->GetSpacing();
Vector3D spacing;
FillVector3D(spacing, spacinglist[0], 1.0, 1.0);
if(m_Dimension>=2)
spacing[1]=spacinglist[1];
if(m_Dimension>=3)
spacing[2]=spacinglist[2];
// access origin of vtkImage
Point3D origin;
vtkFloatingPointType vtkorigin[3];
vtkimagedata->GetOrigin(vtkorigin);
FillVector3D(origin, vtkorigin[0], 0.0, 0.0);
if(m_Dimension>=2)
origin[1]=vtkorigin[1];
if(m_Dimension>=3)
origin[2]=vtkorigin[2];
SlicedGeometry3D* slicedGeometry = GetSlicedGeometry(0);
// re-initialize PlaneGeometry with origin and direction
PlaneGeometry* planeGeometry = static_cast<PlaneGeometry*>(slicedGeometry->GetGeometry2D(0));
planeGeometry->SetOrigin(origin);
// re-initialize SlicedGeometry3D
slicedGeometry->SetOrigin(origin);
slicedGeometry->SetSpacing(spacing);
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
timeGeometry->Initialize(slicedGeometry, m_Dimensions[3]);
SetTimeGeometry(timeGeometry);
delete [] tmpDimensions;
}
bool mitk::Image::IsValidSlice(int s, int t, int n) const
{
if(m_Initialized)
return ((s>=0) && (s<(int)m_Dimensions[2]) && (t>=0) && (t< (int) m_Dimensions[3]) && (n>=0) && (n< (int)GetNumberOfChannels()));
else
return false;
}
bool mitk::Image::IsValidVolume(int t, int n) const
{
if(m_Initialized)
return IsValidSlice(0, t, n);
else
return false;
}
bool mitk::Image::IsValidChannel(int n) const
{
if(m_Initialized)
return IsValidSlice(0, 0, n);
else
return false;
}
void mitk::Image::ComputeOffsetTable()
{
if(m_OffsetTable!=NULL)
delete [] m_OffsetTable;
m_OffsetTable=new size_t[m_Dimension>4 ? m_Dimension+1 : 4+1];
unsigned int i;
size_t num=1;
m_OffsetTable[0] = 1;
for (i=0; i < m_Dimension; ++i)
{
num *= m_Dimensions[i];
m_OffsetTable[i+1] = num;
}
for (;i < 4; ++i)
m_OffsetTable[i+1] = num;
}
bool mitk::Image::IsValidTimeStep(int t) const
{
return ( ( m_Dimension >= 4 && t <= (int)m_Dimensions[3] && t > 0 ) || (t == 0) );
}
void mitk::Image::Expand(unsigned int timeSteps)
{
if(timeSteps < 1) itkExceptionMacro(<< "Invalid timestep in Image!");
Superclass::Expand(timeSteps);
}
int mitk::Image::GetSliceIndex(int s, int t, int n) const
{
if(IsValidSlice(s,t,n)==false) return false;
return ((size_t)s)+((size_t) t)*m_Dimensions[2]+((size_t) n)*m_Dimensions[3]*m_Dimensions[2]; //??
}
int mitk::Image::GetVolumeIndex(int t, int n) const
{
if(IsValidVolume(t,n)==false) return false;
return ((size_t)t)+((size_t) n)*m_Dimensions[3]; //??
}
mitk::Image::ImageDataItemPointer mitk::Image::AllocateSliceData(int s, int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
{
int pos;
pos=GetSliceIndex(s,t,n);
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
// is slice available as part of a volume that is available?
ImageDataItemPointer sl, ch, vol;
vol=m_Volumes[GetVolumeIndex(t,n)];
if(vol.GetPointer()!=NULL)
{
sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*m_OffsetTable[2]*(ptypeSize));
sl->SetComplete(true);
return m_Slices[pos]=sl;
}
// is slice available as part of a channel that is available?
ch=m_Channels[n];
if(ch.GetPointer()!=NULL)
{
sl=new ImageDataItem(*ch, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, (((size_t) s)*m_OffsetTable[2]+((size_t) t)*m_OffsetTable[3])*(ptypeSize));
sl->SetComplete(true);
return m_Slices[pos]=sl;
}
// allocate new volume (instead of a single slice to keep data together!)
m_Volumes[GetVolumeIndex(t,n)]=vol=AllocateVolumeData(t,n,NULL,importMemoryManagement);
sl=new ImageDataItem(*vol, m_ImageDescriptor, 2, data, importMemoryManagement == ManageMemory, ((size_t) s)*m_OffsetTable[2]*(ptypeSize));
sl->SetComplete(true);
return m_Slices[pos]=sl;
////ALTERNATIVE:
//// allocate new slice
//sl=new ImageDataItem(*m_PixelType, 2, m_Dimensions);
//m_Slices[pos]=sl;
//return vol;
}
mitk::Image::ImageDataItemPointer mitk::Image::AllocateVolumeData(int t, int n, void *data, ImportMemoryManagementType importMemoryManagement)
{
int pos;
pos=GetVolumeIndex(t,n);
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
// is volume available as part of a channel that is available?
ImageDataItemPointer ch, vol;
ch=m_Channels[n];
if(ch.GetPointer()!=NULL)
{
vol=new ImageDataItem(*ch, m_ImageDescriptor, 3, data,importMemoryManagement == ManageMemory, (((size_t) t)*m_OffsetTable[3])*(ptypeSize));
return m_Volumes[pos]=vol;
}
mitk::PixelType chPixelType = this->m_ImageDescriptor->GetChannelTypeById(n);
// allocate new volume
if(importMemoryManagement == CopyMemory)
{
vol=new ImageDataItem( chPixelType, 3, m_Dimensions, NULL, true);
if(data != NULL)
std::memcpy(vol->GetData(), data, m_OffsetTable[3]*(ptypeSize));
}
else
{
vol=new ImageDataItem( chPixelType, 3, m_Dimensions, data, importMemoryManagement == ManageMemory);
}
m_Volumes[pos]=vol;
return vol;
}
mitk::Image::ImageDataItemPointer mitk::Image::AllocateChannelData(int n, void *data, ImportMemoryManagementType importMemoryManagement)
{
ImageDataItemPointer ch;
// allocate new channel
if(importMemoryManagement == CopyMemory)
{
const size_t ptypeSize = this->m_ImageDescriptor->GetChannelTypeById(n).GetSize();
ch=new ImageDataItem(this->m_ImageDescriptor, NULL, true);
if(data != NULL)
std::memcpy(ch->GetData(), data, m_OffsetTable[4]*(ptypeSize));
}
else
{
ch=new ImageDataItem(this->m_ImageDescriptor, data, importMemoryManagement == ManageMemory);
}
m_Channels[n]=ch;
return ch;
}
unsigned int* mitk::Image::GetDimensions() const
{
return m_Dimensions;
}
void mitk::Image::Clear()
{
Superclass::Clear();
delete [] m_Dimensions;
m_Dimensions = NULL;
}
void mitk::Image::SetGeometry(Geometry3D* aGeometry3D)
{
// Please be aware of the 0.5 offset/pixel-center issue! See Geometry documentation for further information
if(aGeometry3D->GetImageGeometry()==false)
{
MITK_INFO << "WARNING: Applied a non-image geometry onto an image. Please be SURE that this geometry is pixel-center-based! If it is not, you need to call Geometry3D->ChangeImageGeometryConsideringOriginOffset(true) before calling image->setGeometry(..)\n";
}
Superclass::SetGeometry(aGeometry3D);
- for (TimeStepType step = 0; step < GetTimeGeometry()->GetNumberOfTimeSteps(); ++step)
+ for (TimeStepType step = 0; step < GetTimeGeometry()->CountTimeSteps(); ++step)
GetTimeGeometry()->GetGeometryForTimeStep(step)->ImageGeometryOn();
}
void mitk::Image::PrintSelf(std::ostream& os, itk::Indent indent) const
{
unsigned char i;
if(m_Initialized)
{
os << indent << " Dimension: " << m_Dimension << std::endl;
os << indent << " Dimensions: ";
for(i=0; i < m_Dimension; ++i)
os << GetDimension(i) << " ";
os << std::endl;
for(unsigned int ch=0; ch < this->m_ImageDescriptor->GetNumberOfChannels(); ch++)
{
mitk::PixelType chPixelType = this->m_ImageDescriptor->GetChannelTypeById(ch);
os << indent << " Channel: " << this->m_ImageDescriptor->GetChannelName(ch) << std::endl;
os << indent << " PixelType: " << chPixelType.GetPixelTypeAsString() << std::endl;
os << indent << " BytesPerElement: " << chPixelType.GetSize() << std::endl;
os << indent << " ComponentType: " << chPixelType.GetComponentTypeAsString() << std::endl;
os << indent << " NumberOfComponents: " << chPixelType.GetNumberOfComponents() << std::endl;
os << indent << " BitsPerComponent: " << chPixelType.GetBitsPerComponent() << std::endl;
}
}
else
{
os << indent << " Image not initialized: m_Initialized: false" << std::endl;
}
Superclass::PrintSelf(os,indent);
}
bool mitk::Image::IsRotated() const
{
const mitk::Geometry3D* geo = this->GetGeometry();
bool ret = false;
if(geo)
{
const vnl_matrix_fixed<float, 3, 3> & mx = geo->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix();
float ref = 0;
for(short k = 0; k < 3; ++k)
ref += mx[k][k];
ref/=1000; // Arbitrary value; if a non-diagonal (nd) element is bigger then this, matrix is considered nd.
for(short i = 0; i < 3; ++i)
{
for(short j = 0; j < 3; ++j)
{
if(i != j)
{
if(std::abs(mx[i][j]) > ref) // matrix is nd
ret = true;
}
}
}
}
return ret;
}
mitk::ScalarType mitk::Image::GetScalarValueMin(int t) const
{
return m_ImageStatistics->GetScalarValueMin(t);
}
//## \brief Get the maximum for scalar images
mitk::ScalarType mitk::Image::GetScalarValueMax(int t) const
{
return m_ImageStatistics->GetScalarValueMax(t);
}
//## \brief Get the second smallest value for scalar images
mitk::ScalarType mitk::Image::GetScalarValue2ndMin(int t) const
{
return m_ImageStatistics->GetScalarValue2ndMin(t);
}
mitk::ScalarType mitk::Image::GetScalarValueMinNoRecompute( unsigned int t ) const
{
return m_ImageStatistics->GetScalarValueMinNoRecompute(t);
}
mitk::ScalarType mitk::Image::GetScalarValue2ndMinNoRecompute( unsigned int t ) const
{
return m_ImageStatistics->GetScalarValue2ndMinNoRecompute(t);
}
mitk::ScalarType mitk::Image::GetScalarValue2ndMax(int t) const
{
return m_ImageStatistics->GetScalarValue2ndMax(t);
}
mitk::ScalarType mitk::Image::GetScalarValueMaxNoRecompute( unsigned int t) const
{
return m_ImageStatistics->GetScalarValueMaxNoRecompute(t);
}
mitk::ScalarType mitk::Image::GetScalarValue2ndMaxNoRecompute( unsigned int t ) const
{
return m_ImageStatistics->GetScalarValue2ndMaxNoRecompute(t);
}
mitk::ScalarType mitk::Image::GetCountOfMinValuedVoxels(int t ) const
{
return m_ImageStatistics->GetCountOfMinValuedVoxels(t);
}
mitk::ScalarType mitk::Image::GetCountOfMaxValuedVoxels(int t) const
{
return m_ImageStatistics->GetCountOfMaxValuedVoxels(t);
}
unsigned int mitk::Image::GetCountOfMaxValuedVoxelsNoRecompute( unsigned int t ) const
{
return m_ImageStatistics->GetCountOfMaxValuedVoxelsNoRecompute(t);
}
unsigned int mitk::Image::GetCountOfMinValuedVoxelsNoRecompute( unsigned int t ) const
{
return m_ImageStatistics->GetCountOfMinValuedVoxelsNoRecompute(t);
}
bool mitk::Equal(const mitk::Image* rightHandSide, const mitk::Image* leftHandSide, ScalarType eps, bool verbose)
{
bool returnValue = true;
if( rightHandSide == NULL )
{
if(verbose)
MITK_INFO << "[( Image )] rightHandSide is NULL.";
return false;
}
if( leftHandSide == NULL )
{
if(verbose)
MITK_INFO << "[( Image )] leftHandSide is NULL.";
return false;
}
// Dimensionality
if( rightHandSide->GetDimension() != leftHandSide->GetDimension() )
{
if(verbose)
{
MITK_INFO << "[( Image )] Dimensionality differs.";
MITK_INFO << "rightHandSide is " << rightHandSide->GetDimension()
<< "leftHandSide is " << leftHandSide->GetDimension();
}
returnValue = false;
}
// Pair-wise dimension (size) comparison
unsigned int minDimensionality = std::min(rightHandSide->GetDimension(),leftHandSide->GetDimension());
for( unsigned int i=0; i< minDimensionality; ++i)
{
if( rightHandSide->GetDimension(i) != leftHandSide->GetDimension(i) )
{
returnValue = false;
if(verbose)
{
MITK_INFO << "[( Image )] dimension differs.";
MITK_INFO << "rightHandSide->GetDimension("<<i<<") is " << rightHandSide->GetDimension(i)
<< "leftHandSide->GetDimension("<<i<<") is " << leftHandSide->GetDimension(i);
}
}
}
// Pixeltype
mitk::PixelType pixelTypeRightHandSide = rightHandSide->GetPixelType();
mitk::PixelType pixelTypeLeftHandSide = leftHandSide->GetPixelType();
if( !( pixelTypeRightHandSide == pixelTypeLeftHandSide ) )
{
if(verbose)
{
MITK_INFO << "[( Image )] PixelType differs.";
MITK_INFO << "rightHandSide is " << pixelTypeRightHandSide.GetTypeAsString()
<< "leftHandSide is " << pixelTypeLeftHandSide.GetTypeAsString();
}
returnValue = false;
}
// Geometries
if( !mitk::Equal( leftHandSide->GetGeometry(),
rightHandSide->GetGeometry(), eps, verbose) )
{
if(verbose)
{
MITK_INFO << "[( Image )] Geometries differ.";
}
returnValue = false;
}
// Pixel values - default mode [ 0 threshold in difference ]
// compare only if all previous checks were successfull, otherwise the ITK filter will throw an exception
if( returnValue )
{
mitk::CompareImageFilter::Pointer compareFilter = mitk::CompareImageFilter::New();
compareFilter->SetInput(0, rightHandSide);
compareFilter->SetInput(1, leftHandSide);
compareFilter->Update();
if(( !compareFilter->GetResult() ) )
{
returnValue = false;
if(verbose)
{
MITK_INFO << "[(Image)] Pixel values differ: ";
}
compareFilter->GetCompareResults().PrintSelf();
}
}
return returnValue;
}
diff --git a/Core/Code/DataManagement/mitkPointSet.cpp b/Core/Code/DataManagement/mitkPointSet.cpp
index 8c6d772f72..cff5869618 100755
--- a/Core/Code/DataManagement/mitkPointSet.cpp
+++ b/Core/Code/DataManagement/mitkPointSet.cpp
@@ -1,884 +1,884 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPointSet.h"
#include "mitkPointOperation.h"
#include "mitkInteractionConst.h"
#include <mitkTesting.h>
#include <iomanip>
mitk::PointSet::PointSet()
{
this->InitializeEmpty();
}
mitk::PointSet::PointSet(const PointSet &other)
: BaseData(other)
, m_PointSetSeries(other.GetPointSetSeriesSize())
, m_CalculateBoundingBox(true)
{
// Copy points
for (std::size_t t = 0; t < m_PointSetSeries.size(); ++t)
{
m_PointSetSeries[t] = DataType::New();
DataType::Pointer otherPts = other.GetPointSet(t);
for (PointsConstIterator i = other.Begin(t);
i != other.End(t); ++i)
{
m_PointSetSeries[t]->SetPoint(i.Index(), i.Value());
PointDataType pointData;
if (otherPts->GetPointData(i.Index(), &pointData))
{
m_PointSetSeries[t]->SetPointData(i.Index(), pointData);
}
}
}
}
mitk::PointSet::~PointSet()
{
this->ClearData();
}
void mitk::PointSet::ClearData()
{
m_PointSetSeries.clear();
Superclass::ClearData();
}
void mitk::PointSet::InitializeEmpty()
{
m_PointSetSeries.resize( 1 );
m_PointSetSeries[0] = DataType::New();
PointDataContainer::Pointer pointData = PointDataContainer::New();
m_PointSetSeries[0]->SetPointData( pointData );
m_CalculateBoundingBox = false;
Superclass::InitializeTimeGeometry(1);
m_Initialized = true;
}
bool mitk::PointSet::IsEmptyTimeStep(unsigned int t) const
{
return IsInitialized() && (GetSize(t) == 0);
}
void mitk::PointSet::Expand( unsigned int timeSteps )
{
// Check if the vector is long enough to contain the new element
// at the given position. If not, expand it with sufficient pre-initialized
// elements.
//
// NOTE: This method will never REDUCE the vector size; it should only
// be used to make sure that the vector has enough elements to include the
// specified time step.
unsigned int oldSize = m_PointSetSeries.size();
if ( timeSteps > oldSize )
{
Superclass::Expand( timeSteps );
m_PointSetSeries.resize( timeSteps );
for ( unsigned int i = oldSize; i < timeSteps; ++i )
{
m_PointSetSeries[i] = DataType::New();
PointDataContainer::Pointer pointData = PointDataContainer::New();
m_PointSetSeries[i]->SetPointData( pointData );
}
//if the size changes, then compute the bounding box
m_CalculateBoundingBox = true;
this->InvokeEvent( PointSetExtendTimeRangeEvent() );
}
}
unsigned int mitk::PointSet::GetPointSetSeriesSize() const
{
return m_PointSetSeries.size();
}
int mitk::PointSet::GetSize( unsigned int t ) const
{
if ( t < m_PointSetSeries.size() )
{
return m_PointSetSeries[t]->GetNumberOfPoints();
}
else
{
return 0;
}
}
mitk::PointSet::DataType::Pointer mitk::PointSet::GetPointSet( int t ) const
{
if ( t < (int)m_PointSetSeries.size() )
{
return m_PointSetSeries[t];
}
else
{
return NULL;
}
}
mitk::PointSet::PointsIterator mitk::PointSet::Begin( int t )
{
if (t >= 0 && t < static_cast<int>(m_PointSetSeries.size()))
{
return m_PointSetSeries[t]->GetPoints()->Begin();
}
return PointsIterator();
}
mitk::PointSet::PointsConstIterator mitk::PointSet::Begin(int t) const
{
if (t >= 0 && t < static_cast<int>(m_PointSetSeries.size()))
{
return m_PointSetSeries[t]->GetPoints()->Begin();
}
return PointsConstIterator();
}
mitk::PointSet::PointsIterator mitk::PointSet::End( int t )
{
if (t >= 0 && t < static_cast<int>(m_PointSetSeries.size()))
{
return m_PointSetSeries[t]->GetPoints()->End();
}
return PointsIterator();
}
mitk::PointSet::PointsConstIterator mitk::PointSet::End(int t) const
{
if (t >= 0 && t < static_cast<int>(m_PointSetSeries.size()))
{
return m_PointSetSeries[t]->GetPoints()->End();
}
return PointsConstIterator();
}
int mitk::PointSet::SearchPoint( Point3D point, float distance, int t ) const
{
if ( t >= (int)m_PointSetSeries.size() )
{
return -1;
}
// Out is the point which is checked to be the searched point
PointType out;
out.Fill( 0 );
PointType indexPoint;
this->GetGeometry( t )->WorldToIndex(point, indexPoint);
// Searching the first point in the Set, that is +- distance far away fro
// the given point
unsigned int i;
PointsContainer::Iterator it, end;
end = m_PointSetSeries[t]->GetPoints()->End();
int bestIndex = -1;
distance = distance * distance;
// To correct errors from converting index to world and world to index
if (distance == 0.0)
{
distance = 0.000001;
}
ScalarType bestDist = distance;
ScalarType dist, tmp;
for ( it = m_PointSetSeries[t]->GetPoints()->Begin(), i = 0;
it != end;
++it, ++i )
{
bool ok = m_PointSetSeries[t]->GetPoints()
->GetElementIfIndexExists( it->Index(), &out );
if ( !ok )
{
return -1;
}
else if ( indexPoint == out ) //if totally equal
{
return it->Index();
}
//distance calculation
tmp = out[0] - indexPoint[0]; dist = tmp * tmp;
tmp = out[1] - indexPoint[1]; dist += tmp * tmp;
tmp = out[2] - indexPoint[2]; dist += tmp * tmp;
if ( dist < bestDist )
{
bestIndex = it->Index();
bestDist = dist;
}
}
return bestIndex;
}
mitk::PointSet::PointType
mitk::PointSet::GetPoint( PointIdentifier id, int t ) const
{
PointType out;
out.Fill(0);
if ( (unsigned int) t >= m_PointSetSeries.size() )
{
return out;
}
if ( m_PointSetSeries[t]->GetPoints()->IndexExists(id) )
{
m_PointSetSeries[t]->GetPoint( id, &out );
this->GetGeometry(t)->IndexToWorld( out, out );
return out;
}
else
{
return out;
}
}
bool
mitk::PointSet
::GetPointIfExists( PointIdentifier id, PointType* point, int t ) const
{
if ( (unsigned int) t >= m_PointSetSeries.size() )
{
return false;
}
if ( m_PointSetSeries[t]->GetPoints()->GetElementIfIndexExists(id, point) )
{
this->GetGeometry( t )->IndexToWorld( *point, *point );
return true;
}
else
{
return false;
}
}
void mitk::PointSet::SetPoint( PointIdentifier id, PointType point, int t )
{
// Adapt the size of the data vector if necessary
this->Expand( t+1 );
mitk::Point3D indexPoint;
this->GetGeometry( t )->WorldToIndex( point, indexPoint );
m_PointSetSeries[t]->SetPoint( id, indexPoint );
PointDataType defaultPointData;
defaultPointData.id = id;
defaultPointData.selected = false;
defaultPointData.pointSpec = mitk::PTUNDEFINED;
m_PointSetSeries[t]->SetPointData( id, defaultPointData );
//boundingbox has to be computed anyway
m_CalculateBoundingBox = true;
this->Modified();
}
void mitk::PointSet::SetPoint( PointIdentifier id, PointType point, PointSpecificationType spec, int t )
{
// Adapt the size of the data vector if necessary
this->Expand( t+1 );
mitk::Point3D indexPoint;
this->GetGeometry( t )->WorldToIndex( point, indexPoint );
m_PointSetSeries[t]->SetPoint( id, indexPoint );
PointDataType defaultPointData;
defaultPointData.id = id;
defaultPointData.selected = false;
defaultPointData.pointSpec = spec;
m_PointSetSeries[t]->SetPointData( id, defaultPointData );
//boundingbox has to be computed anyway
m_CalculateBoundingBox = true;
this->Modified();
}
void mitk::PointSet::InsertPoint( PointIdentifier id, PointType point, int t )
{
this->InsertPoint(id, point, mitk::PTUNDEFINED, t);
}
void mitk::PointSet::InsertPoint( PointIdentifier id, PointType point, PointSpecificationType spec, int t )
{
if ( (unsigned int) t < m_PointSetSeries.size() )
{
mitk::Point3D indexPoint;
mitk::Geometry3D* tempGeometry = this->GetGeometry( t );
if (tempGeometry == NULL)
{
MITK_INFO<< __FILE__ << ", l." << __LINE__ << ": GetGeometry of "<< t <<" returned NULL!" << std::endl;
return;
}
tempGeometry->WorldToIndex( point, indexPoint );
m_PointSetSeries[t]->GetPoints()->InsertElement( id, indexPoint );
PointDataType defaultPointData;
defaultPointData.id = id;
defaultPointData.selected = false;
defaultPointData.pointSpec = spec;
m_PointSetSeries[t]->GetPointData()->InsertElement(id, defaultPointData);
//boundingbox has to be computed anyway
m_CalculateBoundingBox = true;
this->Modified();
}
}
bool mitk::PointSet::SwapPointPosition( PointIdentifier id, bool moveUpwards, int t )
{
if(IndexExists(id, t) )
{
PointType point = GetPoint(id,t);
if(moveUpwards)
{//up
if(IndexExists(id-1,t))
{
InsertPoint(id, GetPoint(id - 1, t), t);
InsertPoint(id-1,point,t);
this->Modified();
return true;
}
}
else
{//down
if(IndexExists(id+1,t))
{
InsertPoint(id, GetPoint(id + 1, t), t);
InsertPoint(id+1,point,t);
this->Modified();
return true;
}
}
}
return false;
}
bool mitk::PointSet::IndexExists( int position, int t ) const
{
if ( (unsigned int) t < m_PointSetSeries.size() )
{
return m_PointSetSeries[t]->GetPoints()->IndexExists( position );
}
else
{
return false;
}
}
bool mitk::PointSet::GetSelectInfo( int position, int t ) const
{
if ( this->IndexExists( position, t ) )
{
PointDataType pointData = { 0, false, PTUNDEFINED };
m_PointSetSeries[t]->GetPointData( position, &pointData );
return pointData.selected;
}
else
{
return false;
}
}
void mitk::PointSet::SetSelectInfo( int position, bool selected, int t )
{
if ( this->IndexExists( position, t ) )
{
// timeStep to ms
TimePointType timeInMS = this->GetTimeGeometry()->TimeStepToTimePoint( t );
// point
Point3D point = this->GetPoint( position, t );
std::auto_ptr<PointOperation> op;
if (selected)
{
op.reset(new mitk::PointOperation(OpSELECTPOINT, timeInMS, point, position ));
}
else
{
op.reset(new mitk::PointOperation(OpDESELECTPOINT, timeInMS, point, position ));
}
this->ExecuteOperation( op.get() );
}
}
mitk::PointSpecificationType mitk::PointSet::GetSpecificationTypeInfo( int position, int t ) const
{
if ( this->IndexExists( position, t ) )
{
PointDataType pointData = { 0, false, PTUNDEFINED };
m_PointSetSeries[t]->GetPointData( position, &pointData );
return pointData.pointSpec;
}
else
{
return PTUNDEFINED;
}
}
int mitk::PointSet::GetNumberOfSelected( int t ) const
{
if ( (unsigned int) t >= m_PointSetSeries.size() )
{
return 0;
}
int numberOfSelected = 0;
PointDataIterator it;
for ( it = m_PointSetSeries[t]->GetPointData()->Begin();
it != m_PointSetSeries[t]->GetPointData()->End();
it++ )
{
if (it->Value().selected == true)
{
++numberOfSelected;
}
}
return numberOfSelected;
}
int mitk::PointSet::SearchSelectedPoint( int t ) const
{
if ( (unsigned int) t >= m_PointSetSeries.size() )
{
return -1;
}
PointDataIterator it;
for ( it = m_PointSetSeries[t]->GetPointData()->Begin();
it != m_PointSetSeries[t]->GetPointData()->End();
it++ )
{
if ( it->Value().selected == true )
{
return it->Index();
}
}
return -1;
}
void mitk::PointSet::ExecuteOperation( Operation* operation )
{
int timeStep = -1;
mitkCheckOperationTypeMacro(PointOperation, operation, pointOp);
if ( pointOp )
{
timeStep = this->GetTimeGeometry()->TimePointToTimeStep( pointOp->GetTimeInMS() );
}
if ( timeStep < 0 )
{
MITK_ERROR << "Time step (" << timeStep << ") outside of PointSet time bounds" << std::endl;
return;
}
switch (operation->GetOperationType())
{
case OpNOTHING:
break;
case OpINSERT://inserts the point at the given position and selects it.
{
int position = pointOp->GetIndex();
PointType pt;
pt.CastFrom(pointOp->GetPoint());
//transfer from world to index coordinates
mitk::Geometry3D* geometry = this->GetGeometry( timeStep );
if (geometry == NULL)
{
MITK_INFO<<"GetGeometry returned NULL!\n";
return;
}
geometry->WorldToIndex(pt, pt);
m_PointSetSeries[timeStep]->GetPoints()->InsertElement(position, pt);
PointDataType pointData =
{
static_cast<unsigned int>(pointOp->GetIndex()),
pointOp->GetSelected(),
pointOp->GetPointType()
};
m_PointSetSeries[timeStep]->GetPointData()
->InsertElement(position, pointData);
this->Modified();
//boundingbox has to be computed
m_CalculateBoundingBox = true;
this->InvokeEvent( PointSetAddEvent() );
this->OnPointSetChange();
}
break;
case OpMOVE://moves the point given by index
{
PointType pt;
pt.CastFrom(pointOp->GetPoint());
//transfer from world to index coordinates
this->GetGeometry( timeStep )->WorldToIndex(pt, pt);
// Copy new point into container
m_PointSetSeries[timeStep]->SetPoint(pointOp->GetIndex(), pt);
// Insert a default point data object to keep the containers in sync
// (if no point data object exists yet)
PointDataType pointData;
if ( !m_PointSetSeries[timeStep]->GetPointData( pointOp->GetIndex(), &pointData ) )
{
m_PointSetSeries[timeStep]->SetPointData( pointOp->GetIndex(), pointData );
}
this->OnPointSetChange();
this->Modified();
//boundingbox has to be computed anyway
m_CalculateBoundingBox = true;
this->InvokeEvent( PointSetMoveEvent() );
}
break;
case OpREMOVE://removes the point at given by position
{
m_PointSetSeries[timeStep]->GetPoints()->DeleteIndex((unsigned)pointOp->GetIndex());
m_PointSetSeries[timeStep]->GetPointData()->DeleteIndex((unsigned)pointOp->GetIndex());
this->OnPointSetChange();
this->Modified();
//boundingbox has to be computed anyway
m_CalculateBoundingBox = true;
this->InvokeEvent( PointSetRemoveEvent() );
}
break;
case OpSELECTPOINT://select the given point
{
PointDataType pointData = {0, false, PTUNDEFINED};
m_PointSetSeries[timeStep]->GetPointData(pointOp->GetIndex(), &pointData);
pointData.selected = true;
m_PointSetSeries[timeStep]->SetPointData(pointOp->GetIndex(), pointData);
this->Modified();
}
break;
case OpDESELECTPOINT://unselect the given point
{
PointDataType pointData = {0, false, PTUNDEFINED};
m_PointSetSeries[timeStep]->GetPointData(pointOp->GetIndex(), &pointData);
pointData.selected = false;
m_PointSetSeries[timeStep]->SetPointData(pointOp->GetIndex(), pointData);
this->Modified();
}
break;
case OpSETPOINTTYPE:
{
PointDataType pointData = {0, false, PTUNDEFINED};
m_PointSetSeries[timeStep]->GetPointData(pointOp->GetIndex(), &pointData);
pointData.pointSpec = pointOp->GetPointType();
m_PointSetSeries[timeStep]->SetPointData(pointOp->GetIndex(), pointData);
this->Modified();
}
break;
case OpMOVEPOINTUP: // swap content of point with ID pointOp->GetIndex() with the point preceding it in the container // move point position within the pointset
{
PointIdentifier currentID = pointOp->GetIndex();
/* search for point with this id and point that precedes this one in the data container */
PointsContainer::STLContainerType points = m_PointSetSeries[timeStep]->GetPoints()->CastToSTLContainer();
PointsContainer::STLContainerType::iterator it = points.find(currentID);
if (it == points.end()) // ID not found
break;
if (it == points.begin()) // we are at the first element, there is no previous element
break;
/* get and cache current point & pointdata and previous point & pointdata */
--it;
PointIdentifier prevID = it->first;
if (this->SwapPointContents(prevID, currentID, timeStep) == true)
this->Modified();
}
break;
case OpMOVEPOINTDOWN: // move point position within the pointset
{
PointIdentifier currentID = pointOp->GetIndex();
/* search for point with this id and point that succeeds this one in the data container */
PointsContainer::STLContainerType points = m_PointSetSeries[timeStep]->GetPoints()->CastToSTLContainer();
PointsContainer::STLContainerType::iterator it = points.find(currentID);
if (it == points.end()) // ID not found
break;
++it;
if (it == points.end()) // ID is already the last element, there is no succeeding element
break;
/* get and cache current point & pointdata and previous point & pointdata */
PointIdentifier nextID = it->first;
if (this->SwapPointContents(nextID, currentID, timeStep) == true)
this->Modified();
}
break;
default:
itkWarningMacro("mitkPointSet could not understrand the operation. Please check!");
break;
}
//to tell the mappers, that the data is modified and has to be updated
//only call modified if anything is done, so call in cases
//this->Modified();
mitk::OperationEndEvent endevent(operation);
((const itk::Object*)this)->InvokeEvent(endevent);
//*todo has to be done here, cause of update-pipeline not working yet
// As discussed lately, don't mess with the rendering from inside data structures
//mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::PointSet::UpdateOutputInformation()
{
if ( this->GetSource( ) )
{
this->GetSource( )->UpdateOutputInformation( );
}
//
// first make sure, that the associated time sliced geometry has
// the same number of geometry 3d's as PointSets are present
//
TimeGeometry* timeGeometry = GetTimeGeometry();
- if ( timeGeometry->GetNumberOfTimeSteps() != m_PointSetSeries.size() )
+ if ( timeGeometry->CountTimeSteps() != m_PointSetSeries.size() )
{
- itkExceptionMacro(<<"timeGeometry->GetNumberOfTimeSteps() != m_PointSetSeries.size() -- use Initialize(timeSteps) with correct number of timeSteps!");
+ itkExceptionMacro(<<"timeGeometry->CountTimeSteps() != m_PointSetSeries.size() -- use Initialize(timeSteps) with correct number of timeSteps!");
}
// This is needed to detect zero objects
mitk::ScalarType nullpoint[]={0,0,0,0,0,0};
BoundingBox::BoundsArrayType itkBoundsNull(nullpoint);
//
// Iterate over the PointSets and update the Geometry
// information of each of the items.
//
if (m_CalculateBoundingBox)
{
for ( unsigned int i = 0 ; i < m_PointSetSeries.size() ; ++i )
{
const DataType::BoundingBoxType *bb = m_PointSetSeries[i]->GetBoundingBox();
BoundingBox::BoundsArrayType itkBounds = bb->GetBounds();
if ( m_PointSetSeries[i].IsNull() || (m_PointSetSeries[i]->GetNumberOfPoints() == 0)
|| (itkBounds == itkBoundsNull) )
{
itkBounds = itkBoundsNull;
continue;
}
// Ensure minimal bounds of 1.0 in each dimension
for ( unsigned int j = 0; j < 3; ++j )
{
if ( itkBounds[j*2+1] - itkBounds[j*2] < 1.0 )
{
BoundingBox::CoordRepType center =
(itkBounds[j*2] + itkBounds[j*2+1]) / 2.0;
itkBounds[j*2] = center - 0.5;
itkBounds[j*2+1] = center + 0.5;
}
}
this->GetGeometry(i)->SetBounds(itkBounds);
}
m_CalculateBoundingBox = false;
}
this->GetTimeGeometry()->Update();
}
void mitk::PointSet::SetRequestedRegionToLargestPossibleRegion()
{
}
bool mitk::PointSet::RequestedRegionIsOutsideOfTheBufferedRegion()
{
return false;
}
bool mitk::PointSet::VerifyRequestedRegion()
{
return true;
}
void mitk::PointSet::SetRequestedRegion(const DataObject * )
{
}
void mitk::PointSet::PrintSelf( std::ostream& os, itk::Indent indent ) const
{
Superclass::PrintSelf(os, indent);
os << indent << "Number timesteps: " << m_PointSetSeries.size() << "\n";
unsigned int i = 0;
for (PointSetSeries::const_iterator it = m_PointSetSeries.begin(); it != m_PointSetSeries.end(); ++it)
{
os << indent << "Timestep " << i++ << ": \n";
MeshType::Pointer ps = *it;
itk::Indent nextIndent = indent.GetNextIndent();
ps->Print(os, nextIndent);
MeshType::PointsContainer* points = ps->GetPoints();
MeshType::PointDataContainer* datas = ps->GetPointData();
MeshType::PointDataContainer::Iterator dataIterator = datas->Begin();
for (MeshType::PointsContainer::Iterator pointIterator = points->Begin();
pointIterator != points->End();
++pointIterator, ++dataIterator)
{
os << nextIndent << "Point " << pointIterator->Index() << ": [";
os << pointIterator->Value().GetElement(0);
for (unsigned int i = 1; i < PointType::GetPointDimension(); ++i)
{
os << ", " << pointIterator->Value().GetElement(i);
}
os << "]";
os << ", selected: " << dataIterator->Value().selected << ", point spec: " << dataIterator->Value().pointSpec << "\n";
}
}
}
bool mitk::PointSet::SwapPointContents(PointIdentifier id1, PointIdentifier id2, int timeStep)
{
/* search and cache contents */
PointType p1;
if (m_PointSetSeries[timeStep]->GetPoint(id1, &p1) == false)
return false;
PointDataType data1;
if (m_PointSetSeries[timeStep]->GetPointData(id1, &data1) == false)
return false;
PointType p2;
if (m_PointSetSeries[timeStep]->GetPoint(id2, &p2) == false)
return false;
PointDataType data2;
if (m_PointSetSeries[timeStep]->GetPointData(id2, &data2) == false)
return false;
/* now swap contents */
m_PointSetSeries[timeStep]->SetPoint(id1, p2);
m_PointSetSeries[timeStep]->SetPointData(id1, data2);
m_PointSetSeries[timeStep]->SetPoint(id2, p1);
m_PointSetSeries[timeStep]->SetPointData(id2, data1);
return true;
}
bool mitk::PointSet::PointDataType::operator ==(const mitk::PointSet::PointDataType &other) const
{
return id == other.id && selected == other.selected && pointSpec == other.pointSpec;
}
bool mitk::Equal( const mitk::PointSet* leftHandSide, const mitk::PointSet* rightHandSide, mitk::ScalarType eps, bool verbose )
{
bool result = true;
if( rightHandSide == NULL )
{
if(verbose)
{
MITK_INFO << "[( PointSet )] rightHandSide NULL.";
}
return false;
}
if( leftHandSide == NULL )
{
if(verbose)
MITK_INFO << "[( PointSet )] leftHandSide NULL.";
return false;
}
if( !mitk::Equal(leftHandSide->GetGeometry(), rightHandSide->GetGeometry(), eps, verbose) )
{
if(verbose)
MITK_INFO << "[( PointSet )] Geometries differ.";
result = false;
}
if ( leftHandSide->GetSize() != rightHandSide->GetSize())
{
if(verbose)
MITK_INFO << "[( PointSet )] Number of points differ.";
result = false;
}
else
{
//if the size is equal, we compare the point values
mitk::Point3D pointLeftHandSide;
mitk::Point3D pointRightHandSide;
int numberOfIncorrectPoints = 0;
//Iterate over both pointsets in order to compare all points pair-wise
mitk::PointSet::PointsConstIterator end = leftHandSide->End();
for( mitk::PointSet::PointsConstIterator pointSetIteratorLeft = leftHandSide->Begin(), pointSetIteratorRight = rightHandSide->Begin();
pointSetIteratorLeft != end; ++pointSetIteratorLeft, ++pointSetIteratorRight) //iterate simultaneously over both sets
{
pointLeftHandSide = pointSetIteratorLeft.Value();
pointRightHandSide = pointSetIteratorRight.Value();
if( !mitk::Equal( pointLeftHandSide, pointRightHandSide, eps, verbose ) )
{
if(verbose)
MITK_INFO << "[( PointSet )] Point values are different.";
result = false;
numberOfIncorrectPoints++;
}
}
if((numberOfIncorrectPoints > 0) && verbose)
{
MITK_INFO << numberOfIncorrectPoints <<" of a total of " << leftHandSide->GetSize() << " points are different.";
}
}
return result;
}
diff --git a/Core/Code/DataManagement/mitkProportionalTimeGeometry.cpp b/Core/Code/DataManagement/mitkProportionalTimeGeometry.cpp
index 616162ea4c..cc3a1b90c0 100644
--- a/Core/Code/DataManagement/mitkProportionalTimeGeometry.cpp
+++ b/Core/Code/DataManagement/mitkProportionalTimeGeometry.cpp
@@ -1,222 +1,222 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkProportionalTimeGeometry.h>
#include <limits>
mitk::ProportionalTimeGeometry::ProportionalTimeGeometry() :
m_FirstTimePoint(0.0),
m_StepDuration(1.0)
{
}
mitk::ProportionalTimeGeometry::~ProportionalTimeGeometry()
{
}
void mitk::ProportionalTimeGeometry::Initialize()
{
m_FirstTimePoint = 0.0;
m_StepDuration = 1.0;
}
-mitk::TimeStepType mitk::ProportionalTimeGeometry::GetNumberOfTimeSteps () const
+mitk::TimeStepType mitk::ProportionalTimeGeometry::CountTimeSteps () const
{
return static_cast<TimeStepType>(m_GeometryVector.size() );
}
mitk::TimePointType mitk::ProportionalTimeGeometry::GetMinimumTimePoint () const
{
return m_FirstTimePoint;
}
mitk::TimePointType mitk::ProportionalTimeGeometry::GetMaximumTimePoint () const
{
- TimePointType timePoint = m_FirstTimePoint + m_StepDuration * GetNumberOfTimeSteps();
+ TimePointType timePoint = m_FirstTimePoint + m_StepDuration * CountTimeSteps();
if (timePoint >std::numeric_limits<TimePointType>().max())
timePoint = std::numeric_limits<TimePointType>().max();
return timePoint;
}
mitk::TimeBounds mitk::ProportionalTimeGeometry::GetTimeBounds () const
{
TimeBounds bounds;
bounds[0] = this->GetMinimumTimePoint();
bounds[1] = this->GetMaximumTimePoint();
return bounds;
}
bool mitk::ProportionalTimeGeometry::IsValidTimePoint (TimePointType timePoint) const
{
return this->GetMinimumTimePoint() <= timePoint && timePoint < this->GetMaximumTimePoint();
}
bool mitk::ProportionalTimeGeometry::IsValidTimeStep (TimeStepType timeStep) const
{
- return timeStep < this->GetNumberOfTimeSteps();
+ return timeStep < this->CountTimeSteps();
}
mitk::TimePointType mitk::ProportionalTimeGeometry::TimeStepToTimePoint( TimeStepType timeStep) const
{
if (m_FirstTimePoint <= std::numeric_limits<TimePointType>::min() ||
m_FirstTimePoint >= std::numeric_limits<TimePointType>::max() ||
m_StepDuration <= std::numeric_limits<TimePointType>::min() ||
m_StepDuration >= std::numeric_limits<TimePointType>::max())
{
return static_cast<TimePointType>(timeStep);
}
return m_FirstTimePoint + timeStep * m_StepDuration;
}
mitk::TimeStepType mitk::ProportionalTimeGeometry::TimePointToTimeStep( TimePointType timePoint) const
{
if (m_FirstTimePoint <= timePoint)
return static_cast<TimeStepType>((timePoint -m_FirstTimePoint) / m_StepDuration);
else
return 0;
}
mitk::Geometry3D::Pointer mitk::ProportionalTimeGeometry::GetGeometryForTimeStep( TimeStepType timeStep) const
{
if (IsValidTimeStep(timeStep))
{
return dynamic_cast<Geometry3D*>(m_GeometryVector[timeStep].GetPointer());
}
else
{
return 0;
}
}
mitk::Geometry3D::Pointer mitk::ProportionalTimeGeometry::GetGeometryForTimePoint(TimePointType timePoint) const
{
if (this->IsValidTimePoint(timePoint))
{
TimeStepType timeStep = this->TimePointToTimeStep(timePoint);
return this->GetGeometryForTimeStep(timeStep);
}
else
{
return 0;
}
}
mitk::Geometry3D::Pointer mitk::ProportionalTimeGeometry::GetGeometryCloneForTimeStep( TimeStepType timeStep) const
{
if (timeStep > m_GeometryVector.size())
return 0;
return m_GeometryVector[timeStep]->Clone();
}
bool mitk::ProportionalTimeGeometry::IsValid() const
{
bool isValid = true;
isValid &= m_GeometryVector.size() > 0;
isValid &= m_StepDuration > 0;
return isValid;
}
void mitk::ProportionalTimeGeometry::ClearAllGeometries()
{
m_GeometryVector.clear();
}
void mitk::ProportionalTimeGeometry::ReserveSpaceForGeometries(TimeStepType numberOfGeometries)
{
m_GeometryVector.reserve(numberOfGeometries);
}
void mitk::ProportionalTimeGeometry::Expand(mitk::TimeStepType size)
{
m_GeometryVector.reserve(size);
while (m_GeometryVector.size() < size)
{
m_GeometryVector.push_back(Geometry3D::New());
}
}
void mitk::ProportionalTimeGeometry::SetTimeStepGeometry(Geometry3D* geometry, TimeStepType timeStep)
{
assert(timeStep<=m_GeometryVector.size());
if (timeStep == m_GeometryVector.size())
m_GeometryVector.push_back(geometry);
m_GeometryVector[timeStep] = geometry;
}
itk::LightObject::Pointer mitk::ProportionalTimeGeometry::InternalClone() const
{
itk::LightObject::Pointer parent = Superclass::InternalClone();
ProportionalTimeGeometry::Pointer newTimeGeometry =
dynamic_cast<ProportionalTimeGeometry * > (parent.GetPointer());
newTimeGeometry->m_FirstTimePoint = this->m_FirstTimePoint;
newTimeGeometry->m_StepDuration = this->m_StepDuration;
newTimeGeometry->m_GeometryVector.clear();
- newTimeGeometry->Expand(this->GetNumberOfTimeSteps());
- for (TimeStepType i =0; i < GetNumberOfTimeSteps(); ++i)
+ newTimeGeometry->Expand(this->CountTimeSteps());
+ for (TimeStepType i =0; i < CountTimeSteps(); ++i)
{
Geometry3D::Pointer tempGeometry = GetGeometryForTimeStep(i)->Clone();
newTimeGeometry->SetTimeStepGeometry(tempGeometry.GetPointer(),i);
}
return parent;
}
void mitk::ProportionalTimeGeometry::Initialize (Geometry3D* geometry, TimeStepType timeSteps)
{
timeSteps = (timeSteps > 0) ? timeSteps : 1;
m_FirstTimePoint = geometry->GetTimeBounds()[0];
m_StepDuration = geometry->GetTimeBounds()[1] - geometry->GetTimeBounds()[0];
this->ReserveSpaceForGeometries(timeSteps);
try{
for (TimeStepType currentStep = 0; currentStep < timeSteps; ++currentStep)
{
mitk::TimeBounds timeBounds;
if (timeSteps > 1)
{
timeBounds[0] = m_FirstTimePoint + currentStep * m_StepDuration;
timeBounds[1] = m_FirstTimePoint + (currentStep+1) * m_StepDuration;
}
else
{
timeBounds = geometry->GetTimeBounds();
}
Geometry3D::Pointer clonedGeometry = geometry->Clone();
this->SetTimeStepGeometry(clonedGeometry.GetPointer(), currentStep);
GetGeometryForTimeStep(currentStep)->SetTimeBounds(timeBounds);
}
}
catch (...)
{
MITK_INFO << "Cloning of geometry produced an error!";
}
Update();
}
void mitk::ProportionalTimeGeometry::Initialize (TimeStepType timeSteps)
{
mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
geometry->Initialize();
if ( timeSteps > 1 )
{
mitk::ScalarType timeBounds[] = {0.0, 1.0};
geometry->SetTimeBounds( timeBounds );
}
this->Initialize(geometry.GetPointer(), timeSteps);
}
diff --git a/Core/Code/DataManagement/mitkProportionalTimeGeometry.h b/Core/Code/DataManagement/mitkProportionalTimeGeometry.h
index ce2b96e28f..d3b384aef6 100644
--- a/Core/Code/DataManagement/mitkProportionalTimeGeometry.h
+++ b/Core/Code/DataManagement/mitkProportionalTimeGeometry.h
@@ -1,204 +1,204 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef ProportionalTimeGeometry_h
#define ProportionalTimeGeometry_h
//MITK
#include <mitkTimeGeometry.h>
#include <mitkCommon.h>
#include <MitkExports.h>
namespace mitk {
/**
* \brief Organizes geometries over proportional time steps
*
* For this TimeGeometry implementation it is assumed that
* the durations of the time steps are equidistant, e.g.
* the durations of the time steps in one ProportionalTimeGeometry
* are the same. The geometries of the time steps are independent,
* and not linked to each other. Since the timeBounds of the
* geometries are different for each time step it is not possible
* to set the same geometry to different time steps. Instead
* copies should be used.
*
* \addtogroup geometry
*/
class MITK_CORE_EXPORT ProportionalTimeGeometry : public TimeGeometry
{
public:
mitkClassMacro(ProportionalTimeGeometry, TimeGeometry);
ProportionalTimeGeometry();
typedef ProportionalTimeGeometry self;
itkNewMacro(self);
/**
* \brief Returns the number of time steps.
*
* Returns the number of time steps for which
* geometries are saved. The number of time steps
* is also the upper bound of the time steps. The
* minimum time steps is always 0.
*/
- virtual TimeStepType GetNumberOfTimeSteps() const;
+ virtual TimeStepType CountTimeSteps() const;
/**
* \brief Returns the first time point for which the object is valid.
*
* Returns the first valid time point for this geometry. If only one
* time steps available it usually goes from -max to +max. The time point
* is given in ms.
*/
virtual TimePointType GetMinimumTimePoint () const;
/**
* \brief Returns the last time point for which the object is valid
*
* Gives the last time point for which a valid geometrie is saved in
* this time geometry. The time point is given in ms.
*/
virtual TimePointType GetMaximumTimePoint () const;
/**
* \brief Get the time bounds (in ms)
*/
virtual TimeBounds GetTimeBounds( ) const;
/**
* \brief Tests if a given time point is covered by this object
*
* Returns true if a geometry can be returned for the given time
* point and falls if not. The time point must be given in ms.
*/
virtual bool IsValidTimePoint (TimePointType timePoint) const;
/**
* \brief Test for the given time step if a geometry is availible
*
* Returns true if a geometry is defined for the given time step.
* Otherwise false is returned.
* The time step is defined as positiv number.
*/
virtual bool IsValidTimeStep (TimeStepType timeStep) const;
/**
* \brief Converts a time step to a time point
*
* Converts a time step to a time point in a way that
* the new time point indicates the same geometry as the time step.
* If the original time steps does not point to a valid geometry,
* a time point is calculated that also does not point to a valid
* geometry, but no exception is raised.
*/
virtual TimePointType TimeStepToTimePoint (TimeStepType timeStep) const;
/**
* \brief Converts a time point to the corresponding time step
*
* Converts a time point to a time step in a way that
* the new time step indicates the same geometry as the time point.
* If a negativ invalid time point is given always time step 0 is
* returned. If an positiv invalid time step is given an invalid
* time step will be returned.
*/
virtual TimeStepType TimePointToTimeStep (TimePointType timePoint) const;
/**
* \brief Returns the geometry which corresponds to the given time step
*
* Returns a clone of the geometry which defines the given time step. If
* the given time step is invalid an null-pointer is returned.
*/
virtual Geometry3D::Pointer GetGeometryCloneForTimeStep( TimeStepType timeStep) const;
/**
* \brief Returns the geometry which corresponds to the given time point
*
* Returns the geometry which defines the given time point. If
* the given time point is invalid an null-pointer is returned.
*
* If the returned geometry is changed this will affect the saved
* geometry.
*/
virtual Geometry3D::Pointer GetGeometryForTimePoint ( TimePointType timePoint) const;
/**
* \brief Returns the geometry which corresponds to the given time step
*
* Returns the geometry which defines the given time step. If
* the given time step is invalid an null-pointer is returned.
*
* If the returned geometry is changed this will affect the saved
* geometry.
*/
virtual Geometry3D::Pointer GetGeometryForTimeStep ( TimeStepType timeStep) const;
/**
* \brief Tests if all necessary informations are set and the object is valid
*/
virtual bool IsValid () const;
/**
* \brief Initilizes a new object with one time steps which contains an empty geometry.
*/
virtual void Initialize();
/**
* \brief Expands the time geometry to the given number of time steps.
*
* Initializes the new time steps with empty geometries.
* Shrinking is not supported.
*/
virtual void Expand(TimeStepType size);
/**
* \brief Sets the geometry for the given time step
*
* This method does not afflict other time steps, since the geometry for
* each time step is saved individually.
*/
virtual void SetTimeStepGeometry(Geometry3D* geometry, TimeStepType timeStep);
/**
* \brief Makes a deep copy of the current object
*/
virtual itk::LightObject::Pointer InternalClone () const;
itkGetMacro(FirstTimePoint, TimePointType);
itkSetMacro(FirstTimePoint, TimePointType);
itkGetMacro(StepDuration, TimePointType);
itkSetMacro(StepDuration, TimePointType);
// void SetGeometryForTimeStep(TimeStepType timeStep, BaseGeometry& geometry);
void ClearAllGeometries ();
// void AddGeometry(BaseGeometry geometry);
void ReserveSpaceForGeometries (TimeStepType numberOfGeometries);
/**
* \brief Initializes the TimeGeometry with equally time Step geometries
*
* Saves a copy for each time step.
*/
void Initialize (Geometry3D* geometry, TimeStepType timeSteps);
/**
* \brief Initialize the TimeGeometry with empty Geometry3D
*/
void Initialize (TimeStepType timeSteps);
protected:
virtual ~ProportionalTimeGeometry();
std::vector<Geometry3D::Pointer> m_GeometryVector;
TimePointType m_FirstTimePoint;
TimePointType m_StepDuration;
}; // end class ProportialTimeGeometry
} // end namespace MITK
#endif // ProportionalTimeGeometry_h
\ No newline at end of file
diff --git a/Core/Code/DataManagement/mitkSlicedData.cpp b/Core/Code/DataManagement/mitkSlicedData.cpp
index 48d727bbfa..cdee90cce8 100644
--- a/Core/Code/DataManagement/mitkSlicedData.cpp
+++ b/Core/Code/DataManagement/mitkSlicedData.cpp
@@ -1,344 +1,344 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkSlicedData.h"
#include "mitkBaseProcess.h"
#include <mitkProportionalTimeGeometry.h>
mitk::SlicedData::SlicedData() : m_UseLargestPossibleRegion(false)
{
unsigned int i;
for(i=0;i<4;++i)
{
m_LargestPossibleRegion.SetIndex(i, 0);
m_LargestPossibleRegion.SetSize (i, 1);
}
}
mitk::SlicedData::SlicedData( const SlicedData &other ): BaseData(other),
m_LargestPossibleRegion(other.m_LargestPossibleRegion),
m_RequestedRegion(other.m_RequestedRegion),
m_BufferedRegion(other.m_BufferedRegion),
m_UseLargestPossibleRegion(other.m_UseLargestPossibleRegion)
{
}
mitk::SlicedData::~SlicedData()
{
}
void mitk::SlicedData::UpdateOutputInformation()
{
Superclass::UpdateOutputInformation();
if (this->GetSource().IsNull())
// If we don't have a source, then let's make our Image
// span our buffer
{
m_UseLargestPossibleRegion = true;
}
// Now we should know what our largest possible region is. If our
// requested region was not set yet, (or has been set to something
// invalid - with no data in it ) then set it to the largest possible
// region.
if ( ! m_RequestedRegionInitialized)
{
this->SetRequestedRegionToLargestPossibleRegion();
m_RequestedRegionInitialized = true;
}
m_LastRequestedRegionWasOutsideOfTheBufferedRegion = 0;
}
void mitk::SlicedData::PrepareForNewData()
{
if ( GetUpdateMTime() < GetPipelineMTime() || GetDataReleased() )
{
ReleaseData();
}
}
void mitk::SlicedData::SetRequestedRegionToLargestPossibleRegion()
{
m_UseLargestPossibleRegion = true;
if(GetGeometry()==NULL)
return;
unsigned int i;
const RegionType::IndexType & index = GetLargestPossibleRegion().GetIndex();
const RegionType::SizeType & size = GetLargestPossibleRegion().GetSize();
for(i=0;i<RegionDimension;++i)
{
m_RequestedRegion.SetIndex(i, index[i]);
m_RequestedRegion.SetSize(i, size[i]);
}
}
bool mitk::SlicedData::RequestedRegionIsOutsideOfTheBufferedRegion()
{
// Is the requested region within the currently buffered data?
// SlicedData and subclasses store entire volumes or slices. The
// methods IsVolumeSet() and IsSliceSet are provided to check,
// a volume or slice, respectively, is available. Thus, these
// methods used here.
const IndexType &requestedRegionIndex = m_RequestedRegion.GetIndex();
const SizeType& requestedRegionSize = m_RequestedRegion.GetSize();
const SizeType& largestPossibleRegionSize
= GetLargestPossibleRegion().GetSize();
// are whole channels requested?
int c, cEnd;
c=requestedRegionIndex[4];
cEnd=c+static_cast<long>(requestedRegionSize[4]);
if(requestedRegionSize[3] == largestPossibleRegionSize[3])
{
for (; c< cEnd; ++c)
if(IsChannelSet(c)==false) return true;
return false;
}
// are whole volumes requested?
int t, tEnd;
t=requestedRegionIndex[3];
tEnd=t+static_cast<long>(requestedRegionSize[3]);
if(requestedRegionSize[2] == largestPossibleRegionSize[2])
{
for (; c< cEnd; ++c)
for (; t< tEnd; ++t)
if(IsVolumeSet(t, c)==false) return true;
return false;
}
// ok, only slices are requested. Check if they are available.
int s, sEnd;
s=requestedRegionIndex[2];
sEnd=s+static_cast<long>(requestedRegionSize[2]);
for (; c< cEnd; ++c)
for (; t< tEnd; ++t)
for (; s< sEnd; ++s)
if(IsSliceSet(s, t, c)==false) return true;
return false;
}
bool mitk::SlicedData::VerifyRequestedRegion()
{
if(GetTimeGeometry() == NULL) return false;
unsigned int i;
// Is the requested region within the LargestPossibleRegion?
// Note that the test is indeed against the largest possible region
// rather than the buffered region; see DataObject::VerifyRequestedRegion.
const IndexType &requestedRegionIndex = m_RequestedRegion.GetIndex();
const IndexType &largestPossibleRegionIndex
= GetLargestPossibleRegion().GetIndex();
const SizeType& requestedRegionSize = m_RequestedRegion.GetSize();
const SizeType& largestPossibleRegionSize
= GetLargestPossibleRegion().GetSize();
for (i=0; i< RegionDimension; ++i)
{
if ( (requestedRegionIndex[i] < largestPossibleRegionIndex[i]) ||
((requestedRegionIndex[i] + static_cast<long>(requestedRegionSize[i]))
> (largestPossibleRegionIndex[i]+static_cast<long>(largestPossibleRegionSize[i]))))
{
return false;
}
}
return true;
}
void mitk::SlicedData::SetRequestedRegion( const itk::DataObject *data)
{
m_UseLargestPossibleRegion=false;
const mitk::SlicedData *slicedData = dynamic_cast<const mitk::SlicedData*>(data);
if (slicedData)
{
m_RequestedRegion = slicedData->GetRequestedRegion();
m_RequestedRegionInitialized = true;
}
else
{
// pointer could not be cast back down
itkExceptionMacro( << "mitk::SlicedData::SetRequestedRegion(DataObject*) cannot cast " << typeid(data).name() << " to " << typeid(SlicedData*).name() );
}
}
void mitk::SlicedData::SetRequestedRegion(SlicedData::RegionType *region)
{
m_UseLargestPossibleRegion=false;
if(region!=NULL)
{
m_RequestedRegion = *region;
m_RequestedRegionInitialized = true;
}
else
{
// pointer could not be cast back down
itkExceptionMacro( << "mitk::SlicedData::SetRequestedRegion(SlicedData::RegionType*) cannot cast " << typeid(region).name() << " to " << typeid(SlicedData*).name() );
}
}
void mitk::SlicedData::CopyInformation(const itk::DataObject *data)
{
// Standard call to the superclass' method
Superclass::CopyInformation(data);
const mitk::SlicedData *slicedData;
slicedData = dynamic_cast<const mitk::SlicedData*>(data);
if (slicedData)
{
m_LargestPossibleRegion = slicedData->GetLargestPossibleRegion();
}
else
{
// pointer could not be cast back down
itkExceptionMacro( << "mitk::SlicedData::CopyInformation(const DataObject *data) cannot cast " << typeid(data).name() << " to " << typeid(SlicedData*).name() );
}
}
//const mitk::Geometry2D* mitk::SlicedData::GetGeometry2D(int s, int t) const
//{
// const_cast<SlicedData*>(this)->SetRequestedRegionToLargestPossibleRegion();
//
// const_cast<SlicedData*>(this)->UpdateOutputInformation();
//
// return GetSlicedGeometry(t)->GetGeometry2D(s);
//}
//
mitk::SlicedGeometry3D* mitk::SlicedData::GetSlicedGeometry(unsigned int t) const
{
if (GetTimeGeometry() == NULL)
return NULL;
return dynamic_cast<SlicedGeometry3D*>(GetTimeGeometry()->GetGeometryForTimeStep(t).GetPointer());
}
const mitk::SlicedGeometry3D* mitk::SlicedData::GetUpdatedSlicedGeometry(unsigned int t)
{
SetRequestedRegionToLargestPossibleRegion();
UpdateOutputInformation();
return GetSlicedGeometry(t);
}
void mitk::SlicedData::SetGeometry(Geometry3D* aGeometry3D)
{
if(aGeometry3D!=NULL)
{
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
SlicedGeometry3D::Pointer slicedGeometry = dynamic_cast<SlicedGeometry3D*>(aGeometry3D);
if(slicedGeometry.IsNull())
{
Geometry2D* geometry2d = dynamic_cast<Geometry2D*>(aGeometry3D);
if(geometry2d!=NULL)
{
if((GetSlicedGeometry()->GetGeometry2D(0)==geometry2d) && (GetSlicedGeometry()->GetSlices()==1))
return;
slicedGeometry = SlicedGeometry3D::New();
slicedGeometry->InitializeEvenlySpaced(geometry2d, 1);
}
else
{
slicedGeometry = SlicedGeometry3D::New();
PlaneGeometry::Pointer planeGeometry = PlaneGeometry::New();
planeGeometry->InitializeStandardPlane(aGeometry3D);
slicedGeometry->InitializeEvenlySpaced(planeGeometry, (unsigned int)(aGeometry3D->GetExtent(2)));
}
}
assert(slicedGeometry.IsNotNull());
timeGeometry->Initialize(slicedGeometry, 1);
Superclass::SetTimeGeometry(timeGeometry);
}
else
{
if(GetGeometry()==NULL)
return;
Superclass::SetGeometry(NULL);
}
}
void mitk::SlicedData::SetSpacing(const float aSpacing[3])
{
this->SetSpacing((mitk::Vector3D)aSpacing);
}
void mitk::SlicedData::SetOrigin(const mitk::Point3D& origin)
{
TimeGeometry* timeGeometry = GetTimeGeometry();
assert(timeGeometry!=NULL);
mitk::SlicedGeometry3D* slicedGeometry;
- unsigned int steps = timeGeometry->GetNumberOfTimeSteps();
+ unsigned int steps = timeGeometry->CountTimeSteps();
for(unsigned int timestep = 0; timestep < steps; ++timestep)
{
slicedGeometry = GetSlicedGeometry(timestep);
if(slicedGeometry != NULL)
{
slicedGeometry->SetOrigin(origin);
if(slicedGeometry->GetEvenlySpaced())
{
mitk::Geometry2D* geometry2D = slicedGeometry->GetGeometry2D(0);
geometry2D->SetOrigin(origin);
slicedGeometry->InitializeEvenlySpaced(geometry2D, slicedGeometry->GetSlices());
}
}
//ProportionalTimeGeometry* timeGeometry = dynamic_cast<ProportionalTimeGeometry *>(GetTimeGeometry());
//if(timeGeometry != NULL)
//{
// timeGeometry->Initialize(slicedGeometry, steps);
// break;
//}
}
}
void mitk::SlicedData::SetSpacing(mitk::Vector3D aSpacing)
{
TimeGeometry* timeGeometry = GetTimeGeometry();
assert(timeGeometry!=NULL);
mitk::SlicedGeometry3D* slicedGeometry;
- unsigned int steps = timeGeometry->GetNumberOfTimeSteps();
+ unsigned int steps = timeGeometry->CountTimeSteps();
for(unsigned int timestep = 0; timestep < steps; ++timestep)
{
slicedGeometry = GetSlicedGeometry(timestep);
if(slicedGeometry != NULL)
{
slicedGeometry->SetSpacing(aSpacing);
}
}
timeGeometry->Update();
}
diff --git a/Core/Code/DataManagement/mitkSurface.cpp b/Core/Code/DataManagement/mitkSurface.cpp
index 0a390a5b8b..ed93ff4ee2 100644
--- a/Core/Code/DataManagement/mitkSurface.cpp
+++ b/Core/Code/DataManagement/mitkSurface.cpp
@@ -1,541 +1,541 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkSurface.h"
#include "mitkInteractionConst.h"
#include "mitkSurfaceOperation.h"
#include <algorithm>
#include <vtkPolyData.h>
#include <mitkTesting.h>
static vtkPolyData* DeepCopy(vtkPolyData* other)
{
if (other == NULL)
return NULL;
vtkPolyData* copy = vtkPolyData::New();
copy->DeepCopy(other);
return copy;
}
static void Delete(vtkPolyData* polyData)
{
if (polyData != NULL)
polyData->Delete();
}
static void Update(vtkPolyData* polyData)
{
if (polyData != NULL)
polyData->Update();
}
mitk::Surface::Surface()
: m_CalculateBoundingBox(false)
{
this->InitializeEmpty();
}
mitk::Surface::Surface(const mitk::Surface& other)
: BaseData(other),
m_LargestPossibleRegion(other.m_LargestPossibleRegion),
m_RequestedRegion(other.m_RequestedRegion),
m_CalculateBoundingBox(other.m_CalculateBoundingBox)
{
if(!other.m_PolyDatas.empty())
{
m_PolyDatas.resize(other.m_PolyDatas.size());
std::transform(other.m_PolyDatas.begin(), other.m_PolyDatas.end(), m_PolyDatas.begin(), DeepCopy);
}
else
{
this->InitializeEmpty();
}
}
void mitk::Surface::Swap(mitk::Surface& other)
{
std::swap(m_PolyDatas, other.m_PolyDatas);
std::swap(m_LargestPossibleRegion, other.m_LargestPossibleRegion);
std::swap(m_RequestedRegion, other.m_RequestedRegion);
std::swap(m_CalculateBoundingBox, other.m_CalculateBoundingBox);
}
mitk::Surface& mitk::Surface::operator=(Surface other)
{
this->Swap(other);
return *this;
}
mitk::Surface::~Surface()
{
this->ClearData();
}
void mitk::Surface::ClearData()
{
using ::Delete;
std::for_each(m_PolyDatas.begin(), m_PolyDatas.end(), Delete);
m_PolyDatas.clear();
Superclass::ClearData();
}
const mitk::Surface::RegionType& mitk::Surface::GetLargestPossibleRegion() const
{
m_LargestPossibleRegion.SetIndex(3, 0);
- m_LargestPossibleRegion.SetSize(3, GetTimeGeometry()->GetNumberOfTimeSteps());
+ m_LargestPossibleRegion.SetSize(3, GetTimeGeometry()->CountTimeSteps());
return m_LargestPossibleRegion;
}
const mitk::Surface::RegionType& mitk::Surface::GetRequestedRegion() const
{
return m_RequestedRegion;
}
void mitk::Surface::InitializeEmpty()
{
if (!m_PolyDatas.empty())
this->ClearData();
Superclass::InitializeTimeGeometry();
m_PolyDatas.push_back(NULL);
m_Initialized = true;
}
void mitk::Surface::SetVtkPolyData(vtkPolyData* polyData, unsigned int t)
{
this->Expand(t + 1);
if (m_PolyDatas[t] != NULL)
{
if (m_PolyDatas[t] == polyData)
return;
m_PolyDatas[t]->Delete();
}
m_PolyDatas[t] = polyData;
if(polyData != NULL)
polyData->Register(NULL);
m_CalculateBoundingBox = true;
this->Modified();
this->UpdateOutputInformation();
}
bool mitk::Surface::IsEmptyTimeStep(unsigned int t) const
{
if(!IsInitialized())
return false;
vtkPolyData* polyData = const_cast<Surface*>(this)->GetVtkPolyData(t);
return polyData == NULL || (
polyData->GetNumberOfLines() == 0 &&
polyData->GetNumberOfPolys() == 0 &&
polyData->GetNumberOfStrips() == 0 &&
polyData->GetNumberOfVerts() == 0
);
}
vtkPolyData* mitk::Surface::GetVtkPolyData(unsigned int t)
{
if (t < m_PolyDatas.size())
{
if(m_PolyDatas[t] == NULL && this->GetSource().IsNotNull())
{
RegionType requestedRegion;
requestedRegion.SetIndex(3, t);
requestedRegion.SetSize(3, 1);
this->SetRequestedRegion(&requestedRegion);
this->GetSource()->Update();
}
return m_PolyDatas[t];
}
return NULL;
}
void mitk::Surface::UpdateOutputInformation()
{
if (this->GetSource().IsNotNull())
this->GetSource()->UpdateOutputInformation();
if (m_CalculateBoundingBox == true && !m_PolyDatas.empty())
this->CalculateBoundingBox();
else
this->GetTimeGeometry()->Update();
}
void mitk::Surface::CalculateBoundingBox()
{
TimeGeometry* timeGeometry = this->GetTimeGeometry();
- if (timeGeometry->GetNumberOfTimeSteps() != m_PolyDatas.size())
+ if (timeGeometry->CountTimeSteps() != m_PolyDatas.size())
mitkThrow() << "Number of geometry time steps is inconsistent with number of poly data pointers.";
for (unsigned int i = 0; i < m_PolyDatas.size(); ++i)
{
vtkPolyData* polyData = m_PolyDatas[i];
vtkFloatingPointType bounds[6] = {0};
if (polyData != NULL && polyData->GetNumberOfPoints() > 0)
{
polyData->Update();
polyData->ComputeBounds();
polyData->GetBounds(bounds);
}
Geometry3D::Pointer geometry = timeGeometry->GetGeometryForTimeStep(i);
if (geometry.IsNull())
mitkThrow() << "Time-sliced geometry is invalid (equals NULL).";
geometry->SetFloatBounds(bounds);
}
timeGeometry->Update();
m_CalculateBoundingBox = false;
}
void mitk::Surface::SetRequestedRegionToLargestPossibleRegion()
{
m_RequestedRegion = GetLargestPossibleRegion();
}
bool mitk::Surface::RequestedRegionIsOutsideOfTheBufferedRegion()
{
RegionType::IndexValueType end = m_RequestedRegion.GetIndex(3) + m_RequestedRegion.GetSize(3);
if(static_cast<RegionType::IndexValueType>(m_PolyDatas.size()) < end)
return true;
for(RegionType::IndexValueType t = m_RequestedRegion.GetIndex(3); t < end; ++t)
{
if(m_PolyDatas[t] == NULL)
return true;
}
return false;
}
bool mitk::Surface::VerifyRequestedRegion()
{
if(m_RequestedRegion.GetIndex(3) >= 0 && m_RequestedRegion.GetIndex(3) + m_RequestedRegion.GetSize(3) <= m_PolyDatas.size())
return true;
return false;
}
void mitk::Surface::SetRequestedRegion(const itk::DataObject* data )
{
const mitk::Surface *surface = dynamic_cast<const mitk::Surface*>(data);
if (surface != NULL)
m_RequestedRegion = surface->GetRequestedRegion();
else
mitkThrow() << "Data object used to get requested region is not a mitk::Surface.";
}
void mitk::Surface::SetRequestedRegion(Surface::RegionType* region)
{
if (region == NULL)
mitkThrow() << "Requested region is invalid (equals NULL)";
m_RequestedRegion = *region;
}
void mitk::Surface::CopyInformation(const itk::DataObject* data)
{
Superclass::CopyInformation(data);
const mitk::Surface* surface = dynamic_cast<const mitk::Surface*>(data);
if (surface == NULL)
mitkThrow() << "Data object used to get largest possible region is not a mitk::Surface.";
m_LargestPossibleRegion = surface->GetLargestPossibleRegion();
}
void mitk::Surface::Update()
{
using ::Update;
if (this->GetSource().IsNull())
std::for_each(m_PolyDatas.begin(), m_PolyDatas.end(), Update);
Superclass::Update();
}
void mitk::Surface::Expand(unsigned int timeSteps)
{
if (timeSteps > m_PolyDatas.size())
{
Superclass::Expand(timeSteps);
m_PolyDatas.resize(timeSteps);
m_CalculateBoundingBox = true;
}
}
void mitk::Surface::ExecuteOperation(Operation* operation)
{
switch (operation->GetOperationType())
{
case OpSURFACECHANGED:
{
mitk::SurfaceOperation* surfaceOperation = dynamic_cast<mitk::SurfaceOperation*>(operation);
if(surfaceOperation == NULL)
break;
unsigned int timeStep = surfaceOperation->GetTimeStep();
if(m_PolyDatas[timeStep] != NULL)
{
vtkPolyData* updatedPolyData = surfaceOperation->GetVtkPolyData();
if(updatedPolyData != NULL)
{
this->SetVtkPolyData(updatedPolyData, timeStep);
this->CalculateBoundingBox();
this->Modified();
}
}
break;
}
default:
return;
}
}
unsigned int mitk::Surface::GetSizeOfPolyDataSeries() const
{
return m_PolyDatas.size();
}
void mitk::Surface::Graft(const DataObject* data)
{
const Surface* surface = dynamic_cast<const Surface*>(data);
if(surface == NULL)
mitkThrow() << "Data object used to graft surface is not a mitk::Surface.";
this->CopyInformation(data);
m_PolyDatas.clear();
for (unsigned int i = 0; i < surface->GetSizeOfPolyDataSeries(); ++i)
{
m_PolyDatas.push_back(vtkPolyData::New());
m_PolyDatas.back()->DeepCopy(const_cast<mitk::Surface*>(surface)->GetVtkPolyData(i));
}
}
void mitk::Surface::PrintSelf(std::ostream& os, itk::Indent indent) const
{
Superclass::PrintSelf(os, indent);
os << indent << "\nNumber PolyDatas: " << m_PolyDatas.size() << "\n";
unsigned int count = 0;
for (std::vector<vtkPolyData*>::const_iterator it = m_PolyDatas.begin(); it != m_PolyDatas.end(); ++it)
{
os << "\n";
if(*it != NULL)
{
os << indent << "PolyData at time step " << count << ":\n";
os << indent << "Number of cells: " << (*it)->GetNumberOfCells() << "\n";
os << indent << "Number of points: " << (*it)->GetNumberOfPoints() << "\n\n";
os << indent << "VTKPolyData:\n";
(*it)->Print(os);
}
else
{
os << indent << "Empty PolyData at time step " << count << "\n";
}
++count;
}
}
bool mitk::Equal( vtkPolyData* leftHandSide, vtkPolyData* rightHandSide, mitk::ScalarType eps, bool verbose )
{
bool noDifferenceFound = true;
if( rightHandSide == NULL )
{
if(verbose)
{
MITK_INFO << "[Equal( vtkPolyData*, vtkPolyData* )] rightHandSide NULL.";
}
return false;
}
if( leftHandSide == NULL )
{
if(verbose)
{
MITK_INFO << "[Equal( vtkPolyData*, vtkPolyData* )] leftHandSide NULL.";
}
return false;
}
if( ! mitk::Equal( leftHandSide->GetNumberOfCells(), rightHandSide->GetNumberOfCells(), eps, verbose ) )
{
if(verbose)
MITK_INFO << "[Equal( vtkPolyData*, vtkPolyData* )] Number of cells not equal";
noDifferenceFound = false;
}
if( ! mitk::Equal( leftHandSide->GetNumberOfVerts(), rightHandSide->GetNumberOfVerts(), eps, verbose ))
{
if(verbose)
MITK_INFO << "[Equal( vtkPolyData*, vtkPolyData* )] Number of vertices not equal";
noDifferenceFound = false;
}
if( ! mitk::Equal( leftHandSide->GetNumberOfLines(), rightHandSide->GetNumberOfLines(), eps, verbose ) )
{
if(verbose)
MITK_INFO << "[Equal( vtkPolyData*, vtkPolyData* )] Number of lines not equal";
noDifferenceFound = false;
}
if( ! mitk::Equal( leftHandSide->GetNumberOfPolys(), rightHandSide->GetNumberOfPolys(), eps, verbose ) )
{
if(verbose)
MITK_INFO << "[Equal( vtkPolyData*, vtkPolyData* )] Number of polys not equal";
noDifferenceFound = false;
}
if( ! mitk::Equal( leftHandSide->GetNumberOfStrips(), rightHandSide->GetNumberOfStrips(), eps, verbose ) )
{
if(verbose)
MITK_INFO << "[Equal( vtkPolyData*, vtkPolyData* )] Number of strips not equal";
noDifferenceFound = false;
}
{
unsigned int numberOfPointsRight = rightHandSide->GetPoints()->GetNumberOfPoints();
unsigned int numberOfPointsLeft = leftHandSide->GetPoints()->GetNumberOfPoints();
if(! mitk::Equal( numberOfPointsLeft, numberOfPointsRight, eps, verbose ))
{
if(verbose)
MITK_INFO << "[Equal( vtkPolyData*, vtkPolyData* )] Number of points not equal";
noDifferenceFound = false;
}
else
{
for( unsigned int i( 0 ); i < numberOfPointsRight; i++ )
{
bool pointFound = false;
double pointOne[3];
rightHandSide->GetPoints()->GetPoint(i, pointOne);
for( unsigned int j( 0 ); j < numberOfPointsLeft; j++ )
{
double pointTwo[3];
leftHandSide->GetPoints()->GetPoint(j, pointTwo);
double x = pointOne[0] - pointTwo[0];
double y = pointOne[1] - pointTwo[1];
double z = pointOne[2] - pointTwo[2];
double distance = x*x + y*y + z*z;
if( distance < eps )
{
pointFound = true;
break;
}
}
if( !pointFound )
{
if(verbose)
{
MITK_INFO << "[Equal( vtkPolyData*, vtkPolyData* )] Right hand side point with id " << i << " and coordinates ( "
<< std::setprecision(12)
<< pointOne[0] << " ; " << pointOne[1] << " ; " << pointOne[2]
<< " ) could not be found in left hand side with epsilon " << eps << ".";
}
noDifferenceFound = false;
break;
}
}
}
}
return noDifferenceFound;
}
bool mitk::Equal( mitk::Surface* leftHandSide, mitk::Surface* rightHandSide, mitk::ScalarType eps, bool verbose )
{
bool noDifferenceFound = true;
if( rightHandSide == NULL )
{
if(verbose)
MITK_INFO << "[Equal( mitk::surface*, mitk::surface* )] rightHandSide NULL.";
return false;
}
if( leftHandSide == NULL )
{
if(verbose)
MITK_INFO << "[Equal( mitk::surface*, mitk::surface* )] leftHandSide NULL.";
return false;
}
if( ! mitk::Equal( leftHandSide->GetSizeOfPolyDataSeries(), rightHandSide->GetSizeOfPolyDataSeries(), eps, verbose ) )
{
if(verbose)
MITK_INFO << "[Equal( mitk::surface*, mitk::surface* )] Size of PolyData series not equal.";
noDifferenceFound = false;
}
// No mitk::Equal for TimeGeometry implemented.
//if( ! mitk::Equal( leftHandSide->GetTimeGeometry(), rightHandSide->GetTimeGeometry(), eps, verbose ) )
//{
// if(verbose)
// MITK_INFO << "[Equal( mitk::surface*, mitk::surface* )] Time sliced geometries not equal";
// noDifferenceFound = false;
//}
for( unsigned int i( 0 ); i < rightHandSide->GetSizeOfPolyDataSeries(); i++ )
{
if( ! mitk::Equal( leftHandSide->GetVtkPolyData( i ), rightHandSide->GetVtkPolyData( i ), eps, verbose ) )
{
if(verbose)
MITK_INFO << "[Equal( mitk::surface*, mitk::surface* )] Poly datas not equal.";
noDifferenceFound = false;
}
}
return noDifferenceFound;
}
\ No newline at end of file
diff --git a/Core/Code/DataManagement/mitkTimeGeometry.cpp b/Core/Code/DataManagement/mitkTimeGeometry.cpp
index d69baccc68..3dbc26a082 100644
--- a/Core/Code/DataManagement/mitkTimeGeometry.cpp
+++ b/Core/Code/DataManagement/mitkTimeGeometry.cpp
@@ -1,180 +1,180 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkTimeGeometry.h>
#include <mitkGeometry3D.h>
#include <mitkExceptionMacro.h>
mitk::TimeGeometry::TimeGeometry() :
m_BoundingBox(BoundingBox::New())
{
typedef BoundingBox::PointsContainer ContainerType;
ContainerType::Pointer points = ContainerType::New();
m_BoundingBox->SetPoints(points.GetPointer());
}
mitk::TimeGeometry::~TimeGeometry()
{
}
void mitk::TimeGeometry::Initialize()
{
}
/* \brief short description
* parameters
*
*/
mitk::Point3D mitk::TimeGeometry::GetCornerPointInWorld(int id) const
{
assert(id >= 0);
assert(m_BoundingBox.IsNotNull());
BoundingBox::BoundsArrayType bounds = m_BoundingBox->GetBounds();
Point3D cornerpoint;
switch(id)
{
case 0: FillVector3D(cornerpoint, bounds[0],bounds[2],bounds[4]); break;
case 1: FillVector3D(cornerpoint, bounds[0],bounds[2],bounds[5]); break;
case 2: FillVector3D(cornerpoint, bounds[0],bounds[3],bounds[4]); break;
case 3: FillVector3D(cornerpoint, bounds[0],bounds[3],bounds[5]); break;
case 4: FillVector3D(cornerpoint, bounds[1],bounds[2],bounds[4]); break;
case 5: FillVector3D(cornerpoint, bounds[1],bounds[2],bounds[5]); break;
case 6: FillVector3D(cornerpoint, bounds[1],bounds[3],bounds[4]); break;
case 7: FillVector3D(cornerpoint, bounds[1],bounds[3],bounds[5]); break;
default:
{
itkExceptionMacro(<<"A cube only has 8 corners. These are labeled 0-7.");
return Point3D();
}
}
// TimeGeometry has no Transformation. Therefore the bounding box
// contains all data in world coordinates
return cornerpoint;
}
mitk::Point3D mitk::TimeGeometry::GetCornerPointInWorld(bool xFront, bool yFront, bool zFront) const
{
assert(m_BoundingBox.IsNotNull());
BoundingBox::BoundsArrayType bounds = m_BoundingBox->GetBounds();
Point3D cornerpoint;
cornerpoint[0] = (xFront ? bounds[0] : bounds[1]);
cornerpoint[1] = (yFront ? bounds[2] : bounds[3]);
cornerpoint[2] = (zFront ? bounds[4] : bounds[5]);
return cornerpoint;
}
mitk::Point3D mitk::TimeGeometry::GetCenterInWorld() const
{
assert(m_BoundingBox.IsNotNull());
return m_BoundingBox->GetCenter();
}
double mitk::TimeGeometry::GetDiagonalLength2InWorld() const
{
Vector3D diagonalvector = GetCornerPointInWorld()-GetCornerPointInWorld(false, false, false);
return diagonalvector.GetSquaredNorm();
}
double mitk::TimeGeometry::GetDiagonalLengthInWorld() const
{
return sqrt(GetDiagonalLength2InWorld());
}
bool mitk::TimeGeometry::IsWorldPointInside(const mitk::Point3D& p) const
{
return m_BoundingBox->IsInside(p);
}
void mitk::TimeGeometry::UpdateBoundingBox ()
{
assert(m_BoundingBox.IsNotNull());
typedef BoundingBox::PointsContainer ContainerType;
unsigned long lastModifiedTime = 0;
unsigned long currentModifiedTime = 0;
ContainerType::Pointer points = ContainerType::New();
- points->reserve(2*GetNumberOfTimeSteps());
- for (TimeStepType step = 0; step <GetNumberOfTimeSteps(); ++step)
+ points->reserve(2*CountTimeSteps());
+ for (TimeStepType step = 0; step <CountTimeSteps(); ++step)
{
currentModifiedTime = GetGeometryForTimeStep(step)->GetMTime();
if (currentModifiedTime > lastModifiedTime)
lastModifiedTime = currentModifiedTime;
Point3D minimum = GetGeometryForTimeStep(step)->GetCornerPoint(false,false,false);
Point3D maximum = GetGeometryForTimeStep(step)->GetCornerPoint(true,true,true);
points->push_back(minimum);
points->push_back(maximum);
}
m_BoundingBox->SetPoints(points);
m_BoundingBox->ComputeBoundingBox();
if (this->GetMTime() < lastModifiedTime)
this->Modified();
}
mitk::ScalarType mitk::TimeGeometry::GetExtentInWorld (unsigned int direction) const
{
assert(direction < 3);
assert(m_BoundingBox.IsNotNull());
BoundingBox::BoundsArrayType bounds = m_BoundingBox->GetBounds();
return bounds[direction * 2 + 1] - bounds[direction * 2];
}
void mitk::TimeGeometry::Update()
{
this->UpdateBoundingBox();
this->UpdateWithoutBoundingBox();
}
void mitk::TimeGeometry::ExecuteOperation(mitk::Operation* op)
{
- for (TimeStepType step = 0; step < GetNumberOfTimeSteps(); ++step)
+ for (TimeStepType step = 0; step < CountTimeSteps(); ++step)
{
GetGeometryForTimeStep(step)->ExecuteOperation(op);
}
}
void mitk::TimeGeometry::PrintSelf(std::ostream& os, itk::Indent indent) const
{
//Superclass::PrintSelf(os,indent);
- os << indent << " TimeSteps: " << this->GetNumberOfTimeSteps() << std::endl;
+ os << indent << " TimeSteps: " << this->CountTimeSteps() << std::endl;
os << std::endl;
os << indent << " GetGeometryForTimeStep(0): ";
if(GetGeometryForTimeStep(0).IsNull())
os << "NULL" << std::endl;
else
GetGeometryForTimeStep(0)->Print(os, indent);
}
itk::LightObject::Pointer mitk::TimeGeometry::InternalClone() const
{
itk::LightObject::Pointer parent = Superclass::InternalClone();
Self::Pointer rval = dynamic_cast<Self *> (parent.GetPointer());
if (rval.IsNull())
{
mitkThrow() << " Downcast to type " << this->GetNameOfClass() << " failed.";
}
rval->m_BoundingBox = m_BoundingBox->DeepCopy();
return parent;
}
\ No newline at end of file
diff --git a/Core/Code/DataManagement/mitkTimeGeometry.h b/Core/Code/DataManagement/mitkTimeGeometry.h
index cb88323b3e..fcbc650276 100644
--- a/Core/Code/DataManagement/mitkTimeGeometry.h
+++ b/Core/Code/DataManagement/mitkTimeGeometry.h
@@ -1,288 +1,288 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef TimeGeometry_h
#define TimeGeometry_h
//ITK
#include <itkObject.h>
//MITK
#include <mitkCommon.h>
#include <MitkExports.h>
#include "mitkOperationActor.h"
#include <mitkGeometry3D.h>
namespace mitk {
/**
* \deprecatedSince{2013_09} GlobalInteraction is deprecated. It is replaced by mitk::Dispatcher.
* Please use the new implementation described in \see DataInteractionPage .
*/
typedef float TimePointType;
typedef std::size_t TimeStepType;
/**
* \brief Manages the geometries of a data object for each time step
*
* This class is an abstract class. The concrete implementation
* depends on the way the different time steps are managed.
*
* The time is defined either by a time step or a time point. Time steps
* are non-negativ integers starting from 0. A time point is is an float value
* which gives the passed time since start in ms. Be aware that the starting
* point is not fixed so it is possible that the same time point defines two
* different time depending on the start time of the used time geometry.
*
* \addtogroup geometry
*/
class MITK_CORE_EXPORT TimeGeometry : public itk::Object, public OperationActor
{
protected:
TimeGeometry();
virtual ~TimeGeometry();
/**
* \brief Contains a bounding box which includes all time steps
*/
BoundingBox::Pointer m_BoundingBox;
/**
* \brief Makes a deep copy of the current object
*/
virtual LightObject::Pointer InternalClone() const;
public:
- mitkClassMacro(TimeGeometry, itk::Object);
- itkCloneMacro(Self);
- itkCreateAnotherMacro(Self);
+ mitkClassMacro(TimeGeometry, itk::Object)
+ itkCloneMacro(Self)
+ itkCreateAnotherMacro(Self)
/**
* \brief Returns the number of time steps.
*
* Returns the number of time steps for which
* geometries are saved. The number of time steps
* is also the upper bound of the time steps. The
* minimum time steps is always 0.
*/
- virtual TimeStepType GetNumberOfTimeSteps() const = 0;
+ virtual TimeStepType CountTimeSteps() const = 0;
/**
* \brief Returns the first time point for which the object is valid.
*
* Returns the first valid time point for this geometry. If only one
* time steps available it usually goes from -max to +max. The time point
* is given in ms.
*/
virtual TimePointType GetMinimumTimePoint () const = 0;
/**
* \brief Returns the last time point for which the object is valid
*
* Gives the last time point for which a valid geometrie is saved in
* this time geometry. The time point is given in ms.
*/
virtual TimePointType GetMaximumTimePoint () const = 0;
/**
* \brief Get the time bounds (in ms)
*/
virtual TimeBounds GetTimeBounds( ) const = 0;
/**
* \brief Tests if a given time point is covered by this object
*
* Returns true if a geometry can be returned for the given time
* point and falls if not. The time point must be given in ms.
*/
virtual bool IsValidTimePoint (TimePointType timePoint) const = 0;
/**
* \brief Test for the given time step if a geometry is availible
*
* Returns true if a geometry is defined for the given time step.
* Otherwise false is returned.
* The time step is defined as positiv number.
*/
virtual bool IsValidTimeStep (TimeStepType timeStep) const = 0;
/**
* \brief Converts a time step to a time point
*
* Converts a time step to a time point in a way that
* the new time point indicates the same geometry as the time step.
* If the original time steps does not point to a valid geometry,
* a time point is calculated that also does not point to a valid
* geometry, but no exception is raised.
*/
virtual TimePointType TimeStepToTimePoint (TimeStepType timeStep) const = 0;
/**
* \brief Converts a time point to the corresponding time step
*
* Converts a time point to a time step in a way that
* the new time step indicates the same geometry as the time point.
* If a negativ invalid time point is given always time step 0 is
* returned. If an positiv invalid time step is given an invalid
* time step will be returned.
*/
virtual TimeStepType TimePointToTimeStep (TimePointType timePoint) const = 0;
/**
* \brief Returns the geometry of a specific time point
*
* Returns the geometry which defines the given time point. If
* the given time point is invalid an null-pointer is returned.
*
* The pointer to the returned geometry may point to the saved
* geometry but this is not necessarily the case. So a change to
* the returned geometry may or may not afflict the geometry for the
* time point or all time points depending on the used implementation
* of TimeGeometry.
*/
virtual Geometry3D::Pointer GetGeometryForTimePoint ( TimePointType timePoint) const = 0;
/**
* \brief Returns the geometry which corresponds to the given time step
*
* Returns the geometry which defines the given time step. If
* the given time step is invalid an null-pointer is returned.
*
* The pointer to the returned geometry may point to the saved
* geometry but this is not necessarily the case. So a change to
* the returned geometry may or may not afflict the geometry for the
* time step or all time steps depending on the used implementation
* of TimeGeometry.
*/
virtual Geometry3D::Pointer GetGeometryForTimeStep ( TimeStepType timeStep) const = 0;
/**
* \brief Returns a clone of the geometry of a specific time point
*
* If an invalid time step is given (e.g. no geometry is defined for this time step)
* a null-pointer will be returned.
*/
virtual Geometry3D::Pointer GetGeometryCloneForTimeStep( TimeStepType timeStep) const = 0;
/**
* \brief Sets the geometry for a given time step
*
* Sets the geometry for the given time steps. This may also afflects other
* time steps, depending on the implementation of TimeGeometry.
*/
virtual void SetTimeStepGeometry(Geometry3D* geometry, TimeStepType timeStep) = 0;
/**
* \brief Expands to the given number of time steps
*
* Expands to the given number of time steps. Each new created time
* step is filled with an empty geometry.
* Shrinking is not supported!
*/
virtual void Expand(TimeStepType size) = 0;
/**
* \brief Tests if all necessary informations are set and the object is valid
*/
virtual bool IsValid () const = 0;
/**
* \brief Get the position of the corner number \a id (in world coordinates)
*
* See SetImageGeometry for how a corner is defined on images.
*/
Point3D GetCornerPointInWorld(int id) const;
/**
* \brief Get the position of a corner (in world coordinates)
*
* See SetImageGeometry for how a corner is defined on images.
*/
Point3D GetCornerPointInWorld(bool xFront=true, bool yFront=true, bool zFront=true) const;
/**
* \brief Get the center of the bounding-box in mm
*/
Point3D GetCenterInWorld() const;
/**
* \brief Get the squared length of the diagonal of the bounding-box in mm
*/
double GetDiagonalLength2InWorld() const;
/**
* \brief Get the length of the diagonal of the bounding-box in mm
*/
double GetDiagonalLengthInWorld() const;
/**
* \brief Test whether the point \a p (world coordinates in mm) is inside the bounding box
*/
bool IsWorldPointInside(const mitk::Point3D& p) const;
/**
* \brief Updates the bounding box to cover the area used in all time steps
*
* The bounding box is updated by this method. The new bounding box
* covers an area which includes all bounding boxes during
* all times steps.
*/
void UpdateBoundingBox();
/**
* \brief Returns a bounding box that covers all time steps
*/
BoundingBox* GetBoundingBoxInWorld() const
{
return m_BoundingBox;
}
/**
* \brief Returns the world bounds of the object that cover all time steps
*/
BoundingBox::BoundsArrayType GetBoundsInWorld() const
{
return m_BoundingBox->GetBounds();
}
/**
* \brief Returns the Extend of the bounding in the given direction
*/
ScalarType GetExtentInWorld (unsigned int direction) const;
/**
* \brief Initializes the TimeGeometry
*/
virtual void Initialize();
/**
* \brief Updates the geometry
*/
void Update();
/**
* \brief Updates everything except the Bounding box
*
* This class should be overwritten by child classes.
* The method is called when Update() is required.
*/
virtual void UpdateWithoutBoundingBox()
{};
/**
* \brief Executes the given operation on all time steps
*/
virtual void ExecuteOperation(Operation *op);
virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
}; // end class TimeGeometry
} // end namespace MITK
-#endif // TimeGeometry_h
\ No newline at end of file
+#endif // TimeGeometry_h
diff --git a/Core/Code/IO/mitkSurfaceVtkWriter.txx b/Core/Code/IO/mitkSurfaceVtkWriter.txx
index 15227dcd5c..34930d5a99 100644
--- a/Core/Code/IO/mitkSurfaceVtkWriter.txx
+++ b/Core/Code/IO/mitkSurfaceVtkWriter.txx
@@ -1,174 +1,174 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkSurfaceVtkWriter.h"
#include <vtkConfigure.h>
#include <vtkPolyData.h>
#include <vtkLinearTransform.h>
#include <vtkTransformPolyDataFilter.h>
#include <vtkErrorCode.h>
#include <sstream>
#include <sys/stat.h>
#include <sys/types.h>
#include <stdio.h>
template <class VTKWRITER>
mitk::SurfaceVtkWriter<VTKWRITER>::SurfaceVtkWriter()
: m_WriterWriteHasReturnValue( false )
{
this->SetNumberOfRequiredInputs( 1 );
m_VtkWriter = vtkSmartPointer<VtkWriterType>::New();
//enable to write ascii-formatted-file
//m_VtkWriter->SetFileTypeToASCII();
SetDefaultExtension(); // and information about the Writer's Write() method
}
template <class VTKWRITER>
mitk::SurfaceVtkWriter<VTKWRITER>::~SurfaceVtkWriter()
{
}
template <class VTKWRITER>
void mitk::SurfaceVtkWriter<VTKWRITER>::SetDefaultExtension()
{
m_Extension = ".vtk";
}
template<class VTKWRITER>
void mitk::SurfaceVtkWriter<VTKWRITER>::ExecuteWrite( VtkWriterType* vtkWriter )
{
if ( vtkWriter->Write() == 0 || vtkWriter->GetErrorCode() != 0 )
{
itkExceptionMacro(<<"Error during surface writing: " << vtkErrorCode::GetStringFromErrorCode(vtkWriter->GetErrorCode()) );
}
}
template <class VTKWRITER>
void mitk::SurfaceVtkWriter<VTKWRITER>::GenerateData()
{
if ( m_FileName == "" )
{
itkWarningMacro( << "Sorry, filename has not been set!" );
return ;
}
mitk::Surface::Pointer input = const_cast<mitk::Surface*>(this->GetInput());
vtkSmartPointer<vtkTransformPolyDataFilter> transformPolyData = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
vtkPolyData * polyData;
Geometry3D* geometry;
- unsigned int t, timesteps = input->GetTimeGeometry()->GetNumberOfTimeSteps();
+ unsigned int t, timesteps = input->GetTimeGeometry()->CountTimeSteps();
for(t = 0; t < timesteps; ++t)
{
// surfaces do not have to exist in all timeteps; therefor, only write valid surfaces
if( input->GetVtkPolyData(t) == NULL ) continue;
std::ostringstream filename;
filename.imbue(::std::locale::classic());
geometry = input->GetGeometry(t);
if ( timesteps > 1 )
{
if(input->GetTimeGeometry()->IsValidTimeStep(t))
{
const TimeBounds& timebounds = geometry->GetTimeBounds();
filename << m_FileName.c_str() << "_S" << std::setprecision(0) << timebounds[0] << "_E" << std::setprecision(0) << timebounds[1] << "_T" << t << m_Extension;
}
else
{
itkWarningMacro(<<"Error on write: TimeGeometry invalid of surface " << filename << ".");
filename << m_FileName.c_str() << "_T" << t << m_Extension;
}
m_VtkWriter->SetFileName(filename.str().c_str());
}
else
m_VtkWriter->SetFileName(m_FileName.c_str());
geometry->TransferItkToVtkTransform();
transformPolyData->SetInput(input->GetVtkPolyData(t));
transformPolyData->SetTransform(geometry->GetVtkTransform());
transformPolyData->UpdateWholeExtent();
polyData = transformPolyData->GetOutput();
m_VtkWriter->SetInput(polyData);
ExecuteWrite( m_VtkWriter );
}
m_MimeType = "application/MITK.Surface";
}
template <class VTKWRITER>
void mitk::SurfaceVtkWriter<VTKWRITER>::SetInput( mitk::Surface* surface )
{
this->ProcessObject::SetNthInput( 0, surface );
}
template <class VTKWRITER>
const mitk::Surface* mitk::SurfaceVtkWriter<VTKWRITER>::GetInput()
{
if ( this->GetNumberOfInputs() < 1 )
{
return NULL;
}
else
{
return static_cast< const Surface * >( this->ProcessObject::GetInput( 0 ) );
}
}
template <class VTKWRITER>
bool mitk::SurfaceVtkWriter<VTKWRITER>::CanWriteDataType( DataNode* input )
{
if ( input )
{
BaseData* data = input->GetData();
if ( data )
{
Surface::Pointer surface = dynamic_cast<Surface*>( data );
if( surface.IsNotNull() )
{
SetDefaultExtension();
return true;
}
}
}
return false;
}
template <class VTKWRITER>
void mitk::SurfaceVtkWriter<VTKWRITER>::SetInput( DataNode* input )
{
if( input && CanWriteDataType( input ) )
SetInput( dynamic_cast<Surface*>( input->GetData() ) );
}
template <class VTKWRITER>
std::string mitk::SurfaceVtkWriter<VTKWRITER>::GetWritenMIMEType()
{
return m_MimeType;
}
template <class VTKWRITER>
std::string mitk::SurfaceVtkWriter<VTKWRITER>::GetFileExtension()
{
return m_Extension;
}
diff --git a/Core/Code/Rendering/mitkBaseRenderer.cpp b/Core/Code/Rendering/mitkBaseRenderer.cpp
index 81e1445a12..0084cd5278 100644
--- a/Core/Code/Rendering/mitkBaseRenderer.cpp
+++ b/Core/Code/Rendering/mitkBaseRenderer.cpp
@@ -1,892 +1,892 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkBaseRenderer.h"
#include "mitkMapper.h"
#include "mitkResliceMethodProperty.h"
#include "mitkKeyEvent.h"
// Geometries
#include "mitkPlaneGeometry.h"
#include "mitkSlicedGeometry3D.h"
// Controllers
#include "mitkCameraController.h"
#include "mitkSliceNavigationController.h"
#include "mitkCameraRotationController.h"
#include "mitkVtkInteractorCameraController.h"
#ifdef MITK_USE_TD_MOUSE
#include "mitkTDMouseVtkCameraController.h"
#else
#include "mitkCameraController.h"
#endif
#include "mitkVtkLayerController.h"
// Events // TODO: INTERACTION_LEGACY
#include "mitkEventMapper.h"
#include "mitkGlobalInteraction.h"
#include "mitkPositionEvent.h"
#include "mitkDisplayPositionEvent.h"
#include "mitkProperties.h"
#include "mitkWeakPointerProperty.h"
#include "mitkInteractionConst.h"
#include "mitkOverlayManager.h"
// VTK
#include <vtkLinearTransform.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkCamera.h>
#include <vtkProperty.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
mitk::BaseRenderer::BaseRendererMapType mitk::BaseRenderer::baseRendererMap;
mitk::BaseRenderer* mitk::BaseRenderer::GetInstance(vtkRenderWindow * renWin)
{
for (BaseRendererMapType::iterator mapit = baseRendererMap.begin(); mapit != baseRendererMap.end(); mapit++)
{
if ((*mapit).first == renWin)
return (*mapit).second;
}
return NULL;
}
void mitk::BaseRenderer::AddInstance(vtkRenderWindow* renWin, BaseRenderer* baseRenderer)
{
if (renWin == NULL || baseRenderer == NULL)
return;
// ensure that no BaseRenderer is managed twice
mitk::BaseRenderer::RemoveInstance(renWin);
baseRendererMap.insert(BaseRendererMapType::value_type(renWin, baseRenderer));
}
void mitk::BaseRenderer::RemoveInstance(vtkRenderWindow* renWin)
{
BaseRendererMapType::iterator mapit = baseRendererMap.find(renWin);
if (mapit != baseRendererMap.end())
baseRendererMap.erase(mapit);
}
mitk::BaseRenderer* mitk::BaseRenderer::GetByName(const std::string& name)
{
for (BaseRendererMapType::iterator mapit = baseRendererMap.begin(); mapit != baseRendererMap.end(); mapit++)
{
if ((*mapit).second->m_Name == name)
return (*mapit).second;
}
return NULL;
}
vtkRenderWindow* mitk::BaseRenderer::GetRenderWindowByName(const std::string& name)
{
for (BaseRendererMapType::iterator mapit = baseRendererMap.begin(); mapit != baseRendererMap.end(); mapit++)
{
if ((*mapit).second->m_Name == name)
return (*mapit).first;
}
return NULL;
}
mitk::BaseRenderer::BaseRenderer(const char* name, vtkRenderWindow * renWin, mitk::RenderingManager* rm) :
m_RenderWindow(NULL), m_VtkRenderer(NULL), m_MapperID(defaultMapper), m_DataStorage(NULL), m_RenderingManager(rm), m_LastUpdateTime(0), m_CameraController(
NULL), m_SliceNavigationController(NULL), m_CameraRotationController(NULL), /*m_Size(),*/
m_Focused(false), m_WorldGeometry(NULL), m_TimeWorldGeometry(NULL), m_CurrentWorldGeometry(NULL), m_CurrentWorldGeometry2D(NULL), m_DisplayGeometry(
NULL), m_Slice(0), m_TimeStep(), m_CurrentWorldGeometry2DUpdateTime(), m_DisplayGeometryUpdateTime(), m_TimeStepUpdateTime(), m_WorldGeometryData(
NULL), m_DisplayGeometryData(NULL), m_CurrentWorldGeometry2DData(NULL), m_WorldGeometryNode(NULL), m_DisplayGeometryNode(NULL), m_CurrentWorldGeometry2DNode(
NULL), m_DisplayGeometryTransformTime(0), m_CurrentWorldGeometry2DTransformTime(0), m_Name(name), /*m_Bounds(),*/m_EmptyWorldGeometry(
true), m_DepthPeelingEnabled(true), m_MaxNumberOfPeels(100), m_NumberOfVisibleLODEnabledMappers(0)
{
m_Bounds[0] = 0;
m_Bounds[1] = 0;
m_Bounds[2] = 0;
m_Bounds[3] = 0;
m_Bounds[4] = 0;
m_Bounds[5] = 0;
if (name != NULL)
{
m_Name = name;
}
else
{
m_Name = "unnamed renderer";
itkWarningMacro(<< "Created unnamed renderer. Bad for serialization. Please choose a name.");
}
if (renWin != NULL)
{
m_RenderWindow = renWin;
m_RenderWindow->Register(NULL);
}
else
{
itkWarningMacro(<< "Created mitkBaseRenderer without vtkRenderWindow present.");
}
m_Size[0] = 0;
m_Size[1] = 0;
//instances.insert( this );
//adding this BaseRenderer to the List of all BaseRenderer
// TODO: INTERACTION_LEGACY
m_RenderingManager->GetGlobalInteraction()->AddFocusElement(this);
m_BindDispatcherInteractor = new mitk::BindDispatcherInteractor( GetName() );
WeakPointerProperty::Pointer rendererProp = WeakPointerProperty::New((itk::Object*) this);
m_CurrentWorldGeometry2D = mitk::PlaneGeometry::New();
m_CurrentWorldGeometry2DData = mitk::Geometry2DData::New();
m_CurrentWorldGeometry2DData->SetGeometry2D(m_CurrentWorldGeometry2D);
m_CurrentWorldGeometry2DNode = mitk::DataNode::New();
m_CurrentWorldGeometry2DNode->SetData(m_CurrentWorldGeometry2DData);
m_CurrentWorldGeometry2DNode->GetPropertyList()->SetProperty("renderer", rendererProp);
m_CurrentWorldGeometry2DNode->GetPropertyList()->SetProperty("layer", IntProperty::New(1000));
m_CurrentWorldGeometry2DNode->SetProperty("reslice.thickslices", mitk::ResliceMethodProperty::New());
m_CurrentWorldGeometry2DNode->SetProperty("reslice.thickslices.num", mitk::IntProperty::New(1));
m_CurrentWorldGeometry2DTransformTime = m_CurrentWorldGeometry2DNode->GetVtkTransform()->GetMTime();
m_DisplayGeometry = mitk::DisplayGeometry::New();
m_DisplayGeometry->SetWorldGeometry(m_CurrentWorldGeometry2D);
m_DisplayGeometryData = mitk::Geometry2DData::New();
m_DisplayGeometryData->SetGeometry2D(m_DisplayGeometry);
m_DisplayGeometryNode = mitk::DataNode::New();
m_DisplayGeometryNode->SetData(m_DisplayGeometryData);
m_DisplayGeometryNode->GetPropertyList()->SetProperty("renderer", rendererProp);
m_DisplayGeometryTransformTime = m_DisplayGeometryNode->GetVtkTransform()->GetMTime();
mitk::SliceNavigationController::Pointer sliceNavigationController = mitk::SliceNavigationController::New("navigation");
sliceNavigationController->SetRenderer(this);
sliceNavigationController->ConnectGeometrySliceEvent(this);
sliceNavigationController->ConnectGeometryUpdateEvent(this);
sliceNavigationController->ConnectGeometryTimeEvent(this, false);
m_SliceNavigationController = sliceNavigationController;
m_CameraRotationController = mitk::CameraRotationController::New();
m_CameraRotationController->SetRenderWindow(m_RenderWindow);
m_CameraRotationController->AcquireCamera();
//if TD Mouse Interaction is activated, then call TDMouseVtkCameraController instead of VtkInteractorCameraController
#ifdef MITK_USE_TD_MOUSE
m_CameraController = mitk::TDMouseVtkCameraController::New();
#else
m_CameraController = mitk::CameraController::New(NULL);
#endif
m_VtkRenderer = vtkRenderer::New();
if (mitk::VtkLayerController::GetInstance(m_RenderWindow) == NULL)
{
mitk::VtkLayerController::AddInstance(m_RenderWindow, m_VtkRenderer);
mitk::VtkLayerController::GetInstance(m_RenderWindow)->InsertSceneRenderer(m_VtkRenderer);
}
else
mitk::VtkLayerController::GetInstance(m_RenderWindow)->InsertSceneRenderer(m_VtkRenderer);
}
mitk::BaseRenderer::~BaseRenderer()
{
if (m_VtkRenderer != NULL)
{
m_VtkRenderer->Delete();
m_VtkRenderer = NULL;
}
if (m_CameraController.IsNotNull())
m_CameraController->SetRenderer(NULL);
m_RenderingManager->GetGlobalInteraction()->RemoveFocusElement(this);
mitk::VtkLayerController::RemoveInstance(m_RenderWindow);
RemoveAllLocalStorages();
m_DataStorage = NULL;
if (m_BindDispatcherInteractor != NULL)
{
delete m_BindDispatcherInteractor;
}
if (m_RenderWindow != NULL)
{
m_RenderWindow->Delete();
m_RenderWindow = NULL;
}
if (m_OverlayManager.IsNotNull())
{
m_OverlayManager->RemoveBaseRenderer(this);
}
}
void mitk::BaseRenderer::RemoveAllLocalStorages()
{
this->InvokeEvent(mitk::BaseRenderer::RendererResetEvent());
std::list<mitk::BaseLocalStorageHandler*>::iterator it;
for (it = m_RegisteredLocalStorageHandlers.begin(); it != m_RegisteredLocalStorageHandlers.end(); it++)
(*it)->ClearLocalStorage(this, false);
m_RegisteredLocalStorageHandlers.clear();
}
void mitk::BaseRenderer::RegisterLocalStorageHandler(mitk::BaseLocalStorageHandler *lsh)
{
m_RegisteredLocalStorageHandlers.push_back(lsh);
}
mitk::Dispatcher::Pointer mitk::BaseRenderer::GetDispatcher() const
{
return m_BindDispatcherInteractor->GetDispatcher();
}
mitk::Point3D mitk::BaseRenderer::Map2DRendererPositionTo3DWorldPosition(Point2D* mousePosition) const
{
Point2D p_mm;
Point3D position;
if (m_MapperID == 1)
{
GetDisplayGeometry()->ULDisplayToDisplay(*mousePosition, *mousePosition);
GetDisplayGeometry()->DisplayToWorld(*mousePosition, p_mm);
GetDisplayGeometry()->Map(p_mm, position);
}
else if (m_MapperID == 2)
{
GetDisplayGeometry()->ULDisplayToDisplay(*mousePosition, *mousePosition);
PickWorldPoint(*mousePosition, position);
}
return position;
}
void mitk::BaseRenderer::UnregisterLocalStorageHandler(mitk::BaseLocalStorageHandler *lsh)
{
m_RegisteredLocalStorageHandlers.remove(lsh);
}
void mitk::BaseRenderer::SetDataStorage(DataStorage* storage)
{
if (storage != NULL)
{
m_DataStorage = storage;
m_BindDispatcherInteractor->SetDataStorage(m_DataStorage);
this->Modified();
}
}
const mitk::BaseRenderer::MapperSlotId mitk::BaseRenderer::defaultMapper = 1;
void mitk::BaseRenderer::Paint()
{
}
void mitk::BaseRenderer::Initialize()
{
}
void mitk::BaseRenderer::Resize(int w, int h)
{
m_Size[0] = w;
m_Size[1] = h;
if (m_CameraController)
m_CameraController->Resize(w, h); //(formerly problematic on windows: vtkSizeBug)
GetDisplayGeometry()->SetSizeInDisplayUnits(w, h);
}
void mitk::BaseRenderer::InitRenderer(vtkRenderWindow* renderwindow)
{
if (m_RenderWindow != NULL)
{
m_RenderWindow->Delete();
}
m_RenderWindow = renderwindow;
if (m_RenderWindow != NULL)
{
m_RenderWindow->Register(NULL);
}
RemoveAllLocalStorages();
if (m_CameraController.IsNotNull())
{
m_CameraController->SetRenderer(this);
}
//BUG (#1551) added settings for depth peeling
m_RenderWindow->SetAlphaBitPlanes(1);
m_VtkRenderer->SetUseDepthPeeling(m_DepthPeelingEnabled);
m_VtkRenderer->SetMaximumNumberOfPeels(m_MaxNumberOfPeels);
m_VtkRenderer->SetOcclusionRatio(0.1);
}
void mitk::BaseRenderer::InitSize(int w, int h)
{
m_Size[0] = w;
m_Size[1] = h;
GetDisplayGeometry()->SetSizeInDisplayUnits(w, h, false);
GetDisplayGeometry()->Fit();
}
void mitk::BaseRenderer::SetSlice(unsigned int slice)
{
if (m_Slice != slice)
{
m_Slice = slice;
if (m_TimeWorldGeometry.IsNotNull())
{
SlicedGeometry3D* slicedWorldGeometry = dynamic_cast<SlicedGeometry3D*>(m_TimeWorldGeometry->GetGeometryForTimeStep(m_TimeStep).GetPointer());
if (slicedWorldGeometry != NULL)
{
if (m_Slice >= slicedWorldGeometry->GetSlices())
m_Slice = slicedWorldGeometry->GetSlices() - 1;
SetCurrentWorldGeometry2D(slicedWorldGeometry->GetGeometry2D(m_Slice));
SetCurrentWorldGeometry(slicedWorldGeometry);
}
}
else
Modified();
}
}
void mitk::BaseRenderer::SetOverlayManager(itk::SmartPointer<OverlayManager> overlayManager)
{
if(overlayManager.IsNull())
return;
if(this->m_OverlayManager.IsNotNull())
{
if(this->m_OverlayManager.GetPointer() == overlayManager.GetPointer())
{
return;
}
else
{
this->m_OverlayManager->RemoveBaseRenderer(this);
}
}
this->m_OverlayManager = overlayManager;
this->m_OverlayManager->AddBaseRenderer(this); //TODO
}
itk::SmartPointer<mitk::OverlayManager> mitk::BaseRenderer::GetOverlayManager()
{
if(this->m_OverlayManager.IsNull())
{
m_OverlayManager = mitk::OverlayManager::New();
m_OverlayManager->AddBaseRenderer(this);
}
return this->m_OverlayManager;
}
void mitk::BaseRenderer::SetTimeStep(unsigned int timeStep)
{
if (m_TimeStep != timeStep)
{
m_TimeStep = timeStep;
m_TimeStepUpdateTime.Modified();
if (m_TimeWorldGeometry.IsNotNull())
{
- if (m_TimeStep >= m_TimeWorldGeometry->GetNumberOfTimeSteps())
- m_TimeStep = m_TimeWorldGeometry->GetNumberOfTimeSteps() - 1;
+ if (m_TimeStep >= m_TimeWorldGeometry->CountTimeSteps())
+ m_TimeStep = m_TimeWorldGeometry->CountTimeSteps() - 1;
SlicedGeometry3D* slicedWorldGeometry = dynamic_cast<SlicedGeometry3D*>(m_TimeWorldGeometry->GetGeometryForTimeStep(m_TimeStep).GetPointer());
if (slicedWorldGeometry != NULL)
{
SetCurrentWorldGeometry2D(slicedWorldGeometry->GetGeometry2D(m_Slice));
SetCurrentWorldGeometry(slicedWorldGeometry);
}
}
else
Modified();
}
}
int mitk::BaseRenderer::GetTimeStep(const mitk::BaseData* data) const
{
if ((data == NULL) || (data->IsInitialized() == false))
{
return -1;
}
return data->GetTimeGeometry()->TimePointToTimeStep(GetTime());
}
mitk::ScalarType mitk::BaseRenderer::GetTime() const
{
if (m_TimeWorldGeometry.IsNull())
{
return 0;
}
else
{
ScalarType timeInMS = m_TimeWorldGeometry->TimeStepToTimePoint(GetTimeStep());
if (timeInMS == ScalarTypeNumericTraits::NonpositiveMin())
return 0;
else
return timeInMS;
}
}
void mitk::BaseRenderer::SetWorldTimeGeometry(mitk::TimeGeometry* geometry)
{
assert(geometry != NULL);
itkDebugMacro("setting WorldTimeGeometry to " << geometry);
if (m_TimeWorldGeometry != geometry)
{
if (geometry->GetBoundingBoxInWorld()->GetDiagonalLength2() == 0)
return;
m_TimeWorldGeometry = geometry;
itkDebugMacro("setting TimeWorldGeometry to " << m_TimeWorldGeometry);
- if (m_TimeStep >= m_TimeWorldGeometry->GetNumberOfTimeSteps())
- m_TimeStep = m_TimeWorldGeometry->GetNumberOfTimeSteps() - 1;
+ if (m_TimeStep >= m_TimeWorldGeometry->CountTimeSteps())
+ m_TimeStep = m_TimeWorldGeometry->CountTimeSteps() - 1;
Geometry3D* geometry3d;
geometry3d = m_TimeWorldGeometry->GetGeometryForTimeStep(m_TimeStep);
SetWorldGeometry3D(geometry3d);
}
}
void mitk::BaseRenderer::SetWorldGeometry3D(mitk::Geometry3D* geometry)
{
itkDebugMacro("setting WorldGeometry3D to " << geometry);
if (m_WorldGeometry != geometry)
{
if (geometry->GetBoundingBox()->GetDiagonalLength2() == 0)
return;
m_WorldGeometry = geometry;
SlicedGeometry3D* slicedWorldGeometry;
slicedWorldGeometry = dynamic_cast<SlicedGeometry3D*>(geometry);
Geometry2D::Pointer geometry2d;
if (slicedWorldGeometry != NULL)
{
if (m_Slice >= slicedWorldGeometry->GetSlices() && (m_Slice != 0))
m_Slice = slicedWorldGeometry->GetSlices() - 1;
geometry2d = slicedWorldGeometry->GetGeometry2D(m_Slice);
if (geometry2d.IsNull())
{
PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New();
plane->InitializeStandardPlane(slicedWorldGeometry);
geometry2d = plane;
}
SetCurrentWorldGeometry(slicedWorldGeometry);
}
else
{
geometry2d = dynamic_cast<Geometry2D*>(geometry);
if (geometry2d.IsNull())
{
PlaneGeometry::Pointer plane = PlaneGeometry::New();
plane->InitializeStandardPlane(geometry);
geometry2d = plane;
}
SetCurrentWorldGeometry(geometry);
}
SetCurrentWorldGeometry2D(geometry2d); // calls Modified()
}
if (m_CurrentWorldGeometry2D.IsNull())
itkWarningMacro("m_CurrentWorldGeometry2D is NULL");
}
void mitk::BaseRenderer::SetDisplayGeometry(mitk::DisplayGeometry* geometry2d)
{
itkDebugMacro("setting DisplayGeometry to " << geometry2d);
if (m_DisplayGeometry != geometry2d)
{
m_DisplayGeometry = geometry2d;
m_DisplayGeometryData->SetGeometry2D(m_DisplayGeometry);
m_DisplayGeometryUpdateTime.Modified();
Modified();
}
}
void mitk::BaseRenderer::SetCurrentWorldGeometry2D(mitk::Geometry2D* geometry2d)
{
if (m_CurrentWorldGeometry2D != geometry2d)
{
m_CurrentWorldGeometry2D = geometry2d;
m_CurrentWorldGeometry2DData->SetGeometry2D(m_CurrentWorldGeometry2D);
m_DisplayGeometry->SetWorldGeometry(m_CurrentWorldGeometry2D);
m_CurrentWorldGeometry2DUpdateTime.Modified();
Modified();
}
}
void mitk::BaseRenderer::SendUpdateSlice()
{
m_DisplayGeometryUpdateTime.Modified();
m_CurrentWorldGeometry2DUpdateTime.Modified();
}
void mitk::BaseRenderer::SetCurrentWorldGeometry(mitk::Geometry3D* geometry)
{
m_CurrentWorldGeometry = geometry;
if (geometry == NULL)
{
m_Bounds[0] = 0;
m_Bounds[1] = 0;
m_Bounds[2] = 0;
m_Bounds[3] = 0;
m_Bounds[4] = 0;
m_Bounds[5] = 0;
m_EmptyWorldGeometry = true;
return;
}
BoundingBox::Pointer boundingBox = m_CurrentWorldGeometry->CalculateBoundingBoxRelativeToTransform(NULL);
const BoundingBox::BoundsArrayType& worldBounds = boundingBox->GetBounds();
m_Bounds[0] = worldBounds[0];
m_Bounds[1] = worldBounds[1];
m_Bounds[2] = worldBounds[2];
m_Bounds[3] = worldBounds[3];
m_Bounds[4] = worldBounds[4];
m_Bounds[5] = worldBounds[5];
if (boundingBox->GetDiagonalLength2() <= mitk::eps)
m_EmptyWorldGeometry = true;
else
m_EmptyWorldGeometry = false;
}
void mitk::BaseRenderer::UpdateOverlays()
{
if(m_OverlayManager.IsNotNull())
{
m_OverlayManager->UpdateOverlays(this);
}
}
void mitk::BaseRenderer::SetGeometry(const itk::EventObject & geometrySendEvent)
{
const SliceNavigationController::GeometrySendEvent* sendEvent =
dynamic_cast<const SliceNavigationController::GeometrySendEvent *>(&geometrySendEvent);
assert(sendEvent!=NULL);
SetWorldTimeGeometry(sendEvent->GetTimeGeometry());
}
void mitk::BaseRenderer::UpdateGeometry(const itk::EventObject & geometryUpdateEvent)
{
const SliceNavigationController::GeometryUpdateEvent* updateEvent =
dynamic_cast<const SliceNavigationController::GeometryUpdateEvent*>(&geometryUpdateEvent);
if (updateEvent == NULL)
return;
if (m_CurrentWorldGeometry.IsNotNull())
{
SlicedGeometry3D* slicedWorldGeometry = dynamic_cast<SlicedGeometry3D*>(m_CurrentWorldGeometry.GetPointer());
if (slicedWorldGeometry)
{
Geometry2D* geometry2D = slicedWorldGeometry->GetGeometry2D(m_Slice);
SetCurrentWorldGeometry2D(geometry2D); // calls Modified()
}
}
}
void mitk::BaseRenderer::SetGeometrySlice(const itk::EventObject & geometrySliceEvent)
{
const SliceNavigationController::GeometrySliceEvent* sliceEvent =
dynamic_cast<const SliceNavigationController::GeometrySliceEvent *>(&geometrySliceEvent);
assert(sliceEvent!=NULL);
SetSlice(sliceEvent->GetPos());
}
void mitk::BaseRenderer::SetGeometryTime(const itk::EventObject & geometryTimeEvent)
{
const SliceNavigationController::GeometryTimeEvent * timeEvent =
dynamic_cast<const SliceNavigationController::GeometryTimeEvent *>(&geometryTimeEvent);
assert(timeEvent!=NULL);
SetTimeStep(timeEvent->GetPos());
}
const double* mitk::BaseRenderer::GetBounds() const
{
return m_Bounds;
}
void mitk::BaseRenderer::MousePressEvent(mitk::MouseEvent *me)
{
//set the Focus on the renderer
/*bool success =*/m_RenderingManager->GetGlobalInteraction()->SetFocus(this);
/*
if (! success)
mitk::StatusBar::GetInstance()->DisplayText("Warning! from mitkBaseRenderer.cpp: Couldn't focus this BaseRenderer!");
*/
//if (m_CameraController)
//{
// if(me->GetButtonState()!=512) // provisorisch: Ctrl nicht durchlassen. Bald wird aus m_CameraController eine StateMachine
// m_CameraController->MousePressEvent(me);
//}
if (m_MapperID == 1)
{
Point2D p(me->GetDisplayPosition());
Point2D p_mm;
Point3D position;
GetDisplayGeometry()->ULDisplayToDisplay(p, p);
GetDisplayGeometry()->DisplayToWorld(p, p_mm);
GetDisplayGeometry()->Map(p_mm, position);
mitk::PositionEvent event(this, me->GetType(), me->GetButton(), me->GetButtonState(), mitk::Key_unknown, p, position);
mitk::EventMapper::MapEvent(&event, m_RenderingManager->GetGlobalInteraction());
}
else if (m_MapperID > 1) //==2 for 3D and ==5 for stencil
{
Point2D p(me->GetDisplayPosition());
GetDisplayGeometry()->ULDisplayToDisplay(p, p);
me->SetDisplayPosition(p);
mitk::EventMapper::MapEvent(me, m_RenderingManager->GetGlobalInteraction());
}
}
void mitk::BaseRenderer::MouseReleaseEvent(mitk::MouseEvent *me)
{
//if (m_CameraController)
//{
// if(me->GetButtonState()!=512) // provisorisch: Ctrl nicht durchlassen. Bald wird aus m_CameraController eine StateMachine
// m_CameraController->MouseReleaseEvent(me);
//}
if (m_MapperID == 1)
{
Point2D p(me->GetDisplayPosition());
Point2D p_mm;
Point3D position;
GetDisplayGeometry()->ULDisplayToDisplay(p, p);
GetDisplayGeometry()->DisplayToWorld(p, p_mm);
GetDisplayGeometry()->Map(p_mm, position);
mitk::PositionEvent event(this, me->GetType(), me->GetButton(), me->GetButtonState(), mitk::Key_unknown, p, position);
mitk::EventMapper::MapEvent(&event, m_RenderingManager->GetGlobalInteraction());
}
else if (m_MapperID == 2)
{
Point2D p(me->GetDisplayPosition());
GetDisplayGeometry()->ULDisplayToDisplay(p, p);
me->SetDisplayPosition(p);
mitk::EventMapper::MapEvent(me, m_RenderingManager->GetGlobalInteraction());
}
}
void mitk::BaseRenderer::MouseMoveEvent(mitk::MouseEvent *me)
{
//if (m_CameraController)
//{
// if((me->GetButtonState()<=512) || (me->GetButtonState()>=516))// provisorisch: Ctrl nicht durchlassen. Bald wird aus m_CameraController eine StateMachine
// m_CameraController->MouseMoveEvent(me);
//}
if (m_MapperID == 1)
{
Point2D p(me->GetDisplayPosition());
Point2D p_mm;
Point3D position;
GetDisplayGeometry()->ULDisplayToDisplay(p, p);
GetDisplayGeometry()->DisplayToWorld(p, p_mm);
GetDisplayGeometry()->Map(p_mm, position);
mitk::PositionEvent event(this, me->GetType(), me->GetButton(), me->GetButtonState(), mitk::Key_unknown, p, position);
mitk::EventMapper::MapEvent(&event, m_RenderingManager->GetGlobalInteraction());
}
else if (m_MapperID == 2)
{
Point2D p(me->GetDisplayPosition());
GetDisplayGeometry()->ULDisplayToDisplay(p, p);
me->SetDisplayPosition(p);
mitk::EventMapper::MapEvent(me, m_RenderingManager->GetGlobalInteraction());
}
}
void mitk::BaseRenderer::PickWorldPoint(const mitk::Point2D& displayPoint, mitk::Point3D& worldPoint) const
{
mitk::Point2D worldPoint2D;
GetDisplayGeometry()->DisplayToWorld(displayPoint, worldPoint2D);
GetDisplayGeometry()->Map(worldPoint2D, worldPoint);
}
void mitk::BaseRenderer::WheelEvent(mitk::WheelEvent * we)
{
if (m_MapperID == 1)
{
Point2D p(we->GetDisplayPosition());
Point2D p_mm;
Point3D position;
GetDisplayGeometry()->ULDisplayToDisplay(p, p);
GetDisplayGeometry()->DisplayToWorld(p, p_mm);
GetDisplayGeometry()->Map(p_mm, position);
mitk::PositionEvent event(this, we->GetType(), we->GetButton(), we->GetButtonState(), mitk::Key_unknown, p, position);
mitk::EventMapper::MapEvent(we, m_RenderingManager->GetGlobalInteraction());
mitk::EventMapper::MapEvent(&event, m_RenderingManager->GetGlobalInteraction());
}
else if (m_MapperID == 2)
{
Point2D p(we->GetDisplayPosition());
GetDisplayGeometry()->ULDisplayToDisplay(p, p);
we->SetDisplayPosition(p);
mitk::EventMapper::MapEvent(we, m_RenderingManager->GetGlobalInteraction());
}
}
void mitk::BaseRenderer::KeyPressEvent(mitk::KeyEvent *ke)
{
if (m_MapperID == 1)
{
Point2D p(ke->GetDisplayPosition());
Point2D p_mm;
Point3D position;
GetDisplayGeometry()->ULDisplayToDisplay(p, p);
GetDisplayGeometry()->DisplayToWorld(p, p_mm);
GetDisplayGeometry()->Map(p_mm, position);
mitk::KeyEvent event(this, ke->GetType(), ke->GetButton(), ke->GetButtonState(), ke->GetKey(), ke->GetText(), p);
mitk::EventMapper::MapEvent(&event, m_RenderingManager->GetGlobalInteraction());
}
else if (m_MapperID == 2)
{
Point2D p(ke->GetDisplayPosition());
GetDisplayGeometry()->ULDisplayToDisplay(p, p);
ke->SetDisplayPosition(p);
mitk::EventMapper::MapEvent(ke, m_RenderingManager->GetGlobalInteraction());
}
}
void mitk::BaseRenderer::DrawOverlayMouse(mitk::Point2D& itkNotUsed(p2d))
{
MITK_INFO<<"BaseRenderer::DrawOverlayMouse()- should be inconcret implementation OpenGLRenderer."<<std::endl;
}
void mitk::BaseRenderer::RequestUpdate()
{
m_RenderingManager->RequestUpdate(this->m_RenderWindow);
}
void mitk::BaseRenderer::ForceImmediateUpdate()
{
m_RenderingManager->ForceImmediateUpdate(this->m_RenderWindow);
}
unsigned int mitk::BaseRenderer::GetNumberOfVisibleLODEnabledMappers() const
{
return m_NumberOfVisibleLODEnabledMappers;
}
mitk::RenderingManager* mitk::BaseRenderer::GetRenderingManager() const
{
return m_RenderingManager.GetPointer();
}
/*!
Sets the new Navigation controller
*/
void mitk::BaseRenderer::SetSliceNavigationController(mitk::SliceNavigationController *SlicenavigationController)
{
if (SlicenavigationController == NULL)
return;
//disconnect old from globalinteraction
m_RenderingManager->GetGlobalInteraction()->RemoveListener(SlicenavigationController);
//copy worldgeometry
SlicenavigationController->SetInputWorldTimeGeometry(SlicenavigationController->GetCreatedWorldGeometry());
SlicenavigationController->Update();
//set new
m_SliceNavigationController = SlicenavigationController;
m_SliceNavigationController->SetRenderer(this);
if (m_SliceNavigationController.IsNotNull())
{
m_SliceNavigationController->ConnectGeometrySliceEvent(this);
m_SliceNavigationController->ConnectGeometryUpdateEvent(this);
m_SliceNavigationController->ConnectGeometryTimeEvent(this, false);
}
}
/*!
Sets the new camera controller and deletes the vtkRenderWindowInteractor in case of the VTKInteractorCameraController
*/
void mitk::BaseRenderer::SetCameraController(CameraController* cameraController)
{
mitk::VtkInteractorCameraController::Pointer vtkInteractorCameraController =
dynamic_cast<mitk::VtkInteractorCameraController*>(cameraController);
if (vtkInteractorCameraController.IsNotNull())
MITK_INFO<<"!!!WARNING!!!: RenderWindow interaction events are no longer handled via CameraController (See Bug #954)."<<std::endl;
m_CameraController->SetRenderer(NULL);
m_CameraController = NULL;
m_CameraController = cameraController;
m_CameraController->SetRenderer(this);
}
void mitk::BaseRenderer::PrintSelf(std::ostream& os, itk::Indent indent) const
{
os << indent << " MapperID: " << m_MapperID << std::endl;
os << indent << " Slice: " << m_Slice << std::endl;
os << indent << " TimeStep: " << m_TimeStep << std::endl;
os << indent << " WorldGeometry: ";
if (m_WorldGeometry.IsNull())
os << "NULL" << std::endl;
else
m_WorldGeometry->Print(os, indent);
os << indent << " CurrentWorldGeometry2D: ";
if (m_CurrentWorldGeometry2D.IsNull())
os << "NULL" << std::endl;
else
m_CurrentWorldGeometry2D->Print(os, indent);
os << indent << " CurrentWorldGeometry2DUpdateTime: " << m_CurrentWorldGeometry2DUpdateTime << std::endl;
os << indent << " CurrentWorldGeometry2DTransformTime: " << m_CurrentWorldGeometry2DTransformTime << std::endl;
os << indent << " DisplayGeometry: ";
if (m_DisplayGeometry.IsNull())
os << "NULL" << std::endl;
else
m_DisplayGeometry->Print(os, indent);
os << indent << " DisplayGeometryTransformTime: " << m_DisplayGeometryTransformTime << std::endl;
Superclass::PrintSelf(os, indent);
}
void mitk::BaseRenderer::SetDepthPeelingEnabled(bool enabled)
{
m_DepthPeelingEnabled = enabled;
m_VtkRenderer->SetUseDepthPeeling(enabled);
}
void mitk::BaseRenderer::SetMaxNumberOfPeels(int maxNumber)
{
m_MaxNumberOfPeels = maxNumber;
m_VtkRenderer->SetMaximumNumberOfPeels(maxNumber);
}
diff --git a/Core/Code/Rendering/mitkImageVtkMapper2D.cpp b/Core/Code/Rendering/mitkImageVtkMapper2D.cpp
index c87ccf8ca6..fc9b6cb64d 100644
--- a/Core/Code/Rendering/mitkImageVtkMapper2D.cpp
+++ b/Core/Code/Rendering/mitkImageVtkMapper2D.cpp
@@ -1,1096 +1,1096 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
//MITK
#include <mitkAbstractTransformGeometry.h>
#include <mitkDataNode.h>
#include <mitkDataNodeFactory.h>
#include <mitkImageSliceSelector.h>
#include <mitkLevelWindowProperty.h>
#include <mitkLookupTableProperty.h>
#include <mitkPlaneGeometry.h>
#include <mitkProperties.h>
#include <mitkResliceMethodProperty.h>
#include <mitkVtkResliceInterpolationProperty.h>
#include <mitkPixelType.h>
//#include <mitkTransferFunction.h>
#include <mitkTransferFunctionProperty.h>
#include "mitkImageStatisticsHolder.h"
#include "mitkPlaneClipping.h"
//MITK Rendering
#include "mitkImageVtkMapper2D.h"
#include "vtkMitkThickSlicesFilter.h"
#include "vtkMitkLevelWindowFilter.h"
#include "vtkNeverTranslucentTexture.h"
//VTK
#include <vtkProperty.h>
#include <vtkTransform.h>
#include <vtkMatrix4x4.h>
#include <vtkLookupTable.h>
#include <vtkImageData.h>
#include <vtkPoints.h>
#include <vtkGeneralTransform.h>
#include <vtkImageExtractComponents.h>
#include <vtkImageReslice.h>
#include <vtkImageChangeInformation.h>
#include <vtkPlaneSource.h>
#include <vtkPolyDataMapper.h>
#include <vtkCellArray.h>
#include <vtkCamera.h>
#include <vtkColorTransferFunction.h>
//ITK
#include <itkRGBAPixel.h>
#include <mitkRenderingModeProperty.h>
mitk::ImageVtkMapper2D::ImageVtkMapper2D()
{
}
mitk::ImageVtkMapper2D::~ImageVtkMapper2D()
{
//The 3D RW Mapper (Geometry2DDataVtkMapper3D) is listening to this event,
//in order to delete the images from the 3D RW.
this->InvokeEvent( itk::DeleteEvent() );
}
//set the two points defining the textured plane according to the dimension and spacing
void mitk::ImageVtkMapper2D::GeneratePlane(mitk::BaseRenderer* renderer, vtkFloatingPointType planeBounds[6])
{
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
float depth = this->CalculateLayerDepth(renderer);
//Set the origin to (xMin; yMin; depth) of the plane. This is necessary for obtaining the correct
//plane size in crosshair rotation and swivel mode.
localStorage->m_Plane->SetOrigin(planeBounds[0], planeBounds[2], depth);
//These two points define the axes of the plane in combination with the origin.
//Point 1 is the x-axis and point 2 the y-axis.
//Each plane is transformed according to the view (axial, coronal and saggital) afterwards.
localStorage->m_Plane->SetPoint1(planeBounds[1] , planeBounds[2], depth); //P1: (xMax, yMin, depth)
localStorage->m_Plane->SetPoint2(planeBounds[0], planeBounds[3], depth); //P2: (xMin, yMax, depth)
}
float mitk::ImageVtkMapper2D::CalculateLayerDepth(mitk::BaseRenderer* renderer)
{
//get the clipping range to check how deep into z direction we can render images
double maxRange = renderer->GetVtkRenderer()->GetActiveCamera()->GetClippingRange()[1];
//Due to a VTK bug, we cannot use the whole clipping range. /100 is empirically determined
float depth = -maxRange*0.01; // divide by 100
int layer = 0;
GetDataNode()->GetIntProperty( "layer", layer, renderer);
//add the layer property for each image to render images with a higher layer on top of the others
depth += layer*10; //*10: keep some room for each image (e.g. for QBalls in between)
if(depth > 0.0f) {
depth = 0.0f;
MITK_WARN << "Layer value exceeds clipping range. Set to minimum instead.";
}
return depth;
}
const mitk::Image* mitk::ImageVtkMapper2D::GetInput( void )
{
return static_cast< const mitk::Image * >( GetDataNode()->GetData() );
}
vtkProp* mitk::ImageVtkMapper2D::GetVtkProp(mitk::BaseRenderer* renderer)
{
//return the actor corresponding to the renderer
return m_LSH.GetLocalStorage(renderer)->m_Actors;
}
void mitk::ImageVtkMapper2D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
{
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
mitk::Image *input = const_cast< mitk::Image * >( this->GetInput() );
mitk::DataNode* datanode = this->GetDataNode();
if ( input == NULL || input->IsInitialized() == false )
{
return;
}
//check if there is a valid worldGeometry
const Geometry2D *worldGeometry = renderer->GetCurrentWorldGeometry2D();
if( ( worldGeometry == NULL ) || ( !worldGeometry->IsValid() ) || ( !worldGeometry->HasReferenceGeometry() ))
{
return;
}
input->Update();
// early out if there is no intersection of the current rendering geometry
// and the geometry of the image that is to be rendered.
if ( !RenderingGeometryIntersectsImage( worldGeometry, input->GetSlicedGeometry() ) )
{
// set image to NULL, to clear the texture in 3D, because
// the latest image is used there if the plane is out of the geometry
// see bug-13275
localStorage->m_ReslicedImage = NULL;
localStorage->m_Mapper->SetInput( localStorage->m_EmptyPolyData );
return;
}
//set main input for ExtractSliceFilter
localStorage->m_Reslicer->SetInput(input);
localStorage->m_Reslicer->SetWorldGeometry(worldGeometry);
localStorage->m_Reslicer->SetTimeStep( this->GetTimestep() );
//set the transformation of the image to adapt reslice axis
localStorage->m_Reslicer->SetResliceTransformByGeometry( input->GetTimeGeometry()->GetGeometryForTimeStep( this->GetTimestep() ) );
//is the geometry of the slice based on the input image or the worldgeometry?
bool inPlaneResampleExtentByGeometry = false;
datanode->GetBoolProperty("in plane resample extent by geometry", inPlaneResampleExtentByGeometry, renderer);
localStorage->m_Reslicer->SetInPlaneResampleExtentByGeometry(inPlaneResampleExtentByGeometry);
// Initialize the interpolation mode for resampling; switch to nearest
// neighbor if the input image is too small.
if ( (input->GetDimension() >= 3) && (input->GetDimension(2) > 1) )
{
VtkResliceInterpolationProperty *resliceInterpolationProperty;
datanode->GetProperty(
resliceInterpolationProperty, "reslice interpolation" );
int interpolationMode = VTK_RESLICE_NEAREST;
if ( resliceInterpolationProperty != NULL )
{
interpolationMode = resliceInterpolationProperty->GetInterpolation();
}
switch ( interpolationMode )
{
case VTK_RESLICE_NEAREST:
localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_NEAREST);
break;
case VTK_RESLICE_LINEAR:
localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_LINEAR);
break;
case VTK_RESLICE_CUBIC:
localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_CUBIC);
break;
}
}
else
{
localStorage->m_Reslicer->SetInterpolationMode(ExtractSliceFilter::RESLICE_NEAREST);
}
//set the vtk output property to true, makes sure that no unneeded mitk image convertion
//is done.
localStorage->m_Reslicer->SetVtkOutputRequest(true);
//Thickslicing
int thickSlicesMode = 0;
int thickSlicesNum = 1;
// Thick slices parameters
if( input->GetPixelType().GetNumberOfComponents() == 1 ) // for now only single component are allowed
{
DataNode *dn=renderer->GetCurrentWorldGeometry2DNode();
if(dn)
{
ResliceMethodProperty *resliceMethodEnumProperty=0;
if( dn->GetProperty( resliceMethodEnumProperty, "reslice.thickslices" ) && resliceMethodEnumProperty )
thickSlicesMode = resliceMethodEnumProperty->GetValueAsId();
IntProperty *intProperty=0;
if( dn->GetProperty( intProperty, "reslice.thickslices.num" ) && intProperty )
{
thickSlicesNum = intProperty->GetValue();
if(thickSlicesNum < 1) thickSlicesNum=1;
if(thickSlicesNum > 10) thickSlicesNum=10;
}
}
else
{
MITK_WARN << "no associated widget plane data tree node found";
}
}
const PlaneGeometry *planeGeometry = dynamic_cast< const PlaneGeometry * >( worldGeometry );
if(thickSlicesMode > 0)
{
double dataZSpacing = 1.0;
Vector3D normInIndex, normal;
if ( planeGeometry != NULL ){
normal = planeGeometry->GetNormal();
}else{
const mitk::AbstractTransformGeometry* abstractGeometry = dynamic_cast< const AbstractTransformGeometry * >(worldGeometry);
if(abstractGeometry != NULL)
normal = abstractGeometry->GetPlane()->GetNormal();
else
return; //no fitting geometry set
}
normal.Normalize();
input->GetTimeGeometry()->GetGeometryForTimeStep( this->GetTimestep() )->WorldToIndex( normal, normInIndex );
dataZSpacing = 1.0 / normInIndex.GetNorm();
localStorage->m_Reslicer->SetOutputDimensionality( 3 );
localStorage->m_Reslicer->SetOutputSpacingZDirection(dataZSpacing);
localStorage->m_Reslicer->SetOutputExtentZDirection( -thickSlicesNum, 0+thickSlicesNum );
// 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.
localStorage->m_TSFilter->SetThickSliceMode( thickSlicesMode-1 );
localStorage->m_TSFilter->SetInput( localStorage->m_Reslicer->GetVtkOutput() );
//vtkFilter=>mitkFilter=>vtkFilter update mechanism will fail without calling manually
localStorage->m_Reslicer->Modified();
localStorage->m_Reslicer->Update();
localStorage->m_TSFilter->Modified();
localStorage->m_TSFilter->Update();
localStorage->m_ReslicedImage = localStorage->m_TSFilter->GetOutput();
}
else
{
//this is needed when thick mode was enable bevore. These variable have to be reset to default values
localStorage->m_Reslicer->SetOutputDimensionality( 2 );
localStorage->m_Reslicer->SetOutputSpacingZDirection(1.0);
localStorage->m_Reslicer->SetOutputExtentZDirection( 0, 0 );
localStorage->m_Reslicer->Modified();
//start the pipeline with updating the largest possible, needed if the geometry of the input has changed
localStorage->m_Reslicer->UpdateLargestPossibleRegion();
localStorage->m_ReslicedImage = localStorage->m_Reslicer->GetVtkOutput();
}
// Bounds information for reslicing (only reuqired if reference geometry
// is present)
//this used for generating a vtkPLaneSource with the right size
vtkFloatingPointType sliceBounds[6];
for ( int i = 0; i < 6; ++i )
{
sliceBounds[i] = 0.0;
}
localStorage->m_Reslicer->GetClippedPlaneBounds(sliceBounds);
//get the spacing of the slice
localStorage->m_mmPerPixel = localStorage->m_Reslicer->GetOutputSpacing();
// calculate minimum bounding rect of IMAGE in texture
{
vtkFloatingPointType textureClippingBounds[6];
for ( int i = 0; i < 6; ++i )
{
textureClippingBounds[i] = 0.0;
}
// 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.
mitk::PlaneClipping::CalculateClippedPlaneBounds( input->GetGeometry(), planeGeometry, textureClippingBounds );
textureClippingBounds[0] = static_cast< int >( textureClippingBounds[0] / localStorage->m_mmPerPixel[0] + 0.5 );
textureClippingBounds[1] = static_cast< int >( textureClippingBounds[1] / localStorage->m_mmPerPixel[0] + 0.5 );
textureClippingBounds[2] = static_cast< int >( textureClippingBounds[2] / localStorage->m_mmPerPixel[1] + 0.5 );
textureClippingBounds[3] = static_cast< int >( textureClippingBounds[3] / localStorage->m_mmPerPixel[1] + 0.5 );
//clipping bounds for cutting the image
localStorage->m_LevelWindowFilter->SetClippingBounds(textureClippingBounds);
}
//get the number of scalar components to distinguish between different image types
int numberOfComponents = localStorage->m_ReslicedImage->GetNumberOfScalarComponents();
//get the binary property
bool binary = false;
bool binaryOutline = false;
datanode->GetBoolProperty( "binary", binary, renderer );
if(binary) //binary image
{
datanode->GetBoolProperty( "outline binary", binaryOutline, renderer );
if(binaryOutline) //contour rendering
{
if ( input->GetPixelType().GetBpe() <= 8 )
{
//generate contours/outlines
localStorage->m_OutlinePolyData = CreateOutlinePolyData(renderer);
float binaryOutlineWidth(1.0);
if ( datanode->GetFloatProperty( "outline width", binaryOutlineWidth, renderer ) )
{
if ( localStorage->m_Actors->GetNumberOfPaths() > 1 )
{
float binaryOutlineShadowWidth(1.5);
datanode->GetFloatProperty( "outline shadow width", binaryOutlineShadowWidth, renderer );
dynamic_cast<vtkActor*>(localStorage->m_Actors->GetParts()->GetItemAsObject(0))
->GetProperty()->SetLineWidth( binaryOutlineWidth * binaryOutlineShadowWidth );
}
localStorage->m_Actor->GetProperty()->SetLineWidth( binaryOutlineWidth );
}
}
else
{
binaryOutline = false;
this->ApplyLookuptable(renderer);
MITK_WARN << "Type of all binary images should be (un)signed char. Outline does not work on other pixel types!";
}
}
else //standard binary image
{
if(numberOfComponents != 1)
{
MITK_ERROR << "Rendering Error: Binary Images with more then 1 component are not supported!";
}
}
}
this->ApplyOpacity( renderer );
this->ApplyRenderingMode(renderer);
// do not use a VTK lookup table (we do that ourselves in m_LevelWindowFilter)
localStorage->m_Texture->MapColorScalarsThroughLookupTableOff();
int displayedComponent = 0;
if (datanode->GetIntProperty("Image.Displayed Component", displayedComponent, renderer) && numberOfComponents > 1)
{
localStorage->m_VectorComponentExtractor->SetComponents(displayedComponent);
localStorage->m_VectorComponentExtractor->SetInput(localStorage->m_ReslicedImage);
localStorage->m_LevelWindowFilter->SetInputConnection(localStorage->m_VectorComponentExtractor->GetOutputPort(0));
}
else
{
//connect the input with the levelwindow filter
localStorage->m_LevelWindowFilter->SetInput(localStorage->m_ReslicedImage);
}
// check for texture interpolation property
bool textureInterpolation = false;
GetDataNode()->GetBoolProperty( "texture interpolation", textureInterpolation, renderer );
//set the interpolation modus according to the property
localStorage->m_Texture->SetInterpolate(textureInterpolation);
// connect the texture with the output of the levelwindow filter
localStorage->m_Texture->SetInputConnection(localStorage->m_LevelWindowFilter->GetOutputPort());
this->TransformActor( renderer );
vtkActor* contourShadowActor = dynamic_cast<vtkActor*> (localStorage->m_Actors->GetParts()->GetItemAsObject(0));
if(binary && binaryOutline) //connect the mapper with the polyData which contains the lines
{
//We need the contour for the binary outline property as actor
localStorage->m_Mapper->SetInput(localStorage->m_OutlinePolyData);
localStorage->m_Actor->SetTexture(NULL); //no texture for contours
bool binaryOutlineShadow( false );
datanode->GetBoolProperty( "outline binary shadow", binaryOutlineShadow, renderer );
if ( binaryOutlineShadow )
contourShadowActor->SetVisibility( true );
else
contourShadowActor->SetVisibility( false );
}
else
{ //Connect the mapper with the input texture. This is the standard case.
//setup the textured plane
this->GeneratePlane( renderer, sliceBounds );
//set the plane as input for the mapper
localStorage->m_Mapper->SetInputConnection(localStorage->m_Plane->GetOutputPort());
//set the texture for the actor
localStorage->m_Actor->SetTexture(localStorage->m_Texture);
contourShadowActor->SetVisibility( false );
}
// We have been modified => save this for next Update()
localStorage->m_LastUpdateTime.Modified();
}
void mitk::ImageVtkMapper2D::ApplyLevelWindow(mitk::BaseRenderer *renderer)
{
LocalStorage *localStorage = this->GetLocalStorage( renderer );
LevelWindow levelWindow;
this->GetDataNode()->GetLevelWindow( levelWindow, renderer, "levelwindow" );
localStorage->m_LevelWindowFilter->GetLookupTable()->SetRange( levelWindow.GetLowerWindowBound(), levelWindow.GetUpperWindowBound() );
mitk::LevelWindow opacLevelWindow;
if( this->GetDataNode()->GetLevelWindow( opacLevelWindow, renderer, "opaclevelwindow" ) )
{
//pass the opaque level window to the filter
localStorage->m_LevelWindowFilter->SetMinOpacity(opacLevelWindow.GetLowerWindowBound());
localStorage->m_LevelWindowFilter->SetMaxOpacity(opacLevelWindow.GetUpperWindowBound());
}
else
{
//no opaque level window
localStorage->m_LevelWindowFilter->SetMinOpacity(0.0);
localStorage->m_LevelWindowFilter->SetMaxOpacity(255.0);
}
}
void mitk::ImageVtkMapper2D::ApplyColor( mitk::BaseRenderer* renderer )
{
LocalStorage *localStorage = this->GetLocalStorage( renderer );
float rgb[3]= { 1.0f, 1.0f, 1.0f };
// check for color prop and use it for rendering if it exists
// binary image hovering & binary image selection
bool hover = false;
bool selected = false;
GetDataNode()->GetBoolProperty("binaryimage.ishovering", hover, renderer);
GetDataNode()->GetBoolProperty("selected", selected, renderer);
if(hover && !selected)
{
mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty*>(GetDataNode()->GetProperty
("binaryimage.hoveringcolor", renderer));
if(colorprop.IsNotNull())
{
memcpy(rgb, colorprop->GetColor().GetDataPointer(), 3*sizeof(float));
}
else
{
GetDataNode()->GetColor( rgb, renderer, "color" );
}
}
if(selected)
{
mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty*>(GetDataNode()->GetProperty
("binaryimage.selectedcolor", renderer));
if(colorprop.IsNotNull()) {
memcpy(rgb, colorprop->GetColor().GetDataPointer(), 3*sizeof(float));
}
else
{
GetDataNode()->GetColor(rgb, renderer, "color");
}
}
if(!hover && !selected)
{
GetDataNode()->GetColor( rgb, renderer, "color" );
}
double rgbConv[3] = {(double)rgb[0], (double)rgb[1], (double)rgb[2]}; //conversion to double for VTK
dynamic_cast<vtkActor*> (localStorage->m_Actors->GetParts()->GetItemAsObject(0))->GetProperty()->SetColor(rgbConv);
localStorage->m_Actor->GetProperty()->SetColor(rgbConv);
if ( localStorage->m_Actors->GetParts()->GetNumberOfItems() > 1 )
{
float rgb[3]= { 1.0f, 1.0f, 1.0f };
mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty*>(GetDataNode()->GetProperty
("outline binary shadow color", renderer));
if(colorprop.IsNotNull())
{
memcpy(rgb, colorprop->GetColor().GetDataPointer(), 3*sizeof(float));
}
double rgbConv[3] = {(double)rgb[0], (double)rgb[1], (double)rgb[2]}; //conversion to double for VTK
dynamic_cast<vtkActor*>( localStorage->m_Actors->GetParts()->GetItemAsObject(0) )->GetProperty()->SetColor(rgbConv);
}
}
void mitk::ImageVtkMapper2D::ApplyOpacity( mitk::BaseRenderer* renderer )
{
LocalStorage* localStorage = this->GetLocalStorage( renderer );
float opacity = 1.0f;
// check for opacity prop and use it for rendering if it exists
GetDataNode()->GetOpacity( opacity, renderer, "opacity" );
//set the opacity according to the properties
localStorage->m_Actor->GetProperty()->SetOpacity(opacity);
if ( localStorage->m_Actors->GetParts()->GetNumberOfItems() > 1 )
{
dynamic_cast<vtkActor*>( localStorage->m_Actors->GetParts()->GetItemAsObject(0) )->GetProperty()->SetOpacity(opacity);
}
}
void mitk::ImageVtkMapper2D::ApplyRenderingMode( mitk::BaseRenderer* renderer )
{
LocalStorage* localStorage = m_LSH.GetLocalStorage(renderer);
bool binary = false;
this->GetDataNode()->GetBoolProperty( "binary", binary, renderer );
if(binary) // is it a binary image?
{
//for binary images, we always use our default LuT and map every value to (0,1)
//the opacity of 0 will always be 0.0. We never a apply a LuT/TfF nor a level window.
localStorage->m_LevelWindowFilter->SetLookupTable(localStorage->m_BinaryLookupTable);
}
else
{
//all other image types can make use of the rendering mode
int renderingMode = mitk::RenderingModeProperty::LEVELWINDOW_COLOR;
mitk::RenderingModeProperty::Pointer mode = dynamic_cast<mitk::RenderingModeProperty*>(this->GetDataNode()->GetProperty( "Image Rendering.Mode", renderer ));
if(mode.IsNotNull())
{
renderingMode = mode->GetRenderingMode();
}
switch(renderingMode)
{
case mitk::RenderingModeProperty::LEVELWINDOW_COLOR:
MITK_DEBUG << "'Image Rendering.Mode' = LevelWindow_Color";
localStorage->m_LevelWindowFilter->SetLookupTable( localStorage->m_DefaultLookupTable );
this->ApplyLevelWindow( renderer );
break;
case mitk::RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR:
MITK_DEBUG << "'Image Rendering.Mode' = LevelWindow_LookupTable_Color";
this->ApplyLookuptable( renderer );
this->ApplyLevelWindow( renderer );
break;
case mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_LEVELWINDOW_COLOR:
MITK_DEBUG << "'Image Rendering.Mode' = LevelWindow_ColorTransferFunction_Color";
this->ApplyColorTransferFunction( renderer );
this->ApplyLevelWindow( renderer );
break;
case mitk::RenderingModeProperty::LOOKUPTABLE_COLOR:
MITK_DEBUG << "'Image Rendering.Mode' = LookupTable_Color";
this->ApplyLookuptable( renderer );
break;
case mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_COLOR:
MITK_DEBUG << "'Image Rendering.Mode' = ColorTransferFunction_Color";
this->ApplyColorTransferFunction( renderer );
break;
default:
MITK_ERROR << "No valid 'Image Rendering.Mode' set";
break;
}
}
//we apply color for all images (including binaries).
this->ApplyColor( renderer );
}
void mitk::ImageVtkMapper2D::ApplyLookuptable( mitk::BaseRenderer* renderer )
{
LocalStorage* localStorage = m_LSH.GetLocalStorage(renderer);
vtkLookupTable* usedLookupTable = localStorage->m_ColorLookupTable;
// If lookup table or transferfunction use is requested...
mitk::LookupTableProperty::Pointer lookupTableProp = dynamic_cast<mitk::LookupTableProperty*>(this->GetDataNode()->GetProperty("LookupTable"));
if( lookupTableProp.IsNotNull() ) // is a lookuptable set?
{
usedLookupTable = lookupTableProp->GetLookupTable()->GetVtkLookupTable();
}
else
{
MITK_WARN << "Image Rendering.Mode was set to use a lookup table but there is no property 'LookupTable'. A default (rainbow) lookup table will be used.";
}
localStorage->m_LevelWindowFilter->SetLookupTable(usedLookupTable);
}
void mitk::ImageVtkMapper2D::ApplyColorTransferFunction(mitk::BaseRenderer *renderer)
{
mitk::TransferFunctionProperty::Pointer transferFunctionProp = dynamic_cast<mitk::TransferFunctionProperty*>(this->GetDataNode()->GetProperty("Image Rendering.Transfer Function",renderer ));
if( transferFunctionProp.IsNull() )
{
MITK_ERROR << "'Image Rendering.Mode'' was set to use a color transfer function but there is no property 'Image Rendering.Transfer Function'. Nothing will be done.";
return;
}
LocalStorage* localStorage = m_LSH.GetLocalStorage(renderer);
//pass the transfer function to our level window filter
localStorage->m_LevelWindowFilter->SetLookupTable(transferFunctionProp->GetValue()->GetColorTransferFunction());
}
void mitk::ImageVtkMapper2D::Update(mitk::BaseRenderer* renderer)
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if ( !visible )
{
return;
}
mitk::Image* data = const_cast<mitk::Image *>( this->GetInput() );
if ( data == NULL )
{
return;
}
// Calculate time step of the input data for the specified renderer (integer value)
this->CalculateTimeStep( renderer );
// Check if time step is valid
const TimeGeometry *dataTimeGeometry = data->GetTimeGeometry();
if ( ( dataTimeGeometry == NULL )
- || ( dataTimeGeometry->GetNumberOfTimeSteps() == 0 )
+ || ( dataTimeGeometry->CountTimeSteps() == 0 )
|| ( !dataTimeGeometry->IsValidTimeStep( this->GetTimestep() ) ) )
{
return;
}
const DataNode *node = this->GetDataNode();
data->UpdateOutputInformation();
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
//check if something important has changed and we need to rerender
if ( (localStorage->m_LastUpdateTime < node->GetMTime()) //was the node modified?
|| (localStorage->m_LastUpdateTime < data->GetPipelineMTime()) //Was the data modified?
|| (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldGeometry2DUpdateTime()) //was the geometry modified?
|| (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldGeometry2D()->GetMTime())
|| (localStorage->m_LastUpdateTime < node->GetPropertyList()->GetMTime()) //was a property modified?
|| (localStorage->m_LastUpdateTime < node->GetPropertyList(renderer)->GetMTime()) )
{
this->GenerateDataForRenderer( renderer );
}
// since we have checked that nothing important has changed, we can set
// m_LastUpdateTime to the current time
localStorage->m_LastUpdateTime.Modified();
}
void mitk::ImageVtkMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
{
mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
// Properties common for both images and segmentations
node->AddProperty( "depthOffset", mitk::FloatProperty::New( 0.0 ), renderer, overwrite );
node->AddProperty( "outline binary", mitk::BoolProperty::New( false ), renderer, overwrite );
node->AddProperty( "outline width", mitk::FloatProperty::New( 1.0 ), renderer, overwrite );
node->AddProperty( "outline binary shadow", mitk::BoolProperty::New( false ), renderer, overwrite );
node->AddProperty( "outline binary shadow color", ColorProperty::New(0.0,0.0,0.0), renderer, overwrite );
node->AddProperty( "outline shadow width", mitk::FloatProperty::New( 1.5 ), renderer, overwrite );
if(image->IsRotated()) node->AddProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New(VTK_RESLICE_CUBIC) );
else node->AddProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New() );
node->AddProperty( "texture interpolation", mitk::BoolProperty::New( mitk::DataNodeFactory::m_TextureInterpolationActive ) ); // set to user configurable default value (see global options)
node->AddProperty( "in plane resample extent by geometry", mitk::BoolProperty::New( false ) );
node->AddProperty( "bounding box", mitk::BoolProperty::New( false ) );
mitk::RenderingModeProperty::Pointer renderingModeProperty = mitk::RenderingModeProperty::New();
node->AddProperty( "Image Rendering.Mode", renderingModeProperty);
std::string photometricInterpretation; // DICOM tag telling us how pixel values should be displayed
if ( node->GetStringProperty( "dicom.pixel.PhotometricInterpretation", photometricInterpretation ) )
{
// modality provided by DICOM or other reader
if ( photometricInterpretation.find("MONOCHROME1") != std::string::npos ) // meaning: display MINIMUM pixels as WHITE
{
// generate LUT (white to black)
mitk::LookupTable::Pointer mitkLut = mitk::LookupTable::New();
vtkLookupTable* bwLut = mitkLut->GetVtkLookupTable();
bwLut->SetTableRange (0, 1);
bwLut->SetSaturationRange (0, 0);
bwLut->SetHueRange (0, 0);
bwLut->SetValueRange (1, 0);
bwLut->SetAlphaRange (1, 1);
bwLut->SetRampToLinear();
bwLut->Build();
mitk::LookupTableProperty::Pointer mitkLutProp = mitk::LookupTableProperty::New();
mitkLutProp->SetLookupTable(mitkLut);
node->SetProperty( "LookupTable", mitkLutProp );
}
else
if ( photometricInterpretation.find("MONOCHROME2") != std::string::npos ) // meaning: display MINIMUM pixels as BLACK
{
// apply default LUT (black to white)
node->SetProperty( "color", mitk::ColorProperty::New( 1,1,1 ), renderer );
}
// PALETTE interpretation should be handled ok by RGB loading
}
bool isBinaryImage(false);
if ( ! node->GetBoolProperty("binary", isBinaryImage) )
{
// ok, property is not set, use heuristic to determine if this
// is a binary image
mitk::Image::Pointer centralSliceImage;
ScalarType minValue = 0.0;
ScalarType maxValue = 0.0;
ScalarType min2ndValue = 0.0;
ScalarType max2ndValue = 0.0;
mitk::ImageSliceSelector::Pointer sliceSelector = mitk::ImageSliceSelector::New();
sliceSelector->SetInput(image);
sliceSelector->SetSliceNr(image->GetDimension(2)/2);
sliceSelector->SetTimeNr(image->GetDimension(3)/2);
sliceSelector->SetChannelNr(image->GetDimension(4)/2);
sliceSelector->Update();
centralSliceImage = sliceSelector->GetOutput();
if ( centralSliceImage.IsNotNull() && centralSliceImage->IsInitialized() )
{
minValue = centralSliceImage->GetStatistics()->GetScalarValueMin();
maxValue = centralSliceImage->GetStatistics()->GetScalarValueMax();
min2ndValue = centralSliceImage->GetStatistics()->GetScalarValue2ndMin();
max2ndValue = centralSliceImage->GetStatistics()->GetScalarValue2ndMax();
}
if ((maxValue == min2ndValue && minValue == max2ndValue) || minValue == maxValue)
{
// centralSlice is strange, lets look at all data
minValue = image->GetStatistics()->GetScalarValueMin();
maxValue = image->GetStatistics()->GetScalarValueMaxNoRecompute();
min2ndValue = image->GetStatistics()->GetScalarValue2ndMinNoRecompute();
max2ndValue = image->GetStatistics()->GetScalarValue2ndMaxNoRecompute();
}
isBinaryImage = ( maxValue == min2ndValue && minValue == max2ndValue );
}
// some more properties specific for a binary...
if (isBinaryImage)
{
node->AddProperty( "opacity", mitk::FloatProperty::New(0.3f), renderer, overwrite );
node->AddProperty( "color", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
node->AddProperty( "binaryimage.selectedcolor", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
node->AddProperty( "binaryimage.selectedannotationcolor", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
node->AddProperty( "binaryimage.hoveringcolor", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
node->AddProperty( "binaryimage.hoveringannotationcolor", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
node->AddProperty( "binary", mitk::BoolProperty::New( true ), renderer, overwrite );
node->AddProperty("layer", mitk::IntProperty::New(10), renderer, overwrite);
}
else //...or image type object
{
node->AddProperty( "opacity", mitk::FloatProperty::New(1.0f), renderer, overwrite );
node->AddProperty( "color", ColorProperty::New(1.0,1.0,1.0), renderer, overwrite );
node->AddProperty( "binary", mitk::BoolProperty::New( false ), renderer, overwrite );
node->AddProperty("layer", mitk::IntProperty::New(0), renderer, overwrite);
std::string className = image->GetNameOfClass();
if (className != "TensorImage" && className != "QBallImage")
{
PixelType pixelType = image->GetPixelType();
size_t numComponents = pixelType.GetNumberOfComponents();
if ((pixelType.GetPixelTypeAsString() == "vector" && numComponents > 1) || numComponents == 2 || numComponents > 4)
node->AddProperty("Image.Displayed Component", mitk::IntProperty::New(0), renderer, overwrite);
}
}
if(image.IsNotNull() && image->IsInitialized())
{
if((overwrite) || (node->GetProperty("levelwindow", renderer)==NULL))
{
/* initialize level/window from DICOM tags */
std::string sLevel;
std::string sWindow;
if ( image->GetPropertyList()->GetStringProperty( "dicom.voilut.WindowCenter", sLevel )
&& image->GetPropertyList()->GetStringProperty( "dicom.voilut.WindowWidth", sWindow ) )
{
float level = atof( sLevel.c_str() );
float window = atof( sWindow.c_str() );
mitk::LevelWindow contrast;
std::string sSmallestPixelValueInSeries;
std::string sLargestPixelValueInSeries;
if ( image->GetPropertyList()->GetStringProperty( "dicom.series.SmallestPixelValueInSeries", sSmallestPixelValueInSeries )
&& image->GetPropertyList()->GetStringProperty( "dicom.series.LargestPixelValueInSeries", sLargestPixelValueInSeries ) )
{
float smallestPixelValueInSeries = atof( sSmallestPixelValueInSeries.c_str() );
float largestPixelValueInSeries = atof( sLargestPixelValueInSeries.c_str() );
contrast.SetRangeMinMax( smallestPixelValueInSeries-1, largestPixelValueInSeries+1 ); // why not a little buffer?
// might remedy some l/w widget challenges
}
else
{
contrast.SetAuto( static_cast<mitk::Image*>(node->GetData()), false, true ); // we need this as a fallback
}
contrast.SetLevelWindow( level, window, true );
node->SetProperty( "levelwindow", LevelWindowProperty::New( contrast ), renderer );
}
}
if(((overwrite) || (node->GetProperty("opaclevelwindow", renderer)==NULL))
&& (image->GetPixelType().GetPixelType() == itk::ImageIOBase::RGBA)
&& (image->GetPixelType().GetComponentType() == itk::ImageIOBase::UCHAR) )
{
mitk::LevelWindow opaclevwin;
opaclevwin.SetRangeMinMax(0,255);
opaclevwin.SetWindowBounds(0,255);
mitk::LevelWindowProperty::Pointer prop = mitk::LevelWindowProperty::New(opaclevwin);
node->SetProperty( "opaclevelwindow", prop, renderer );
}
}
Superclass::SetDefaultProperties(node, renderer, overwrite);
}
mitk::ImageVtkMapper2D::LocalStorage* mitk::ImageVtkMapper2D::GetLocalStorage(mitk::BaseRenderer* renderer)
{
return m_LSH.GetLocalStorage(renderer);
}
vtkSmartPointer<vtkPolyData> mitk::ImageVtkMapper2D::CreateOutlinePolyData(mitk::BaseRenderer* renderer ){
LocalStorage* localStorage = this->GetLocalStorage(renderer);
//get the min and max index values of each direction
int* extent = localStorage->m_ReslicedImage->GetExtent();
int xMin = extent[0];
int xMax = extent[1];
int yMin = extent[2];
int yMax = extent[3];
int* dims = localStorage->m_ReslicedImage->GetDimensions(); //dimensions of the image
int line = dims[0]; //how many pixels per line?
int x = xMin; //pixel index x
int y = yMin; //pixel index y
char* currentPixel;
//get the depth for each contour
float depth = CalculateLayerDepth(renderer);
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New(); //the points to draw
vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New(); //the lines to connect the points
// We take the pointer to the first pixel of the image
currentPixel = static_cast<char*>(localStorage->m_ReslicedImage->GetScalarPointer() );
while (y <= yMax)
{
//if the current pixel value is set to something
if ((currentPixel) && (*currentPixel != 0))
{
//check in which direction a line is necessary
//a line is added if the neighbor of the current pixel has the value 0
//and if the pixel is located at the edge of the image
//if vvvvv not the first line vvvvv
if (y > yMin && *(currentPixel-line) == 0)
{ //x direction - bottom edge of the pixel
//add the 2 points
vtkIdType p1 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
vtkIdType p2 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
//add the line between both points
lines->InsertNextCell(2);
lines->InsertCellPoint(p1);
lines->InsertCellPoint(p2);
}
//if vvvvv not the last line vvvvv
if (y < yMax && *(currentPixel+line) == 0)
{ //x direction - top edge of the pixel
vtkIdType p1 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
vtkIdType p2 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
lines->InsertNextCell(2);
lines->InsertCellPoint(p1);
lines->InsertCellPoint(p2);
}
//if vvvvv not the first pixel vvvvv
if ( (x > xMin || y > yMin) && *(currentPixel-1) == 0)
{ //y direction - left edge of the pixel
vtkIdType p1 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
vtkIdType p2 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
lines->InsertNextCell(2);
lines->InsertCellPoint(p1);
lines->InsertCellPoint(p2);
}
//if vvvvv not the last pixel vvvvv
if ( (y < yMax || (x < xMax) ) && *(currentPixel+1) == 0)
{ //y direction - right edge of the pixel
vtkIdType p1 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
vtkIdType p2 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
lines->InsertNextCell(2);
lines->InsertCellPoint(p1);
lines->InsertCellPoint(p2);
}
/* now consider pixels at the edge of the image */
//if vvvvv left edge of image vvvvv
if (x == xMin)
{ //draw left edge of the pixel
vtkIdType p1 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
vtkIdType p2 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
lines->InsertNextCell(2);
lines->InsertCellPoint(p1);
lines->InsertCellPoint(p2);
}
//if vvvvv right edge of image vvvvv
if (x == xMax)
{ //draw right edge of the pixel
vtkIdType p1 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
vtkIdType p2 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
lines->InsertNextCell(2);
lines->InsertCellPoint(p1);
lines->InsertCellPoint(p2);
}
//if vvvvv bottom edge of image vvvvv
if (y == yMin)
{ //draw bottom edge of the pixel
vtkIdType p1 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
vtkIdType p2 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], y*localStorage->m_mmPerPixel[1], depth);
lines->InsertNextCell(2);
lines->InsertCellPoint(p1);
lines->InsertCellPoint(p2);
}
//if vvvvv top edge of image vvvvv
if (y == yMax)
{ //draw top edge of the pixel
vtkIdType p1 = points->InsertNextPoint(x*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
vtkIdType p2 = points->InsertNextPoint((x+1)*localStorage->m_mmPerPixel[0], (y+1)*localStorage->m_mmPerPixel[1], depth);
lines->InsertNextCell(2);
lines->InsertCellPoint(p1);
lines->InsertCellPoint(p2);
}
}//end if currentpixel is set
x++;
if (x > xMax)
{ //reached end of line
x = xMin;
y++;
}
// Increase the pointer-position to the next pixel.
// This is safe, as the while-loop and the x-reset logic above makes
// sure we do not exceed the bounds of the image
currentPixel++;
}//end of while
// Create a polydata to store everything in
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
// Add the points to the dataset
polyData->SetPoints(points);
// Add the lines to the dataset
polyData->SetLines(lines);
return polyData;
}
void mitk::ImageVtkMapper2D::TransformActor(mitk::BaseRenderer* renderer)
{
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
//get the transformation matrix of the reslicer in order to render the slice as axial, coronal or saggital
vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
vtkSmartPointer<vtkMatrix4x4> matrix = localStorage->m_Reslicer->GetResliceAxes();
trans->SetMatrix(matrix);
//transform the plane/contour (the actual actor) to the corresponding view (axial, coronal or saggital)
localStorage->m_Actor->SetUserTransform(trans);
//transform the origin to center based coordinates, because MITK is center based.
localStorage->m_Actor->SetPosition( -0.5*localStorage->m_mmPerPixel[0], -0.5*localStorage->m_mmPerPixel[1], 0.0);
if ( localStorage->m_Actors->GetNumberOfPaths() > 1 )
{
vtkActor* secondaryActor = dynamic_cast<vtkActor*>( localStorage->m_Actors->GetParts()->GetItemAsObject(0) );
secondaryActor->SetUserTransform(trans);
secondaryActor->SetPosition( -0.5*localStorage->m_mmPerPixel[0], -0.5*localStorage->m_mmPerPixel[1], 0.0);
}
}
bool mitk::ImageVtkMapper2D::RenderingGeometryIntersectsImage( const Geometry2D* renderingGeometry, SlicedGeometry3D* imageGeometry )
{
// if either one of the two geometries is NULL we return true
// for safety reasons
if ( renderingGeometry == NULL || imageGeometry == NULL )
return true;
// get the distance for the first cornerpoint
ScalarType initialDistance = renderingGeometry->SignedDistance( imageGeometry->GetCornerPoint( 0 ) );
for( int i=1; i<8; i++ )
{
mitk::Point3D cornerPoint = imageGeometry->GetCornerPoint( i );
// get the distance to the other cornerpoints
ScalarType distance = renderingGeometry->SignedDistance( cornerPoint );
// if it has not the same signing as the distance of the first point
if ( initialDistance * distance < 0 )
{
// we have an intersection and return true
return true;
}
}
// all distances have the same sign, no intersection and we return false
return false;
}
mitk::ImageVtkMapper2D::LocalStorage::~LocalStorage()
{
}
mitk::ImageVtkMapper2D::LocalStorage::LocalStorage()
: m_VectorComponentExtractor(vtkSmartPointer<vtkImageExtractComponents>::New())
{
m_LevelWindowFilter = vtkSmartPointer<vtkMitkLevelWindowFilter>::New();
//Do as much actions as possible in here to avoid double executions.
m_Plane = vtkSmartPointer<vtkPlaneSource>::New();
m_Texture = vtkSmartPointer<vtkNeverTranslucentTexture>::New().GetPointer();
m_DefaultLookupTable = vtkSmartPointer<vtkLookupTable>::New();
m_BinaryLookupTable = vtkSmartPointer<vtkLookupTable>::New();
m_ColorLookupTable = vtkSmartPointer<vtkLookupTable>::New();
m_Mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
m_Actor = vtkSmartPointer<vtkActor>::New();
m_Actors = vtkSmartPointer<vtkPropAssembly>::New();
m_Reslicer = mitk::ExtractSliceFilter::New();
m_TSFilter = vtkSmartPointer<vtkMitkThickSlicesFilter>::New();
m_OutlinePolyData = vtkSmartPointer<vtkPolyData>::New();
m_ReslicedImage = vtkSmartPointer<vtkImageData>::New();
m_EmptyPolyData = vtkSmartPointer<vtkPolyData>::New();
//the following actions are always the same and thus can be performed
//in the constructor for each image (i.e. the image-corresponding local storage)
m_TSFilter->ReleaseDataFlagOn();
//built a default lookuptable
m_DefaultLookupTable->SetRampToLinear();
m_DefaultLookupTable->SetSaturationRange( 0.0, 0.0 );
m_DefaultLookupTable->SetHueRange( 0.0, 0.0 );
m_DefaultLookupTable->SetValueRange( 0.0, 1.0 );
m_DefaultLookupTable->Build();
m_BinaryLookupTable->SetRampToLinear();
m_BinaryLookupTable->SetSaturationRange( 0.0, 0.0 );
m_BinaryLookupTable->SetHueRange( 0.0, 0.0 );
m_BinaryLookupTable->SetValueRange( 0.0, 1.0 );
m_BinaryLookupTable->SetRange(0.0, 1.0);
m_BinaryLookupTable->Build();
// add a default rainbow lookup table for color mapping
m_ColorLookupTable->SetRampToLinear();
m_ColorLookupTable->SetHueRange(0.6667, 0.0);
m_ColorLookupTable->SetTableRange(0.0, 20.0);
m_ColorLookupTable->Build();
// make first value transparent
{
double rgba[4];
m_BinaryLookupTable->GetTableValue(0, rgba);
m_BinaryLookupTable->SetTableValue(0, rgba[0], rgba[1], rgba[2], 0.0); // background to 0
}
//do not repeat the texture (the image)
m_Texture->RepeatOff();
//set the mapper for the actor
m_Actor->SetMapper( m_Mapper );
vtkSmartPointer<vtkActor> outlineShadowActor = vtkSmartPointer<vtkActor>::New();
outlineShadowActor->SetMapper( m_Mapper );
m_Actors->AddPart( outlineShadowActor );
m_Actors->AddPart( m_Actor );
}
diff --git a/Core/Code/Rendering/mitkMapper.cpp b/Core/Code/Rendering/mitkMapper.cpp
index 81a07a2024..f2157b2bed 100644
--- a/Core/Code/Rendering/mitkMapper.cpp
+++ b/Core/Code/Rendering/mitkMapper.cpp
@@ -1,165 +1,165 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkMapper.h"
#include "mitkDataNode.h"
#include "mitkBaseRenderer.h"
#include "mitkProperties.h"
mitk::Mapper::Mapper()
: m_DataNode(NULL)
, m_TimeStep( 0 )
{
}
mitk::Mapper::~Mapper()
{
}
mitk::BaseData* mitk::Mapper::GetData() const
{
return m_DataNode == NULL ? NULL : m_DataNode->GetData();
}
mitk::DataNode* mitk::Mapper::GetDataNode() const
{
return this->m_DataNode;
}
bool mitk::Mapper::GetColor(float rgb[3], mitk::BaseRenderer* renderer, const char* name) const
{
const mitk::DataNode* node=GetDataNode();
if(node==NULL)
return false;
return node->GetColor(rgb, renderer, name);
}
bool mitk::Mapper::GetVisibility(bool &visible, mitk::BaseRenderer* renderer, const char* name) const
{
const mitk::DataNode* node=GetDataNode();
if(node==NULL)
return false;
return node->GetVisibility(visible, renderer, name);
}
bool mitk::Mapper::GetOpacity(float &opacity, mitk::BaseRenderer* renderer, const char* name) const
{
const mitk::DataNode* node=GetDataNode();
if(node==NULL)
return false;
return node->GetOpacity(opacity, renderer, name);
}
bool mitk::Mapper::GetLevelWindow(mitk::LevelWindow& levelWindow, mitk::BaseRenderer* renderer, const char* name) const
{
const mitk::DataNode* node=GetDataNode();
if(node==NULL)
return false;
return node->GetLevelWindow(levelWindow, renderer, name);
}
bool mitk::Mapper::IsVisible(mitk::BaseRenderer* renderer, const char* name) const
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, name);
return visible;
}
void mitk::Mapper::CalculateTimeStep( mitk::BaseRenderer *renderer )
{
if ( ( renderer != NULL ) && ( m_DataNode != NULL ) )
{
m_TimeStep = renderer->GetTimeStep(m_DataNode->GetData());
}
else
{
m_TimeStep = 0;
}
}
void mitk::Mapper::Update(mitk::BaseRenderer *renderer)
{
const DataNode* node = GetDataNode();
assert(node!=NULL);
mitk::BaseData * data = static_cast<mitk::BaseData *>(node->GetData());
if (!data)
return;
// Calculate time step of the input data for the specified renderer (integer value)
this->CalculateTimeStep( renderer );
// Check if time step is valid
const TimeGeometry *dataTimeGeometry = data->GetTimeGeometry();
if ( ( dataTimeGeometry == NULL )
- || ( dataTimeGeometry->GetNumberOfTimeSteps() == 0 )
+ || ( dataTimeGeometry->CountTimeSteps() == 0 )
|| ( !dataTimeGeometry->IsValidTimeStep( m_TimeStep ) ) )
{
// TimeGeometry or time step is not valid for this data:
// reset mapper so that nothing is displayed
this->ResetMapper( renderer );
return;
}
this->GenerateDataForRenderer(renderer);
}
bool mitk::Mapper::BaseLocalStorage::IsGenerateDataRequired(
mitk::BaseRenderer *renderer,
mitk::Mapper *mapper,
mitk::DataNode *dataNode) const
{
if( mapper && m_LastGenerateDataTime < mapper -> GetMTime () )
return true;
if( dataNode )
{
if( m_LastGenerateDataTime < dataNode -> GetDataReferenceChangedTime () )
return true;
mitk::BaseData * data = dataNode -> GetData ( ) ;
if( data && m_LastGenerateDataTime < data -> GetMTime ( ) )
return true;
}
if( renderer && m_LastGenerateDataTime < renderer -> GetTimeStepUpdateTime ( ) )
return true;
return false;
}
void mitk::Mapper::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
{
node->AddProperty( "visible", mitk::BoolProperty::New(true), renderer, overwrite );
node->AddProperty( "layer", mitk::IntProperty::New(0), renderer, overwrite);
node->AddProperty( "name", mitk::StringProperty::New("No Name!"), renderer, overwrite );
}
diff --git a/Core/Code/Rendering/mitkPointSetGLMapper2D.cpp b/Core/Code/Rendering/mitkPointSetGLMapper2D.cpp
index 59ef764078..fe850d975b 100644
--- a/Core/Code/Rendering/mitkPointSetGLMapper2D.cpp
+++ b/Core/Code/Rendering/mitkPointSetGLMapper2D.cpp
@@ -1,524 +1,524 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPointSetGLMapper2D.h"
#include "mitkPointSet.h"
#include "mitkPlaneGeometry.h"
#include "mitkColorProperty.h"
#include "mitkProperties.h"
#include "vtkLinearTransform.h"
#include "mitkStringProperty.h"
#include "mitkPointSet.h"
#include "mitkVtkPropRenderer.h"
#include "mitkGL.h"
//const float selectedColor[]={1.0,0.0,0.6}; //for selected!
mitk::PointSetGLMapper2D::PointSetGLMapper2D()
: m_Polygon(false),
m_ShowPoints(true),
m_ShowDistances(false),
m_DistancesDecimalDigits(1),
m_ShowAngles(false),
m_ShowDistantLines(true),
m_LineWidth(1)
{
}
mitk::PointSetGLMapper2D::~PointSetGLMapper2D()
{
}
const mitk::PointSet *mitk::PointSetGLMapper2D::GetInput(void)
{
return static_cast<const mitk::PointSet * > ( GetDataNode()->GetData() );
}
void mitk::PointSetGLMapper2D::ApplyAllProperties(mitk::BaseRenderer* renderer)
{
GLMapper::ApplyColorAndOpacityProperties( renderer );
const mitk::DataNode* node=GetDataNode();
if( node == NULL )
return;
node->GetBoolProperty("show contour", m_Polygon);
node->GetBoolProperty("close contour", m_PolygonClosed);
node->GetBoolProperty("show points", m_ShowPoints);
node->GetBoolProperty("show distances", m_ShowDistances);
node->GetIntProperty("distance decimal digits", m_DistancesDecimalDigits);
node->GetBoolProperty("show angles", m_ShowAngles);
node->GetBoolProperty("show distant lines", m_ShowDistantLines);
node->GetIntProperty("line width", m_LineWidth);
node->GetIntProperty("point line width", m_PointLineWidth);
node->GetIntProperty("point 2D size", m_Point2DSize);
}
static bool makePerpendicularVector2D(const mitk::Vector2D& in, mitk::Vector2D& out)
{
if((fabs(in[0])>0) && ( (fabs(in[0])>fabs(in[1])) || (in[1] == 0) ) )
{
out[0]=-in[1]/in[0];
out[1]=1;
out.Normalize();
return true;
}
else
if(fabs(in[1])>0)
{
out[0]=1;
out[1]=-in[0]/in[1];
out.Normalize();
return true;
}
else
return false;
}
void mitk::PointSetGLMapper2D::Paint( mitk::BaseRenderer *renderer )
{
const mitk::DataNode* node=GetDataNode();
if( node == NULL )
return;
const int text2dDistance = 10;
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if ( !visible) return;
// @FIXME: Logik fuer update
bool updateNeccesary=true;
if (updateNeccesary)
{
// ok, das ist aus GenerateData kopiert
mitk::PointSet::Pointer input = const_cast<mitk::PointSet*>(this->GetInput());
// Get the TimeGeometry of the input object
const TimeGeometry* inputTimeGeometry = input->GetTimeGeometry();
- if (( inputTimeGeometry == NULL ) || ( inputTimeGeometry->GetNumberOfTimeSteps() == 0 ) )
+ if (( inputTimeGeometry == NULL ) || ( inputTimeGeometry->CountTimeSteps() == 0 ) )
{
return;
}
//
// get the world time
//
const Geometry2D* worldGeometry = renderer->GetCurrentWorldGeometry2D();
assert( worldGeometry != NULL );
ScalarType time = worldGeometry->GetTimeBounds()[ 0 ];
//
// convert the world time in time steps of the input object
//
int timeStep=0;
if ( time > ScalarTypeNumericTraits::NonpositiveMin() )
timeStep = inputTimeGeometry->TimePointToTimeStep( time );
if ( inputTimeGeometry->IsValidTimeStep( timeStep ) == false )
{
return;
}
mitk::PointSet::DataType::Pointer itkPointSet = input->GetPointSet( timeStep );
if ( itkPointSet.GetPointer() == NULL)
{
return;
}
mitk::DisplayGeometry::Pointer displayGeometry = renderer->GetDisplayGeometry();
assert(displayGeometry.IsNotNull());
//apply color and opacity read from the PropertyList
this->ApplyAllProperties(renderer);
vtkLinearTransform* transform = GetDataNode()->GetVtkTransform();
//List of the Points
PointSet::DataType::PointsContainerConstIterator it, end;
it = itkPointSet->GetPoints()->Begin();
end = itkPointSet->GetPoints()->End();
//iterator on the additional data of each point
PointSet::DataType::PointDataContainerIterator selIt, selEnd;
bool pointDataBroken = (itkPointSet->GetPointData()->Size() != itkPointSet->GetPoints()->Size());
selIt = itkPointSet->GetPointData()->Begin();
selEnd = itkPointSet->GetPointData()->End();
int counter = 0;
//for writing text
int j = 0;
//for switching back to old color after using selected color
float recallColor[4];
glGetFloatv(GL_CURRENT_COLOR,recallColor);
//get the properties for coloring the points
float unselectedColor[4] = {1.0, 1.0, 0.0, 1.0};//yellow
//check if there is an unselected property
if (dynamic_cast<mitk::ColorProperty*>(node->GetPropertyList(renderer)->GetProperty("unselectedcolor")) != NULL)
{
mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("unselectedcolor"))->GetValue();
unselectedColor[0] = tmpColor[0];
unselectedColor[1] = tmpColor[1];
unselectedColor[2] = tmpColor[2];
unselectedColor[3] = 1.0f; //!!define a new ColorProp to be able to pass alpha value
}
else if (dynamic_cast<mitk::ColorProperty*>(node->GetPropertyList(NULL)->GetProperty("unselectedcolor")) != NULL)
{
mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("unselectedcolor"))->GetValue();
unselectedColor[0] = tmpColor[0];
unselectedColor[1] = tmpColor[1];
unselectedColor[2] = tmpColor[2];
unselectedColor[3] = 1.0f; //!!define a new ColorProp to be able to pass alpha value
}
else
{
//get the color from the dataNode
node->GetColor(unselectedColor, NULL);
}
//get selected property
float selectedColor[4] = {1.0, 0.0, 0.6, 1.0};
if (dynamic_cast<mitk::ColorProperty*>(node->GetPropertyList(renderer)->GetProperty("selectedcolor")) != NULL)
{
mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("selectedcolor"))->GetValue();
selectedColor[0] = tmpColor[0];
selectedColor[1] = tmpColor[1];
selectedColor[2] = tmpColor[2];
selectedColor[3] = 1.0f;
}
else if (dynamic_cast<mitk::ColorProperty*>(node->GetPropertyList(NULL)->GetProperty("selectedcolor")) != NULL)
{
mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("selectedcolor"))->GetValue();
selectedColor[0] = tmpColor[0];
selectedColor[1] = tmpColor[1];
selectedColor[2] = tmpColor[2];
selectedColor[3] = 1.0f;
}
//check if there is an pointLineWidth property
if (dynamic_cast<mitk::IntProperty*>(node->GetPropertyList(renderer)->GetProperty("point line width")) != NULL)
{
m_PointLineWidth = dynamic_cast<mitk::IntProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("point line width"))->GetValue();
}
else if (dynamic_cast<mitk::IntProperty*>(node->GetPropertyList(NULL)->GetProperty("point line width")) != NULL)
{
m_PointLineWidth = dynamic_cast<mitk::IntProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("point line width"))->GetValue();
}
//check if there is an point 2D size property
if (dynamic_cast<mitk::IntProperty*>(node->GetPropertyList(renderer)->GetProperty("point 2D size")) != NULL)
{
m_Point2DSize = dynamic_cast<mitk::IntProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("point 2D size"))->GetValue();
}
else if (dynamic_cast<mitk::IntProperty*>(node->GetPropertyList(NULL)->GetProperty("point 2D size")) != NULL)
{
m_Point2DSize = dynamic_cast<mitk::IntProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("point 2D size"))->GetValue();
}
Point3D p; // currently visited point
Point3D lastP; // last visited point
Vector3D vec; // p - lastP
Vector3D lastVec; // lastP - point before lastP
vec.Fill(0);
mitk::Point3D projected_p; // p projected on viewplane
Point2D pt2d; // projected_p in display coordinates
Point2D lastPt2d; // last projected_p in display coordinates
Point2D preLastPt2d;// projected_p in display coordinates before lastPt2d
Point2D lastPt2DInPointSet; // The last point in the pointset in display coordinates
mitk::PointSet::DataType::PointType plob;
plob.Fill(0);
itkPointSet->GetPoint( itkPointSet->GetNumberOfPoints()-1, &plob);
//map lastPt2DInPointSet to display coordinates
float vtkp[3];
itk2vtk(plob, vtkp);
transform->TransformPoint(vtkp, vtkp);
vtk2itk(vtkp,p);
displayGeometry->Project(p, projected_p);
displayGeometry->Map(projected_p, lastPt2DInPointSet);
displayGeometry->WorldToDisplay(lastPt2DInPointSet, lastPt2DInPointSet);
while(it!=end) // iterate over all points
{
lastP = p; // valid only for counter > 0
lastVec = vec; // valid only for counter > 1
preLastPt2d = lastPt2d; // valid only for counter > 1
lastPt2d = pt2d; // valid only for counter > 0
itk2vtk(it->Value(), vtkp);
transform->TransformPoint(vtkp, vtkp);
vtk2itk(vtkp,p);
vec = p-lastP; // valid only for counter > 0
displayGeometry->Project(p, projected_p);
Vector3D diff=p-projected_p;
ScalarType scalardiff = diff.GetSquaredNorm();
//MouseOrientation
bool isInputDevice=false;
bool isRendererSlice = scalardiff < 0.00001; //cause roundoff error
if(this->GetDataNode()->GetBoolProperty("inputdevice",isInputDevice) && isInputDevice && !isRendererSlice )
{
displayGeometry->Map(projected_p, pt2d);
displayGeometry->WorldToDisplay(pt2d, pt2d);
//Point size depending of distance to slice
/*float p_size = (1/scalardiff)*10*m_Point2DSize;
if(p_size < m_Point2DSize * 0.6 )
p_size = m_Point2DSize * 0.6 ;
else if ( p_size > m_Point2DSize )
p_size = m_Point2DSize;*/
float p_size = (1/scalardiff)*100.0;
if(p_size < 6.0 )
p_size = 6.0 ;
else if ( p_size > 10.0 )
p_size = 10.0;
//draw Point
float opacity = (p_size<8)?0.3:1.0;//don't get the opacity from the node? Feature not a bug! Otehrwise the 2D cross is hardly seen.
glColor4f(unselectedColor[0],unselectedColor[1],unselectedColor[2],opacity);
glPointSize(p_size);
//glShadeModel(GL_FLAT);
glBegin (GL_POINTS);
glVertex2fv(&pt2d[0]);
glEnd ();
}
//for point set
if(!isInputDevice && ( (scalardiff<4.0) || (m_Polygon)))
{
Point2D tmp;
displayGeometry->Map(projected_p, pt2d);
displayGeometry->WorldToDisplay(pt2d, pt2d);
Vector2D horz,vert;
horz[0]=(float)m_Point2DSize-scalardiff*2; horz[1]=0;
vert[0]=0; vert[1]=(float)m_Point2DSize-scalardiff*2;
// now paint text if available
if (dynamic_cast<mitk::StringProperty *>(this->GetDataNode()
->GetProperty("label")) != NULL)
{
const char * pointLabel = dynamic_cast<mitk::StringProperty *>(
this->GetDataNode()->GetProperty("label"))->GetValue();
std::string l = pointLabel;
if (input->GetSize()>1)
{
// char buffer[20];
// sprintf(buffer,"%d",it->Index());
std::stringstream ss;
ss << it->Index();
l.append(ss.str());
}
if (unselectedColor != NULL)
{
mitk::VtkPropRenderer* OpenGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
float rgb[3];//yellow
rgb[0] = unselectedColor[0]; rgb[1] = unselectedColor[1]; rgb[2] = unselectedColor[2];
OpenGLrenderer->WriteSimpleText(l, pt2d[0] + text2dDistance, pt2d[1] + text2dDistance,rgb[0], rgb[1],rgb[2]);
}
else
{
mitk::VtkPropRenderer* OpenGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
OpenGLrenderer->WriteSimpleText(l, pt2d[0] + text2dDistance, pt2d[1] + text2dDistance,0.0,1.0,0.0);
}
}
if((m_ShowPoints) && (scalardiff<4.0))
{
//check if the point is to be marked as selected
if(selIt != selEnd || pointDataBroken)
{
bool addAsSelected = false;
if (pointDataBroken)
addAsSelected = false;
else if (selIt->Value().selected)
addAsSelected = true;
else
addAsSelected = false;
if (addAsSelected)
{
horz[0]=(float)m_Point2DSize;
vert[1]=(float)m_Point2DSize;
glColor3f(selectedColor[0],selectedColor[1],selectedColor[2]);
glLineWidth(m_PointLineWidth);
//a diamond around the point with the selected color
glBegin (GL_LINE_LOOP);
tmp=pt2d-horz; glVertex2fv(&tmp[0]);
tmp=pt2d+vert; glVertex2fv(&tmp[0]);
tmp=pt2d+horz; glVertex2fv(&tmp[0]);
tmp=pt2d-vert; glVertex2fv(&tmp[0]);
glEnd ();
glLineWidth(1);
//the actual point in the specified color to see the usual color of the point
glColor3f(unselectedColor[0],unselectedColor[1],unselectedColor[2]);
glPointSize(1);
glBegin (GL_POINTS);
tmp=pt2d; glVertex2fv(&tmp[0]);
glEnd ();
}
else //if not selected
{
glColor3f(unselectedColor[0],unselectedColor[1],unselectedColor[2]);
glLineWidth(m_PointLineWidth);
//drawing crosses
glBegin (GL_LINES);
tmp=pt2d-horz; glVertex2fv(&tmp[0]);
tmp=pt2d+horz; glVertex2fv(&tmp[0]);
tmp=pt2d-vert; glVertex2fv(&tmp[0]);
tmp=pt2d+vert; glVertex2fv(&tmp[0]);
glEnd ();
glLineWidth(1);
}
}
}
bool drawLinesEtc = true;
if (!m_ShowDistantLines && counter > 0) // check, whether this line should be drawn
{
ScalarType currentDistance = displayGeometry->GetWorldGeometry()->SignedDistance(p);
ScalarType lastDistance = displayGeometry->GetWorldGeometry()->SignedDistance(lastP);
if ( currentDistance * lastDistance > 0.5 ) // points on same side of plane
drawLinesEtc = false;
}
// draw a line
if ((m_Polygon && counter>0 && drawLinesEtc) ||
(m_Polygon && m_PolygonClosed && drawLinesEtc))
{
if ((counter == 0) && ( m_PolygonClosed))
{
lastPt2d = lastPt2DInPointSet;
}
//get contour color property
float contourColor[4] = {unselectedColor[0], unselectedColor[1], unselectedColor[2], unselectedColor[3]};//so if no property set, then use unselected color
if (dynamic_cast<mitk::ColorProperty*>(node->GetPropertyList(renderer)->GetProperty("contourcolor")) != NULL)
{
mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("contourcolor"))->GetValue();
contourColor[0] = tmpColor[0];
contourColor[1] = tmpColor[1];
contourColor[2] = tmpColor[2];
contourColor[3] = 1.0f;
}
else if (dynamic_cast<mitk::ColorProperty*>(node->GetPropertyList(NULL)->GetProperty("contourcolor")) != NULL)
{
mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("contourcolor"))->GetValue();
contourColor[0] = tmpColor[0];
contourColor[1] = tmpColor[1];
contourColor[2] = tmpColor[2];
contourColor[3] = 1.0f;
}
//set this color
glColor3f(contourColor[0],contourColor[1],contourColor[2]);
glLineWidth( m_LineWidth );
glBegin (GL_LINES);
glVertex2fv(&pt2d[0]);
glVertex2fv(&lastPt2d[0]);
glEnd ();
glLineWidth(1.0);
if(m_ShowDistances) // calculate and print a distance
{
std::stringstream buffer;
float distance = vec.GetNorm();
buffer<<std::fixed <<std::setprecision(m_DistancesDecimalDigits)<<distance<<" mm";
Vector2D vec2d = pt2d-lastPt2d;
makePerpendicularVector2D(vec2d, vec2d);
Vector2D pos2d = (lastPt2d.GetVectorFromOrigin()+pt2d)*0.5+vec2d*text2dDistance;
mitk::VtkPropRenderer* OpenGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
OpenGLrenderer->WriteSimpleText(buffer.str(), pos2d[0], pos2d[1]);
//this->WriteTextXY(pos2d[0], pos2d[1], buffer.str(),renderer);
}
if(m_ShowAngles && counter > 1 ) // calculate and print the angle btw. two lines
{
std::stringstream buffer;
//buffer << angle(vec.Get_vnl_vector(), -lastVec.Get_vnl_vector())*180/vnl_math::pi << "�";
buffer << angle(vec.GetVnlVector(), -lastVec.GetVnlVector())*180/vnl_math::pi << (char)176;
Vector2D vec2d = pt2d-lastPt2d;
vec2d.Normalize();
Vector2D lastVec2d = lastPt2d-preLastPt2d;
lastVec2d.Normalize();
vec2d=vec2d-lastVec2d;
vec2d.Normalize();
Vector2D pos2d = lastPt2d.GetVectorFromOrigin()+vec2d*text2dDistance*text2dDistance;
mitk::VtkPropRenderer* OpenGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
OpenGLrenderer->WriteSimpleText(buffer.str(), pos2d[0], pos2d[1]);
//this->WriteTextXY(pos2d[0], pos2d[1], buffer.str(),renderer);
}
}
counter++;
}
++it;
if(selIt != selEnd && !pointDataBroken)
++selIt;
j++;
}
//recall the color to the same color before this drawing
glColor3f(recallColor[0],recallColor[1],recallColor[2]);
}
}
void mitk::PointSetGLMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
{
node->AddProperty( "line width", mitk::IntProperty::New(2), renderer, overwrite ); // width of the line from one point to another
node->AddProperty( "point line width", mitk::IntProperty::New(1), renderer, overwrite ); //width of the cross marking a point
node->AddProperty( "point 2D size", mitk::IntProperty::New(8), renderer, overwrite ); // length of the cross marking a point // length of an edge of the box marking a point
node->AddProperty( "show contour", mitk::BoolProperty::New(false), renderer, overwrite ); // contour of the line between points
node->AddProperty( "close contour", mitk::BoolProperty::New(false), renderer, overwrite );
node->AddProperty( "show points", mitk::BoolProperty::New(true), renderer, overwrite ); //show or hide points
node->AddProperty( "show distances", mitk::BoolProperty::New(false), renderer, overwrite ); //show or hide distance measure (not always available)
node->AddProperty( "distance decimal digits", mitk::IntProperty::New(2), renderer, overwrite ); //set the number of decimal digits to be shown
node->AddProperty( "show angles", mitk::BoolProperty::New(false), renderer, overwrite ); //show or hide angle measurement (not always available)
node->AddProperty( "show distant lines", mitk::BoolProperty::New(false), renderer, overwrite ); //show the line between to points from a distant view (equals "always on top" option)
node->AddProperty( "layer", mitk::IntProperty::New(1), renderer, overwrite ); // default to draw pointset above images (they have a default layer of 0)
Superclass::SetDefaultProperties(node, renderer, overwrite);
}
diff --git a/Core/Code/Rendering/mitkSurfaceGLMapper2D.cpp b/Core/Code/Rendering/mitkSurfaceGLMapper2D.cpp
index 3274cb83d4..8adf9d85ad 100644
--- a/Core/Code/Rendering/mitkSurfaceGLMapper2D.cpp
+++ b/Core/Code/Rendering/mitkSurfaceGLMapper2D.cpp
@@ -1,544 +1,544 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkGL.h>
#include "mitkSurfaceGLMapper2D.h"
#include "mitkBaseRenderer.h"
#include "mitkPlaneGeometry.h"
#include "mitkSurface.h"
#include "mitkColorProperty.h"
#include "mitkProperties.h"
#include "mitkVtkScalarModeProperty.h"
#include "mitkAbstractTransformGeometry.h"
#include "mitkLookupTableProperty.h"
#include <vtkPolyData.h>
#include <vtkPlane.h>
#include <vtkCutter.h>
#include <vtkPoints.h>
#include <vtkCellArray.h>
#include <vtkLookupTable.h>
#include <vtkPointData.h>
#include <vtkCellData.h>
#include <vtkDataArray.h>
#include <vtkLinearTransform.h>
#include <vtkAbstractMapper.h>
#include <vtkPKdTree.h>
#include <vtkStripper.h>
mitk::SurfaceGLMapper2D::SurfaceGLMapper2D()
: m_Plane( vtkPlane::New() ),
m_Cutter( vtkCutter::New() ),
m_LUT( vtkLookupTable::New() ),
m_PointLocator( vtkPKdTree::New() ),
m_Stripper( vtkStripper::New() ),
m_DrawNormals(false),
m_FrontNormalLengthInPixels(10.0),
m_BackNormalLengthInPixels(10.0)
{
// default for normals on front side = green
m_FrontSideColor[0] = 0.0;
m_FrontSideColor[1] = 1.0;
m_FrontSideColor[2] = 0.0;
m_FrontSideColor[3] = 1.0;
// default for normals on back side = red
m_BackSideColor[0] = 1.0;
m_BackSideColor[1] = 0.0;
m_BackSideColor[2] = 0.0;
m_BackSideColor[3] = 1.0;
// default for line color = yellow
m_LineColor[0] = 1.0;
m_LineColor[1] = 1.0;
m_LineColor[2] = 0.0;
m_LineColor[3] = 1.0;
m_Cutter->SetCutFunction(m_Plane);
m_Cutter->GenerateValues(1,0,1);
m_LUT->SetTableRange(0,255);
m_LUT->SetNumberOfColors(255);
m_LUT->SetRampToLinear();
m_LUT->Build();
}
mitk::SurfaceGLMapper2D::~SurfaceGLMapper2D()
{
m_Plane->Delete();
m_Cutter->Delete();
m_LUT->Delete();
m_PointLocator->Delete();
m_Stripper->Delete();
}
const mitk::Surface *mitk::SurfaceGLMapper2D::GetInput(void)
{
if(m_Surface.IsNotNull())
return m_Surface;
return static_cast<const Surface * > ( GetDataNode()->GetData() );
}
void mitk::SurfaceGLMapper2D::SetDataNode( mitk::DataNode* node )
{
Superclass::SetDataNode( node );
bool useCellData;
if (dynamic_cast<BoolProperty *>(node->GetProperty("deprecated useCellDataForColouring")) == NULL)
useCellData = false;
else
useCellData = dynamic_cast<BoolProperty *>(node->GetProperty("deprecated useCellDataForColouring"))->GetValue();
if (!useCellData)
{
// search min/max point scalars over all time steps
vtkFloatingPointType dataRange[2] = {0,0};
vtkFloatingPointType range[2];
Surface::Pointer input = const_cast< Surface* >(dynamic_cast<const Surface*>( this->GetDataNode()->GetData() ));
if(input.IsNull()) return;
const TimeGeometry::Pointer inputTimeGeometry = input->GetTimeGeometry();
- if(( inputTimeGeometry.IsNull() ) || ( inputTimeGeometry->GetNumberOfTimeSteps() == 0 ) ) return;
- for (unsigned int timestep=0; timestep<inputTimeGeometry->GetNumberOfTimeSteps(); timestep++)
+ if(( inputTimeGeometry.IsNull() ) || ( inputTimeGeometry->CountTimeSteps() == 0 ) ) return;
+ for (unsigned int timestep=0; timestep<inputTimeGeometry->CountTimeSteps(); timestep++)
{
vtkPolyData * vtkpolydata = input->GetVtkPolyData( timestep );
if((vtkpolydata==NULL) || (vtkpolydata->GetNumberOfPoints() < 1 )) continue;
vtkDataArray *vpointscalars = vtkpolydata->GetPointData()->GetScalars();
if (vpointscalars) {
vpointscalars->GetRange( range, 0 );
if (dataRange[0]==0 && dataRange[1]==0) {
dataRange[0] = range[0];
dataRange[1] = range[1];
}
else {
if (range[0] < dataRange[0]) dataRange[0] = range[0];
if (range[1] > dataRange[1]) dataRange[1] = range[1];
}
}
}
if (dataRange[1] - dataRange[0] > 0) {
m_LUT->SetTableRange( dataRange );
m_LUT->Build();
}
}
}
void mitk::SurfaceGLMapper2D::Paint(mitk::BaseRenderer * renderer)
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if(!visible) return;
Surface::Pointer input = const_cast<Surface*>(this->GetInput());
if(input.IsNull())
return;
//
// get the TimeGeometry of the input object
//
const TimeGeometry* inputTimeGeometry = input->GetTimeGeometry();
- if(( inputTimeGeometry == NULL ) || ( inputTimeGeometry->GetNumberOfTimeSteps() == 0 ) )
+ if(( inputTimeGeometry == NULL ) || ( inputTimeGeometry->CountTimeSteps() == 0 ) )
return;
if (dynamic_cast<IntProperty *>(this->GetDataNode()->GetProperty("line width")) == NULL)
m_LineWidth = 1;
else
m_LineWidth = dynamic_cast<IntProperty *>(this->GetDataNode()->GetProperty("line width"))->GetValue();
//
// get the world time
//
Geometry2D::ConstPointer worldGeometry = renderer->GetCurrentWorldGeometry2D();
assert( worldGeometry.IsNotNull() );
ScalarType time = worldGeometry->GetTimeBounds()[ 0 ];
int timestep=0;
if( time > ScalarTypeNumericTraits::NonpositiveMin() )
timestep = inputTimeGeometry->TimePointToTimeStep( time );
// int timestep = this->GetTimestep();
if( inputTimeGeometry->IsValidTimeStep( timestep ) == false )
return;
vtkPolyData * vtkpolydata = input->GetVtkPolyData( timestep );
if((vtkpolydata==NULL) || (vtkpolydata->GetNumberOfPoints() < 1 ))
return;
PlaneGeometry::ConstPointer worldPlaneGeometry = dynamic_cast<const PlaneGeometry*>(worldGeometry.GetPointer());
//apply color and opacity read from the PropertyList
this->ApplyAllProperties(renderer);
if (m_DrawNormals)
{
m_PointLocator->SetDataSet( vtkpolydata );
m_PointLocator->BuildLocatorFromPoints( vtkpolydata->GetPoints() );
}
if(vtkpolydata!=NULL)
{
Point3D point;
Vector3D normal;
//Check if Lookup-Table is already given, else use standard one.
vtkFloatingPointType* scalarLimits = m_LUT->GetTableRange();
vtkFloatingPointType scalarsMin = scalarLimits[0], scalarsMax = scalarLimits[1];
vtkLookupTable *lut;// = vtkLookupTable::New();
LookupTableProperty::Pointer lookupTableProp;
this->GetDataNode()->GetProperty(lookupTableProp, "LookupTable", renderer);
if (lookupTableProp.IsNotNull() )
{
lut = lookupTableProp->GetLookupTable()->GetVtkLookupTable();
if (dynamic_cast<FloatProperty *>(this->GetDataNode()->GetProperty("ScalarsRangeMinimum")) != NULL)
scalarsMin = dynamic_cast<FloatProperty*>(this->GetDataNode()->GetProperty("ScalarsRangeMinimum"))->GetValue();
if (dynamic_cast<FloatProperty *>(this->GetDataNode()->GetProperty("ScalarsRangeMaximum")) != NULL)
scalarsMax = dynamic_cast<FloatProperty*>(this->GetDataNode()->GetProperty("ScalarsRangeMaximum"))->GetValue();
// check if the scalar range has been changed, e.g. manually, for the data tree node, and rebuild the LUT if necessary.
double* oldRange = lut->GetTableRange();
if( oldRange[0] != scalarsMin || oldRange[1] != scalarsMax )
{
lut->SetTableRange(scalarsMin, scalarsMax);
lut->Build();
}
}
else
{
lut = m_LUT;
}
vtkLinearTransform * vtktransform = GetDataNode()->GetVtkTransform(timestep);
if(worldPlaneGeometry.IsNotNull())
{
// set up vtkPlane according to worldGeometry
point=worldPlaneGeometry->GetOrigin();
normal=worldPlaneGeometry->GetNormal(); normal.Normalize();
m_Plane->SetTransform((vtkAbstractTransform*)NULL);
}
else
{
AbstractTransformGeometry::ConstPointer worldAbstractGeometry = dynamic_cast<const AbstractTransformGeometry*>(renderer->GetCurrentWorldGeometry2D());
if(worldAbstractGeometry.IsNotNull())
{
AbstractTransformGeometry::ConstPointer surfaceAbstractGeometry = dynamic_cast<const AbstractTransformGeometry*>(input->GetTimeGeometry()->GetGeometryForTimeStep(0).GetPointer());
if(surfaceAbstractGeometry.IsNotNull()) //@todo substitude by operator== after implementation, see bug id 28
{
PaintCells(renderer, vtkpolydata, worldGeometry, renderer->GetDisplayGeometry(), vtktransform, lut);
return;
}
else
{
//@FIXME: does not work correctly. Does m_Plane->SetTransform really transforms a "flat plane" into a "curved plane"?
return;
// set up vtkPlane according to worldGeometry
point=const_cast<BoundingBox*>(worldAbstractGeometry->GetParametricBoundingBox())->GetMinimum();
FillVector3D(normal, 0, 0, 1);
m_Plane->SetTransform(worldAbstractGeometry->GetVtkAbstractTransform()->GetInverse());
}
}
else
return;
}
vtkFloatingPointType vp[3], vnormal[3];
vnl2vtk(point.GetVnlVector(), vp);
vnl2vtk(normal.GetVnlVector(), vnormal);
//normally, we would need to transform the surface and cut the transformed surface with the cutter.
//This might be quite slow. Thus, the idea is, to perform an inverse transform of the plane instead.
//@todo It probably does not work for scaling operations yet:scaling operations have to be
//dealed with after the cut is performed by scaling the contour.
vtkLinearTransform * inversetransform = vtktransform->GetLinearInverse();
inversetransform->TransformPoint(vp, vp);
inversetransform->TransformNormalAtPoint(vp, vnormal, vnormal);
m_Plane->SetOrigin(vp);
m_Plane->SetNormal(vnormal);
//set data into cutter
m_Cutter->SetInput(vtkpolydata);
m_Cutter->Update();
// m_Cutter->GenerateCutScalarsOff();
// m_Cutter->SetSortByToSortByCell();
if (m_DrawNormals)
{
m_Stripper->SetInput( m_Cutter->GetOutput() );
// calculate the cut
m_Stripper->Update();
PaintCells(renderer, m_Stripper->GetOutput(), worldGeometry, renderer->GetDisplayGeometry(), vtktransform, lut, vtkpolydata);
}
else
{
PaintCells(renderer, m_Cutter->GetOutput(), worldGeometry, renderer->GetDisplayGeometry(), vtktransform, lut, vtkpolydata);
}
}
}
void mitk::SurfaceGLMapper2D::PaintCells(mitk::BaseRenderer* renderer, vtkPolyData* contour,
const Geometry2D* worldGeometry,
const DisplayGeometry* displayGeometry,
vtkLinearTransform * vtktransform,
vtkLookupTable *lut,
vtkPolyData* original3DObject)
{
// deprecated settings
bool usePointData = false;
bool useCellData = false;
this->GetDataNode()->GetBoolProperty("deprecated useCellDataForColouring", useCellData);
bool scalarVisibility = false;
this->GetDataNode()->GetBoolProperty("scalar visibility", scalarVisibility);
if(scalarVisibility)
{
VtkScalarModeProperty* scalarMode;
if(this->GetDataNode()->GetProperty(scalarMode, "scalar mode", renderer))
{
if( (scalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_USE_POINT_DATA) ||
(scalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_DEFAULT) )
{
usePointData = true;
}
if(scalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_USE_CELL_DATA)
{
useCellData = true;
}
}
else
{
usePointData = true;
}
}
vtkPoints *vpoints = contour->GetPoints();
vtkDataArray *vpointscalars = contour->GetPointData()->GetScalars();
vtkCellArray *vlines = contour->GetLines();
vtkDataArray* vcellscalars = contour->GetCellData()->GetScalars();
Point3D p; Point2D p2d, last;
int i, j;
int numberOfLines = vlines->GetNumberOfCells();
glLineWidth( m_LineWidth );
glBegin (GL_LINES);
glColor4fv(m_LineColor);
double distanceSinceLastNormal(0.0);
vlines->InitTraversal();
for(i=0;i<numberOfLines;++i)
{
vtkIdType *cell(NULL);
vtkIdType cellSize(0);
vtkFloatingPointType vp[3];
vlines->GetNextCell(cellSize, cell);
vpoints->GetPoint(cell[0], vp);
//take transformation via vtktransform into account
vtktransform->TransformPoint(vp, vp);
vtk2itk(vp, p);
//convert 3D point (in mm) to 2D point on slice (also in mm)
worldGeometry->Map(p, p2d);
//convert point (until now mm and in world coordinates) to display coordinates (units )
displayGeometry->WorldToDisplay(p2d, p2d);
last=p2d;
for(j=1; j<cellSize; ++j)
{
vpoints->GetPoint(cell[j], vp);
Point3D originalPoint;
vtk2itk(vp, originalPoint);
//take transformation via vtktransform into account
vtktransform->TransformPoint(vp, vp);
vtk2itk(vp, p);
//convert 3D point (in mm) to 2D point on slice (also in mm)
worldGeometry->Map(p, p2d);
//convert point (until now mm and in world coordinates) to display coordinates (units )
displayGeometry->WorldToDisplay(p2d, p2d);
vtkFloatingPointType color[3];
if (useCellData && vcellscalars != NULL )
{
// color each cell according to cell data
lut->GetColor( vcellscalars->GetComponent(i,0),color);
glColor3f(color[0],color[1],color[2]);
glVertex2f(last[0], last[1]);
glVertex2f(p2d[0], p2d[1]);
}
else if (usePointData && vpointscalars != NULL )
{
lut->GetColor( vpointscalars->GetComponent(cell[j-1],0),color);
glColor3f(color[0],color[1],color[2]);
glVertex2f(last[0], last[1]);
lut->GetColor( vpointscalars->GetComponent(cell[j],0),color);
glColor3f(color[0],color[1],color[2]);
glVertex2f(p2d[0], p2d[1]);
}
else
{
glVertex2f(last[0], last[1]);
glVertex2f(p2d[0], p2d[1]);
// draw normals ?
if (m_DrawNormals && original3DObject)
{
distanceSinceLastNormal += sqrt((p2d[0]-last[0])*(p2d[0]-last[0]) + (p2d[1]-last[1])*(p2d[1]-last[1]));
if (distanceSinceLastNormal >= 5.0)
{
distanceSinceLastNormal = 0.0;
vtkPointData* pointData = original3DObject->GetPointData();
if (!pointData) break;
vtkDataArray* normalsArray = pointData->GetNormals();
if (!normalsArray) break;
// find 3D point closest to the currently drawn point
double distance(0.0);
vtkIdType closestPointId = m_PointLocator->FindClosestPoint(originalPoint[0], originalPoint[1], originalPoint[2], distance);
if (closestPointId >= 0)
{
// find normal of 3D object at this 3D point
double* normal = normalsArray->GetTuple3(closestPointId);
double transformedNormal[3];
vtktransform->TransformNormal(normal, transformedNormal);
Vector3D normalITK;
vtk2itk(transformedNormal, normalITK);
normalITK.Normalize();
// calculate a point (point from the cut 3D object) + (normal vector of closest point)
Point3D tip3D = p + normalITK;
// map this point into our 2D coordinate system
Point2D tip2D;
worldGeometry->Map(tip3D, tip2D);
displayGeometry->WorldToDisplay(tip2D, tip2D);
// calculate 2D vector from point to point+normal, normalize it to standard length
Vector2D tipVectorGLFront = tip2D - p2d;
tipVectorGLFront.Normalize();
tipVectorGLFront *= m_FrontNormalLengthInPixels;
Vector2D tipVectorGLBack = p2d - tip2D;
tipVectorGLBack.Normalize();
tipVectorGLBack *= m_BackNormalLengthInPixels;
Point2D tipPoint2D = p2d + tipVectorGLFront;
Point2D backTipPoint2D = p2d + tipVectorGLBack;
// draw normalized mapped normal vector
glColor4f(m_BackSideColor[0], m_BackSideColor[1], m_BackSideColor[2], m_BackSideColor[3]); // red backside
glVertex2f(p2d[0], p2d[1]);
glVertex2f(tipPoint2D[0], tipPoint2D[1]);
glColor4f(m_FrontSideColor[0], m_FrontSideColor[1], m_FrontSideColor[2], m_FrontSideColor[3]); // green backside
glVertex2f(p2d[0], p2d[1]);
glVertex2f(backTipPoint2D[0], backTipPoint2D[1]);
glColor4fv(m_LineColor); // back to line color
}
}
}
}
last=p2d;
}
}
glEnd();
glLineWidth(1.0);
}
void mitk::SurfaceGLMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
{
node->AddProperty( "line width", IntProperty::New(2), renderer, overwrite );
node->AddProperty( "scalar mode", VtkScalarModeProperty::New(), renderer, overwrite );
node->AddProperty( "draw normals 2D", BoolProperty::New(false), renderer, overwrite );
node->AddProperty( "invert normals", BoolProperty::New(false), renderer, overwrite );
node->AddProperty( "front color", ColorProperty::New(0.0, 1.0, 0.0), renderer, overwrite );
node->AddProperty( "back color", ColorProperty::New(1.0, 0.0, 0.0), renderer, overwrite );
node->AddProperty( "front normal lenth (px)", FloatProperty::New(10.0), renderer, overwrite );
node->AddProperty( "back normal lenth (px)", FloatProperty::New(10.0), renderer, overwrite );
node->AddProperty( "layer", mitk::IntProperty::New(100), renderer, overwrite);
Superclass::SetDefaultProperties(node, renderer, overwrite);
}
void mitk::SurfaceGLMapper2D::ApplyAllProperties(mitk::BaseRenderer* renderer)
{
ApplyColorAndOpacityProperties(renderer);
DataNode * node = GetDataNode();
if(node == NULL)
{
return;
}
node->GetBoolProperty("draw normals 2D", m_DrawNormals, renderer);
// check for color and opacity properties, use it for rendering if they exists
node->GetColor(m_LineColor, renderer, "color");
node->GetOpacity(m_LineColor[3], renderer, "opacity");
bool invertNormals(false);
node->GetBoolProperty("invert normals", invertNormals, renderer);
if (!invertNormals)
{
node->GetColor(m_FrontSideColor, renderer, "front color");
node->GetOpacity(m_FrontSideColor[3], renderer, "opacity");
node->GetColor(m_BackSideColor, renderer, "back color");
node->GetOpacity(m_BackSideColor[3], renderer, "opacity");
node->GetFloatProperty( "front normal lenth (px)", m_FrontNormalLengthInPixels, renderer );
node->GetFloatProperty( "back normal lenth (px)", m_BackNormalLengthInPixels, renderer );
}
else
{
node->GetColor(m_FrontSideColor, renderer, "back color");
node->GetOpacity(m_FrontSideColor[3], renderer, "opacity");
node->GetColor(m_BackSideColor, renderer, "front color");
node->GetOpacity(m_BackSideColor[3], renderer, "opacity");
node->GetFloatProperty( "back normal lenth (px)", m_FrontNormalLengthInPixels, renderer );
node->GetFloatProperty( "front normal lenth (px)", m_BackNormalLengthInPixels, renderer );
}
}
diff --git a/Core/Code/Testing/mitkBaseDataTest.cpp b/Core/Code/Testing/mitkBaseDataTest.cpp
index ca397a04d2..e305a5e304 100644
--- a/Core/Code/Testing/mitkBaseDataTest.cpp
+++ b/Core/Code/Testing/mitkBaseDataTest.cpp
@@ -1,120 +1,120 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkBaseDataTestImplementation.h"
#include "mitkStringProperty.h"
#include "mitkTestingMacros.h"
#include <mitkTimeGeometry.h>
#include <mitkProportionalTimeGeometry.h>
#include "itkImage.h"
int mitkBaseDataTest(int /*argc*/, char* /*argv*/[])
{
MITK_TEST_BEGIN("BaseData")
//Create a BaseData implementation
MITK_INFO << "Creating a base data instance...";
mitk::BaseDataTestImplementation::Pointer baseDataImpl = mitk::BaseDataTestImplementation::New();
MITK_TEST_CONDITION_REQUIRED(baseDataImpl.IsNotNull(),"Testing instantiation");
MITK_TEST_CONDITION(baseDataImpl->IsInitialized(), "BaseDataTestImplementation is initialized");
MITK_TEST_CONDITION(baseDataImpl->IsEmpty(), "BaseDataTestImplementation is initialized and empty");
mitk::BaseDataTestImplementation::Pointer cloneBaseData = baseDataImpl->Clone();
MITK_TEST_CONDITION_REQUIRED(cloneBaseData.IsNotNull(),"Testing instantiation of base data clone");
MITK_TEST_CONDITION(cloneBaseData->IsInitialized(), "Clone of BaseDataTestImplementation is initialized");
MITK_TEST_CONDITION(cloneBaseData->IsEmpty(), "Clone of BaseDataTestImplementation is initialized and empty");
MITK_INFO << "Testing setter and getter for geometries...";
//test method GetTimeGeometry()
MITK_TEST_CONDITION(baseDataImpl->GetTimeGeometry(), "Testing creation of TimeGeometry");
mitk::TimeGeometry* geo = NULL;
baseDataImpl->SetTimeGeometry(geo);
MITK_TEST_CONDITION(baseDataImpl->GetTimeGeometry() == NULL, "Reset Geometry");
mitk::ProportionalTimeGeometry::Pointer geo2 = mitk::ProportionalTimeGeometry::New();
baseDataImpl->SetTimeGeometry(geo2);
geo2->Initialize(2);
MITK_TEST_CONDITION(baseDataImpl->GetTimeGeometry() == geo2.GetPointer(), "Correct Reinit of TimeGeometry");
//test method GetGeometry(int timeStep)
MITK_TEST_CONDITION(baseDataImpl->GetGeometry(1) != NULL, "... and single Geometries");
//test method Expand(unsigned int timeSteps)
baseDataImpl->Expand(5);
MITK_TEST_CONDITION(baseDataImpl->GetTimeSteps() == 5, "Expand the geometry to further time slices!");
//test method GetUpdatedGeometry(int timeStep);
mitk::Geometry3D::Pointer geo3 = mitk::Geometry3D::New();
mitk::ProportionalTimeGeometry::Pointer timeGeometry = dynamic_cast<mitk::ProportionalTimeGeometry *>(baseDataImpl->GetTimeGeometry());
if (timeGeometry.IsNotNull() )
{
timeGeometry->SetTimeStepGeometry(geo3,1);
}
MITK_TEST_CONDITION(baseDataImpl->GetUpdatedGeometry(1) == geo3, "Set Geometry for time step 1");
MITK_TEST_CONDITION(baseDataImpl->GetMTime()!= 0, "Check if modified time is set");
baseDataImpl->SetClonedGeometry(geo3, 1);
float x[3];
x[0] = 2;
x[1] = 4;
x[2] = 6;
mitk::Point3D p3d(x);
baseDataImpl->SetOrigin(p3d);
geo3->SetOrigin(p3d);
MITK_TEST_CONDITION(baseDataImpl->GetGeometry(1)->GetOrigin() == geo3->GetOrigin(), "Testing Origin set");
cloneBaseData = baseDataImpl->Clone();
MITK_TEST_CONDITION(cloneBaseData->GetGeometry(1)->GetOrigin() == geo3->GetOrigin(), "Testing origin set in clone!");
MITK_TEST_CONDITION(!baseDataImpl->IsEmptyTimeStep(1), "Is not empty before clear()!");
baseDataImpl->Clear();
MITK_TEST_CONDITION(baseDataImpl->IsEmptyTimeStep(1), "...but afterwards!");
//test method Set-/GetProperty()
baseDataImpl->SetProperty("property38", mitk::StringProperty::New("testproperty"));
//baseDataImpl->SetProperty("visibility", mitk::BoolProperty::New());
MITK_TEST_CONDITION(baseDataImpl->GetProperty("property38")->GetValueAsString() == "testproperty","Check if base property is set correctly!");
cloneBaseData = baseDataImpl->Clone();
MITK_TEST_CONDITION(cloneBaseData->GetProperty("property38")->GetValueAsString() == "testproperty", "Testing origin set in clone!");
//test method Set-/GetPropertyList
mitk::PropertyList::Pointer propertyList = mitk::PropertyList::New();
propertyList->SetFloatProperty("floatProperty1", 123.45);
propertyList->SetBoolProperty("visibility",true);
propertyList->SetStringProperty("nameXY","propertyName");
baseDataImpl->SetPropertyList(propertyList);
bool value = false;
MITK_TEST_CONDITION(baseDataImpl->GetPropertyList() == propertyList, "Check if base property list is set correctly!");
MITK_TEST_CONDITION(baseDataImpl->GetPropertyList()->GetBoolProperty("visibility", value) == true, "Check if base property is set correctly in the property list!");
//test method UpdateOutputInformation()
baseDataImpl->UpdateOutputInformation();
MITK_TEST_CONDITION(baseDataImpl->GetUpdatedTimeGeometry() == geo2, "TimeGeometry update!");
//Test method CopyInformation()
mitk::BaseDataTestImplementation::Pointer newBaseData = mitk::BaseDataTestImplementation::New();
newBaseData->CopyInformation(baseDataImpl);
- MITK_TEST_CONDITION_REQUIRED( newBaseData->GetTimeGeometry()->GetNumberOfTimeSteps() == 5, "Check copying of of Basedata Data Object!");
+ MITK_TEST_CONDITION_REQUIRED( newBaseData->GetTimeGeometry()->CountTimeSteps() == 5, "Check copying of of Basedata Data Object!");
MITK_TEST_END()
}
diff --git a/Core/Code/Testing/mitkDataStorageTest.cpp b/Core/Code/Testing/mitkDataStorageTest.cpp
index 88700caa0c..154706710c 100644
--- a/Core/Code/Testing/mitkDataStorageTest.cpp
+++ b/Core/Code/Testing/mitkDataStorageTest.cpp
@@ -1,875 +1,875 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <fstream>
#include <algorithm>
#include "mitkImage.h"
#include "mitkSurface.h"
#include "mitkStringProperty.h"
#include "mitkColorProperty.h"
#include "mitkGroupTagProperty.h"
#include "mitkDataNode.h"
#include "mitkReferenceCountWatcher.h"
#include "mitkDataStorage.h"
#include "mitkStandaloneDataStorage.h"
#include "mitkNodePredicateProperty.h"
#include "mitkNodePredicateDataType.h"
#include "mitkNodePredicateDimension.h"
#include "mitkNodePredicateData.h"
#include "mitkNodePredicateNot.h"
#include "mitkNodePredicateAnd.h"
#include "mitkNodePredicateOr.h"
#include "mitkNodePredicateSource.h"
#include "mitkMessage.h"
//#include "mitkPicFileReader.h"
#include "mitkTestingMacros.h"
#include "mitkItkImageFileReader.h"
void TestDataStorage(mitk::DataStorage* ds, std::string filename);
namespace mitk
{
class TestStandaloneDataStorage: public StandaloneDataStorage
{
public:
mitkClassMacro(TestStandaloneDataStorage, mitk::DataStorage);
itkNewMacro(Self);
std::map<const mitk::DataNode*, unsigned long>
GetModifiedObserverTags() const {return m_NodeModifiedObserverTags;}
std::map<const mitk::DataNode*, unsigned long>
GetDeletedObserverTags() const { return m_NodeDeleteObserverTags; }
protected:
TestStandaloneDataStorage() {}
};
}
class DSEventReceiver // Helper class for event testing
{
public:
const mitk::DataNode* m_NodeAdded;
const mitk::DataNode* m_NodeRemoved;
DSEventReceiver()
: m_NodeAdded(NULL), m_NodeRemoved(NULL)
{
}
void OnAdd(const mitk::DataNode* node)
{
m_NodeAdded = node;
}
void OnRemove(const mitk::DataNode* node)
{
m_NodeRemoved = node;
}
};
///
/// \brief a class for checking if the datastorage is really thread safe
///
/// Therefore it listens to a node contained in the datastorage. when this node
/// gets removed and deleted, this class gets informed by calling OnObjectDelete().
/// in OnObjectDelete() an empty node gets added. this must not cause a deadlock
///
struct ItkDeleteEventListener
{
ItkDeleteEventListener( mitk::DataStorage* ds )
: m_Node(0), m_DataStorage(ds),
m_DeleteObserverTag(0)
{
}
void SetNode( mitk::DataNode* _Node )
{
if(m_Node)
return;
m_Node = _Node;
itk::MemberCommand<ItkDeleteEventListener>::Pointer onObjectDelete =
itk::MemberCommand<ItkDeleteEventListener>::New();
onObjectDelete->SetCallbackFunction(this, &ItkDeleteEventListener::OnObjectDelete);
m_DeleteObserverTag = m_Node->AddObserver(itk::DeleteEvent(), onObjectDelete);
}
void OnObjectDelete( const itk::Object* /*caller*/, const itk::EventObject & )
{
mitk::DataNode::Pointer node = mitk::DataNode::New();
m_DataStorage->Add( node ); // SHOULD NOT CAUSE A DEADLOCK!
m_DataStorage->Remove( node ); // tidy up: remove the empty node again
m_Node = 0;
}
protected:
mitk::DataNode* m_Node;
mitk::DataStorage::Pointer m_DataStorage;
unsigned int m_DeleteObserverTag;
};
//## Documentation
//## main testing method
//## NOTE: the current Singleton implementation of DataTreeStorage will lead to crashes if a testcase fails
//## and therefore mitk::DataStorage::ShutdownSingleton() is not called.
int mitkDataStorageTest(int argc, char* argv[])
{
MITK_TEST_BEGIN("DataStorageTest");
// muellerm: test observer tag remove
mitk::TestStandaloneDataStorage::Pointer testDS
= mitk::TestStandaloneDataStorage::New();
mitk::DataNode::Pointer n1 = mitk::DataNode::New();
testDS->Add(n1);
MITK_TEST_CONDITION_REQUIRED(
testDS->GetModifiedObserverTags().size()==1, "Testing if modified"
" observer was added.");
MITK_TEST_CONDITION_REQUIRED(
testDS->GetDeletedObserverTags().size()==1, "Testing if delete"
" observer was added.");
testDS->Remove(n1);
MITK_TEST_CONDITION_REQUIRED(
testDS->GetModifiedObserverTags().size()==0, "Testing if modified"
" observer was removed.");
MITK_TEST_CONDITION_REQUIRED(
testDS->GetDeletedObserverTags().size()==0, "Testing if delete"
" observer was removed.");
/* Create StandaloneDataStorage */
MITK_TEST_OUTPUT( << "Create StandaloneDataStorage : ");
mitk::StandaloneDataStorage::Pointer sds;
try
{
sds = mitk::StandaloneDataStorage::New();
MITK_TEST_CONDITION_REQUIRED(sds.IsNotNull(), "Testing Instatiation");
}
catch (...)
{
MITK_TEST_FAILED_MSG( << "Exception during creation of StandaloneDataStorage");
}
MITK_TEST_OUTPUT( << "Testing StandaloneDataStorage: ");
MITK_TEST_CONDITION_REQUIRED(argc>1, "Testing correct test invocation");
TestDataStorage(sds,argv[1]);
// TODO: Add specific StandaloneDataStorage Tests here
sds = NULL;
MITK_TEST_END();
}
//##Documentation
//## @brief Test for the DataStorage class and its associated classes (e.g. the predicate classes)
//## This method will be called once for each subclass of DataStorage
void TestDataStorage( mitk::DataStorage* ds, std::string filename )
{
/* DataStorage valid? */
MITK_TEST_CONDITION_REQUIRED(ds != NULL, "DataStorage valid?");
// Take the ItkImageFile Reader for the .nrrd data format.
// (was previously pic which is now deprecated format)
mitk::ItkImageFileReader::Pointer reader = mitk::ItkImageFileReader::New();
reader -> SetFileName(filename.c_str());
reader -> Update();
mitk::Image::Pointer image = reader->GetOutput();
// create some DataNodes to fill the ds
mitk::DataNode::Pointer n1 = mitk::DataNode::New(); // node with image and name property
// mitk::Image::Pointer image = mitk::Image::New();
// unsigned int imageDimensions[] = { 10, 10, 10, 10 };
// mitk::PixelType pt(typeid(int));
// image->Initialize( pt, 4, imageDimensions );
n1->SetData(image);
n1->SetProperty("name", mitk::StringProperty::New("Node 1 - Image Node"));
mitk::DataStorage::SetOfObjects::Pointer parents1 = mitk::DataStorage::SetOfObjects::New();
mitk::DataNode::Pointer n2 = mitk::DataNode::New(); // node with surface and name and color properties
mitk::Surface::Pointer surface = mitk::Surface::New();
n2->SetData(surface);
n2->SetProperty("name", mitk::StringProperty::New("Node 2 - Surface Node"));
mitk::Color color; color.Set(1.0f, 1.0f, 0.0f);
n2->SetColor(color);
n2->SetProperty("Resection Proposal 1", mitk::GroupTagProperty::New());
mitk::DataStorage::SetOfObjects::Pointer parents2 = mitk::DataStorage::SetOfObjects::New();
parents2->InsertElement(0, n1); // n1 (image node) is source of n2 (surface node)
mitk::DataNode::Pointer n3 = mitk::DataNode::New(); // node without data but with name property
n3->SetProperty("name", mitk::StringProperty::New("Node 3 - Empty Node"));
n3->SetProperty("Resection Proposal 1", mitk::GroupTagProperty::New());
n3->SetProperty("Resection Proposal 2", mitk::GroupTagProperty::New());
mitk::DataStorage::SetOfObjects::Pointer parents3 = mitk::DataStorage::SetOfObjects::New();
parents3->InsertElement(0, n2); // n2 is source of n3
mitk::DataNode::Pointer n4 = mitk::DataNode::New(); // node without data but with color property
n4->SetColor(color);
n4->SetProperty("Resection Proposal 2", mitk::GroupTagProperty::New());
mitk::DataStorage::SetOfObjects::Pointer parents4 = mitk::DataStorage::SetOfObjects::New();
parents4->InsertElement(0, n2);
parents4->InsertElement(1, n3); // n2 and n3 are sources of n4
mitk::DataNode::Pointer n5 = mitk::DataNode::New(); // extra node
n5->SetProperty("name", mitk::StringProperty::New("Node 5"));
try /* adding objects */
{
/* Add an object */
ds->Add(n1, parents1);
MITK_TEST_CONDITION_REQUIRED((ds->GetAll()->Size() == 1) && (ds->GetAll()->GetElement(0) == n1), "Testing Adding a new object");
/* Check exception on adding the same object again */
MITK_TEST_OUTPUT( << "Check exception on adding the same object again: ");
MITK_TEST_FOR_EXCEPTION(..., ds->Add(n1, parents1));
MITK_TEST_CONDITION(ds->GetAll()->Size() == 1, "Test if object count is correct after exception");
/* Add an object that has a source object */
ds->Add(n2, parents2);
MITK_TEST_CONDITION_REQUIRED(ds->GetAll()->Size() == 2, "Testing Adding an object that has a source object");
/* Add some more objects needed for further tests */
ds->Add(n3, parents3); // n3 object that has name property and one parent
ds->Add(n4, parents4); // n4 object that has color property
ds->Add(n5); // n5 has no parents
MITK_TEST_CONDITION_REQUIRED(ds->GetAll()->Size() == 5, "Adding some more objects needed for further tests");
}
catch(...)
{
MITK_TEST_FAILED_MSG( << "Exeption during object creation");
}
try /* object retrieval methods */
{
/* Requesting all Objects */
{
const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetAll();
std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
MITK_TEST_CONDITION(
(stlAll.size() == 5) // check if all tree nodes are in resultset
&& (std::find(stlAll.begin(), stlAll.end(), n1) != stlAll.end()) && (std::find(stlAll.begin(), stlAll.end(), n2) != stlAll.end())
&& (std::find(stlAll.begin(), stlAll.end(), n3) != stlAll.end()) && (std::find(stlAll.begin(), stlAll.end(), n4) != stlAll.end())
&& (std::find(stlAll.begin(), stlAll.end(), n5) != stlAll.end()),
"Testing GetAll()"
);
}
/* Requesting a named object */
{
mitk::NodePredicateProperty::Pointer predicate(mitk::NodePredicateProperty::New("name", mitk::StringProperty::New("Node 2 - Surface Node")));
mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSubset(predicate);
MITK_TEST_CONDITION((all->Size() == 1) && (all->GetElement(0) == n2), "Requesting a named object");
}
/* Requesting objects of specific data type */
{
mitk::NodePredicateDataType::Pointer predicate(mitk::NodePredicateDataType::New("Image"));
mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSubset(predicate);
MITK_TEST_CONDITION((all->Size() == 1) && (all->GetElement(0) == n1), "Requesting objects of specific data type")
}
/* Requesting objects of specific dimension */
{
mitk::NodePredicateDimension::Pointer predicate(mitk::NodePredicateDimension::New( 4 ));
mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSubset(predicate);
MITK_TEST_CONDITION((all->Size() == 1) && (all->GetElement(0) == n1), "Requesting objects of specific dimension")
}
/* Requesting objects with specific data object */
{
mitk::NodePredicateData::Pointer predicate(mitk::NodePredicateData::New(image));
mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSubset(predicate);
MITK_TEST_CONDITION((all->Size() == 1) && (all->GetElement(0) == n1), "Requesting objects with specific data object")
}
/* Requesting objects with NULL data */
{
mitk::NodePredicateData::Pointer predicate(mitk::NodePredicateData::New(NULL));
mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSubset(predicate);
MITK_TEST_CONDITION(
(all->Size() == 3)
&& (std::find(all->begin(), all->end(), n3) != all->end())
&& (std::find(all->begin(), all->end(), n4) != all->end())
&& (std::find(all->begin(), all->end(), n5) != all->end())
, "Requesting objects with NULL data");
}
/* Requesting objects that meet a conjunction criteria */
{
mitk::NodePredicateDataType::Pointer p1 = mitk::NodePredicateDataType::New("Surface");
mitk::NodePredicateProperty::Pointer p2 = mitk::NodePredicateProperty::New("color", mitk::ColorProperty::New(color));
mitk::NodePredicateAnd::Pointer predicate = mitk::NodePredicateAnd::New();
predicate->AddPredicate(p1);
predicate->AddPredicate(p2); // objects must be of datatype "Surface" and have red color (= n2)
const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSubset(predicate);
MITK_TEST_CONDITION((all->Size() == 1) && (all->GetElement(0) == n2), "Requesting objects that meet a conjunction criteria");
}
/* Requesting objects that meet a disjunction criteria */
{
mitk::NodePredicateDataType::Pointer p1(mitk::NodePredicateDataType::New("Image"));
mitk::NodePredicateProperty::Pointer p2(mitk::NodePredicateProperty::New("color", mitk::ColorProperty::New(color)));
mitk::NodePredicateOr::Pointer predicate = mitk::NodePredicateOr::New();
predicate->AddPredicate(p1);
predicate->AddPredicate(p2); // objects must be of datatype "Surface" or have red color (= n1, n2, n4)
const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSubset(predicate);
MITK_TEST_CONDITION(
(all->Size() == 3)
&& (std::find(all->begin(), all->end(), n1) != all->end())
&& (std::find(all->begin(), all->end(), n2) != all->end())
&& (std::find(all->begin(), all->end(), n4) != all->end()),
"Requesting objects that meet a disjunction criteria");
}
/* Requesting objects that do not meet a criteria */
{
mitk::ColorProperty::Pointer cp = mitk::ColorProperty::New(color);
mitk::NodePredicateProperty::Pointer proppred(mitk::NodePredicateProperty::New("color", cp));
mitk::NodePredicateNot::Pointer predicate(mitk::NodePredicateNot::New(proppred));
const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSubset(predicate);
std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
MITK_TEST_CONDITION(
(all->Size() == 3) // check if correct objects are in resultset
&& (std::find(stlAll.begin(), stlAll.end(), n1) != stlAll.end())
&& (std::find(stlAll.begin(), stlAll.end(), n3) != stlAll.end())
&& (std::find(stlAll.begin(), stlAll.end(), n5) != stlAll.end()), "Requesting objects that do not meet a criteria");
}
/* Requesting *direct* source objects */
{
const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSources(n3, NULL, true); // Get direct parents of n3 (=n2)
std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
MITK_TEST_CONDITION(
(all->Size() == 1) && (std::find(stlAll.begin(), stlAll.end(), n2) != stlAll.end()),
"Requesting *direct* source objects");
}
/* Requesting *all* source objects */
{
const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSources(n3, NULL, false); // Get all parents of n3 (= n1 + n2)
std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
MITK_TEST_CONDITION(
(all->Size() == 2)
&& (std::find(stlAll.begin(), stlAll.end(), n1) != stlAll.end())
&& (std::find(stlAll.begin(), stlAll.end(), n2) != stlAll.end()),
"Requesting *all* source objects"); // check if n1 and n2 are the resultset
}
/* Requesting *all* sources of object with multiple parents */
{
const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSources(n4, NULL, false); // Get all parents of n4 (= n1 + n2 + n3)
std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
MITK_TEST_CONDITION(
(all->Size() == 3)
&& (std::find(stlAll.begin(), stlAll.end(), n1) != stlAll.end())
&& (std::find(stlAll.begin(), stlAll.end(), n2) != stlAll.end())
&& (std::find(stlAll.begin(), stlAll.end(), n3) != stlAll.end()) // check if n1 and n2 and n3 are the resultset
, "Requesting *all* sources of object with multiple parents");
}
/* Requesting *direct* derived objects */
{
const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetDerivations(n1, NULL, true); // Get direct childs of n1 (=n2)
std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
MITK_TEST_CONDITION(
(all->Size() == 1)
&& (std::find(stlAll.begin(), stlAll.end(), n2) != stlAll.end())// check if n1 is the resultset
, "Requesting *direct* derived objects");
}
///* Requesting *direct* derived objects with multiple parents/derivations */
{
const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetDerivations(n2, NULL, true); // Get direct childs of n2 (=n3 + n4)
std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
MITK_TEST_CONDITION(
(all->Size() == 2)
&& (std::find(stlAll.begin(), stlAll.end(), n3) != stlAll.end()) // check if n3 is the resultset
&& (std::find(stlAll.begin(), stlAll.end(), n4) != stlAll.end()) // check if n4 is the resultset
, "Requesting *direct* derived objects with multiple parents/derivations");
}
//* Requesting *all* derived objects */
{
const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetDerivations(n1, NULL, false); // Get all childs of n1 (=n2, n3, n4)
std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
MITK_TEST_CONDITION(
(all->Size() == 3)
&& (std::find(stlAll.begin(), stlAll.end(), n2) != stlAll.end())
&& (std::find(stlAll.begin(), stlAll.end(), n3) != stlAll.end())
&& (std::find(stlAll.begin(), stlAll.end(), n4) != stlAll.end())
, "Requesting *all* derived objects");
}
/* Checking for circular source relationships */
{
parents1->InsertElement(0, n4); // make n1 derived from n4 (which is derived from n2, which is derived from n1)
const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSources(n4, NULL, false); // Get all parents of n4 (= n1 + n2 + n3, not n4 itself and not multiple versions of the nodes!)
std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
MITK_TEST_CONDITION(
(all->Size() == 3)
&& (std::find(stlAll.begin(), stlAll.end(), n1) != stlAll.end())
&& (std::find(stlAll.begin(), stlAll.end(), n2) != stlAll.end())
&& (std::find(stlAll.begin(), stlAll.end(), n3) != stlAll.end()) // check if n1 and n2 and n3 are the resultset
, "Checking for circular source relationships");
}
///* Checking for circular derivation relationships can not be performed, because the internal derivations datastructure
// can not be accessed from the outside. (Therefore it should not be possible to create these circular relations */
//* Checking GroupTagProperty */
{
mitk::GroupTagProperty::Pointer tp = mitk::GroupTagProperty::New();
mitk::NodePredicateProperty::Pointer pred(mitk::NodePredicateProperty::New("Resection Proposal 1", tp));
const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSubset(pred);
std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
MITK_TEST_CONDITION(
(all->Size() == 2) // check if n2 and n3 are in resultset
&& (std::find(stlAll.begin(), stlAll.end(), n2) != stlAll.end())
&& (std::find(stlAll.begin(), stlAll.end(), n3) != stlAll.end())
, "Checking GroupTagProperty");
}
/* Checking GroupTagProperty 2 */
{
mitk::GroupTagProperty::Pointer tp = mitk::GroupTagProperty::New();
mitk::NodePredicateProperty::Pointer pred(mitk::NodePredicateProperty::New("Resection Proposal 2", tp));
const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSubset(pred);
std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
MITK_TEST_CONDITION(
(all->Size() == 2) // check if n3 and n4 are in resultset
&& (std::find(stlAll.begin(), stlAll.end(), n3) != stlAll.end())
&& (std::find(stlAll.begin(), stlAll.end(), n4) != stlAll.end())
, "Checking GroupTagProperty 2");
}
/* Checking direct sources with condition */
{
mitk::NodePredicateDataType::Pointer pred = mitk::NodePredicateDataType::New("Surface");
const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSources(n4, pred, true);
std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
MITK_TEST_CONDITION(
(all->Size() == 1) // check if n2 is in resultset
&& (std::find(stlAll.begin(), stlAll.end(), n2) != stlAll.end())
, "checking direct sources with condition");
}
/* Checking all sources with condition */
{
mitk::NodePredicateDataType::Pointer pred = mitk::NodePredicateDataType::New("Image");
const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSources(n4, pred, false);
std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
MITK_TEST_CONDITION(
(all->Size() == 1) // check if n1 is in resultset
&& (std::find(stlAll.begin(), stlAll.end(), n1) != stlAll.end())
, "Checking all sources with condition");
}
/* Checking all sources with condition with empty resultset */
{
mitk::NodePredicateDataType::Pointer pred = mitk::NodePredicateDataType::New("VesselTree");
const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetSources(n4, pred, false);
MITK_TEST_CONDITION(all->Size() == 0 , "Checking all sources with condition with empty resultset"); // check if resultset is empty
}
/* Checking direct derivations with condition */
{
mitk::NodePredicateProperty::Pointer pred = mitk::NodePredicateProperty::New("color");
const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetDerivations(n1, pred, true);
std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
MITK_TEST_CONDITION(
(all->Size() == 1) // check if n2 is in resultset
&& (std::find(stlAll.begin(), stlAll.end(), n2) != stlAll.end())
, "Checking direct derivations with condition");
}
/* Checking all derivations with condition */
{
mitk::NodePredicateProperty::Pointer pred = mitk::NodePredicateProperty::New("color");
const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetDerivations(n1, pred, false);
std::vector<mitk::DataNode::Pointer> stlAll = all->CastToSTLConstContainer();
MITK_TEST_CONDITION(
(all->Size() == 2) // check if n2 and n4 are in resultset
&& (std::find(stlAll.begin(), stlAll.end(), n2) != stlAll.end())
&& (std::find(stlAll.begin(), stlAll.end(), n4) != stlAll.end())
, "Checking direct derivations with condition");
}
/* Checking named node method */
MITK_TEST_CONDITION(ds->GetNamedNode("Node 2 - Surface Node") == n2, "Checking named node method");
MITK_TEST_CONDITION(ds->GetNamedNode(std::string("Node 2 - Surface Node")) == n2, "Checking named node(std::string) method");
/* Checking named node method with wrong name */
MITK_TEST_CONDITION(ds->GetNamedNode("This name does not exist") == NULL, "Checking named node method with wrong name");
/* Checking named object method */
MITK_TEST_CONDITION(ds->GetNamedObject<mitk::Image>("Node 1 - Image Node") == image, "Checking named object method");
MITK_TEST_CONDITION(ds->GetNamedObject<mitk::Image>(std::string("Node 1 - Image Node")) == image, "Checking named object(std::string) method");
/* Checking named object method with wrong DataType */
MITK_TEST_CONDITION(ds->GetNamedObject<mitk::Surface>("Node 1 - Image Node") == NULL, "Checking named object method with wrong DataType");
/* Checking named object method with wrong name */
MITK_TEST_CONDITION(ds->GetNamedObject<mitk::Image>("This name does not exist") == NULL, "Checking named object method with wrong name");
/* Checking GetNamedDerivedNode with valid name and direct derivation only */
MITK_TEST_CONDITION(ds->GetNamedDerivedNode("Node 2 - Surface Node", n1, true) == n2, "Checking GetNamedDerivedNode with valid name & direct derivation only");
/* Checking GetNamedDerivedNode with invalid Name and direct derivation only */
MITK_TEST_CONDITION(ds->GetNamedDerivedNode("wrong name", n1, true) == NULL, "Checking GetNamedDerivedNode with invalid name & direct derivation only");
/* Checking GetNamedDerivedNode with invalid Name and direct derivation only */
MITK_TEST_CONDITION(ds->GetNamedDerivedNode("Node 3 - Empty Node", n1, false) == n3, "Checking GetNamedDerivedNode with invalid name & direct derivation only");
/* Checking GetNamedDerivedNode with valid Name but direct derivation only */
MITK_TEST_CONDITION(ds->GetNamedDerivedNode("Node 3 - Empty Node", n1, true) == NULL, "Checking GetNamedDerivedNode with valid Name but direct derivation only");
/* Checking GetNode with valid predicate */
{
mitk::NodePredicateDataType::Pointer p(mitk::NodePredicateDataType::New("Image"));
MITK_TEST_CONDITION(ds->GetNode(p) == n1, "Checking GetNode with valid predicate");
}
/* Checking GetNode with invalid predicate */
{
mitk::NodePredicateDataType::Pointer p(mitk::NodePredicateDataType::New("PointSet"));
MITK_TEST_CONDITION(ds->GetNode(p) == NULL, "Checking GetNode with invalid predicate");
}
} // object retrieval methods
catch(...)
{
MITK_TEST_FAILED_MSG( << "Exeption during object retrieval (GetXXX() Methods)");
}
try /* object removal methods */
{
/* Checking removal of a node without relations */
{
mitk::DataNode::Pointer extra = mitk::DataNode::New();
extra->SetProperty("name", mitk::StringProperty::New("extra"));
mitk::ReferenceCountWatcher::Pointer watcher = new mitk::ReferenceCountWatcher(extra);
int refCountbeforeDS = watcher->GetReferenceCount();
ds->Add(extra);
MITK_TEST_CONDITION(ds->GetNamedNode("extra") == extra, "Adding extra node");
ds->Remove(extra);
MITK_TEST_CONDITION(
(ds->GetNamedNode("extra") == NULL)
&& (refCountbeforeDS == watcher->GetReferenceCount())
, "Checking removal of a node without relations");
extra = NULL;
}
/* Checking removal of a node with a parent */
{
mitk::DataNode::Pointer extra = mitk::DataNode::New();
extra->SetProperty("name", mitk::StringProperty::New("extra"));
mitk::ReferenceCountWatcher::Pointer watcher = new mitk::ReferenceCountWatcher(extra);
int refCountbeforeDS = watcher->GetReferenceCount();
ds->Add(extra, n1); // n1 is parent of extra
MITK_TEST_CONDITION(
(ds->GetNamedNode("extra") == extra)
&& (ds->GetDerivations(n1)->Size() == 2) // n2 and extra should be derived from n1
, "Adding extra node");
ds->Remove(extra);
MITK_TEST_CONDITION(
(ds->GetNamedNode("extra") == NULL)
&& (refCountbeforeDS == watcher->GetReferenceCount())
&& (ds->GetDerivations(n1)->Size() == 1)
, "Checking removal of a node with a parent");
extra = NULL;
}
/* Checking removal of a node with two parents */
{
mitk::DataNode::Pointer extra = mitk::DataNode::New();
extra->SetProperty("name", mitk::StringProperty::New("extra"));
mitk::ReferenceCountWatcher::Pointer watcher = new mitk::ReferenceCountWatcher(extra);
int refCountbeforeDS = watcher->GetReferenceCount();
mitk::DataStorage::SetOfObjects::Pointer p = mitk::DataStorage::SetOfObjects::New();
p->push_back(n1);
p->push_back(n2);
ds->Add(extra, p); // n1 and n2 are parents of extra
MITK_TEST_CONDITION(
(ds->GetNamedNode("extra") == extra)
&& (ds->GetDerivations(n1)->Size() == 2) // n2 and extra should be derived from n1
&& (ds->GetDerivations(n2)->Size() == 3)
, "add extra node");
ds->Remove(extra);
MITK_TEST_CONDITION(
(ds->GetNamedNode("extra") == NULL)
&& (refCountbeforeDS == watcher->GetReferenceCount())
&& (ds->GetDerivations(n1)->Size() == 1) // after remove, only n2 should be derived from n1
&& (ds->GetDerivations(n2)->Size() == 2) // after remove, only n3 and n4 should be derived from n2
, "Checking removal of a node with two parents");
extra = NULL;
}
/* Checking removal of a node with two derived nodes */
{
mitk::DataNode::Pointer extra = mitk::DataNode::New();
extra->SetProperty("name", mitk::StringProperty::New("extra"));
mitk::ReferenceCountWatcher::Pointer watcher = new mitk::ReferenceCountWatcher(extra);
int refCountbeforeDS = watcher->GetReferenceCount();
ds->Add(extra);
mitk::DataNode::Pointer d1 = mitk::DataNode::New();
d1->SetProperty("name", mitk::StringProperty::New("d1"));
ds->Add(d1, extra);
mitk::DataNode::Pointer d2 = mitk::DataNode::New();
d2->SetProperty("name", mitk::StringProperty::New("d2"));
ds->Add(d2, extra);
MITK_TEST_CONDITION(
(ds->GetNamedNode("extra") == extra)
&& (ds->GetNamedNode("d1") == d1)
&& (ds->GetNamedNode("d2") == d2)
&& (ds->GetSources(d1)->Size() == 1) // extra should be source of d1
&& (ds->GetSources(d2)->Size() == 1) // extra should be source of d2
&& (ds->GetDerivations(extra)->Size() == 2) // d1 and d2 should be derived from extra
, "add extra node");
ds->Remove(extra);
MITK_TEST_CONDITION(
(ds->GetNamedNode("extra") == NULL)
&& (ds->GetNamedNode("d1") == d1)
&& (ds->GetNamedNode("d2") == d2)
&& (refCountbeforeDS == watcher->GetReferenceCount())
&& (ds->GetSources(d1)->Size() == 0) // after remove, d1 should not have a source anymore
&& (ds->GetSources(d2)->Size() == 0) // after remove, d2 should not have a source anymore
, "Checking removal of a node with two derived nodes");
extra = NULL;
}
/* Checking removal of a node with two parents and two derived nodes */
{
mitk::DataNode::Pointer extra = mitk::DataNode::New();
extra->SetProperty("name", mitk::StringProperty::New("extra"));
mitk::ReferenceCountWatcher::Pointer watcher = new mitk::ReferenceCountWatcher(extra);
mitk::ReferenceCountWatcher::Pointer n1watcher = new mitk::ReferenceCountWatcher(n1);
int refCountbeforeDS = watcher->GetReferenceCount();
mitk::DataStorage::SetOfObjects::Pointer p = mitk::DataStorage::SetOfObjects::New();
p->push_back(n1);
p->push_back(n2);
ds->Add(extra, p); // n1 and n2 are parents of extra
mitk::DataNode::Pointer d1 = mitk::DataNode::New();
d1->SetProperty("name", mitk::StringProperty::New("d1x"));
ds->Add(d1, extra);
mitk::DataNode::Pointer d2 = mitk::DataNode::New();
d2->SetProperty("name", mitk::StringProperty::New("d2x"));
ds->Add(d2, extra);
MITK_TEST_CONDITION(
(ds->GetNamedNode("extra") == extra)
&& (ds->GetNamedNode("d1x") == d1)
&& (ds->GetNamedNode("d2x") == d2)
&& (ds->GetSources(d1)->Size() == 1) // extra should be source of d1
&& (ds->GetSources(d2)->Size() == 1) // extra should be source of d2
&& (ds->GetDerivations(n1)->Size() == 2) // n2 and extra should be derived from n1
&& (ds->GetDerivations(n2)->Size() == 3) // n3, n4 and extra should be derived from n2
&& (ds->GetDerivations(extra)->Size() == 2) // d1 and d2 should be derived from extra
, "add extra node");
ds->Remove(extra);
MITK_TEST_CONDITION(
(ds->GetNamedNode("extra") == NULL)
&& (ds->GetNamedNode("d1x") == d1)
&& (ds->GetNamedNode("d2x") == d2)
&& (refCountbeforeDS == watcher->GetReferenceCount())
&& (ds->GetDerivations(n1)->Size() == 1) // after remove, only n2 should be derived from n1
&& (ds->GetDerivations(n2)->Size() == 2) // after remove, only n3 and n4 should be derived from n2
&& (ds->GetSources(d1)->Size() == 0) // after remove, d1 should not have a source anymore
&& (ds->GetSources(d2)->Size() == 0) // after remove, d2 should not have a source anymore
, "Checking removal of a node with two parents and two derived nodes");
extra = NULL;
}
}
catch(...)
{
MITK_TEST_FAILED_MSG( << "Exeption during object removal methods");
}
/* Checking for node is it's own parent exception */
{
MITK_TEST_FOR_EXCEPTION_BEGIN(...);
mitk::DataNode::Pointer extra = mitk::DataNode::New();
extra->SetProperty("name", mitk::StringProperty::New("extra"));
mitk::DataStorage::SetOfObjects::Pointer p = mitk::DataStorage::SetOfObjects::New();
p->push_back(n1);
p->push_back(extra); // extra is parent of extra!!!
ds->Add(extra, p);
MITK_TEST_FOR_EXCEPTION_END(...);
}
/* Checking reference count of node after add and remove */
{
mitk::DataNode::Pointer extra = mitk::DataNode::New();
mitk::ReferenceCountWatcher::Pointer watcher = new mitk::ReferenceCountWatcher(extra);
extra->SetProperty("name", mitk::StringProperty::New("extra"));
mitk::DataStorage::SetOfObjects::Pointer p = mitk::DataStorage::SetOfObjects::New();
p->push_back(n1);
p->push_back(n3);
ds->Add(extra, p);
extra = NULL;
ds->Remove(ds->GetNamedNode("extra"));
MITK_TEST_CONDITION(watcher->GetReferenceCount() == 0, "Checking reference count of node after add and remove");
}
/* Checking removal of a node with two derived nodes [ dataStorage->GetDerivations( rootNode )] see bug #3426 */
{
mitk::DataNode::Pointer extra = mitk::DataNode::New();
extra->SetProperty("name", mitk::StringProperty::New("extra"));
ds->Add(extra);
mitk::DataNode::Pointer d1y = mitk::DataNode::New();
d1y->SetProperty("name", mitk::StringProperty::New("d1y"));
mitk::ReferenceCountWatcher::Pointer watcherD1y = new mitk::ReferenceCountWatcher(d1y);
int refCountbeforeDS = watcherD1y->GetReferenceCount();
ds->Add(d1y, extra);
mitk::DataNode::Pointer d2y = mitk::DataNode::New();
d2y->SetProperty("name", mitk::StringProperty::New("d2y"));
ds->Add(d2y, extra);
MITK_TEST_CONDITION(
(ds->GetNamedNode("extra") == extra)
&& (ds->GetNamedNode("d1y") == d1y)
&& (ds->GetNamedNode("d2y") == d2y)
&& (ds->GetSources(d1y)->Size() == 1) // extra should be source of d1y
&& (ds->GetSources(d2y)->Size() == 1) // extra should be source of d2y
&& (ds->GetDerivations(extra)->Size() == 2) // d1y and d2y should be derived from extra
, "add extra node");
ds->Remove(ds->GetDerivations( extra));
MITK_TEST_CONDITION(
(ds->GetNamedNode("extra") == extra)
&& (ds->GetNamedNode("d1y") == NULL) // d1y should be NULL now
&& (ds->GetNamedNode("d2y") == NULL) // d2y should be NULL now
&& (refCountbeforeDS == watcherD1y->GetReferenceCount())
, "Checking removal of subset of two derived nodes from one parent node");
ds->Remove(extra);
MITK_TEST_CONDITION(
(ds->GetNamedNode("extra") == NULL)
, "Checking removal of a parent node");
extra = NULL;
}
/* Checking GetGrouptags() */
{
const std::set<std::string> groupTags = ds->GetGroupTags();
MITK_TEST_CONDITION(
(groupTags.size() == 2)
&& (std::find(groupTags.begin(), groupTags.end(), "Resection Proposal 1") != groupTags.end())
&& (std::find(groupTags.begin(), groupTags.end(), "Resection Proposal 2") != groupTags.end())
, "Checking GetGrouptags()");
}
/* Checking Event handling */
DSEventReceiver listener;
try
{
ds->AddNodeEvent += mitk::MessageDelegate1<DSEventReceiver, const mitk::DataNode*>(&listener, &DSEventReceiver::OnAdd);
ds->RemoveNodeEvent += mitk::MessageDelegate1<DSEventReceiver, const mitk::DataNode*>(&listener, &DSEventReceiver::OnRemove);
mitk::DataNode::Pointer extra = mitk::DataNode::New();
mitk::ReferenceCountWatcher::Pointer watcher = new mitk::ReferenceCountWatcher(extra);
ds->Add(extra);
MITK_TEST_CONDITION(listener.m_NodeAdded == extra.GetPointer(), "Checking AddEvent");
ds->Remove(extra);
MITK_TEST_CONDITION(listener.m_NodeRemoved == extra.GetPointer(), "Checking RemoveEvent");
/* RemoveListener */
ds->AddNodeEvent -= mitk::MessageDelegate1<DSEventReceiver, const mitk::DataNode*>(&listener, &DSEventReceiver::OnAdd);
ds->RemoveNodeEvent -= mitk::MessageDelegate1<DSEventReceiver, const mitk::DataNode*>(&listener, &DSEventReceiver::OnRemove);
listener.m_NodeAdded = NULL;
listener.m_NodeRemoved = NULL;
ds->Add(extra);
ds->Remove(extra);
MITK_TEST_CONDITION((listener.m_NodeRemoved == NULL) && (listener.m_NodeAdded == NULL), "Checking RemoveListener");
std::cout << "Pointer handling after event handling: " << std::flush;
extra = NULL; // delete reference to the node. its memory should be freed now
MITK_TEST_CONDITION(watcher->GetReferenceCount() == 0, "Pointer handling after event handling");
}
catch(...)
{
/* cleanup */
ds->AddNodeEvent -= mitk::MessageDelegate1<DSEventReceiver, const mitk::DataNode*>(&listener, &DSEventReceiver::OnAdd);
ds->RemoveNodeEvent -= mitk::MessageDelegate1<DSEventReceiver, const mitk::DataNode*>(&listener, &DSEventReceiver::OnRemove);
MITK_TEST_FAILED_MSG( << "Exception during object removal methods");
}
//Checking ComputeBoundingGeometry3D method*/
const mitk::DataStorage::SetOfObjects::ConstPointer all = ds->GetAll();
mitk::TimeGeometry::Pointer geometry = ds->ComputeBoundingGeometry3D();
- MITK_TEST_CONDITION(geometry->GetNumberOfTimeSteps()==4, "Test for number or time steps with ComputeBoundingGeometry()");
+ MITK_TEST_CONDITION(geometry->CountTimeSteps()==4, "Test for number or time steps with ComputeBoundingGeometry()");
mitk::TimeBounds timebounds = geometry->GetTimeBounds();
MITK_TEST_CONDITION((timebounds[0]==0)&&(timebounds[1]==4),"Test for timebounds with ComputeBoundingGeometry()");
- for (unsigned int i=0; i<geometry->GetNumberOfTimeSteps(); i++)
+ for (unsigned int i=0; i<geometry->CountTimeSteps(); i++)
{
mitk::Geometry3D::Pointer subGeometry = geometry->GetGeometryForTimeStep(i);
mitk::TimeBounds bounds = subGeometry->GetTimeBounds();
MITK_TEST_CONDITION((bounds[0]==i)&&(bounds[1]==i+1),"Test for timebounds of geometry at different time steps with ComputeBoundingGeometry()");
}
geometry = ds->ComputeBoundingGeometry3D(all);
- MITK_TEST_CONDITION(geometry->GetNumberOfTimeSteps()==4, "Test for number or time steps with ComputeBoundingGeometry(allNodes)");
+ MITK_TEST_CONDITION(geometry->CountTimeSteps()==4, "Test for number or time steps with ComputeBoundingGeometry(allNodes)");
timebounds = geometry->GetTimeBounds();
MITK_TEST_CONDITION((timebounds[0]==0)&&(timebounds[1]==4),"Test for timebounds with ComputeBoundingGeometry(allNodes)");
- for (unsigned int i=0; i<geometry->GetNumberOfTimeSteps(); i++)
+ for (unsigned int i=0; i<geometry->CountTimeSteps(); i++)
{
mitk::Geometry3D::Pointer subGeometry = geometry->GetGeometryForTimeStep(i);
mitk::TimeBounds bounds = subGeometry->GetTimeBounds();
MITK_TEST_CONDITION((bounds[0]==i)&&(bounds[1]==i+1),"Test for timebounds of geometry at different time steps with ComputeBoundingGeometry()");
}
// test for thread safety of DataStorage
try
{
mitk::StandaloneDataStorage::Pointer standaloneDataStorage
= mitk::StandaloneDataStorage::New();
ItkDeleteEventListener listener( standaloneDataStorage );
{
mitk::DataNode::Pointer emptyNode = mitk::DataNode::New();
mitk::DataNode* pEmptyNode = emptyNode;
listener.SetNode( emptyNode );
standaloneDataStorage->Add( emptyNode );
emptyNode = 0; // emptyNode is still alive because standaloneDataStorage
// owns it
standaloneDataStorage->Remove( pEmptyNode ); // this should not freeze the whole thing
}
}
catch(...)
{
MITK_TEST_FAILED_MSG( << "Exception during testing DataStorage thread safe");
}
/* Clear DataStorage */
ds->Remove(ds->GetAll());
MITK_TEST_CONDITION(ds->GetAll()->Size() == 0, "Checking Clear DataStorage");
}
diff --git a/Core/Code/Testing/mitkTimeGeometryTest.cpp b/Core/Code/Testing/mitkTimeGeometryTest.cpp
index e32602f1ac..0460507afc 100644
--- a/Core/Code/Testing/mitkTimeGeometryTest.cpp
+++ b/Core/Code/Testing/mitkTimeGeometryTest.cpp
@@ -1,774 +1,774 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkTimeGeometry.h"
#include "mitkGeometry3D.h"
#include "mitkRotationOperation.h"
#include "mitkInteractionConst.h"
#include <mitkMatrixConvert.h>
#include <mitkImageCast.h>
#include "mitkTestingMacros.h"
#include <fstream>
#include <mitkVector.h>
#include <mitkStandaloneDataStorage.h>
#include "mitkImageGenerator.h"
#include "mitkPointSet.h"
#include <limits>
class mitkTimeGeometryTestClass
{
public:
void Translation_Image_MovedOrigin(unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
{
// DimX, DimY, DimZ,
mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(DimX, DimY, DimZ, DimT,0.5,0.33,0.78,100);
mitk::Geometry3D::Pointer geometry = image->GetTimeGeometry()->GetGeometryForTimeStep(0);
mitk::Point3D imageOrigin = geometry->GetOrigin();
mitk::Point3D expectedOrigin;
expectedOrigin[0] = 0;
expectedOrigin[1] = 0;
expectedOrigin[2] = 0;
MITK_TEST_CONDITION(mitk::Equal(imageOrigin, expectedOrigin), "Original origin match expected origin");
expectedOrigin[0] = 0.325;
expectedOrigin[1] = 0.487;
expectedOrigin[2] = 0.78;
mitk::Vector3D translationVector;
translationVector[0] = expectedOrigin[0];
translationVector[1] = expectedOrigin[1];
translationVector[2] = expectedOrigin[2];
- for (mitk::TimeStepType timeStep = 0; timeStep < image->GetTimeGeometry()->GetNumberOfTimeSteps(); ++timeStep)
+ for (mitk::TimeStepType timeStep = 0; timeStep < image->GetTimeGeometry()->CountTimeSteps(); ++timeStep)
{
image->GetTimeGeometry()->GetGeometryForTimeStep(timeStep)->Translate(translationVector);
}
imageOrigin = image->GetGeometry(0)->GetOrigin();
MITK_TEST_CONDITION(mitk::Equal(imageOrigin, expectedOrigin), "Translated origin match expected origin");
expectedOrigin[0] = 2*translationVector[0];
expectedOrigin[1] = 2*translationVector[1];
expectedOrigin[2] = 2*translationVector[2];
- for (mitk::TimeStepType timeStep = 0; timeStep < image->GetTimeGeometry()->GetNumberOfTimeSteps(); ++timeStep)
+ for (mitk::TimeStepType timeStep = 0; timeStep < image->GetTimeGeometry()->CountTimeSteps(); ++timeStep)
{
image->GetTimeGeometry()->GetGeometryForTimeStep(timeStep)->Translate(translationVector);
}
imageOrigin = image->GetGeometry(0)->GetOrigin();
MITK_TEST_CONDITION(mitk::Equal(imageOrigin, expectedOrigin), "Translated origin match expected origin");
}
void Rotate_Image_RotatedPoint(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
{
mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
mitk::DataNode::Pointer dataNode = mitk::DataNode::New();
// DimX, DimY, DimZ,
dataNode->SetData(baseData);
ds->Add(dataNode);
mitk::Geometry3D::Pointer geometry = baseData->GetTimeGeometry()->GetGeometryForTimeStep(0);
mitk::Point3D expectedPoint;
expectedPoint[0] = 3*0.5;
expectedPoint[1] = 3*0.33;
expectedPoint[2] = 3*0.78;
mitk::Point3D originalPoint;
originalPoint[0] = 3;
originalPoint[1] = 3;
originalPoint[2] = 3;
mitk::Point3D worldPoint;
geometry->IndexToWorld(originalPoint, worldPoint);
MITK_TEST_CONDITION(mitk::Equal(worldPoint, expectedPoint), "Index-to-World without rotation as expected ");
mitk::Point3D pointOfRotation;
pointOfRotation[0] = 0;
pointOfRotation[1] = 0;
pointOfRotation[2] = 0;
mitk::Vector3D vectorOfRotation;
vectorOfRotation[0] = 1;
vectorOfRotation[1] = 0.5;
vectorOfRotation[2] = 0.2;
float angleOfRotation = 73.0;
mitk::RotationOperation* rotation = new mitk::RotationOperation(mitk::OpROTATE,pointOfRotation, vectorOfRotation, angleOfRotation);
baseData->GetTimeGeometry()->ExecuteOperation(rotation);
delete rotation;
expectedPoint[0] = 2.6080379;
expectedPoint[1] = -0.75265157;
expectedPoint[2] = 1.1564401;
baseData->GetGeometry(0)->IndexToWorld(originalPoint,worldPoint);
MITK_TEST_CONDITION(mitk::Equal(worldPoint, expectedPoint), "Rotation returns expected values ");
}
void Scale_Image_ScaledPoint(unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
{
// DimX, DimY, DimZ,
mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(DimX, DimY, DimZ, DimT,0.5,0.33,0.78,100);
mitk::Geometry3D::Pointer geometry = image->GetTimeGeometry()->GetGeometryForTimeStep(0);
mitk::Point3D expectedPoint;
expectedPoint[0] = 3*0.5;
expectedPoint[1] = 3*0.33;
expectedPoint[2] = 3*0.78;
mitk::Point3D originalPoint;
originalPoint[0] = 3;
originalPoint[1] = 3;
originalPoint[2] = 3;
mitk::Point3D worldPoint;
geometry->IndexToWorld(originalPoint, worldPoint);
MITK_TEST_CONDITION(mitk::Equal(worldPoint, expectedPoint), "Index-to-World with old Scaling as expected ");
mitk::Vector3D newSpacing;
newSpacing[0] = 2;
newSpacing[1] = 1.254;
newSpacing[2] = 0.224;
image->SetSpacing(newSpacing);
mitk::BaseData* base;
expectedPoint[0] = 3*2;
expectedPoint[1] = 3*1.254;
expectedPoint[2] = 3*0.224;
image->GetGeometry(0)->IndexToWorld(originalPoint,worldPoint);
MITK_TEST_CONDITION(mitk::Equal(worldPoint, expectedPoint), "Index-toWorld with new Scaling returns expected values ");
}
void GetMinimumTimePoint_4DBaseData_Zero(mitk::BaseData* baseData, unsigned int DimT)
{
baseData->Update();
mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
mitk::TimePointType expectedTimePoint = geometry->GetMinimumTimePoint();
MITK_TEST_CONDITION(mitk::Equal(expectedTimePoint, 0), "Returns correct minimum time point ");
}
void GetMaximumTimePoint_4DBaseData_DimT(mitk::BaseData* baseData, unsigned int DimT)
{
baseData->Update();
mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
mitk::TimePointType expectedTimePoint = geometry->GetMaximumTimePoint();
MITK_TEST_CONDITION(mitk::Equal(expectedTimePoint, DimT), "Returns correct maximum time point ");
}
- void GetNumberOfTimeSteps_Image_ReturnDimT(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
+ void CountTimeSteps_Image_ReturnDimT(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
{
mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
- mitk::TimeStepType expectedTimeSteps = geometry->GetNumberOfTimeSteps();
+ mitk::TimeStepType expectedTimeSteps = geometry->CountTimeSteps();
MITK_TEST_CONDITION(mitk::Equal(expectedTimeSteps, DimT), "Returns correct number of time Steps ");
}
void GetMinimumTimePoint_3DImage_Min(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
{
mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
mitk::TimePointType expectedTimePoint = geometry->GetMinimumTimePoint();
MITK_TEST_CONDITION(mitk::Equal(expectedTimePoint, -std::numeric_limits<mitk::TimePointType>().max()), "Returns correct minimum time point ");
}
void GetMaximumTimePoint_3DImage_Max(mitk::BaseData* baseData,unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
{
mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
mitk::TimePointType expectedTimePoint = geometry->GetMaximumTimePoint();
MITK_INFO << expectedTimePoint;
MITK_INFO << std::numeric_limits<mitk::TimePointType>().max();
MITK_TEST_CONDITION(mitk::Equal(expectedTimePoint, std::numeric_limits<mitk::TimePointType>().max()), "Returns correct maximum time point ");
}
void GetTimeBounds_4DImage_ZeroAndDimT(unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
{
mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(DimX, DimY, DimZ, DimT,0.5,0.33,0.78,100);
mitk::TimeGeometry::Pointer geometry = image->GetTimeGeometry();
mitk::TimeBounds expectedTimeBounds = geometry->GetTimeBounds();
MITK_TEST_CONDITION(mitk::Equal(expectedTimeBounds[0], 0), "Returns correct minimum time point ");
MITK_TEST_CONDITION(mitk::Equal(expectedTimeBounds[1], DimT), "Returns correct maximum time point ");
}
void GetTimeBounds_3DImage_ZeroAndDimT(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
{
baseData->Update();
mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
mitk::TimeBounds expectedTimeBounds = geometry->GetTimeBounds();
MITK_TEST_CONDITION(mitk::Equal(expectedTimeBounds[0], -std::numeric_limits<mitk::TimePointType>().max()), "Returns correct minimum time point ");
MITK_TEST_CONDITION(mitk::Equal(expectedTimeBounds[1], std::numeric_limits<mitk::TimePointType>().max()), "Returns correct maximum time point ");
}
void IsValidTimePoint_ImageValidTimePoint_True(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
{
baseData->Update();
mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
bool isValid = geometry->IsValidTimePoint(DimT-1);
MITK_TEST_CONDITION(mitk::Equal(isValid, true), "Is valid time Point correct minimum time point ");
}
void IsValidTimePoint_ImageNegativInvalidTimePoint_False(unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
{
mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(DimX, DimY, DimZ, DimT,0.5,0.33,0.78,100);
mitk::TimeGeometry::Pointer geometry = image->GetTimeGeometry();
bool isValid = geometry->IsValidTimePoint(-DimT);
MITK_TEST_CONDITION(mitk::Equal(isValid, false), "Is invalid time Point correct minimum time point ");
}
void IsValidTimePoint_ImageInvalidTimePoint_False(unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
{
mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(DimX, DimY, DimZ, DimT,0.5,0.33,0.78,100);
mitk::TimeGeometry::Pointer geometry = image->GetTimeGeometry();
bool isValid = geometry->IsValidTimePoint(DimT+1);
MITK_TEST_CONDITION(mitk::Equal(isValid, false), "Is invalid time Point correct minimum time point ");
}
void IsValidTimeStep_ImageValidTimeStep_True(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
{
mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
bool isValid = geometry->IsValidTimeStep(DimT-1);
MITK_TEST_CONDITION(mitk::Equal(isValid, true), "Is valid time Point correct minimum time point ");
}
void IsValidTimeStep_ImageNegativInvalidTimeStep_False(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
{
mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
bool isValid = geometry->IsValidTimeStep(-DimT);
MITK_TEST_CONDITION(mitk::Equal(isValid, false), "Is invalid time Point correct minimum time point ");
}
void IsValidTimeStep_ImageInvalidTimeStep_False(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
{
mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
bool isValid = geometry->IsValidTimeStep(DimT);
MITK_TEST_CONDITION(mitk::Equal(isValid, false), "Is invalid time Point correct minimum time point ");
}
void TimeStepToTimePoint_ImageValidTimeStep_TimePoint(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
{
mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
mitk::TimePointType timePoint= geometry->TimeStepToTimePoint(DimT-1);
MITK_TEST_CONDITION(mitk::Equal(timePoint, DimT-1), "Calculated right time Point for Time Step ");
}
void TimeStepToTimePoint_ImageInvalidTimeStep_TimePoint(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
{
mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
mitk::TimePointType timePoint= geometry->TimeStepToTimePoint(DimT+1);
MITK_TEST_CONDITION(mitk::Equal(timePoint, DimT+1), "Calculated right time Point for invalid Time Step ");
}
void TimePointToTimeStep_ImageValidTimePoint_TimePoint(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
{
mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
mitk::TimeStepType timePoint= geometry->TimePointToTimeStep(DimT-0.5);
MITK_TEST_CONDITION(mitk::Equal(timePoint, DimT-1), "Calculated right time step for valid time point");
}
void TimePointToTimeStep_4DImageInvalidTimePoint_TimePoint(unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
{
mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(DimX, DimY, DimZ, DimT,0.5,0.33,0.78,100);
mitk::TimeGeometry::Pointer geometry = image->GetTimeGeometry();
mitk::TimeStepType timePoint= geometry->TimePointToTimeStep(DimT+1.5);
MITK_TEST_CONDITION(mitk::Equal(timePoint, DimT+1), "Calculated right time step for invalid time point");
}
void TimePointToTimeStep_4DImageNegativInvalidTimePoint_TimePoint(unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
{
mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(DimX, DimY, DimZ, DimT,0.5,0.33,0.78,100);
mitk::TimeGeometry::Pointer geometry = image->GetTimeGeometry();
mitk::TimePointType negativTimePoint = (-1.0*DimT) - 1.5;
mitk::TimeStepType timePoint= geometry->TimePointToTimeStep(negativTimePoint);
MITK_TEST_CONDITION(mitk::Equal(timePoint, 0), "Calculated right time step for negativ invalid time point");
}
void GetGeometryForTimeStep_BaseDataValidTimeStep_CorrectGeometry(mitk::BaseData* baseData,
float inputX, float inputY, float inputZ,
float outputX, float outputY, float outputZ, unsigned int DimT)
{
baseData->Update();
mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
mitk::Geometry3D::Pointer geometry3D = geometry->GetGeometryForTimeStep(DimT-1);
MITK_TEST_CONDITION(geometry3D.IsNotNull(), "Non-zero geometry returned");
mitk::Point3D expectedPoint;
expectedPoint[0] = outputX;
expectedPoint[1] = outputY;
expectedPoint[2] = outputZ;
mitk::Point3D originalPoint;
originalPoint[0] = inputX;
originalPoint[1] = inputY;
originalPoint[2] = inputZ;
mitk::Point3D worldPoint;
geometry3D->IndexToWorld(originalPoint, worldPoint);
MITK_TEST_CONDITION(mitk::Equal(worldPoint, expectedPoint), "Geometry transformation match expection. ");
}
void GetGeometryForTimeStep_ImageInvalidTimeStep_NullPointer(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
{
mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
mitk::Geometry3D::Pointer geometry3D = geometry->GetGeometryForTimeStep(DimT+1);
MITK_TEST_CONDITION(geometry3D.IsNull(), "Null-Pointer geometry returned");
}
void GetGeometryForTimePoint_BaseDataValidTimePoint_CorrectGeometry(mitk::BaseData* baseData,
float inputX, float inputY, float inputZ,
float outputX, float outputY, float outputZ, unsigned int DimT)
{
baseData->Update();
mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
mitk::Geometry3D::Pointer geometry3D = geometry->GetGeometryForTimePoint(DimT-0.5);
MITK_TEST_CONDITION(geometry3D.IsNotNull(), "Non-zero geometry returned");
mitk::Point3D expectedPoint;
expectedPoint[0] = outputX;
expectedPoint[1] = outputY;
expectedPoint[2] = outputZ;
mitk::Point3D originalPoint;
originalPoint[0] = inputX;
originalPoint[1] = inputY;
originalPoint[2] = inputZ;
mitk::Point3D worldPoint;
geometry3D->IndexToWorld(originalPoint, worldPoint);
MITK_TEST_CONDITION(mitk::Equal(worldPoint, expectedPoint), "Geometry transformation match expection. ");
}
void GetGeometryForTimePoint_4DImageInvalidTimePoint_NullPointer(unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
{
mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(DimX, DimY, DimZ, DimT,0.5,0.33,0.78,100);
mitk::TimeGeometry::Pointer geometry = image->GetTimeGeometry();
mitk::Geometry3D::Pointer geometry3D = geometry->GetGeometryForTimePoint(DimT+1);
MITK_TEST_CONDITION(geometry3D.IsNull(), "Null-Pointer geometry returned with invalid time point");
}
void GetGeometryForTimePoint_4DImageNEgativInvalidTimePoint_NullPointer(unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
{
mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(DimX, DimY, DimZ, DimT,0.5,0.33,0.78,100);
mitk::TimeGeometry::Pointer geometry = image->GetTimeGeometry();
mitk::TimePointType timePoint = (-1.0*(DimT)) -1;
mitk::Geometry3D::Pointer geometry3D = geometry->GetGeometryForTimePoint(timePoint);
MITK_TEST_CONDITION(geometry3D.IsNull(), "Null-Pointer geometry returned with invalid negativ time point");
}
void GetGeometryCloneForTimeStep_BaseDataValidTimeStep_CorrectGeometry(mitk::BaseData* baseData, unsigned int DimT)
{
mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
mitk::Geometry3D::Pointer geometry3D = geometry->GetGeometryCloneForTimeStep(DimT-1);
MITK_TEST_CONDITION(geometry3D.IsNotNull(), "Non-zero geometry returned");
mitk::Point3D expectedPoint;
mitk::Point3D originalPoint;
originalPoint[0] = 3;
originalPoint[1] = 3;
originalPoint[2] = 3;
mitk::Point3D worldPoint;
geometry3D->IndexToWorld(originalPoint, expectedPoint);
mitk::Vector3D translationVector;
translationVector[0] = 5;
translationVector[1] = 8;
translationVector[2] = 7;
geometry3D->Translate(translationVector);
geometry3D = geometry->GetGeometryForTimeStep(DimT-1);
geometry3D->IndexToWorld(originalPoint, worldPoint);
MITK_TEST_CONDITION(mitk::Equal(worldPoint, expectedPoint), "Geometry transformation not changed. ");
}
void GetGeometryCloneForTimeStep_ImageInvalidTimeStep_NullPointer(mitk::BaseData* baseData, unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
{
mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
mitk::Geometry3D::Pointer geometry3D = geometry->GetGeometryCloneForTimeStep(DimT+1);
MITK_TEST_CONDITION(geometry3D.IsNull(), "Null-Pointer geometry returned");
}
void SetTimeStepGeometry_BaseDataValidTimeStep_CorrectGeometry(mitk::BaseData* baseData, float scaleX, float scaleY, float scaleZ, unsigned int DimT)
{
baseData->Update();
mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
mitk::Geometry3D::Pointer geometry3D = geometry->GetGeometryCloneForTimeStep(DimT-1);
MITK_TEST_CONDITION(geometry3D.IsNotNull(), "Non-zero geometry returned");
mitk::Vector3D translationVector;
translationVector[0] = 5;
translationVector[1] = 8;
translationVector[2] = 7;
geometry3D->Translate(translationVector);
geometry->SetTimeStepGeometry(geometry3D,DimT-1);
mitk::Point3D expectedPoint;
expectedPoint[0] = 3*scaleX+5;
expectedPoint[1] = 3*scaleY+8;
expectedPoint[2] = 3*scaleZ+7;
mitk::Point3D originalPoint;
originalPoint[0] = 3;
originalPoint[1] = 3;
originalPoint[2] = 3;
mitk::Point3D worldPoint;
geometry->GetGeometryForTimeStep(DimT-1)->IndexToWorld(originalPoint, worldPoint);
MITK_TEST_CONDITION(mitk::Equal(worldPoint, expectedPoint), "Geometry transformation match expection. ");
}
void Expand_BaseDataDoubleSize_SizeChanged(mitk::BaseData* baseData, int DimT)
{
mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
- MITK_TEST_CONDITION(geometry->GetNumberOfTimeSteps()==DimT, "Number of time Steps match expection. ");
+ MITK_TEST_CONDITION(geometry->CountTimeSteps()==DimT, "Number of time Steps match expection. ");
geometry->Expand(DimT * 2);
- MITK_TEST_CONDITION(geometry->GetNumberOfTimeSteps()==DimT*2, "Number of time Steps match expection. ");
+ MITK_TEST_CONDITION(geometry->CountTimeSteps()==DimT*2, "Number of time Steps match expection. ");
mitk::Geometry3D::Pointer geometry3D = geometry->GetGeometryForTimeStep(DimT*2 -1);
MITK_TEST_CONDITION(geometry3D.IsNotNull(), "Non-zero geometry is generated. ");
}
void CheckBounds_BaseData_PointsAsExpected(mitk::BaseData* baseData, float minX, float minY, float minZ, float maxX, float maxY, float maxZ)
{
baseData->Update();
mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
mitk::Point3D expectedPoint;
expectedPoint[0] = minX;
expectedPoint[1] = minY;
expectedPoint[2] = minZ;
mitk::Point3D point = geometry->GetCornerPointInWorld(0);
MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 0 as expected ");
point = geometry->GetCornerPointInWorld(true,true,true);
MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 0 as expected ");
point = geometry->GetCornerPointInWorld(1);
expectedPoint[0] = minX;
expectedPoint[1] = minY;
expectedPoint[2] = maxZ;
MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "GBounding Point 1 as expected ");
point = geometry->GetCornerPointInWorld(true,true,false);
MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 1 as expected ");
point = geometry->GetCornerPointInWorld(2);
expectedPoint[0] = minX;
expectedPoint[1] = maxY;
expectedPoint[2] = minZ;
MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 2 as expected ");
point = geometry->GetCornerPointInWorld(true,false,true);
MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 2 as expected ");
point = geometry->GetCornerPointInWorld(3);
expectedPoint[0] = minX;
expectedPoint[1] = maxY;
expectedPoint[2] = maxZ;
MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 3 as expected ");
point = geometry->GetCornerPointInWorld(true,false,false);
MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 3 as expected ");
point = geometry->GetCornerPointInWorld(4);
expectedPoint[0] = maxX;
expectedPoint[1] = minY;
expectedPoint[2] = minZ;
MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 4 as expected ");
point = geometry->GetCornerPointInWorld(false,true,true);
MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 4 as expected ");
point = geometry->GetCornerPointInWorld(5);
expectedPoint[0] = maxX;
expectedPoint[1] = minY;
expectedPoint[2] = maxZ;
MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 5 as expected ");
point = geometry->GetCornerPointInWorld(false,true,false);
MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 5 as expected ");
point = geometry->GetCornerPointInWorld(6);
expectedPoint[0] = maxX;
expectedPoint[1] = maxY;
expectedPoint[2] = minZ;
MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 6 as expected ");
point = geometry->GetCornerPointInWorld(false,false,true);
MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 6 as expected ");
point = geometry->GetCornerPointInWorld(7);
expectedPoint[0] = maxX;
expectedPoint[1] = maxY;
expectedPoint[2] = maxZ;
MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 7 as expected ");
point = geometry->GetCornerPointInWorld(false,false,false);
MITK_TEST_CONDITION(mitk::Equal(expectedPoint, point), "Bounding Point 7 as expected ");
}
void CheckLength_BaseData_AsExpected(mitk::BaseData* baseData, double length, double squareLength)
{
baseData->Update();
mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
double dimension = geometry->GetDiagonalLengthInWorld();
MITK_TEST_CONDITION(mitk::Equal(dimension,length ), "Length as expected ");
dimension = geometry->GetDiagonalLength2InWorld();
MITK_TEST_CONDITION(mitk::Equal(dimension, squareLength ), "Square length as expected ");
}
void CheckPointInside_BaseDataPointInside_True(mitk::BaseData* baseData, float pointX, float pointY, float pointZ)
{
baseData->Update();
mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
mitk::Point3D expectedPoint;
expectedPoint[0] = pointX;
expectedPoint[1] = pointY;
expectedPoint[2] = pointZ;
bool isInside = geometry->IsWorldPointInside(expectedPoint);
MITK_TEST_CONDITION(isInside, "Point is inside Image...");
}
void CheckPointInside_BaseDataPointOutside_False(mitk::BaseData* baseData, float pointX, float pointY, float pointZ)
{
baseData->Update();
mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
mitk::Point3D expectedPoint;
expectedPoint[0] = pointX;
expectedPoint[1] = pointY;
expectedPoint[2] = pointZ;
bool isInside = geometry->IsWorldPointInside(expectedPoint);
MITK_TEST_CONDITION(!isInside, "Point is outside Image...");
}
void CheckBounds_Image_AsSet(unsigned int DimX, unsigned int DimY, unsigned int DimZ, unsigned int DimT)
{
mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(DimX, DimY, DimZ, DimT,0.5,0.33,0.78,100);
mitk::TimeGeometry::Pointer geometry = image->GetTimeGeometry();
mitk::BoundingBox::BoundsArrayType bound = geometry->GetBoundsInWorld();
bool isEqual = true;
isEqual = isEqual && mitk::Equal(bound[0], -0.5*0.5);
isEqual = isEqual && mitk::Equal(bound[1], 29.5*0.5);
isEqual = isEqual && mitk::Equal(bound[2], -0.5*0.33);
isEqual = isEqual && mitk::Equal(bound[3], 24.5*0.33);
isEqual = isEqual && mitk::Equal(bound[4], -0.5*0.78);
isEqual = isEqual && mitk::Equal(bound[5], 19.5*0.78);
MITK_TEST_CONDITION(isEqual, "Bounds as precalculated...");
}
void CheckBounds_BaseData_AsSet(mitk::BaseData* baseData, float minBoundX, float maxBoundX, float minBoundY, float maxBoundY, float minBoundZ, float maxBoundZ)
{
baseData->Update();
mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
mitk::BoundingBox::BoundsArrayType bound = geometry->GetBoundsInWorld();
bool isEqual = true;
isEqual = isEqual && mitk::Equal(bound[0], minBoundX);
isEqual = isEqual && mitk::Equal(bound[1], maxBoundX);
isEqual = isEqual && mitk::Equal(bound[2], minBoundY);
isEqual = isEqual && mitk::Equal(bound[3], maxBoundY);
isEqual = isEqual && mitk::Equal(bound[4], minBoundZ);
isEqual = isEqual && mitk::Equal(bound[5], maxBoundZ);
MITK_TEST_CONDITION(isEqual, "Bounds as precalculated...");
}
void CheckExtent_BaseData_AsSet(mitk::BaseData* baseData, double extentX, double extentY, double extentZ)
{
baseData->Update();
mitk::TimeGeometry::Pointer geometry = baseData->GetTimeGeometry();
mitk::BoundingBox::BoundsArrayType bound = geometry->GetBoundsInWorld();
bool isEqual = true;
isEqual = isEqual && mitk::Equal(geometry->GetExtentInWorld(0), extentX);//30*0.5);
isEqual = isEqual && mitk::Equal(geometry->GetExtentInWorld(1), extentY);//25*0.33);
isEqual = isEqual && mitk::Equal(geometry->GetExtentInWorld(2), extentZ);//20*0.78);
MITK_TEST_CONDITION(isEqual, "Extent as precalculated...");
}
mitk::PointSet::Pointer makePointset()
{
mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
mitk::Point3D pointA, pointB, pointC;
pointA.Fill(1);
pointB.Fill(2);
pointC.Fill(3);
pointSet->SetPoint(1,pointA);
pointSet->SetPoint(2,pointB);
pointSet->SetPoint(3,pointC);
pointSet->Update();
MITK_INFO<< pointSet->GetPoint(0);
MITK_INFO<< pointSet->GetPoint(1);
MITK_INFO<< pointSet->GetPoint(2);
MITK_INFO<< pointSet->GetPoint(3);
mitk::PointSet::Pointer pointSet2 = pointSet->Clone();
MITK_INFO<< pointSet2->GetPoint(0);
MITK_INFO<< pointSet2->GetPoint(1);
MITK_INFO<< pointSet2->GetPoint(2);
MITK_INFO<< pointSet2->GetPoint(3);
return pointSet;
}
};
int mitkTimeGeometryTest(int /*argc*/, char* /*argv*/[])
{
MITK_TEST_BEGIN(mitkTimeGeometryTest);
mitkTimeGeometryTestClass testClass;
MITK_TEST_OUTPUT(<< "Test for 3D image");
mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(30, 25, 20, 1,0.5,0.33,0.78,100);
testClass.Translation_Image_MovedOrigin(30,25,20,1);
testClass.Rotate_Image_RotatedPoint(image->Clone(),30,25,20,1);
testClass.Scale_Image_ScaledPoint(30,25,20,1);
- testClass.GetNumberOfTimeSteps_Image_ReturnDimT(image->Clone(),30,25,20,1);
+ testClass.CountTimeSteps_Image_ReturnDimT(image->Clone(),30,25,20,1);
testClass.GetMinimumTimePoint_3DImage_Min(image->Clone(),30,25,20,1);
testClass.GetMaximumTimePoint_3DImage_Max(image->Clone(),30,25,20,1);
testClass.GetTimeBounds_3DImage_ZeroAndDimT(image->Clone(),30,25,20,1);
testClass.IsValidTimePoint_ImageValidTimePoint_True(image->Clone(),30,25,20,1);
testClass.IsValidTimeStep_ImageValidTimeStep_True(image->Clone(), 30,25,20,1);
testClass.IsValidTimeStep_ImageNegativInvalidTimeStep_False(image->Clone(), 30,25,20,1);
testClass.IsValidTimeStep_ImageInvalidTimeStep_False(image->Clone(), 30,25,20,1);
testClass.TimeStepToTimePoint_ImageValidTimeStep_TimePoint(image->Clone(), 30,25,20,1);
testClass.TimeStepToTimePoint_ImageInvalidTimeStep_TimePoint(image->Clone(), 30,25,20,1);
testClass.TimePointToTimeStep_ImageValidTimePoint_TimePoint(image->Clone(), 30,25,20,1);
testClass.GetGeometryForTimeStep_BaseDataValidTimeStep_CorrectGeometry(image->Clone(), 3,3,3,3*0.5,3*0.33,3*0.78,1);
testClass.GetGeometryForTimeStep_ImageInvalidTimeStep_NullPointer(image->Clone(), 30,25,20,1);
testClass.GetGeometryForTimePoint_BaseDataValidTimePoint_CorrectGeometry(image->Clone(), 3,3,3,3*0.5,3*0.33,3*0.78,1);
testClass.GetGeometryCloneForTimeStep_BaseDataValidTimeStep_CorrectGeometry(image->Clone(),1);
testClass.GetGeometryCloneForTimeStep_ImageInvalidTimeStep_NullPointer(image->Clone(), 30,25,20,1);
testClass.SetTimeStepGeometry_BaseDataValidTimeStep_CorrectGeometry(image->Clone(),0.5,0.33,0.78,1);
testClass.Expand_BaseDataDoubleSize_SizeChanged(image->Clone(),1);
testClass.CheckBounds_BaseData_PointsAsExpected(image->Clone(),-0.5*0.5,-0.5*0.33,-0.5*0.78,29.5*0.5,24.5*0.33,19.5*0.78);
testClass.CheckLength_BaseData_AsExpected(image->Clone(), 23.160796233014466, 536.42248214721712);
testClass.CheckPointInside_BaseDataPointInside_True(image->Clone(),10,5,5);
testClass.CheckPointInside_BaseDataPointOutside_False(image->Clone(),100,500,100);
testClass.CheckBounds_Image_AsSet(30,25,20,1);
testClass.CheckExtent_BaseData_AsSet(image->Clone(), 30*0.5,25*0.33,20*0.78);
MITK_TEST_OUTPUT(<< "Test for 2D image");
image = mitk::ImageGenerator::GenerateRandomImage<float>(30, 25, 1, 1,0.5,0.33,0.78,100);
testClass.Translation_Image_MovedOrigin(30,25,1,1);
testClass.Rotate_Image_RotatedPoint(image->Clone(),30,25,1,1);
testClass.Scale_Image_ScaledPoint(30,25,1,1);
- testClass.GetNumberOfTimeSteps_Image_ReturnDimT(image->Clone(),30,25,1,1);
+ testClass.CountTimeSteps_Image_ReturnDimT(image->Clone(),30,25,1,1);
testClass.GetMinimumTimePoint_3DImage_Min(image->Clone(),30,25,1,1);
testClass.GetMaximumTimePoint_3DImage_Max(image->Clone(),30,25,1,1);
testClass.GetTimeBounds_3DImage_ZeroAndDimT(image->Clone(),30,25,1,1);
testClass.IsValidTimePoint_ImageValidTimePoint_True(image->Clone(),30,25,1,1);
testClass.IsValidTimeStep_ImageValidTimeStep_True(image->Clone(), 30,25,1,1);
testClass.IsValidTimeStep_ImageNegativInvalidTimeStep_False(image->Clone(), 30,25,1,1);
testClass.IsValidTimeStep_ImageInvalidTimeStep_False(image->Clone(), 30,25,1,1);
testClass.TimeStepToTimePoint_ImageValidTimeStep_TimePoint(image->Clone(), 30,25,1,1);
testClass.TimeStepToTimePoint_ImageInvalidTimeStep_TimePoint(image->Clone(), 30,25,1,1);
testClass.TimePointToTimeStep_ImageValidTimePoint_TimePoint(image->Clone(), 30,25,1,1);
testClass.GetGeometryForTimeStep_BaseDataValidTimeStep_CorrectGeometry(image->Clone(), 3,3,3,3*0.5,3*0.33,3*0.78,1);
testClass.GetGeometryForTimeStep_ImageInvalidTimeStep_NullPointer(image->Clone(), 30,25,1,1);
testClass.GetGeometryForTimePoint_BaseDataValidTimePoint_CorrectGeometry(image->Clone(), 3,3,3,3*0.5,3*0.33,3*0.78,1);
testClass.GetGeometryCloneForTimeStep_BaseDataValidTimeStep_CorrectGeometry(image->Clone(),1);
testClass.GetGeometryCloneForTimeStep_ImageInvalidTimeStep_NullPointer(image->Clone(), 30,25,1,1);
testClass.SetTimeStepGeometry_BaseDataValidTimeStep_CorrectGeometry(image->Clone(),0.5,0.33,0.78,1);
testClass.Expand_BaseDataDoubleSize_SizeChanged(image->Clone(),1);
testClass.CheckBounds_BaseData_PointsAsExpected(image->Clone(),-0.5*0.5,-0.5*0.33,-0.5*0.78,29.5*0.5,24.5*0.33,0.5*0.78);
testClass.CheckLength_BaseData_AsExpected(image->Clone(), 17.1368287615, 293.6709);
testClass.CheckPointInside_BaseDataPointInside_True(image->Clone(),10,5,0);
testClass.CheckPointInside_BaseDataPointOutside_False(image->Clone(),100,500,0.5);
testClass.CheckExtent_BaseData_AsSet(image->Clone(), 30*0.5,25*0.33,1*0.78);
MITK_TEST_OUTPUT(<< "Test for 3D+time image");
image = mitk::ImageGenerator::GenerateRandomImage<float>(30, 25, 20, 5,0.5,0.33,0.78,100);
testClass.Translation_Image_MovedOrigin(30,25,20,5); // Test with 3D+t-Image
testClass.Rotate_Image_RotatedPoint(image->Clone(),30,25,20,5); // Test with 3D+t-Image
testClass.Scale_Image_ScaledPoint(30,25,20,5); // Test with 3D+t-Image
- testClass.GetNumberOfTimeSteps_Image_ReturnDimT(image->Clone(),30,25,20,5);
+ testClass.CountTimeSteps_Image_ReturnDimT(image->Clone(),30,25,20,5);
testClass.GetMinimumTimePoint_4DBaseData_Zero(image->Clone(),5);
testClass.GetMaximumTimePoint_4DBaseData_DimT(image->Clone(),5);
testClass.GetTimeBounds_4DImage_ZeroAndDimT(30,25,20,5);
testClass.IsValidTimePoint_ImageValidTimePoint_True(image->Clone(),30,25,20,5);
testClass.IsValidTimePoint_ImageNegativInvalidTimePoint_False(30,25,20,5);
testClass.IsValidTimePoint_ImageInvalidTimePoint_False(30,25,20,5);
testClass.IsValidTimeStep_ImageValidTimeStep_True(image->Clone(), 30,25,20,5);
testClass.IsValidTimeStep_ImageNegativInvalidTimeStep_False(image->Clone(), 30,25,20,5);
testClass.IsValidTimeStep_ImageInvalidTimeStep_False(image->Clone(), 30,25,20,5);
testClass.TimeStepToTimePoint_ImageValidTimeStep_TimePoint(image->Clone(), 30,25,20,5);
testClass.TimeStepToTimePoint_ImageInvalidTimeStep_TimePoint(image->Clone(), 30,25,20,5);
testClass.TimePointToTimeStep_ImageValidTimePoint_TimePoint(image->Clone(), 30,25,20,5);
testClass.TimePointToTimeStep_4DImageInvalidTimePoint_TimePoint(30,25,20,5);
testClass.TimePointToTimeStep_4DImageNegativInvalidTimePoint_TimePoint(30,25,20,5);
testClass.GetGeometryForTimeStep_BaseDataValidTimeStep_CorrectGeometry(image->Clone(), 3,3,3,3*0.5,3*0.33,3*0.78,5);
testClass.GetGeometryForTimeStep_ImageInvalidTimeStep_NullPointer(image->Clone(), 30,25,20,5);
testClass.GetGeometryForTimePoint_BaseDataValidTimePoint_CorrectGeometry(image->Clone(), 3,3,3,3*0.5,3*0.33,3*0.78,5);
testClass.GetGeometryForTimePoint_4DImageInvalidTimePoint_NullPointer(30,25,20,5);
testClass.GetGeometryForTimePoint_4DImageNEgativInvalidTimePoint_NullPointer(30,25,20,5);
testClass.GetGeometryCloneForTimeStep_BaseDataValidTimeStep_CorrectGeometry(image->Clone(),5);
testClass.GetGeometryCloneForTimeStep_ImageInvalidTimeStep_NullPointer(image->Clone(), 30,25,20,5);
testClass.SetTimeStepGeometry_BaseDataValidTimeStep_CorrectGeometry(image->Clone(),0.5,0.33,0.78,5);
testClass.Expand_BaseDataDoubleSize_SizeChanged(image->Clone(),5);
testClass.CheckBounds_BaseData_PointsAsExpected(image->Clone(),-0.5*0.5,-0.5*0.33,-0.5*0.78,29.5*0.5,24.5*0.33,19.5*0.78);
testClass.CheckLength_BaseData_AsExpected(image->Clone(), 23.160796233014466, 536.42248214721712);
testClass.CheckPointInside_BaseDataPointInside_True(image->Clone(),10,5,5);
testClass.CheckPointInside_BaseDataPointOutside_False(image->Clone(), 100,100,500);
testClass.CheckBounds_Image_AsSet(30,25,20,5);
testClass.CheckExtent_BaseData_AsSet(image->Clone(), 30*0.5,25*0.33,20*0.78);
/*
MITK_TEST_OUTPUT(<< "Test for 2D+time image");
testClass.Translation_Image_MovedOrigin(30,25,1 ,5); // Test with 2D+t-Image
testClass.Rotate_Image_RotatedPoint(30,25,1 ,5); // Test with 2D+t-Image
testClass.Scale_Image_ScaledPoint(30,25,1 ,5); // Test with 2D+t-Image
*/
mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
mitk::Point3D pointA, pointB, pointC;
pointA.Fill(1);
pointB.Fill(2);
pointC.Fill(3);
pointSet->SetPoint(0,pointA);
pointSet->SetPoint(1,pointB);
pointSet->SetPoint(2,pointC);
- testClass.GetNumberOfTimeSteps_Image_ReturnDimT(pointSet->Clone(),30,25,20,1);
+ testClass.CountTimeSteps_Image_ReturnDimT(pointSet->Clone(),30,25,20,1);
testClass.GetMinimumTimePoint_3DImage_Min(pointSet->Clone(),30,25,20,1);
testClass.GetMaximumTimePoint_3DImage_Max(pointSet->Clone(),30,25,20,1);
testClass.GetTimeBounds_3DImage_ZeroAndDimT(pointSet->Clone(),30,25,20,1);
testClass.IsValidTimePoint_ImageValidTimePoint_True(pointSet->Clone(),30,25,20,1);
testClass.IsValidTimeStep_ImageValidTimeStep_True(pointSet->Clone(),30,25,20,1);
testClass.IsValidTimeStep_ImageNegativInvalidTimeStep_False(pointSet->Clone(),30,25,20,1);
testClass.IsValidTimeStep_ImageInvalidTimeStep_False(pointSet->Clone(),30,25,20,1);
testClass.TimeStepToTimePoint_ImageValidTimeStep_TimePoint(pointSet->Clone(),30,25,20,1);
testClass.TimeStepToTimePoint_ImageInvalidTimeStep_TimePoint(pointSet->Clone(),30,25,20,1);
testClass.TimePointToTimeStep_ImageValidTimePoint_TimePoint(pointSet->Clone(),30,25,20,1);
testClass.GetGeometryForTimeStep_BaseDataValidTimeStep_CorrectGeometry(pointSet->Clone(), 3,3,3,3,3,3,1);
testClass.GetGeometryForTimeStep_ImageInvalidTimeStep_NullPointer(pointSet->Clone(), 30,25,20,1);
testClass.GetGeometryForTimePoint_BaseDataValidTimePoint_CorrectGeometry(pointSet->Clone(), 3,3,3,3,3,3,1);
testClass.GetGeometryCloneForTimeStep_BaseDataValidTimeStep_CorrectGeometry(pointSet->Clone(),1);
testClass.GetGeometryCloneForTimeStep_ImageInvalidTimeStep_NullPointer(pointSet->Clone(), 30,25,20,1);
testClass.SetTimeStepGeometry_BaseDataValidTimeStep_CorrectGeometry(pointSet->Clone(), 1,1,1,1);
testClass.Expand_BaseDataDoubleSize_SizeChanged(pointSet->Clone(),1);
testClass.CheckBounds_BaseData_PointsAsExpected(pointSet->Clone(),1,1,1,3,3,3);
testClass.CheckLength_BaseData_AsExpected(pointSet->Clone(),3.46410161,12);
testClass.CheckPointInside_BaseDataPointInside_True(pointSet->Clone(),2,2,3);
testClass.CheckPointInside_BaseDataPointOutside_False(pointSet->Clone(),4,5,1);
testClass.CheckBounds_BaseData_AsSet(pointSet->Clone(),1,3,1,3,1,3);
testClass.CheckExtent_BaseData_AsSet(pointSet->Clone(),2,2,2 );
MITK_TEST_END();
return EXIT_SUCCESS;
}
diff --git a/Modules/ContourModel/DataManagement/mitkContourModel.cpp b/Modules/ContourModel/DataManagement/mitkContourModel.cpp
index 4ff74c9f1c..91746a3de6 100644
--- a/Modules/ContourModel/DataManagement/mitkContourModel.cpp
+++ b/Modules/ContourModel/DataManagement/mitkContourModel.cpp
@@ -1,638 +1,638 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkContourModel.h>
#include <mitkPlaneGeometry.h>
mitk::ContourModel::ContourModel() :
m_UpdateBoundingBox(true)
{
//set to initial state
this->InitializeEmpty();
}
mitk::ContourModel::ContourModel(const mitk::ContourModel &other) :
m_ContourSeries(other.m_ContourSeries), m_lineInterpolation(other.m_lineInterpolation)
{
m_SelectedVertex = NULL;
}
mitk::ContourModel::~ContourModel()
{
m_SelectedVertex = NULL;
this->m_ContourSeries.clear();//TODO check destruction
}
void mitk::ContourModel::AddVertex(mitk::Point3D &vertex, int timestep)
{
if(!this->IsEmptyTimeStep(timestep) )
{
this->AddVertex(vertex, false, timestep);
}
}
void mitk::ContourModel::AddVertex(mitk::Point3D &vertex, bool isControlPoint, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->AddVertex(vertex, isControlPoint);
this->InvokeEvent( ContourModelSizeChangeEvent() );
this->Modified();this->m_UpdateBoundingBox = true;
}
}
void mitk::ContourModel::AddVertex(VertexType &vertex, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->AddVertex(vertex);
this->InvokeEvent( ContourModelSizeChangeEvent() );
this->Modified();this->m_UpdateBoundingBox = true;
}
}
void mitk::ContourModel::AddVertexAtFront(mitk::Point3D &vertex, int timestep)
{
if(!this->IsEmptyTimeStep(timestep) )
{
this->AddVertexAtFront(vertex, false, timestep);
}
}
void mitk::ContourModel::AddVertexAtFront(mitk::Point3D &vertex, bool isControlPoint, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->AddVertexAtFront(vertex, isControlPoint);
this->InvokeEvent( ContourModelSizeChangeEvent() );
this->Modified();this->m_UpdateBoundingBox = true;
}
}
void mitk::ContourModel::AddVertexAtFront(VertexType &vertex, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->AddVertexAtFront(vertex);
this->InvokeEvent( ContourModelSizeChangeEvent() );
this->Modified();this->m_UpdateBoundingBox = true;
}
}
void mitk::ContourModel::InsertVertexAtIndex(mitk::Point3D &vertex, int index, bool isControlPoint, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
if(index > 0 && this->m_ContourSeries[timestep]->GetSize() > index)
{
this->m_ContourSeries[timestep]->InsertVertexAtIndex(vertex, isControlPoint, index);
this->InvokeEvent( ContourModelSizeChangeEvent() );
this->Modified();this->m_UpdateBoundingBox = true;
}
}
}
bool mitk::ContourModel::IsEmpty( int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
return this->m_ContourSeries[timestep]->IsEmpty();
}
return true;
}
int mitk::ContourModel::GetNumberOfVertices( int timestep) const
{
if(!this->IsEmptyTimeStep(timestep))
{
return this->m_ContourSeries[timestep]->GetSize();
}
return -1;
}
const mitk::ContourModel::VertexType* mitk::ContourModel::GetVertexAt(int index, int timestep) const
{
if(!this->IsEmptyTimeStep(timestep))
{
return this->m_ContourSeries[timestep]->GetVertexAt(index);
}
return NULL;
}
void mitk::ContourModel::Close( int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->Close();
this->InvokeEvent( ContourModelClosedEvent() );
this->Modified();this->m_UpdateBoundingBox = true;
}
}
void mitk::ContourModel::Open( int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->Open();
this->InvokeEvent( ContourModelClosedEvent() );
this->Modified();this->m_UpdateBoundingBox = true;
}
}
void mitk::ContourModel::SetIsClosed(bool isClosed, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->SetIsClosed(isClosed);
this->InvokeEvent( ContourModelClosedEvent() );
this->Modified();this->m_UpdateBoundingBox = true;
}
}
bool mitk::ContourModel::IsEmptyTimeStep( int t) const
{
return (t < 0) || (this->m_ContourSeries.size() <= t);
}
bool mitk::ContourModel::IsNearContour(mitk::Point3D &point, float eps, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
return this->m_ContourSeries[timestep]->IsNearContour(point, eps);
}
return false;
}
void mitk::ContourModel::Concatenate(mitk::ContourModel* other, int timestep, bool check)
{
if(!this->IsEmptyTimeStep(timestep))
{
if( !this->m_ContourSeries[timestep]->IsClosed() )
{
this->m_ContourSeries[timestep]->Concatenate(other->m_ContourSeries[timestep], check);
this->InvokeEvent( ContourModelSizeChangeEvent() );
this->Modified();this->m_UpdateBoundingBox = true;
}
}
}
mitk::ContourModel::VertexIterator mitk::ContourModel::Begin( int timestep)
{
return this->IteratorBegin(timestep);
}
mitk::ContourModel::VertexIterator mitk::ContourModel::IteratorBegin( int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
return this->m_ContourSeries[timestep]->IteratorBegin();
}
else
{
mitkThrow() << "No iterator at invalid timestep " << timestep << ". There are only " << this->GetTimeSteps() << " timesteps available.";
}
}
mitk::ContourModel::VertexIterator mitk::ContourModel::End( int timestep)
{
return this->IteratorEnd(timestep);
}
mitk::ContourModel::VertexIterator mitk::ContourModel::IteratorEnd( int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
return this->m_ContourSeries[timestep]->IteratorEnd();
}
else
{
mitkThrow() << "No iterator at invalid timestep " << timestep << ". There are only " << this->GetTimeSteps() << " timesteps available.";
}
}
bool mitk::ContourModel::IsClosed( int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
return this->m_ContourSeries[timestep]->IsClosed();
}
return false;
}
bool mitk::ContourModel::SelectVertexAt(mitk::Point3D &point, float eps, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
this->m_SelectedVertex = this->m_ContourSeries[timestep]->GetVertexAt(point, eps);
}
return this->m_SelectedVertex != NULL;
}
bool mitk::ContourModel::SelectVertexAt(int index, int timestep)
{
if(!this->IsEmptyTimeStep(timestep) && index >= 0)
{
return (this->m_SelectedVertex = this->m_ContourSeries[timestep]->GetVertexAt(index));
}
return false;
}
bool mitk::ContourModel::SetControlVertexAt(mitk::Point3D &point, float eps, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
VertexType* vertex = this->m_ContourSeries[timestep]->GetVertexAt(point, eps);
if (vertex != NULL)
{
vertex->IsControlPoint = true;
return true;
}
}
return false;
}
bool mitk::ContourModel::SetControlVertexAt(int index, int timestep)
{
if(!this->IsEmptyTimeStep(timestep) && index >= 0)
{
VertexType* vertex = this->m_ContourSeries[timestep]->GetVertexAt(index);
if (vertex != NULL)
{
vertex->IsControlPoint = true;
return true;
}
}
return false;
}
bool mitk::ContourModel::RemoveVertex(VertexType* vertex, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
if(this->m_ContourSeries[timestep]->RemoveVertex(vertex))
{
this->Modified();this->m_UpdateBoundingBox = true;
this->InvokeEvent( ContourModelSizeChangeEvent() );
return true;
}
}
return false;
}
bool mitk::ContourModel::RemoveVertexAt(int index, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
if(this->m_ContourSeries[timestep]->RemoveVertexAt(index))
{
this->Modified();this->m_UpdateBoundingBox = true;
this->InvokeEvent( ContourModelSizeChangeEvent() );
return true;
}
}
return false;
}
bool mitk::ContourModel::RemoveVertexAt(mitk::Point3D &point, float eps, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
if(this->m_ContourSeries[timestep]->RemoveVertexAt(point, eps))
{
this->Modified();this->m_UpdateBoundingBox = true;
this->InvokeEvent( ContourModelSizeChangeEvent() );
return true;
}
}
return false;
}
void mitk::ContourModel::ShiftSelectedVertex(mitk::Vector3D &translate)
{
if(this->m_SelectedVertex)
{
this->ShiftVertex(this->m_SelectedVertex,translate);
this->Modified();this->m_UpdateBoundingBox = true;
}
}
void mitk::ContourModel::ShiftContour(mitk::Vector3D &translate, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
VertexListType* vList = this->m_ContourSeries[timestep]->GetVertexList();
VertexIterator it = vList->begin();
VertexIterator end = vList->end();
//shift all vertices
while(it != end)
{
this->ShiftVertex((*it),translate);
it++;
}
this->Modified();this->m_UpdateBoundingBox = true;
this->InvokeEvent( ContourModelShiftEvent() );
}
}
void mitk::ContourModel::ShiftVertex(VertexType* vertex, mitk::Vector3D &vector)
{
vertex->Coordinates[0] += vector[0];
vertex->Coordinates[1] += vector[1];
vertex->Coordinates[2] += vector[2];
}
void mitk::ContourModel::Clear(int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
//clear data at timestep
this->m_ContourSeries[timestep]->Clear();
this->InitializeEmpty();
this->Modified();this->m_UpdateBoundingBox = true;
}
}
void mitk::ContourModel::Expand( int timeSteps )
{
int oldSize = this->m_ContourSeries.size();
if( timeSteps > 0 && timeSteps > oldSize )
{
Superclass::Expand(timeSteps);
//insert contours for each new timestep
for( int i = oldSize; i < timeSteps; i++)
{
m_ContourSeries.push_back(mitk::ContourElement::New());
}
this->InvokeEvent( ContourModelExpandTimeBoundsEvent() );
}
}
void mitk::ContourModel::SetRequestedRegionToLargestPossibleRegion ()
{
//no support for regions
}
bool mitk::ContourModel::RequestedRegionIsOutsideOfTheBufferedRegion ()
{
//no support for regions
return false;
}
bool mitk::ContourModel::VerifyRequestedRegion ()
{
//no support for regions
return true;
}
const mitk::Geometry3D * mitk::ContourModel::GetUpdatedGeometry (int t)
{
return Superclass::GetUpdatedGeometry(t);
}
mitk::Geometry3D* mitk::ContourModel::GetGeometry (int t)const
{
return Superclass::GetGeometry(t);
}
void mitk::ContourModel::SetRequestedRegion( const itk::DataObject *data)
{
//no support for regions
}
void mitk::ContourModel::Clear()
{
//clear data and set to initial state again
this->ClearData();
this->InitializeEmpty();
this->Modified();this->m_UpdateBoundingBox = true;
}
void mitk::ContourModel::RedistributeControlVertices(int period, int timestep)
{
if(!this->IsEmptyTimeStep(timestep))
{
this->m_ContourSeries[timestep]->RedistributeControlVertices(this->GetSelectedVertex(), period);
this->InvokeEvent( ContourModelClosedEvent() );
this->Modified();this->m_UpdateBoundingBox = true;
}
}
void mitk::ContourModel::ClearData()
{
//call the superclass, this releases the data of BaseData
Superclass::ClearData();
//clear out the time resolved contours
this->m_ContourSeries.clear();
}
void mitk::ContourModel::Initialize()
{
this->InitializeEmpty();
this->Modified();this->m_UpdateBoundingBox = true;
}
void mitk::ContourModel::Initialize(mitk::ContourModel &other)
{
- unsigned int numberOfTimesteps = other.GetTimeGeometry()->GetNumberOfTimeSteps();
+ unsigned int numberOfTimesteps = other.GetTimeGeometry()->CountTimeSteps();
this->InitializeTimeGeometry(numberOfTimesteps);
for(int currentTimestep = 0; currentTimestep < numberOfTimesteps; currentTimestep++)
{
this->m_ContourSeries.push_back(mitk::ContourElement::New());
this->SetIsClosed(other.IsClosed(currentTimestep),currentTimestep);
}
m_SelectedVertex = NULL;
this->m_lineInterpolation = other.m_lineInterpolation;
this->Modified();this->m_UpdateBoundingBox = true;
}
void mitk::ContourModel::InitializeEmpty()
{
//clear data at timesteps
this->m_ContourSeries.resize(0);
this->m_ContourSeries.push_back(mitk::ContourElement::New());
//set number of timesteps to one
this->InitializeTimeGeometry(1);
m_SelectedVertex = NULL;
this->m_lineInterpolation = ContourModel::LINEAR;
}
void mitk::ContourModel::UpdateOutputInformation()
{
if ( this->GetSource() )
{
this->GetSource()->UpdateOutputInformation();
}
if(this->m_UpdateBoundingBox)
{
//update the bounds of the geometry according to the stored vertices
float mitkBounds[6];
//calculate the boundingbox at each timestep
typedef itk::BoundingBox<unsigned long, 3, ScalarType> BoundingBoxType;
typedef BoundingBoxType::PointsContainer PointsContainer;
int timesteps = this->GetTimeSteps();
//iterate over the timesteps
for(int currenTimeStep = 0; currenTimeStep < timesteps; currenTimeStep++)
{
if( dynamic_cast< mitk::PlaneGeometry* >(this->GetGeometry(currenTimeStep)) )
{
//do not update bounds for 2D geometries, as they are unfortunately defined with min bounds 0!
return;
}
else
{//we have a 3D geometry -> let's update bounds
//only update bounds if the contour was modified
if (this->GetMTime() > this->GetGeometry(currenTimeStep)->GetBoundingBox()->GetMTime())
{
mitkBounds[0] = 0.0;
mitkBounds[1] = 0.0;
mitkBounds[2] = 0.0;
mitkBounds[3] = 0.0;
mitkBounds[4] = 0.0;
mitkBounds[5] = 0.0;
BoundingBoxType::Pointer boundingBox = BoundingBoxType::New();
PointsContainer::Pointer points = PointsContainer::New();
VertexIterator it = this->IteratorBegin(currenTimeStep);
VertexIterator end = this->IteratorEnd(currenTimeStep);
//fill the boundingbox with the points
while(it != end)
{
Point3D currentP = (*it)->Coordinates;
BoundingBoxType::PointType p;
p.CastFrom(currentP);
points->InsertElement(points->Size(), p);
it++;
}
//construct the new boundingBox
boundingBox->SetPoints(points);
boundingBox->ComputeBoundingBox();
BoundingBoxType::BoundsArrayType tmp = boundingBox->GetBounds();
mitkBounds[0] = tmp[0];
mitkBounds[1] = tmp[1];
mitkBounds[2] = tmp[2];
mitkBounds[3] = tmp[3];
mitkBounds[4] = tmp[4];
mitkBounds[5] = tmp[5];
//set boundingBox at current timestep
Geometry3D* geometry3d = this->GetGeometry(currenTimeStep);
geometry3d->SetBounds(mitkBounds);
}
}
}
this->m_UpdateBoundingBox = false;
}
GetTimeGeometry()->Update();
}
void mitk::ContourModel::ExecuteOperation(mitk::Operation* operation)
{
//not supported yet
}
\ No newline at end of file
diff --git a/Modules/ContourModel/Rendering/mitkContourModelMapper2D.cpp b/Modules/ContourModel/Rendering/mitkContourModelMapper2D.cpp
index 0327ab997e..20282865d7 100644
--- a/Modules/ContourModel/Rendering/mitkContourModelMapper2D.cpp
+++ b/Modules/ContourModel/Rendering/mitkContourModelMapper2D.cpp
@@ -1,392 +1,392 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkContourModelMapper2D.h>
#include <mitkContourModelSubDivisionFilter.h>
#include <vtkPoints.h>
#include <vtkCellArray.h>
#include <vtkAppendPolyData.h>
#include <vtkProperty.h>
#include <vtkPlane.h>
#include <vtkCutter.h>
#include <vtkStripper.h>
#include <vtkTubeFilter.h>
#include <vtkSphereSource.h>
mitk::ContourModelMapper2D::ContourModelMapper2D()
{
}
mitk::ContourModelMapper2D::~ContourModelMapper2D()
{
}
const mitk::ContourModel* mitk::ContourModelMapper2D::GetInput( void )
{
//convient way to get the data from the dataNode
return static_cast< const mitk::ContourModel * >( GetDataNode()->GetData() );
}
vtkProp* mitk::ContourModelMapper2D::GetVtkProp(mitk::BaseRenderer* renderer)
{
//return the actor corresponding to the renderer
return m_LSH.GetLocalStorage(renderer)->m_Actor;
}
void mitk::ContourModelMapper2D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
{
/*++ convert the contour to vtkPolyData and set it as input for our mapper ++*/
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
mitk::ContourModel* inputContour = static_cast< mitk::ContourModel* >( GetDataNode()->GetData() );
unsigned int timestep = renderer->GetTimeStep();
//if there's something to be rendered
if( inputContour->GetNumberOfVertices(timestep) > 0)
{
localStorage->m_OutlinePolyData = this->CreateVtkPolyDataFromContour(inputContour, renderer);
}
this->ApplyContourProperties(renderer);
localStorage->m_Mapper->SetInput(localStorage->m_OutlinePolyData);
}
void mitk::ContourModelMapper2D::Update(mitk::BaseRenderer* renderer)
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if ( !visible ) return;
//check if there is something to be rendered
mitk::ContourModel* data = static_cast< mitk::ContourModel*>( GetDataNode()->GetData() );
if ( data == NULL )
{
return;
}
// Calculate time step of the input data for the specified renderer (integer value)
this->CalculateTimeStep( renderer );
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
// Check if time step is valid
const TimeGeometry *dataTimeGeometry = data->GetTimeGeometry();
if ( ( dataTimeGeometry == NULL )
- || ( dataTimeGeometry->GetNumberOfTimeSteps() == 0 )
+ || ( dataTimeGeometry->CountTimeSteps() == 0 )
|| ( !dataTimeGeometry->IsValidTimeStep( renderer->GetTimeStep() ) ) )
{
//clear the rendered polydata
localStorage->m_Mapper->RemoveAllInputs();//SetInput(vtkSmartPointer<vtkPolyData>::New());
return;
}
const DataNode *node = this->GetDataNode();
data->UpdateOutputInformation();
//check if something important has changed and we need to rerender
if ( (localStorage->m_LastUpdateTime < node->GetMTime()) //was the node modified?
|| (localStorage->m_LastUpdateTime < data->GetPipelineMTime()) //Was the data modified?
|| (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldGeometry2DUpdateTime()) //was the geometry modified?
|| (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldGeometry2D()->GetMTime())
|| (localStorage->m_LastUpdateTime < node->GetPropertyList()->GetMTime()) //was a property modified?
|| (localStorage->m_LastUpdateTime < node->GetPropertyList(renderer)->GetMTime()) )
{
this->GenerateDataForRenderer( renderer );
}
// since we have checked that nothing important has changed, we can set
// m_LastUpdateTime to the current time
localStorage->m_LastUpdateTime.Modified();
}
vtkSmartPointer<vtkPolyData> mitk::ContourModelMapper2D::CreateVtkPolyDataFromContour(mitk::ContourModel* inputContour, mitk::BaseRenderer* renderer)
{
unsigned int timestep = this->GetTimestep();
// Create a polydata to store everything in
vtkSmartPointer<vtkPolyData> resultingPolyData = vtkSmartPointer<vtkPolyData>::New();
//check for the worldgeometry from the current render window
mitk::PlaneGeometry* currentWorldGeometry = dynamic_cast<mitk::PlaneGeometry*>( const_cast<mitk::Geometry2D*>(renderer->GetCurrentWorldGeometry2D()));
if(currentWorldGeometry)
{
//origin and normal of vtkPlane
mitk::Point3D origin = currentWorldGeometry->GetOrigin();
mitk::Vector3D normal = currentWorldGeometry->GetNormal();
//the implicit function to slice through the polyData
vtkSmartPointer<vtkPlane> plane = vtkSmartPointer<vtkPlane>::New();
plane->SetOrigin(origin[0], origin[1], origin[2]);
plane->SetNormal(normal[0], normal[1], normal[2]);
/* First of all convert the control points of the contourModel to vtk points
* and add lines in between them
*/
//the points to draw
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
//the lines to connect the points
vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
// Create a polydata to store everything in
vtkSmartPointer<vtkPolyData> polyDataIn3D = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkAppendPolyData> appendPoly = vtkSmartPointer<vtkAppendPolyData>::New();
mitk::ContourModel::Pointer renderingContour = mitk::ContourModel::New();
renderingContour = inputContour;
bool subdivision = false;
this->GetDataNode()->GetBoolProperty( "subdivision curve", subdivision, renderer );
if (subdivision)
{
mitk::ContourModel::Pointer subdivContour = mitk::ContourModel::New();
mitk::ContourModelSubDivisionFilter::Pointer subdivFilter = mitk::ContourModelSubDivisionFilter::New();
subdivFilter->SetInput(inputContour);
subdivFilter->Update();
subdivContour = subdivFilter->GetOutput();
if(subdivContour->GetNumberOfVertices() == 0 )
{
subdivContour = inputContour;
}
renderingContour = subdivContour;
}
//iterate over all control points
mitk::ContourModel::VertexIterator current = renderingContour->IteratorBegin(timestep);
mitk::ContourModel::VertexIterator next = renderingContour->IteratorBegin(timestep);
if(next != renderingContour->IteratorEnd(timestep))
{
next++;
mitk::ContourModel::VertexIterator end = renderingContour->IteratorEnd(timestep);
while(next != end)
{
mitk::ContourModel::VertexType* currentControlPoint = *current;
mitk::ContourModel::VertexType* nextControlPoint = *next;
vtkIdType p1 = points->InsertNextPoint(currentControlPoint->Coordinates[0], currentControlPoint->Coordinates[1], currentControlPoint->Coordinates[2]);
vtkIdType p2 = points->InsertNextPoint(nextControlPoint->Coordinates[0], nextControlPoint->Coordinates[1], nextControlPoint->Coordinates[2]);
//add the line between both contorlPoints
lines->InsertNextCell(2);
lines->InsertCellPoint(p1);
lines->InsertCellPoint(p2);
if ( currentControlPoint->IsControlPoint )
{
double coordinates[3];
coordinates[0] = currentControlPoint->Coordinates[0];
coordinates[1] = currentControlPoint->Coordinates[1];
coordinates[2] = currentControlPoint->Coordinates[2];
double distance = plane->DistanceToPlane(coordinates);
if(distance < 0.1)
{
vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New();
sphere->SetRadius(1.2);
sphere->SetCenter(coordinates[0], coordinates[1], coordinates[2]);
sphere->Update();
appendPoly->AddInput(sphere->GetOutput());
}
}
current++;
next++;
}//end while (it!=end)
//check if last control point is enabled to draw it
if ( (*current)->IsControlPoint )
{
double coordinates[3];
coordinates[0] = (*current)->Coordinates[0];
coordinates[1] = (*current)->Coordinates[1];
coordinates[2] = (*current)->Coordinates[2];
double distance = plane->DistanceToPlane(coordinates);
if(distance < 0.1)
{
vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New();
sphere->SetRadius(1.2);
sphere->SetCenter(coordinates[0], coordinates[1], coordinates[2]);
sphere->Update();
appendPoly->AddInput(sphere->GetOutput());
}
}
/* If the contour is closed an additional line has to be created between the very first point
* and the last point
*/
if(renderingContour->IsClosed(timestep))
{
//add a line from the last to the first control point
mitk::ContourModel::VertexType* firstControlPoint = *(renderingContour->IteratorBegin(timestep));
mitk::ContourModel::VertexType* lastControlPoint = *(--(renderingContour->IteratorEnd(timestep)));
vtkIdType p2 = points->InsertNextPoint(lastControlPoint->Coordinates[0], lastControlPoint->Coordinates[1], lastControlPoint->Coordinates[2]);
vtkIdType p1 = points->InsertNextPoint(firstControlPoint->Coordinates[0], firstControlPoint->Coordinates[1], firstControlPoint->Coordinates[2]);
//add the line between both contorlPoints
lines->InsertNextCell(2);
lines->InsertCellPoint(p1);
lines->InsertCellPoint(p2);
}//end if(isClosed)
// Add the points to the dataset
polyDataIn3D->SetPoints(points);
// Add the lines to the dataset
polyDataIn3D->SetLines(lines);
//cut through polyData
bool useCuttingPlane = false;
this->GetDataNode()->GetBoolProperty( "use cutting plane", useCuttingPlane, renderer );
if (useCuttingPlane)
{
//slice through the data to get a 2D representation of the (possible) 3D contour
//needed because currently there is no outher solution if the contour is within the plane
vtkSmartPointer<vtkTubeFilter> tubeFilter = vtkSmartPointer<vtkTubeFilter>::New();
tubeFilter->SetInput(polyDataIn3D);
tubeFilter->SetRadius(0.05);
//cuts through vtkPolyData with a given implicit function. In our case a plane
vtkSmartPointer<vtkCutter> cutter = vtkSmartPointer<vtkCutter>::New();
cutter->SetCutFunction(plane);
cutter->SetInputConnection(tubeFilter->GetOutputPort());
//we want the scalars of the input - so turn off generating the scalars within vtkCutter
cutter->GenerateCutScalarsOff();
cutter->Update();
//set to 2D representation of the contour
resultingPolyData= cutter->GetOutput();
}//end if(project contour)
else
{
//set to 3D polyData
resultingPolyData = polyDataIn3D;
}
}//end if (it != end)
appendPoly->AddInput(resultingPolyData);
appendPoly->Update();
//return contour with control points
return appendPoly->GetOutput();
}else
{
//return empty polyData
return resultingPolyData;
}
}
void mitk::ContourModelMapper2D::ApplyContourProperties(mitk::BaseRenderer* renderer)
{
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
float lineWidth(1.0);
if (this->GetDataNode()->GetFloatProperty( "width", lineWidth, renderer ))
{
localStorage->m_Actor->GetProperty()->SetLineWidth(lineWidth);
}
mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty*>(GetDataNode()->GetProperty("color", renderer));
if(colorprop)
{
//set the color of the contour
double red = colorprop->GetColor().GetRed();
double green = colorprop->GetColor().GetGreen();
double blue = colorprop->GetColor().GetBlue();
localStorage->m_Actor->GetProperty()->SetColor(red, green, blue);
}
//make sure that directional lighting isn't used for our contour
localStorage->m_Actor->GetProperty()->SetAmbient(1.0);
localStorage->m_Actor->GetProperty()->SetDiffuse(0.0);
localStorage->m_Actor->GetProperty()->SetSpecular(0.0);
}
/*+++++++++++++++++++ LocalStorage part +++++++++++++++++++++++++*/
mitk::ContourModelMapper2D::LocalStorage* mitk::ContourModelMapper2D::GetLocalStorage(mitk::BaseRenderer* renderer)
{
return m_LSH.GetLocalStorage(renderer);
}
mitk::ContourModelMapper2D::LocalStorage::LocalStorage()
{
m_Mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
m_Actor = vtkSmartPointer<vtkActor>::New();
m_OutlinePolyData = vtkSmartPointer<vtkPolyData>::New();
//set the mapper for the actor
m_Actor->SetMapper(m_Mapper);
}
void mitk::ContourModelMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
{
node->AddProperty( "color", ColorProperty::New(0.9, 1.0, 0.1), renderer, overwrite );
node->AddProperty( "width", mitk::FloatProperty::New( 1.0 ), renderer, overwrite );
node->AddProperty( "use cutting plane", mitk::BoolProperty::New( true ), renderer, overwrite );
node->AddProperty( "subdivision curve", mitk::BoolProperty::New( false ), renderer, overwrite );
Superclass::SetDefaultProperties(node, renderer, overwrite);
}
diff --git a/Modules/ContourModel/Rendering/mitkContourModelMapper3D.cpp b/Modules/ContourModel/Rendering/mitkContourModelMapper3D.cpp
index d3a112c671..59b4b04680 100644
--- a/Modules/ContourModel/Rendering/mitkContourModelMapper3D.cpp
+++ b/Modules/ContourModel/Rendering/mitkContourModelMapper3D.cpp
@@ -1,243 +1,243 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkContourModelMapper3D.h>
#include <vtkPoints.h>
#include <vtkCellArray.h>
#include <vtkProperty.h>
mitk::ContourModelMapper3D::ContourModelMapper3D()
{
}
mitk::ContourModelMapper3D::~ContourModelMapper3D()
{
}
const mitk::ContourModel* mitk::ContourModelMapper3D::GetInput( void )
{
//convient way to get the data from the dataNode
return static_cast< const mitk::ContourModel * >( GetDataNode()->GetData() );
}
vtkProp* mitk::ContourModelMapper3D::GetVtkProp(mitk::BaseRenderer* renderer)
{
//return the actor corresponding to the renderer
return m_LSH.GetLocalStorage(renderer)->m_Actor;
}
void mitk::ContourModelMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
{
/* First convert the contourModel to vtkPolyData, then tube filter it and
* set it input for our mapper
*/
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
mitk::ContourModel* inputContour = static_cast< mitk::ContourModel* >( GetDataNode()->GetData() );
localStorage->m_OutlinePolyData = this->CreateVtkPolyDataFromContour(inputContour);
this->ApplyContourProperties(renderer);
//tube filter the polyData
localStorage->m_TubeFilter->SetInput(localStorage->m_OutlinePolyData);
float lineWidth(1.0);
if (this->GetDataNode()->GetFloatProperty( "3D contour width", lineWidth, renderer ))
{
localStorage->m_TubeFilter->SetRadius(lineWidth);
}else
{
localStorage->m_TubeFilter->SetRadius(0.5);
}
localStorage->m_TubeFilter->CappingOn();
localStorage->m_TubeFilter->SetNumberOfSides(10);
localStorage->m_TubeFilter->Update();
localStorage->m_Mapper->SetInput(localStorage->m_TubeFilter->GetOutput());
}
void mitk::ContourModelMapper3D::Update(mitk::BaseRenderer* renderer)
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
mitk::ContourModel* data = static_cast< mitk::ContourModel*>( GetDataNode()->GetData() );
if ( data == NULL )
{
return;
}
// Calculate time step of the input data for the specified renderer (integer value)
this->CalculateTimeStep( renderer );
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
// Check if time step is valid
const TimeGeometry *dataTimeGeometry = data->GetTimeGeometry();
if ( ( dataTimeGeometry == NULL )
- || ( dataTimeGeometry->GetNumberOfTimeSteps() == 0 )
+ || ( dataTimeGeometry->CountTimeSteps() == 0 )
|| ( !dataTimeGeometry->IsValidTimeStep( renderer->GetTimeStep() ) )
|| ( this->GetTimestep() == -1 ) )
{
//clear the rendered polydata
localStorage->m_Mapper->SetInput(vtkSmartPointer<vtkPolyData>::New());
return;
}
const DataNode *node = this->GetDataNode();
data->UpdateOutputInformation();
//check if something important has changed and we need to rerender
if ( (localStorage->m_LastUpdateTime < node->GetMTime()) //was the node modified?
|| (localStorage->m_LastUpdateTime < data->GetPipelineMTime()) //Was the data modified?
|| (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldGeometry2DUpdateTime()) //was the geometry modified?
|| (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldGeometry2D()->GetMTime())
|| (localStorage->m_LastUpdateTime < node->GetPropertyList()->GetMTime()) //was a property modified?
|| (localStorage->m_LastUpdateTime < node->GetPropertyList(renderer)->GetMTime()) )
{
this->GenerateDataForRenderer( renderer );
}
// since we have checked that nothing important has changed, we can set
// m_LastUpdateTime to the current time
localStorage->m_LastUpdateTime.Modified();
}
vtkSmartPointer<vtkPolyData> mitk::ContourModelMapper3D::CreateVtkPolyDataFromContour(mitk::ContourModel* inputContour)
{
unsigned int timestep = this->GetTimestep();
//the points to draw
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
//the lines to connect the points
vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
// Create a polydata to store everything in
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
//iterate over the control points
mitk::ContourModel::VertexIterator current = inputContour->IteratorBegin(timestep);
mitk::ContourModel::VertexIterator next = inputContour->IteratorBegin(timestep);
if(next != inputContour->IteratorEnd(timestep))
{
next++;
mitk::ContourModel::VertexIterator end = inputContour->IteratorEnd(timestep);
while(next != end)
{
mitk::ContourModel::VertexType* currentControlPoint = *current;
mitk::ContourModel::VertexType* nextControlPoint = *next;
if( !(currentControlPoint->Coordinates[0] == nextControlPoint->Coordinates[0] &&
currentControlPoint->Coordinates[1] == nextControlPoint->Coordinates[1] &&
currentControlPoint->Coordinates[2] == nextControlPoint->Coordinates[2]))
{
vtkIdType p1 = points->InsertNextPoint(currentControlPoint->Coordinates[0], currentControlPoint->Coordinates[1], currentControlPoint->Coordinates[2]);
vtkIdType p2 = points->InsertNextPoint(nextControlPoint->Coordinates[0], nextControlPoint->Coordinates[1], nextControlPoint->Coordinates[2]);
//add the line between both contorlPoints
lines->InsertNextCell(2);
lines->InsertCellPoint(p1);
lines->InsertCellPoint(p2);
}
current++;
next++;
}
if(inputContour->IsClosed(timestep))
{
// If the contour is closed add a line from the last to the first control point
mitk::ContourModel::VertexType* firstControlPoint = *(inputContour->IteratorBegin(timestep));
mitk::ContourModel::VertexType* lastControlPoint = *(--(inputContour->IteratorEnd(timestep)));
if( lastControlPoint->Coordinates[0] != firstControlPoint->Coordinates[0] ||
lastControlPoint->Coordinates[1] != firstControlPoint->Coordinates[1] ||
lastControlPoint->Coordinates[2] != firstControlPoint->Coordinates[2])
{
vtkIdType p2 = points->InsertNextPoint(lastControlPoint->Coordinates[0], lastControlPoint->Coordinates[1], lastControlPoint->Coordinates[2]);
vtkIdType p1 = points->InsertNextPoint(firstControlPoint->Coordinates[0], firstControlPoint->Coordinates[1], firstControlPoint->Coordinates[2]);
//add the line to the cellArray
lines->InsertNextCell(2);
lines->InsertCellPoint(p1);
lines->InsertCellPoint(p2);
}
}
// Add the points to the dataset
polyData->SetPoints(points);
// Add the lines to the dataset
polyData->SetLines(lines);
}
return polyData;
}
void mitk::ContourModelMapper3D::ApplyContourProperties(mitk::BaseRenderer* renderer)
{
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty*>(GetDataNode()->GetProperty
("color", renderer));
if(colorprop)
{
//set the color of the contour
double red = colorprop->GetColor().GetRed();
double green = colorprop->GetColor().GetGreen();
double blue = colorprop->GetColor().GetBlue();
localStorage->m_Actor->GetProperty()->SetColor(red, green, blue);
}
}
/*+++++++++++++++++++ LocalStorage part +++++++++++++++++++++++++*/
mitk::ContourModelMapper3D::LocalStorage* mitk::ContourModelMapper3D::GetLocalStorage(mitk::BaseRenderer* renderer)
{
return m_LSH.GetLocalStorage(renderer);
}
mitk::ContourModelMapper3D::LocalStorage::LocalStorage()
{
m_Mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
m_Actor = vtkSmartPointer<vtkActor>::New();
m_OutlinePolyData = vtkSmartPointer<vtkPolyData>::New();
m_TubeFilter = vtkSmartPointer<vtkTubeFilter>::New();
//set the mapper for the actor
m_Actor->SetMapper(m_Mapper);
}
void mitk::ContourModelMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
{
node->AddProperty( "color", ColorProperty::New(1.0,0.0,0.0), renderer, overwrite );
node->AddProperty( "3D contour width", mitk::FloatProperty::New( 0.5 ), renderer, overwrite );
Superclass::SetDefaultProperties(node, renderer, overwrite);
}
diff --git a/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkOdfVtkMapper2D.txx b/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkOdfVtkMapper2D.txx
index 3a0f33f4d5..3f5318d042 100644
--- a/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkOdfVtkMapper2D.txx
+++ b/Modules/DiffusionImaging/DiffusionCore/Rendering/mitkOdfVtkMapper2D.txx
@@ -1,885 +1,885 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkOdfVtkMapper2D_txx__
#define __mitkOdfVtkMapper2D_txx__
#include "mitkOdfVtkMapper2D.h"
#include "mitkDataNode.h"
#include "mitkBaseRenderer.h"
#include "mitkMatrixConvert.h"
#include "mitkGeometry3D.h"
#include "mitkTimeGeometry.h"
#include "mitkOdfNormalizationMethodProperty.h"
#include "mitkOdfScaleByProperty.h"
#include "mitkProperties.h"
#include "mitkTensorImage.h"
#include "vtkSphereSource.h"
#include "vtkPropCollection.h"
#include "vtkMaskedGlyph3D.h"
#include "vtkGlyph2D.h"
#include "vtkGlyph3D.h"
#include "vtkMaskedProgrammableGlyphFilter.h"
#include "vtkImageData.h"
#include "vtkLinearTransform.h"
#include "vtkCamera.h"
#include "vtkPointData.h"
#include "vtkTransformPolyDataFilter.h"
#include "vtkTransform.h"
#include "vtkOdfSource.h"
#include "vtkDoubleArray.h"
#include "vtkLookupTable.h"
#include "vtkProperty.h"
#include "vtkPolyDataNormals.h"
#include "vtkLight.h"
#include "vtkLightCollection.h"
#include "vtkMath.h"
#include "vtkFloatArray.h"
#include "vtkDelaunay2D.h"
#include "vtkMapper.h"
#include "vtkRenderer.h"
#include "itkOrientationDistributionFunction.h"
#include "itkFixedArray.h"
#include <mitkGL.h>
#include "vtkOpenGLRenderer.h"
#define _USE_MATH_DEFINES
#include <math.h>
template<class T, int N>
vtkSmartPointer<vtkTransform> mitk::OdfVtkMapper2D<T,N>::m_OdfTransform = vtkSmartPointer<vtkTransform>::New();
template<class T, int N>
vtkSmartPointer<vtkOdfSource> mitk::OdfVtkMapper2D<T,N>::m_OdfSource = vtkSmartPointer<vtkOdfSource>::New();
template<class T, int N>
float mitk::OdfVtkMapper2D<T,N>::m_Scaling;
template<class T, int N>
int mitk::OdfVtkMapper2D<T,N>::m_Normalization;
template<class T, int N>
int mitk::OdfVtkMapper2D<T,N>::m_ScaleBy;
template<class T, int N>
float mitk::OdfVtkMapper2D<T,N>::m_IndexParam1;
template<class T, int N>
float mitk::OdfVtkMapper2D<T,N>::m_IndexParam2;
#define ODF_MAPPER_PI M_PI
template<class T, int N>
mitk::OdfVtkMapper2D<T,N>::LocalStorage::LocalStorage()
{
m_PropAssemblies.push_back(vtkPropAssembly::New());
m_PropAssemblies.push_back(vtkPropAssembly::New());
m_PropAssemblies.push_back(vtkPropAssembly::New());
m_OdfsPlanes.push_back(vtkAppendPolyData::New());
m_OdfsPlanes.push_back(vtkAppendPolyData::New());
m_OdfsPlanes.push_back(vtkAppendPolyData::New());
m_OdfsPlanes[0]->AddInput(vtkPolyData::New());
m_OdfsPlanes[1]->AddInput(vtkPolyData::New());
m_OdfsPlanes[2]->AddInput(vtkPolyData::New());
m_OdfsActors.push_back(vtkActor::New());
m_OdfsActors.push_back(vtkActor::New());
m_OdfsActors.push_back(vtkActor::New());
m_OdfsActors[0]->GetProperty()->SetInterpolationToGouraud();
m_OdfsActors[1]->GetProperty()->SetInterpolationToGouraud();
m_OdfsActors[2]->GetProperty()->SetInterpolationToGouraud();
m_OdfsMappers.push_back(vtkPolyDataMapper::New());
m_OdfsMappers.push_back(vtkPolyDataMapper::New());
m_OdfsMappers.push_back(vtkPolyDataMapper::New());
vtkLookupTable *lut = vtkLookupTable::New();
m_OdfsMappers[0]->SetLookupTable(lut);
m_OdfsMappers[1]->SetLookupTable(lut);
m_OdfsMappers[2]->SetLookupTable(lut);
m_OdfsActors[0]->SetMapper(m_OdfsMappers[0]);
m_OdfsActors[1]->SetMapper(m_OdfsMappers[1]);
m_OdfsActors[2]->SetMapper(m_OdfsMappers[2]);
}
template<class T, int N>
mitk::OdfVtkMapper2D<T,N>
::OdfVtkMapper2D()
{
m_Planes.push_back(vtkPlane::New());
m_Planes.push_back(vtkPlane::New());
m_Planes.push_back(vtkPlane::New());
m_Cutters.push_back(vtkCutter::New());
m_Cutters.push_back(vtkCutter::New());
m_Cutters.push_back(vtkCutter::New());
m_Cutters[0]->SetCutFunction( m_Planes[0] );
m_Cutters[0]->GenerateValues( 1, 0, 1 );
m_Cutters[1]->SetCutFunction( m_Planes[1] );
m_Cutters[1]->GenerateValues( 1, 0, 1 );
m_Cutters[2]->SetCutFunction( m_Planes[2] );
m_Cutters[2]->GenerateValues( 1, 0, 1 );
// Windowing the cutted planes in direction 1
m_ThickPlanes1.push_back(vtkThickPlane::New());
m_ThickPlanes1.push_back(vtkThickPlane::New());
m_ThickPlanes1.push_back(vtkThickPlane::New());
m_Clippers1.push_back(vtkClipPolyData::New());
m_Clippers1.push_back(vtkClipPolyData::New());
m_Clippers1.push_back(vtkClipPolyData::New());
m_Clippers1[0]->SetClipFunction( m_ThickPlanes1[0] );
m_Clippers1[1]->SetClipFunction( m_ThickPlanes1[1] );
m_Clippers1[2]->SetClipFunction( m_ThickPlanes1[2] );
// Windowing the cutted planes in direction 2
m_ThickPlanes2.push_back(vtkThickPlane::New());
m_ThickPlanes2.push_back(vtkThickPlane::New());
m_ThickPlanes2.push_back(vtkThickPlane::New());
m_Clippers2.push_back(vtkClipPolyData::New());
m_Clippers2.push_back(vtkClipPolyData::New());
m_Clippers2.push_back(vtkClipPolyData::New());
m_Clippers2[0]->SetClipFunction( m_ThickPlanes2[0] );
m_Clippers2[1]->SetClipFunction( m_ThickPlanes2[1] );
m_Clippers2[2]->SetClipFunction( m_ThickPlanes2[2] );
m_ShowMaxNumber = 500;
}
template<class T, int N>
mitk::OdfVtkMapper2D<T,N>
::~OdfVtkMapper2D()
{
}
template<class T, int N>
mitk::Image* mitk::OdfVtkMapper2D<T,N>
::GetInput()
{
return static_cast<mitk::Image * > ( m_DataNode->GetData() );
}
template<class T, int N>
vtkProp* mitk::OdfVtkMapper2D<T,N>
::GetVtkProp(mitk::BaseRenderer* renderer)
{
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
return localStorage->m_PropAssemblies[GetIndex(renderer)];
}
template<class T, int N>
int mitk::OdfVtkMapper2D<T,N>
::GetIndex(mitk::BaseRenderer* renderer)
{
if(!strcmp(renderer->GetName(),"stdmulti.widget1"))
return 0;
if(!strcmp(renderer->GetName(),"stdmulti.widget2"))
return 1;
if(!strcmp(renderer->GetName(),"stdmulti.widget3"))
return 2;
return 0;
}
template<class T, int N>
void mitk::OdfVtkMapper2D<T,N>
::GlyphMethod(void *arg)
{
vtkMaskedProgrammableGlyphFilter* pfilter=(vtkMaskedProgrammableGlyphFilter*)arg;
double point[3];
double debugpoint[3];
pfilter->GetPoint(point);
pfilter->GetPoint(debugpoint);
itk::Point<double,3> p(point);
Vector3D spacing = pfilter->GetGeometry()->GetSpacing();
p[0] /= spacing[0];
p[1] /= spacing[1];
p[2] /= spacing[2];
mitk::Point3D p2;
pfilter->GetGeometry()->IndexToWorld( p, p2 );
point[0] = p2[0];
point[1] = p2[1];
point[2] = p2[2];
vtkPointData* data = pfilter->GetPointData();
vtkDataArray* odfvals = data->GetArray("vector");
vtkIdType id = pfilter->GetPointId();
m_OdfTransform->Identity();
m_OdfTransform->Translate(point[0],point[1],point[2]);
typedef itk::OrientationDistributionFunction<float,N> OdfType;
OdfType odf;
if(odfvals->GetNumberOfComponents()==6)
{
float tensorelems[6] = {
(float)odfvals->GetComponent(id,0),
(float)odfvals->GetComponent(id,1),
(float)odfvals->GetComponent(id,2),
(float)odfvals->GetComponent(id,3),
(float)odfvals->GetComponent(id,4),
(float)odfvals->GetComponent(id,5),
};
itk::DiffusionTensor3D<float> tensor(tensorelems);
odf.InitFromTensor(tensor);
}
else
{
for(int i=0; i<N; i++)
odf[i] = (double)odfvals->GetComponent(id,i);
}
switch(m_ScaleBy)
{
case ODFSB_NONE:
m_OdfSource->SetScale(m_Scaling);
break;
case ODFSB_GFA:
m_OdfSource->SetScale(m_Scaling*odf.GetGeneralizedGFA(m_IndexParam1, m_IndexParam2));
break;
case ODFSB_PC:
m_OdfSource->SetScale(m_Scaling*odf.GetPrincipleCurvature(m_IndexParam1, m_IndexParam2, 0));
break;
}
m_OdfSource->SetNormalization(m_Normalization);
m_OdfSource->SetOdf(odf);
m_OdfSource->Modified();
}
template<class T, int N>
typename mitk::OdfVtkMapper2D<T,N>::OdfDisplayGeometry mitk::OdfVtkMapper2D<T,N>
::MeasureDisplayedGeometry(mitk::BaseRenderer* renderer)
{
Geometry2D::ConstPointer worldGeometry = renderer->GetCurrentWorldGeometry2D();
PlaneGeometry::ConstPointer worldPlaneGeometry = dynamic_cast<const PlaneGeometry*>( worldGeometry.GetPointer() );
// set up the cutter orientation according to the current geometry of
// the renderers plane
vtkFloatingPointType vp[ 3 ], vnormal[ 3 ];
Point3D point = worldPlaneGeometry->GetOrigin();
Vector3D normal = worldPlaneGeometry->GetNormal(); normal.Normalize();
vnl2vtk( point.Get_vnl_vector(), vp );
vnl2vtk( normal.Get_vnl_vector(), vnormal );
mitk::DisplayGeometry::Pointer dispGeometry = renderer->GetDisplayGeometry();
mitk::Vector2D size = dispGeometry->GetSizeInMM();
mitk::Vector2D origin = dispGeometry->GetOriginInMM();
//
// |------O------|
// | d2 |
// L d1 M |
// | |
// |-------------|
//
mitk::Vector2D M;
mitk::Vector2D L;
mitk::Vector2D O;
M[0] = origin[0] + size[0]/2;
M[1] = origin[1] + size[1]/2;
L[0] = origin[0];
L[1] = origin[1] + size[1]/2;
O[0] = origin[0] + size[0]/2;
O[1] = origin[1] + size[1];
mitk::Point2D point1;
point1[0] = M[0]; point1[1] = M[1];
mitk::Point3D M3D;
dispGeometry->Map(point1, M3D);
point1[0] = L[0]; point1[1] = L[1];
mitk::Point3D L3D;
dispGeometry->Map(point1, L3D);
point1[0] = O[0]; point1[1] = O[1];
mitk::Point3D O3D;
dispGeometry->Map(point1, O3D);
double d1 = sqrt((M3D[0]-L3D[0])*(M3D[0]-L3D[0])
+ (M3D[1]-L3D[1])*(M3D[1]-L3D[1])
+ (M3D[2]-L3D[2])*(M3D[2]-L3D[2]));
double d2 = sqrt((M3D[0]-O3D[0])*(M3D[0]-O3D[0])
+ (M3D[1]-O3D[1])*(M3D[1]-O3D[1])
+ (M3D[2]-O3D[2])*(M3D[2]-O3D[2]));
double d = d1>d2 ? d1 : d2;
d = d2;
OdfDisplayGeometry retval;
retval.vp[0] = vp[0];
retval.vp[1] = vp[1];
retval.vp[2] = vp[2];
retval.vnormal[0] = vnormal[0];
retval.vnormal[1] = vnormal[1];
retval.vnormal[2] = vnormal[2];
retval.normal[0] = normal[0];
retval.normal[1] = normal[1];
retval.normal[2] = normal[2];
retval.d = d;
retval.d1 = d1;
retval.d2 = d2;
retval.M3D[0] = M3D[0];
retval.M3D[1] = M3D[1];
retval.M3D[2] = M3D[2];
retval.L3D[0] = L3D[0];
retval.L3D[1] = L3D[1];
retval.L3D[2] = L3D[2];
retval.O3D[0] = O3D[0];
retval.O3D[1] = O3D[1];
retval.O3D[2] = O3D[2];
retval.vp_original[0] = vp[0];
retval.vp_original[1] = vp[1];
retval.vp_original[2] = vp[2];
retval.vnormal_original[0] = vnormal[0];
retval.vnormal_original[1] = vnormal[1];
retval.vnormal_original[2] = vnormal[2];
retval.size[0] = size[0];
retval.size[1] = size[1];
retval.origin[0] = origin[0];
retval.origin[1] = origin[1];
return retval;
}
template<class T, int N>
void mitk::OdfVtkMapper2D<T,N>
::Slice(mitk::BaseRenderer* renderer, OdfDisplayGeometry dispGeo)
{
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
vtkLinearTransform * vtktransform =
this->GetDataNode()->GetVtkTransform(this->GetTimestep());
int index = GetIndex(renderer);
vtkSmartPointer<vtkTransform> inversetransform = vtkSmartPointer<vtkTransform>::New();
inversetransform->Identity();
inversetransform->Concatenate(vtktransform->GetLinearInverse());
double myscale[3];
((vtkTransform*)vtktransform)->GetScale(myscale);
inversetransform->PostMultiply();
inversetransform->Scale(1*myscale[0],1*myscale[1],1*myscale[2]);
inversetransform->TransformPoint( dispGeo.vp, dispGeo.vp );
inversetransform->TransformNormalAtPoint( dispGeo.vp, dispGeo.vnormal, dispGeo.vnormal );
// vtk works in axis align coords
// thus the normal also must be axis align, since
// we do not allow arbitrary cutting through volume
//
// vnormal should already be axis align, but in order
// to get rid of precision effects, we set the two smaller
// components to zero here
int dims[3];
m_VtkImage->GetDimensions(dims);
double spac[3];
m_VtkImage->GetSpacing(spac);
if(fabs(dispGeo.vnormal[0]) > fabs(dispGeo.vnormal[1])
&& fabs(dispGeo.vnormal[0]) > fabs(dispGeo.vnormal[2]) )
{
if(fabs(dispGeo.vp[0]/spac[0]) < 0.4)
dispGeo.vp[0] = 0.4*spac[0];
if(fabs(dispGeo.vp[0]/spac[0]) > (dims[0]-1)-0.4)
dispGeo.vp[0] = ((dims[0]-1)-0.4)*spac[0];
dispGeo.vnormal[1] = 0;
dispGeo.vnormal[2] = 0;
}
if(fabs(dispGeo.vnormal[1]) > fabs(dispGeo.vnormal[0]) && fabs(dispGeo.vnormal[1]) > fabs(dispGeo.vnormal[2]) )
{
if(fabs(dispGeo.vp[1]/spac[1]) < 0.4)
dispGeo.vp[1] = 0.4*spac[1];
if(fabs(dispGeo.vp[1]/spac[1]) > (dims[1]-1)-0.4)
dispGeo.vp[1] = ((dims[1]-1)-0.4)*spac[1];
dispGeo.vnormal[0] = 0;
dispGeo.vnormal[2] = 0;
}
if(fabs(dispGeo.vnormal[2]) > fabs(dispGeo.vnormal[1]) && fabs(dispGeo.vnormal[2]) > fabs(dispGeo.vnormal[0]) )
{
if(fabs(dispGeo.vp[2]/spac[2]) < 0.4)
dispGeo.vp[2] = 0.4*spac[2];
if(fabs(dispGeo.vp[2]/spac[2]) > (dims[2]-1)-0.4)
dispGeo.vp[2] = ((dims[2]-1)-0.4)*spac[2];
dispGeo.vnormal[0] = 0;
dispGeo.vnormal[1] = 0;
}
m_Planes[index]->SetTransform( (vtkAbstractTransform*)NULL );
m_Planes[index]->SetOrigin( dispGeo.vp );
m_Planes[index]->SetNormal( dispGeo.vnormal );
vtkSmartPointer<vtkPoints> points;
vtkSmartPointer<vtkPoints> tmppoints;
vtkSmartPointer<vtkPolyData> polydata;
vtkSmartPointer<vtkFloatArray> pointdata;
vtkSmartPointer<vtkDelaunay2D> delaunay;
vtkSmartPointer<vtkPolyData> cuttedPlane;
// the cutter only works if we do not have a 2D-image
// or if we have a 2D-image and want to see the whole image.
//
// for side views of 2D-images, we need some special treatment
if(!( (dims[0] == 1 && dispGeo.vnormal[0] != 0) ||
(dims[1] == 1 && dispGeo.vnormal[1] != 0) ||
(dims[2] == 1 && dispGeo.vnormal[2] != 0) ))
{
m_Cutters[index]->SetCutFunction( m_Planes[index] );
m_Cutters[index]->SetInput( m_VtkImage );
m_Cutters[index]->Update();
cuttedPlane = m_Cutters[index]->GetOutput();
}
else
{
// cutting of a 2D-Volume does not work,
// so we have to build up our own polydata object
cuttedPlane = vtkPolyData::New();
points = vtkPoints::New();
points->SetNumberOfPoints(m_VtkImage->GetNumberOfPoints());
for(int i=0; i<m_VtkImage->GetNumberOfPoints(); i++)
{
points->SetPoint(i, m_VtkImage->GetPoint(i));
}
cuttedPlane->SetPoints(points);
pointdata = vtkFloatArray::New();
int comps = m_VtkImage->GetPointData()->GetScalars()->GetNumberOfComponents();
pointdata->SetNumberOfComponents(comps);
int tuples = m_VtkImage->GetPointData()->GetScalars()->GetNumberOfTuples();
pointdata->SetNumberOfTuples(tuples);
for(int i=0; i<tuples; i++)
pointdata->SetTuple(i,m_VtkImage->GetPointData()->GetScalars()->GetTuple(i));
pointdata->SetName( "vector" );
cuttedPlane->GetPointData()->AddArray(pointdata);
int nZero1, nZero2;
if(dims[0]==1)
{
nZero1 = 1; nZero2 = 2;
}
else if(dims[1]==1)
{
nZero1 = 0; nZero2 = 2;
}
else
{
nZero1 = 0; nZero2 = 1;
}
tmppoints = vtkPoints::New();
for(int j=0; j<m_VtkImage->GetNumberOfPoints(); j++){
double pt[3];
m_VtkImage->GetPoint(j,pt);
tmppoints->InsertNextPoint(pt[nZero1],pt[nZero2],0);
}
polydata = vtkPolyData::New();
polydata->SetPoints( tmppoints );
delaunay = vtkDelaunay2D::New();
delaunay->SetInput( polydata );
delaunay->Update();
vtkCellArray* polys = delaunay->GetOutput()->GetPolys();
cuttedPlane->SetPolys(polys);
}
if(cuttedPlane->GetNumberOfPoints())
{
// WINDOWING HERE
inversetransform = vtkTransform::New();
inversetransform->Identity();
inversetransform->Concatenate(vtktransform->GetLinearInverse());
double myscale[3];
((vtkTransform*)vtktransform)->GetScale(myscale);
inversetransform->PostMultiply();
inversetransform->Scale(1*myscale[0],1*myscale[1],1*myscale[2]);
dispGeo.vnormal[0] = dispGeo.M3D[0]-dispGeo.O3D[0];
dispGeo.vnormal[1] = dispGeo.M3D[1]-dispGeo.O3D[1];
dispGeo.vnormal[2] = dispGeo.M3D[2]-dispGeo.O3D[2];
vtkMath::Normalize(dispGeo.vnormal);
dispGeo.vp[0] = dispGeo.M3D[0];
dispGeo.vp[1] = dispGeo.M3D[1];
dispGeo.vp[2] = dispGeo.M3D[2];
inversetransform->TransformPoint( dispGeo.vp, dispGeo.vp );
inversetransform->TransformNormalAtPoint( dispGeo.vp, dispGeo.vnormal, dispGeo.vnormal );
m_ThickPlanes1[index]->count = 0;
m_ThickPlanes1[index]->SetTransform((vtkAbstractTransform*)NULL );
m_ThickPlanes1[index]->SetPose( dispGeo.vnormal, dispGeo.vp );
m_ThickPlanes1[index]->SetThickness(dispGeo.d2);
m_Clippers1[index]->SetClipFunction( m_ThickPlanes1[index] );
m_Clippers1[index]->SetInput( cuttedPlane );
m_Clippers1[index]->SetInsideOut(1);
m_Clippers1[index]->Update();
dispGeo.vnormal[0] = dispGeo.M3D[0]-dispGeo.L3D[0];
dispGeo.vnormal[1] = dispGeo.M3D[1]-dispGeo.L3D[1];
dispGeo.vnormal[2] = dispGeo.M3D[2]-dispGeo.L3D[2];
vtkMath::Normalize(dispGeo.vnormal);
dispGeo.vp[0] = dispGeo.M3D[0];
dispGeo.vp[1] = dispGeo.M3D[1];
dispGeo.vp[2] = dispGeo.M3D[2];
inversetransform->TransformPoint( dispGeo.vp, dispGeo.vp );
inversetransform->TransformNormalAtPoint( dispGeo.vp, dispGeo.vnormal, dispGeo.vnormal );
m_ThickPlanes2[index]->count = 0;
m_ThickPlanes2[index]->SetTransform((vtkAbstractTransform*)NULL );
m_ThickPlanes2[index]->SetPose( dispGeo.vnormal, dispGeo.vp );
m_ThickPlanes2[index]->SetThickness(dispGeo.d1);
m_Clippers2[index]->SetClipFunction( m_ThickPlanes2[index] );
m_Clippers2[index]->SetInput( m_Clippers1[index]->GetOutput() );
m_Clippers2[index]->SetInsideOut(1);
m_Clippers2[index]->Update();
cuttedPlane = m_Clippers2[index]->GetOutput ();
if(cuttedPlane->GetNumberOfPoints())
{
localStorage->m_OdfsPlanes[index]->RemoveAllInputs();
vtkSmartPointer<vtkPolyDataNormals> normals = vtkSmartPointer<vtkPolyDataNormals>::New();
normals->SetInputConnection( m_OdfSource->GetOutputPort() );
normals->SplittingOff();
normals->ConsistencyOff();
normals->AutoOrientNormalsOff();
normals->ComputePointNormalsOn();
normals->ComputeCellNormalsOff();
normals->FlipNormalsOff();
normals->NonManifoldTraversalOff();
vtkSmartPointer<vtkTransformPolyDataFilter> trans = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
trans->SetInputConnection( normals->GetOutputPort() );
trans->SetTransform(m_OdfTransform);
vtkSmartPointer<vtkMaskedProgrammableGlyphFilter> glyphGenerator = vtkSmartPointer<vtkMaskedProgrammableGlyphFilter>::New();
glyphGenerator->SetMaximumNumberOfPoints(std::min(m_ShowMaxNumber,(int)cuttedPlane->GetNumberOfPoints()));
glyphGenerator->SetRandomMode(0);
glyphGenerator->SetUseMaskPoints(1);
glyphGenerator->SetSource( trans->GetOutput() );
glyphGenerator->SetInput(cuttedPlane);
glyphGenerator->SetColorModeToColorBySource();
glyphGenerator->SetInputArrayToProcess(0,0,0, vtkDataObject::FIELD_ASSOCIATION_POINTS , "vector");
glyphGenerator->SetGeometry(this->GetDataNode()->GetData()->GetGeometry());
glyphGenerator->SetGlyphMethod(&(GlyphMethod),(void *)glyphGenerator);
try
{
glyphGenerator->Update();
}
catch( itk::ExceptionObject& err )
{
std::cout << err << std::endl;
}
localStorage->m_OdfsPlanes[index]->AddInput(glyphGenerator->GetOutput());
localStorage->m_OdfsPlanes[index]->Update();
}
}
localStorage->m_PropAssemblies[index]->VisibilityOn();
if(localStorage->m_PropAssemblies[index]->GetParts()->IsItemPresent(localStorage->m_OdfsActors[index]))
localStorage->m_PropAssemblies[index]->RemovePart(localStorage->m_OdfsActors[index]);
localStorage->m_OdfsMappers[index]->SetInput(localStorage->m_OdfsPlanes[index]->GetOutput());
localStorage->m_PropAssemblies[index]->AddPart(localStorage->m_OdfsActors[index]);
}
template<class T, int N>
bool mitk::OdfVtkMapper2D<T,N>
::IsVisibleOdfs(mitk::BaseRenderer* renderer)
{
mitk::Image::Pointer input = const_cast<mitk::Image*>(this->GetInput());
const TimeGeometry *inputTimeGeometry = input->GetTimeGeometry();
- if(inputTimeGeometry==NULL || inputTimeGeometry->GetNumberOfTimeSteps()==0 || !inputTimeGeometry->IsValidTimeStep(this->GetTimestep()))
+ if(inputTimeGeometry==NULL || inputTimeGeometry->CountTimeSteps()==0 || !inputTimeGeometry->IsValidTimeStep(this->GetTimestep()))
return false;
if(this->IsPlaneRotated(renderer))
return false;
bool retval = false;
switch(GetIndex(renderer))
{
case 0:
GetDataNode()->GetVisibility(retval, renderer, "VisibleOdfs_T");
break;
case 1:
GetDataNode()->GetVisibility(retval, renderer, "VisibleOdfs_S");
break;
case 2:
GetDataNode()->GetVisibility(retval, renderer, "VisibleOdfs_C");
break;
}
return retval;
}
template<class T, int N>
void mitk::OdfVtkMapper2D<T,N>
::MitkRenderOverlay(mitk::BaseRenderer* renderer)
{
if ( this->IsVisibleOdfs(renderer)==false )
return;
if ( this->GetVtkProp(renderer)->GetVisibility() )
this->GetVtkProp(renderer)->RenderOverlay(renderer->GetVtkRenderer());
}
template<class T, int N>
void mitk::OdfVtkMapper2D<T,N>
::MitkRenderOpaqueGeometry(mitk::BaseRenderer* renderer)
{
if ( this->IsVisibleOdfs( renderer )==false )
return;
if ( this->GetVtkProp(renderer)->GetVisibility() )
{
// adapt cam pos
OdfDisplayGeometry dispGeo = MeasureDisplayedGeometry( renderer);
this->GetVtkProp(renderer)->RenderOpaqueGeometry( renderer->GetVtkRenderer() );
}
}
template<class T, int N>
void mitk::OdfVtkMapper2D<T,N>
::MitkRenderTranslucentGeometry(mitk::BaseRenderer* renderer)
{
if ( this->IsVisibleOdfs(renderer)==false )
return;
if ( this->GetVtkProp(renderer)->GetVisibility() )
this->GetVtkProp(renderer)->RenderTranslucentPolygonalGeometry(renderer->GetVtkRenderer());
}
template<class T, int N>
void mitk::OdfVtkMapper2D<T,N>
::Update(mitk::BaseRenderer* renderer)
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if ( !visible ) return;
mitk::Image::Pointer input = const_cast<mitk::Image*>( this->GetInput() );
if ( input.IsNull() ) return ;
std::string classname("TensorImage");
if(classname.compare(input->GetNameOfClass())==0)
m_VtkImage = dynamic_cast<mitk::TensorImage*>( this->GetInput() )->GetNonRgbVtkImageData();
std::string qclassname("QBallImage");
if(qclassname.compare(input->GetNameOfClass())==0)
m_VtkImage = dynamic_cast<mitk::QBallImage*>( this->GetInput() )->GetNonRgbVtkImageData();
if( m_VtkImage )
{
// make sure, that we have point data with more than 1 component (as vectors)
vtkPointData* pointData = m_VtkImage->GetPointData();
if ( pointData == NULL )
{
itkWarningMacro( << "m_VtkImage->GetPointData() returns NULL!" );
return ;
}
if ( pointData->GetNumberOfArrays() == 0 )
{
itkWarningMacro( << "m_VtkImage->GetPointData()->GetNumberOfArrays() is 0!" );
return ;
}
else if ( pointData->GetArray(0)->GetNumberOfComponents() != N
&& pointData->GetArray(0)->GetNumberOfComponents() != 6 /*for tensor visualization*/)
{
itkWarningMacro( << "number of components != number of directions in ODF!" );
return;
}
else if ( pointData->GetArrayName( 0 ) == NULL )
{
m_VtkImage->GetPointData()->GetArray(0)->SetName("vector");
}
GenerateDataForRenderer(renderer);
}
else
{
itkWarningMacro( << "m_VtkImage is NULL!" );
return ;
}
}
template<class T, int N>
void mitk::OdfVtkMapper2D<T,N>
::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
{
LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
OdfDisplayGeometry dispGeo = MeasureDisplayedGeometry( renderer);
if ( (localStorage->m_LastUpdateTime >= m_DataNode->GetMTime()) //was the node modified?
&& (localStorage->m_LastUpdateTime >= m_DataNode->GetPropertyList()->GetMTime()) //was a property modified?
&& (localStorage->m_LastUpdateTime >= m_DataNode->GetPropertyList(renderer)->GetMTime())
&& dispGeo.Equals(m_LastDisplayGeometry))
return;
localStorage->m_LastUpdateTime.Modified();
if(!IsVisibleOdfs(renderer))
{
localStorage->m_OdfsActors[0]->VisibilityOff();
localStorage->m_OdfsActors[1]->VisibilityOff();
localStorage->m_OdfsActors[2]->VisibilityOff();
}
else
{
localStorage->m_OdfsActors[0]->VisibilityOn();
localStorage->m_OdfsActors[1]->VisibilityOn();
localStorage->m_OdfsActors[2]->VisibilityOn();
m_OdfSource->SetAdditionalScale(GetMinImageSpacing(GetIndex(renderer)));
ApplyPropertySettings();
Slice(renderer, dispGeo);
m_LastDisplayGeometry = dispGeo;
}
}
template<class T, int N>
double mitk::OdfVtkMapper2D<T,N>::GetMinImageSpacing( int index )
{
// Spacing adapted scaling
double spacing[3];
m_VtkImage->GetSpacing(spacing);
double min;
if(index==0)
{
min = spacing[0];
min = min > spacing[1] ? spacing[1] : min;
}
if(index==1)
{
min = spacing[1];
min = min > spacing[2] ? spacing[2] : min;
}
if(index==2)
{
min = spacing[0];
min = min > spacing[2] ? spacing[2] : min;
}
return min;
}
template<class T, int N>
void mitk::OdfVtkMapper2D<T,N>
::ApplyPropertySettings()
{
this->GetDataNode()->GetFloatProperty( "Scaling", m_Scaling );
this->GetDataNode()->GetIntProperty( "ShowMaxNumber", m_ShowMaxNumber );
OdfNormalizationMethodProperty* nmp = dynamic_cast<OdfNormalizationMethodProperty*>(this->GetDataNode()->GetProperty( "Normalization" ));
if(nmp)
m_Normalization = nmp->GetNormalization();
OdfScaleByProperty* sbp = dynamic_cast<OdfScaleByProperty*>(this->GetDataNode()->GetProperty( "ScaleBy" ));
if(sbp)
m_ScaleBy = sbp->GetScaleBy();
this->GetDataNode()->GetFloatProperty( "IndexParam1", m_IndexParam1);
this->GetDataNode()->GetFloatProperty( "IndexParam2", m_IndexParam2);
}
template <class T, int N>
bool mitk::OdfVtkMapper2D<T,N>
::IsPlaneRotated(mitk::BaseRenderer* renderer)
{
Geometry2D::ConstPointer worldGeometry =
renderer->GetCurrentWorldGeometry2D();
PlaneGeometry::ConstPointer worldPlaneGeometry =
dynamic_cast<const PlaneGeometry*>( worldGeometry.GetPointer() );
vtkFloatingPointType vnormal[ 3 ];
Vector3D normal = worldPlaneGeometry->GetNormal(); normal.Normalize();
vnl2vtk( normal.Get_vnl_vector(), vnormal );
vtkLinearTransform * vtktransform =
this->GetDataNode()->GetVtkTransform(this->GetTimestep());
vtkSmartPointer<vtkTransform> inversetransform = vtkSmartPointer<vtkTransform>::New();
inversetransform->Identity();
inversetransform->Concatenate(vtktransform->GetLinearInverse());
double* n = inversetransform->TransformNormal(vnormal);
int nonZeros = 0;
for (int j=0; j<3; j++)
{
if (fabs(n[j])>mitk::eps){
nonZeros++;
}
}
if(nonZeros>1)
return true;
return false;
}
template<class T, int N>
void mitk::OdfVtkMapper2D<T,N>
::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* /*renderer*/, bool /*overwrite*/)
{
node->SetProperty( "ShowMaxNumber", mitk::IntProperty::New( 150 ) );
node->SetProperty( "Scaling", mitk::FloatProperty::New( 1.0 ) );
node->SetProperty( "Normalization", mitk::OdfNormalizationMethodProperty::New());
node->SetProperty( "ScaleBy", mitk::OdfScaleByProperty::New());
node->SetProperty( "IndexParam1", mitk::FloatProperty::New(2));
node->SetProperty( "IndexParam2", mitk::FloatProperty::New(1));
node->SetProperty( "visible", mitk::BoolProperty::New( true ) );
node->SetProperty( "VisibleOdfs_T", mitk::BoolProperty::New( false ) );
node->SetProperty( "VisibleOdfs_C", mitk::BoolProperty::New( false ) );
node->SetProperty( "VisibleOdfs_S", mitk::BoolProperty::New( false ) );
node->SetProperty ("layer", mitk::IntProperty::New(100));
node->SetProperty( "DoRefresh", mitk::BoolProperty::New( true ) );
}
#endif // __mitkOdfVtkMapper2D_txx__
diff --git a/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilter.cpp b/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilter.cpp
index 20cc9ef310..cff4ff37ce 100644
--- a/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilter.cpp
+++ b/Modules/ImageExtraction/mitkExtractDirectedPlaneImageFilter.cpp
@@ -1,508 +1,508 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkExtractDirectedPlaneImageFilter.h"
#include "mitkAbstractTransformGeometry.h"
//#include "mitkImageMapperGL2D.h"
#include <mitkProperties.h>
#include <mitkDataNode.h>
#include <mitkDataNodeFactory.h>
#include <mitkResliceMethodProperty.h>
#include "vtkMitkThickSlicesFilter.h"
#include <vtkTransform.h>
#include <vtkGeneralTransform.h>
#include <vtkImageData.h>
#include <vtkImageChangeInformation.h>
#include <vtkPoints.h>
#include <vtkSmartPointer.h>
#include <vtkTransform.h>
mitk::ExtractDirectedPlaneImageFilter::ExtractDirectedPlaneImageFilter()
: m_WorldGeometry(NULL)
{
MITK_WARN << "Class ExtractDirectedPlaneImageFilter is deprecated! Use ExtractSliceFilter instead.";
m_Reslicer = vtkImageReslice::New();
m_TargetTimestep = 0;
m_InPlaneResampleExtentByGeometry = true;
m_ResliceInterpolationProperty = NULL;//VtkResliceInterpolationProperty::New(); //TODO initial with value
m_ThickSlicesMode = 0;
m_ThickSlicesNum = 1;
}
mitk::ExtractDirectedPlaneImageFilter::~ExtractDirectedPlaneImageFilter()
{
if(m_ResliceInterpolationProperty!=NULL)m_ResliceInterpolationProperty->Delete();
m_Reslicer->Delete();
}
void mitk::ExtractDirectedPlaneImageFilter::GenerateData()
{
// 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 TimeGeometry *inputTimeGeometry = input->GetTimeGeometry();
if ( ( inputTimeGeometry == NULL )
- || ( inputTimeGeometry->GetNumberOfTimeSteps() == 0 ) )
+ || ( inputTimeGeometry->CountTimeSteps() == 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->TimePointToTimeStep( time );
}
}
else timestep = m_TargetTimestep;
if ( inputTimeGeometry->IsValidTimeStep( 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->GetTimeGeometry() == inputTimeGeometry );
// take transform of input image into account
Geometry3D* inputGeometry = inputTimeGeometry->GetGeometryForTimeStep( 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( right, rightInIndex );
inputGeometry->WorldToIndex( 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->SetInput( inputData );
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.GetVnlVector(), cosines );
// direction of the Y-axis of the sampled result
vnl2vtk( bottom.GetVnlVector(), cosines + 3 );
// normal of the plane
vnl2vtk( normal.GetVnlVector(), cosines + 6 );
m_Reslicer->SetResliceAxesDirectionCosines( cosines );
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(input->GetPixelType(), 2, dimensions );
//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()
{
Superclass::GenerateOutputInformation();
}
bool mitk::ExtractDirectedPlaneImageFilter
::CalculateClippedPlaneBounds( const Geometry3D *boundingGeometry,
const PlaneGeometry *planeGeometry, vtkFloatingPointType *bounds )
{
// 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();
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;
}
}
bool mitk::ExtractDirectedPlaneImageFilter
::LineIntersectZero( vtkPoints *points, int p1, int p2,
vtkFloatingPointType *bounds )
{
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;
}
diff --git a/Modules/MitkExt/Algorithms/mitkAngleCorrectByPointFilter.cpp b/Modules/MitkExt/Algorithms/mitkAngleCorrectByPointFilter.cpp
index a3868f58c6..2a3acd2591 100644
--- a/Modules/MitkExt/Algorithms/mitkAngleCorrectByPointFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkAngleCorrectByPointFilter.cpp
@@ -1,228 +1,228 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkAngleCorrectByPointFilter.h"
#include "mitkIpPic.h"
#include "mitkImageTimeSelector.h"
#include "mitkProperties.h"
#include "mitkImageReadAccessor.h"
#include <mitkProportionalTimeGeometry.h>
mitk::AngleCorrectByPointFilter::AngleCorrectByPointFilter() : m_PreferTransducerPositionFromProperty(true)
{
m_Center.Fill(0);
m_TransducerPosition.Fill(0);
}
mitk::AngleCorrectByPointFilter::~AngleCorrectByPointFilter()
{
}
void mitk::AngleCorrectByPointFilter::GenerateOutputInformation()
{
mitk::Image::ConstPointer input = this->GetInput();
mitk::Image::Pointer output = this->GetOutput();
if ((output->IsInitialized()) && (this->GetMTime() <= m_TimeOfHeaderInitialization.GetMTime()))
return;
itkDebugMacro(<<"GenerateOutputInformation()");
unsigned int i;
unsigned int *tmpDimensions = new unsigned int[input->GetDimension()];
for(i=0;i<input->GetDimension();++i)
tmpDimensions[i]=input->GetDimension(i);
//@todo maybe we should shift the following somehow in ImageToImageFilter
mitk::PixelType scalarPType = MakeScalarPixelType<ScalarType>();
output->Initialize(scalarPType,
input->GetDimension(),
tmpDimensions,
input->GetNumberOfChannels());
output->GetSlicedGeometry()->SetSpacing(input->GetSlicedGeometry()->GetSpacing());
//output->GetSlicedGeometry()->SetGeometry2D(mitk::Image::BuildStandardPlaneGeometry2D(output->GetSlicedGeometry(), tmpDimensions).GetPointer(), 0);
//output->GetSlicedGeometry()->SetEvenlySpaced();
//set the timebounds - after SetGeometry2D, so that the already created PlaneGeometry will also receive this timebounds.
//@fixme!!! will not work for not evenly timed data!
output->GetSlicedGeometry()->SetTimeBounds(input->GetSlicedGeometry()->GetTimeBounds());
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
- timeGeometry->Initialize(output->GetSlicedGeometry(), output->GetTimeGeometry()->GetNumberOfTimeSteps());
+ timeGeometry->Initialize(output->GetSlicedGeometry(), output->GetTimeGeometry()->CountTimeSteps());
output->SetTimeGeometry(timeGeometry);
output->SetPropertyList(input->GetPropertyList()->Clone());
delete [] tmpDimensions;
m_TimeOfHeaderInitialization.Modified();
}
void mitk::AngleCorrectByPointFilter::GenerateData()
{
mitk::Image::ConstPointer input = this->GetInput();
mitk::Image::Pointer output = this->GetOutput();
if(m_PreferTransducerPositionFromProperty)
{
mitk::Point3iProperty::Pointer pointProp;
pointProp = dynamic_cast<mitk::Point3iProperty*>(input->GetProperty("ORIGIN").GetPointer());
if (pointProp.IsNotNull() )
{
const itk::Point<int, 3> & p = pointProp->GetValue();
m_TransducerPosition[0] = p[0];
m_TransducerPosition[1] = p[1];
m_TransducerPosition[2] = p[2];
}
}
itkDebugMacro( << "compute angle corrected image .... " );
itkDebugMacro( << " Center[0]=" << m_Center[0] << " Center[1]=" << m_Center[1] << " Center[2]=" << m_Center[2] );
itkDebugMacro( << " TransducerPosition[0]=" << m_TransducerPosition[0] << " TransducerPosition[1]=" << m_TransducerPosition[1] << " TransducerPosition[2]=" << m_TransducerPosition[2] );
const Vector3D & spacing = input->GetSlicedGeometry()->GetSpacing();
// MITK_INFO << " in: xres=" << spacing[0] << " yres=" << spacing[1] << " zres=" << spacing[2] << std::endl;
if((spacing[0]!=spacing[1]) || (spacing[0]!=spacing[2]))
{
itkExceptionMacro("filter does not work for uninsotropic data: spacing: ("<< spacing[0] << "," << spacing[1] << "," << spacing[2] << ")");
}
Vector3D p;
Vector3D tx_direction;
Vector3D tx_position = m_TransducerPosition.GetVectorFromOrigin();
Vector3D center = m_Center.GetVectorFromOrigin();
Vector3D assumed_direction;
ScalarType &x=p[0];
ScalarType &y=p[1];
ScalarType &z=p[2];
Vector3D down;
FillVector3D(down,0.0,0.0,-1.0);
int xDim = input->GetDimension(0);
int yDim = input->GetDimension(1);
int zDim = input->GetDimension(2);
mitkIpPicDescriptor* pic_out;
pic_out = mitkIpPicNew();
pic_out->dim = 3;
pic_out->bpe = output->GetPixelType().GetBpe();
//pic_out->type = output->GetPixelType().GetType();
pic_out->n[0] = xDim;
pic_out->n[1] = yDim;
pic_out->n[2] = zDim;
pic_out->data = malloc(_mitkIpPicSize(pic_out));
//go!
mitk::ImageTimeSelector::Pointer timeSelector=mitk::ImageTimeSelector::New();
timeSelector->SetInput(input);
int nstart, nmax;
int tstart, tmax;
tstart=output->GetRequestedRegion().GetIndex(3);
nstart=output->GetRequestedRegion().GetIndex(4);
tmax=tstart+output->GetRequestedRegion().GetSize(3);
nmax=nstart+output->GetRequestedRegion().GetSize(4);
int n,t;
for(n=nstart;n<nmax;++n)//output->GetNumberOfChannels();++n)
{
timeSelector->SetChannelNr(n);
for(t=tstart;t<tmax;++t)
{
timeSelector->SetTimeNr(t);
timeSelector->Update();
typedef unsigned char InputImagePixelType;
typedef ScalarType OutputImagePixelType;
if(input->GetPixelType().GetPixelType() != itk::ImageIOBase::SCALAR ||
input->GetPixelType().GetComponentType()!= MapPixelComponentType<InputImagePixelType>::value)
{
itkExceptionMacro("only implemented for " << typeid(PixelType).name() );
}
InputImagePixelType *in;
OutputImagePixelType *out;
mitk::ImageReadAccessor tsOutAcc(timeSelector->GetOutput());
in = (InputImagePixelType *)tsOutAcc.GetData();
out = (OutputImagePixelType*)pic_out->data;
for (z=0 ; z<zDim ; ++z)
{
for (y=0; y<yDim; ++y)
{
for (x=0; x<xDim; ++x, ++in, ++out)
{
tx_direction = tx_position-p;
tx_direction.Normalize();
//are we within the acquisition cone?
// if(-tx_direction*down>vnl_math::pi_over_4)
{
assumed_direction = center-p;
assumed_direction.Normalize();
ScalarType cos_factor = tx_direction*assumed_direction;
if(fabs(cos_factor)>eps)
*out=((ScalarType)(*in)-128.0)/cos_factor;
else
*out=((ScalarType)(*in)-128.0)/eps;
}
//else
// *out=0;
}
}
}
//output->SetPicVolume(pic_out, t, n);
}
}
}
void mitk::AngleCorrectByPointFilter::GenerateInputRequestedRegion()
{
Superclass::GenerateInputRequestedRegion();
mitk::ImageToImageFilter::InputImagePointer input =
const_cast< mitk::ImageToImageFilter::InputImageType * > ( this->GetInput() );
mitk::Image::Pointer output = this->GetOutput();
Image::RegionType requestedRegion;
requestedRegion = output->GetRequestedRegion();
requestedRegion.SetIndex(0, 0);
requestedRegion.SetIndex(1, 0);
requestedRegion.SetIndex(2, 0);
//requestedRegion.SetIndex(3, 0);
//requestedRegion.SetIndex(4, 0);
requestedRegion.SetSize(0, input->GetDimension(0));
requestedRegion.SetSize(1, input->GetDimension(1));
requestedRegion.SetSize(2, input->GetDimension(2));
//requestedRegion.SetSize(3, output->GetDimension(3));
//requestedRegion.SetSize(4, output->GetNumberOfChannels());
input->SetRequestedRegion( & requestedRegion );
}
diff --git a/Modules/MitkExt/Algorithms/mitkBoundingObjectCutter.cpp b/Modules/MitkExt/Algorithms/mitkBoundingObjectCutter.cpp
index 4659e37356..bd12832f98 100644
--- a/Modules/MitkExt/Algorithms/mitkBoundingObjectCutter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkBoundingObjectCutter.cpp
@@ -1,231 +1,231 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#if(_MSC_VER==1200)
#include <itkFixedCenterOfRotationAffineTransform.h>
#include <itkIndex.h>
#include <itkConceptChecking.h>
#endif
#include "mitkBoundingObjectCutter.h"
#include "mitkBoundingObjectCutter.txx"
#include "mitkTimeHelper.h"
#include "mitkImageAccessByItk.h"
#include "mitkBoundingObject.h"
#include "mitkGeometry3D.h"
#include <math.h>
//#include "itkImageRegionIteratorWithIndex.h"
namespace mitk
{
void BoundingObjectCutter::SetBoundingObject( const mitk::BoundingObject* boundingObject )
{
m_BoundingObject = const_cast<mitk::BoundingObject*>(boundingObject);
// Process object is not const-correct so the const_cast is required here
this->ProcessObject::SetNthInput(1,
const_cast< mitk::BoundingObject * >( boundingObject ) );
}
const mitk::BoundingObject* BoundingObjectCutter::GetBoundingObject() const
{
return m_BoundingObject.GetPointer();
}
BoundingObjectCutter::BoundingObjectCutter()
: m_BoundingObject(NULL), m_InsideValue(1), m_OutsideValue(0), m_AutoOutsideValue(false),
m_UseInsideValue(false), m_OutsidePixelCount(0), m_InsidePixelCount(0), m_UseWholeInputRegion(false)
{
this->SetNumberOfIndexedInputs(2);
this->SetNumberOfRequiredInputs(2);
m_InputTimeSelector = mitk::ImageTimeSelector::New();
m_OutputTimeSelector = mitk::ImageTimeSelector::New();
}
BoundingObjectCutter::~BoundingObjectCutter()
{
}
const mitk::PixelType BoundingObjectCutter::GetOutputPixelType()
{
return this->GetInput()->GetPixelType();
}
void BoundingObjectCutter::GenerateInputRequestedRegion()
{
mitk::Image* output = this->GetOutput();
- if((output->IsInitialized()==false) || (m_BoundingObject.IsNull()) || (m_BoundingObject->GetTimeGeometry()->GetNumberOfTimeSteps() == 0))
+ if((output->IsInitialized()==false) || (m_BoundingObject.IsNull()) || (m_BoundingObject->GetTimeGeometry()->CountTimeSteps() == 0))
return;
// we have already calculated the spatial part of the
// input-requested-region in m_InputRequestedRegion in
// GenerateOutputInformation (which is called before
// GenerateInputRequestedRegion).
GenerateTimeInInputRegion(output, const_cast< mitk::Image * > ( this->GetInput() ));
GenerateTimeInInputRegion(output, m_BoundingObject.GetPointer());
}
void BoundingObjectCutter::GenerateOutputInformation()
{
mitk::Image::Pointer output = this->GetOutput();
if ((output->IsInitialized()) && (output->GetPipelineMTime() <= m_TimeOfHeaderInitialization.GetMTime()))
return;
mitk::Image::Pointer input = const_cast< mitk::Image * > ( this->GetInput() );
if(input.IsNull())
{
MITK_WARN << "Input is not a mitk::Image";
return;
}
itkDebugMacro(<<"GenerateOutputInformation()");
unsigned int dimension = input->GetDimension();
if (dimension < 3)
{
MITK_WARN << "ImageCropper cannot handle 1D or 2D Objects. Operation aborted.";
return;
}
- if((m_BoundingObject.IsNull()) || (m_BoundingObject->GetTimeGeometry()->GetNumberOfTimeSteps() == 0))
+ if((m_BoundingObject.IsNull()) || (m_BoundingObject->GetTimeGeometry()->CountTimeSteps() == 0))
return;
mitk::Geometry3D* boGeometry = m_BoundingObject->GetGeometry();
mitk::Geometry3D* inputImageGeometry = input->GetSlicedGeometry();
// calculate bounding box of bounding-object relative to the geometry
// of the input image. The result is in pixel coordinates of the input
// image (because the m_IndexToWorldTransform includes the spacing).
mitk::BoundingBox::Pointer boBoxRelativeToImage = boGeometry->CalculateBoundingBoxRelativeToTransform( inputImageGeometry->GetIndexToWorldTransform() );
// PART I: initialize input requested region. We do this already here (and not
// later when GenerateInputRequestedRegion() is called), because we
// also need the information to setup the output.
// pre-initialize input-requested-region to largest-possible-region
// and correct time-region; spatial part will be cropped by
// bounding-box of bounding-object below
m_InputRequestedRegion = input->GetLargestPossibleRegion();
// build region out of bounding-box of bounding-object
mitk::SlicedData::IndexType index=m_InputRequestedRegion.GetIndex(); //init times and channels
mitk::BoundingBox::PointType min = boBoxRelativeToImage->GetMinimum();
index[0] = (mitk::SlicedData::IndexType::IndexValueType)(std::ceil(min[0]));
index[1] = (mitk::SlicedData::IndexType::IndexValueType)(std::ceil(min[1]));
index[2] = (mitk::SlicedData::IndexType::IndexValueType)(std::ceil(min[2]));
mitk::SlicedData::SizeType size = m_InputRequestedRegion.GetSize(); //init times and channels
mitk::BoundingBox::PointType max = boBoxRelativeToImage->GetMaximum();
size[0] = (mitk::SlicedData::SizeType::SizeValueType)(std::ceil(max[0])-index[0]);
size[1] = (mitk::SlicedData::SizeType::SizeValueType)(std::ceil(max[1])-index[1]);
size[2] = (mitk::SlicedData::SizeType::SizeValueType)(std::ceil(max[2])-index[2]);
mitk::SlicedData::RegionType boRegion(index, size);
if(m_UseWholeInputRegion == false)
{
// crop input-requested-region with region of bounding-object
if(m_InputRequestedRegion.Crop(boRegion)==false)
{
// crop not possible => do nothing: set time size to 0.
size.Fill(0);
m_InputRequestedRegion.SetSize(size);
boRegion.SetSize(size);
m_BoundingObject->SetRequestedRegion(&boRegion);
return;
}
}
// set input-requested-region, because we access it later in
// GenerateInputRequestedRegion (there we just set the time)
input->SetRequestedRegion(&m_InputRequestedRegion);
// PART II: initialize output image
unsigned int *dimensions = new unsigned int [dimension];
itk2vtk(m_InputRequestedRegion.GetSize(), dimensions);
if(dimension>3)
memcpy(dimensions+3, input->GetDimensions()+3, (dimension-3)*sizeof(unsigned int));
output->Initialize(mitk::PixelType(GetOutputPixelType()), dimension, dimensions);
delete [] dimensions;
// now we have everything to initialize the transform of the output
mitk::SlicedGeometry3D* slicedGeometry = output->GetSlicedGeometry();
// set the transform: use the transform of the input;
// the origin will be replaced afterwards
AffineTransform3D::Pointer indexToWorldTransform = AffineTransform3D::New();
indexToWorldTransform->SetParameters(input->GetSlicedGeometry()->GetIndexToWorldTransform()->GetParameters());
slicedGeometry->SetIndexToWorldTransform(indexToWorldTransform);
// Position the output Image to match the corresponding region of the input image
const mitk::SlicedData::IndexType& start = m_InputRequestedRegion.GetIndex();
mitk::Point3D origin; vtk2itk(start, origin);
inputImageGeometry->IndexToWorld(origin, origin);
slicedGeometry->SetOrigin(origin);
m_TimeOfHeaderInitialization.Modified();
}
void BoundingObjectCutter::ComputeData(mitk::Image* input3D, int boTimeStep)
{
AccessFixedDimensionByItk_2(input3D, CutImage, 3, this, boTimeStep);
}
void BoundingObjectCutter::GenerateData()
{
mitk::Image::ConstPointer input = this->GetInput();
mitk::Image::Pointer output = this->GetOutput();
if(input.IsNull())
return;
- if((output->IsInitialized()==false) || (m_BoundingObject.IsNull()) || (m_BoundingObject->GetTimeGeometry()->GetNumberOfTimeSteps() == 0))
+ if((output->IsInitialized()==false) || (m_BoundingObject.IsNull()) || (m_BoundingObject->GetTimeGeometry()->CountTimeSteps() == 0))
return;
m_InputTimeSelector->SetInput(input);
m_OutputTimeSelector->SetInput(this->GetOutput());
mitk::Surface::RegionType outputRegion = output->GetRequestedRegion();
const mitk::TimeGeometry *outputTimeGeometry = output->GetTimeGeometry();
const mitk::TimeGeometry *inputTimeGeometry = input->GetTimeGeometry();
const mitk::TimeGeometry *boundingObjectTimeGeometry = m_BoundingObject->GetTimeGeometry();
TimePointType timeInMS;
int timestep=0;
int tstart=outputRegion.GetIndex(3);
int tmax=tstart+outputRegion.GetSize(3);
int t;
for(t=tstart;t<tmax;++t)
{
timeInMS = outputTimeGeometry->TimeStepToTimePoint( t );
timestep = inputTimeGeometry->TimePointToTimeStep( timeInMS );
m_InputTimeSelector->SetTimeNr(timestep);
m_InputTimeSelector->UpdateLargestPossibleRegion();
m_OutputTimeSelector->SetTimeNr(t);
m_OutputTimeSelector->UpdateLargestPossibleRegion();
timestep = boundingObjectTimeGeometry->TimePointToTimeStep( timeInMS );
ComputeData(m_InputTimeSelector->GetOutput(), timestep);
}
m_InputTimeSelector->SetInput(NULL);
m_OutputTimeSelector->SetInput(NULL);
m_TimeOfHeaderInitialization.Modified();
}
} // of namespace mitk
diff --git a/Modules/MitkExt/Algorithms/mitkCylindricToCartesianFilter.cpp b/Modules/MitkExt/Algorithms/mitkCylindricToCartesianFilter.cpp
index 230f1bf9a7..4301b86fcc 100644
--- a/Modules/MitkExt/Algorithms/mitkCylindricToCartesianFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkCylindricToCartesianFilter.cpp
@@ -1,501 +1,501 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkCylindricToCartesianFilter.h"
#include "mitkImageTimeSelector.h"
#include "mitkSlicedGeometry3D.h"
#include "mitkPlaneGeometry.h"
#include "mitkProperties.h"
#include "mitkLegacyAdaptors.h"
#include <ipPic/mitkIpPicTypeMultiplex.h>
#include <mitkProportionalTimeGeometry.h>
template <class T>
void _transform(mitkIpPicDescriptor *pic, mitkIpPicDescriptor *dest, float _outsideValue, float *fr, float *fphi, float *fz, short *rt, unsigned int *phit, unsigned int *zt, mitkIpPicDescriptor *coneCutOff_pic) //...t=truncated
{
T outsideValue = static_cast<T>(_outsideValue);
register float f, ft, f0, f1, f2, f3;
mitkIpInt2_t ox_size;
mitkIpInt2_t nx_size, ny_size, nz_size;
int oxy_size, nxy_size;
T* orig, *dp, *dest_start;
mitkIpInt2_t* coneCutOff=(mitkIpInt2_t*)coneCutOff_pic->data;
orig=(T*)pic->data;
ox_size=pic->n[0];
oxy_size=ox_size*pic->n[1];
nx_size=dest->n[0];
ny_size=dest->n[1];
nxy_size=nx_size*ny_size;
nz_size=dest->n[2];
/*nx_size=360;
ny_size=360;
nxy_size=nx_size*ny_size;
nz_size=256;*/
dest_start=dp=((T*)dest->data)+nxy_size*(nz_size-1);
mitkIpInt2_t y;
// int size=_mitkIpPicElements(pic);
register mitkIpInt2_t x,z;
for(y=0;y<ny_size;++y)
{
mitkIpInt2_t x_start;
register mitkIpInt2_t x_end;
int r0plusphi0=*rt;
if(r0plusphi0>=0)
{
x_start=0; x_end=nx_size;
}
else
{
x_start=-r0plusphi0; x_end=nx_size+r0plusphi0;
for(z=0;z<nz_size;++z,dp+=-nxy_size-x_start)
for(x=0;x<x_start;++x,++dp)
*dp=outsideValue;
dp+=nxy_size*nz_size; dp+=x_end;
for(z=0;z<nz_size;++z,dp+=-nxy_size-x_start)
for(x=x_end;x<nx_size;++x,++dp)
*dp=outsideValue;
dp+=nxy_size*nz_size; dp-=x_end;
fr+=x_start;
fphi+=x_start;
rt+=x_start;
phit+=x_start;
dp+=x_start;
coneCutOff+=x_start;
}
for(x=x_start;x<x_end;++x, ++fr, ++fphi, ++rt, ++phit, ++dp, ++coneCutOff)
{
f=*fr;
f3=*fphi;
f0=1-f;
f1=1-f3;
f2=f0*f3;
f0*=f1;
f1*=f;
f3*=f;
r0plusphi0=*rt+*phit;
mitkIpInt2_t z_start;
z_start=*coneCutOff;
T *op;
register unsigned int step;
unsigned int *ztp;
op=orig+*rt+*phit;
float *fzp;
for(z=0;z<z_start;++z, dp-=nxy_size)
*dp=outsideValue;
ztp=zt+z_start;
fzp=fz+z_start;
for(z=z_start;z<nz_size;++z, dp-=nxy_size)
{
step=*(ztp++);
register T *opt=op;
opt+=step;
f =*opt*f0; ++opt;
f+=*opt*f1; opt+=oxy_size; --opt;
f+=*opt*f2; ++opt;
f+=*opt*f3; opt-=oxy_size; --opt;
opt+=ox_size;
ft =*opt*f0; ++opt;
ft+=*opt*f1; opt+=oxy_size; --opt;
ft+=*opt*f2; ++opt;
ft+=*opt*f3;
*dp=(T)((1-*fzp)*f+*fzp*ft+0.5);
}
dp+=nxy_size*nz_size;
}
fr+=nx_size-x_end;
fphi+=nx_size-x_end;
rt+=nx_size-x_end;
phit+=nx_size-x_end;
dp+=nx_size-x_end;
coneCutOff+=nx_size-x_end;
}
}
void mitk::CylindricToCartesianFilter::buildTransformShortCuts(int orig_xsize, int orig_ysize, int orig_zsize, int new_xsize, mitkIpPicDescriptor * &rt_pic, mitkIpPicDescriptor * &phit_pic, mitkIpPicDescriptor * &fr_pic, mitkIpPicDescriptor * &fphi_pic, unsigned int * &zt, float * &fz)
{
--orig_zsize;
rt_pic=mitkIpPicNew();
rt_pic->type=mitkIpPicInt;
rt_pic->bpe=16;
rt_pic->dim=2;
rt_pic->n[0]=rt_pic->n[1]=new_xsize;
rt_pic->data=malloc(_mitkIpPicSize(rt_pic));
phit_pic=mitkIpPicNew();
phit_pic->type=mitkIpPicUInt;
phit_pic->bpe=32;
phit_pic->dim=2;
phit_pic->n[0]=phit_pic->n[1]=new_xsize;
phit_pic->data=malloc(_mitkIpPicSize(phit_pic));
fr_pic=mitkIpPicNew();
fr_pic->type=mitkIpPicFloat;
fr_pic->bpe=32;
fr_pic->dim=2;
fr_pic->n[0]=fr_pic->n[1]=new_xsize;
fr_pic->data=malloc(_mitkIpPicSize(fr_pic));
fphi_pic=mitkIpPicNew();
fphi_pic->type=mitkIpPicFloat;
fphi_pic->bpe=32;
fphi_pic->dim=2;
fphi_pic->n[0]=fphi_pic->n[1]=new_xsize;
fphi_pic->data=malloc(_mitkIpPicSize(fphi_pic));
mitkIpInt2_t *rtp=(mitkIpInt2_t*)rt_pic->data, *rt_xzero, rt, phit;
mitkIpUInt4_t *phitp=(mitkIpUInt4_t*)phit_pic->data;
mitkIpFloat4_t *fr=(mitkIpFloat4_t *)fr_pic->data;
mitkIpFloat4_t *fphi=(mitkIpFloat4_t *)fphi_pic->data;
mitkIpFloat4_t r, phi, scale=(double)orig_xsize/(double)new_xsize;
int x,y,xy0,xy0_orig, oxy_size, new_zsize;
oxy_size=orig_xsize*orig_ysize;
xy0=(int)(((double)new_xsize)/2+0.5);
xy0_orig=(int)(((double)orig_xsize)/2+0.5);
new_zsize=(int)(orig_ysize/scale);
// \bug y compared to x
for(y=0;y<new_xsize;++y)
{
rt_xzero=rtp; *rtp=0;
for(x=0;x<new_xsize;++x,++fr,++fphi,++rtp, ++phitp)
{
int xq=x-xy0, yq=y-xy0;
r=sqrt( (double) (xq*xq+yq*yq));
// float rtest=-(xy0-sqrt(xy0*xy0-yq*yq))-0.5;
rt=(mitkIpInt2_t)(-(xy0-sqrt((double) (xy0*xy0-yq*yq)))-0.5);/*in rt steht der Index des Endes der zu �berspringenden Punkte=>anfangen bei -rt+1!*/
// if((x>=-rt) && (x<new_xsize+rt))
{
if(y!=xy0)
r=r*(y>xy0?1.0:-1.0)*scale+xy0_orig;
else
r=r*(x>xy0?-1.0:1.0)*scale+xy0_orig;
rt=(mitkIpInt2_t)r;
int xtmp=x;
if(x>xy0)
xtmp=new_xsize-x;
if(rt<0)
{
r=rt=0;
if(xtmp>-*rt_xzero)
*rt_xzero=-xtmp;
*fr=0;
}
else
if(rt>orig_xsize-1)
{
r=rt=orig_xsize-1;
if(xtmp>-*rt_xzero)
*rt_xzero=-xtmp;
*fr=0;
}
else
*fr=r-rt;
if(*fr<0)
*fr=0;
}
// else
// *fr=0;
phi=orig_zsize-(yq==0?1:-atan((float)xq/yq)/M_PI+0.5)*orig_zsize;
phit=(mitkIpUInt4_t)phi;
*fphi=phi-phit;
*rtp=rt;
*phitp=phit*oxy_size;
}
}
zt=(unsigned int *)malloc(sizeof(unsigned int)*new_zsize);
fz=(float *)malloc(sizeof(float)*new_zsize);
float *fzp=fz;
unsigned int *ztp=zt;
int z;
float z_step=orig_ysize/(orig_ysize*((float)new_xsize)/orig_xsize);
for(z=0;z<new_zsize;++z,++fzp,++ztp)
{
*fzp=z*z_step;
*ztp=(unsigned int)*fzp;
*fzp-=*ztp;
*ztp*=orig_xsize;
}
}
void mitk::CylindricToCartesianFilter::buildConeCutOffShortCut(int orig_xsize, int orig_ysize, mitkIpPicDescriptor *rt_pic, mitkIpPicDescriptor *fr_pic, float a, float b, mitkIpPicDescriptor * &coneCutOff_pic)
{
coneCutOff_pic=mitkIpPicNew();
coneCutOff_pic->type=mitkIpPicInt;
coneCutOff_pic->bpe=16;
coneCutOff_pic->dim=2;
coneCutOff_pic->n[0]=coneCutOff_pic->n[1]=rt_pic->n[0];
coneCutOff_pic->data=malloc(_mitkIpPicSize(coneCutOff_pic));
int i, size=_mitkIpPicElements(rt_pic);
mitkIpInt2_t *rt, *ccop, ohx_size, nz_size;
mitkIpFloat4_t *fr;
a*=(float)rt_pic->n[0]/orig_xsize;
b*=(float)rt_pic->n[0]/orig_xsize;
ohx_size=orig_xsize/2;
nz_size=orig_ysize*rt_pic->n[0]/orig_xsize;
rt=(mitkIpInt2_t *)rt_pic->data; fr=(mitkIpFloat4_t*)fr_pic->data; ccop=(mitkIpInt2_t *)coneCutOff_pic->data;
for(i=0; i<size; ++i, ++rt, ++ccop)
{
register mitkIpInt2_t cco;
if(*rt<=ohx_size)
cco=(mitkIpInt2_t)(a*(*rt+*fr)+b);
else
cco=(mitkIpInt2_t)(a*(orig_xsize-(*rt+*fr))+b);
if(cco<0)
cco=0;
if(cco>=nz_size)
cco=nz_size;
*ccop=cco;
}
}
void mitk::CylindricToCartesianFilter::GenerateOutputInformation()
{
mitk::Image::Pointer output = this->GetOutput();
if ((output->IsInitialized()) && (output->GetPipelineMTime() <= m_TimeOfHeaderInitialization.GetMTime()))
return;
mitk::Image::ConstPointer input = this->GetInput();
itkDebugMacro(<<"GenerateOutputInformation()");
unsigned int i, *tmpDimensions=new unsigned int[std::max(3u,input->GetDimension())];
tmpDimensions[0]=m_TargetXSize;
if(tmpDimensions[0]==0)
tmpDimensions[0] = input->GetDimension(0);
float scale=((float)tmpDimensions[0])/input->GetDimension(0);
tmpDimensions[1] = tmpDimensions[0];
tmpDimensions[2] = (unsigned int)(scale*input->GetDimension(1));
for(i=3;i<input->GetDimension();++i)
tmpDimensions[i]=input->GetDimension(i);
output->Initialize(input->GetPixelType(),
input->GetDimension(),
tmpDimensions,
input->GetNumberOfChannels());
// initialize the spacing of the output
Vector3D spacing = input->GetSlicedGeometry()->GetSpacing();
if(input->GetDimension()>=2)
spacing[2]=spacing[1];
else
spacing[2] = 1.0;
spacing[1] = spacing[0];
spacing *= 1.0/scale;
output->GetSlicedGeometry()->SetSpacing(spacing);
mitk::Point3iProperty::Pointer pointProp;
pointProp = dynamic_cast<mitk::Point3iProperty*>(input->GetProperty("ORIGIN").GetPointer());
if (pointProp.IsNotNull() )
{
itk::Point<int, 3> tp = pointProp->GetValue();
tp[2] = (int)(tmpDimensions[2]-tp[1] * scale-1);
tp[0] = tmpDimensions[0]/2;
tp[1] = tmpDimensions[0]/2;
mitk::Point3iProperty::Pointer pointProp = mitk::Point3iProperty::New(tp);
output->SetProperty("ORIGIN", pointProp);
}
delete [] tmpDimensions;
//output->GetSlicedGeometry()->SetGeometry2D(mitk::Image::BuildStandardPlaneGeometry2D(output->GetSlicedGeometry(), tmpDimensions).GetPointer(), 0);
//set the timebounds - after SetGeometry2D, so that the already created PlaneGeometry will also receive this timebounds.
//@fixme!!! will not work for not evenly timed data!
output->GetSlicedGeometry()->SetTimeBounds(input->GetSlicedGeometry()->GetTimeBounds());
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
- timeGeometry->Initialize(output->GetSlicedGeometry(), output->GetTimeGeometry()->GetNumberOfTimeSteps());
+ timeGeometry->Initialize(output->GetSlicedGeometry(), output->GetTimeGeometry()->CountTimeSteps());
output->SetTimeGeometry(timeGeometry);
output->SetPropertyList(input->GetPropertyList()->Clone());
m_TimeOfHeaderInitialization.Modified();
}
void mitk::CylindricToCartesianFilter::GenerateData()
{
mitk::Image::ConstPointer input = this->GetInput();
mitk::Image::Pointer output = this->GetOutput();
mitk::ImageTimeSelector::Pointer timeSelector=mitk::ImageTimeSelector::New();
timeSelector->SetInput(input);
mitkIpPicDescriptor* pic_transformed=NULL;
pic_transformed = mitkIpPicNew();
pic_transformed->dim=3;
pic_transformed->bpe = output->GetPixelType().GetBpe();
//pic_transformed->type = output->GetPixelType().GetType();
pic_transformed->n[0] = output->GetDimension(0);
pic_transformed->n[1] = output->GetDimension(1);
pic_transformed->n[2] = output->GetDimension(2);
pic_transformed->data=malloc(_mitkIpPicSize(pic_transformed));
int nstart, nmax;
int tstart, tmax;
tstart=output->GetRequestedRegion().GetIndex(3);
nstart=output->GetRequestedRegion().GetIndex(4);
tmax=tstart+output->GetRequestedRegion().GetSize(3);
nmax=nstart+output->GetRequestedRegion().GetSize(4);
if(zt==NULL)
{
timeSelector->SetChannelNr(nstart);
timeSelector->SetTimeNr(tstart);
buildTransformShortCuts(input->GetDimension(0),input->GetDimension(1), input->GetDimension(2), output->GetDimension(0), rt_pic, phit_pic, fr_pic, fphi_pic, zt, fz);
// query the line limiting the sector
a=b=0;
mitk::FloatProperty::Pointer prop;
prop = dynamic_cast<mitk::FloatProperty*>(input->GetProperty("SECTOR LIMITING LINE SLOPE").GetPointer());
if (prop.IsNotNull() )
a = prop->GetValue();
prop = dynamic_cast<mitk::FloatProperty*>(input->GetProperty("SECTOR LIMITING LINE OFFSET").GetPointer());
if (prop.IsNotNull() )
b = prop->GetValue();
buildConeCutOffShortCut(input->GetDimension(0),input->GetDimension(1), rt_pic, fr_pic, a, b, coneCutOff_pic);
// mitkIpPicPut("C:\\temp\\rt_90.pic",rt_pic);
//mitkIpPicPut("C:\\temp\\coneCutOff.pic", coneCutOff_pic);
}
int n,t;
for(n=nstart;n<nmax;++n)//output->GetNumberOfChannels();++n)
{
timeSelector->SetChannelNr(n);
for(t=tstart;t<tmax;++t)
{
timeSelector->SetTimeNr(t);
timeSelector->Update();
// Cast to pic descriptor for the timeSelector image
mitkIpPicDescriptor* timeSelectorPic = mitkIpPicNew();
mitk::ImageWriteAccessor imageAccess(timeSelector->GetOutput());
CastToIpPicDescriptor( timeSelector->GetOutput(), &imageAccess, timeSelectorPic );
_mitkIpPicFreeTags(pic_transformed->info->tags_head);
pic_transformed->info->tags_head = _mitkIpPicCloneTags(timeSelectorPic->info->tags_head);
if(input->GetDimension(2)>1)
{
mitkIpPicTypeMultiplex9(_transform, timeSelectorPic , pic_transformed, m_OutsideValue, (float*)fr_pic->data, (float*)fphi_pic->data, fz, (short *)rt_pic->data, (unsigned int *)phit_pic->data, zt, coneCutOff_pic);
// mitkIpPicPut("1trf.pic",pic_transformed);
}
else
{
mitkIpPicDescriptor *doubleSlice = mitkIpPicCopyHeader( timeSelectorPic , NULL);
doubleSlice->dim=3;
doubleSlice->n[2]=2;
doubleSlice->data=malloc(_mitkIpPicSize(doubleSlice));
memcpy(doubleSlice->data, timeSelectorPic->data, _mitkIpPicSize(doubleSlice)/2);
mitkIpPicTypeMultiplex9(_transform, doubleSlice, pic_transformed, m_OutsideValue, (float*)fr_pic->data, (float*)fphi_pic->data, fz, (short *)rt_pic->data, (unsigned int *)phit_pic->data, zt, coneCutOff_pic);
mitkIpPicFree(doubleSlice);
}
output->SetVolume(pic_transformed->data, t, n);
}
}
//mitkIpPicPut("outzzzzzzzz.pic",pic_transformed);
mitkIpPicFree(pic_transformed);
m_TimeOfHeaderInitialization.Modified();
}
mitk::CylindricToCartesianFilter::CylindricToCartesianFilter()
: m_OutsideValue(0.0), m_TargetXSize(0)
{
rt_pic = NULL; phit_pic = NULL; fr_pic = NULL; fphi_pic = NULL; coneCutOff_pic = NULL;
zt = NULL; fz = NULL;
a=b=0.0;
}
mitk::CylindricToCartesianFilter::~CylindricToCartesianFilter()
{
if(rt_pic!=NULL) mitkIpPicFree(rt_pic);
if(phit_pic!=NULL) mitkIpPicFree(phit_pic);
if(fr_pic!=NULL) mitkIpPicFree(fr_pic);
if(fphi_pic!=NULL) mitkIpPicFree(fphi_pic);
if(coneCutOff_pic!=NULL) mitkIpPicFree(coneCutOff_pic);
if(zt != NULL) free(zt);
if(fz != NULL) free (fz);
}
void mitk::CylindricToCartesianFilter::GenerateInputRequestedRegion()
{
Superclass::GenerateInputRequestedRegion();
mitk::ImageToImageFilter::InputImagePointer input =
const_cast< mitk::ImageToImageFilter::InputImageType * > ( this->GetInput() );
mitk::Image::Pointer output = this->GetOutput();
Image::RegionType requestedRegion;
requestedRegion = output->GetRequestedRegion();
requestedRegion.SetIndex(0, 0);
requestedRegion.SetIndex(1, 0);
requestedRegion.SetIndex(2, 0);
requestedRegion.SetSize(0, input->GetDimension(0));
requestedRegion.SetSize(1, input->GetDimension(1));
requestedRegion.SetSize(2, input->GetDimension(2));
input->SetRequestedRegion( & requestedRegion );
}
diff --git a/Modules/MitkExt/Algorithms/mitkLabeledImageToSurfaceFilter.cpp b/Modules/MitkExt/Algorithms/mitkLabeledImageToSurfaceFilter.cpp
index fec0fc43c4..8d40accd49 100644
--- a/Modules/MitkExt/Algorithms/mitkLabeledImageToSurfaceFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkLabeledImageToSurfaceFilter.cpp
@@ -1,365 +1,365 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include <mitkLabeledImageToSurfaceFilter.h>
#include <vtkImageChangeInformation.h>
#include <vtkImageThreshold.h>
#include <vtkImageGaussianSmooth.h>
#include <vtkImageMarchingCubes.h>
#include <vtkPolyData.h>
#include <vtkSmoothPolyDataFilter.h>
#include <vtkDecimatePro.h>
#include <vtkLinearTransform.h>
#include <vtkMatrix4x4.h>
#include <mitkImageAccessByItk.h>
#include <mitkInstantiateAccessFunctions.h>
#include <itkImageRegionIterator.h>
#include <itkNumericTraits.h>
mitk::LabeledImageToSurfaceFilter::LabeledImageToSurfaceFilter() :
m_GaussianStandardDeviation(1.5),
m_GenerateAllLabels(true),
m_Label(1),
m_BackgroundLabel(0)
{
}
mitk::LabeledImageToSurfaceFilter::~LabeledImageToSurfaceFilter()
{
}
void mitk::LabeledImageToSurfaceFilter::GenerateOutputInformation()
{
Superclass::GenerateOutputInformation();
//
// check which labels are available in the image
//
m_AvailableLabels = this->GetAvailableLabels();
m_IdxToLabels.clear();
//
// if we don't want to generate surfaces for all labels
// we have to remove all labels except m_Label and m_BackgroundLabel
// from the list of available labels
//
if ( ! m_GenerateAllLabels )
{
LabelMapType tmp;
LabelMapType::iterator it;
it = m_AvailableLabels.find( m_Label );
if ( it != m_AvailableLabels.end() )
tmp[m_Label] = it->second;
else
tmp[m_Label] = 0;
it = m_AvailableLabels.find( m_BackgroundLabel );
if ( it != m_AvailableLabels.end() )
tmp[m_BackgroundLabel] = it->second;
else
tmp[m_BackgroundLabel] = 0;
m_AvailableLabels = tmp;
}
//
// check for the number of labels: if the whole image is filled, no
// background is available and thus the numberOfOutpus is equal to the
// number of available labels in the image (which is a special case).
// If we have background voxels, the number of outputs is one less than
// then number of available labels.
//
unsigned int numberOfOutputs = 0;
if ( m_AvailableLabels.find( m_BackgroundLabel ) == m_AvailableLabels.end() )
numberOfOutputs = m_AvailableLabels.size();
else
numberOfOutputs = m_AvailableLabels.size() - 1;
if ( numberOfOutputs == 0 )
{
itkWarningMacro("Number of outputs == 0");
}
//
// determine the number of time steps of the input image
//
mitk::Image* image = ( mitk::Image* )GetInput();
- unsigned int numberOfTimeSteps = image->GetTimeGeometry()->GetNumberOfTimeSteps();
+ unsigned int numberOfTimeSteps = image->GetTimeGeometry()->CountTimeSteps();
//
// set the number of outputs to the number of labels used.
// initialize the output surfaces accordingly (incl. time steps)
//
this->SetNumberOfIndexedOutputs( numberOfOutputs );
this->SetNumberOfRequiredOutputs( numberOfOutputs );
for ( unsigned int i = 0 ; i < numberOfOutputs; ++i )
{
if ( ! this->GetOutput( i ) )
{
mitk::Surface::Pointer output = static_cast<mitk::Surface*>( this->MakeOutput(0).GetPointer() );
assert ( output.IsNotNull() );
output->Expand( numberOfTimeSteps );
this->SetNthOutput( i, output.GetPointer() );
}
}
}
void mitk::LabeledImageToSurfaceFilter::GenerateData()
{
mitk::Image* image = ( mitk::Image* )GetInput();
if ( image == NULL )
{
itkWarningMacro("Image is NULL");
return;
}
mitk::Image::RegionType outputRegion = image->GetRequestedRegion();
m_IdxToLabels.clear();
if ( this->GetNumberOfOutputs() == 0 )
return;
//
// traverse the known labels and create surfaces for them.
//
unsigned int currentOutputIndex = 0;
for ( LabelMapType::iterator it = m_AvailableLabels.begin() ; it != m_AvailableLabels.end() ; ++it )
{
if ( it->first == m_BackgroundLabel )
continue;
if ( ( it->second == 0 ) && m_GenerateAllLabels )
continue;
assert ( currentOutputIndex < this->GetNumberOfOutputs() );
mitk::Surface::Pointer surface = this->GetOutput( currentOutputIndex );
assert( surface.IsNotNull() );
int tstart=outputRegion.GetIndex(3);
int tmax=tstart+outputRegion.GetSize(3); //GetSize()==1 - will aber 0 haben, wenn nicht zeitaufgeloet
int t;
for( t=tstart; t < tmax; ++t)
{
vtkImageData *vtkimagedata = image->GetVtkImageData( t );
CreateSurface( t,vtkimagedata,surface.GetPointer(), it->first );
}
m_IdxToLabels[ currentOutputIndex ] = it->first;
currentOutputIndex++;
}
}
void mitk::LabeledImageToSurfaceFilter::CreateSurface( int time, vtkImageData *vtkimage, mitk::Surface * surface, mitk::LabeledImageToSurfaceFilter::LabelType label )
{
vtkImageChangeInformation *indexCoordinatesImageFilter = vtkImageChangeInformation::New();
indexCoordinatesImageFilter->SetInput(vtkimage);
indexCoordinatesImageFilter->SetOutputOrigin(0.0,0.0,0.0);
vtkImageThreshold* threshold = vtkImageThreshold::New();
threshold->SetInput( indexCoordinatesImageFilter->GetOutput() );
//indexCoordinatesImageFilter->Delete();
threshold->SetInValue( 100 );
threshold->SetOutValue( 0 );
threshold->ThresholdBetween( label, label );
threshold->SetOutputScalarTypeToUnsignedChar();
threshold->ReleaseDataFlagOn();
vtkImageGaussianSmooth *gaussian = vtkImageGaussianSmooth::New();
gaussian->SetInput( threshold->GetOutput() );
//threshold->Delete();
gaussian->SetDimensionality( 3 );
gaussian->SetRadiusFactor( 0.49 );
gaussian->SetStandardDeviation( GetGaussianStandardDeviation() );
gaussian->ReleaseDataFlagOn();
gaussian->UpdateInformation();
gaussian->Update();
//MarchingCube -->create Surface
vtkMarchingCubes *skinExtractor = vtkMarchingCubes::New();
skinExtractor->ReleaseDataFlagOn();
skinExtractor->SetInput(gaussian->GetOutput());//RC++
indexCoordinatesImageFilter->Delete();
skinExtractor->SetValue(0, 50);
vtkPolyData *polydata;
polydata = skinExtractor->GetOutput();
polydata->Register(NULL);//RC++
skinExtractor->Delete();
if (m_Smooth)
{
vtkSmoothPolyDataFilter *smoother = vtkSmoothPolyDataFilter::New();
//read poly1 (poly1 can be the original polygon, or the decimated polygon)
smoother->SetInput(polydata);//RC++
smoother->SetNumberOfIterations( m_SmoothIteration );
smoother->SetRelaxationFactor( m_SmoothRelaxation );
smoother->SetFeatureAngle( 60 );
smoother->FeatureEdgeSmoothingOff();
smoother->BoundarySmoothingOff();
smoother->SetConvergence( 0 );
polydata->Delete();//RC--
polydata = smoother->GetOutput();
polydata->Register(NULL);//RC++
smoother->Delete();
}
//decimate = to reduce number of polygons
if(m_Decimate==DecimatePro)
{
vtkDecimatePro *decimate = vtkDecimatePro::New();
decimate->SplittingOff();
decimate->SetErrorIsAbsolute(5);
decimate->SetFeatureAngle(30);
decimate->PreserveTopologyOn();
decimate->BoundaryVertexDeletionOff();
decimate->SetDegree(10); //std-value is 25!
decimate->SetInput(polydata);//RC++
decimate->SetTargetReduction(m_TargetReduction);
decimate->SetMaximumError(0.002);
polydata->Delete();//RC--
polydata = decimate->GetOutput();
polydata->Register(NULL);//RC++
decimate->Delete();
}
polydata->Update();
polydata->SetSource(NULL);
if(polydata->GetNumberOfPoints() > 0)
{
mitk::Vector3D spacing = GetInput()->GetGeometry(time)->GetSpacing();
vtkPoints * points = polydata->GetPoints();
vtkMatrix4x4 *vtkmatrix = vtkMatrix4x4::New();
GetInput()->GetGeometry(time)->GetVtkTransform()->GetMatrix(vtkmatrix);
double (*matrix)[4] = vtkmatrix->Element;
unsigned int i,j;
for(i=0;i<3;++i)
for(j=0;j<3;++j)
matrix[i][j]/=spacing[j];
unsigned int n = points->GetNumberOfPoints();
vtkFloatingPointType point[3];
for (i = 0; i < n; i++)
{
points->GetPoint(i, point);
mitkVtkLinearTransformPoint(matrix,point,point);
points->SetPoint(i, point);
}
vtkmatrix->Delete();
}
surface->SetVtkPolyData(polydata, time);
polydata->UnRegister(NULL);
gaussian->Delete();
threshold->Delete();
}
template < typename TPixel, unsigned int VImageDimension >
void GetAvailableLabelsInternal( itk::Image<TPixel, VImageDimension>* image, mitk::LabeledImageToSurfaceFilter::LabelMapType& availableLabels )
{
typedef itk::Image<TPixel, VImageDimension> ImageType;
typedef itk::ImageRegionIterator< ImageType > ImageRegionIteratorType;
availableLabels.clear();
ImageRegionIteratorType it( image, image->GetLargestPossibleRegion() );
it.GoToBegin();
mitk::LabeledImageToSurfaceFilter::LabelMapType::iterator labelIt;
while( ! it.IsAtEnd() )
{
labelIt = availableLabels.find( ( mitk::LabeledImageToSurfaceFilter::LabelType ) ( it.Get() ) );
if ( labelIt == availableLabels.end() )
{
availableLabels[ ( mitk::LabeledImageToSurfaceFilter::LabelType ) ( it.Get() ) ] = 1;
}
else
{
labelIt->second += 1;
}
++it;
}
}
#define InstantiateAccessFunction_GetAvailableLabelsInternal(pixelType, dim) \
template void GetAvailableLabelsInternal(itk::Image<pixelType, dim>*, mitk::LabeledImageToSurfaceFilter::LabelMapType&);
InstantiateAccessFunctionForFixedDimension(GetAvailableLabelsInternal, 3);
mitk::LabeledImageToSurfaceFilter::LabelMapType mitk::LabeledImageToSurfaceFilter::GetAvailableLabels()
{
mitk::Image::Pointer image = ( mitk::Image* )GetInput();
LabelMapType availableLabels;
AccessFixedDimensionByItk_1( image, GetAvailableLabelsInternal, 3, availableLabels );
return availableLabels;
}
void mitk::LabeledImageToSurfaceFilter::CreateSurface(int, vtkImageData*, mitk::Surface*, const ScalarType)
{
itkWarningMacro( "This function should never be called!" );
assert(false);
}
mitk::LabeledImageToSurfaceFilter::LabelType mitk::LabeledImageToSurfaceFilter::GetLabelForNthOutput( const unsigned int& idx )
{
IdxToLabelMapType::iterator it = m_IdxToLabels.find( idx );
if ( it != m_IdxToLabels.end() )
{
return it->second;
}
else
{
itkWarningMacro( "Unknown index encountered: " << idx << ". There are " << this->GetNumberOfOutputs() << " outputs available." );
return itk::NumericTraits<LabelType>::max();
}
}
mitk::ScalarType mitk::LabeledImageToSurfaceFilter::GetVolumeForNthOutput( const unsigned int& i )
{
return GetVolumeForLabel( GetLabelForNthOutput( i ) );
}
mitk::ScalarType mitk::LabeledImageToSurfaceFilter::GetVolumeForLabel( const mitk::LabeledImageToSurfaceFilter::LabelType& label )
{
// get the image spacing
mitk::Image* image = ( mitk::Image* )GetInput();
const float* spacing = image->GetSlicedGeometry()->GetFloatSpacing();
// get the number of voxels encountered for the given label,
// calculate the volume and return it.
LabelMapType::iterator it = m_AvailableLabels.find( label );
if ( it != m_AvailableLabels.end() )
{
return static_cast<float>(it->second) * ( spacing[0] * spacing[1] * spacing[2] / 1000.0f );
}
else
{
itkWarningMacro( "Unknown label encountered: " << label );
return 0.0;
}
}
diff --git a/Modules/MitkExt/Algorithms/mitkMaskImageFilter.cpp b/Modules/MitkExt/Algorithms/mitkMaskImageFilter.cpp
index fc1d7c0e88..049ce49b18 100644
--- a/Modules/MitkExt/Algorithms/mitkMaskImageFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkMaskImageFilter.cpp
@@ -1,185 +1,185 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkMaskImageFilter.h"
#include "mitkImageTimeSelector.h"
#include "mitkTimeHelper.h"
#include "mitkProperties.h"
#include "mitkImageToItk.h"
#include "mitkImageAccessByItk.h"
#include "itkImageRegionConstIterator.h"
#include "itkImageRegionIteratorWithIndex.h"
#include <limits>
mitk::MaskImageFilter::MaskImageFilter() : m_Mask(NULL)
{
this->SetNumberOfIndexedInputs(2);
this->SetNumberOfRequiredInputs(2);
m_InputTimeSelector = mitk::ImageTimeSelector::New();
m_MaskTimeSelector = mitk::ImageTimeSelector::New();
m_OutputTimeSelector = mitk::ImageTimeSelector::New();
m_OverrideOutsideValue = false;
m_OutsideValue = 0;
}
mitk::MaskImageFilter::~MaskImageFilter()
{
}
void mitk::MaskImageFilter::SetMask( const mitk::Image* mask )
{
// Process object is not const-correct so the const_cast is required here
m_Mask = const_cast< mitk::Image * >( mask );
this->ProcessObject::SetNthInput(1, m_Mask );
}
const mitk::Image* mitk::MaskImageFilter::GetMask() const
{
return m_Mask;
}
void mitk::MaskImageFilter::GenerateInputRequestedRegion()
{
Superclass::GenerateInputRequestedRegion();
mitk::Image* output = this->GetOutput();
mitk::Image* input = const_cast< mitk::Image * > ( this->GetInput() );
mitk::Image* mask = m_Mask ;
- if((output->IsInitialized()==false) || (mask == NULL) || (mask->GetTimeGeometry()->GetNumberOfTimeSteps() == 0))
+ if((output->IsInitialized()==false) || (mask == NULL) || (mask->GetTimeGeometry()->CountTimeSteps() == 0))
return;
input->SetRequestedRegionToLargestPossibleRegion();
mask->SetRequestedRegionToLargestPossibleRegion();
GenerateTimeInInputRegion(output, input);
GenerateTimeInInputRegion(output, mask);
}
void mitk::MaskImageFilter::GenerateOutputInformation()
{
mitk::Image::ConstPointer input = this->GetInput();
mitk::Image::Pointer output = this->GetOutput();
if ((output->IsInitialized()) && (this->GetMTime() <= m_TimeOfHeaderInitialization.GetMTime()))
return;
itkDebugMacro(<<"GenerateOutputInformation()");
output->Initialize(input->GetPixelType(), *input->GetTimeGeometry());
output->SetPropertyList(input->GetPropertyList()->Clone());
m_TimeOfHeaderInitialization.Modified();
}
template < typename TPixel, unsigned int VImageDimension >
void mitk::MaskImageFilter::InternalComputeMask(itk::Image<TPixel, VImageDimension>* inputItkImage)
{
typedef itk::Image<TPixel, VImageDimension> ItkInputImageType;
typedef itk::Image<unsigned char, VImageDimension> ItkMaskImageType;
typedef itk::Image<TPixel, VImageDimension> ItkOutputImageType;
typedef itk::ImageRegionConstIterator< ItkInputImageType > ItkInputImageIteratorType;
typedef itk::ImageRegionConstIterator< ItkMaskImageType > ItkMaskImageIteratorType;
typedef itk::ImageRegionIteratorWithIndex< ItkOutputImageType > ItkOutputImageIteratorType;
typename mitk::ImageToItk<ItkMaskImageType>::Pointer maskimagetoitk = mitk::ImageToItk<ItkMaskImageType>::New();
maskimagetoitk->SetInput(m_MaskTimeSelector->GetOutput());
maskimagetoitk->Update();
typename ItkMaskImageType::Pointer maskItkImage = maskimagetoitk->GetOutput();
typename mitk::ImageToItk<ItkOutputImageType>::Pointer outputimagetoitk = mitk::ImageToItk<ItkOutputImageType>::New();
outputimagetoitk->SetInput(m_OutputTimeSelector->GetOutput());
outputimagetoitk->Update();
typename ItkOutputImageType::Pointer outputItkImage = outputimagetoitk->GetOutput();
// create the iterators
typename ItkInputImageType::RegionType inputRegionOfInterest = inputItkImage->GetLargestPossibleRegion();
ItkInputImageIteratorType inputIt( inputItkImage, inputRegionOfInterest );
ItkMaskImageIteratorType maskIt ( maskItkImage, inputRegionOfInterest );
ItkOutputImageIteratorType outputIt( outputItkImage, inputRegionOfInterest );
//typename ItkOutputImageType::PixelType outsideValue = itk::NumericTraits<typename ItkOutputImageType::PixelType>::min();
if ( !m_OverrideOutsideValue )
m_OutsideValue = itk::NumericTraits<typename ItkOutputImageType::PixelType>::min();
m_MinValue = std::numeric_limits<mitk::ScalarType>::max();
m_MaxValue = std::numeric_limits<mitk::ScalarType>::min();
for ( inputIt.GoToBegin(), maskIt.GoToBegin(), outputIt.GoToBegin(); !inputIt.IsAtEnd() && !maskIt.IsAtEnd(); ++inputIt, ++maskIt, ++outputIt)
{
if ( maskIt.Get() > itk::NumericTraits<typename ItkMaskImageType::PixelType>::Zero )
{
outputIt.Set(inputIt.Get());
m_MinValue = vnl_math_min((float)inputIt.Get(), (float)m_MinValue);
m_MaxValue = vnl_math_max((float)inputIt.Get(), (float)m_MaxValue);
}
else
{
outputIt.Set(m_OutsideValue);
}
}
}
void mitk::MaskImageFilter::GenerateData()
{
mitk::Image::ConstPointer input = this->GetInput();
mitk::Image::Pointer mask = m_Mask;
mitk::Image::Pointer output = this->GetOutput();
- if((output->IsInitialized()==false) || (mask.IsNull()) || (mask->GetTimeGeometry()->GetNumberOfTimeSteps() == 0))
+ if((output->IsInitialized()==false) || (mask.IsNull()) || (mask->GetTimeGeometry()->CountTimeSteps() == 0))
return;
m_InputTimeSelector->SetInput(input);
m_MaskTimeSelector->SetInput(mask);
m_OutputTimeSelector->SetInput(this->GetOutput());
mitk::Image::RegionType outputRegion = output->GetRequestedRegion();
const mitk::TimeGeometry *outputTimeGeometry = output->GetTimeGeometry();
const mitk::TimeGeometry *inputTimeGeometry = input->GetTimeGeometry();
const mitk::TimeGeometry *maskTimeGeometry = mask->GetTimeGeometry();
ScalarType timeInMS;
int timestep=0;
int tstart=outputRegion.GetIndex(3);
int tmax=tstart+outputRegion.GetSize(3);
int t;
for(t=tstart;t<tmax;++t)
{
timeInMS = outputTimeGeometry->TimeStepToTimePoint( t );
timestep = inputTimeGeometry->TimePointToTimeStep( timeInMS );
m_InputTimeSelector->SetTimeNr(timestep);
m_InputTimeSelector->UpdateLargestPossibleRegion();
m_OutputTimeSelector->SetTimeNr(t);
m_OutputTimeSelector->UpdateLargestPossibleRegion();
timestep = maskTimeGeometry->TimePointToTimeStep( timeInMS );
m_MaskTimeSelector->SetTimeNr(timestep);
m_MaskTimeSelector->UpdateLargestPossibleRegion();
AccessByItk(m_InputTimeSelector->GetOutput(),InternalComputeMask);
}
m_TimeOfHeaderInitialization.Modified();
}
diff --git a/Modules/MitkExt/Algorithms/mitkPlaneFit.cpp b/Modules/MitkExt/Algorithms/mitkPlaneFit.cpp
index ad2239fabf..cba794f3e0 100644
--- a/Modules/MitkExt/Algorithms/mitkPlaneFit.cpp
+++ b/Modules/MitkExt/Algorithms/mitkPlaneFit.cpp
@@ -1,205 +1,205 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPlaneFit.h"
#include "mitkPlaneGeometry.h"
#include "mitkGeometryData.h"
#include <mitkProportionalTimeGeometry.h>
#include <vnl/algo/vnl_svd.h>
#include <vcl_iostream.h>
mitk::PlaneFit::PlaneFit()
: m_PointSet( NULL )
{
m_TimeGeometry = mitk::ProportionalTimeGeometry::New();
}
mitk::PlaneFit::~PlaneFit()
{
}
void mitk::PlaneFit::GenerateOutputInformation()
{
mitk::PointSet::ConstPointer input = this->GetInput();
mitk::GeometryData::Pointer output = this->GetOutput();
itkDebugMacro(<<"GenerateOutputInformation()");
if (input.IsNull()) return;
if ( m_PointSet == NULL )
{
return;
}
bool update = false;
if ( output->GetGeometry() == NULL || output->GetTimeGeometry() == NULL )
update = true;
- if ( ( ! update ) && ( output->GetTimeGeometry()->GetNumberOfTimeSteps() != input->GetTimeGeometry()->GetNumberOfTimeSteps() ) )
+ if ( ( ! update ) && ( output->GetTimeGeometry()->CountTimeSteps() != input->GetTimeGeometry()->CountTimeSteps() ) )
update = true;
if ( update )
{
mitk::PlaneGeometry::Pointer planeGeometry = mitk::PlaneGeometry::New();
ProportionalTimeGeometry::Pointer timeGeometry = dynamic_cast<ProportionalTimeGeometry *>(m_TimeGeometry.GetPointer());
timeGeometry->Initialize(planeGeometry, m_PointSet->GetPointSetSeriesSize());
//m_TimeGeometry->InitializeEvenlyTimed(
// planeGeometry, m_PointSet->GetPointSetSeriesSize() );
TimeStepType timeStep;
for ( timeStep = 0;
(timeStep < m_PointSet->GetPointSetSeriesSize())
&& (timeStep < m_Planes.size());
++timeStep )
{
timeGeometry->SetTimeStepGeometry( m_Planes[timeStep], timeStep );
}
output->SetTimeGeometry( m_TimeGeometry );
}
}
void mitk::PlaneFit::GenerateData()
{
unsigned int t;
for ( t = 0; t < m_PointSet->GetPointSetSeriesSize(); ++t )
{
// check number of data points - less then 3points isn't enough
if ( m_PointSet->GetSize( t ) >= 3 )
{
this->CalculateCentroid( t );
this->ProcessPointSet( t );
this->InitializePlane( t );
}
}
}
void mitk::PlaneFit::SetInput( const mitk::PointSet* pointSet )
{
// Process object is not const-correct so the const_cast is required here
this->ProcessObject::SetNthInput(0,
const_cast< mitk::PointSet * >( pointSet ) );
m_PointSet = pointSet;
unsigned int pointSetSize = pointSet->GetPointSetSeriesSize();
m_Planes.resize( pointSetSize );
m_Centroids.resize( pointSetSize );
m_PlaneVectors.resize( pointSetSize );
unsigned int t;
for ( t = 0; t < pointSetSize; ++t )
{
m_Planes[t] = mitk::PlaneGeometry::New();
}
}
const mitk::PointSet* mitk::PlaneFit::GetInput()
{
if (this->GetNumberOfInputs() < 1)
{
return 0;
}
return static_cast<const mitk::PointSet * > (this->ProcessObject::GetInput(0) );
}
void mitk::PlaneFit::CalculateCentroid( int t )
{
if ( m_PointSet == NULL ) return;
int ps_total = m_PointSet->GetSize( t );
m_Centroids[t][0] = m_Centroids[t][1] = m_Centroids[t][2] = 0.0;
for (int i=0; i<ps_total; i++)
{
mitk::Point3D p3d = m_PointSet->GetPoint(i,t);
m_Centroids[t][0] += p3d[0];
m_Centroids[t][1] += p3d[1];
m_Centroids[t][2] += p3d[2];
}
// calculation of centroid
m_Centroids[t][0] /= ps_total;
m_Centroids[t][1] /= ps_total;
m_Centroids[t][2] /= ps_total;
}
void mitk::PlaneFit::ProcessPointSet( int t )
{
if (m_PointSet == NULL ) return;
// int matrix with POINTS x (X,Y,Z)
vnl_matrix<mitk::ScalarType> dataM( m_PointSet->GetSize( t ), 3);
int ps_total = m_PointSet->GetSize( t );
for (int i=0; i<ps_total; i++)
{
mitk::Point3D p3d = m_PointSet->GetPoint(i,t);
dataM[i][0] = p3d[0] - m_Centroids[t][0];
dataM[i][1] = p3d[1] - m_Centroids[t][1];
dataM[i][2] = p3d[2] - m_Centroids[t][2];
}
// process the SVD (singular value decomposition) from ITK
// the vector will be orderd descending
vnl_svd<mitk::ScalarType> svd(dataM, 0.0);
// calculate the SVD of A
vnl_vector<mitk::ScalarType> v = svd.nullvector();
// Avoid erratic normal sign switching when the plane changes minimally
// by negating the vector for negative x values.
if ( v[0] < 0 )
{
v = -v;
}
m_PlaneVectors[t][0] = v[0];
m_PlaneVectors[t][1] = v[1];
m_PlaneVectors[t][2] = v[2];
}
mitk::PlaneGeometry::Pointer mitk::PlaneFit::GetPlaneGeometry( int t )
{
return m_Planes[t];
}
const mitk::Vector3D &mitk::PlaneFit::GetPlaneNormal( int t ) const
{
return m_PlaneVectors[t];
}
const mitk::Point3D &mitk::PlaneFit::GetCentroid( int t ) const
{
return m_Centroids[t];
}
void mitk::PlaneFit::InitializePlane( int t )
{
m_Planes[t]->InitializePlane( m_Centroids[t], m_PlaneVectors[t] );
}
diff --git a/Modules/MitkExt/Algorithms/mitkPointSetToCurvedGeometryFilter.cpp b/Modules/MitkExt/Algorithms/mitkPointSetToCurvedGeometryFilter.cpp
index ed60e81010..a753331438 100644
--- a/Modules/MitkExt/Algorithms/mitkPointSetToCurvedGeometryFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkPointSetToCurvedGeometryFilter.cpp
@@ -1,165 +1,165 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPointSetToCurvedGeometryFilter.h"
#include "mitkThinPlateSplineCurvedGeometry.h"
#include "mitkPlaneGeometry.h"
#include "mitkImage.h"
#include "mitkDataNode.h"
#include "mitkGeometryData.h"
#include "mitkGeometry2DData.h"
#include "mitkProperties.h"
#include "itkMesh.h"
#include "itkPointSet.h"
mitk::PointSetToCurvedGeometryFilter::PointSetToCurvedGeometryFilter()
{
m_ProjectionMode = YZPlane;
m_PCAPlaneCalculator = mitk::PlaneFit::New();
m_ImageToBeMapped = NULL;
m_Sigma = 1000;
mitk::Geometry2DData::Pointer output = static_cast<mitk::Geometry2DData*> ( this->MakeOutput ( 0 ).GetPointer() );
output->Initialize();
Superclass::SetNumberOfRequiredOutputs ( 1 );
Superclass::SetNthOutput ( 0, output.GetPointer() );
}
mitk::PointSetToCurvedGeometryFilter::~PointSetToCurvedGeometryFilter()
{}
void mitk::PointSetToCurvedGeometryFilter::GenerateOutputInformation()
{
mitk::PointSet::ConstPointer input = this->GetInput();
mitk::Geometry2DData::Pointer output = dynamic_cast<mitk::Geometry2DData*> ( this->GetOutput() );
if ( input.IsNull() )
itkGenericExceptionMacro ( "Input point set is NULL!" );
- if ( input->GetTimeGeometry()->GetNumberOfTimeSteps() != 1 )
+ if ( input->GetTimeGeometry()->CountTimeSteps() != 1 )
itkWarningMacro ( "More than one time step is not yet supported!" );
if ( output.IsNull() )
itkGenericExceptionMacro ( "Output is NULL!" );
if ( m_ImageToBeMapped.IsNull() )
itkGenericExceptionMacro ( "Image to be mapped is NULL!" );
bool update = false;
if ( output->GetGeometry() == NULL || output->GetGeometry2D() == NULL || output->GetTimeGeometry() == NULL )
update = true;
- if ( ( ! update ) && ( output->GetTimeGeometry()->GetNumberOfTimeSteps() != input->GetTimeGeometry()->GetNumberOfTimeSteps() ) )
+ if ( ( ! update ) && ( output->GetTimeGeometry()->CountTimeSteps() != input->GetTimeGeometry()->CountTimeSteps() ) )
update = true;
if ( update )
{
mitk::ThinPlateSplineCurvedGeometry::Pointer curvedGeometry = mitk::ThinPlateSplineCurvedGeometry::New();
output->SetGeometry(curvedGeometry);
}
}
void mitk::PointSetToCurvedGeometryFilter::GenerateData()
{
mitk::PointSet::ConstPointer input = this->GetInput();
mitk::GeometryData::Pointer output = this->GetOutput();
//
// check preconditions
//
if ( input.IsNull() )
itkGenericExceptionMacro ( "Input point set is NULL!" );
if ( output.IsNull() )
itkGenericExceptionMacro ( "output geometry data is NULL!" );
if ( output->GetTimeGeometry() == NULL )
itkGenericExceptionMacro ( "Output time sliced geometry is NULL!" );
if ( output->GetTimeGeometry()->GetGeometryForTimeStep ( 0 ).IsNull() )
itkGenericExceptionMacro ( "Output geometry3d is NULL!" );
mitk::ThinPlateSplineCurvedGeometry::Pointer curvedGeometry = dynamic_cast<mitk::ThinPlateSplineCurvedGeometry*> ( output->GetTimeGeometry()->GetGeometryForTimeStep( 0 ).GetPointer() );
if ( curvedGeometry.IsNull() )
itkGenericExceptionMacro ( "Output geometry3d is not an instance of mitk::ThinPlateSPlineCurvedGeometry!" );
if ( m_ImageToBeMapped.IsNull() )
itkGenericExceptionMacro ( "Image to be mapped is NULL!" );
//
// initialize members if needed
//
if ( m_XYPlane.IsNull() || m_XZPlane.IsNull() || m_YZPlane.IsNull() )
{
m_ImageToBeMapped->UpdateOutputInformation();
const mitk::Geometry3D* imageGeometry = m_ImageToBeMapped->GetUpdatedGeometry();
imageGeometry = m_ImageToBeMapped->GetUpdatedGeometry();
m_XYPlane = mitk::PlaneGeometry::New();
m_XZPlane = mitk::PlaneGeometry::New();
m_YZPlane = mitk::PlaneGeometry::New();
m_XYPlane->InitializeStandardPlane ( imageGeometry, mitk::PlaneGeometry::Axial );
m_YZPlane->InitializeStandardPlane ( imageGeometry, mitk::PlaneGeometry::Sagittal );
m_XZPlane->InitializeStandardPlane ( imageGeometry, mitk::PlaneGeometry::Frontal );
}
if ( m_PlaneLandmarkProjector.IsNull() )
{
m_PlaneLandmarkProjector = mitk::PlaneLandmarkProjector::New();
m_SphereLandmarkProjector = mitk::SphereLandmarkProjector::New();
}
//
// set up geometry according to the current settings
//
if ( m_ProjectionMode == Sphere )
{
curvedGeometry->SetLandmarkProjector ( m_SphereLandmarkProjector );
}
else
{
if ( m_ProjectionMode == XYPlane )
m_PlaneLandmarkProjector->SetProjectionPlane ( m_XYPlane );
else if ( m_ProjectionMode == XZPlane )
m_PlaneLandmarkProjector->SetProjectionPlane ( m_XZPlane );
else if ( m_ProjectionMode == YZPlane )
m_PlaneLandmarkProjector->SetProjectionPlane ( m_YZPlane );
else if ( m_ProjectionMode == PCAPlane )
{
itkExceptionMacro ( "PCAPlane not yet implemented!" );
m_PCAPlaneCalculator->SetInput ( input );
m_PCAPlaneCalculator->Update();
m_PlaneLandmarkProjector->SetProjectionPlane ( dynamic_cast<mitk::PlaneGeometry*> ( m_PCAPlaneCalculator->GetOutput() ) );
}
else
itkExceptionMacro ( "Unknown projection mode" );
curvedGeometry->SetLandmarkProjector ( m_PlaneLandmarkProjector );
}
//curvedGeometry->SetReferenceGeometry( m_ImageToBeMapped->GetGeometry() );
curvedGeometry->SetTargetLandmarks ( input->GetPointSet ( 0 )->GetPoints() );
curvedGeometry->SetSigma ( m_Sigma );
curvedGeometry->ComputeGeometry();
curvedGeometry->SetOversampling ( 1.0 );
}
void mitk::PointSetToCurvedGeometryFilter::SetDefaultCurvedGeometryProperties ( mitk::DataNode* node )
{
if ( node == NULL )
{
itkGenericOutputMacro ( "Warning: node is NULL!" );
return;
}
node->SetIntProperty ( "xresolution", 50 );
node->SetIntProperty ( "yresolution", 50 );
node->SetProperty ( "name", mitk::StringProperty::New ( "Curved Plane" ) );
// exclude extent of this plane when calculating DataStorage bounding box
node->SetProperty ( "includeInBoundingBox", mitk::BoolProperty::New ( false ) );
}
diff --git a/Modules/MitkExt/Algorithms/mitkProbeFilter.cpp b/Modules/MitkExt/Algorithms/mitkProbeFilter.cpp
index 766bcb0654..d0285c3e23 100644
--- a/Modules/MitkExt/Algorithms/mitkProbeFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkProbeFilter.cpp
@@ -1,214 +1,214 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkProbeFilter.h"
#include "mitkSurface.h"
#include "mitkImage.h"
#include <vtkPolyDataSource.h>
#include <vtkProbeFilter.h>
#include <itkImageRegion.h>
#include <vtkDataSet.h>
#include <vtkPolyData.h>
#include <vtkImageData.h>
mitk::ProbeFilter::ProbeFilter()
{
}
mitk::ProbeFilter::~ProbeFilter()
{
}
const mitk::Surface *mitk::ProbeFilter::GetInput(void)
{
if (this->GetNumberOfInputs() < 1)
{
return 0;
}
return static_cast< const mitk::Surface * >(this->ProcessObject::GetInput(0) );
}
const mitk::Image *mitk::ProbeFilter::GetSource(void)
{
return static_cast< const mitk::Image * >(this->ProcessObject::GetInput(1));
}
void mitk::ProbeFilter::SetInput(const mitk::Surface *input)
{
this->ProcessObject::SetNthInput( 0, const_cast< mitk::Surface * >( input ) );
}
void mitk::ProbeFilter::SetSource(const mitk::Image *source)
{
this->ProcessObject::SetNthInput( 1, const_cast< mitk::Image * >( source ) );
}
void mitk::ProbeFilter::GenerateOutputInformation()
{
mitk::Surface::ConstPointer input = this->GetInput();
mitk::Image::ConstPointer source = this->GetSource();
mitk::Surface::Pointer output = this->GetOutput();
if(input.IsNull()) return;
if(source.IsNull()) return;
if(input->GetGeometry()==NULL) return;
if(source->GetGeometry()==NULL) return;
- if( (input->GetTimeGeometry()->GetNumberOfTimeSteps()==1) && (source->GetTimeGeometry()->GetNumberOfTimeSteps()>1) )
+ if( (input->GetTimeGeometry()->CountTimeSteps()==1) && (source->GetTimeGeometry()->CountTimeSteps()>1) )
{
Geometry3D::Pointer geometry3D = Geometry3D::New();
geometry3D->Initialize();
geometry3D->SetBounds(source->GetTimeGeometry()->GetBoundsInWorld());
geometry3D->SetTimeBounds(source->GetTimeGeometry()->GetGeometryForTimeStep(0)->GetTimeBounds());
ProportionalTimeGeometry::Pointer outputTimeGeometry = ProportionalTimeGeometry::New();
- outputTimeGeometry->Initialize(geometry3D, source->GetTimeGeometry()->GetNumberOfTimeSteps());
+ outputTimeGeometry->Initialize(geometry3D, source->GetTimeGeometry()->CountTimeSteps());
- output->Expand(outputTimeGeometry->GetNumberOfTimeSteps());
+ output->Expand(outputTimeGeometry->CountTimeSteps());
output->SetTimeGeometry( outputTimeGeometry );
}
else
output->SetGeometry( static_cast<Geometry3D*>(input->GetGeometry()->Clone().GetPointer()) );
itkDebugMacro(<<"GenerateOutputInformation()");
}
void mitk::ProbeFilter::GenerateData()
{
mitk::Surface *input = const_cast< mitk::Surface * >(this->GetInput());
mitk::Image *source = const_cast< mitk::Image * >(this->GetSource());
mitk::Surface::Pointer output = this->GetOutput();
itkDebugMacro(<<"Generating Data");
if(output.IsNull())
{
itkDebugMacro(<<"Output is NULL.");
return;
}
mitk::Surface::RegionType outputRegion = output->GetRequestedRegion();
const TimeGeometry *outputTimeGeometry = output->GetTimeGeometry();
const TimeGeometry *inputTimeGeometry = input->GetTimeGeometry();
const TimeGeometry *sourceTimeGeometry = source->GetTimeGeometry();
TimePointType timeInMS;
int timestep=0;
int tstart, tmax;
tstart=outputRegion.GetIndex(3);
tmax=tstart+outputRegion.GetSize(3);
int t;
for(t=tstart;t<tmax;++t)
{
timeInMS = outputTimeGeometry->TimeStepToTimePoint( t );
vtkProbeFilter* probe = vtkProbeFilter::New();
timestep = inputTimeGeometry->TimePointToTimeStep( timeInMS );
probe->SetInput( input->GetVtkPolyData(timestep) );
timestep = sourceTimeGeometry->TimePointToTimeStep( timeInMS );
probe->SetSource( source->GetVtkImageData(timestep) );
output->SetVtkPolyData( probe->GetPolyDataOutput(), t );
probe->Update();
probe->Delete();
}
}
void mitk::ProbeFilter::GenerateInputRequestedRegion()
{
Superclass::GenerateInputRequestedRegion();
mitk::Surface *input = const_cast< mitk::Surface * >( this->GetInput() );
mitk::Image *source = const_cast< mitk::Image * >( this->GetSource() );
if(input==NULL) return;
if(source==NULL) return;
mitk::Surface::Pointer output = this->GetOutput();
mitk::Surface::RegionType outputRegion = output->GetRequestedRegion();
const TimeGeometry *outputTimeGeometry = output->GetTimeGeometry();
mitk::Surface::RegionType inputSurfaceRegion = outputRegion;
Image::RegionType sourceImageRegion = source->GetLargestPossibleRegion();
if(outputRegion.GetSize(3)<1)
{
mitk::Surface::RegionType::SizeType surfacesize;
surfacesize.Fill(0);
inputSurfaceRegion.SetSize(surfacesize);
input->SetRequestedRegion( &inputSurfaceRegion );
mitk::Image::RegionType::SizeType imagesize;
imagesize.Fill(0);
sourceImageRegion.SetSize(imagesize);
source->SetRequestedRegion( &sourceImageRegion );
return;
}
//create and set input requested region for the input surface
const TimeGeometry *inputTimeGeometry = input->GetTimeGeometry();
ScalarType timeInMS;
int timestep=0;
// convert the start-index-time of output in start-index-time of input via millisecond-time
timeInMS = outputTimeGeometry->TimeStepToTimePoint(outputRegion.GetIndex(3));
timestep = inputTimeGeometry->TimePointToTimeStep( timeInMS );
if( ( timeInMS > ScalarTypeNumericTraits::NonpositiveMin() ) && ( inputTimeGeometry->IsValidTimeStep( timestep ) ) )
inputSurfaceRegion.SetIndex( 3, timestep );
else
inputSurfaceRegion.SetIndex( 3, 0 );
// convert the end-index-time of output in end-index-time of input via millisecond-time
timeInMS = outputTimeGeometry->TimeStepToTimePoint(outputRegion.GetIndex(3)+outputRegion.GetSize(3)-1);
timestep = inputTimeGeometry->TimePointToTimeStep( timeInMS );
if( ( timeInMS > ScalarTypeNumericTraits::NonpositiveMin() ) && ( outputTimeGeometry->IsValidTimeStep( timestep ) ) )
inputSurfaceRegion.SetSize( 3, timestep - inputSurfaceRegion.GetIndex(3) + 1 );
else
inputSurfaceRegion.SetSize( 3, 1 );
input->SetRequestedRegion( &inputSurfaceRegion );
//create and set input requested region for the source image
const TimeGeometry *sourceTimeGeometry = source->GetTimeGeometry();
// convert the start-index-time of output in start-index-time of source via millisecond-time
timeInMS = outputTimeGeometry->TimeStepToTimePoint(outputRegion.GetIndex(3));
timestep = sourceTimeGeometry->TimePointToTimeStep( timeInMS );
if( ( timeInMS > ScalarTypeNumericTraits::NonpositiveMin() ) && ( sourceTimeGeometry->IsValidTimeStep( timestep ) ) )
sourceImageRegion.SetIndex( 3, timestep );
else
sourceImageRegion.SetIndex( 3, 0 );
// convert the end-index-time of output in end-index-time of source via millisecond-time
timeInMS = outputTimeGeometry->TimeStepToTimePoint(outputRegion.GetIndex(3)+outputRegion.GetSize(3)-1);
timestep = sourceTimeGeometry->TimePointToTimeStep( timeInMS );
if( ( timeInMS > ScalarTypeNumericTraits::NonpositiveMin() ) && ( outputTimeGeometry->IsValidTimeStep( timestep ) ) )
sourceImageRegion.SetSize( 3, timestep - sourceImageRegion.GetIndex(3) + 1 );
else
sourceImageRegion.SetSize( 3, 1 );
sourceImageRegion.SetIndex( 4, 0 );
sourceImageRegion.SetSize( 4, 1 );
source->SetRequestedRegion( &sourceImageRegion );
}
diff --git a/Modules/MitkExt/DataManagement/mitkBoundingObjectGroup.cpp b/Modules/MitkExt/DataManagement/mitkBoundingObjectGroup.cpp
index 34db104cb4..d274470911 100644
--- a/Modules/MitkExt/DataManagement/mitkBoundingObjectGroup.cpp
+++ b/Modules/MitkExt/DataManagement/mitkBoundingObjectGroup.cpp
@@ -1,208 +1,208 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkBoundingObjectGroup.h"
#include "mitkBaseProcess.h"
#include <vtkLinearTransform.h>
#include <mitkProportionalTimeGeometry.h>
mitk::BoundingObjectGroup::BoundingObjectGroup()
:m_BoundingObjects(0),
m_Counter(0),
m_CSGMode(Union)// m_CSGMode(Difference) //m_CSGMode(Intersection)
{
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
timeGeometry->Initialize(1);
SetTimeGeometry(timeGeometry);
SetVtkPolyData(NULL);
}
mitk::BoundingObjectGroup::~BoundingObjectGroup()
{
}
void mitk::BoundingObjectGroup::UpdateOutputInformation()
{
if ( this->GetSource() )
{
this->GetSource()->UpdateOutputInformation();
}
// calculate global bounding box
if(m_BoundingObjects.size() < 1 ) // if there is no BoundingObject, the bounding box is zero
{
mitk::BoundingBox::BoundsArrayType boundsArray;
boundsArray.Fill(0);
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
timeGeometry->Initialize(1);
SetTimeGeometry(timeGeometry);
GetGeometry()->SetBounds(boundsArray);
GetTimeGeometry()->Update();
return;
}
// initialize container
mitk::BoundingBox::PointsContainer::Pointer pointscontainer=mitk::BoundingBox::PointsContainer::New();
mitk::BoundingBox::PointIdentifier pointid=0;
mitk::Point3D point;
mitk::AffineTransform3D* transform = GetGeometry()->GetIndexToWorldTransform();
mitk::AffineTransform3D::Pointer inverse = mitk::AffineTransform3D::New();
transform->GetInverse(inverse);
// calculate a bounding box that includes all BoundingObjects
// \todo probably we should do this additionally for each time-step
//while (boundingObjectsIterator != boundingObjectsIteratorEnd)
for(unsigned int j = 0; j<m_BoundingObjects.size();j++)
{
const TimeGeometry* geometry = m_BoundingObjects.at(j)->GetUpdatedTimeGeometry();
unsigned char i;
for(i=0; i<8; ++i)
{
point = inverse->TransformPoint(geometry->GetCornerPointInWorld(i));
if(point[0]*point[0]+point[1]*point[1]+point[2]*point[2] < mitk::large)
pointscontainer->InsertElement( pointid++, point);
else
{
itkGenericOutputMacro( << "Unrealistically distant corner point encountered. Ignored. BoundingObject: " << m_BoundingObjects.at(j) );
}
}
}
mitk::BoundingBox::Pointer boundingBox = mitk::BoundingBox::New();
boundingBox->SetPoints(pointscontainer);
boundingBox->ComputeBoundingBox();
Geometry3D* geometry3d = GetGeometry(0);
geometry3d->SetIndexToWorldTransform(transform);
geometry3d->SetBounds(boundingBox->GetBounds());
/* the objects position is the center of all sub bounding objects */
//geometry3d->SetOrigin(center);
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
- timeGeometry->Initialize(geometry3d, GetTimeGeometry()->GetNumberOfTimeSteps());
+ timeGeometry->Initialize(geometry3d, GetTimeGeometry()->CountTimeSteps());
SetTimeGeometry(timeGeometry);
}
void mitk::BoundingObjectGroup::AddBoundingObject(mitk::BoundingObject::Pointer boundingObject)
{
if (boundingObject->GetPositive())
m_BoundingObjects.push_front(boundingObject);
else
m_BoundingObjects.push_back(boundingObject);
++m_Counter;
UpdateOutputInformation();
}
void mitk::BoundingObjectGroup::RemoveBoundingObject(mitk::BoundingObject::Pointer boundingObject)
{
std::deque<mitk::BoundingObject::Pointer>::iterator it = m_BoundingObjects.begin();
for (unsigned int i=0 ; i<m_BoundingObjects.size();i++)
{
if (m_BoundingObjects.at(i) == boundingObject)
m_BoundingObjects.erase(it);
++it;
}
--m_Counter;
UpdateOutputInformation();
}
bool mitk::BoundingObjectGroup::IsInside(const mitk::Point3D& p) const
{
bool inside = false; // initialize with true for intersection, with false for union
bool posInside = false;
bool negInside = false;
for (unsigned int i = 0; i<m_BoundingObjects.size();i++)
{
switch(m_CSGMode)
{
case Intersection:
inside = true;
// calculate intersection: each point, that is inside each BoundingObject is considered inside the group
inside = m_BoundingObjects.at(i)->IsInside(p) && inside;
if (!inside) // shortcut, it is enough to find one object that does not contain the point
i=m_BoundingObjects.size();
break;
case Union:
case Difference:
posInside = false;
negInside = false;
// calculate union: each point, that is inside least one BoundingObject is considered inside the group
if (m_BoundingObjects.at(i)->GetPositive())
posInside = m_BoundingObjects.at(i)->IsInside(p) || posInside;
else
negInside = m_BoundingObjects.at(i)->IsInside(p) || negInside;
if (posInside && !negInside)
inside = true;
else
inside = false;
break;
default:
inside = false;
// calculate union: each point, that is inside least one BoundingObject is considered inside the group
inside = m_BoundingObjects.at(i)->IsInside(p) || inside;
if (inside) // shortcut, it is enough to find one object that contains the point
i=m_BoundingObjects.size();
break;
}
}
return inside;
}
unsigned int mitk::BoundingObjectGroup::GetCount() const
{
return m_Counter;
}
bool mitk::BoundingObjectGroup::VerifyRequestedRegion()
{
return m_Counter > 0;
}
mitk::Geometry3D * mitk::BoundingObjectGroup::GetGeometry (int t) const
{
//if ( m_BoundingObjects == NULL )
return Superclass::GetGeometry(t);
//mitk::BoundingObjectGroup::BoundingObjectContainer::ConstIterator boI = m_BoundingObjects->Begin();
//const mitk::BoundingObjectGroup::BoundingObjectContainer::ConstIterator boIEnd = m_BoundingObjects->End();
//mitk::Geometry3D* currentGeometry = NULL;
//while ( boI != boIEnd )
//{
// currentGeometry = boI.Value()->GetGeometry( t );
// boI++;
//}
//return currentGeometry;
}
void mitk::BoundingObjectGroup::SetBoundingObjects(const std::deque<mitk::BoundingObject::Pointer> boundingObjects)
{
m_BoundingObjects = boundingObjects;
}
std::deque<mitk::BoundingObject::Pointer> mitk::BoundingObjectGroup::GetBoundingObjects()
{
return m_BoundingObjects;
}
diff --git a/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.cpp b/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.cpp
index bb0762ad40..05ebcd8b1c 100644
--- a/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.cpp
+++ b/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.cpp
@@ -1,248 +1,248 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkUnstructuredGrid.h"
#include <vtkUnstructuredGrid.h>
void mitk::UnstructuredGrid::SetVtkUnstructuredGrid( vtkUnstructuredGrid* grid, unsigned int t )
{
this->Expand(t);
if(m_GridSeries[ t ] != NULL)
{
m_GridSeries[ t ]->Delete();
}
m_GridSeries[ t ] = grid;
// call m_VtkPolyData->Register(NULL) to tell the reference counting that we
// want to keep a reference on the object
if (m_GridSeries[t] != 0)
m_GridSeries[t]->Register(grid);
this->Modified();
m_CalculateBoundingBox = true;
}
void mitk::UnstructuredGrid::Expand(unsigned int timeSteps)
{
// check if the vector is long enough to contain the new element
// at the given position. If not, expand it with sufficient zero-filled elements.
if(timeSteps > m_GridSeries.size())
{
Superclass::Expand(timeSteps);
vtkUnstructuredGrid* pdnull = 0;
m_GridSeries.resize( timeSteps, pdnull );
m_CalculateBoundingBox = true;
}
}
void mitk::UnstructuredGrid::ClearData()
{
for ( VTKUnstructuredGridSeries::iterator it = m_GridSeries.begin(); it != m_GridSeries.end(); ++it )
{
if ( ( *it ) != 0 )
( *it )->Delete();
}
m_GridSeries.clear();
Superclass::ClearData();
}
void mitk::UnstructuredGrid::InitializeEmpty()
{
vtkUnstructuredGrid* pdnull = 0;
m_GridSeries.resize( 1, pdnull );
Superclass::InitializeTimeGeometry(1);
m_Initialized = true;
}
vtkUnstructuredGrid* mitk::UnstructuredGrid::GetVtkUnstructuredGrid(unsigned int t)
{
if ( t < m_GridSeries.size() )
{
vtkUnstructuredGrid* grid = m_GridSeries[ t ];
if((grid == 0) && (GetSource().GetPointer() != 0))
{
RegionType requestedregion;
requestedregion.SetIndex(3, t);
requestedregion.SetSize(3, 1);
SetRequestedRegion(&requestedregion);
GetSource()->Update();
}
grid = m_GridSeries[ t ];
return grid;
}
else
return 0;
}
mitk::UnstructuredGrid::UnstructuredGrid() : m_CalculateBoundingBox( false )
{
this->InitializeEmpty();
}
mitk::UnstructuredGrid::UnstructuredGrid(const mitk::UnstructuredGrid &other) :
BaseData(other),
m_CalculateBoundingBox( other.m_CalculateBoundingBox ),
m_LargestPossibleRegion(other.m_LargestPossibleRegion)
{
if(!other.m_Initialized)
{
this->InitializeEmpty();
}
else
{
m_GridSeries = other.m_GridSeries;
m_Initialized = other.m_Initialized;
}
this->SetRequestedRegion( const_cast<mitk::UnstructuredGrid*>(&other) );
}
mitk::UnstructuredGrid::~UnstructuredGrid()
{
this->ClearData();
}
void mitk::UnstructuredGrid::UpdateOutputInformation()
{
if ( this->GetSource() )
{
this->GetSource()->UpdateOutputInformation();
}
if ( ( m_CalculateBoundingBox ) && ( m_GridSeries.size() > 0 ) )
CalculateBoundingBox();
else
GetTimeGeometry()->Update();
}
void mitk::UnstructuredGrid::CalculateBoundingBox()
{
//
// first make sure, that the associated time sliced geometry has
// the same number of geometry 3d's as vtkUnstructuredGrids are present
//
TimeGeometry* timeGeometry = GetTimeGeometry();
- if ( timeGeometry->GetNumberOfTimeSteps() != m_GridSeries.size() )
+ if ( timeGeometry->CountTimeSteps() != m_GridSeries.size() )
{
- itkExceptionMacro(<<"timeGeometry->GetNumberOfTimeSteps() != m_GridSeries.size() -- use Initialize(timeSteps) with correct number of timeSteps!");
+ itkExceptionMacro(<<"timeGeometry->CountTimeSteps() != m_GridSeries.size() -- use Initialize(timeSteps) with correct number of timeSteps!");
}
//
// Iterate over the vtkUnstructuredGrids and update the Geometry
// information of each of the items.
//
for ( unsigned int i = 0 ; i < m_GridSeries.size() ; ++i )
{
vtkUnstructuredGrid* grid = m_GridSeries[ i ];
vtkFloatingPointType bounds[ ] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
if ( ( grid != 0 ) && ( grid->GetNumberOfCells() > 0 ) )
{
grid->Update();
grid->ComputeBounds();
grid->GetBounds( bounds );
}
mitk::Geometry3D::Pointer g3d = timeGeometry->GetGeometryForTimeStep( i );
assert( g3d.IsNotNull() );
g3d->SetFloatBounds( bounds );
}
timeGeometry->Update();
mitk::BoundingBox::Pointer bb = const_cast<mitk::BoundingBox*>( timeGeometry->GetBoundingBoxInWorld() );
itkDebugMacro( << "boundingbox min: "<< bb->GetMinimum());
itkDebugMacro( << "boundingbox max: "<< bb->GetMaximum());
m_CalculateBoundingBox = false;
}
void mitk::UnstructuredGrid::SetRequestedRegionToLargestPossibleRegion()
{
m_RequestedRegion = GetLargestPossibleRegion();
}
bool mitk::UnstructuredGrid::RequestedRegionIsOutsideOfTheBufferedRegion()
{
RegionType::IndexValueType end = m_RequestedRegion.GetIndex(3)+m_RequestedRegion.GetSize(3);
if(((RegionType::IndexValueType)m_GridSeries.size()) < end)
return true;
for( RegionType::IndexValueType t=m_RequestedRegion.GetIndex(3); t < end; ++t )
if(m_GridSeries[t] == 0)
return true;
return false;
}
bool mitk::UnstructuredGrid::VerifyRequestedRegion()
{
if( (m_RequestedRegion.GetIndex(3)>=0) &&
(m_RequestedRegion.GetIndex(3)+m_RequestedRegion.GetSize(3)<=m_GridSeries.size()) )
return true;
return false;
}
void mitk::UnstructuredGrid::SetRequestedRegion(const itk::DataObject *data )
{
const mitk::UnstructuredGrid *gridData;
gridData = dynamic_cast<const mitk::UnstructuredGrid*>(data);
if (gridData)
{
m_RequestedRegion = gridData->GetRequestedRegion();
}
else
{
// pointer could not be cast back down
itkExceptionMacro( << "mitk::UnstructuredGrid::SetRequestedRegion(DataObject*) cannot cast " << typeid(data).name() << " to " << typeid(UnstructuredGrid*).name() );
}
}
void mitk::UnstructuredGrid::SetRequestedRegion(UnstructuredGrid::RegionType *region) //by arin
{
if(region != 0)
{
m_RequestedRegion = *region;
}
else
{
// pointer could not be cast back down
itkExceptionMacro( << "mitk::UnstructuredGrid::SetRequestedRegion(UnstructuredGrid::RegionType*) cannot cast " << typeid(region).name() << " to " << typeid(UnstructuredGrid*).name() );
}
}
void mitk::UnstructuredGrid::CopyInformation( const itk::DataObject * data )
{
Superclass::CopyInformation(data);
}
void mitk::UnstructuredGrid::Update()
{
if ( GetSource().IsNull() )
{
for ( VTKUnstructuredGridSeries::iterator it = m_GridSeries.begin() ; it != m_GridSeries.end() ; ++it )
{
if ( ( *it ) != 0 )
( *it )->Update();
}
}
Superclass::Update();
}
diff --git a/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.h b/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.h
index 39362822af..0be0a14ff5 100644
--- a/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.h
+++ b/Modules/MitkExt/DataManagement/mitkUnstructuredGrid.h
@@ -1,112 +1,112 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_UNSTRUCTURED_GRID_H_
#define _MITK_UNSTRUCTURED_GRID_H_
#include "mitkBaseData.h"
#include "MitkExtExports.h"
#include "itkImageRegion.h"
class vtkUnstructuredGrid;
namespace mitk {
//##Documentation
//## @brief Class for storing unstructured grids (vtkUnstructuredGrid)
//## @ingroup Data
class MitkExt_EXPORT UnstructuredGrid : public BaseData
{
public:
// not yet the best choice of a region-type for surfaces, but it works for the time being
typedef itk::ImageRegion< 5 > RegionType;
mitkClassMacro(UnstructuredGrid, BaseData);
itkNewMacro(Self);
mitkCloneMacro(UnstructuredGrid);
virtual void SetVtkUnstructuredGrid(vtkUnstructuredGrid* grid, unsigned int t = 0);
virtual vtkUnstructuredGrid* GetVtkUnstructuredGrid(unsigned int t = 0);
virtual void UpdateOutputInformation();
virtual void SetRequestedRegionToLargestPossibleRegion();
virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
virtual bool VerifyRequestedRegion();
virtual void SetRequestedRegion( const itk::DataObject *data);
virtual void SetRequestedRegion(UnstructuredGrid::RegionType *region);
virtual void CopyInformation(const itk::DataObject *data);
virtual void Update();
// Initialize should not be called manually;
// The polydata vector is initialized automatically when enlarged;
virtual void Expand( unsigned int timeSteps = 1 );
const RegionType& GetLargestPossibleRegion() const
{
m_LargestPossibleRegion.SetIndex(3, 0);
- m_LargestPossibleRegion.SetSize(3, GetTimeGeometry()->GetNumberOfTimeSteps());
+ m_LargestPossibleRegion.SetSize(3, GetTimeGeometry()->CountTimeSteps());
return m_LargestPossibleRegion;
}
//##Documentation
//## Get the region object that defines the size and starting index
//## for the region of the image requested (i.e., the region of the
//## image to be operated on by a filter).
virtual const RegionType& GetRequestedRegion() const
{
return m_RequestedRegion;
}
void CalculateBoundingBox();
protected:
typedef std::vector< vtkUnstructuredGrid* > VTKUnstructuredGridSeries;
UnstructuredGrid();
UnstructuredGrid(const mitk::UnstructuredGrid & other);
virtual ~UnstructuredGrid();
virtual void ClearData();
virtual void InitializeEmpty();
VTKUnstructuredGridSeries m_GridSeries;
mutable RegionType m_LargestPossibleRegion;
RegionType m_RequestedRegion;
bool m_CalculateBoundingBox;
};
} // namespace mitk
#endif /* _MITK_UNSTRUCTURED_GRID_H_ */
diff --git a/Modules/MitkExt/IO/mitkUnstructuredGridVtkWriter.txx b/Modules/MitkExt/IO/mitkUnstructuredGridVtkWriter.txx
index 4b9b0ec1b7..10a55f9add 100644
--- a/Modules/MitkExt/IO/mitkUnstructuredGridVtkWriter.txx
+++ b/Modules/MitkExt/IO/mitkUnstructuredGridVtkWriter.txx
@@ -1,205 +1,205 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef _MITK_UNSTRUCTURED_GRID_VTKWRITER_TXX_
#define _MITK_UNSTRUCTURED_GRID_VTKWRITER_TXX_
#include <itkLightObject.h>
#include <vtkUnstructuredGrid.h>
#include <vtkLinearTransform.h>
#include <vtkTransformFilter.h>
#include <vtkUnstructuredGridWriter.h>
#include <vtkXMLUnstructuredGridWriter.h>
#include <vtkXMLPUnstructuredGridWriter.h>
#include <sstream>
#include <sys/stat.h>
#include <sys/types.h>
#include <stdio.h>
namespace mitk {
template<class VTKWRITER>
UnstructuredGridVtkWriter<VTKWRITER>::UnstructuredGridVtkWriter()
: m_Success(false)
{
this->SetNumberOfRequiredInputs(1);
}
template<class VTKWRITER>
UnstructuredGridVtkWriter<VTKWRITER>::~UnstructuredGridVtkWriter()
{
}
template<class VTKWRITER>
void UnstructuredGridVtkWriter<VTKWRITER>::GenerateData()
{
m_Success = false;
if ( m_FileName == "" )
{
itkWarningMacro( << "Sorry, filename has not been set!" );
return ;
}
mitk::UnstructuredGrid::Pointer input = const_cast<mitk::UnstructuredGrid*>(this->GetInput());
if (input.IsNull())
{
itkWarningMacro( << "Sorry, input to mitk::UnstructuredGridVtkWriter is NULL");
return;
}
VTKWRITER* unstructuredGridWriter = VTKWRITER::New();
vtkTransformFilter* transformPointSet = vtkTransformFilter::New();
vtkUnstructuredGrid * unstructuredGrid;
Geometry3D* geometry;
- if(input->GetTimeGeometry()->GetNumberOfTimeSteps()>1)
+ if(input->GetTimeGeometry()->CountTimeSteps()>1)
{
int t, timesteps;
- timesteps = input->GetTimeGeometry()->GetNumberOfTimeSteps();
+ timesteps = input->GetTimeGeometry()->CountTimeSteps();
for(t = 0; t < timesteps; ++t)
{
std::ostringstream filename;
geometry = input->GetGeometry(t);
if(input->GetTimeGeometry()->IsValidTimeStep(t))
{
const mitk::TimeBounds& timebounds = geometry->GetTimeBounds();
filename << m_FileName.c_str() << "_S" << std::setprecision(0) << timebounds[0] << "_E" << std::setprecision(0) << timebounds[1] << "_T" << t << GetDefaultExtension();
}
else
{
itkWarningMacro(<<"Error on write: TimeGeometry invalid of unstructured grid " << filename << ".");
filename << m_FileName.c_str() << "_T" << t << GetDefaultExtension();
}
geometry->TransferItkToVtkTransform();
transformPointSet->SetInput(input->GetVtkUnstructuredGrid(t));
transformPointSet->SetTransform(geometry->GetVtkTransform());
transformPointSet->UpdateWholeExtent();
unstructuredGrid = static_cast<vtkUnstructuredGrid*>(transformPointSet->GetOutput());
unstructuredGridWriter->SetFileName(filename.str().c_str());
unstructuredGridWriter->SetInput(unstructuredGrid);
ExecuteWrite( unstructuredGridWriter );
}
}
else
{
geometry = input->GetGeometry();
geometry->TransferItkToVtkTransform();
transformPointSet->SetInput(input->GetVtkUnstructuredGrid());
transformPointSet->SetTransform(geometry->GetVtkTransform());
transformPointSet->UpdateWholeExtent();
unstructuredGrid = static_cast<vtkUnstructuredGrid*>(transformPointSet->GetOutput());
unstructuredGridWriter->SetFileName(m_FileName.c_str());
unstructuredGridWriter->SetInput(unstructuredGrid);
ExecuteWrite( unstructuredGridWriter );
}
transformPointSet->Delete();
unstructuredGridWriter->Delete();
m_Success = true;
}
template<class VTKWRITER>
void UnstructuredGridVtkWriter<VTKWRITER>::ExecuteWrite( VTKWRITER* vtkWriter )
{
struct stat fileStatus;
time_t timeBefore=0;
if (!stat(vtkWriter->GetFileName(), &fileStatus))
{
timeBefore = fileStatus.st_mtime;
}
if (!vtkWriter->Write())
{
itkExceptionMacro( << "Error during unstructured grid writing.");
}
// check if file can be written because vtkWriter doesn't check that
if (stat(vtkWriter->GetFileName(), &fileStatus) || (timeBefore == fileStatus.st_mtime))
{
itkExceptionMacro(<<"Error during unstructured grid writing: file could not be written");
}
}
template<class VTKWRITER>
void UnstructuredGridVtkWriter<VTKWRITER>::SetInput(BaseData *input)
{
this->ProcessObject::SetNthInput(0, input);
}
template<class VTKWRITER>
const UnstructuredGrid* UnstructuredGridVtkWriter<VTKWRITER>::GetInput()
{
if (this->GetNumberOfInputs() < 1)
{
return 0;
}
else
{
return dynamic_cast<UnstructuredGrid*>(this->ProcessObject::GetInput(0));
}
}
template<class VTKWRITER>
bool UnstructuredGridVtkWriter<VTKWRITER>::CanWriteBaseDataType(BaseData::Pointer data)
{
return (dynamic_cast<mitk::UnstructuredGrid*>(data.GetPointer()) != 0);
}
template<class VTKWRITER>
void UnstructuredGridVtkWriter<VTKWRITER>::DoWrite(BaseData::Pointer data)
{
if (CanWriteBaseDataType(data))
{
this->SetInput(dynamic_cast<mitk::UnstructuredGrid*>(data.GetPointer()));
this->Update();
}
}
template<class VTKWRITER>
std::vector<std::string> UnstructuredGridVtkWriter<VTKWRITER>::GetPossibleFileExtensions()
{
throw std::exception(); // no specialization available!
}
template<class VTKWRITER>
const char* UnstructuredGridVtkWriter<VTKWRITER>::GetDefaultFilename()
{
throw std::exception(); // no specialization available!
}
template<class VTKWRITER>
const char* UnstructuredGridVtkWriter<VTKWRITER>::GetFileDialogPattern()
{
throw std::exception(); // no specialization available!
}
template<class VTKWRITER>
const char* UnstructuredGridVtkWriter<VTKWRITER>::GetDefaultExtension()
{
throw std::exception(); // no specialization available!
}
}
#endif
diff --git a/Modules/MitkExt/Rendering/mitkMeshMapper2D.cpp b/Modules/MitkExt/Rendering/mitkMeshMapper2D.cpp
index 20f3ad4171..3b2f205fd8 100644
--- a/Modules/MitkExt/Rendering/mitkMeshMapper2D.cpp
+++ b/Modules/MitkExt/Rendering/mitkMeshMapper2D.cpp
@@ -1,481 +1,481 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkMeshMapper2D.h"
#include "mitkMesh.h"
#include "mitkBaseRenderer.h"
#include "mitkPlaneGeometry.h"
#include "mitkColorProperty.h"
#include "mitkProperties.h"
#include "mitkLine.h"
#include "mitkGL.h"
#include <vtkLinearTransform.h>
#include <algorithm>
const float selectedColor[]={1.0,0.0,0.6}; //for selected!
mitk::MeshMapper2D::MeshMapper2D()
{
}
mitk::MeshMapper2D::~MeshMapper2D()
{
}
const mitk::Mesh *mitk::MeshMapper2D::GetInput(void)
{
return static_cast<const mitk::Mesh * > ( GetDataNode()->GetData() );
}
// Return whether a point is "smaller" than the second
static bool point3DSmaller( const mitk::Point3D& elem1, const mitk::Point3D& elem2 )
{
if(elem1[0]!=elem2[0])
return elem1[0] < elem2[0];
if(elem1[1]!=elem2[1])
return elem1[1] < elem2[1];
return elem1[2] < elem2[2];
}
void mitk::MeshMapper2D::Paint( mitk::BaseRenderer *renderer )
{
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if(!visible) return;
// @FIXME: Logik fuer update
bool updateNeccesary = true;
if (updateNeccesary)
{
//aus GenerateData
mitk::Mesh::Pointer input = const_cast<mitk::Mesh*>(this->GetInput());
// Get the TimeGeometry of the input object
const TimeGeometry* inputTimeGeometry = input->GetTimeGeometry();
- if (( inputTimeGeometry == NULL ) || ( inputTimeGeometry->GetNumberOfTimeSteps() == 0 ) )
+ if (( inputTimeGeometry == NULL ) || ( inputTimeGeometry->CountTimeSteps() == 0 ) )
{
return;
}
//
// get the world time
//
const Geometry2D* worldGeometry = renderer->GetCurrentWorldGeometry2D();
assert( worldGeometry != NULL );
ScalarType time = worldGeometry->GetTimeBounds()[ 0 ];
//
// convert the world time in time steps of the input object
//
int timeStep=0;
if ( time > ScalarTypeNumericTraits::NonpositiveMin() )
timeStep = inputTimeGeometry->TimePointToTimeStep( time );
if ( inputTimeGeometry->IsValidTimeStep( timeStep ) == false )
{
return;
}
mitk::Mesh::MeshType::Pointer itkMesh = input->GetMesh( timeStep );
if ( itkMesh.GetPointer() == NULL)
{
return;
}
mitk::DisplayGeometry::Pointer displayGeometry = renderer->GetDisplayGeometry();
assert(displayGeometry.IsNotNull());
const PlaneGeometry* worldplanegeometry = dynamic_cast<const PlaneGeometry*>(renderer->GetCurrentWorldGeometry2D());
//apply color and opacity read from the PropertyList
ApplyColorAndOpacityProperties(renderer);
vtkLinearTransform* transform = GetDataNode()->GetVtkTransform();
//List of the Points
Mesh::DataType::PointsContainerConstIterator it, end;
it=itkMesh->GetPoints()->Begin();
end=itkMesh ->GetPoints()->End();
//iterator on the additional data of each point
Mesh::PointDataIterator dataIt;//, dataEnd;
dataIt=itkMesh->GetPointData()->Begin();
//for switching back to old color after using selected color
float unselectedColor[4];
glGetFloatv(GL_CURRENT_COLOR,unselectedColor);
while(it!=end)
{
mitk::Point3D p, projected_p;
float vtkp[3];
itk2vtk(it->Value(), vtkp);
transform->TransformPoint(vtkp, vtkp);
vtk2itk(vtkp,p);
displayGeometry->Project(p, projected_p);
Vector3D diff=p-projected_p;
if(diff.GetSquaredNorm()<4.0)
{
Point2D pt2d, tmp;
displayGeometry->Map(projected_p, pt2d);
displayGeometry->WorldToDisplay(pt2d, pt2d);
Vector2D horz,vert;
horz[0]=5; horz[1]=0;
vert[0]=0; vert[1]=5;
//check if the point is to be marked as selected
if (dataIt->Value().selected)
{
horz[0]=8;
vert[1]=8;
glColor3f(selectedColor[0],selectedColor[1],selectedColor[2]);//red
switch (dataIt->Value().pointSpec)
{
case PTSTART:
{
//a quad
glBegin (GL_LINE_LOOP);
tmp=pt2d-horz+vert; glVertex2fv(&tmp[0]);
tmp=pt2d+horz+vert; glVertex2fv(&tmp[0]);
tmp=pt2d+horz-vert; glVertex2fv(&tmp[0]);
tmp=pt2d-horz-vert; glVertex2fv(&tmp[0]);
glEnd ();
}
break;
case PTUNDEFINED:
{
//a diamond around the point
glBegin (GL_LINE_LOOP);
tmp=pt2d-horz; glVertex2fv(&tmp[0]);
tmp=pt2d+vert; glVertex2fv(&tmp[0]);
tmp=pt2d+horz; glVertex2fv(&tmp[0]);
tmp=pt2d-vert; glVertex2fv(&tmp[0]);
glEnd ();
}
break;
default:
break;
}//switch
//the actual point
glBegin (GL_POINTS);
tmp=pt2d; glVertex2fv(&tmp[0]);
glEnd ();
}
else //if not selected
{
glColor3f(unselectedColor[0],unselectedColor[1],unselectedColor[2]);
switch (dataIt->Value().pointSpec)
{
case PTSTART:
{
//a quad
glBegin (GL_LINE_LOOP);
tmp=pt2d-horz+vert; glVertex2fv(&tmp[0]);
tmp=pt2d+horz+vert; glVertex2fv(&tmp[0]);
tmp=pt2d+horz-vert; glVertex2fv(&tmp[0]);
tmp=pt2d-horz-vert; glVertex2fv(&tmp[0]);
glEnd ();
}
case PTUNDEFINED:
{
//drawing crosses
glBegin (GL_LINES);
tmp=pt2d-horz; glVertex2fv(&tmp[0]);
tmp=pt2d+horz; glVertex2fv(&tmp[0]);
tmp=pt2d-vert; glVertex2fv(&tmp[0]);
tmp=pt2d+vert; glVertex2fv(&tmp[0]);
glEnd ();
}
default:
{
break;
}
}//switch
}//else
}
++it;
++dataIt;
}
//now connect the lines inbetween
mitk::Mesh::PointType thisPoint; thisPoint.Fill(0);
Point2D *firstOfCell = NULL;
Point2D *lastPoint = NULL;
unsigned int lastPointId = 0;
bool lineSelected = false;
Point3D firstOfCell3D;
Point3D lastPoint3D;
bool first;
mitk::Line<mitk::ScalarType> line;
std::vector<mitk::Point3D> intersectionPoints;
double t;
//iterate through all cells and then iterate through all indexes of points in that cell
Mesh::CellIterator cellIt, cellEnd;
Mesh::CellDataIterator cellDataIt;//, cellDataEnd;
Mesh::PointIdIterator cellIdIt, cellIdEnd;
cellIt = itkMesh->GetCells()->Begin();
cellEnd = itkMesh->GetCells()->End();
cellDataIt = itkMesh->GetCellData()->Begin();
while (cellIt != cellEnd)
{
unsigned int numOfPointsInCell = cellIt->Value()->GetNumberOfPoints();
if (numOfPointsInCell>1)
{
//iterate through all id's in the cell
cellIdIt = cellIt->Value()->PointIdsBegin();
cellIdEnd = cellIt->Value()->PointIdsEnd();
firstOfCell3D = input->GetPoint(*cellIdIt,timeStep);
intersectionPoints.clear();
intersectionPoints.reserve(numOfPointsInCell);
first = true;
while(cellIdIt != cellIdEnd)
{
lastPoint3D = thisPoint;
thisPoint = input->GetPoint(*cellIdIt,timeStep);
//search in data (vector<> selectedLines) if the index of the point is set. if so, then the line is selected.
lineSelected = false;
Mesh::SelectedLinesType selectedLines = cellDataIt->Value().selectedLines;
//a line between 1(lastPoint) and 2(pt2d) has the Id 1, so look for the Id of lastPoint
//since we only start, if we have more than one point in the cell, lastPointId is initiated with 0
Mesh::SelectedLinesIter position = std::find(selectedLines.begin(), selectedLines.end(), lastPointId);
if (position != selectedLines.end())
{
lineSelected = true;
}
mitk::Point3D p, projected_p;
float vtkp[3];
itk2vtk(thisPoint, vtkp);
transform->TransformPoint(vtkp, vtkp);
vtk2itk(vtkp,p);
displayGeometry->Project(p, projected_p);
Vector3D diff=p-projected_p;
if(diff.GetSquaredNorm()<4.0)
{
Point2D pt2d, tmp;
displayGeometry->Map(projected_p, pt2d);
displayGeometry->WorldToDisplay(pt2d, pt2d);
if (lastPoint == NULL)
{
//set the first point in the cell. This point in needed to close the polygon
firstOfCell = new Point2D;
*firstOfCell = pt2d;
lastPoint = new Point2D;
*lastPoint = pt2d;
lastPointId = *cellIdIt;
}
else
{
if (lineSelected)
{
glColor3f(selectedColor[0],selectedColor[1],selectedColor[2]);//red
//a line from lastPoint to thisPoint
glBegin (GL_LINES);
glVertex2fv(&(*lastPoint)[0]);
glVertex2fv(&pt2d[0]);
glEnd ();
}
else //if not selected
{
glColor3f(unselectedColor[0],unselectedColor[1],unselectedColor[2]);
//drawing crosses
glBegin (GL_LINES);
glVertex2fv(&(*lastPoint)[0]);
glVertex2fv(&pt2d[0]);
glEnd ();
}
//to draw the line to the next in iteration step
*lastPoint = pt2d;
//and to search for the selection state of the line
lastPointId = *cellIdIt;
}//if..else
}//if <4.0
//fill off-plane polygon part 1
if((!first) && (worldplanegeometry!=NULL))
{
line.SetPoints(lastPoint3D, thisPoint);
if(worldplanegeometry->IntersectionPointParam(line, t) &&
((t>=0) && (t<=1))
)
{
intersectionPoints.push_back(line.GetPoint(t));
}
}
++cellIdIt;
first=false;
}//while cellIdIter
//closed polygon?
if ( cellDataIt->Value().closed )
{
//close the polygon if needed
if( firstOfCell != NULL )
{
lineSelected = false;
Mesh::SelectedLinesType selectedLines = cellDataIt->Value().selectedLines;
Mesh::SelectedLinesIter position = std::find(selectedLines.begin(), selectedLines.end(), lastPointId);
if (position != selectedLines.end())//found the index
{
glColor3f(selectedColor[0],selectedColor[1],selectedColor[2]);//red
//a line from lastPoint to firstPoint
glBegin (GL_LINES);
glVertex2fv(&(*lastPoint)[0]);
glVertex2fv(&(*firstOfCell)[0]);
glEnd ();
}
else
{
glColor3f(unselectedColor[0],unselectedColor[1],unselectedColor[2]);
glBegin (GL_LINES);
glVertex2fv(&(*lastPoint)[0]);
glVertex2fv(&(*firstOfCell)[0]);
glEnd ();
}
}
}//if closed
//Axis-aligned bounding box(AABB) around the cell if selected and set in Property
bool showBoundingBox;
if (dynamic_cast<mitk::BoolProperty *>(this->GetDataNode()->GetProperty("showBoundingBox")) == NULL)
showBoundingBox = false;
else
showBoundingBox = dynamic_cast<mitk::BoolProperty *>(this->GetDataNode()->GetProperty("showBoundingBox"))->GetValue();
if(showBoundingBox)
{
if (cellDataIt->Value().selected)
{
mitk::Mesh::DataType::BoundingBoxPointer aABB = input->GetBoundingBoxFromCell(cellIt->Index());
if (aABB.IsNotNull())
{
mitk::Mesh::PointType min, max;
min = aABB->GetMinimum();
max = aABB->GetMaximum();
//project to the displayed geometry
Point2D min2D, max2D;
Point3D p, projected_p;
float vtkp[3];
itk2vtk(min, vtkp);
transform->TransformPoint(vtkp, vtkp);
vtk2itk(vtkp,p);
displayGeometry->Project(p, projected_p);
displayGeometry->Map(projected_p, min2D);
displayGeometry->WorldToDisplay(min2D, min2D);
itk2vtk(max, vtkp);
transform->TransformPoint(vtkp, vtkp);
vtk2itk(vtkp,p);
displayGeometry->Project(p, projected_p);
Vector3D diff=p-projected_p;
if(diff.GetSquaredNorm()<4.0)
{
displayGeometry->Map(projected_p, max2D);
displayGeometry->WorldToDisplay(max2D, max2D);
//draw the BoundingBox
glColor3f(selectedColor[0],selectedColor[1],selectedColor[2]);//red
//a line from lastPoint to firstPoint
glBegin(GL_LINE_LOOP);
glVertex2f(min2D[0], min2D[1]);
glVertex2f(min2D[0], max2D[1]);
glVertex2f(max2D[0], max2D[1]);
glVertex2f(max2D[0], min2D[1]);
glEnd();
}//draw bounding-box
}//bounding-box exists
}//cell selected
}//show bounding-box
//fill off-plane polygon part 2
if(worldplanegeometry!=NULL)
{
//consider line from last to first
line.SetPoints(thisPoint, firstOfCell3D);
if(worldplanegeometry->IntersectionPointParam(line, t) &&
((t>=0) && (t<=1))
)
{
intersectionPoints.push_back(line.GetPoint(t));
}
std::sort(intersectionPoints.begin(), intersectionPoints.end(), point3DSmaller);
std::vector<mitk::Point3D>::iterator it, end;
end=intersectionPoints.end();
if((intersectionPoints.size()%2)!=0)
{
--end; //ensure even number of intersection-points
}
float p[2];
Point3D pt3d;
Point2D pt2d;
for ( it = intersectionPoints.begin( ); it != end; ++it )
{
glBegin (GL_LINES);
displayGeometry->Map(*it, pt2d); displayGeometry->WorldToDisplay(pt2d, pt2d);
p[0] = pt2d[0]; p[1] = pt2d[1]; glVertex2fv(p);
++it;
displayGeometry->Map(*it, pt2d); displayGeometry->WorldToDisplay(pt2d, pt2d);
p[0] = pt2d[0]; p[1] = pt2d[1]; glVertex2fv(p);
glEnd ();
}
if(it!=intersectionPoints.end())
{
glBegin (GL_LINES);
displayGeometry->Map(*it, pt2d); displayGeometry->WorldToDisplay(pt2d, pt2d);
p[0] = pt2d[0]; p[1] = pt2d[1]; glVertex2fv(p);
p[0] = pt2d[0]; p[1] = pt2d[1]; glVertex2fv(p);
glEnd ();
}
}//fill off-plane polygon part 2
}//if numOfPointsInCell>1
delete firstOfCell;
delete lastPoint;
lastPoint = NULL;
firstOfCell = NULL;
lastPointId = 0;
++cellIt;
++cellDataIt;
}
}
}
diff --git a/Modules/MitkExt/Rendering/mitkVectorImageMapper2D.cpp b/Modules/MitkExt/Rendering/mitkVectorImageMapper2D.cpp
index 00066f6b04..df31c17e23 100644
--- a/Modules/MitkExt/Rendering/mitkVectorImageMapper2D.cpp
+++ b/Modules/MitkExt/Rendering/mitkVectorImageMapper2D.cpp
@@ -1,538 +1,538 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkVectorImageMapper2D.h"
//vtk related includes
#include <vtkPlane.h>
#include <vtkLookupTable.h>
#include <vtkScalarsToColors.h>
#include <vtkImageReslice.h>
#include <vtkPolyData.h>
#include <vtkGlyph2D.h>
#include <vtkGlyphSource2D.h>
#include <vtkPolyData.h>
#include <vtkPolyDataSource.h>
#include <vtkPolyDataMapper.h>
#include <vtkPoints.h>
#include <vtkCellArray.h>
#include <vtkFloatArray.h>
#include <vtkPointData.h>
#include <vtkCellData.h>
#include <vtkDataArray.h>
#include <vtkMath.h>
#include <vtkLinearTransform.h>
#include <vtkMatrixToLinearTransform.h>
#include <vtkLookupTable.h>
#include <vtkScalarsToColors.h>
#include <vtkTransform.h>
#include <vtkImageData.h>
#include <vtkDataSetWriter.h>
#include <vtkMaskedGlyph3D.h>
#include <vtkMaskedGlyph2D.h>
#include <vtkMatrix4x4.h>
#include <vtkCutter.h>
#include <vtkPlane.h>
#include <vtkIndent.h>
#include <vtkDataObject.h>
#include <fstream>
//mitk related includes
#include "mitkGL.h"
#include "mitkBaseRenderer.h"
#include "mitkColorProperty.h"
#include "mitkProperties.h"
#include "mitkAbstractTransformGeometry.h"
#include <mitkLookupTableProperty.h>
const mitk::Image * mitk::VectorImageMapper2D::GetInput( void )
{
if ( m_Image.IsNotNull() )
return m_Image;
else
return dynamic_cast<const mitk::Image*>( GetDataNode()->GetData() );
}
void mitk::VectorImageMapper2D::Paint( mitk::BaseRenderer * renderer )
{
//std::cout << "2d vector mapping..." << std::endl;
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if ( !visible )
return ;
mitk::Image::Pointer input = const_cast<mitk::Image*>( this->GetInput() );
if ( input.IsNull() )
return ;
mitk::PlaneGeometry::Pointer worldPlaneGeometry2D = dynamic_cast< mitk::PlaneGeometry*>( const_cast<mitk::Geometry2D*>( renderer->GetCurrentWorldGeometry2D() ) );
assert( worldPlaneGeometry2D.IsNotNull() );
vtkImageData* vtkImage = input->GetVtkImageData( this->GetCurrentTimeStep( input, renderer ) );
//
// set up the cutter orientation according to the current geometry of
// the renderers plane
//
Point3D point;
Vector3D normal;
Geometry2D::ConstPointer worldGeometry = renderer->GetCurrentWorldGeometry2D();
PlaneGeometry::ConstPointer worldPlaneGeometry = dynamic_cast<const PlaneGeometry*>( worldGeometry.GetPointer() );
if ( worldPlaneGeometry.IsNotNull() )
{
// set up vtkPlane according to worldGeometry
point = worldPlaneGeometry->GetOrigin();
normal = worldPlaneGeometry->GetNormal(); normal.Normalize();
m_Plane->SetTransform( (vtkAbstractTransform*)NULL );
}
else
{
itkWarningMacro( << "worldPlaneGeometry is NULL!" );
return ;
}
vtkFloatingPointType vp[ 3 ], vp_slice[ 3 ], vnormal[ 3 ];
vnl2vtk( point.Get_vnl_vector(), vp );
vnl2vtk( normal.Get_vnl_vector(), vnormal );
//std::cout << "Origin: " << vp[0] <<" "<< vp[1] <<" "<< vp[2] << std::endl;
//std::cout << "Normal: " << vnormal[0] <<" "<< vnormal[1] <<" "<< vnormal[2] << std::endl;
//normally, we would need to transform the surface and cut the transformed surface with the cutter.
//This might be quite slow. Thus, the idea is, to perform an inverse transform of the plane instead.
//@todo It probably does not work for scaling operations yet:scaling operations have to be
//dealed with after the cut is performed by scaling the contour.
vtkLinearTransform * vtktransform = GetDataNode() ->GetVtkTransform();
vtkTransform* world2vtk = vtkTransform::New();
world2vtk->Identity();
world2vtk->Concatenate(vtktransform->GetLinearInverse());
double myscale[3];
world2vtk->GetScale(myscale);
world2vtk->PostMultiply();
world2vtk->Scale(1/myscale[0],1/myscale[1],1/myscale[2]);
world2vtk->TransformPoint( vp, vp );
world2vtk->TransformNormalAtPoint( vp, vnormal, vnormal );
world2vtk->Delete();
// vtk works in axis align coords
// thus the normal also must be axis align, since
// we do not allow arbitrary cutting through volume
//
// vnormal should already be axis align, but in order
// to get rid of precision effects, we set the two smaller
// components to zero here
int dims[3];
vtkImage->GetDimensions(dims);
double spac[3];
vtkImage->GetSpacing(spac);
vp_slice[0] = vp[0];
vp_slice[1] = vp[1];
vp_slice[2] = vp[2];
if(fabs(vnormal[0]) > fabs(vnormal[1]) && fabs(vnormal[0]) > fabs(vnormal[2]) )
{
if(fabs(vp_slice[0]/spac[0]) < 0.4)
vp_slice[0] = 0.4*spac[0];
if(fabs(vp_slice[0]/spac[0]) > (dims[0]-1)-0.4)
vp_slice[0] = ((dims[0]-1)-0.4)*spac[0];
vnormal[1] = 0;
vnormal[2] = 0;
}
if(fabs(vnormal[1]) > fabs(vnormal[0]) && fabs(vnormal[1]) > fabs(vnormal[2]) )
{
if(fabs(vp_slice[1]/spac[1]) < 0.4)
vp_slice[1] = 0.4*spac[1];
if(fabs(vp_slice[1]/spac[1]) > (dims[1]-1)-0.4)
vp_slice[1] = ((dims[1]-1)-0.4)*spac[1];
vnormal[0] = 0;
vnormal[2] = 0;
}
if(fabs(vnormal[2]) > fabs(vnormal[1]) && fabs(vnormal[2]) > fabs(vnormal[0]) )
{
if(fabs(vp_slice[2]/spac[2]) < 0.4)
vp_slice[2] = 0.4*spac[2];
if(fabs(vp_slice[2]/spac[2]) > (dims[2]-1)-0.4)
vp_slice[2] = ((dims[2]-1)-0.4)*spac[2];
vnormal[0] = 0;
vnormal[1] = 0;
}
m_Plane->SetOrigin( vp_slice );
m_Plane->SetNormal( vnormal );
vtkPolyData* cuttedPlane;
if(!( (dims[0] == 1 && vnormal[0] != 0) ||
(dims[1] == 1 && vnormal[1] != 0) ||
(dims[2] == 1 && vnormal[2] != 0) ))
{
m_Cutter->SetCutFunction( m_Plane );
m_Cutter->SetInput( vtkImage );
m_Cutter->GenerateCutScalarsOff();//!
m_Cutter->Update();
cuttedPlane = m_Cutter->GetOutput();
}
else
{
// cutting of a 2D-Volume does not work,
// so we have to build up our own polydata object
cuttedPlane = vtkPolyData::New();
vtkPoints* points = vtkPoints::New();
points->SetNumberOfPoints(vtkImage->GetNumberOfPoints());
for(int i=0; i<vtkImage->GetNumberOfPoints(); i++)
points->SetPoint(i, vtkImage->GetPoint(i));
cuttedPlane->SetPoints(points);
vtkFloatArray* pointdata = vtkFloatArray::New();
int comps = vtkImage->GetPointData()->GetScalars()->GetNumberOfComponents();
pointdata->SetNumberOfComponents(comps);
int tuples = vtkImage->GetPointData()->GetScalars()->GetNumberOfTuples();
pointdata->SetNumberOfTuples(tuples);
for(int i=0; i<tuples; i++)
pointdata->SetTuple(i,vtkImage->GetPointData()->GetScalars()->GetTuple(i));
pointdata->SetName( "vector" );
cuttedPlane->GetPointData()->AddArray(pointdata);
}
if ( cuttedPlane->GetNumberOfPoints() != 0)
{
//
// make sure, that we have point data with more than 1 component (as vectors)
//
vtkPointData * pointData = cuttedPlane->GetPointData();
if ( pointData == NULL )
{
itkWarningMacro( << "no point data associated with cutters result!" );
return ;
}
if ( pointData->GetNumberOfArrays() == 0 )
{
itkWarningMacro( << "point data returned by cutter doesn't have any arrays associated!" );
return ;
}
else if ( pointData->GetArray(0)->GetNumberOfComponents() <= 1)
{
itkWarningMacro( << "number of components <= 1!" );
return;
}
else if ( pointData->GetArrayName( 0 ) == NULL )
{
pointData->GetArray( 0 ) ->SetName( "vector" );
//std::cout << "array name = vectors now" << std::endl;
}
//std::cout << " projecting..."<< std::endl;
//
// constrain the vectors to lie on the plane, which means to remove the vector component,
// which is orthogonal to the plane.
//
vtkIdType numPoints, pointId;
numPoints = cuttedPlane->GetNumberOfPoints();
vtkDataArray* inVectors = cuttedPlane->GetPointData()->GetVectors( "vector" );
assert( inVectors != NULL );
vtkFloatArray* vectorMagnitudes = vtkFloatArray::New();
vectorMagnitudes->SetName("vectorMagnitudes");
vectorMagnitudes->SetNumberOfComponents(1);
vectorMagnitudes->SetNumberOfValues(numPoints);
vectorMagnitudes->SetNumberOfTuples(numPoints);
vtkFloatingPointType inVector[ 3 ], outVector[3], wnormal[3]; //, tmpVector[ 3 ], outVector[ 3 ];
vtkFloatingPointType k = 0.0;
vnl2vtk( normal.Get_vnl_vector(), wnormal );
vtkMath::Normalize( wnormal );
bool normalizeVecs;
m_DataNode->GetBoolProperty( "NormalizeVecs", normalizeVecs );
for ( pointId = 0; pointId < numPoints; ++pointId )
{
inVectors->GetTuple( pointId, inVector );
if(normalizeVecs)
{
vnl_vector<double> tmp(3);
vtk2vnl(inVector, tmp);
tmp.normalize();
vnl2vtk(tmp, inVector);
}
k = vtkMath::Dot( wnormal, inVector );
// Remove non orthogonal component.
outVector[ 0 ] = inVector[ 0 ] - ( wnormal[ 0 ] * k );
outVector[ 1 ] = inVector[ 1 ] - ( wnormal[ 1 ] * k );
outVector[ 2 ] = inVector[ 2 ] - ( wnormal[ 2 ] * k );
inVectors->SetTuple( pointId, outVector );
// ?? this was set to norm(inVector) before, but outVector made more sense to me
vectorMagnitudes->SetValue( pointId, vtkMath::Norm( outVector ) );
//std::cout << "method old: " << inVector[0] <<", " << inVector[1] << ", "<<inVector[2] << ", method new: " << outVector[0] << ", "<< outVector[1] << ", "<< outVector[2] << std::endl;
}
pointData->AddArray(vectorMagnitudes);
pointData->CopyAllOn();
//pointData->PrintSelf(std::cout, vtkIndent(4));
//std::cout << " ...done!"<< std::endl;
//std::cout << " glyphing..."<< std::endl;
// call glyph2D to generate 2D glyphs for each of the
// vectors
vtkGlyphSource2D* glyphSource = vtkGlyphSource2D::New();
//glyphSource->SetGlyphTypeToDash();
glyphSource->DashOn();
//glyphSource->SetScale( 0.1 );
//glyphSource->SetScale2( .5 );
//glyphSource->SetCenter( 0.5, 0.5, 0.5 );
glyphSource->CrossOff();
//glyphSource->FilledOff();
//glyphSource->Update();
double spacing[3];
vtkImage->GetSpacing(spacing);
double min = spacing[0];
min = min > spacing[1] ? spacing[1] : min;
min = min > spacing[2] ? spacing[2] : min;
float scale = 1;
mitk::FloatProperty::Pointer mitkScaleProp = dynamic_cast<mitk::FloatProperty*>(GetDataNode()->GetProperty("Scale"));
if (mitkScaleProp.IsNotNull())
{
scale = mitkScaleProp->GetValue();
}
vtkMaskedGlyph3D* glyphGenerator = vtkMaskedGlyph3D::New();
glyphGenerator->SetSource( glyphSource->GetOutput() );
glyphGenerator->SetInputConnection(cuttedPlane->GetProducerPort());
glyphGenerator->SetInputArrayToProcess (1, 0,0, vtkDataObject::FIELD_ASSOCIATION_POINTS , "vector");
glyphGenerator->SetVectorModeToUseVector();
glyphGenerator->OrientOn();
glyphGenerator->SetScaleFactor( min*scale );
glyphGenerator->SetUseMaskPoints( true );
glyphGenerator->SetRandomMode( true );
glyphGenerator->SetMaximumNumberOfPoints( 128*128 );
glyphGenerator->Update();
vtkLookupTable* vtkLut = NULL;
mitk::LookupTableProperty::Pointer mitkLutProp = dynamic_cast<mitk::LookupTableProperty*>(GetDataNode()->GetProperty("LookupTable"));
if (mitkLutProp.IsNotNull())
{
vtkLut = mitkLutProp->GetLookupTable()->GetVtkLookupTable();
}
mitk::Color color;
mitk::ColorProperty::Pointer mitkColorProp = dynamic_cast<mitk::ColorProperty*>(GetDataNode()->GetProperty("color"));
if (mitkColorProp.IsNotNull())
{
color = mitkColorProp->GetColor();
}
else
{
color.SetRed(0);
color.SetBlue(1);
color.SetGreen(0);
}
float lwidth = 1;
mitk::FloatProperty::Pointer mitkLWidthProp = dynamic_cast<mitk::FloatProperty*>(GetDataNode()->GetProperty("LineWidth"));
if (mitkLWidthProp.IsNotNull())
{
lwidth = mitkLWidthProp->GetValue();
}
vtkTransform* trafo = vtkTransform::New();
trafo->Identity();
trafo->Concatenate(vtktransform);
trafo->PreMultiply();
double myscale[3];
trafo->GetScale(myscale);
trafo->Scale(1/myscale[0],1/myscale[1],1/myscale[2]);
this->PaintCells( glyphGenerator->GetOutput(), renderer->GetCurrentWorldGeometry2D(), renderer->GetDisplayGeometry(), trafo, renderer, NULL/*vtkLut*/, color, lwidth, spacing );
vectorMagnitudes->Delete();
glyphSource->Delete();
glyphGenerator->Delete();
trafo->Delete();
}
else
{
std::cout << " no points cutted!"<< std::endl;
}
//std::cout << "...done!" << std::endl;
}
void mitk::VectorImageMapper2D::PaintCells( vtkPolyData* glyphs, const Geometry2D* worldGeometry, const DisplayGeometry* displayGeometry, vtkLinearTransform* vtktransform, mitk::BaseRenderer* /*renderer*/, vtkScalarsToColors *lut, mitk::Color color, float lwidth, vtkFloatingPointType *spacing )
{
vtkPoints * points = glyphs->GetPoints();
vtkPointData * vpointdata = glyphs->GetPointData();
vtkDataArray* vpointscalars = vpointdata->GetArray("vectorMagnitudes");
//vtkDataArray* vpointpositions = vpointdata->GetArray("pointPositions");
assert(vpointscalars != NULL);
//std::cout << " Scalars range 2d:" << vpointscalars->GetRange()[0] << " " << vpointscalars->GetRange()[0] << std::endl;
Point3D p;
Point2D p2d;
vtkIdList* idList;
vtkCell* cell;
vtkFloatingPointType offset[3];
for (unsigned int i = 0; i < 3; ++i)
{
offset[i] = 0;
}
vtkIdType numCells = glyphs->GetNumberOfCells();
for ( vtkIdType cellId = 0; cellId < numCells; ++cellId )
{
vtkFloatingPointType vp[ 3 ];
cell = glyphs->GetCell( cellId );
idList = cell->GetPointIds();
int numPoints = idList->GetNumberOfIds();
if(numPoints == 1)
{
//take transformation via vtktransform into account
vtkFloatingPointType pos[ 3 ],vp_raster[3];
points->GetPoint( idList->GetId( 0 ), vp );
vp_raster[0] = vtkMath::Round(vp[0]/spacing[0])*spacing[0];
vp_raster[1] = vtkMath::Round(vp[1]/spacing[1])*spacing[1];
vp_raster[2] = vtkMath::Round(vp[2]/spacing[2])*spacing[2];
vtktransform->TransformPoint( vp_raster, pos );
offset[0] = pos[0] - vp[0];
offset[1] = pos[1] - vp[1];
offset[2] = pos[2] - vp[2];
}
else
{
glLineWidth(lwidth);
glBegin ( GL_LINE_LOOP );
for ( int pointNr = 0; pointNr < numPoints ;++pointNr )
{
points->GetPoint( idList->GetId( pointNr ), vp );
vp[0] = vp[0] + offset[0];
vp[1] = vp[1] + offset[1];
vp[2] = vp[2] + offset[2];
vtkFloatingPointType tmp[ 3 ];
vtktransform->TransformPoint( vp,tmp );
vtk2itk( vp, p );
//convert 3D point (in mm) to 2D point on slice (also in mm)
worldGeometry->Map( p, p2d );
//convert point (until now mm and in worldcoordinates) to display coordinates (units )
displayGeometry->WorldToDisplay( p2d, p2d );
if ( lut != NULL )
{
// color each point according to point data
vtkFloatingPointType * color;
if ( vpointscalars != NULL )
{
vpointscalars->GetComponent( pointNr, 0 );
color = lut->GetColor( vpointscalars->GetComponent( idList->GetId( pointNr ), 0 ) );
glColor3f( color[ 0 ], color[ 1 ], color[ 2 ] );
}
}
else
{
glColor3f( color.GetRed(), color.GetGreen(), color.GetBlue() );
}
//std::cout << idList->GetId( pointNr )<< ": " << p2d[0]<< " "<< p2d[1] << std::endl;
//draw the line
glVertex2f( p2d[ 0 ], p2d[ 1 ] );
}
glEnd ();
}
}
}
mitk::VectorImageMapper2D::VectorImageMapper2D()
{
m_LUT = NULL;
m_Plane = vtkPlane::New();
m_Cutter = vtkCutter::New();
m_Cutter->SetCutFunction( m_Plane );
m_Cutter->GenerateValues( 1, 0, 1 );
}
mitk::VectorImageMapper2D::~VectorImageMapper2D()
{
if ( m_LUT != NULL )
m_LUT->Delete();
if ( m_Plane != NULL )
m_Plane->Delete();
if ( m_Cutter != NULL )
m_Cutter->Delete();
}
int mitk::VectorImageMapper2D::GetCurrentTimeStep( mitk::BaseData* data, mitk::BaseRenderer* renderer )
{
//
// get the TimeGeometry of the input object
//
const TimeGeometry * dataTimeGeometry = data->GetUpdatedTimeGeometry();
- if ( ( dataTimeGeometry == NULL ) || ( dataTimeGeometry->GetNumberOfTimeSteps() == 0 ) )
+ if ( ( dataTimeGeometry == NULL ) || ( dataTimeGeometry->CountTimeSteps() == 0 ) )
{
itkWarningMacro( << "The given object is missing a mitk::TimeGeometry, or the number of time steps is 0!" );
return 0;
}
//
// get the world time
//
Geometry2D::ConstPointer worldGeometry = renderer->GetCurrentWorldGeometry2D();
assert( worldGeometry.IsNotNull() );
ScalarType time = worldGeometry->GetTimeBounds() [ 0 ];
//
// convert the world time to time steps of the input object
//
int timestep = 0;
if ( time > ScalarTypeNumericTraits::NonpositiveMin() )
timestep = dataTimeGeometry->TimePointToTimeStep( time );
if ( dataTimeGeometry->IsValidTimeStep( timestep ) == false )
{
itkWarningMacro( << timestep << " is not a valid time of the given data object!" );
return 0;
}
return timestep;
}
diff --git a/Modules/Segmentation/Algorithms/mitkContourUtils.cpp b/Modules/Segmentation/Algorithms/mitkContourUtils.cpp
index 96dacdb382..3740aefe08 100644
--- a/Modules/Segmentation/Algorithms/mitkContourUtils.cpp
+++ b/Modules/Segmentation/Algorithms/mitkContourUtils.cpp
@@ -1,237 +1,237 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkContourUtils.h"
#include "mitkImageCast.h"
#include "mitkImageAccessByItk.h"
#include "mitkInstantiateAccessFunctions.h"
#include "ipSegmentation.h"
#define InstantiateAccessFunction_ItkCopyFilledContourToSlice(pixelType, dim) \
template void mitk::ContourUtils::ItkCopyFilledContourToSlice(itk::Image<pixelType,dim>*, const mitk::Image*, int);
// explicitly instantiate the 2D version of this method
InstantiateAccessFunctionForFixedDimension(ItkCopyFilledContourToSlice, 2);
mitk::ContourUtils::ContourUtils()
{
}
mitk::ContourUtils::~ContourUtils()
{
}
mitk::ContourModel::Pointer mitk::ContourUtils::ProjectContourTo2DSlice(Image* slice, Contour* contourIn3D, bool itkNotUsed( correctionForIpSegmentation ), bool constrainToInside)
{
mitk::Contour::PointsContainerIterator it = contourIn3D->GetPoints()->Begin();
mitk::Contour::PointsContainerIterator end = contourIn3D->GetPoints()->End();
mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
while(it!=end)
{
contour->AddVertex(it.Value());
it++;
}
return this->ProjectContourTo2DSlice(slice, contour, false/*not used*/, constrainToInside );
}
mitk::ContourModel::Pointer mitk::ContourUtils::ProjectContourTo2DSlice(Image* slice, ContourModel* contourIn3D, bool itkNotUsed( correctionForIpSegmentation ), bool constrainToInside)
{
if ( !slice || !contourIn3D ) return NULL;
ContourModel::Pointer projectedContour = ContourModel::New();
projectedContour->Initialize(*contourIn3D);
const Geometry3D* sliceGeometry = slice->GetGeometry();
- int numberOfTimesteps = contourIn3D->GetTimeGeometry()->GetNumberOfTimeSteps();
+ int numberOfTimesteps = contourIn3D->GetTimeGeometry()->CountTimeSteps();
for(int currentTimestep = 0; currentTimestep < numberOfTimesteps; currentTimestep++)
{
ContourModel::VertexIterator iter = contourIn3D->Begin(currentTimestep);
ContourModel::VertexIterator end = contourIn3D->End(currentTimestep);
while( iter != end)
{
Point3D currentPointIn3D = (*iter)->Coordinates;
Point3D projectedPointIn2D;
projectedPointIn2D.Fill(0.0);
sliceGeometry->WorldToIndex( currentPointIn3D, projectedPointIn2D );
// MITK_INFO << "world point " << currentPointIn3D << " in index is " << projectedPointIn2D;
if ( !sliceGeometry->IsIndexInside( projectedPointIn2D ) && constrainToInside )
{
MITK_INFO << "**" << currentPointIn3D << " is " << projectedPointIn2D << " --> correct it (TODO)" << std::endl;
}
projectedContour->AddVertex( projectedPointIn2D, currentTimestep );
iter++;
}
}
return projectedContour;
}
mitk::ContourModel::Pointer mitk::ContourUtils::BackProjectContourFrom2DSlice(const Geometry3D* sliceGeometry, Contour* contourIn2D, bool itkNotUsed( correctionForIpSegmentation ) )
{
mitk::Contour::PointsContainerIterator it = contourIn2D->GetPoints()->Begin();
mitk::Contour::PointsContainerIterator end = contourIn2D->GetPoints()->End();
mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
while(it!=end)
{
contour->AddVertex(it.Value());
it++;
}
return this->BackProjectContourFrom2DSlice(sliceGeometry, contour, false/*not used*/);
}
mitk::ContourModel::Pointer mitk::ContourUtils::BackProjectContourFrom2DSlice(const Geometry3D* sliceGeometry, ContourModel* contourIn2D, bool itkNotUsed( correctionForIpSegmentation ) )
{
if ( !sliceGeometry || !contourIn2D ) return NULL;
ContourModel::Pointer worldContour = ContourModel::New();
worldContour->Initialize(*contourIn2D);
- int numberOfTimesteps = contourIn2D->GetTimeGeometry()->GetNumberOfTimeSteps();
+ int numberOfTimesteps = contourIn2D->GetTimeGeometry()->CountTimeSteps();
for(int currentTimestep = 0; currentTimestep < numberOfTimesteps; currentTimestep++)
{
ContourModel::VertexIterator iter = contourIn2D->Begin(currentTimestep);
ContourModel::VertexIterator end = contourIn2D->End(currentTimestep);
while( iter != end)
{
Point3D currentPointIn2D = (*iter)->Coordinates;
Point3D worldPointIn3D;
worldPointIn3D.Fill(0.0);
sliceGeometry->IndexToWorld( currentPointIn2D, worldPointIn3D );
//MITK_INFO << "index " << currentPointIn2D << " world " << worldPointIn3D << std::endl;
worldContour->AddVertex( worldPointIn3D, currentTimestep );
iter++;
}
}
return worldContour;
}
void mitk::ContourUtils::FillContourInSlice( Contour* projectedContour, Image* sliceImage, int paintingPixelValue )
{
mitk::Contour::PointsContainerIterator it = projectedContour->GetPoints()->Begin();
mitk::Contour::PointsContainerIterator end = projectedContour->GetPoints()->End();
mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
while(it!=end)
{
contour->AddVertex(it.Value());
it++;
}
this->FillContourInSlice(contour, sliceImage, paintingPixelValue);
}
void mitk::ContourUtils::FillContourInSlice( ContourModel* projectedContour, Image* sliceImage, int paintingPixelValue )
{
this->FillContourInSlice(projectedContour, 0, sliceImage, paintingPixelValue);
}
void mitk::ContourUtils::FillContourInSlice( ContourModel* projectedContour, unsigned int timeStep, Image* sliceImage, int paintingPixelValue )
{
// 1. Use ipSegmentation to draw a filled(!) contour into a new 8 bit 2D image, which will later be copied back to the slice.
// We don't work on the "real" working data, because ipSegmentation would restrict us to 8 bit images
// convert the projected contour into a ipSegmentation format
mitkIpInt4_t* picContour = new mitkIpInt4_t[2 * projectedContour->GetNumberOfVertices(timeStep)];
unsigned int index(0);
ContourModel::VertexIterator iter = projectedContour->Begin(timeStep);
ContourModel::VertexIterator end = projectedContour->End(timeStep);
while( iter != end)
{
picContour[ 2 * index + 0 ] = static_cast<mitkIpInt4_t>( (*iter)->Coordinates[0] + 1.0 ); // +0.5 wahrscheinlich richtiger
picContour[ 2 * index + 1 ] = static_cast<mitkIpInt4_t>( (*iter)->Coordinates[1] + 1.0 );
//MITK_INFO << "mitk 2d [" << (*iter)[0] << ", " << (*iter)[1] << "] pic [" << picContour[ 2*index+0] << ", " << picContour[ 2*index+1] << "]";
iter++;
index++;
}
assert( sliceImage->GetSliceData() );
mitkIpPicDescriptor* originalPicSlice = mitkIpPicNew();
CastToIpPicDescriptor( sliceImage, originalPicSlice);
mitkIpPicDescriptor* picSlice = ipMITKSegmentationNew( originalPicSlice );
ipMITKSegmentationClear( picSlice );
assert( originalPicSlice && picSlice );
// here comes the actual contour filling algorithm (from ipSegmentation/Graphics Gems)
ipMITKSegmentationCombineRegion ( picSlice, picContour, projectedContour->GetNumberOfVertices(timeStep), NULL, IPSEGMENTATION_OR, 1); // set to 1
delete[] picContour;
// 2. Copy the filled contour to the working data slice
// copy all pixels that are non-zero to the original image (not caring for the actual type of the working image). perhaps make the replace value a parameter ( -> general painting tool ).
// make the pic slice an mitk/itk image (as little ipPic code as possible), call a templated method with accessbyitk, iterate over the original and the modified slice
Image::Pointer ipsegmentationModifiedSlice = Image::New();
ipsegmentationModifiedSlice->Initialize( CastToImageDescriptor( picSlice ) );
ipsegmentationModifiedSlice->SetSlice( picSlice->data );
AccessFixedDimensionByItk_2( sliceImage, ItkCopyFilledContourToSlice, 2, ipsegmentationModifiedSlice, paintingPixelValue );
ipsegmentationModifiedSlice = NULL; // free MITK header information
ipMITKSegmentationFree( picSlice ); // free actual memory
}
template<typename TPixel, unsigned int VImageDimension>
void mitk::ContourUtils::ItkCopyFilledContourToSlice( itk::Image<TPixel,VImageDimension>* originalSlice, const Image* filledContourSlice, int overwritevalue )
{
typedef itk::Image<TPixel,VImageDimension> SliceType;
typename SliceType::Pointer filledContourSliceITK;
CastToItkImage( filledContourSlice, filledContourSliceITK );
// now the original slice and the ipSegmentation-painted slice are in the same format, and we can just copy all pixels that are non-zero
typedef itk::ImageRegionIterator< SliceType > OutputIteratorType;
typedef itk::ImageRegionConstIterator< SliceType > InputIteratorType;
InputIteratorType inputIterator( filledContourSliceITK, filledContourSliceITK->GetLargestPossibleRegion() );
OutputIteratorType outputIterator( originalSlice, originalSlice->GetLargestPossibleRegion() );
outputIterator.GoToBegin();
inputIterator.GoToBegin();
while ( !outputIterator.IsAtEnd() )
{
if ( inputIterator.Get() != 0 )
{
outputIterator.Set( overwritevalue );
}
++outputIterator;
++inputIterator;
}
}
\ No newline at end of file
diff --git a/Modules/Segmentation/DataManagement/mitkContourSet.cpp b/Modules/Segmentation/DataManagement/mitkContourSet.cpp
index a6a0820249..1004392ade 100644
--- a/Modules/Segmentation/DataManagement/mitkContourSet.cpp
+++ b/Modules/Segmentation/DataManagement/mitkContourSet.cpp
@@ -1,129 +1,129 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkContourSet.h"
#include <mitkProportionalTimeGeometry.h>
mitk::ContourSet::ContourSet() :
m_ContourVector( ContourVectorType() ),
m_NumberOfContours (0)
{
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
timeGeometry->Initialize(1);
SetTimeGeometry(timeGeometry);
}
mitk::ContourSet::~ContourSet()
{
}
void mitk::ContourSet::AddContour(unsigned int index, mitk::Contour::Pointer contour)
{
m_ContourVector.insert(std::make_pair( index , contour) );
}
void mitk::ContourSet::RemoveContour(unsigned long index)
{
m_ContourVector.erase( index );
}
void mitk::ContourSet::UpdateOutputInformation()
{
mitk::ContourSet::ContourVectorType contourVec = GetContours();
mitk::ContourSet::ContourIterator contoursIterator = contourVec.begin();
mitk::ContourSet::ContourIterator contoursIteratorEnd = contourVec.end();
// initialize container
mitk::BoundingBox::PointsContainer::Pointer pointscontainer=mitk::BoundingBox::PointsContainer::New();
mitk::BoundingBox::PointIdentifier pointid=0;
mitk::Point3D point;
mitk::AffineTransform3D* transform = GetGeometry(0)->GetIndexToWorldTransform();
mitk::AffineTransform3D::Pointer inverse = mitk::AffineTransform3D::New();
transform->GetInverse(inverse);
// calculate a bounding box that includes all contours
// \todo probably we should do this additionally for each time-step
while (contoursIterator != contoursIteratorEnd)
{
const TimeGeometry* geometry = (*contoursIterator).second->GetUpdatedTimeGeometry();
unsigned char i;
for(i=0; i<8; ++i)
{
point = inverse->TransformPoint(geometry->GetCornerPointInWorld(i));
if(point[0]*point[0]+point[1]*point[1]+point[2]*point[2] < mitk::large)
pointscontainer->InsertElement( pointid++, point);
else
{
itkGenericOutputMacro( << "Unrealistically distant corner point encountered. Ignored. BoundingObject: " << (*contoursIterator).second );
}
}
++contoursIterator;
}
mitk::BoundingBox::Pointer boundingBox = mitk::BoundingBox::New();
boundingBox->SetPoints(pointscontainer);
boundingBox->ComputeBoundingBox();
Geometry3D* geometry3d = GetGeometry(0);
geometry3d->SetIndexToWorldTransform(transform);
geometry3d->SetBounds(boundingBox->GetBounds());
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
- timeGeometry->Initialize(geometry3d,GetTimeGeometry()->GetNumberOfTimeSteps());
+ timeGeometry->Initialize(geometry3d,GetTimeGeometry()->CountTimeSteps());
SetTimeGeometry(timeGeometry);
}
void mitk::ContourSet::SetRequestedRegionToLargestPossibleRegion()
{
}
bool mitk::ContourSet::RequestedRegionIsOutsideOfTheBufferedRegion()
{
return true;
}
bool mitk::ContourSet::VerifyRequestedRegion()
{
return true;
}
void mitk::ContourSet::SetRequestedRegion( const itk::DataObject*)
{
}
void mitk::ContourSet::Initialize()
{
m_ContourVector = ContourVectorType();
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
timeGeometry->Initialize(1);
SetTimeGeometry(timeGeometry);
}
unsigned int mitk::ContourSet::GetNumberOfContours()
{
return m_ContourVector.size();
}
mitk::ContourSet::ContourVectorType mitk::ContourSet::GetContours()
{
return m_ContourVector;
}
diff --git a/Modules/Segmentation/Interactions/mitkFastMarchingTool.cpp b/Modules/Segmentation/Interactions/mitkFastMarchingTool.cpp
index be2c77bbeb..2f4c18a58f 100644
--- a/Modules/Segmentation/Interactions/mitkFastMarchingTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkFastMarchingTool.cpp
@@ -1,481 +1,481 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkFastMarchingTool.h"
#include "mitkToolManager.h"
#include "mitkBaseRenderer.h"
#include "mitkRenderingManager.h"
#include "mitkInteractionConst.h"
#include "itkOrImageFilter.h"
#include "mitkImageTimeSelector.h"
// us
#include <usModule.h>
#include <usModuleResource.h>
#include <usGetModuleContext.h>
#include <usModuleContext.h>
namespace mitk {
MITK_TOOL_MACRO(Segmentation_EXPORT, FastMarchingTool, "FastMarching2D tool");
}
mitk::FastMarchingTool::FastMarchingTool()
:FeedbackContourTool("PressMoveReleaseAndPointSetting"),
m_NeedUpdate(true),
m_CurrentTimeStep(0),
m_LowerThreshold(0),
m_UpperThreshold(200),
m_StoppingValue(100),
m_Sigma(1.0),
m_Alpha(-0.5),
m_Beta(3.0),
m_PositionEvent(0)
{
CONNECT_ACTION( AcADDPOINTRMB, OnAddPoint );
CONNECT_ACTION( AcADDPOINT, OnAddPoint );
CONNECT_ACTION( AcREMOVEPOINT, OnDelete );
}
mitk::FastMarchingTool::~FastMarchingTool()
{
if (this->m_SmoothFilter.IsNotNull())
this->m_SmoothFilter->RemoveAllObservers();
if (this->m_SigmoidFilter.IsNotNull())
this->m_SigmoidFilter->RemoveAllObservers();
if (this->m_GradientMagnitudeFilter.IsNotNull())
this->m_GradientMagnitudeFilter->RemoveAllObservers();
if (this->m_FastMarchingFilter.IsNotNull())
this->m_FastMarchingFilter->RemoveAllObservers();
}
float mitk::FastMarchingTool::CanHandleEvent( StateEvent const *stateEvent) const
{
float returnValue = Superclass::CanHandleEvent(stateEvent);
//we can handle delete
if(stateEvent->GetId() == 12 )
{
returnValue = 1.0;
}
return returnValue;
}
const char** mitk::FastMarchingTool::GetXPM() const
{
return NULL;//mitkFastMarchingTool_xpm;
}
us::ModuleResource mitk::FastMarchingTool::GetIconResource() const
{
us::Module* module = us::GetModuleContext()->GetModule();
us::ModuleResource resource = module->GetResource("FastMarching_48x48.png");
return resource;
}
us::ModuleResource mitk::FastMarchingTool::GetCursorIconResource() const
{
us::Module* module = us::GetModuleContext()->GetModule();
us::ModuleResource resource = module->GetResource("FastMarching_Cursor_32x32.png");
return resource;
}
const char* mitk::FastMarchingTool::GetName() const
{
return "2D Fast Marching";
}
void mitk::FastMarchingTool::BuildITKPipeline()
{
m_ReferenceImageSliceAsITK = InternalImageType::New();
m_ReferenceImageSlice = GetAffectedReferenceSlice( m_PositionEvent );
CastToItkImage(m_ReferenceImageSlice, m_ReferenceImageSliceAsITK);
m_ProgressCommand = mitk::ToolCommand::New();
m_SmoothFilter = SmoothingFilterType::New();
m_SmoothFilter->SetInput( m_ReferenceImageSliceAsITK );
m_SmoothFilter->SetTimeStep( 0.05 );
m_SmoothFilter->SetNumberOfIterations( 2 );
m_SmoothFilter->SetConductanceParameter( 9.0 );
m_GradientMagnitudeFilter = GradientFilterType::New();
m_GradientMagnitudeFilter->SetSigma( m_Sigma );
m_SigmoidFilter = SigmoidFilterType::New();
m_SigmoidFilter->SetAlpha( m_Alpha );
m_SigmoidFilter->SetBeta( m_Beta );
m_SigmoidFilter->SetOutputMinimum( 0.0 );
m_SigmoidFilter->SetOutputMaximum( 1.0 );
m_FastMarchingFilter = FastMarchingFilterType::New();
m_FastMarchingFilter->SetStoppingValue( m_StoppingValue );
m_ThresholdFilter = ThresholdingFilterType::New();
m_ThresholdFilter->SetLowerThreshold( m_LowerThreshold );
m_ThresholdFilter->SetUpperThreshold( m_UpperThreshold );
m_ThresholdFilter->SetOutsideValue( 0 );
m_ThresholdFilter->SetInsideValue( 1.0 );
m_SeedContainer = NodeContainer::New();
m_SeedContainer->Initialize();
m_FastMarchingFilter->SetTrialPoints( m_SeedContainer );
if (this->m_SmoothFilter.IsNotNull())
this->m_SmoothFilter->RemoveAllObservers();
if (this->m_SigmoidFilter.IsNotNull())
this->m_SigmoidFilter->RemoveAllObservers();
if (this->m_GradientMagnitudeFilter.IsNotNull())
this->m_GradientMagnitudeFilter->RemoveAllObservers();
if (this->m_FastMarchingFilter.IsNotNull())
this->m_FastMarchingFilter->RemoveAllObservers();
m_SmoothFilter->AddObserver( itk::ProgressEvent(), m_ProgressCommand);
m_GradientMagnitudeFilter->AddObserver( itk::ProgressEvent(), m_ProgressCommand);
m_SigmoidFilter->AddObserver( itk::ProgressEvent(), m_ProgressCommand);
m_FastMarchingFilter->AddObserver( itk::ProgressEvent(), m_ProgressCommand);
m_SmoothFilter->SetInput( m_ReferenceImageSliceAsITK );
m_GradientMagnitudeFilter->SetInput( m_SmoothFilter->GetOutput() );
m_SigmoidFilter->SetInput( m_GradientMagnitudeFilter->GetOutput() );
m_FastMarchingFilter->SetInput( m_SigmoidFilter->GetOutput() );
m_ThresholdFilter->SetInput( m_FastMarchingFilter->GetOutput() );
m_ReferenceImageSliceAsITK = InternalImageType::New();
}
void mitk::FastMarchingTool::SetUpperThreshold(double value)
{
if (m_UpperThreshold != value)
{
m_UpperThreshold = value / 10.0;
m_ThresholdFilter->SetUpperThreshold( m_UpperThreshold );
m_NeedUpdate = true;
}
}
void mitk::FastMarchingTool::SetLowerThreshold(double value)
{
if (m_LowerThreshold != value)
{
m_LowerThreshold = value / 10.0;
m_ThresholdFilter->SetLowerThreshold( m_LowerThreshold );
m_NeedUpdate = true;
}
}
void mitk::FastMarchingTool::SetBeta(double value)
{
if (m_Beta != value)
{
m_Beta = value;
m_SigmoidFilter->SetBeta( m_Beta );
m_NeedUpdate = true;
}
}
void mitk::FastMarchingTool::SetSigma(double value)
{
if (m_Sigma != value)
{
m_Sigma = value;
m_GradientMagnitudeFilter->SetSigma( m_Sigma );
m_NeedUpdate = true;
}
}
void mitk::FastMarchingTool::SetAlpha(double value)
{
if (m_Alpha != value)
{
m_Alpha = value;
m_SigmoidFilter->SetAlpha( m_Alpha );
m_NeedUpdate = true;
}
}
void mitk::FastMarchingTool::SetStoppingValue(double value)
{
if (m_StoppingValue != value)
{
m_StoppingValue = value;
m_FastMarchingFilter->SetStoppingValue( m_StoppingValue );
m_NeedUpdate = true;
}
}
void mitk::FastMarchingTool::Activated()
{
Superclass::Activated();
m_ResultImageNode = mitk::DataNode::New();
m_ResultImageNode->SetName("FastMarching_Preview");
m_ResultImageNode->SetBoolProperty("helper object", true);
m_ResultImageNode->SetColor(0.0, 1.0, 0.0);
m_ResultImageNode->SetVisibility(true);
m_ToolManager->GetDataStorage()->Add( this->m_ResultImageNode, m_ToolManager->GetReferenceData(0));
m_SeedsAsPointSet = mitk::PointSet::New();
m_SeedsAsPointSetNode = mitk::DataNode::New();
m_SeedsAsPointSetNode->SetData(m_SeedsAsPointSet);
m_SeedsAsPointSetNode->SetName("Seeds_Preview");
m_SeedsAsPointSetNode->SetBoolProperty("helper object", true);
m_SeedsAsPointSetNode->SetColor(0.0, 1.0, 0.0);
m_SeedsAsPointSetNode->SetVisibility(true);
m_ToolManager->GetDataStorage()->Add( this->m_SeedsAsPointSetNode, m_ToolManager->GetReferenceData(0));
this->Initialize();
}
void mitk::FastMarchingTool::Deactivated()
{
Superclass::Deactivated();
m_ToolManager->GetDataStorage()->Remove( this->m_ResultImageNode );
m_ToolManager->GetDataStorage()->Remove( this->m_SeedsAsPointSetNode );
this->ClearSeeds();
m_ResultImageNode = NULL;
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::FastMarchingTool::Initialize()
{
m_ReferenceImage = dynamic_cast<mitk::Image*>(m_ToolManager->GetReferenceData(0)->GetData());
- if(m_ReferenceImage->GetTimeGeometry()->GetNumberOfTimeSteps() > 1)
+ if(m_ReferenceImage->GetTimeGeometry()->CountTimeSteps() > 1)
{
mitk::ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
timeSelector->SetInput( m_ReferenceImage );
timeSelector->SetTimeNr( m_CurrentTimeStep );
timeSelector->UpdateLargestPossibleRegion();
m_ReferenceImage = timeSelector->GetOutput();
}
m_NeedUpdate = true;
}
void mitk::FastMarchingTool::ConfirmSegmentation()
{
// combine preview image with current working segmentation
if (dynamic_cast<mitk::Image*>(m_ResultImageNode->GetData()))
{
//logical or combination of preview and segmentation slice
OutputImageType::Pointer workingImageSliceInITK = OutputImageType::New();
mitk::Image::Pointer workingImageSlice;
mitk::Image::Pointer workingImage = dynamic_cast<mitk::Image*>(this->m_ToolManager->GetWorkingData(0)->GetData());
- if(workingImage->GetTimeGeometry()->GetNumberOfTimeSteps() > 1)
+ if(workingImage->GetTimeGeometry()->CountTimeSteps() > 1)
{
mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
timeSelector->SetInput( workingImage );
timeSelector->SetTimeNr( m_CurrentTimeStep );
timeSelector->UpdateLargestPossibleRegion();
// todo: make GetAffectedWorkingSlice dependant of current time step
workingImageSlice = GetAffectedWorkingSlice( m_PositionEvent );
CastToItkImage( workingImageSlice, workingImageSliceInITK );
}
else
{
workingImageSlice = GetAffectedWorkingSlice( m_PositionEvent );
CastToItkImage( workingImageSlice, workingImageSliceInITK );
}
typedef itk::OrImageFilter<OutputImageType, OutputImageType> OrImageFilterType;
OrImageFilterType::Pointer orFilter = OrImageFilterType::New();
orFilter->SetInput(0, m_ThresholdFilter->GetOutput());
orFilter->SetInput(1, workingImageSliceInITK);
orFilter->Update();
mitk::Image::Pointer segmentationResult = mitk::Image::New();
mitk::CastToMitkImage(orFilter->GetOutput(), segmentationResult);
segmentationResult->GetGeometry()->SetOrigin(workingImageSlice->GetGeometry()->GetOrigin());
segmentationResult->GetGeometry()->SetIndexToWorldTransform(workingImageSlice->GetGeometry()->GetIndexToWorldTransform());
//write to segmentation volume and hide preview image
// again, current time step is not considered
this->WriteBackSegmentationResult(m_PositionEvent, segmentationResult );
this->m_ResultImageNode->SetVisibility(false);
this->ClearSeeds();
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
bool mitk::FastMarchingTool::OnAddPoint(Action* action, const StateEvent* stateEvent)
{
// Add a new seed point for FastMarching algorithm
const PositionEvent* p = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
if (!p) return false;
if (m_PositionEvent != NULL)
delete m_PositionEvent;
m_PositionEvent = new PositionEvent(p->GetSender(), p->GetType(), p->GetButton(), p->GetButtonState(), p->GetKey(), p->GetDisplayPosition(), p->GetWorldPosition() );
//if click was on another renderwindow or slice then reset pipeline and preview
if( (m_LastEventSender != m_PositionEvent->GetSender()) || (m_LastEventSlice != m_PositionEvent->GetSender()->GetSlice()) )
{
this->BuildITKPipeline();
this->ClearSeeds();
}
m_LastEventSender = m_PositionEvent->GetSender();
m_LastEventSlice = m_LastEventSender->GetSlice();
mitk::Point3D clickInIndex;
m_ReferenceImageSlice->GetGeometry()->WorldToIndex(m_PositionEvent->GetWorldPosition(), clickInIndex);
itk::Index<2> seedPosition;
seedPosition[0] = clickInIndex[0];
seedPosition[1] = clickInIndex[1];
NodeType node;
const double seedValue = 0.0;
node.SetValue( seedValue );
node.SetIndex( seedPosition );
this->m_SeedContainer->InsertElement(this->m_SeedContainer->Size(), node);
m_FastMarchingFilter->Modified();
m_SeedsAsPointSet->InsertPoint(m_SeedsAsPointSet->GetSize(), m_PositionEvent->GetWorldPosition());
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
m_NeedUpdate = true;
m_ReadyMessage.Send();
this->Update();
return true;
}
bool mitk::FastMarchingTool::OnDelete(Action* action, const StateEvent* stateEvent)
{
// delete last seed point
if(!(this->m_SeedContainer->empty()))
{
//delete last element of seeds container
this->m_SeedContainer->pop_back();
m_FastMarchingFilter->Modified();
//delete last point in pointset - somehow ugly
m_SeedsAsPointSet->GetPointSet()->GetPoints()->DeleteIndex(m_SeedsAsPointSet->GetSize() - 1);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
m_NeedUpdate = true;
this->Update();
}
return true;
}
void mitk::FastMarchingTool::Update()
{
const unsigned int progress_steps = 20;
// update FastMarching pipeline and show result
if (m_NeedUpdate)
{
m_ProgressCommand->AddStepsToDo(progress_steps);
CurrentlyBusy.Send(true);
try
{
m_ThresholdFilter->Update();
}
catch( itk::ExceptionObject & excep )
{
MITK_ERROR << "Exception caught: " << excep.GetDescription();
// progress by max step count, will force
m_ProgressCommand->SetProgress(progress_steps);
CurrentlyBusy.Send(false);
std::string msg = excep.GetDescription();
ErrorMessage.Send(msg);
return;
}
m_ProgressCommand->SetProgress(progress_steps);
CurrentlyBusy.Send(false);
//make output visible
mitk::Image::Pointer result = mitk::Image::New();
CastToMitkImage( m_ThresholdFilter->GetOutput(), result);
result->GetGeometry()->SetOrigin(m_ReferenceImageSlice->GetGeometry()->GetOrigin() );
result->GetGeometry()->SetIndexToWorldTransform(m_ReferenceImageSlice->GetGeometry()->GetIndexToWorldTransform() );
m_ResultImageNode->SetData(result);
m_ResultImageNode->SetVisibility(true);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void mitk::FastMarchingTool::ClearSeeds()
{
// clear seeds for FastMarching as well as the PointSet for visualization
if(this->m_SeedContainer.IsNotNull())
this->m_SeedContainer->Initialize();
if(this->m_SeedsAsPointSet.IsNotNull())
{
this->m_SeedsAsPointSet = mitk::PointSet::New();
this->m_SeedsAsPointSetNode->SetData(this->m_SeedsAsPointSet);
m_SeedsAsPointSetNode->SetName("Seeds_Preview");
m_SeedsAsPointSetNode->SetBoolProperty("helper object", true);
m_SeedsAsPointSetNode->SetColor(0.0, 1.0, 0.0);
m_SeedsAsPointSetNode->SetVisibility(true);
}
if(this->m_FastMarchingFilter.IsNotNull())
m_FastMarchingFilter->Modified();
this->m_NeedUpdate = true;
}
void mitk::FastMarchingTool::Reset()
{
//clear all seeds and preview empty result
this->ClearSeeds();
m_ResultImageNode->SetVisibility(false);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::FastMarchingTool::SetCurrentTimeStep(int t)
{
if( m_CurrentTimeStep != t )
{
m_CurrentTimeStep = t;
this->Initialize();
}
}
diff --git a/Modules/Segmentation/Interactions/mitkFastMarchingTool3D.cpp b/Modules/Segmentation/Interactions/mitkFastMarchingTool3D.cpp
index e0092cbaca..97acb326d9 100644
--- a/Modules/Segmentation/Interactions/mitkFastMarchingTool3D.cpp
+++ b/Modules/Segmentation/Interactions/mitkFastMarchingTool3D.cpp
@@ -1,437 +1,437 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkFastMarchingTool3D.h"
#include "mitkToolManager.h"
#include "mitkBaseRenderer.h"
#include "mitkRenderingManager.h"
#include "mitkInteractionConst.h"
#include "mitkGlobalInteraction.h"
#include "itkOrImageFilter.h"
#include "mitkImageTimeSelector.h"
#include "mitkImageCast.h"
// us
#include <usModule.h>
#include <usModuleResource.h>
#include <usGetModuleContext.h>
#include <usModuleContext.h>
namespace mitk {
MITK_TOOL_MACRO(Segmentation_EXPORT, FastMarchingTool3D, "FastMarching3D tool");
}
mitk::FastMarchingTool3D::FastMarchingTool3D()
:/*FeedbackContourTool*/AutoSegmentationTool(),
m_NeedUpdate(true),
m_CurrentTimeStep(0),
m_LowerThreshold(0),
m_UpperThreshold(200),
m_StoppingValue(100),
m_Sigma(1.0),
m_Alpha(-0.5),
m_Beta(3.0)
{
}
mitk::FastMarchingTool3D::~FastMarchingTool3D()
{
}
const char** mitk::FastMarchingTool3D::GetXPM() const
{
return NULL;//mitkFastMarchingTool3D_xpm;
}
us::ModuleResource mitk::FastMarchingTool3D::GetIconResource() const
{
us::Module* module = us::GetModuleContext()->GetModule();
us::ModuleResource resource = module->GetResource("FastMarching_48x48.png");
return resource;
}
const char* mitk::FastMarchingTool3D::GetName() const
{
return "Fast Marching 3D";
}
void mitk::FastMarchingTool3D::SetUpperThreshold(double value)
{
m_UpperThreshold = value / 10.0;
m_ThresholdFilter->SetUpperThreshold( m_UpperThreshold );
m_NeedUpdate = true;
}
void mitk::FastMarchingTool3D::SetLowerThreshold(double value)
{
m_LowerThreshold = value / 10.0;
m_ThresholdFilter->SetLowerThreshold( m_LowerThreshold );
m_NeedUpdate = true;
}
void mitk::FastMarchingTool3D::SetBeta(double value)
{
if (m_Beta != value)
{
m_Beta = value;
m_SigmoidFilter->SetBeta( m_Beta );
m_NeedUpdate = true;
}
}
void mitk::FastMarchingTool3D::SetSigma(double value)
{
if (m_Sigma != value)
{
if(value > 0.0)
{
m_Sigma = value;
m_GradientMagnitudeFilter->SetSigma( m_Sigma );
m_NeedUpdate = true;
}
}
}
void mitk::FastMarchingTool3D::SetAlpha(double value)
{
if (m_Alpha != value)
{
m_Alpha = value;
m_SigmoidFilter->SetAlpha( m_Alpha );
m_NeedUpdate = true;
}
}
void mitk::FastMarchingTool3D::SetStoppingValue(double value)
{
if (m_StoppingValue != value)
{
m_StoppingValue = value;
m_FastMarchingFilter->SetStoppingValue( m_StoppingValue );
m_NeedUpdate = true;
}
}
void mitk::FastMarchingTool3D::Activated()
{
Superclass::Activated();
m_ResultImageNode = mitk::DataNode::New();
m_ResultImageNode->SetName("FastMarching_Preview");
m_ResultImageNode->SetBoolProperty("helper object", true);
m_ResultImageNode->SetColor(0.0, 1.0, 0.0);
m_ResultImageNode->SetVisibility(true);
m_ToolManager->GetDataStorage()->Add( this->m_ResultImageNode, m_ToolManager->GetReferenceData(0));
m_SeedsAsPointSet = mitk::PointSet::New();
m_SeedsAsPointSetNode = mitk::DataNode::New();
m_SeedsAsPointSetNode->SetData(m_SeedsAsPointSet);
m_SeedsAsPointSetNode->SetName("3D_FastMarching_PointSet");
m_SeedsAsPointSetNode->SetBoolProperty("helper object", true);
m_SeedsAsPointSetNode->SetColor(0.0, 1.0, 0.0);
m_SeedsAsPointSetNode->SetVisibility(true);
m_SeedPointInteractor = mitk::PointSetInteractor::New("PressMoveReleaseAndPointSetting", m_SeedsAsPointSetNode);
m_ReferenceImageAsITK = InternalImageType::New();
m_ProgressCommand = mitk::ToolCommand::New();
m_ThresholdFilter = ThresholdingFilterType::New();
m_ThresholdFilter->SetLowerThreshold( m_LowerThreshold );
m_ThresholdFilter->SetUpperThreshold( m_UpperThreshold );
m_ThresholdFilter->SetOutsideValue( 0 );
m_ThresholdFilter->SetInsideValue( 1.0 );
m_SmoothFilter = SmoothingFilterType::New();
m_SmoothFilter->AddObserver( itk::ProgressEvent(), m_ProgressCommand);
m_SmoothFilter->SetTimeStep( 0.05 );
m_SmoothFilter->SetNumberOfIterations( 2 );
m_SmoothFilter->SetConductanceParameter( 9.0 );
m_GradientMagnitudeFilter = GradientFilterType::New();
m_GradientMagnitudeFilter->AddObserver( itk::ProgressEvent(), m_ProgressCommand);
m_GradientMagnitudeFilter->SetSigma( m_Sigma );
m_SigmoidFilter = SigmoidFilterType::New();
m_SigmoidFilter->AddObserver( itk::ProgressEvent(), m_ProgressCommand);
m_SigmoidFilter->SetAlpha( m_Alpha );
m_SigmoidFilter->SetBeta( m_Beta );
m_SigmoidFilter->SetOutputMinimum( 0.0 );
m_SigmoidFilter->SetOutputMaximum( 1.0 );
m_FastMarchingFilter = FastMarchingFilterType::New();
m_FastMarchingFilter->AddObserver( itk::ProgressEvent(), m_ProgressCommand);
m_FastMarchingFilter->SetStoppingValue( m_StoppingValue );
m_SeedContainer = NodeContainer::New();
m_SeedContainer->Initialize();
m_FastMarchingFilter->SetTrialPoints( m_SeedContainer );
//set up pipeline
m_SmoothFilter->SetInput( m_ReferenceImageAsITK );
m_GradientMagnitudeFilter->SetInput( m_SmoothFilter->GetOutput() );
m_SigmoidFilter->SetInput( m_GradientMagnitudeFilter->GetOutput() );
m_FastMarchingFilter->SetInput( m_SigmoidFilter->GetOutput() );
m_ThresholdFilter->SetInput( m_FastMarchingFilter->GetOutput() );
m_ToolManager->GetDataStorage()->Add(m_SeedsAsPointSetNode, m_ToolManager->GetWorkingData(0));
mitk::GlobalInteraction::GetInstance()->AddInteractor(m_SeedPointInteractor);
itk::SimpleMemberCommand<mitk::FastMarchingTool3D>::Pointer pointAddedCommand = itk::SimpleMemberCommand<mitk::FastMarchingTool3D>::New();
pointAddedCommand->SetCallbackFunction(this, &mitk::FastMarchingTool3D::OnAddPoint);
m_PointSetAddObserverTag = m_SeedsAsPointSet->AddObserver( mitk::PointSetAddEvent(), pointAddedCommand);
itk::SimpleMemberCommand<mitk::FastMarchingTool3D>::Pointer pointRemovedCommand = itk::SimpleMemberCommand<mitk::FastMarchingTool3D>::New();
pointRemovedCommand->SetCallbackFunction(this, &mitk::FastMarchingTool3D::OnDelete);
m_PointSetRemoveObserverTag = m_SeedsAsPointSet->AddObserver( mitk::PointSetRemoveEvent(), pointRemovedCommand);
this->Initialize();
}
void mitk::FastMarchingTool3D::Deactivated()
{
Superclass::Deactivated();
m_ToolManager->GetDataStorage()->Remove( this->m_ResultImageNode );
m_ToolManager->GetDataStorage()->Remove( this->m_SeedsAsPointSetNode );
this->ClearSeeds();
this->m_SmoothFilter->RemoveAllObservers();
this->m_SigmoidFilter->RemoveAllObservers();
this->m_GradientMagnitudeFilter->RemoveAllObservers();
this->m_FastMarchingFilter->RemoveAllObservers();
m_ResultImageNode = NULL;
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
unsigned int numberOfPoints = m_SeedsAsPointSet->GetSize();
for (unsigned int i = 0; i < numberOfPoints; ++i)
{
mitk::Point3D point = m_SeedsAsPointSet->GetPoint(i);
mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpREMOVE, point, 0);
m_SeedsAsPointSet->ExecuteOperation(doOp);
}
mitk::GlobalInteraction::GetInstance()->RemoveInteractor(m_SeedPointInteractor);
m_ToolManager->GetDataStorage()->Remove(m_SeedsAsPointSetNode);
m_SeedsAsPointSet->RemoveObserver(m_PointSetAddObserverTag);
m_SeedsAsPointSet->RemoveObserver(m_PointSetRemoveObserverTag);
}
void mitk::FastMarchingTool3D::Initialize()
{
m_ReferenceImage = dynamic_cast<mitk::Image*>(m_ToolManager->GetReferenceData(0)->GetData());
- if(m_ReferenceImage->GetTimeGeometry()->GetNumberOfTimeSteps() > 1)
+ if(m_ReferenceImage->GetTimeGeometry()->CountTimeSteps() > 1)
{
mitk::ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
timeSelector->SetInput( m_ReferenceImage );
timeSelector->SetTimeNr( m_CurrentTimeStep );
timeSelector->UpdateLargestPossibleRegion();
m_ReferenceImage = timeSelector->GetOutput();
}
CastToItkImage(m_ReferenceImage, m_ReferenceImageAsITK);
m_SmoothFilter->SetInput( m_ReferenceImageAsITK );
m_NeedUpdate = true;
}
void mitk::FastMarchingTool3D::ConfirmSegmentation()
{
// combine preview image with current working segmentation
if (dynamic_cast<mitk::Image*>(m_ResultImageNode->GetData()))
{
//logical or combination of preview and segmentation slice
OutputImageType::Pointer segmentationImageInITK = OutputImageType::New();
mitk::Image::Pointer workingImage = dynamic_cast<mitk::Image*>(GetTargetSegmentationNode()->GetData());
- if(workingImage->GetTimeGeometry()->GetNumberOfTimeSteps() > 1)
+ if(workingImage->GetTimeGeometry()->CountTimeSteps() > 1)
{
mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
timeSelector->SetInput( workingImage );
timeSelector->SetTimeNr( m_CurrentTimeStep );
timeSelector->UpdateLargestPossibleRegion();
CastToItkImage( timeSelector->GetOutput(), segmentationImageInITK );
}
else
{
CastToItkImage( workingImage, segmentationImageInITK );
}
typedef itk::OrImageFilter<OutputImageType, OutputImageType> OrImageFilterType;
OrImageFilterType::Pointer orFilter = OrImageFilterType::New();
orFilter->SetInput(0, m_ThresholdFilter->GetOutput());
orFilter->SetInput(1, segmentationImageInITK);
orFilter->Update();
//set image volume in current time step from itk image
workingImage->SetVolume( (void*)(m_ThresholdFilter->GetOutput()->GetPixelContainer()->GetBufferPointer()), m_CurrentTimeStep);
this->m_ResultImageNode->SetVisibility(false);
this->ClearSeeds();
workingImage->Modified();
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::FastMarchingTool3D::OnAddPoint()
{
// Add a new seed point for FastMarching algorithm
mitk::Point3D clickInIndex;
m_ReferenceImage->GetGeometry()->WorldToIndex(m_SeedsAsPointSet->GetPoint(m_SeedsAsPointSet->GetSize()-1),
clickInIndex);
itk::Index<3> seedPosition;
seedPosition[0] = clickInIndex[0];
seedPosition[1] = clickInIndex[1];
seedPosition[2] = clickInIndex[2];
NodeType node;
const double seedValue = 0.0;
node.SetValue( seedValue );
node.SetIndex( seedPosition );
this->m_SeedContainer->InsertElement(this->m_SeedContainer->Size(), node);
m_FastMarchingFilter->Modified();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
m_NeedUpdate = true;
m_ReadyMessage.Send();
this->Update();
}
void mitk::FastMarchingTool3D::OnDelete()
{
// delete last seed point
if(!(this->m_SeedContainer->empty()))
{
//delete last element of seeds container
this->m_SeedContainer->pop_back();
m_FastMarchingFilter->Modified();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
m_NeedUpdate = true;
this->Update();
}
}
void mitk::FastMarchingTool3D::Update()
{
const unsigned int progress_steps = 200;
if (m_NeedUpdate)
{
m_ProgressCommand->AddStepsToDo(progress_steps);
//remove interaction with poinset while updating
mitk::GlobalInteraction::GetInstance()->RemoveInteractor(m_SeedPointInteractor);
CurrentlyBusy.Send(true);
try
{
m_ThresholdFilter->Update();
}
catch( itk::ExceptionObject & excep )
{
MITK_ERROR << "Exception caught: " << excep.GetDescription();
m_ProgressCommand->SetProgress(progress_steps);
CurrentlyBusy.Send(false);
std::string msg = excep.GetDescription();
ErrorMessage.Send(msg);
return;
}
m_ProgressCommand->SetProgress(progress_steps);
CurrentlyBusy.Send(false);
//make output visible
mitk::Image::Pointer result = mitk::Image::New();
CastToMitkImage( m_ThresholdFilter->GetOutput(), result);
result->GetGeometry()->SetOrigin(m_ReferenceImage->GetGeometry()->GetOrigin() );
result->GetGeometry()->SetIndexToWorldTransform(m_ReferenceImage->GetGeometry()->GetIndexToWorldTransform() );
m_ResultImageNode->SetData(result);
m_ResultImageNode->SetVisibility(true);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
//add interaction with poinset again
mitk::GlobalInteraction::GetInstance()->AddInteractor(m_SeedPointInteractor);
}
}
void mitk::FastMarchingTool3D::ClearSeeds()
{
// clear seeds for FastMarching as well as the PointSet for visualization
if(this->m_SeedContainer.IsNotNull())
this->m_SeedContainer->Initialize();
if(this->m_SeedsAsPointSet.IsNotNull())
{
//remove observers from current pointset
m_SeedsAsPointSet->RemoveObserver(m_PointSetAddObserverTag);
m_SeedsAsPointSet->RemoveObserver(m_PointSetRemoveObserverTag);
//renew pointset
this->m_SeedsAsPointSet = mitk::PointSet::New();
this->m_SeedsAsPointSetNode->SetData(this->m_SeedsAsPointSet);
m_SeedsAsPointSetNode->SetName("Seeds_Preview");
m_SeedsAsPointSetNode->SetBoolProperty("helper object", true);
m_SeedsAsPointSetNode->SetColor(0.0, 1.0, 0.0);
m_SeedsAsPointSetNode->SetVisibility(true);
//add callback function for adding and removing points
itk::SimpleMemberCommand<mitk::FastMarchingTool3D>::Pointer pointAddedCommand = itk::SimpleMemberCommand<mitk::FastMarchingTool3D>::New();
pointAddedCommand->SetCallbackFunction(this, &mitk::FastMarchingTool3D::OnAddPoint);
m_PointSetAddObserverTag = m_SeedsAsPointSet->AddObserver( mitk::PointSetAddEvent(), pointAddedCommand);
itk::SimpleMemberCommand<mitk::FastMarchingTool3D>::Pointer pointRemovedCommand = itk::SimpleMemberCommand<mitk::FastMarchingTool3D>::New();
pointRemovedCommand->SetCallbackFunction(this, &mitk::FastMarchingTool3D::OnDelete);
m_PointSetRemoveObserverTag = m_SeedsAsPointSet->AddObserver( mitk::PointSetRemoveEvent(), pointRemovedCommand);
}
if(this->m_FastMarchingFilter.IsNotNull())
m_FastMarchingFilter->Modified();
this->m_NeedUpdate = true;
}
void mitk::FastMarchingTool3D::Reset()
{
//clear all seeds and preview empty result
this->ClearSeeds();
m_ResultImageNode->SetVisibility(false);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::FastMarchingTool3D::SetCurrentTimeStep(int t)
{
if( m_CurrentTimeStep != t )
{
m_CurrentTimeStep = t;
this->Initialize();
}
}
diff --git a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
index c8663f760b..22f1ace3c0 100644
--- a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
+++ b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
@@ -1,694 +1,694 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkLiveWireTool2D.h"
#include "mitkToolManager.h"
#include "mitkBaseRenderer.h"
#include "mitkRenderingManager.h"
#include "mitkLiveWireTool2D.xpm"
#include <mitkInteractionConst.h>
#include <mitkGlobalInteraction.h>
#include "mitkContourUtils.h"
#include "mitkContour.h"
#include <itkGradientMagnitudeImageFilter.h>
// us
#include <usModule.h>
#include <usModuleResource.h>
#include <usGetModuleContext.h>
#include <usModuleContext.h>
namespace mitk {
MITK_TOOL_MACRO(Segmentation_EXPORT, LiveWireTool2D, "LiveWire tool");
}
mitk::LiveWireTool2D::LiveWireTool2D()
:SegTool2D("LiveWireTool")
{
// great magic numbers
CONNECT_ACTION( AcINITNEWOBJECT, OnInitLiveWire );
CONNECT_ACTION( AcADDPOINT, OnAddPoint );
CONNECT_ACTION( AcMOVE, OnMouseMoveNoDynamicCosts );
CONNECT_ACTION( AcCHECKPOINT, OnCheckPoint );
CONNECT_ACTION( AcFINISH, OnFinish );
CONNECT_ACTION( AcDELETEPOINT, OnLastSegmentDelete );
CONNECT_ACTION( AcADDLINE, OnMouseMoved );
}
mitk::LiveWireTool2D::~LiveWireTool2D()
{
this->m_WorkingContours.clear();
this->m_EditingContours.clear();
}
float mitk::LiveWireTool2D::CanHandleEvent( StateEvent const *stateEvent) const
{
mitk::PositionEvent const *positionEvent =
dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
//Key event handling:
if (positionEvent == NULL)
{
//check for delete and escape event
if(stateEvent->GetId() == 12 || stateEvent->GetId() == 14)
{
return 1.0;
}
//check, if the current state has a transition waiting for that key event.
else if (this->GetCurrentState()->GetTransition(stateEvent->GetId())!=NULL)
{
return 0.5;
}
else
{
return 0.0;
}
}
else
{
if ( positionEvent->GetSender()->GetMapperID() != BaseRenderer::Standard2D )
return 0.0; // we don't want anything but 2D
return 1.0;
}
}
const char** mitk::LiveWireTool2D::GetXPM() const
{
return mitkLiveWireTool2D_xpm;
}
us::ModuleResource mitk::LiveWireTool2D::GetIconResource() const
{
us::Module* module = us::GetModuleContext()->GetModule();
us::ModuleResource resource = module->GetResource("LiveWire_48x48.png");
return resource;
}
us::ModuleResource mitk::LiveWireTool2D::GetCursorIconResource() const
{
us::Module* module = us::GetModuleContext()->GetModule();
us::ModuleResource resource = module->GetResource("LiveWire_Cursor_32x32.png");
return resource;
}
const char* mitk::LiveWireTool2D::GetName() const
{
return "Live Wire";
}
void mitk::LiveWireTool2D::Activated()
{
Superclass::Activated();
//enable interaction if there are any previously created contours
this->EnableContourLiveWireInteraction(true);
}
void mitk::LiveWireTool2D::Deactivated()
{
Superclass::Deactivated();
//disable interaction with current contours
this->EnableContourLiveWireInteraction(false);
}
void mitk::LiveWireTool2D::ClearContours()
{
// for all contours in list (currently created by tool)
std::vector< std::pair<mitk::DataNode::Pointer, mitk::PlaneGeometry::Pointer> >::iterator iter = this->m_WorkingContours.begin();
while(iter != this->m_WorkingContours.end() )
{
//remove contour node from datastorage
m_ToolManager->GetDataStorage()->Remove( iter->first );
++iter;
}
this->m_WorkingContours.clear();
// for all contours in list (currently created by tool)
std::vector< std::pair<mitk::DataNode::Pointer, mitk::PlaneGeometry::Pointer> >::iterator itEditingContours = this->m_EditingContours.begin();
while(itEditingContours != this->m_EditingContours.end() )
{
//remove contour node from datastorage
m_ToolManager->GetDataStorage()->Remove( itEditingContours->first );
++itEditingContours;
}
this->m_EditingContours.clear();
this->EnableContourLiveWireInteraction(false);
this->m_LiveWireInteractors.clear();
}
void mitk::LiveWireTool2D::EnableContourLiveWireInteraction(bool on)
{
//for all currently created contours enable or disable interactor
std::vector< mitk::ContourModelLiveWireInteractor::Pointer >::iterator itLiveWireInteractors = this->m_LiveWireInteractors.begin();
std::vector< mitk::ContourModelLiveWireInteractor::Pointer >::iterator end = this->m_LiveWireInteractors.end();
while(itLiveWireInteractors != end )
{
if(on)
{
// add interactors to globalInteraction instance
mitk::GlobalInteraction::GetInstance()->AddInteractor( *itLiveWireInteractors );
}
else
{
// remove interactors from globalInteraction instance
mitk::GlobalInteraction::GetInstance()->RemoveInteractor( *itLiveWireInteractors );
}
++itLiveWireInteractors;
}
}
void mitk::LiveWireTool2D::ConfirmSegmentation()
{
DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
assert ( workingNode );
Image* workingImage = dynamic_cast<Image*>(workingNode->GetData());
assert ( workingImage );
ContourUtils::Pointer contourUtils = mitk::ContourUtils::New();
// for all contours in list (currently created by tool)
std::vector< std::pair<mitk::DataNode::Pointer, mitk::PlaneGeometry::Pointer> >::iterator itWorkingContours = this->m_WorkingContours.begin();
while(itWorkingContours != this->m_WorkingContours.end() )
{
// if node contains data
if( itWorkingContours->first->GetData() )
{
// if this is a contourModel
mitk::ContourModel* contourModel = dynamic_cast<mitk::ContourModel*>(itWorkingContours->first->GetData());
if( contourModel )
{
// for each timestep of this contourModel
- for( TimeStepType currentTimestep = 0; currentTimestep < contourModel->GetTimeGeometry()->GetNumberOfTimeSteps(); ++currentTimestep)
+ for( TimeStepType currentTimestep = 0; currentTimestep < contourModel->GetTimeGeometry()->CountTimeSteps(); ++currentTimestep)
{
//get the segmentation image slice at current timestep
mitk::Image::Pointer workingSlice = this->GetAffectedImageSliceAs2DImage(itWorkingContours->second, workingImage, currentTimestep);
mitk::ContourModel::Pointer projectedContour = contourUtils->ProjectContourTo2DSlice(workingSlice, contourModel, true, false);
contourUtils->FillContourInSlice(projectedContour, workingSlice, 1.0);
//write back to image volume
this->WriteBackSegmentationResult(itWorkingContours->second, workingSlice, currentTimestep);
}
//remove contour node from datastorage
// m_ToolManager->GetDataStorage()->Remove( itWorkingContours->first );
}
}
++itWorkingContours;
}
/*
this->m_WorkingContours.clear();
// for all contours in list (currently created by tool)
std::vector< std::pair<mitk::DataNode::Pointer, mitk::PlaneGeometry::Pointer> >::iterator itEditingContours = this->m_EditingContours.begin();
while(itEditingContours != this->m_EditingContours.end() )
{
//remove contour node from datastorage
m_ToolManager->GetDataStorage()->Remove( itEditingContours->first );
++itEditingContours;
}
this->m_EditingContours.clear();
std::vector< mitk::ContourModelLiveWireInteractor::Pointer >::iterator itLiveWireInteractors = this->m_LiveWireInteractors.begin();
while(itLiveWireInteractors != this->m_LiveWireInteractors.end() )
{
// remove interactors from globalInteraction instance
mitk::GlobalInteraction::GetInstance()->RemoveInteractor( *itLiveWireInteractors );
++itLiveWireInteractors;
}
this->m_LiveWireInteractors.clear();
*/
this->ClearContours();
}
bool mitk::LiveWireTool2D::OnInitLiveWire (Action* action, const StateEvent* stateEvent)
{
const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
if (!positionEvent) return false;
m_LastEventSender = positionEvent->GetSender();
m_LastEventSlice = m_LastEventSender->GetSlice();
if ( Superclass::CanHandleEvent(stateEvent) < 1.0 ) return false;
int timestep = positionEvent->GetSender()->GetTimeStep();
m_Contour = mitk::ContourModel::New();
m_Contour->Expand(timestep+1);
m_ContourModelNode = mitk::DataNode::New();
m_ContourModelNode->SetData( m_Contour );
m_ContourModelNode->SetName("working contour node");
m_ContourModelNode->AddProperty( "contour.color", ColorProperty::New(1, 1, 0), NULL, true );
m_ContourModelNode->AddProperty( "contour.points.color", ColorProperty::New(1.0, 0.0, 0.1), NULL, true );
m_ContourModelNode->AddProperty( "contour.controlpoints.show", BoolProperty::New(true), NULL, true );
m_LiveWireContour = mitk::ContourModel::New();
m_LiveWireContour->Expand(timestep+1);
m_LiveWireContourNode = mitk::DataNode::New();
m_LiveWireContourNode->SetData( m_LiveWireContour );
m_LiveWireContourNode->SetName("active livewire node");
m_LiveWireContourNode->SetProperty( "layer", IntProperty::New(100));
m_LiveWireContourNode->SetProperty( "helper object", mitk::BoolProperty::New(true));
m_LiveWireContourNode->AddProperty( "contour.color", ColorProperty::New(0.1, 1.0, 0.1), NULL, true );
m_LiveWireContourNode->AddProperty( "contour.width", mitk::FloatProperty::New( 4.0 ), NULL, true );
m_EditingContour = mitk::ContourModel::New();
m_EditingContour->Expand(timestep+1);
m_EditingContourNode = mitk::DataNode::New();
m_EditingContourNode->SetData( m_EditingContour );
m_EditingContourNode->SetName("editing node");
m_EditingContourNode->SetProperty( "layer", IntProperty::New(100));
m_EditingContourNode->SetProperty( "helper object", mitk::BoolProperty::New(true));
m_EditingContourNode->AddProperty( "contour.color", ColorProperty::New(0.1, 1.0, 0.1), NULL, true );
m_EditingContourNode->AddProperty( "contour.points.color", ColorProperty::New(0.0, 0.0, 1.0), NULL, true );
m_EditingContourNode->AddProperty( "contour.width", mitk::FloatProperty::New( 4.0 ), NULL, true );
m_ToolManager->GetDataStorage()->Add( m_ContourModelNode );
m_ToolManager->GetDataStorage()->Add( m_LiveWireContourNode );
m_ToolManager->GetDataStorage()->Add( m_EditingContourNode );
//set current slice as input for ImageToLiveWireContourFilter
m_WorkingSlice = this->GetAffectedReferenceSlice(positionEvent);
m_LiveWireFilter = mitk::ImageLiveWireContourModelFilter::New();
m_LiveWireFilter->SetInput(m_WorkingSlice);
//map click to pixel coordinates
mitk::Point3D click = const_cast<mitk::Point3D &>(positionEvent->GetWorldPosition());
itk::Index<3> idx;
m_WorkingSlice->GetGeometry()->WorldToIndex(click, idx);
// get the pixel the gradient in region of 5x5
itk::Index<3> indexWithHighestGradient;
AccessFixedDimensionByItk_2(m_WorkingSlice, FindHighestGradientMagnitudeByITK, 2, idx, indexWithHighestGradient);
// itk::Index to mitk::Point3D
click[0] = indexWithHighestGradient[0];
click[1] = indexWithHighestGradient[1];
click[2] = indexWithHighestGradient[2];
m_WorkingSlice->GetGeometry()->IndexToWorld(click, click);
//set initial start point
m_Contour->AddVertex( click, true, timestep );
m_LiveWireFilter->SetStartPoint(click);
m_CreateAndUseDynamicCosts = true;
//render
assert( positionEvent->GetSender()->GetRenderWindow() );
mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
return true;
}
bool mitk::LiveWireTool2D::OnAddPoint (Action* action, const StateEvent* stateEvent)
{
//complete LiveWire interaction for last segment
//add current LiveWire contour to the finished contour and reset
//to start new segment and computation
/* check if event can be handled */
const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
if (!positionEvent) return false;
if ( Superclass::CanHandleEvent(stateEvent) < 1.0 ) return false;
/* END check if event can be handled */
int timestep = positionEvent->GetSender()->GetTimeStep();
//add repulsive points to avoid to get the same path again
typedef mitk::ImageLiveWireContourModelFilter::InternalImageType::IndexType IndexType;
mitk::ContourModel::ConstVertexIterator iter = m_LiveWireContour->IteratorBegin(timestep);
for (;iter != m_LiveWireContour->IteratorEnd(timestep); iter++)
{
IndexType idx;
this->m_WorkingSlice->GetGeometry()->WorldToIndex((*iter)->Coordinates, idx);
this->m_LiveWireFilter->AddRepulsivePoint( idx );
}
//remove duplicate first vertex, it's already contained in m_Contour
m_LiveWireContour->RemoveVertexAt(0, timestep);
// set last added point as control point
m_LiveWireContour->SetControlVertexAt(m_LiveWireContour->GetNumberOfVertices(timestep)-1, timestep);
//merge contours
m_Contour->Concatenate(m_LiveWireContour, timestep);
//clear the livewire contour and reset the corresponding datanode
m_LiveWireContour->Clear(timestep);
//set new start point
m_LiveWireFilter->SetStartPoint(const_cast<mitk::Point3D &>(positionEvent->GetWorldPosition()));
if( m_CreateAndUseDynamicCosts )
{
//use dynamic cost map for next update
m_LiveWireFilter->CreateDynamicCostMap(m_Contour);
m_LiveWireFilter->SetUseDynamicCostMap(true);
//m_CreateAndUseDynamicCosts = false;
}
//render
assert( positionEvent->GetSender()->GetRenderWindow() );
mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
return true;
}
bool mitk::LiveWireTool2D::OnMouseMoved( Action* action, const StateEvent* stateEvent)
{
//compute LiveWire segment from last control point to current mouse position
// check if event can be handled
if ( Superclass::CanHandleEvent(stateEvent) < 1.0 ) return false;
const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
if (!positionEvent) return false;
// actual LiveWire computation
int timestep = positionEvent->GetSender()->GetTimeStep();
m_LiveWireFilter->SetEndPoint(const_cast<mitk::Point3D &>(positionEvent->GetWorldPosition()));
m_LiveWireFilter->SetTimeStep(m_TimeStep);
m_LiveWireFilter->Update();
m_LiveWireContour = this->m_LiveWireFilter->GetOutput();
m_LiveWireContourNode->SetData( this->m_LiveWireContour );
//render
assert( positionEvent->GetSender()->GetRenderWindow() );
mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
return true;
}
bool mitk::LiveWireTool2D::OnMouseMoveNoDynamicCosts(Action* action, const StateEvent* stateEvent)
{
//do not use dynamic cost map
m_LiveWireFilter->SetUseDynamicCostMap(false);
OnMouseMoved(action, stateEvent);
m_LiveWireFilter->SetUseDynamicCostMap(true);
return true;
}
bool mitk::LiveWireTool2D::OnCheckPoint( Action* action, const StateEvent* stateEvent)
{
//check double click on first control point to finish the LiveWire tool
//
//Check distance to first point.
//Transition YES if click close to first control point
//
mitk::StateEvent* newStateEvent = NULL;
const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
if (!positionEvent)
{
//stay in current state
newStateEvent = new mitk::StateEvent(EIDNO, stateEvent->GetEvent());
}
else
{
int timestep = positionEvent->GetSender()->GetTimeStep();
mitk::Point3D click = positionEvent->GetWorldPosition();
mitk::Point3D first = this->m_Contour->GetVertexAt(0, timestep)->Coordinates;
if (first.EuclideanDistanceTo(click) < 4.5)
{
// allow to finish
newStateEvent = new mitk::StateEvent(EIDYES, stateEvent->GetEvent());
}
else
{
//stay active
newStateEvent = new mitk::StateEvent(EIDNO, stateEvent->GetEvent());
}
}
this->HandleEvent( newStateEvent );
return true;
}
bool mitk::LiveWireTool2D::OnFinish( Action* action, const StateEvent* stateEvent)
{
// finish livewire tool interaction
// check if event can be handled
if ( Superclass::CanHandleEvent(stateEvent) < 1.0 ) return false;
const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
if (!positionEvent) return false;
// actual timestep
int timestep = positionEvent->GetSender()->GetTimeStep();
// remove last control point being added by double click
m_Contour->RemoveVertexAt(m_Contour->GetNumberOfVertices(timestep) - 1, timestep);
// save contour and corresponding plane geometry to list
std::pair<mitk::DataNode::Pointer, mitk::PlaneGeometry::Pointer> cp(m_ContourModelNode, dynamic_cast<mitk::PlaneGeometry*>(positionEvent->GetSender()->GetCurrentWorldGeometry2D()->Clone().GetPointer()) );
this->m_WorkingContours.push_back(cp);
std::pair<mitk::DataNode::Pointer, mitk::PlaneGeometry::Pointer> ecp(m_EditingContourNode, dynamic_cast<mitk::PlaneGeometry*>(positionEvent->GetSender()->GetCurrentWorldGeometry2D()->Clone().GetPointer()) );
this->m_EditingContours.push_back(ecp);
m_LiveWireFilter->SetUseDynamicCostMap(false);
this->FinishTool();
return true;
}
void mitk::LiveWireTool2D::FinishTool()
{
- TimeStepType numberOfTimesteps = m_Contour->GetTimeGeometry()->GetNumberOfTimeSteps();
+ TimeStepType numberOfTimesteps = m_Contour->GetTimeGeometry()->CountTimeSteps();
//close contour in each timestep
for( int i = 0; i <= numberOfTimesteps; i++)
{
m_Contour->Close(i);
}
m_ToolManager->GetDataStorage()->Remove( m_LiveWireContourNode );
// clear live wire contour node
m_LiveWireContourNode = NULL;
m_LiveWireContour = NULL;
//change color as visual feedback of completed livewire
//m_ContourModelNode->AddProperty( "contour.color", ColorProperty::New(1.0, 1.0, 0.1), NULL, true );
//m_ContourModelNode->SetName("contour node");
//set the livewire interactor to edit control points
m_ContourInteractor = mitk::ContourModelLiveWireInteractor::New(m_ContourModelNode);
m_ContourInteractor->SetWorkingImage(this->m_WorkingSlice);
m_ContourInteractor->SetEditingContourModelNode(this->m_EditingContourNode);
m_ContourModelNode->SetInteractor(m_ContourInteractor);
this->m_LiveWireInteractors.push_back( m_ContourInteractor );
//add interactor to globalInteraction instance
mitk::GlobalInteraction::GetInstance()->AddInteractor(m_ContourInteractor);
}
bool mitk::LiveWireTool2D::OnLastSegmentDelete( Action* action, const StateEvent* stateEvent)
{
int timestep = stateEvent->GetEvent()->GetSender()->GetTimeStep();
//if last point of current contour will be removed go to start state and remove nodes
if( m_Contour->GetNumberOfVertices(timestep) <= 1 )
{
m_ToolManager->GetDataStorage()->Remove( m_LiveWireContourNode );
m_ToolManager->GetDataStorage()->Remove( m_ContourModelNode );
m_ToolManager->GetDataStorage()->Remove( m_EditingContourNode );
m_LiveWireContour = mitk::ContourModel::New();
m_Contour = mitk::ContourModel::New();
m_ContourModelNode->SetData( m_Contour );
m_LiveWireContourNode->SetData( m_LiveWireContour );
Superclass::Deactivated(); //go to start state
}
else //remove last segment from contour and reset livewire contour
{
m_LiveWireContour = mitk::ContourModel::New();
m_LiveWireContourNode->SetData(m_LiveWireContour);
mitk::ContourModel::Pointer newContour = mitk::ContourModel::New();
newContour->Expand(m_Contour->GetTimeSteps());
mitk::ContourModel::VertexIterator begin = m_Contour->IteratorBegin();
//iterate from last point to next active point
mitk::ContourModel::VertexIterator newLast = m_Contour->IteratorBegin() + (m_Contour->GetNumberOfVertices() - 1);
//go at least one down
if(newLast != begin)
{
newLast--;
}
//search next active control point
while(newLast != begin && !((*newLast)->IsControlPoint) )
{
newLast--;
}
//set position of start point for livewire filter to coordinates of the new last point
m_LiveWireFilter->SetStartPoint((*newLast)->Coordinates);
mitk::ContourModel::VertexIterator it = m_Contour->IteratorBegin();
//fill new Contour
while(it <= newLast)
{
newContour->AddVertex((*it)->Coordinates, (*it)->IsControlPoint, timestep);
it++;
}
newContour->SetIsClosed(m_Contour->IsClosed());
//set new contour visible
m_ContourModelNode->SetData(newContour);
m_Contour = newContour;
assert( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
mitk::RenderingManager::GetInstance()->RequestUpdate( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
}
return true;
}
template<typename TPixel, unsigned int VImageDimension>
void mitk::LiveWireTool2D::FindHighestGradientMagnitudeByITK(itk::Image<TPixel, VImageDimension>* inputImage, itk::Index<3> &index, itk::Index<3> &returnIndex)
{
typedef itk::Image<TPixel, VImageDimension> InputImageType;
typedef typename InputImageType::IndexType IndexType;
unsigned long xMAX = inputImage->GetLargestPossibleRegion().GetSize()[0];
unsigned long yMAX = inputImage->GetLargestPossibleRegion().GetSize()[1];
returnIndex[0] = index[0];
returnIndex[1] = index[1];
returnIndex[2] = 0.0;
double gradientMagnitude = 0.0;
double maxGradientMagnitude = 0.0;
/*
the size and thus the region of 7x7 is only used to calculate the gradient magnitude in that region
not for searching the maximum value
*/
//maximum value in each direction for size
typename InputImageType::SizeType size;
size[0] = 7;
size[1] = 7;
//minimum value in each direction for startRegion
IndexType startRegion;
startRegion[0] = index[0] - 3;
startRegion[1] = index[1] - 3;
if(startRegion[0] < 0) startRegion[0] = 0;
if(startRegion[1] < 0) startRegion[1] = 0;
if(xMAX - index[0] < 7) startRegion[0] = xMAX - 7;
if(yMAX - index[1] < 7) startRegion[1] = yMAX - 7;
index[0] = startRegion[0] + 3;
index[1] = startRegion[1] + 3;
typename InputImageType::RegionType region;
region.SetSize( size );
region.SetIndex( startRegion );
typedef typename itk::GradientMagnitudeImageFilter< InputImageType, InputImageType> GradientMagnitudeFilterType;
typename GradientMagnitudeFilterType::Pointer gradientFilter = GradientMagnitudeFilterType::New();
gradientFilter->SetInput(inputImage);
gradientFilter->GetOutput()->SetRequestedRegion(region);
gradientFilter->Update();
typename InputImageType::Pointer gradientMagnImage;
gradientMagnImage = gradientFilter->GetOutput();
IndexType currentIndex;
currentIndex[0] = 0;
currentIndex[1] = 0;
// search max (approximate) gradient magnitude
for( int x = -1; x <= 1; ++x)
{
currentIndex[0] = index[0] + x;
for( int y = -1; y <= 1; ++y)
{
currentIndex[1] = index[1] + y;
gradientMagnitude = gradientMagnImage->GetPixel(currentIndex);
//check for new max
if(maxGradientMagnitude < gradientMagnitude)
{
maxGradientMagnitude = gradientMagnitude;
returnIndex[0] = currentIndex[0];
returnIndex[1] = currentIndex[1];
returnIndex[2] = 0.0;
}//end if
}//end for y
currentIndex[1] = index[1];
}//end for x
}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkAdaptiveRegionGrowingToolGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitkAdaptiveRegionGrowingToolGUI.cpp
index 0516d1714f..7b7c285928 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkAdaptiveRegionGrowingToolGUI.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkAdaptiveRegionGrowingToolGUI.cpp
@@ -1,834 +1,834 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "QmitkAdaptiveRegionGrowingToolGUI.h"
#include "QmitkStdMultiWidget.h"
#include <qmessagebox.h>
#include "mitkNodePredicateDataType.h"
#include "mitkGlobalInteraction.h"
#include "mitkPointSetInteractor.h"
#include "mitkProperties.h"
#include "mitkITKImageImport.h"
#include "mitkImageAccessByItk.h"
#include "mitkTransferFunctionProperty.h"
#include "mitkImageTimeSelector.h"
#include "mitkImageStatisticsHolder.h"
#include <itkConnectedAdaptiveThresholdImageFilter.h>
#include <itkMinimumMaximumImageCalculator.h>
#include <itkBinaryThresholdImageFilter.h>
#include <itkImageIterator.h>
#include "itkOrImageFilter.h"
#include "mitkImageCast.h"
#include "QmitkConfirmSegmentationDialog.h"
MITK_TOOL_GUI_MACRO( , QmitkAdaptiveRegionGrowingToolGUI, "")
QmitkAdaptiveRegionGrowingToolGUI::QmitkAdaptiveRegionGrowingToolGUI(QWidget* parent) :
QmitkToolGUI(), m_MultiWidget(NULL), m_UseVolumeRendering(false), m_UpdateSuggestedThreshold(true), m_SuggestedThValue(0.0), m_DataStorage(NULL)
{
this->setParent(parent);
m_Controls.setupUi(this);
m_Controls.m_ThresholdSlider->setDecimals(1);
m_Controls.m_ThresholdSlider->setSpinBoxAlignment(Qt::AlignVCenter);
m_Controls.m_PreviewSlider->setEnabled(false);
m_Controls.m_PreviewSlider->setSingleStep(0.5);
//Not yet available
//m_Controls.m_PreviewSlider->InvertedAppearance(true);
this->CreateConnections();
this->SetDataNodeNames("labeledRGSegmentation","RGResult","RGFeedbackSurface");
connect( this, SIGNAL(NewToolAssociated(mitk::Tool*)), this, SLOT(OnNewToolAssociated(mitk::Tool*)) );
}
QmitkAdaptiveRegionGrowingToolGUI::~QmitkAdaptiveRegionGrowingToolGUI()
{
//Removing the observer of the PointSet node
if (m_RegionGrow3DTool->GetPointSetNode().IsNotNull())
{
m_RegionGrow3DTool->GetPointSetNode()->GetData()->RemoveObserver(m_PointSetAddObserverTag);
}
this->RemoveHelperNodes();
}
void QmitkAdaptiveRegionGrowingToolGUI::OnNewToolAssociated(mitk::Tool* tool)
{
m_RegionGrow3DTool = dynamic_cast<mitk::AdaptiveRegionGrowingTool*> (tool);
if(m_RegionGrow3DTool.IsNotNull())
{
SetInputImageNode( this->m_RegionGrow3DTool->GetReferenceData() );
this->m_DataStorage = this->m_RegionGrow3DTool->GetDataStorage();
this->EnableControls(true);
//Watch for point added or modified
itk::SimpleMemberCommand<QmitkAdaptiveRegionGrowingToolGUI>::Pointer pointAddedCommand = itk::SimpleMemberCommand<QmitkAdaptiveRegionGrowingToolGUI>::New();
pointAddedCommand->SetCallbackFunction(this, &QmitkAdaptiveRegionGrowingToolGUI::OnPointAdded);
m_PointSetAddObserverTag = m_RegionGrow3DTool->GetPointSetNode()->GetData()->AddObserver( mitk::PointSetAddEvent(), pointAddedCommand);
}
else
{
this->EnableControls(false);
}
}
void QmitkAdaptiveRegionGrowingToolGUI::RemoveHelperNodes()
{
mitk::DataNode::Pointer imageNode = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
if( imageNode.IsNotNull() )
{
m_DataStorage->Remove(imageNode);
}
}
void QmitkAdaptiveRegionGrowingToolGUI::CreateConnections()
{
//Connecting GUI components
connect( (QObject*) (m_Controls.m_pbRunSegmentation), SIGNAL(clicked()), this, SLOT(RunSegmentation()));
connect( m_Controls.m_PreviewSlider, SIGNAL(valueChanged(double)), this, SLOT(ChangeLevelWindow(double)));
connect( (QObject*) (m_Controls.m_pbConfirmSegementation), SIGNAL(clicked()), this, SLOT(ConfirmSegmentation()));
connect( (QObject*) (m_Controls.m_cbVolumeRendering), SIGNAL(toggled(bool)), this, SLOT(UseVolumeRendering(bool) ));
connect( m_Controls.m_ThresholdSlider, SIGNAL(maximumValueChanged(double)), this, SLOT(SetUpperThresholdValue(double)));
connect( m_Controls.m_ThresholdSlider, SIGNAL(minimumValueChanged(double)), this, SLOT(SetLowerThresholdValue(double)));
}
void QmitkAdaptiveRegionGrowingToolGUI::SetDataNodeNames(std::string labledSegmentation, std::string binaryImage, std::string surface)
{
m_NAMEFORLABLEDSEGMENTATIONIMAGE = labledSegmentation;
m_NAMEFORBINARYIMAGE = binaryImage;
m_NAMEFORSURFACE = surface;
}
void QmitkAdaptiveRegionGrowingToolGUI::SetDataStorage(mitk::DataStorage* dataStorage)
{
m_DataStorage = dataStorage;
}
void QmitkAdaptiveRegionGrowingToolGUI::SetMultiWidget(QmitkStdMultiWidget* multiWidget)
{
m_MultiWidget = multiWidget;
}
void QmitkAdaptiveRegionGrowingToolGUI::SetInputImageNode(mitk::DataNode* node)
{
m_InputImageNode = node;
mitk::Image* inputImage = dynamic_cast<mitk::Image*>(m_InputImageNode->GetData());
if (inputImage)
{
mitk::ScalarType max = inputImage->GetStatistics()->GetScalarValueMax();
mitk::ScalarType min = inputImage->GetStatistics()->GetScalarValueMin();
m_Controls.m_ThresholdSlider->setMaximum(max);
m_Controls.m_ThresholdSlider->setMinimum(min);
// Just for initialization
m_Controls.m_ThresholdSlider->setMaximumValue(max);
m_Controls.m_ThresholdSlider->setMinimumValue(min);
}
}
void QmitkAdaptiveRegionGrowingToolGUI::OnPointAdded()
{
if (m_RegionGrow3DTool.IsNull())
return;
mitk::DataNode* node = m_RegionGrow3DTool->GetPointSetNode();
if (node != NULL)
{
mitk::PointSet::Pointer pointSet = dynamic_cast<mitk::PointSet*>(node->GetData());
if (pointSet.IsNull())
{
QMessageBox::critical(NULL, "QmitkAdaptiveRegionGrowingToolGUI", "PointSetNode does not contain a pointset");
return;
}
m_Controls.m_lblSetSeedpoint->setText("");
mitk::Image* image = dynamic_cast<mitk::Image*>(m_InputImageNode->GetData());
mitk::Point3D seedPoint = pointSet->GetPointSet(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1") )->GetTimeStep())->GetPoints()->ElementAt(0);
m_SeedpointValue = image->GetPixelValueByWorldCoordinate(seedPoint);
/* In this case the seedpoint is placed e.g. in the lung or bronchialtree
* The lowerFactor sets the windowsize depending on the regiongrowing direction
*/
m_CurrentRGDirectionIsUpwards = true;
if (m_SeedpointValue < -500)
{
m_CurrentRGDirectionIsUpwards = false;
}
// Initializing the region by the area around the seedpoint
m_SeedPointValueMean = 0;
mitk::Index3D currentIndex, runningIndex;
mitk::ScalarType pixelValues[125];
unsigned int pos (0);
image->GetGeometry(0)->WorldToIndex(seedPoint, currentIndex);
runningIndex = currentIndex;
for(int i = runningIndex[0]-2; i <= runningIndex[0]+2; i++)
{
for(int j = runningIndex[1]-2; j <= runningIndex[1]+2; j++)
{
for(int k = runningIndex[2]-2; k <= runningIndex[2]+2; k++)
{
currentIndex[0] = i;
currentIndex[1] = j;
currentIndex[2] = k;
if(image->GetGeometry()->IsIndexInside(currentIndex))
{
pixelValues[pos] = image->GetPixelValueByIndex(currentIndex);
pos++;
}
else
{
pixelValues[pos] = -10000000;
pos++;
}
}
}
}
//Now calculation mean of the pixelValues
unsigned int numberOfValues(0);
for (unsigned int i = 0; i < 125; i++)
{
if(pixelValues[i] > -10000000)
{
m_SeedPointValueMean += pixelValues[i];
numberOfValues++;
}
}
m_SeedPointValueMean = m_SeedPointValueMean/numberOfValues;
/*
* Here the upper- and lower threshold is calculated:
* The windowSize is 20% of the maximum range of the intensity values existing in the current image
* If the RG direction is upwards the lower TH is meanSeedValue-0.15*windowSize and upper TH is meanSeedValue+0.85*windowsSize
* if the RG direction is downwards the lower TH is meanSeedValue-0.85*windowSize and upper TH is meanSeedValue+0.15*windowsSize
*/
mitk::ScalarType min = image->GetStatistics()->GetScalarValueMin();
mitk::ScalarType max = image->GetStatistics()->GetScalarValueMax();
mitk::ScalarType windowSize = max - min;
windowSize = 0.15*windowSize;
if (m_CurrentRGDirectionIsUpwards)
{
m_LOWERTHRESHOLD = m_SeedPointValueMean;
if (m_SeedpointValue < m_SeedPointValueMean)
m_LOWERTHRESHOLD = m_SeedpointValue;
m_UPPERTHRESHOLD = m_SeedpointValue + windowSize;
if (m_UPPERTHRESHOLD > max)
m_UPPERTHRESHOLD = max;
m_Controls.m_ThresholdSlider->setMaximumValue(m_UPPERTHRESHOLD);
m_Controls.m_ThresholdSlider->setMinimumValue(m_LOWERTHRESHOLD);
}
else
{
m_UPPERTHRESHOLD = m_SeedPointValueMean;
if (m_SeedpointValue > m_SeedPointValueMean)
m_UPPERTHRESHOLD = m_SeedpointValue;
m_LOWERTHRESHOLD = m_SeedpointValue - windowSize;
if (m_LOWERTHRESHOLD < min)
m_LOWERTHRESHOLD = min;
m_Controls.m_ThresholdSlider->setMinimumValue(m_LOWERTHRESHOLD);
m_Controls.m_ThresholdSlider->setMaximumValue(m_UPPERTHRESHOLD);
}
}
}
void QmitkAdaptiveRegionGrowingToolGUI::RunSegmentation()
{
if (m_InputImageNode.IsNull())
{
QMessageBox::information( NULL, "Adaptive Region Growing functionality", "Please specify the image in Datamanager!");
return;
}
mitk::DataNode::Pointer node = m_RegionGrow3DTool->GetPointSetNode();
if (node.IsNull())
{
QMessageBox::information( NULL, "Adaptive Region Growing functionality", "Please insert a seed point inside the image.\n\nFirst press the \"Define Seed Point\" button,\nthen click left mouse button inside the image.");
return;
}
//safety if no pointSet or pointSet empty
mitk::PointSet::Pointer seedPointSet = dynamic_cast<mitk::PointSet*> (node->GetData());
if (seedPointSet.IsNull())
{
m_Controls.m_pbRunSegmentation->setEnabled(true);
QMessageBox::information( NULL, "Adaptive Region Growing functionality", "The seed point is empty! Please choose a new seed point.");
return;
}
int timeStep = mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1") )->GetTimeStep();
if (!(seedPointSet->GetSize(timeStep)))
{
m_Controls.m_pbRunSegmentation->setEnabled(true);
QMessageBox::information( NULL, "Adaptive Region Growing functionality", "The seed point is empty! Please choose a new seed point.");
return;
}
mitk::PointSet::PointType seedPoint = seedPointSet->GetPointSet(timeStep)->GetPoints()->Begin().Value();
mitk::Image::Pointer orgImage = dynamic_cast<mitk::Image*> (m_InputImageNode->GetData());
if (orgImage.IsNotNull())
{
if (orgImage->GetDimension() == 4)
{
mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
timeSelector->SetInput(orgImage);
timeSelector->SetTimeNr( timeStep );
timeSelector->UpdateLargestPossibleRegion();
mitk::Image* timedImage = timeSelector->GetOutput();
AccessByItk_2( timedImage , StartRegionGrowing, timedImage->GetGeometry(), seedPoint);
}
else if (orgImage->GetDimension() == 3)
{
QApplication::setOverrideCursor(QCursor(Qt::WaitCursor)); //set the cursor to waiting
AccessByItk_2(orgImage, StartRegionGrowing, orgImage->GetGeometry(), seedPoint);
QApplication::restoreOverrideCursor();//reset cursor
}
else
{
QMessageBox::information( NULL, "Adaptive Region Growing functionality", "Only images of dimension 3 or 4 can be processed!");
return;
}
}
EnableControls(true); // Segmentation ran successfully, so enable all controls.
node->SetVisibility(true);
}
template<typename TPixel, unsigned int VImageDimension>
void QmitkAdaptiveRegionGrowingToolGUI::StartRegionGrowing(itk::Image<TPixel, VImageDimension>* itkImage, mitk::Geometry3D* imageGeometry, mitk::PointSet::PointType seedPoint)
{
typedef itk::Image<TPixel, VImageDimension> InputImageType;
typedef typename InputImageType::IndexType IndexType;
typedef itk::ConnectedAdaptiveThresholdImageFilter<InputImageType, InputImageType> RegionGrowingFilterType;
typename RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
typedef itk::MinimumMaximumImageCalculator<InputImageType> MinMaxValueFilterType;
if ( !imageGeometry->IsInside(seedPoint) )
{
QApplication::restoreOverrideCursor();//reset cursor to be able to click ok with the regular mouse cursor
QMessageBox::information( NULL, "Segmentation functionality", "The seed point is outside of the image! Please choose a position inside the image!");
return;
}
IndexType seedIndex;
imageGeometry->WorldToIndex( seedPoint, seedIndex);// convert world coordinates to image indices
if (m_SeedpointValue>m_UPPERTHRESHOLD || m_SeedpointValue<m_LOWERTHRESHOLD)
{
QApplication::restoreOverrideCursor();//reset cursor to be able to click ok with the regular mouse cursor
QMessageBox::information( NULL, "Segmentation functionality", "The seed point is outside the defined thresholds! Please set a new seed point or adjust the thresholds.");
MITK_INFO << "Mean: " <<m_SeedPointValueMean;
return;
}
//Setting the direction of the regiongrowing. For dark structures e.g. the lung the regiongrowing
//is performed starting at the upper value going to the lower one
regionGrower->SetGrowingDirectionIsUpwards( m_CurrentRGDirectionIsUpwards );
regionGrower->SetInput( itkImage );
regionGrower->AddSeed( seedIndex );
//In some cases we have to subtract 1 for the lower threshold and add 1 to the upper.
//Otherwise no region growing is done. Maybe a bug in the ConnectiveAdaptiveThresholdFilter
regionGrower->SetLower( m_LOWERTHRESHOLD-1 );
regionGrower->SetUpper( m_UPPERTHRESHOLD+1);
try
{
regionGrower->Update();
}
catch(itk::ExceptionObject &exc)
{
QMessageBox errorInfo;
errorInfo.setWindowTitle("Adaptive RG Segmentation Functionality");
errorInfo.setIcon(QMessageBox::Critical);
errorInfo.setText("An error occurred during region growing!");
errorInfo.setDetailedText(exc.what());
errorInfo.exec();
return; // can't work
}
catch( ... )
{
QMessageBox::critical( NULL, "Adaptive RG Segmentation Functionality", "An error occurred during region growing!");
return;
}
mitk::Image::Pointer resultImage = mitk::ImportItkImage(regionGrower->GetOutput())->Clone();
//initialize slider
m_Controls.m_PreviewSlider->setMinimum(m_LOWERTHRESHOLD);
mitk::ScalarType max = m_LOWERTHRESHOLD+resultImage->GetStatistics()->GetScalarValueMax();
if (max < m_UPPERTHRESHOLD)
m_Controls.m_PreviewSlider->setMaximum(max);
else
m_Controls.m_PreviewSlider->setMaximum(m_UPPERTHRESHOLD);
this->m_DetectedLeakagePoint = regionGrower->GetLeakagePoint();
if(m_CurrentRGDirectionIsUpwards)
{
m_Controls.m_PreviewSlider->setValue(m_SeedPointValueMean-1);
}
else
{
m_Controls.m_PreviewSlider->setValue(m_SeedPointValueMean+1);
}
this->m_SliderInitialized = true;
//create new node and then delete the old one if there is one
mitk::DataNode::Pointer newNode = mitk::DataNode::New();
newNode->SetData( resultImage );
// set some properties
newNode->SetProperty("name", mitk::StringProperty::New(m_NAMEFORLABLEDSEGMENTATIONIMAGE));
newNode->SetProperty("helper object", mitk::BoolProperty::New(true));
newNode->SetProperty("color", mitk::ColorProperty::New(0.0,1.0,0.0));
newNode->SetProperty("layer", mitk::IntProperty::New(1));
newNode->SetProperty("opacity", mitk::FloatProperty::New(0.7));
//delete the old image, if there was one:
mitk::DataNode::Pointer binaryNode = m_DataStorage->GetNamedNode(m_NAMEFORLABLEDSEGMENTATIONIMAGE);
m_DataStorage->Remove(binaryNode);
// now add result to data tree
m_DataStorage->Add( newNode, m_InputImageNode );
this->InitializeLevelWindow();
if(m_UseVolumeRendering)
this->EnableVolumeRendering(true);
m_UpdateSuggestedThreshold = true;// reset first stored threshold value
//Setting progress to finished
mitk::ProgressBar::GetInstance()->Progress(357);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkAdaptiveRegionGrowingToolGUI::InitializeLevelWindow()
{
//get the preview from the datatree
mitk::DataNode::Pointer newNode = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
mitk::LevelWindow tempLevelWindow;
newNode->GetLevelWindow(tempLevelWindow, NULL, "levelwindow");
mitk::ScalarType* level = new mitk::ScalarType(0.0);
mitk::ScalarType* window = new mitk::ScalarType(1.0);
int upper;
if (m_CurrentRGDirectionIsUpwards)
{
upper = m_UPPERTHRESHOLD - m_SeedpointValue;
}
else
{
upper = m_SeedpointValue - m_LOWERTHRESHOLD;
}
tempLevelWindow.SetRangeMinMax(mitk::ScalarType(0), mitk::ScalarType(upper));
//get the suggested threshold from the detected leakage-point and adjust the slider
if (m_CurrentRGDirectionIsUpwards)
{
this->m_Controls.m_PreviewSlider->setValue(m_SeedpointValue);
*level = m_UPPERTHRESHOLD - (m_SeedpointValue) + 0.5;
}
else
{
this->m_Controls.m_PreviewSlider->setValue(m_SeedpointValue);
*level = (m_SeedpointValue) - m_LOWERTHRESHOLD + 0.5;
}
tempLevelWindow.SetLevelWindow(*level, *window);
newNode->SetLevelWindow(tempLevelWindow, NULL, "levelwindow");
//update the widgets
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
m_SliderInitialized = true;
//inquiry need to fix bug#1828
static int lastSliderPosition = 0;
if ((this->m_SeedpointValue + this->m_DetectedLeakagePoint - 1) == lastSliderPosition)
{
this->ChangeLevelWindow(lastSliderPosition);
}
lastSliderPosition = this->m_SeedpointValue + this->m_DetectedLeakagePoint-1;
if(m_MultiWidget)
{
this->m_MultiWidget->levelWindowWidget->GetManager()->SetAutoTopMostImage(false);
this->m_MultiWidget->levelWindowWidget->GetManager()->SetLevelWindowProperty(static_cast<mitk::LevelWindowProperty*>(newNode->GetProperty("levelwindow")));
}
if (m_UseVolumeRendering)
this->UpdateVolumeRenderingThreshold((int) (*level + 0.5));//lower threshold for labeled image
}
void QmitkAdaptiveRegionGrowingToolGUI::ChangeLevelWindow(double newValue)
{
if (m_SliderInitialized)
{
//do nothing, if no preview exists
mitk::DataNode::Pointer newNode = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
if (newNode.IsNull())
return;
mitk::LevelWindow tempLevelWindow;
newNode->GetLevelWindow(tempLevelWindow, NULL, "levelwindow"); //get the levelWindow associated with the preview
mitk::ScalarType level;// = this->m_UPPERTHRESHOLD - newValue + 0.5;
mitk::ScalarType* window = new mitk::ScalarType(1);
//adjust the levelwindow according to the position of the slider (newvalue)
if (m_CurrentRGDirectionIsUpwards)
{
level = m_UPPERTHRESHOLD - newValue + 0.5;
tempLevelWindow.SetLevelWindow(level, *window);
}
else
{
level = newValue - m_LOWERTHRESHOLD +0.5;
tempLevelWindow.SetLevelWindow(level, *window);
}
newNode->SetLevelWindow(tempLevelWindow, NULL, "levelwindow");
if (m_UseVolumeRendering)
this->UpdateVolumeRenderingThreshold((int) (level - 0.5));//lower threshold for labeled image
newNode->SetVisibility(true);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkAdaptiveRegionGrowingToolGUI::DecreaseSlider()
{
//moves the slider one step to the left, when the "-"-button is pressed
if (this->m_Controls.m_PreviewSlider->value() != this->m_Controls.m_PreviewSlider->minimum())
{
int newValue = this->m_Controls.m_PreviewSlider->value() - 1;
this->ChangeLevelWindow(newValue);
this->m_Controls.m_PreviewSlider->setValue(newValue);
}
}
void QmitkAdaptiveRegionGrowingToolGUI::IncreaseSlider()
{
//moves the slider one step to the right, when the "+"-button is pressed
if (this->m_Controls.m_PreviewSlider->value() != this->m_Controls.m_PreviewSlider->maximum())
{
int newValue = this->m_Controls.m_PreviewSlider->value() + 1;
this->ChangeLevelWindow(newValue);
this->m_Controls.m_PreviewSlider->setValue(newValue);
}
}
void QmitkAdaptiveRegionGrowingToolGUI::ConfirmSegmentation()
{
//get image node
if(m_InputImageNode.IsNull())
{
QMessageBox::critical( NULL, "Adaptive region growing functionality", "Please specify the image in Datamanager!");
return;
}
//get image data
mitk::Image::Pointer orgImage = dynamic_cast<mitk::Image*> (m_InputImageNode->GetData());
if(orgImage.IsNull())
{
QMessageBox::critical( NULL, "Adaptive region growing functionality", "No Image found!");
return;
}
//get labeled segmentation
mitk::Image::Pointer labeledSeg = (mitk::Image*)m_DataStorage->GetNamedObject<mitk::Image>(m_NAMEFORLABLEDSEGMENTATIONIMAGE);
if(labeledSeg.IsNull())
{
QMessageBox::critical( NULL, "Adaptive region growing functionality", "No Segmentation Preview found!");
return;
}
mitk::DataNode::Pointer newNode = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
if (newNode.IsNull())
return;
QmitkConfirmSegmentationDialog dialog;
QString segName = QString::fromStdString(m_RegionGrow3DTool->GetCurrentSegmentationName());
dialog.SetSegmentationName(segName);
int result = dialog.exec();
switch(result)
{
case QmitkConfirmSegmentationDialog::CREATE_NEW_SEGMENTATION:
m_RegionGrow3DTool->SetOverwriteExistingSegmentation(false);
break;
case QmitkConfirmSegmentationDialog::OVERWRITE_SEGMENTATION:
m_RegionGrow3DTool->SetOverwriteExistingSegmentation(true);
break;
case QmitkConfirmSegmentationDialog::CANCEL_SEGMENTATION:
return;
}
mitk::Image* img = dynamic_cast<mitk::Image*>(newNode->GetData());
AccessByItk(img, ITKThresholding);
// disable volume rendering preview after the segmentation node was created
this->EnableVolumeRendering(false);
newNode->SetVisibility(false);
m_Controls.m_cbVolumeRendering->setChecked(false);
//TODO disable slider etc...
}
template<typename TPixel, unsigned int VImageDimension>
void QmitkAdaptiveRegionGrowingToolGUI::ITKThresholding(itk::Image<TPixel, VImageDimension>* itkImage)
{
mitk::Image::Pointer originalSegmentation = dynamic_cast<mitk::Image*>(this->m_RegionGrow3DTool->
GetTargetSegmentationNode()->GetData());
int timeStep = mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1") )->GetTimeStep();
if (originalSegmentation)
{
typedef itk::Image<TPixel, VImageDimension> InputImageType;
typedef itk::Image<unsigned char, VImageDimension> SegmentationType;
//select single 3D volume if we have more than one time step
typename SegmentationType::Pointer originalSegmentationInITK = SegmentationType::New();
- if(originalSegmentation->GetTimeGeometry()->GetNumberOfTimeSteps() > 1)
+ if(originalSegmentation->GetTimeGeometry()->CountTimeSteps() > 1)
{
mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
timeSelector->SetInput( originalSegmentation );
timeSelector->SetTimeNr( timeStep );
timeSelector->UpdateLargestPossibleRegion();
CastToItkImage( timeSelector->GetOutput(), originalSegmentationInITK );
}
else //use original
{
CastToItkImage( originalSegmentation, originalSegmentationInITK );
}
//Fill current preiview image in segmentation image
originalSegmentationInITK->FillBuffer(0);
itk::ImageRegionIterator<SegmentationType> itOutput( originalSegmentationInITK, originalSegmentationInITK->GetLargestPossibleRegion() );
itk::ImageRegionIterator<InputImageType> itInput( itkImage, itkImage->GetLargestPossibleRegion() );
itOutput.GoToBegin();
itInput.GoToBegin();
//calculate threhold from slider value
int currentTreshold = 0;
if (m_CurrentRGDirectionIsUpwards)
{
currentTreshold = m_UPPERTHRESHOLD - m_Controls.m_PreviewSlider->value() + 1;
}
else
{
currentTreshold = m_Controls.m_PreviewSlider->value() - m_LOWERTHRESHOLD;
}
//iterate over image and set pixel in segmentation according to thresholded labeled image
while( !itOutput.IsAtEnd() && !itInput.IsAtEnd() )
{
//Use threshold slider to determine if pixel is set to 1
if( itInput.Value() != 0 && itInput.Value() > currentTreshold )
{
itOutput.Set( 1 );
}
++itOutput;
++itInput;
}
//combine current working segmentation image with our region growing result
originalSegmentation->SetVolume( (void*)(originalSegmentationInITK->GetPixelContainer()->GetBufferPointer()), timeStep);
originalSegmentation->Modified();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkAdaptiveRegionGrowingToolGUI::EnableControls(bool enable)
{
if (m_RegionGrow3DTool.IsNull())
return;
// Check if seed point is already set, if not leave RunSegmentation disabled
//if even m_DataStorage is NULL leave node NULL
mitk::DataNode::Pointer node = m_RegionGrow3DTool->GetPointSetNode();
if (node.IsNull()) {
this->m_Controls.m_pbRunSegmentation->setEnabled(false);
}
else
{
this->m_Controls.m_pbRunSegmentation->setEnabled(enable);
}
// Check if a segmentation exists, if not leave segmentation dependent disabled.
//if even m_DataStorage is NULL leave node NULL
node = m_DataStorage?m_DataStorage->GetNamedNode(m_NAMEFORLABLEDSEGMENTATIONIMAGE):NULL;
if (node.IsNull())
{
this->m_Controls.m_PreviewSlider->setEnabled(false);
this->m_Controls.m_pbConfirmSegementation->setEnabled(false);
}
else
{
this->m_Controls.m_PreviewSlider->setEnabled(enable);
this->m_Controls.m_pbConfirmSegementation->setEnabled(enable);
}
this->m_Controls.m_cbVolumeRendering->setEnabled(enable);
}
void QmitkAdaptiveRegionGrowingToolGUI::EnableVolumeRendering(bool enable)
{
mitk::DataNode::Pointer node = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
if(node.IsNull())
return;
if(m_MultiWidget)
m_MultiWidget->SetWidgetPlanesVisibility(!enable);
if (enable)
{
node->SetBoolProperty("volumerendering", enable);
node->SetBoolProperty("volumerendering.uselod", true);
}
else
{
node->SetBoolProperty("volumerendering", enable);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkAdaptiveRegionGrowingToolGUI::UpdateVolumeRenderingThreshold(int thValue)
{
mitk::DataNode::Pointer node = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New();
if (m_UpdateSuggestedThreshold)
{
m_SuggestedThValue = thValue;
m_UpdateSuggestedThreshold = false;
}
// grayvalue->opacity
{
vtkPiecewiseFunction *f = tf->GetScalarOpacityFunction();
f->RemoveAllPoints();
f->AddPoint(0, 0);
f->AddPoint(thValue+0.5, 0);
f->AddPoint(thValue+1.5, 1);
f->AddPoint(1000, 1);
f->ClampingOn();
f->Modified();
}
// grayvalue->color
{
float a = 255.0;
vtkColorTransferFunction *ctf = tf->GetColorTransferFunction();
ctf->RemoveAllPoints();
//ctf->AddRGBPoint(-1000, 0.0, 0.0, 0.0);
ctf->AddRGBPoint(m_SuggestedThValue+1, 203/a, 104/a, 102/a);
ctf->AddRGBPoint(m_SuggestedThValue, 255/a, 0/a, 0/a);
ctf->ClampingOn();
ctf->Modified();
}
// GradientOpacityFunction
{
vtkPiecewiseFunction *gof = tf->GetGradientOpacityFunction();
gof->RemoveAllPoints();
gof->AddPoint(-10000, 1);
gof->AddPoint(10000, 1);
gof->ClampingOn();
gof->Modified();
}
mitk::TransferFunctionProperty::Pointer tfp = mitk::TransferFunctionProperty::New();
tfp->SetValue(tf);
node->SetProperty("TransferFunction", tfp);
}
void QmitkAdaptiveRegionGrowingToolGUI::UseVolumeRendering(bool on)
{
m_UseVolumeRendering = on;
this->EnableVolumeRendering(on);
}
void QmitkAdaptiveRegionGrowingToolGUI::SetLowerThresholdValue( double lowerThreshold )
{
m_LOWERTHRESHOLD = lowerThreshold;
}
void QmitkAdaptiveRegionGrowingToolGUI::SetUpperThresholdValue( double upperThreshold)
{
m_UPPERTHRESHOLD = upperThreshold;
}
void QmitkAdaptiveRegionGrowingToolGUI::Deactivated()
{
// make the segmentation preview node invisible
mitk::DataNode::Pointer node = m_DataStorage->GetNamedNode( m_NAMEFORLABLEDSEGMENTATIONIMAGE);
if( node.IsNotNull() )
{
node->SetVisibility(false);
}
// disable volume rendering preview after the segmentation node was created
this->EnableVolumeRendering(false);
m_Controls.m_cbVolumeRendering->setChecked(false);
}
void QmitkAdaptiveRegionGrowingToolGUI::Activated()
{
}
\ No newline at end of file