diff --git a/Core/Code/Controllers/mitkRenderingManager.cpp b/Core/Code/Controllers/mitkRenderingManager.cpp
index 21b97fe5cc..672211e906 100644
--- a/Core/Code/Controllers/mitkRenderingManager.cpp
+++ b/Core/Code/Controllers/mitkRenderingManager.cpp
@@ -1,972 +1,972 @@
/*===================================================================
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 );
typedef itk::MemberCommand< RenderingManager > MemberCommandType;
// 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 = dataGeometry->Clone().GetPointer();
+ TimeGeometry::Pointer 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
AffineGeometryFrame3D::TransformType::Pointer transform = AffineGeometryFrame3D::TransformType::New();
assert( modifiedGeometry->GetGeometryForTimeStep(0)->GetIndexToWorldTransform() );
transform->SetMatrix( modifiedGeometry->GetGeometryForTimeStep(0)->GetIndexToWorldTransform()->GetMatrix() );
transform->SetOffset( modifiedGeometry->GetGeometryForTimeStep(0)->GetIndexToWorldTransform()->GetOffset() );
// get transform matrix
AffineGeometryFrame3D::TransformType::MatrixType::InternalMatrixType& oldMatrix =
const_cast< AffineGeometryFrame3D::TransformType::MatrixType::InternalMatrixType& > ( transform->GetMatrix().GetVnlMatrix() );
AffineGeometryFrame3D::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
AffineGeometryFrame3D::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)
{
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 1cac802cfb..7a20385c73 100644
--- a/Core/Code/Controllers/mitkSliceNavigationController.cpp
+++ b/Core/Code/Controllers/mitkSliceNavigationController.cpp
@@ -1,759 +1,764 @@
/*===================================================================
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;
}
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 )
{
const TimeGeometry* worldTimeGeometry = m_InputWorldTimeGeometry.GetPointer();
if( m_BlockUpdate ||
( m_InputWorldTimeGeometry.IsNull() && m_InputWorldGeometry3D.IsNull() ) ||
( (worldTimeGeometry != NULL) && (worldTimeGeometry->GetNumberOfTimeSteps() == 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())
+ currentGeometry = m_InputWorldTimeGeometry->GetGeometryForTimeStep(GetTime()->GetPos());
+ else
+ currentGeometry = m_InputWorldGeometry3D;
m_CreatedWorldGeometry = NULL;
switch ( viewDirection )
{
case Original:
if ( worldTimeGeometry != NULL )
{
m_CreatedWorldGeometry = worldTimeGeometry->Clone().GetPointer();
worldTimeGeometry = m_CreatedWorldGeometry.GetPointer();
slicedWorldGeometry = dynamic_cast< SlicedGeometry3D * >(
m_CreatedWorldGeometry->GetGeometryForTimeStep( this->GetTime()->GetPos() ) );
if ( slicedWorldGeometry.IsNotNull() )
{
break;
}
}
else
{
const SlicedGeometry3D *worldSlicedGeometry =
dynamic_cast< const SlicedGeometry3D * >(
- m_InputWorldGeometry3D.GetPointer());
+ currentGeometry.GetPointer());
if ( worldSlicedGeometry != NULL )
{
slicedWorldGeometry = static_cast< SlicedGeometry3D * >(
- m_InputWorldGeometry3D->Clone().GetPointer());
+ currentGeometry->Clone().GetPointer());
break;
}
}
//else: use Axial: no "break" here!!
case Axial:
slicedWorldGeometry = SlicedGeometry3D::New();
slicedWorldGeometry->InitializePlanes(
- m_InputWorldGeometry3D, PlaneGeometry::Axial,
+ currentGeometry, PlaneGeometry::Axial,
top, frontside, rotated );
slicedWorldGeometry->SetSliceNavigationController( this );
break;
case Frontal:
slicedWorldGeometry = SlicedGeometry3D::New();
- slicedWorldGeometry->InitializePlanes( m_InputWorldGeometry3D,
+ slicedWorldGeometry->InitializePlanes( currentGeometry,
PlaneGeometry::Frontal, top, frontside, rotated );
slicedWorldGeometry->SetSliceNavigationController( this );
break;
case Sagittal:
slicedWorldGeometry = SlicedGeometry3D::New();
- slicedWorldGeometry->InitializePlanes( m_InputWorldGeometry3D,
+ 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 == NULL )
{
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->SetPos( 0 );
const TimeBounds &timeBounds = worldTimeGeometry->GetTimeBounds();
m_Time->SetRange( timeBounds[0], timeBounds[1] );
m_BlockUpdate = false;
assert( worldTimeGeometry->GetGeometryForTimeStep( this->GetTime()->GetPos() ) != NULL );
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());
}
}
// 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() ) );
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;
}
}
}
// 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;
// find image with largest layer, that is the image shown on top in the render window
for (unsigned int x = 0; x < nodes->size(); x++)
{
//Just consider image data that is no helper object. E.g. do not consider nodes created for the slice interpolation
bool isHelper (false);
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))
{
image3D = dynamic_cast<mitk::Image*>(nodes->at(x)->GetData());
maxlayer = layer;
}
}
}
}
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/mitkProportionalTimeGeometry.cpp b/Core/Code/DataManagement/mitkProportionalTimeGeometry.cpp
index 8180d87548..ddeff32f39 100644
--- a/Core/Code/DataManagement/mitkProportionalTimeGeometry.cpp
+++ b/Core/Code/DataManagement/mitkProportionalTimeGeometry.cpp
@@ -1,178 +1,179 @@
/*===================================================================
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>
mitk::ProportionalTimeGeometry::ProportionalTimeGeometry()
{
}
mitk::ProportionalTimeGeometry::~ProportionalTimeGeometry()
{
}
void mitk::ProportionalTimeGeometry::Initialize()
{
}
mitk::TimeStepType mitk::ProportionalTimeGeometry::GetNumberOfTimeSteps () const
{
return static_cast<TimeStepType>(m_GeometryVector.size() );
}
mitk::TimePointType mitk::ProportionalTimeGeometry::GetMinimumTimePoint () const
{
return m_FirstTimePoint;
}
mitk::TimePointType mitk::ProportionalTimeGeometry::GetMaximumTimePoint () const
{
return m_FirstTimePoint + m_StepDuration * GetNumberOfTimeSteps();
}
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 0 <= timeStep && timeStep < this->GetNumberOfTimeSteps();
}
mitk::TimePointType mitk::ProportionalTimeGeometry::TimeStepToTimePoint( TimeStepType timeStep) const
{
return m_FirstTimePoint + timeStep * m_StepDuration;
}
mitk::TimeStepType mitk::ProportionalTimeGeometry::TimePointToTimeStep( TimePointType timePoint) const
{
assert(timePoint >= m_FirstTimePoint);
return static_cast<TimeStepType>((timePoint -m_FirstTimePoint) / m_StepDuration);
}
mitk::Geometry3D* mitk::ProportionalTimeGeometry::GetGeometryForTimeStep( TimeStepType timeStep) const
{
if (IsValidTimeStep(timeStep))
{
return dynamic_cast<Geometry3D*>(m_GeometryVector[timeStep].GetPointer());
}
else
{
return NULL;
}
}
mitk::Geometry3D* mitk::ProportionalTimeGeometry::GetGeometryForTimePoint(TimePointType timePoint) const
{
TimeStepType timeStep = this->TimePointToTimeStep(timePoint);
return this->GetGeometryForTimeStep(timeStep);
}
mitk::Geometry3D::Pointer mitk::ProportionalTimeGeometry::GetGeometryCloneForTimeStep( TimeStepType timeStep) const
{
return m_GeometryVector[timeStep].GetPointer();
}
bool mitk::ProportionalTimeGeometry::IsValid()
{
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());
assert(timeStep >= 0);
if (timeStep == m_GeometryVector.size())
m_GeometryVector.push_back(geometry);
m_GeometryVector[timeStep] = geometry;
}
mitk::TimeGeometry::Pointer mitk::ProportionalTimeGeometry::Clone() const
{
ProportionalTimeGeometry::Pointer newTimeGeometry = ProportionalTimeGeometry::New();
newTimeGeometry->m_BoundingBox = m_BoundingBox->DeepCopy();
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)
{
AffineGeometryFrame3D::Pointer pointer = GetGeometryForTimeStep(i)->Clone();
Geometry3D* tempGeometry = dynamic_cast<Geometry3D*> (pointer.GetPointer());
newTimeGeometry->SetTimeStepGeometry(tempGeometry,i);
}
TimeGeometry::Pointer finalPointer = dynamic_cast<TimeGeometry*>(newTimeGeometry.GetPointer());
return finalPointer;
}
void mitk::ProportionalTimeGeometry::Initialize (Geometry3D * geometry, TimeStepType timeSteps)
{
timeSteps = (timeSteps > 0) ? timeSteps : 1;
this->ReserveSpaceForGeometries(timeSteps);
for (TimeStepType currentStep = 0; currentStep < timeSteps; ++currentStep)
{
- this->SetTimeStepGeometry(dynamic_cast<Geometry3D *>(geometry->Clone().GetPointer()), currentStep);
+ //AffineGeometryFrame3D::Pointer clonedGeometry = geometry->Clone();
+ this->SetTimeStepGeometry(geometry, currentStep);
}
m_FirstTimePoint = geometry->GetTimeBounds()[0];
m_StepDuration = geometry->GetTimeBounds()[1] - geometry->GetTimeBounds()[0];
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/mitkTimeGeometry.cpp b/Core/Code/DataManagement/mitkTimeGeometry.cpp
index 40ee0b93ae..407b55d9df 100644
--- a/Core/Code/DataManagement/mitkTimeGeometry.cpp
+++ b/Core/Code/DataManagement/mitkTimeGeometry.cpp
@@ -1,161 +1,153 @@
/*===================================================================
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>
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 NULL;
}
}
// 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)
{
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);
- Point3D minimumWorld;
- GetGeometryForTimeStep(step)->IndexToWorld(minimum, minimumWorld);
- Point3D maximumWorld;
- GetGeometryForTimeStep(step)->IndexToWorld(maximum, maximumWorld);
-
- points->push_back(minimumWorld);
- points->push_back(maximumWorld);
+ points->push_back(minimum);
+ points->push_back(maximum);
}
+ m_BoundingBox->SetPoints(points);
+ m_BoundingBox->ComputeBoundingBox();
+ this->Modified();
- if (lastModifiedTime >= this->GetMTime())
- {
- m_BoundingBox->SetPoints(points);
- m_BoundingBox->ComputeBoundingBox();
- this->Modified();
- }
}
mitk::ScalarType mitk::TimeGeometry::GetExtendInWorld (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)
{
GetGeometryForTimeStep(step)->ExecuteOperation(op);
}
}
diff --git a/Core/Code/IO/mitkItkImageFileReader.cpp b/Core/Code/IO/mitkItkImageFileReader.cpp
index d4f22b537b..ba0b331e9b 100644
--- a/Core/Code/IO/mitkItkImageFileReader.cpp
+++ b/Core/Code/IO/mitkItkImageFileReader.cpp
@@ -1,212 +1,215 @@
/*===================================================================
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 "mitkItkImageFileReader.h"
#include "mitkConfig.h"
#include "mitkException.h"
#include <mitkProportionalTimeGeometry.h>
#include <itkImageFileReader.h>
#include <itksys/SystemTools.hxx>
#include <itksys/Directory.hxx>
#include <itkImage.h>
//#include <itkImageSeriesReader.h>
#include <itkImageFileReader.h>
#include <itkImageIOFactory.h>
#include <itkImageIORegion.h>
//#include <itkImageSeriesReader.h>
//#include <itkDICOMImageIO2.h>
//#include <itkDICOMSeriesFileNames.h>
//#include <itkGDCMImageIO.h>
//#include <itkGDCMSeriesFileNames.h>
//#include <itkNumericSeriesFileNames.h>
void mitk::ItkImageFileReader::GenerateData()
{
const std::string& locale = "C";
const std::string& currLocale = setlocale( LC_ALL, NULL );
if ( locale.compare(currLocale)!=0 )
{
try
{
setlocale(LC_ALL, locale.c_str());
}
catch(...)
{
MITK_INFO << "Could not set locale " << locale;
}
}
mitk::Image::Pointer image = this->GetOutput();
const unsigned int MINDIM = 2;
const unsigned int MAXDIM = 4;
MITK_INFO << "loading " << m_FileName << " via itk::ImageIOFactory... " << std::endl;
// Check to see if we can read the file given the name or prefix
if ( m_FileName == "" )
{
mitkThrow() << "Empty filename in mitk::ItkImageFileReader ";
return ;
}
itk::ImageIOBase::Pointer imageIO = itk::ImageIOFactory::CreateImageIO( m_FileName.c_str(), itk::ImageIOFactory::ReadMode );
if ( imageIO.IsNull() )
{
//itkWarningMacro( << "File Type not supported!" );
mitkThrow() << "Could not create itk::ImageIOBase object for filename " << m_FileName;
return ;
}
// Got to allocate space for the image. Determine the characteristics of
// the image.
imageIO->SetFileName( m_FileName.c_str() );
imageIO->ReadImageInformation();
unsigned int ndim = imageIO->GetNumberOfDimensions();
if ( ndim < MINDIM || ndim > MAXDIM )
{
itkWarningMacro( << "Sorry, only dimensions 2, 3 and 4 are supported. The given file has " << ndim << " dimensions! Reading as 4D." );
ndim = MAXDIM;
}
itk::ImageIORegion ioRegion( ndim );
itk::ImageIORegion::SizeType ioSize = ioRegion.GetSize();
itk::ImageIORegion::IndexType ioStart = ioRegion.GetIndex();
unsigned int dimensions[ MAXDIM ];
dimensions[ 0 ] = 0;
dimensions[ 1 ] = 0;
dimensions[ 2 ] = 0;
dimensions[ 3 ] = 0;
float spacing[ MAXDIM ];
spacing[ 0 ] = 1.0f;
spacing[ 1 ] = 1.0f;
spacing[ 2 ] = 1.0f;
spacing[ 3 ] = 1.0f;
Point3D origin;
origin.Fill(0);
unsigned int i;
for ( i = 0; i < ndim ; ++i )
{
ioStart[ i ] = 0;
ioSize[ i ] = imageIO->GetDimensions( i );
if(i<MAXDIM)
{
dimensions[ i ] = imageIO->GetDimensions( i );
spacing[ i ] = imageIO->GetSpacing( i );
if(spacing[ i ] <= 0)
spacing[ i ] = 1.0f;
}
if(i<3)
{
origin[ i ] = imageIO->GetOrigin( i );
}
}
ioRegion.SetSize( ioSize );
ioRegion.SetIndex( ioStart );
MITK_INFO << "ioRegion: " << ioRegion << std::endl;
imageIO->SetIORegion( ioRegion );
void* buffer = new unsigned char[imageIO->GetImageSizeInBytes()];
imageIO->Read( buffer );
mitk::PixelType pixelType = mitk::PixelType(imageIO->GetComponentTypeInfo(), imageIO->GetPixelType(),
imageIO->GetComponentSize(), imageIO->GetNumberOfComponents(),
imageIO->GetComponentTypeAsString( imageIO->GetComponentType() ).c_str(),
imageIO->GetPixelTypeAsString( imageIO->GetPixelType() ).c_str() );
image->Initialize( pixelType, ndim, dimensions );
image->SetImportChannel( buffer, 0, Image::ManageMemory );
// access direction of itk::Image and include spacing
mitk::Matrix3D matrix;
matrix.SetIdentity();
unsigned int j, itkDimMax3 = (ndim >= 3? 3 : ndim);
for ( i=0; i < itkDimMax3; ++i)
for( j=0; j < itkDimMax3; ++j )
matrix[i][j] = imageIO->GetDirection(j)[i];
// re-initialize PlaneGeometry with origin and direction
PlaneGeometry* planeGeometry = static_cast<PlaneGeometry*>(image->GetSlicedGeometry(0)->GetGeometry2D(0));
planeGeometry->SetOrigin(origin);
planeGeometry->GetIndexToWorldTransform()->SetMatrix(matrix);
// re-initialize SlicedGeometry3D
SlicedGeometry3D* slicedGeometry = image->GetSlicedGeometry(0);
slicedGeometry->InitializeEvenlySpaced(planeGeometry, image->GetDimension(2));
slicedGeometry->SetSpacing(spacing);
+ MITK_INFO << slicedGeometry->GetCornerPoint(false,false,false);
+ MITK_INFO << slicedGeometry->GetCornerPoint(true,true,true);
+
// re-initialize TimeGeometry
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
timeGeometry->Initialize(slicedGeometry, image->GetDimension(3));
image->SetTimeGeometry(timeGeometry);
buffer = NULL;
MITK_INFO << "number of image components: "<< image->GetPixelType().GetNumberOfComponents() << std::endl;
// mitk::DataNode::Pointer node = this->GetOutput();
// node->SetData( image );
// add level-window property
//if ( image->GetPixelType().GetNumberOfComponents() == 1 )
//{
// SetDefaultImageProperties( node );
//}
MITK_INFO << "...finished!" << std::endl;
try
{
setlocale(LC_ALL, currLocale.c_str());
}
catch(...)
{
MITK_INFO << "Could not reset locale " << currLocale;
}
}
bool mitk::ItkImageFileReader::CanReadFile(const std::string filename, const std::string filePrefix, const std::string filePattern)
{
// First check the extension
if( filename == "" )
return false;
// check if image is serie
if( filePattern != "" && filePrefix != "" )
return false;
itk::ImageIOBase::Pointer imageIO = itk::ImageIOFactory::CreateImageIO( filename.c_str(), itk::ImageIOFactory::ReadMode );
if ( imageIO.IsNull() )
return false;
return true;
}
mitk::ItkImageFileReader::ItkImageFileReader()
: m_FileName(""), m_FilePrefix(""), m_FilePattern("")
{
}
mitk::ItkImageFileReader::~ItkImageFileReader()
{
}