diff --git a/Modules/Core/src/Rendering/mitkVtkPropRenderer.cpp b/Modules/Core/src/Rendering/mitkVtkPropRenderer.cpp
index 61c34bb3eb..d1bf69160f 100644
--- a/Modules/Core/src/Rendering/mitkVtkPropRenderer.cpp
+++ b/Modules/Core/src/Rendering/mitkVtkPropRenderer.cpp
@@ -1,685 +1,685 @@
/*===================================================================
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 "mitkVtkPropRenderer.h"
// MAPPERS
#include "mitkCameraController.h"
#include "mitkImageVtkMapper2D.h"
#include "mitkMapper.h"
#include "mitkPlaneGeometryDataVtkMapper3D.h"
#include "mitkVtkMapper.h"
#include <mitkAbstractTransformGeometry.h>
#include <mitkGeometry3D.h>
#include <mitkImageSliceSelector.h>
#include <mitkLevelWindow.h>
#include <mitkNodePredicateDataType.h>
#include <mitkPlaneGeometry.h>
#include <mitkProperties.h>
#include <mitkRenderingManager.h>
#include <mitkSurface.h>
#include <mitkVtkInteractorStyle.h>
// VTK
#include <vtkAssemblyNode.h>
#include <vtkAssemblyPath.h>
#include <vtkCamera.h>
#include <vtkCellPicker.h>
#include <vtkInteractorStyleTrackballCamera.h>
#include <vtkLight.h>
#include <vtkLightKit.h>
#include <vtkLinearTransform.h>
#include <vtkMapper.h>
#include <vtkPointPicker.h>
#include <vtkProp.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
#include <vtkRendererCollection.h>
#include <vtkSmartPointer.h>
#include <vtkTextActor.h>
#include <vtkTextProperty.h>
#include <vtkTransform.h>
#include <vtkWorldPointPicker.h>
mitk::VtkPropRenderer::VtkPropRenderer(const char *name,
vtkRenderWindow *renWin,
mitk::RenderingManager *rm,
mitk::BaseRenderer::RenderingMode::Type renderingMode)
: BaseRenderer(name, renWin, rm, renderingMode), m_CameraInitializedForMapperID(0)
{
didCount = false;
m_WorldPointPicker = vtkWorldPointPicker::New();
m_PointPicker = vtkPointPicker::New();
m_PointPicker->SetTolerance(0.0025);
m_CellPicker = vtkCellPicker::New();
m_CellPicker->SetTolerance(0.0025);
mitk::PlaneGeometryDataVtkMapper3D::Pointer geometryMapper = mitk::PlaneGeometryDataVtkMapper3D::New();
m_CurrentWorldPlaneGeometryMapper = geometryMapper;
m_CurrentWorldPlaneGeometryNode->SetMapper(2, geometryMapper);
m_LightKit = vtkLightKit::New();
m_LightKit->AddLightsToRenderer(m_VtkRenderer);
m_PickingMode = WorldPointPicking;
m_TextRenderer = vtkRenderer::New();
m_TextRenderer->SetRenderWindow(renWin);
m_TextRenderer->SetInteractive(0);
m_TextRenderer->SetErase(0);
}
/*!
\brief Destructs the VtkPropRenderer.
*/
mitk::VtkPropRenderer::~VtkPropRenderer()
{
// Workaround for GLDisplayList Bug
{
m_MapperID = 0;
checkState();
}
- if (m_LightKit != NULL)
+ if (m_LightKit != nullptr)
m_LightKit->Delete();
- if (m_VtkRenderer != NULL)
+ if (m_VtkRenderer != nullptr)
{
- m_CameraController = NULL;
+ m_CameraController = nullptr;
m_VtkRenderer->Delete();
- m_VtkRenderer = NULL;
+ m_VtkRenderer = nullptr;
}
else
- m_CameraController = NULL;
+ m_CameraController = nullptr;
- if (m_WorldPointPicker != NULL)
+ if (m_WorldPointPicker != nullptr)
m_WorldPointPicker->Delete();
- if (m_PointPicker != NULL)
+ if (m_PointPicker != nullptr)
m_PointPicker->Delete();
- if (m_CellPicker != NULL)
+ if (m_CellPicker != nullptr)
m_CellPicker->Delete();
- if (m_TextRenderer != NULL)
+ if (m_TextRenderer != nullptr)
m_TextRenderer->Delete();
}
void mitk::VtkPropRenderer::SetDataStorage(mitk::DataStorage *storage)
{
- if (storage == NULL)
+ if (storage == nullptr || storage == m_DataStorage)
return;
BaseRenderer::SetDataStorage(storage);
static_cast<mitk::PlaneGeometryDataVtkMapper3D *>(m_CurrentWorldPlaneGeometryMapper.GetPointer())
->SetDataStorageForTexture(m_DataStorage.GetPointer());
// Compute the geometry from the current data tree bounds and set it as world geometry
this->SetWorldGeometryToDataStorageBounds();
}
bool mitk::VtkPropRenderer::SetWorldGeometryToDataStorageBounds()
{
if (m_DataStorage.IsNull())
return false;
// initialize world geometry
- mitk::TimeGeometry::Pointer geometry = m_DataStorage->ComputeVisibleBoundingGeometry3D(NULL, "includeInBoundingBox");
+ mitk::TimeGeometry::Pointer geometry = m_DataStorage->ComputeVisibleBoundingGeometry3D(nullptr, "includeInBoundingBox");
if (geometry.IsNull())
return false;
this->SetWorldTimeGeometry(geometry);
this->GetVtkRenderer()->ResetCamera();
this->GetCameraController()->Fit();
this->Modified();
return true;
}
/*!
\brief
Called by the vtkMitkRenderProp in order to start MITK rendering process.
*/
int mitk::VtkPropRenderer::Render(mitk::VtkPropRenderer::RenderType type)
{
// Update all overlays in any case
this->UpdateOverlays();
// Do we have objects to render?
if (this->GetEmptyWorldGeometry())
return 0;
if (m_DataStorage.IsNull())
return 0;
// Update mappers and prepare mapper queue
if (type == VtkPropRenderer::Opaque)
this->PrepareMapperQueue();
// go through the generated list and let the sorted mappers paint
for (auto it = m_MappersMap.cbegin(); it != m_MappersMap.cend(); it++)
{
Mapper *mapper = (*it).second;
mapper->MitkRender(this, type);
}
// Update overlays in case a mapper has changed them
this->UpdateOverlays();
// Render text
if (type == VtkPropRenderer::Overlay)
{
if (m_TextCollection.size() > 0)
{
m_TextRenderer->SetViewport(this->GetVtkRenderer()->GetViewport());
for (TextMapType::iterator it = m_TextCollection.begin(); it != m_TextCollection.end(); ++it)
m_TextRenderer->AddViewProp((*it).second);
m_TextRenderer->Render();
}
}
return 1;
}
/*!
\brief PrepareMapperQueue iterates the datatree
PrepareMapperQueue iterates the datatree in order to find mappers which shall be rendered. Also, it sortes the mappers
wrt to their layer.
*/
void mitk::VtkPropRenderer::PrepareMapperQueue()
{
// variable for counting LOD-enabled mappers
m_NumberOfVisibleLODEnabledMappers = 0;
// Do we have to update the mappers ?
if (m_LastUpdateTime < GetMTime() || m_LastUpdateTime < this->GetCurrentWorldPlaneGeometry()->GetMTime())
{
Update();
}
else if (m_MapperID >= 1 && m_MapperID < 6)
Update();
// remove all text properties before mappers will add new ones
m_TextRenderer->RemoveAllViewProps();
for (unsigned int i = 0; i < m_TextCollection.size(); i++)
{
m_TextCollection[i]->Delete();
}
m_TextCollection.clear();
// clear priority_queue
m_MappersMap.clear();
int mapperNo = 0;
// DataStorage
if (m_DataStorage.IsNull())
return;
DataStorage::SetOfObjects::ConstPointer allObjects = m_DataStorage->GetAll();
for (DataStorage::SetOfObjects::ConstIterator it = allObjects->Begin(); it != allObjects->End(); ++it)
{
const DataNode::Pointer node = it->Value();
if (node.IsNull())
continue;
const mitk::Mapper::Pointer mapper = node->GetMapper(m_MapperID);
if (mapper.IsNull())
continue;
bool visible = true;
node->GetVisibility(visible, this, "visible");
// The information about LOD-enabled mappers is required by RenderingManager
if (mapper->IsLODEnabled(this) && visible)
{
++m_NumberOfVisibleLODEnabledMappers;
}
// mapper without a layer property get layer number 1
int layer = 1;
node->GetIntProperty("layer", layer, this);
int nr = (layer << 16) + mapperNo;
m_MappersMap.insert(std::pair<int, Mapper *>(nr, mapper));
mapperNo++;
}
}
void mitk::VtkPropRenderer::Update(mitk::DataNode *datatreenode)
{
- if (datatreenode != NULL)
+ if (datatreenode != nullptr)
{
mitk::Mapper::Pointer mapper = datatreenode->GetMapper(m_MapperID);
if (mapper.IsNotNull())
{
if (GetCurrentWorldPlaneGeometry()->IsValid())
{
mapper->Update(this);
{
VtkMapper *vtkmapper = dynamic_cast<VtkMapper *>(mapper.GetPointer());
- if (vtkmapper != NULL)
+ if (vtkmapper != nullptr)
{
vtkmapper->UpdateVtkTransform(this);
}
}
}
}
}
}
void mitk::VtkPropRenderer::Update()
{
if (m_DataStorage.IsNull())
return;
mitk::DataStorage::SetOfObjects::ConstPointer all = m_DataStorage->GetAll();
for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
Update(it->Value());
Modified();
m_LastUpdateTime = GetMTime();
}
/*!
\brief
This method is called from the two Constructors
*/
void mitk::VtkPropRenderer::InitRenderer(vtkRenderWindow *renderWindow)
{
BaseRenderer::InitRenderer(renderWindow);
vtkCallbackCommand *renderCallbackCommand = vtkCallbackCommand::New();
renderCallbackCommand->SetCallback(VtkPropRenderer::RenderingCallback);
renderWindow->GetInteractor()->AddObserver(vtkCommand::RenderEvent, renderCallbackCommand);
renderCallbackCommand->Delete();
- if (renderWindow == NULL)
+ if (renderWindow == nullptr)
{
m_InitNeeded = false;
m_ResizeNeeded = false;
return;
}
m_InitNeeded = true;
m_ResizeNeeded = true;
m_LastUpdateTime = 0;
}
void mitk::VtkPropRenderer::RenderingCallback(vtkObject *caller, unsigned long, void *, void *)
{
vtkRenderWindowInteractor *renderWindowInteractor = dynamic_cast<vtkRenderWindowInteractor *>(caller);
if (!renderWindowInteractor)
return;
mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(renderWindowInteractor->GetRenderWindow());
if (renderer)
renderer->RequestUpdate();
}
/*!
\brief Resize the OpenGL Window
*/
void mitk::VtkPropRenderer::Resize(int w, int h)
{
BaseRenderer::Resize(w, h);
m_RenderingManager->RequestUpdate(this->GetRenderWindow());
}
void mitk::VtkPropRenderer::InitSize(int w, int h)
{
m_RenderWindow->SetSize(w, h);
Superclass::InitSize(w, h);
Modified();
Update();
- if (m_VtkRenderer != NULL)
+ if (m_VtkRenderer != nullptr)
{
int w = vtkObject::GetGlobalWarningDisplay();
vtkObject::GlobalWarningDisplayOff();
m_VtkRenderer->ResetCamera();
vtkObject::SetGlobalWarningDisplay(w);
}
this->GetCameraController()->Fit();
}
int mitk::VtkPropRenderer::WriteSimpleText(
std::string text, double posX, double posY, double color1, double color2, double color3, float opacity)
{
this->GetVtkRenderer()->ViewToDisplay();
if (!text.empty())
{
Point2D p;
vtkTextActor *textActor = vtkTextActor::New();
textActor->SetDisplayPosition(posX, posY);
textActor->SetInput(text.c_str());
textActor->SetTextScaleModeToNone();
textActor->GetTextProperty()->SetColor(color1, color2, color3); // TODO: Read color from node property
textActor->GetTextProperty()->SetOpacity(opacity);
int text_id = m_TextCollection.size();
m_TextCollection.insert(TextMapType::value_type(text_id, textActor));
return text_id;
}
else
{
return -1;
}
}
void mitk::VtkPropRenderer::SetMapperID(const MapperSlotId mapperId)
{
if (m_MapperID != mapperId)
Superclass::SetMapperID(mapperId);
// Workaround for GL Displaylist Bug
checkState();
}
/*!
\brief Activates the current renderwindow.
*/
void mitk::VtkPropRenderer::MakeCurrent()
{
- if (m_RenderWindow != NULL)
+ if (m_RenderWindow != nullptr)
m_RenderWindow->MakeCurrent();
}
void mitk::VtkPropRenderer::PickWorldPoint(const mitk::Point2D &displayPoint, mitk::Point3D &worldPoint) const
{
if (this->GetRenderWindow()->GetNeverRendered() != 0)
return; // somebody called picking before we ever rendered; cannot have enough information yet
switch (m_PickingMode)
{
case (WorldPointPicking):
{
m_WorldPointPicker->Pick(displayPoint[0], displayPoint[1], 0, m_VtkRenderer);
vtk2itk(m_WorldPointPicker->GetPickPosition(), worldPoint);
break;
}
case (PointPicking):
{
m_PointPicker->Pick(displayPoint[0], displayPoint[1], 0, m_VtkRenderer);
vtk2itk(m_PointPicker->GetPickPosition(), worldPoint);
break;
}
case (CellPicking):
{
m_CellPicker->Pick(displayPoint[0], displayPoint[1], 0, m_VtkRenderer);
vtk2itk(m_CellPicker->GetPickPosition(), worldPoint);
break;
}
}
// todo: is this picking in 2D renderwindows?
// Superclass::PickWorldPoint(displayPoint, worldPoint);
}
mitk::DataNode *mitk::VtkPropRenderer::PickObject(const Point2D &displayPosition, Point3D &worldPosition) const
{
m_CellPicker->InitializePickList();
// Iterate over all DataStorage objects to determine all vtkProps intended
// for picking
DataStorage::SetOfObjects::ConstPointer allObjects = m_DataStorage->GetAll();
for (DataStorage::SetOfObjects::ConstIterator it = allObjects->Begin(); it != allObjects->End(); ++it)
{
const DataNode *node = it->Value();
- if (node == NULL)
+ if (node == nullptr)
continue;
bool pickable = false;
node->GetBoolProperty("pickable", pickable);
if (!pickable)
continue;
VtkMapper *mapper = dynamic_cast<VtkMapper *>(node->GetMapper(m_MapperID));
- if (mapper == NULL)
+ if (mapper == nullptr)
continue;
vtkProp *prop = mapper->GetVtkProp((mitk::BaseRenderer *)this);
- if (prop == NULL)
+ if (prop == nullptr)
continue;
m_CellPicker->AddPickList(prop);
}
// Do the picking and retrieve the picked vtkProp (if any)
m_CellPicker->PickFromListOn();
m_CellPicker->Pick(displayPosition[0], displayPosition[1], 0.0, m_VtkRenderer);
m_CellPicker->PickFromListOff();
vtk2itk(m_CellPicker->GetPickPosition(), worldPosition);
vtkProp *prop = m_CellPicker->GetViewProp();
- if (prop == NULL)
+ if (prop == nullptr)
{
- return NULL;
+ return nullptr;
}
// Iterate over all DataStorage objects to determine if the retrieved
// vtkProp is owned by any associated mapper.
for (DataStorage::SetOfObjects::ConstIterator it = allObjects->Begin(); it != allObjects->End(); ++it)
{
DataNode::Pointer node = it->Value();
if (node.IsNull())
continue;
mitk::Mapper *mapper = node->GetMapper(m_MapperID);
- if (mapper == NULL)
+ if (mapper == nullptr)
continue;
mitk::VtkMapper *vtkmapper = dynamic_cast<VtkMapper *>(mapper);
if (vtkmapper)
{
// if vtk-based, then ...
if (vtkmapper->HasVtkProp(prop, const_cast<mitk::VtkPropRenderer *>(this)))
{
return node;
}
}
}
- return NULL;
+ return nullptr;
}
// todo: is this 2D renderwindow picking?
// return Superclass::PickObject( displayPosition, worldPosition );
vtkTextProperty *mitk::VtkPropRenderer::GetTextLabelProperty(int text_id)
{
return this->m_TextCollection[text_id]->GetTextProperty();
}
void mitk::VtkPropRenderer::InitPathTraversal()
{
if (m_DataStorage.IsNotNull())
{
this->UpdatePaths();
this->m_Paths->InitTraversal();
}
}
void mitk::VtkPropRenderer::UpdatePaths()
{
if (m_DataStorage.IsNull())
{
return;
}
if (GetMTime() > m_PathTime || (m_Paths != nullptr && m_Paths->GetMTime() > m_PathTime))
{
// Create the list to hold all the paths
m_Paths = vtkSmartPointer<vtkAssemblyPaths>::New();
DataStorage::SetOfObjects::ConstPointer objects = m_DataStorage->GetAll();
for (DataStorage::SetOfObjects::const_iterator iter = objects->begin(); iter != objects->end(); ++iter)
{
vtkSmartPointer<vtkAssemblyPath> onePath = vtkSmartPointer<vtkAssemblyPath>::New();
Mapper *mapper = (*iter)->GetMapper(BaseRenderer::Standard3D);
if (mapper)
{
VtkMapper *vtkmapper = dynamic_cast<VtkMapper *>(mapper);
{
vtkProp *prop = vtkmapper->GetVtkProp(this);
if (prop && prop->GetVisibility())
{
// add to assembly path
onePath->AddNode(prop, prop->GetMatrix());
m_Paths->AddItem(onePath);
}
}
}
}
m_PathTime.Modified();
}
}
int mitk::VtkPropRenderer::GetNumberOfPaths()
{
UpdatePaths();
return m_Paths->GetNumberOfItems();
}
vtkAssemblyPath *mitk::VtkPropRenderer::GetNextPath()
{
return m_Paths ? m_Paths->GetNextItem() : 0;
}
void mitk::VtkPropRenderer::ReleaseGraphicsResources(vtkWindow * /*renWin*/)
{
if (m_DataStorage.IsNull())
return;
DataStorage::SetOfObjects::ConstPointer allObjects = m_DataStorage->GetAll();
for (DataStorage::SetOfObjects::const_iterator iter = allObjects->begin(); iter != allObjects->end(); ++iter)
{
DataNode::Pointer node = *iter;
if (node.IsNull())
continue;
Mapper *mapper = node->GetMapper(m_MapperID);
if (mapper)
{
VtkMapper *vtkmapper = dynamic_cast<VtkMapper *>(mapper);
if (vtkmapper)
vtkmapper->ReleaseGraphicsResources(this);
}
}
}
const vtkWorldPointPicker *mitk::VtkPropRenderer::GetWorldPointPicker() const
{
return m_WorldPointPicker;
}
const vtkPointPicker *mitk::VtkPropRenderer::GetPointPicker() const
{
return m_PointPicker;
}
const vtkCellPicker *mitk::VtkPropRenderer::GetCellPicker() const
{
return m_CellPicker;
}
mitk::VtkPropRenderer::MappersMapType mitk::VtkPropRenderer::GetMappersMap() const
{
return m_MappersMap;
}
// Workaround for GL Displaylist bug
static int glWorkAroundGlobalCount = 0;
bool mitk::VtkPropRenderer::useImmediateModeRendering()
{
return glWorkAroundGlobalCount > 1;
}
void mitk::VtkPropRenderer::checkState()
{
if (m_MapperID == Standard3D)
{
if (!didCount)
{
didCount = true;
glWorkAroundGlobalCount++;
if (glWorkAroundGlobalCount == 2)
{
MITK_INFO << "Multiple 3D Renderwindows active...: turning Immediate Rendering ON for legacy mappers";
// vtkMapper::GlobalImmediateModeRenderingOn();
}
}
}
else
{
if (didCount)
{
didCount = false;
glWorkAroundGlobalCount--;
if (glWorkAroundGlobalCount == 1)
{
MITK_INFO << "Single 3D Renderwindow active...: turning Immediate Rendering OFF for legacy mappers";
// vtkMapper::GlobalImmediateModeRenderingOff();
}
}
}
}
//### Contains all methods which are neceassry before each VTK Render() call
void mitk::VtkPropRenderer::PrepareRender()
{
if (this->GetMapperID() != m_CameraInitializedForMapperID)
{
Initialize2DvtkCamera(); // Set parallel projection etc.
}
GetCameraController()->AdjustCameraToPlane();
}
bool mitk::VtkPropRenderer::Initialize2DvtkCamera()
{
if (this->GetMapperID() == Standard3D)
{
// activate parallel projection for 2D
this->GetVtkRenderer()->GetActiveCamera()->SetParallelProjection(false);
vtkSmartPointer<vtkInteractorStyleTrackballCamera> style =
vtkSmartPointer<vtkInteractorStyleTrackballCamera>::New();
this->GetRenderWindow()->GetInteractor()->SetInteractorStyle(style);
this->GetRenderWindow()->GetInteractor()->EnableRenderOff();
m_CameraInitializedForMapperID = Standard3D;
}
else if (this->GetMapperID() == Standard2D)
{
// activate parallel projection for 2D
this->GetVtkRenderer()->GetActiveCamera()->SetParallelProjection(true);
// turn the light out in the scene in order to render correct grey values.
// TODO Implement a property for light in the 2D render windows (in another method)
this->GetVtkRenderer()->RemoveAllLights();
vtkSmartPointer<mitkVtkInteractorStyle> style = vtkSmartPointer<mitkVtkInteractorStyle>::New();
this->GetRenderWindow()->GetInteractor()->SetInteractorStyle(style);
this->GetRenderWindow()->GetInteractor()->EnableRenderOff();
m_CameraInitializedForMapperID = Standard2D;
}
return true;
}
diff --git a/Modules/DiffusionImaging/DiffusionCore/cmdapps/CMakeLists.txt b/Modules/DiffusionImaging/DiffusionCore/cmdapps/CMakeLists.txt
index 11f0c2aa2b..7fbf48d40b 100644
--- a/Modules/DiffusionImaging/DiffusionCore/cmdapps/CMakeLists.txt
+++ b/Modules/DiffusionImaging/DiffusionCore/cmdapps/CMakeLists.txt
@@ -1,44 +1,44 @@
option(BUILD_DiffusionMiniApps "Build commandline tools for diffusion" OFF)
if(BUILD_DiffusionMiniApps OR MITK_BUILD_ALL_APPS)
# needed include directories
include_directories(
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_BINARY_DIR}
)
# list of diffusion miniapps
# if an app requires additional dependencies
# they are added after a "^^" and separated by "_"
set( diffusionminiapps
DwiDenoising^^
ImageResampler^^
ExportShImage^^
CopyGeometry^^
DiffusionIndices^^
QballReconstruction^^
Registration^^
TensorReconstruction^^
TensorDerivedMapsExtraction^^
DiffusionDICOMLoader^^
- DiffusionIVIMFit^^
+ DiffusionKurtosisFit^^
)
foreach(diffusionminiapp ${diffusionminiapps})
# extract mini app name and dependencies
string(REPLACE "^^" "\\;" miniapp_info ${diffusionminiapp})
set(miniapp_info_list ${miniapp_info})
list(GET miniapp_info_list 0 appname)
list(GET miniapp_info_list 1 raw_dependencies)
string(REPLACE "_" "\\;" dependencies "${raw_dependencies}")
set(dependencies_list ${dependencies})
mitkFunctionCreateCommandLineApp(
NAME ${appname}
DEPENDS MitkCore MitkDiffusionCore ${dependencies_list}
PACKAGE_DEPENDS ITK
)
endforeach()
endif()
diff --git a/Modules/DiffusionImaging/DiffusionCore/cmdapps/DiffusionIVIMFit.cpp b/Modules/DiffusionImaging/DiffusionCore/cmdapps/DiffusionKurtosisFit.cpp
similarity index 60%
rename from Modules/DiffusionImaging/DiffusionCore/cmdapps/DiffusionIVIMFit.cpp
rename to Modules/DiffusionImaging/DiffusionCore/cmdapps/DiffusionKurtosisFit.cpp
index 6c49d7a7d0..d1886d0469 100644
--- a/Modules/DiffusionImaging/DiffusionCore/cmdapps/DiffusionIVIMFit.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/cmdapps/DiffusionKurtosisFit.cpp
@@ -1,207 +1,253 @@
/*===================================================================
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 "mitkCommandLineParser.h"
#include <mitkIOUtil.h>
#include <mitkDiffusionPropertyHelper.h>
#include <mitkImageCaster.h>
#include <itkDiffusionKurtosisReconstructionImageFilter.h>
+#include "mitkImage.h"
+#include <iostream>
+#include <usAny.h>
+#include <fstream>
+#include "mitkIOUtil.h"
+
+#include <itkFileTools.h>
+#include <itksys/SystemTools.hxx>
+
+
//vnl_includes
#include "vnl/vnl_math.h"
#include "vnl/vnl_cost_function.h"
#include "vnl/vnl_least_squares_function.h"
#include "vnl/algo/vnl_lbfgsb.h"
#include "vnl/algo/vnl_lbfgs.h"
#include "vnl/algo/vnl_levenberg_marquardt.h"
typedef mitk::DiffusionPropertyHelper DPH;
#include <itkGaussianBlurImageFunction.h>
#include <itkUnaryFunctorImageFilter.h>
#include <itkImageFileWriter.h>
#include <itkVectorIndexSelectionCastImageFilter.h>
#include <itkComposeImageFilter.h>
#include <itkDiscreteGaussianImageFilter.h>
+
+
DPH::ImageType::Pointer GetBlurredVectorImage( DPH::ImageType::Pointer vectorImage, double sigma)
{
typedef itk::DiscreteGaussianImageFilter< itk::Image<DPH::DiffusionPixelType, 3 >, itk::Image<DPH::DiffusionPixelType, 3 > > GaussianFilterType;
typedef itk::VectorIndexSelectionCastImageFilter< DPH::ImageType, itk::Image<DPH::DiffusionPixelType, 3 > > IndexSelectionType;
IndexSelectionType::Pointer indexSelectionFilter = IndexSelectionType::New();
indexSelectionFilter->SetInput( vectorImage );
typedef itk::ComposeImageFilter< itk::Image<DPH::DiffusionPixelType, 3>, DPH::ImageType > ComposeFilterType;
ComposeFilterType::Pointer vec_composer = ComposeFilterType::New();
for( unsigned int i=0; i<vectorImage->GetVectorLength(); ++i)
{
GaussianFilterType::Pointer gaussian_filter = GaussianFilterType::New();
indexSelectionFilter->SetIndex( i );
gaussian_filter->SetInput( indexSelectionFilter->GetOutput() );
gaussian_filter->SetVariance( sigma );
vec_composer->SetInput(i, gaussian_filter->GetOutput() );
gaussian_filter->Update();
}
try
{
vec_composer->Update();
}
catch(const itk::ExceptionObject &e)
{
mitkThrow() << "[VectorImage.GaussianSmoothing] !! Failed with ITK Exception: " << e.what();
}
DPH::ImageType::Pointer smoothed_vector = vec_composer->GetOutput();
-/*
+
+ /*
itk::ImageFileWriter< DPH::ImageType >::Pointer writer =
itk::ImageFileWriter< DPH::ImageType >::New();
writer->SetInput( smoothed_vector );
writer->SetFileName( "/tmp/itk_smoothed_vector.nrrd");
writer->Update();*/
return smoothed_vector;
}
-void KurtosisMapComputation( mitk::Image::Pointer input, std::string output_prefix )
+void KurtosisMapComputation( mitk::Image::Pointer input,
+ std::string output_prefix ,
+ std::string output_type,
+ std::string maskPath,
+ bool omitBZero,
+ double lower,
+ double upper )
{
DPH::ImageType::Pointer vectorImage = DPH::ImageType::New();
mitk::CastToItkImage( input, vectorImage );
-
-
typedef itk::DiffusionKurtosisReconstructionImageFilter< short, double > KurtosisFilterType;
KurtosisFilterType::Pointer kurtosis_filter = KurtosisFilterType::New();
-
kurtosis_filter->SetInput( GetBlurredVectorImage( vectorImage, 1.5 ) );
kurtosis_filter->SetReferenceBValue( DPH::GetReferenceBValue( input.GetPointer() ) );
kurtosis_filter->SetGradientDirections( DPH::GetGradientContainer( input.GetPointer() ) );
- kurtosis_filter->SetNumberOfThreads(1);
+// kurtosis_filter->SetNumberOfThreads(1);
+ kurtosis_filter->SetOmitUnweightedValue(omitBZero);
+ kurtosis_filter->SetBoundariesForKurtosis(-lower,upper);
+// kurtosis_filter->SetInitialSolution(const vnl_vector<double>& x0 );
- KurtosisFilterType::OutputImageRegionType o_region;
- KurtosisFilterType::OutputImageRegionType::SizeType o_size;
- KurtosisFilterType::OutputImageRegionType::IndexType o_index;
- o_index.Fill(0); o_size.Fill(0);
- o_index[0] = 48; o_index[1] = 18; o_index[2] = 12;
- o_size[0] = 16; o_size[1] = 24; o_size[2] = 1;
-
- o_region.SetSize( o_size );
- o_region.SetIndex( o_index );
- kurtosis_filter->SetMapOutputRegion( o_region );
+ if(maskPath != "")
+ {
+ mitk::Image::Pointer segmentation;
+ segmentation = mitk::IOUtil::LoadImage(maskPath);
+ typedef itk::Image< short , 3> MaskImageType;
+ MaskImageType::Pointer vectorSeg = MaskImageType::New() ;
+ mitk::CastToItkImage( segmentation, vectorSeg );
+ kurtosis_filter->SetImageMask(vectorSeg) ;
+ }
try
{
kurtosis_filter->Update();
}
catch( const itk::ExceptionObject& e)
{
mitkThrow() << "Kurtosis fit failed with an ITK Exception: " << e.what();
}
mitk::Image::Pointer d_image = mitk::Image::New();
d_image->InitializeByItk( kurtosis_filter->GetOutput(0) );
d_image->SetVolume( kurtosis_filter->GetOutput(0)->GetBufferPointer() );
mitk::Image::Pointer k_image = mitk::Image::New();
k_image->InitializeByItk( kurtosis_filter->GetOutput(1) );
k_image->SetVolume( kurtosis_filter->GetOutput(1)->GetBufferPointer() );
- std::string outputD_FileName = output_prefix + "_ADC_map.nrrd";
- std::string outputK_FileName = output_prefix + "_AKC_map.nrrd";
+ std::string outputD_FileName = output_prefix + "_ADC_map." + output_type;
+ std::string outputK_FileName = output_prefix + "_AKC_map." + output_type;
try
{
- mitk::IOUtil::Save( d_image, outputD_FileName );
- mitk::IOUtil::Save( k_image, outputK_FileName );
+ mitk::IOUtil::Save( d_image, outputD_FileName );
+ mitk::IOUtil::Save( k_image, outputK_FileName );
}
catch( const itk::ExceptionObject& e)
{
mitkThrow() << "Failed to save the KurtosisFit Results due to exception: " << e.what();
}
}
int main( int argc, char* argv[] )
{
-
mitkCommandLineParser parser;
- parser.setTitle("Diffusion IVIM (Kurtosis) Fit");
+ parser.setTitle("Diffusion Kurtosis Fit");
parser.setCategory("Signal Reconstruction");
parser.setContributor("MIC");
- parser.setDescription("Fitting of IVIM / Kurtosis");
-
+ parser.setDescription("Fitting Kurtosis");
parser.setArgumentPrefix("--","-");
+
// mandatory arguments
parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input: ", "input image (DWI)", us::Any(), false);
parser.addArgument("output", "o", mitkCommandLineParser::String, "Output Preifx: ", "Prefix for the output images, will append _f, _K, _D accordingly ", us::Any(), false);
- parser.addArgument("fit", "f", mitkCommandLineParser::String, "Input: ", "input image (DWI)", us::Any(), false);
+ parser.addArgument("output_type", "ot", mitkCommandLineParser::String, "Output Type: ", "choose data type of output image, e.g. '.nii' or '.nrrd' ", us::Any(), false);
// optional arguments
- parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Masking Image: ", "ROI (segmentation)", us::Any(), true);
+ parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Masking Image: ", "ROI (segmentation)", us::Any());
+ parser.addArgument("help", "h", mitkCommandLineParser::Bool, "Help", "Show this help text");
+ parser.addArgument("omitbzero", "om", mitkCommandLineParser::Bool, "Omit b0:", "Omit b0 value during fit (default = false)", us::Any());
+ parser.addArgument("lowerkbound", "kl", mitkCommandLineParser::Float, "lower Kbound:", "Set (unsigned) lower boundary for Kurtosis parameter (default = -1000)", us::Any());
+ parser.addArgument("upperkbound", "ku", mitkCommandLineParser::Float, "upper Kbound:", "Set upper boundary for Kurtosis parameter (default = 1000)", us::Any());
std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
- if (parsedArgs.size()==0)
- return EXIT_FAILURE;
+
+ if (parsedArgs.size()==0 || parsedArgs.count("help") || parsedArgs.count("h")){
+ std::cout << parser.helpText();
+ return EXIT_SUCCESS;
+ }
// mandatory arguments
std::string inFileName = us::any_cast<std::string>(parsedArgs["input"]);
std::string out_prefix = us::any_cast<std::string>(parsedArgs["output"]);
- std::string fit_name = us::any_cast<std::string>(parsedArgs["fit"]);
+ std::string maskPath = "";
mitk::Image::Pointer inputImage = mitk::IOUtil::LoadImage(inFileName);
- if( !DPH::IsDiffusionWeightedImage( inputImage ) )
+
+ bool omitBZero = false;
+ double lower = -1000;
+ double upper = 1000;
+ std::string out_type = "nrrd";
+
+ if (parsedArgs.count("mask") || parsedArgs.count("m"))
{
- MITK_ERROR("DiffusionIVIMFit.Input") << "No valid diffusion-weighted image provided, failed to load " << inFileName << " as DW Image. Aborting...";
- return EXIT_FAILURE;
+ maskPath = us::any_cast<std::string>(parsedArgs["mask"]);
}
- if( fit_name == "Kurtosis" )
+ if (parsedArgs.count("output_type") || parsedArgs.count("ot"))
{
- MITK_INFO("DiffusionIVIMFit.Main") << "-----[ Kurtosis Fit ]-----";
+ out_type = us::any_cast<std::string>(parsedArgs["output_type"]);
+ }
- KurtosisMapComputation( inputImage, out_prefix );
+ if (parsedArgs.count("omitbzero") || parsedArgs.count("om"))
+ {
+ omitBZero = us::any_cast<bool>(parsedArgs["omitbzero"]);
+ }
+ if (parsedArgs.count("lowerkbound") || parsedArgs.count("kl"))
+ {
+ lower = us::any_cast<float>(parsedArgs["lowerkbound"]);
}
- else if (fit_name == "IVIM" )
+
+ if (parsedArgs.count("upperkbound") || parsedArgs.count("ku"))
{
- MITK_INFO("DiffusionIVIMFit.Main") << "IVIM Fit not fully implemented yet. Aborting...";
- return EXIT_FAILURE;
+ upper = us::any_cast<float>(parsedArgs["upperkbound"]);
}
- else
+
+ if( !DPH::IsDiffusionWeightedImage( inputImage ) )
{
- MITK_ERROR("DiffusionIVIMFit.Main") << "Unrecognized option: " << fit_name << ". Valid values [\"IVIM\", \"Kurtosis\"] \n Aborting... \n";
+ MITK_ERROR("DiffusionIVIMFit.Input") << "No valid diffusion-weighted image provided, failed to load " << inFileName << " as DW Image. Aborting...";
return EXIT_FAILURE;
-
}
+
+
+KurtosisMapComputation( inputImage,
+ out_prefix ,
+ out_type,
+ maskPath,
+ omitBZero,
+ lower,
+ upper);
+
}
diff --git a/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp b/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
index d194449d0f..7ab9dc853b 100644
--- a/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
@@ -1,2017 +1,2022 @@
/*===================================================================
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.
===================================================================*/
#define SMW_INFO MITK_INFO("widget.stdmulti")
#include "QmitkStdMultiWidget.h"
#include <QGridLayout>
#include <QHBoxLayout>
#include <QList>
#include <QMouseEvent>
#include <QTimer>
#include <QVBoxLayout>
#include <qsplitter.h>
#include "mitkImagePixelReadAccessor.h"
#include "mitkPixelTypeMultiplex.h"
#include <mitkCameraController.h>
#include <mitkDataStorage.h>
#include <mitkImage.h>
#include <mitkInteractionConst.h>
#include <mitkLine.h>
#include <mitkNodePredicateBase.h>
#include <mitkNodePredicateDataType.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
#include <mitkOverlayManager.h>
#include <mitkPlaneGeometryDataMapper2D.h>
#include <mitkPointSet.h>
#include <mitkProperties.h>
#include <mitkStatusBar.h>
#include <mitkVtkLayerController.h>
#include <vtkCornerAnnotation.h>
#include <vtkMitkRectangleProp.h>
#include <vtkTextProperty.h>
#include <iomanip>
QmitkStdMultiWidget::QmitkStdMultiWidget(QWidget *parent,
Qt::WindowFlags f,
mitk::RenderingManager *renderingManager,
mitk::BaseRenderer::RenderingMode::Type renderingMode,
const QString &name)
: QWidget(parent, f),
mitkWidget1(NULL),
mitkWidget2(NULL),
mitkWidget3(NULL),
mitkWidget4(NULL),
levelWindowWidget(NULL),
QmitkStdMultiWidgetLayout(NULL),
m_Layout(LAYOUT_DEFAULT),
m_PlaneMode(PLANE_MODE_SLICING),
m_RenderingManager(renderingManager),
m_GradientBackgroundFlag(true),
m_TimeNavigationController(NULL),
m_MainSplit(NULL),
m_LayoutSplit(NULL),
m_SubSplit1(NULL),
m_SubSplit2(NULL),
mitkWidget1Container(NULL),
mitkWidget2Container(NULL),
mitkWidget3Container(NULL),
mitkWidget4Container(NULL),
m_PendingCrosshairPositionEvent(false),
m_CrosshairNavigationEnabled(false)
{
/******************************************************
* Use the global RenderingManager if none was specified
* ****************************************************/
if (m_RenderingManager == NULL)
{
m_RenderingManager = mitk::RenderingManager::GetInstance();
}
m_TimeNavigationController = m_RenderingManager->GetTimeNavigationController();
/*******************************/
// Create Widget manually
/*******************************/
// create Layouts
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
QmitkStdMultiWidgetLayout->setContentsMargins(0, 0, 0, 0);
// Set Layout to widget
this->setLayout(QmitkStdMultiWidgetLayout);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit);
m_MainSplit->addWidget(m_LayoutSplit);
// create m_SubSplit1 and m_SubSplit2
m_SubSplit1 = new QSplitter(m_LayoutSplit);
m_SubSplit2 = new QSplitter(m_LayoutSplit);
// creae Widget Container
mitkWidget1Container = new QWidget(m_SubSplit1);
mitkWidget2Container = new QWidget(m_SubSplit1);
mitkWidget3Container = new QWidget(m_SubSplit2);
mitkWidget4Container = new QWidget(m_SubSplit2);
mitkWidget1Container->setContentsMargins(0, 0, 0, 0);
mitkWidget2Container->setContentsMargins(0, 0, 0, 0);
mitkWidget3Container->setContentsMargins(0, 0, 0, 0);
mitkWidget4Container->setContentsMargins(0, 0, 0, 0);
// create Widget Layout
QHBoxLayout *mitkWidgetLayout1 = new QHBoxLayout(mitkWidget1Container);
QHBoxLayout *mitkWidgetLayout2 = new QHBoxLayout(mitkWidget2Container);
QHBoxLayout *mitkWidgetLayout3 = new QHBoxLayout(mitkWidget3Container);
QHBoxLayout *mitkWidgetLayout4 = new QHBoxLayout(mitkWidget4Container);
m_CornerAnnotations[0] = vtkSmartPointer<vtkCornerAnnotation>::New();
m_CornerAnnotations[1] = vtkSmartPointer<vtkCornerAnnotation>::New();
m_CornerAnnotations[2] = vtkSmartPointer<vtkCornerAnnotation>::New();
m_CornerAnnotations[3] = vtkSmartPointer<vtkCornerAnnotation>::New();
m_RectangleProps[0] = vtkSmartPointer<vtkMitkRectangleProp>::New();
m_RectangleProps[1] = vtkSmartPointer<vtkMitkRectangleProp>::New();
m_RectangleProps[2] = vtkSmartPointer<vtkMitkRectangleProp>::New();
m_RectangleProps[3] = vtkSmartPointer<vtkMitkRectangleProp>::New();
mitkWidgetLayout1->setMargin(0);
mitkWidgetLayout2->setMargin(0);
mitkWidgetLayout3->setMargin(0);
mitkWidgetLayout4->setMargin(0);
// set Layout to Widget Container
mitkWidget1Container->setLayout(mitkWidgetLayout1);
mitkWidget2Container->setLayout(mitkWidgetLayout2);
mitkWidget3Container->setLayout(mitkWidgetLayout3);
mitkWidget4Container->setLayout(mitkWidgetLayout4);
// set SizePolicy
mitkWidget1Container->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
mitkWidget2Container->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
mitkWidget3Container->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
mitkWidget4Container->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
// insert Widget Container into the splitters
m_SubSplit1->addWidget(mitkWidget1Container);
m_SubSplit1->addWidget(mitkWidget2Container);
m_SubSplit2->addWidget(mitkWidget3Container);
m_SubSplit2->addWidget(mitkWidget4Container);
// Create RenderWindows 1
mitkWidget1 = new QmitkRenderWindow(mitkWidget1Container, name + ".widget1", NULL, m_RenderingManager, renderingMode);
mitkWidget1->SetLayoutIndex(AXIAL);
mitkWidgetLayout1->addWidget(mitkWidget1);
// Create RenderWindows 2
mitkWidget2 = new QmitkRenderWindow(mitkWidget2Container, name + ".widget2", NULL, m_RenderingManager, renderingMode);
mitkWidget2->setEnabled(true);
mitkWidget2->SetLayoutIndex(SAGITTAL);
mitkWidgetLayout2->addWidget(mitkWidget2);
// Create RenderWindows 3
mitkWidget3 = new QmitkRenderWindow(mitkWidget3Container, name + ".widget3", NULL, m_RenderingManager, renderingMode);
mitkWidget3->SetLayoutIndex(CORONAL);
mitkWidgetLayout3->addWidget(mitkWidget3);
// Create RenderWindows 4
mitkWidget4 = new QmitkRenderWindow(mitkWidget4Container, name + ".widget4", NULL, m_RenderingManager, renderingMode);
mitkWidget4->SetLayoutIndex(THREE_D);
mitkWidgetLayout4->addWidget(mitkWidget4);
// create SignalSlot Connection
connect(mitkWidget1, SIGNAL(SignalLayoutDesignChanged(int)), this, SLOT(OnLayoutDesignChanged(int)));
connect(mitkWidget1, SIGNAL(ResetView()), this, SLOT(ResetCrosshair()));
connect(mitkWidget1, SIGNAL(ChangeCrosshairRotationMode(int)), this, SLOT(SetWidgetPlaneMode(int)));
connect(this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget1, SLOT(OnWidgetPlaneModeChanged(int)));
connect(mitkWidget2, SIGNAL(SignalLayoutDesignChanged(int)), this, SLOT(OnLayoutDesignChanged(int)));
connect(mitkWidget2, SIGNAL(ResetView()), this, SLOT(ResetCrosshair()));
connect(mitkWidget2, SIGNAL(ChangeCrosshairRotationMode(int)), this, SLOT(SetWidgetPlaneMode(int)));
connect(this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget2, SLOT(OnWidgetPlaneModeChanged(int)));
connect(mitkWidget3, SIGNAL(SignalLayoutDesignChanged(int)), this, SLOT(OnLayoutDesignChanged(int)));
connect(mitkWidget3, SIGNAL(ResetView()), this, SLOT(ResetCrosshair()));
connect(mitkWidget3, SIGNAL(ChangeCrosshairRotationMode(int)), this, SLOT(SetWidgetPlaneMode(int)));
connect(this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget3, SLOT(OnWidgetPlaneModeChanged(int)));
connect(mitkWidget4, SIGNAL(SignalLayoutDesignChanged(int)), this, SLOT(OnLayoutDesignChanged(int)));
connect(mitkWidget4, SIGNAL(ResetView()), this, SLOT(ResetCrosshair()));
connect(mitkWidget4, SIGNAL(ChangeCrosshairRotationMode(int)), this, SLOT(SetWidgetPlaneMode(int)));
connect(this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget4, SLOT(OnWidgetPlaneModeChanged(int)));
// Create Level Window Widget
levelWindowWidget = new QmitkLevelWindowWidget(m_MainSplit); // this
levelWindowWidget->setObjectName(QString::fromUtf8("levelWindowWidget"));
QSizePolicy sizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
sizePolicy.setHorizontalStretch(0);
sizePolicy.setVerticalStretch(0);
sizePolicy.setHeightForWidth(levelWindowWidget->sizePolicy().hasHeightForWidth());
levelWindowWidget->setSizePolicy(sizePolicy);
levelWindowWidget->setMaximumWidth(50);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// show mainSplitt and add to Layout
m_MainSplit->show();
// resize Image.
this->resize(QSize(364, 477).expandedTo(minimumSizeHint()));
// Initialize the widgets.
this->InitializeWidget();
// Activate Widget Menu
this->ActivateMenuWidget(true);
}
void QmitkStdMultiWidget::InitializeWidget()
{
// Make all black and overwrite renderwindow 4
this->FillGradientBackgroundWithBlack();
// This is #191919 in hex
float tmp1[3] = {0.098f, 0.098f, 0.098f};
// This is #7F7F7F in hex
float tmp2[3] = {0.498f, 0.498f, 0.498f};
m_GradientBackgroundColors[3] = std::make_pair(mitk::Color(tmp1), mitk::Color(tmp2));
// Yellow is default color for widget4
m_DecorationColorWidget4[0] = 1.0f;
m_DecorationColorWidget4[1] = 1.0f;
m_DecorationColorWidget4[2] = 0.0f;
// transfer colors in WorldGeometry-Nodes of the associated Renderer
mitk::IntProperty::Pointer layer;
// of widget 1
m_PlaneNode1 = mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode();
m_PlaneNode1->SetColor(GetDecorationColor(0));
layer = mitk::IntProperty::New(1000);
m_PlaneNode1->SetProperty("layer", layer);
// ... of widget 2
m_PlaneNode2 = mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode();
m_PlaneNode2->SetColor(GetDecorationColor(1));
layer = mitk::IntProperty::New(1000);
m_PlaneNode2->SetProperty("layer", layer);
// ... of widget 3
m_PlaneNode3 = mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode();
m_PlaneNode3->SetColor(GetDecorationColor(2));
layer = mitk::IntProperty::New(1000);
m_PlaneNode3->SetProperty("layer", layer);
// The parent node
m_ParentNodeForGeometryPlanes =
mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode();
layer = mitk::IntProperty::New(1000);
m_ParentNodeForGeometryPlanes->SetProperty("layer", layer);
mitk::OverlayManager::Pointer OverlayManager = mitk::OverlayManager::New();
mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->SetOverlayManager(OverlayManager);
mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->SetOverlayManager(OverlayManager);
mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->SetOverlayManager(OverlayManager);
mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->SetOverlayManager(OverlayManager);
mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->SetMapperID(mitk::BaseRenderer::Standard3D);
// Set plane mode (slicing/rotation behavior) to slicing (default)
m_PlaneMode = PLANE_MODE_SLICING;
// Set default view directions for SNCs
mitkWidget1->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
mitkWidget2->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
mitkWidget3->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Frontal);
mitkWidget4->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Original);
SetDecorationProperties("Axial", GetDecorationColor(0), 0);
SetDecorationProperties("Sagittal", GetDecorationColor(1), 1);
SetDecorationProperties("Coronal", GetDecorationColor(2), 2);
SetDecorationProperties("3D", GetDecorationColor(3), 3);
// connect to the "time navigation controller": send time via sliceNavigationControllers
m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget1->GetSliceNavigationController(), false);
m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget2->GetSliceNavigationController(), false);
m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget3->GetSliceNavigationController(), false);
m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget4->GetSliceNavigationController(), false);
mitkWidget1->GetSliceNavigationController()->ConnectGeometrySendEvent(
mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()));
// reverse connection between sliceNavigationControllers and m_TimeNavigationController
mitkWidget1->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
mitkWidget2->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
mitkWidget3->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
// mitkWidget4->GetSliceNavigationController()
// ->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
m_MouseModeSwitcher = mitk::MouseModeSwitcher::New();
// setup the department logo rendering
m_LogoRendering = mitk::LogoOverlay::New();
mitk::BaseRenderer::Pointer renderer4 = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow());
m_LogoRendering->SetOpacity(0.5);
mitk::Point2D offset;
offset.Fill(0.03);
m_LogoRendering->SetOffsetVector(offset);
m_LogoRendering->SetRelativeSize(0.15);
m_LogoRendering->SetCornerPosition(1);
m_LogoRendering->SetLogoImagePath("DefaultLogo");
renderer4->GetOverlayManager()->AddOverlay(m_LogoRendering.GetPointer(), renderer4);
}
void QmitkStdMultiWidget::FillGradientBackgroundWithBlack()
{
// We have 4 widgets and ...
for (unsigned int i = 0; i < 4; ++i)
{
float black[3] = {0.0f, 0.0f, 0.0f};
m_GradientBackgroundColors[i] = std::make_pair(mitk::Color(black), mitk::Color(black));
}
}
std::pair<mitk::Color, mitk::Color> QmitkStdMultiWidget::GetGradientColors(unsigned int widgetNumber)
{
if (widgetNumber > 3)
{
MITK_ERROR << "Decoration color for unknown widget!";
float black[3] = {0.0f, 0.0f, 0.0f};
return std::make_pair(mitk::Color(black), mitk::Color(black));
}
return m_GradientBackgroundColors[widgetNumber];
}
mitk::Color QmitkStdMultiWidget::GetDecorationColor(unsigned int widgetNumber)
{
// The implementation looks a bit messy here, but it avoids
// synchronization of the color of the geometry nodes and an
// internal member here.
// Default colors were chosen for decent visibitliy.
// Feel free to change your preferences in the workbench.
float tmp[3] = {0.0f, 0.0f, 0.0f};
switch (widgetNumber)
{
case 0:
{
if (m_PlaneNode1.IsNotNull())
{
if (m_PlaneNode1->GetColor(tmp))
{
return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode1->GetProperty("color"))->GetColor();
}
}
float red[3] = {0.753f, 0.0f, 0.0f}; // This is #C00000 in hex
return mitk::Color(red);
}
case 1:
{
if (m_PlaneNode2.IsNotNull())
{
if (m_PlaneNode2->GetColor(tmp))
{
return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode2->GetProperty("color"))->GetColor();
}
}
float green[3] = {0.0f, 0.69f, 0.0f}; // This is #00B000 in hex
return mitk::Color(green);
}
case 2:
{
if (m_PlaneNode3.IsNotNull())
{
if (m_PlaneNode3->GetColor(tmp))
{
return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode3->GetProperty("color"))->GetColor();
}
}
float blue[3] = {0.0, 0.502f, 1.0f}; // This is #0080FF in hex
return mitk::Color(blue);
}
case 3:
{
return m_DecorationColorWidget4;
}
default:
MITK_ERROR << "Decoration color for unknown widget!";
float black[3] = {0.0f, 0.0f, 0.0f};
return mitk::Color(black);
}
}
std::string QmitkStdMultiWidget::GetCornerAnnotationText(unsigned int widgetNumber)
{
if (widgetNumber > 3)
{
MITK_ERROR << "Decoration color for unknown widget!";
return std::string("");
}
return std::string(m_CornerAnnotations[widgetNumber]->GetText(0));
}
QmitkStdMultiWidget::~QmitkStdMultiWidget()
{
DisablePositionTracking();
// DisableNavigationControllerEventListening();
m_TimeNavigationController->Disconnect(mitkWidget1->GetSliceNavigationController());
m_TimeNavigationController->Disconnect(mitkWidget2->GetSliceNavigationController());
m_TimeNavigationController->Disconnect(mitkWidget3->GetSliceNavigationController());
m_TimeNavigationController->Disconnect(mitkWidget4->GetSliceNavigationController());
}
void QmitkStdMultiWidget::RemovePlanesFromDataStorage()
{
if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull() && m_PlaneNode3.IsNotNull() &&
m_ParentNodeForGeometryPlanes.IsNotNull())
{
if (m_DataStorage.IsNotNull())
{
m_DataStorage->Remove(m_PlaneNode1);
m_DataStorage->Remove(m_PlaneNode2);
m_DataStorage->Remove(m_PlaneNode3);
m_DataStorage->Remove(m_ParentNodeForGeometryPlanes);
}
}
}
void QmitkStdMultiWidget::AddPlanesToDataStorage()
{
if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull() && m_PlaneNode3.IsNotNull() &&
m_ParentNodeForGeometryPlanes.IsNotNull())
{
if (m_DataStorage.IsNotNull())
{
m_DataStorage->Add(m_ParentNodeForGeometryPlanes);
m_DataStorage->Add(m_PlaneNode1, m_ParentNodeForGeometryPlanes);
m_DataStorage->Add(m_PlaneNode2, m_ParentNodeForGeometryPlanes);
m_DataStorage->Add(m_PlaneNode3, m_ParentNodeForGeometryPlanes);
}
}
}
void QmitkStdMultiWidget::changeLayoutTo2DImagesUp()
{
SMW_INFO << "changing layout to 2D images up... " << std::endl;
// Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout;
// create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
// Set Layout to widget
this->setLayout(QmitkStdMultiWidgetLayout);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit);
m_MainSplit->addWidget(m_LayoutSplit);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// create m_SubSplit1 and m_SubSplit2
m_SubSplit1 = new QSplitter(m_LayoutSplit);
m_SubSplit2 = new QSplitter(m_LayoutSplit);
// insert Widget Container into splitter top
m_SubSplit1->addWidget(mitkWidget1Container);
m_SubSplit1->addWidget(mitkWidget2Container);
m_SubSplit1->addWidget(mitkWidget3Container);
// set SplitterSize for splitter top
QList<int> splitterSize;
splitterSize.push_back(1000);
splitterSize.push_back(1000);
splitterSize.push_back(1000);
m_SubSplit1->setSizes(splitterSize);
// insert Widget Container into splitter bottom
m_SubSplit2->addWidget(mitkWidget4Container);
// set SplitterSize for splitter m_LayoutSplit
splitterSize.clear();
splitterSize.push_back(400);
splitterSize.push_back(1000);
m_LayoutSplit->setSizes(splitterSize);
// show mainSplitt
m_MainSplit->show();
// show Widget if hidden
if (mitkWidget1->isHidden())
mitkWidget1->show();
if (mitkWidget2->isHidden())
mitkWidget2->show();
if (mitkWidget3->isHidden())
mitkWidget3->show();
if (mitkWidget4->isHidden())
mitkWidget4->show();
// Change Layout Name
m_Layout = LAYOUT_2D_IMAGES_UP;
// update Layout Design List
mitkWidget1->LayoutDesignListChanged(LAYOUT_2D_IMAGES_UP);
mitkWidget2->LayoutDesignListChanged(LAYOUT_2D_IMAGES_UP);
mitkWidget3->LayoutDesignListChanged(LAYOUT_2D_IMAGES_UP);
mitkWidget4->LayoutDesignListChanged(LAYOUT_2D_IMAGES_UP);
// update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutTo2DImagesLeft()
{
SMW_INFO << "changing layout to 2D images left... " << std::endl;
// Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout;
// create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter(m_MainSplit);
m_MainSplit->addWidget(m_LayoutSplit);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// create m_SubSplit1 and m_SubSplit2
m_SubSplit1 = new QSplitter(Qt::Vertical, m_LayoutSplit);
m_SubSplit2 = new QSplitter(m_LayoutSplit);
// insert Widget into the splitters
m_SubSplit1->addWidget(mitkWidget1Container);
m_SubSplit1->addWidget(mitkWidget2Container);
m_SubSplit1->addWidget(mitkWidget3Container);
// set splitterSize of SubSplit1
QList<int> splitterSize;
splitterSize.push_back(1000);
splitterSize.push_back(1000);
splitterSize.push_back(1000);
m_SubSplit1->setSizes(splitterSize);
m_SubSplit2->addWidget(mitkWidget4Container);
// set splitterSize of Layout Split
splitterSize.clear();
splitterSize.push_back(400);
splitterSize.push_back(1000);
m_LayoutSplit->setSizes(splitterSize);
// show mainSplitt and add to Layout
m_MainSplit->show();
// show Widget if hidden
if (mitkWidget1->isHidden())
mitkWidget1->show();
if (mitkWidget2->isHidden())
mitkWidget2->show();
if (mitkWidget3->isHidden())
mitkWidget3->show();
if (mitkWidget4->isHidden())
mitkWidget4->show();
// update Layout Name
m_Layout = LAYOUT_2D_IMAGES_LEFT;
// update Layout Design List
mitkWidget1->LayoutDesignListChanged(LAYOUT_2D_IMAGES_LEFT);
mitkWidget2->LayoutDesignListChanged(LAYOUT_2D_IMAGES_LEFT);
mitkWidget3->LayoutDesignListChanged(LAYOUT_2D_IMAGES_LEFT);
mitkWidget4->LayoutDesignListChanged(LAYOUT_2D_IMAGES_LEFT);
// update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::SetDecorationProperties(std::string text, mitk::Color color, int widgetNumber)
{
if (widgetNumber > 3)
{
MITK_ERROR << "Unknown render window for annotation.";
return;
}
vtkRenderer *renderer = this->GetRenderWindow(widgetNumber)->GetRenderer()->GetVtkRenderer();
if (!renderer)
return;
vtkSmartPointer<vtkCornerAnnotation> annotation = m_CornerAnnotations[widgetNumber];
annotation->SetText(0, text.c_str());
annotation->SetMaximumFontSize(12);
annotation->GetTextProperty()->SetColor(color[0], color[1], color[2]);
if (!renderer->HasViewProp(annotation))
{
renderer->AddViewProp(annotation);
}
vtkSmartPointer<vtkMitkRectangleProp> frame = m_RectangleProps[widgetNumber];
frame->SetColor(color[0], color[1], color[2]);
if (!renderer->HasViewProp(frame))
{
renderer->AddViewProp(frame);
}
}
void QmitkStdMultiWidget::SetCornerAnnotationVisibility(bool visibility)
{
for (int i = 0; i < 4; ++i)
{
m_CornerAnnotations[i]->SetVisibility(visibility);
}
}
bool QmitkStdMultiWidget::IsCornerAnnotationVisible(void) const
{
return m_CornerAnnotations[0]->GetVisibility() > 0;
}
QmitkRenderWindow *QmitkStdMultiWidget::GetRenderWindow(unsigned int number)
{
switch (number)
{
case 0:
return this->GetRenderWindow1();
case 1:
return this->GetRenderWindow2();
case 2:
return this->GetRenderWindow3();
case 3:
return this->GetRenderWindow4();
default:
MITK_ERROR << "Requested unknown render window";
break;
}
return NULL;
}
void QmitkStdMultiWidget::changeLayoutToDefault()
{
SMW_INFO << "changing layout to default... " << std::endl;
// Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout;
// create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit);
m_MainSplit->addWidget(m_LayoutSplit);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// create m_SubSplit1 and m_SubSplit2
m_SubSplit1 = new QSplitter(m_LayoutSplit);
m_SubSplit2 = new QSplitter(m_LayoutSplit);
// insert Widget container into the splitters
m_SubSplit1->addWidget(mitkWidget1Container);
m_SubSplit1->addWidget(mitkWidget2Container);
m_SubSplit2->addWidget(mitkWidget3Container);
m_SubSplit2->addWidget(mitkWidget4Container);
// set splitter Size
QList<int> splitterSize;
splitterSize.push_back(1000);
splitterSize.push_back(1000);
m_SubSplit1->setSizes(splitterSize);
m_SubSplit2->setSizes(splitterSize);
m_LayoutSplit->setSizes(splitterSize);
// show mainSplitt and add to Layout
m_MainSplit->show();
// show Widget if hidden
if (mitkWidget1->isHidden())
mitkWidget1->show();
if (mitkWidget2->isHidden())
mitkWidget2->show();
if (mitkWidget3->isHidden())
mitkWidget3->show();
if (mitkWidget4->isHidden())
mitkWidget4->show();
m_Layout = LAYOUT_DEFAULT;
// update Layout Design List
mitkWidget1->LayoutDesignListChanged(LAYOUT_DEFAULT);
mitkWidget2->LayoutDesignListChanged(LAYOUT_DEFAULT);
mitkWidget3->LayoutDesignListChanged(LAYOUT_DEFAULT);
mitkWidget4->LayoutDesignListChanged(LAYOUT_DEFAULT);
// update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutToBig3D()
{
SMW_INFO << "changing layout to big 3D ..." << std::endl;
// Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout;
// create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// add widget Splitter to main Splitter
m_MainSplit->addWidget(mitkWidget4Container);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// show mainSplitt and add to Layout
m_MainSplit->show();
// show/hide Widgets
mitkWidget1->hide();
mitkWidget2->hide();
mitkWidget3->hide();
if (mitkWidget4->isHidden())
mitkWidget4->show();
m_Layout = LAYOUT_BIG_3D;
// update Layout Design List
mitkWidget1->LayoutDesignListChanged(LAYOUT_BIG_3D);
mitkWidget2->LayoutDesignListChanged(LAYOUT_BIG_3D);
mitkWidget3->LayoutDesignListChanged(LAYOUT_BIG_3D);
mitkWidget4->LayoutDesignListChanged(LAYOUT_BIG_3D);
// update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutToWidget1()
{
SMW_INFO << "changing layout to big Widget1 ..." << std::endl;
// Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout;
// create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// add widget Splitter to main Splitter
m_MainSplit->addWidget(mitkWidget1Container);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// show mainSplitt and add to Layout
m_MainSplit->show();
// show/hide Widgets
if (mitkWidget1->isHidden())
mitkWidget1->show();
mitkWidget2->hide();
mitkWidget3->hide();
mitkWidget4->hide();
m_Layout = LAYOUT_WIDGET1;
// update Layout Design List
mitkWidget1->LayoutDesignListChanged(LAYOUT_WIDGET1);
mitkWidget2->LayoutDesignListChanged(LAYOUT_WIDGET1);
mitkWidget3->LayoutDesignListChanged(LAYOUT_WIDGET1);
mitkWidget4->LayoutDesignListChanged(LAYOUT_WIDGET1);
// update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutToWidget2()
{
SMW_INFO << "changing layout to big Widget2 ..." << std::endl;
// Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout;
// create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// add widget Splitter to main Splitter
m_MainSplit->addWidget(mitkWidget2Container);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// show mainSplitt and add to Layout
m_MainSplit->show();
// show/hide Widgets
mitkWidget1->hide();
if (mitkWidget2->isHidden())
mitkWidget2->show();
mitkWidget3->hide();
mitkWidget4->hide();
m_Layout = LAYOUT_WIDGET2;
// update Layout Design List
mitkWidget1->LayoutDesignListChanged(LAYOUT_WIDGET2);
mitkWidget2->LayoutDesignListChanged(LAYOUT_WIDGET2);
mitkWidget3->LayoutDesignListChanged(LAYOUT_WIDGET2);
mitkWidget4->LayoutDesignListChanged(LAYOUT_WIDGET2);
// update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutToWidget3()
{
SMW_INFO << "changing layout to big Widget3 ..." << std::endl;
// Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout;
// create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// add widget Splitter to main Splitter
m_MainSplit->addWidget(mitkWidget3Container);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// show mainSplitt and add to Layout
m_MainSplit->show();
// show/hide Widgets
mitkWidget1->hide();
mitkWidget2->hide();
if (mitkWidget3->isHidden())
mitkWidget3->show();
mitkWidget4->hide();
m_Layout = LAYOUT_WIDGET3;
// update Layout Design List
mitkWidget1->LayoutDesignListChanged(LAYOUT_WIDGET3);
mitkWidget2->LayoutDesignListChanged(LAYOUT_WIDGET3);
mitkWidget3->LayoutDesignListChanged(LAYOUT_WIDGET3);
mitkWidget4->LayoutDesignListChanged(LAYOUT_WIDGET3);
// update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutToRowWidget3And4()
{
SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
// Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout;
// create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit);
m_MainSplit->addWidget(m_LayoutSplit);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// add Widgets to splitter
m_LayoutSplit->addWidget(mitkWidget3Container);
m_LayoutSplit->addWidget(mitkWidget4Container);
// set Splitter Size
QList<int> splitterSize;
splitterSize.push_back(1000);
splitterSize.push_back(1000);
m_LayoutSplit->setSizes(splitterSize);
// show mainSplitt and add to Layout
m_MainSplit->show();
// show/hide Widgets
mitkWidget1->hide();
mitkWidget2->hide();
if (mitkWidget3->isHidden())
mitkWidget3->show();
if (mitkWidget4->isHidden())
mitkWidget4->show();
m_Layout = LAYOUT_ROW_WIDGET_3_AND_4;
// update Layout Design List
mitkWidget1->LayoutDesignListChanged(LAYOUT_ROW_WIDGET_3_AND_4);
mitkWidget2->LayoutDesignListChanged(LAYOUT_ROW_WIDGET_3_AND_4);
mitkWidget3->LayoutDesignListChanged(LAYOUT_ROW_WIDGET_3_AND_4);
mitkWidget4->LayoutDesignListChanged(LAYOUT_ROW_WIDGET_3_AND_4);
// update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutToColumnWidget3And4()
{
SMW_INFO << "changing layout to Widget3 and 4 in one Column..." << std::endl;
// Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout;
// create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter(m_MainSplit);
m_MainSplit->addWidget(m_LayoutSplit);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// add Widgets to splitter
m_LayoutSplit->addWidget(mitkWidget3Container);
m_LayoutSplit->addWidget(mitkWidget4Container);
// set SplitterSize
QList<int> splitterSize;
splitterSize.push_back(1000);
splitterSize.push_back(1000);
m_LayoutSplit->setSizes(splitterSize);
// show mainSplitt and add to Layout
m_MainSplit->show();
// show/hide Widgets
mitkWidget1->hide();
mitkWidget2->hide();
if (mitkWidget3->isHidden())
mitkWidget3->show();
if (mitkWidget4->isHidden())
mitkWidget4->show();
m_Layout = LAYOUT_COLUMN_WIDGET_3_AND_4;
// update Layout Design List
mitkWidget1->LayoutDesignListChanged(LAYOUT_COLUMN_WIDGET_3_AND_4);
mitkWidget2->LayoutDesignListChanged(LAYOUT_COLUMN_WIDGET_3_AND_4);
mitkWidget3->LayoutDesignListChanged(LAYOUT_COLUMN_WIDGET_3_AND_4);
mitkWidget4->LayoutDesignListChanged(LAYOUT_COLUMN_WIDGET_3_AND_4);
// update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutToRowWidgetSmall3andBig4()
{
SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
this->changeLayoutToRowWidget3And4();
m_Layout = LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4;
}
void QmitkStdMultiWidget::changeLayoutToSmallUpperWidget2Big3and4()
{
SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
// Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout;
// create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit);
m_MainSplit->addWidget(m_LayoutSplit);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// create m_SubSplit1 and m_SubSplit2
m_SubSplit1 = new QSplitter(Qt::Vertical, m_LayoutSplit);
m_SubSplit2 = new QSplitter(m_LayoutSplit);
// insert Widget into the splitters
m_SubSplit1->addWidget(mitkWidget2Container);
m_SubSplit2->addWidget(mitkWidget3Container);
m_SubSplit2->addWidget(mitkWidget4Container);
// set Splitter Size
QList<int> splitterSize;
splitterSize.push_back(1000);
splitterSize.push_back(1000);
m_SubSplit2->setSizes(splitterSize);
splitterSize.clear();
splitterSize.push_back(500);
splitterSize.push_back(1000);
m_LayoutSplit->setSizes(splitterSize);
// show mainSplitt
m_MainSplit->show();
// show Widget if hidden
mitkWidget1->hide();
if (mitkWidget2->isHidden())
mitkWidget2->show();
if (mitkWidget3->isHidden())
mitkWidget3->show();
if (mitkWidget4->isHidden())
mitkWidget4->show();
m_Layout = LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4;
// update Layout Design List
mitkWidget1->LayoutDesignListChanged(LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4);
mitkWidget2->LayoutDesignListChanged(LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4);
mitkWidget3->LayoutDesignListChanged(LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4);
mitkWidget4->LayoutDesignListChanged(LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4);
// update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutTo2x2Dand3DWidget()
{
SMW_INFO << "changing layout to 2 x 2D and 3D Widget" << std::endl;
// Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout;
// create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter(m_MainSplit);
m_MainSplit->addWidget(m_LayoutSplit);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// create m_SubSplit1 and m_SubSplit2
m_SubSplit1 = new QSplitter(Qt::Vertical, m_LayoutSplit);
m_SubSplit2 = new QSplitter(m_LayoutSplit);
// add Widgets to splitter
m_SubSplit1->addWidget(mitkWidget1Container);
m_SubSplit1->addWidget(mitkWidget2Container);
m_SubSplit2->addWidget(mitkWidget4Container);
// set Splitter Size
QList<int> splitterSize;
splitterSize.push_back(1000);
splitterSize.push_back(1000);
m_SubSplit1->setSizes(splitterSize);
m_LayoutSplit->setSizes(splitterSize);
// show mainSplitt and add to Layout
m_MainSplit->show();
// show/hide Widgets
if (mitkWidget1->isHidden())
mitkWidget1->show();
if (mitkWidget2->isHidden())
mitkWidget2->show();
mitkWidget3->hide();
if (mitkWidget4->isHidden())
mitkWidget4->show();
m_Layout = LAYOUT_2X_2D_AND_3D_WIDGET;
// update Layout Design List
mitkWidget1->LayoutDesignListChanged(LAYOUT_2X_2D_AND_3D_WIDGET);
mitkWidget2->LayoutDesignListChanged(LAYOUT_2X_2D_AND_3D_WIDGET);
mitkWidget3->LayoutDesignListChanged(LAYOUT_2X_2D_AND_3D_WIDGET);
mitkWidget4->LayoutDesignListChanged(LAYOUT_2X_2D_AND_3D_WIDGET);
// update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutToLeft2Dand3DRight2D()
{
SMW_INFO << "changing layout to 2D and 3D left, 2D right Widget" << std::endl;
// Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout;
// create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter(m_MainSplit);
m_MainSplit->addWidget(m_LayoutSplit);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// create m_SubSplit1 and m_SubSplit2
m_SubSplit1 = new QSplitter(Qt::Vertical, m_LayoutSplit);
m_SubSplit2 = new QSplitter(m_LayoutSplit);
// add Widgets to splitter
m_SubSplit1->addWidget(mitkWidget1Container);
m_SubSplit1->addWidget(mitkWidget4Container);
m_SubSplit2->addWidget(mitkWidget2Container);
// set Splitter Size
QList<int> splitterSize;
splitterSize.push_back(1000);
splitterSize.push_back(1000);
m_SubSplit1->setSizes(splitterSize);
m_LayoutSplit->setSizes(splitterSize);
// show mainSplitt and add to Layout
m_MainSplit->show();
// show/hide Widgets
if (mitkWidget1->isHidden())
mitkWidget1->show();
if (mitkWidget2->isHidden())
mitkWidget2->show();
mitkWidget3->hide();
if (mitkWidget4->isHidden())
mitkWidget4->show();
m_Layout = LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET;
// update Layout Design List
mitkWidget1->LayoutDesignListChanged(LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET);
mitkWidget2->LayoutDesignListChanged(LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET);
mitkWidget3->LayoutDesignListChanged(LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET);
mitkWidget4->LayoutDesignListChanged(LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET);
// update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutTo2DUpAnd3DDown()
{
SMW_INFO << "changing layout to 2D up and 3D down" << std::endl;
// Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout;
// create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
// Set Layout to widget
this->setLayout(QmitkStdMultiWidgetLayout);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit);
m_MainSplit->addWidget(m_LayoutSplit);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// create m_SubSplit1 and m_SubSplit2
m_SubSplit1 = new QSplitter(m_LayoutSplit);
m_SubSplit2 = new QSplitter(m_LayoutSplit);
// insert Widget Container into splitter top
m_SubSplit1->addWidget(mitkWidget1Container);
// set SplitterSize for splitter top
QList<int> splitterSize;
// insert Widget Container into splitter bottom
m_SubSplit2->addWidget(mitkWidget4Container);
// set SplitterSize for splitter m_LayoutSplit
splitterSize.clear();
splitterSize.push_back(700);
splitterSize.push_back(700);
m_LayoutSplit->setSizes(splitterSize);
// show mainSplitt
m_MainSplit->show();
// show/hide Widgets
if (mitkWidget1->isHidden())
mitkWidget1->show();
mitkWidget2->hide();
mitkWidget3->hide();
if (mitkWidget4->isHidden())
mitkWidget4->show();
m_Layout = LAYOUT_2D_UP_AND_3D_DOWN;
// update Layout Design List
mitkWidget1->LayoutDesignListChanged(LAYOUT_2D_UP_AND_3D_DOWN);
mitkWidget2->LayoutDesignListChanged(LAYOUT_2D_UP_AND_3D_DOWN);
mitkWidget3->LayoutDesignListChanged(LAYOUT_2D_UP_AND_3D_DOWN);
mitkWidget4->LayoutDesignListChanged(LAYOUT_2D_UP_AND_3D_DOWN);
// update all Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::SetDataStorage(mitk::DataStorage *ds)
{
+ if (ds == m_DataStorage)
+ {
+ return;
+ }
+
mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->SetDataStorage(ds);
mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->SetDataStorage(ds);
mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->SetDataStorage(ds);
mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->SetDataStorage(ds);
m_DataStorage = ds;
}
void QmitkStdMultiWidget::Fit()
{
vtkSmartPointer<vtkRenderer> vtkrenderer;
vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetVtkRenderer();
if (vtkrenderer != NULL)
vtkrenderer->ResetCamera();
vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetVtkRenderer();
if (vtkrenderer != NULL)
vtkrenderer->ResetCamera();
vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetVtkRenderer();
if (vtkrenderer != NULL)
vtkrenderer->ResetCamera();
vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetVtkRenderer();
if (vtkrenderer != NULL)
vtkrenderer->ResetCamera();
mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetCameraController()->Fit();
mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetCameraController()->Fit();
mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetCameraController()->Fit();
mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetCameraController()->Fit();
int w = vtkObject::GetGlobalWarningDisplay();
vtkObject::GlobalWarningDisplayOff();
vtkObject::SetGlobalWarningDisplay(w);
}
void QmitkStdMultiWidget::InitPositionTracking()
{
// TODO POSITIONTRACKER
}
void QmitkStdMultiWidget::AddDisplayPlaneSubTree()
{
// add the displayed planes of the multiwidget to a node to which the subtree
// @a planesSubTree points ...
mitk::PlaneGeometryDataMapper2D::Pointer mapper;
// ... of widget 1
mitk::BaseRenderer *renderer1 = mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow());
m_PlaneNode1 = renderer1->GetCurrentWorldPlaneGeometryNode();
m_PlaneNode1->SetProperty("visible", mitk::BoolProperty::New(true));
m_PlaneNode1->SetProperty("name", mitk::StringProperty::New(std::string(renderer1->GetName()) + ".plane"));
m_PlaneNode1->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
m_PlaneNode1->SetProperty("helper object", mitk::BoolProperty::New(true));
mapper = mitk::PlaneGeometryDataMapper2D::New();
m_PlaneNode1->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
// ... of widget 2
mitk::BaseRenderer *renderer2 = mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow());
m_PlaneNode2 = renderer2->GetCurrentWorldPlaneGeometryNode();
m_PlaneNode2->SetProperty("visible", mitk::BoolProperty::New(true));
m_PlaneNode2->SetProperty("name", mitk::StringProperty::New(std::string(renderer2->GetName()) + ".plane"));
m_PlaneNode2->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
m_PlaneNode2->SetProperty("helper object", mitk::BoolProperty::New(true));
mapper = mitk::PlaneGeometryDataMapper2D::New();
m_PlaneNode2->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
// ... of widget 3
mitk::BaseRenderer *renderer3 = mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow());
m_PlaneNode3 = renderer3->GetCurrentWorldPlaneGeometryNode();
m_PlaneNode3->SetProperty("visible", mitk::BoolProperty::New(true));
m_PlaneNode3->SetProperty("name", mitk::StringProperty::New(std::string(renderer3->GetName()) + ".plane"));
m_PlaneNode3->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
m_PlaneNode3->SetProperty("helper object", mitk::BoolProperty::New(true));
mapper = mitk::PlaneGeometryDataMapper2D::New();
m_PlaneNode3->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
m_ParentNodeForGeometryPlanes = mitk::DataNode::New();
m_ParentNodeForGeometryPlanes->SetProperty("name", mitk::StringProperty::New("Widgets"));
m_ParentNodeForGeometryPlanes->SetProperty("helper object", mitk::BoolProperty::New(true));
}
mitk::SliceNavigationController *QmitkStdMultiWidget::GetTimeNavigationController()
{
return m_TimeNavigationController;
}
void QmitkStdMultiWidget::EnableStandardLevelWindow()
{
levelWindowWidget->disconnect(this);
levelWindowWidget->SetDataStorage(mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetDataStorage());
levelWindowWidget->show();
}
void QmitkStdMultiWidget::DisableStandardLevelWindow()
{
levelWindowWidget->disconnect(this);
levelWindowWidget->hide();
}
// CAUTION: Legacy code for enabling Qt-signal-controlled view initialization.
// Use RenderingManager::InitializeViews() instead.
bool QmitkStdMultiWidget::InitializeStandardViews(const mitk::Geometry3D *geometry)
{
return m_RenderingManager->InitializeViews(geometry);
}
void QmitkStdMultiWidget::RequestUpdate()
{
m_RenderingManager->RequestUpdate(mitkWidget1->GetRenderWindow());
m_RenderingManager->RequestUpdate(mitkWidget2->GetRenderWindow());
m_RenderingManager->RequestUpdate(mitkWidget3->GetRenderWindow());
m_RenderingManager->RequestUpdate(mitkWidget4->GetRenderWindow());
}
void QmitkStdMultiWidget::ForceImmediateUpdate()
{
m_RenderingManager->ForceImmediateUpdate(mitkWidget1->GetRenderWindow());
m_RenderingManager->ForceImmediateUpdate(mitkWidget2->GetRenderWindow());
m_RenderingManager->ForceImmediateUpdate(mitkWidget3->GetRenderWindow());
m_RenderingManager->ForceImmediateUpdate(mitkWidget4->GetRenderWindow());
}
void QmitkStdMultiWidget::wheelEvent(QWheelEvent *e)
{
emit WheelMoved(e);
}
void QmitkStdMultiWidget::mousePressEvent(QMouseEvent *e)
{
}
void QmitkStdMultiWidget::moveEvent(QMoveEvent *e)
{
QWidget::moveEvent(e);
// it is necessary to readjust the position of the overlays as the StdMultiWidget has moved
// unfortunately it's not done by QmitkRenderWindow::moveEvent -> must be done here
emit Moved();
}
QmitkRenderWindow *QmitkStdMultiWidget::GetRenderWindow1() const
{
return mitkWidget1;
}
QmitkRenderWindow *QmitkStdMultiWidget::GetRenderWindow2() const
{
return mitkWidget2;
}
QmitkRenderWindow *QmitkStdMultiWidget::GetRenderWindow3() const
{
return mitkWidget3;
}
QmitkRenderWindow *QmitkStdMultiWidget::GetRenderWindow4() const
{
return mitkWidget4;
}
const mitk::Point3D QmitkStdMultiWidget::GetCrossPosition() const
{
const mitk::PlaneGeometry *plane1 = mitkWidget1->GetSliceNavigationController()->GetCurrentPlaneGeometry();
const mitk::PlaneGeometry *plane2 = mitkWidget2->GetSliceNavigationController()->GetCurrentPlaneGeometry();
const mitk::PlaneGeometry *plane3 = mitkWidget3->GetSliceNavigationController()->GetCurrentPlaneGeometry();
mitk::Line3D line;
if ((plane1 != NULL) && (plane2 != NULL) && (plane1->IntersectionLine(plane2, line)))
{
mitk::Point3D point;
if ((plane3 != NULL) && (plane3->IntersectionPoint(line, point)))
{
return point;
}
}
// TODO BUG POSITIONTRACKER;
mitk::Point3D p;
return p;
// return m_LastLeftClickPositionSupplier->GetCurrentPoint();
}
void QmitkStdMultiWidget::EnablePositionTracking()
{
}
void QmitkStdMultiWidget::DisablePositionTracking()
{
}
void QmitkStdMultiWidget::EnsureDisplayContainsPoint(mitk::BaseRenderer *renderer, const mitk::Point3D &p)
{
mitk::Point2D pointOnDisplay;
renderer->WorldToDisplay(p, pointOnDisplay);
if (pointOnDisplay[0] < renderer->GetVtkRenderer()->GetOrigin()[0] ||
pointOnDisplay[1] < renderer->GetVtkRenderer()->GetOrigin()[1] ||
pointOnDisplay[0] > renderer->GetVtkRenderer()->GetOrigin()[0] + renderer->GetViewportSize()[0] ||
pointOnDisplay[1] > renderer->GetVtkRenderer()->GetOrigin()[1] + renderer->GetViewportSize()[1])
{
mitk::Point2D pointOnPlane;
renderer->GetCurrentWorldPlaneGeometry()->Map(p, pointOnPlane);
renderer->GetCameraController()->MoveCameraToPoint(pointOnPlane);
}
}
void QmitkStdMultiWidget::MoveCrossToPosition(const mitk::Point3D &newPosition)
{
mitkWidget1->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
mitkWidget2->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
mitkWidget3->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
m_RenderingManager->RequestUpdateAll();
}
void QmitkStdMultiWidget::HandleCrosshairPositionEvent()
{
if (!m_PendingCrosshairPositionEvent)
{
m_PendingCrosshairPositionEvent = true;
QTimer::singleShot(0, this, SLOT(HandleCrosshairPositionEventDelayed()));
}
}
mitk::DataNode::Pointer QmitkStdMultiWidget::GetTopLayerNode(mitk::DataStorage::SetOfObjects::ConstPointer nodes)
{
mitk::Point3D crosshairPos = this->GetCrossPosition();
mitk::DataNode::Pointer node;
int maxlayer = -32768;
if (nodes.IsNotNull())
{
mitk::BaseRenderer *baseRenderer = this->mitkWidget1->GetSliceNavigationController()->GetRenderer();
// find node with largest layer, that is the node shown on top in the render window
for (unsigned int x = 0; x < nodes->size(); x++)
{
if ((nodes->at(x)->GetData()->GetGeometry() != NULL) &&
nodes->at(x)->GetData()->GetGeometry()->IsInside(crosshairPos))
{
int layer = 0;
if (!(nodes->at(x)->GetIntProperty("layer", layer)))
continue;
if (layer > maxlayer)
{
if (static_cast<mitk::DataNode::Pointer>(nodes->at(x))->IsVisible(baseRenderer))
{
node = nodes->at(x);
maxlayer = layer;
}
}
}
}
}
return node;
}
void QmitkStdMultiWidget::HandleCrosshairPositionEventDelayed()
{
m_PendingCrosshairPositionEvent = false;
// find image with highest layer
mitk::TNodePredicateDataType<mitk::Image>::Pointer isImageData = mitk::TNodePredicateDataType<mitk::Image>::New();
mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->m_DataStorage->GetSubset(isImageData).GetPointer();
mitk::DataNode::Pointer node;
mitk::DataNode::Pointer topSourceNode;
mitk::Image::Pointer image;
bool isBinary = false;
node = this->GetTopLayerNode(nodes);
int component = 0;
if (node.IsNotNull())
{
node->GetBoolProperty("binary", isBinary);
if (isBinary)
{
mitk::DataStorage::SetOfObjects::ConstPointer sourcenodes = m_DataStorage->GetSources(node, NULL, true);
if (!sourcenodes->empty())
{
topSourceNode = this->GetTopLayerNode(sourcenodes);
}
if (topSourceNode.IsNotNull())
{
image = dynamic_cast<mitk::Image *>(topSourceNode->GetData());
topSourceNode->GetIntProperty("Image.Displayed Component", component);
}
else
{
image = dynamic_cast<mitk::Image *>(node->GetData());
node->GetIntProperty("Image.Displayed Component", component);
}
}
else
{
image = dynamic_cast<mitk::Image *>(node->GetData());
node->GetIntProperty("Image.Displayed Component", component);
}
}
mitk::Point3D crosshairPos = this->GetCrossPosition();
std::string statusText;
std::stringstream stream;
itk::Index<3> p;
mitk::BaseRenderer *baseRenderer = this->mitkWidget1->GetSliceNavigationController()->GetRenderer();
unsigned int timestep = baseRenderer->GetTimeStep();
if (image.IsNotNull() && (image->GetTimeSteps() > timestep))
{
image->GetGeometry()->WorldToIndex(crosshairPos, p);
stream.precision(2);
stream << "Position: <" << std::fixed << crosshairPos[0] << ", " << std::fixed << crosshairPos[1] << ", "
<< std::fixed << crosshairPos[2] << "> mm";
stream << "; Index: <" << p[0] << ", " << p[1] << ", " << p[2] << "> ";
mitk::ScalarType pixelValue;
mitkPixelTypeMultiplex5(mitk::FastSinglePixelAccess,
image->GetChannelDescriptor().GetPixelType(),
image,
image->GetVolumeData(baseRenderer->GetTimeStep()),
p,
pixelValue,
component);
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());
}
int QmitkStdMultiWidget::GetLayout() const
{
return m_Layout;
}
bool QmitkStdMultiWidget::GetGradientBackgroundFlag() const
{
return m_GradientBackgroundFlag;
}
void QmitkStdMultiWidget::EnableGradientBackground()
{
// gradient background is by default only in widget 4, otherwise
// interferences between 2D rendering and VTK rendering may occur.
for (unsigned int i = 0; i < 4; ++i)
{
GetRenderWindow(i)->GetRenderer()->GetVtkRenderer()->GradientBackgroundOn();
}
m_GradientBackgroundFlag = true;
}
void QmitkStdMultiWidget::DisableGradientBackground()
{
for (unsigned int i = 0; i < 4; ++i)
{
GetRenderWindow(i)->GetRenderer()->GetVtkRenderer()->GradientBackgroundOff();
}
m_GradientBackgroundFlag = false;
}
void QmitkStdMultiWidget::EnableDepartmentLogo()
{
m_LogoRendering->SetVisibility(true);
RequestUpdate();
}
void QmitkStdMultiWidget::DisableDepartmentLogo()
{
m_LogoRendering->SetVisibility(false);
RequestUpdate();
}
bool QmitkStdMultiWidget::IsDepartmentLogoEnabled() const
{
return m_LogoRendering->IsVisible(mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()));
}
void QmitkStdMultiWidget::SetWidgetPlaneVisibility(const char *widgetName, bool visible, mitk::BaseRenderer *renderer)
{
if (m_DataStorage.IsNotNull())
{
mitk::DataNode *n = m_DataStorage->GetNamedNode(widgetName);
if (n != NULL)
n->SetVisibility(visible, renderer);
}
}
void QmitkStdMultiWidget::SetWidgetPlanesVisibility(bool visible, mitk::BaseRenderer *renderer)
{
if (m_PlaneNode1.IsNotNull())
{
m_PlaneNode1->SetVisibility(visible, renderer);
}
if (m_PlaneNode2.IsNotNull())
{
m_PlaneNode2->SetVisibility(visible, renderer);
}
if (m_PlaneNode3.IsNotNull())
{
m_PlaneNode3->SetVisibility(visible, renderer);
}
m_RenderingManager->RequestUpdateAll();
}
void QmitkStdMultiWidget::SetWidgetPlanesLocked(bool locked)
{
// do your job and lock or unlock slices.
GetRenderWindow1()->GetSliceNavigationController()->SetSliceLocked(locked);
GetRenderWindow2()->GetSliceNavigationController()->SetSliceLocked(locked);
GetRenderWindow3()->GetSliceNavigationController()->SetSliceLocked(locked);
}
void QmitkStdMultiWidget::SetWidgetPlanesRotationLocked(bool locked)
{
// do your job and lock or unlock slices.
GetRenderWindow1()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
GetRenderWindow2()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
GetRenderWindow3()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
}
void QmitkStdMultiWidget::SetWidgetPlanesRotationLinked(bool link)
{
emit WidgetPlanesRotationLinked(link);
}
void QmitkStdMultiWidget::SetWidgetPlaneMode(int userMode)
{
MITK_DEBUG << "Changing crosshair mode to " << userMode;
emit WidgetNotifyNewCrossHairMode(userMode);
// Convert user interface mode to actual mode
{
switch (userMode)
{
case 0:
m_MouseModeSwitcher->SetInteractionScheme(mitk::MouseModeSwitcher::InteractionScheme::MITK);
break;
case 1:
m_MouseModeSwitcher->SetInteractionScheme(mitk::MouseModeSwitcher::InteractionScheme::ROTATION);
break;
case 2:
m_MouseModeSwitcher->SetInteractionScheme(mitk::MouseModeSwitcher::InteractionScheme::ROTATIONLINKED);
break;
case 3:
m_MouseModeSwitcher->SetInteractionScheme(mitk::MouseModeSwitcher::InteractionScheme::SWIVEL);
break;
}
}
}
void QmitkStdMultiWidget::SetGradientBackgroundColorForRenderWindow(const mitk::Color &upper,
const mitk::Color &lower,
unsigned int widgetNumber)
{
if (widgetNumber > 3)
{
MITK_ERROR << "Gradientbackground for unknown widget!";
return;
}
m_GradientBackgroundColors[widgetNumber].first = upper;
m_GradientBackgroundColors[widgetNumber].second = lower;
vtkRenderer *renderer = GetRenderWindow(widgetNumber)->GetRenderer()->GetVtkRenderer();
renderer->SetBackground2(upper[0], upper[1], upper[2]);
renderer->SetBackground(lower[0], lower[1], lower[2]);
m_GradientBackgroundFlag = true;
}
void QmitkStdMultiWidget::SetGradientBackgroundColors(const mitk::Color &upper, const mitk::Color &lower)
{
for (unsigned int i = 0; i < 4; ++i)
{
vtkRenderer *renderer = GetRenderWindow(i)->GetRenderer()->GetVtkRenderer();
renderer->SetBackground2(upper[0], upper[1], upper[2]);
renderer->SetBackground(lower[0], lower[1], lower[2]);
}
m_GradientBackgroundFlag = true;
}
void QmitkStdMultiWidget::SetDepartmentLogoPath(const char *path)
{
m_LogoRendering->SetLogoImagePath(path);
mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow());
m_LogoRendering->Update(renderer);
RequestUpdate();
}
void QmitkStdMultiWidget::SetWidgetPlaneModeToSlicing(bool activate)
{
if (activate)
{
this->SetWidgetPlaneMode(PLANE_MODE_SLICING);
}
}
void QmitkStdMultiWidget::SetWidgetPlaneModeToRotation(bool activate)
{
if (activate)
{
this->SetWidgetPlaneMode(PLANE_MODE_ROTATION);
}
}
void QmitkStdMultiWidget::SetWidgetPlaneModeToSwivel(bool activate)
{
if (activate)
{
this->SetWidgetPlaneMode(PLANE_MODE_SWIVEL);
}
}
void QmitkStdMultiWidget::OnLayoutDesignChanged(int layoutDesignIndex)
{
switch (layoutDesignIndex)
{
case LAYOUT_DEFAULT:
{
this->changeLayoutToDefault();
break;
}
case LAYOUT_2D_IMAGES_UP:
{
this->changeLayoutTo2DImagesUp();
break;
}
case LAYOUT_2D_IMAGES_LEFT:
{
this->changeLayoutTo2DImagesLeft();
break;
}
case LAYOUT_BIG_3D:
{
this->changeLayoutToBig3D();
break;
}
case LAYOUT_WIDGET1:
{
this->changeLayoutToWidget1();
break;
}
case LAYOUT_WIDGET2:
{
this->changeLayoutToWidget2();
break;
}
case LAYOUT_WIDGET3:
{
this->changeLayoutToWidget3();
break;
}
case LAYOUT_2X_2D_AND_3D_WIDGET:
{
this->changeLayoutTo2x2Dand3DWidget();
break;
}
case LAYOUT_ROW_WIDGET_3_AND_4:
{
this->changeLayoutToRowWidget3And4();
break;
}
case LAYOUT_COLUMN_WIDGET_3_AND_4:
{
this->changeLayoutToColumnWidget3And4();
break;
}
case LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4:
{
this->changeLayoutToRowWidgetSmall3andBig4();
break;
}
case LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4:
{
this->changeLayoutToSmallUpperWidget2Big3and4();
break;
}
case LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET:
{
this->changeLayoutToLeft2Dand3DRight2D();
break;
}
};
}
void QmitkStdMultiWidget::UpdateAllWidgets()
{
mitkWidget1->resize(mitkWidget1Container->frameSize().width() - 1, mitkWidget1Container->frameSize().height());
mitkWidget1->resize(mitkWidget1Container->frameSize().width(), mitkWidget1Container->frameSize().height());
mitkWidget2->resize(mitkWidget2Container->frameSize().width() - 1, mitkWidget2Container->frameSize().height());
mitkWidget2->resize(mitkWidget2Container->frameSize().width(), mitkWidget2Container->frameSize().height());
mitkWidget3->resize(mitkWidget3Container->frameSize().width() - 1, mitkWidget3Container->frameSize().height());
mitkWidget3->resize(mitkWidget3Container->frameSize().width(), mitkWidget3Container->frameSize().height());
mitkWidget4->resize(mitkWidget4Container->frameSize().width() - 1, mitkWidget4Container->frameSize().height());
mitkWidget4->resize(mitkWidget4Container->frameSize().width(), mitkWidget4Container->frameSize().height());
}
void QmitkStdMultiWidget::HideAllWidgetToolbars()
{
mitkWidget1->HideRenderWindowMenu();
mitkWidget2->HideRenderWindowMenu();
mitkWidget3->HideRenderWindowMenu();
mitkWidget4->HideRenderWindowMenu();
}
void QmitkStdMultiWidget::ActivateMenuWidget(bool state)
{
mitkWidget1->ActivateMenuWidget(state, this);
mitkWidget2->ActivateMenuWidget(state, this);
mitkWidget3->ActivateMenuWidget(state, this);
mitkWidget4->ActivateMenuWidget(state, this);
}
bool QmitkStdMultiWidget::IsMenuWidgetEnabled() const
{
return mitkWidget1->GetActivateMenuWidgetFlag();
}
void QmitkStdMultiWidget::SetDecorationColor(unsigned int widgetNumber, mitk::Color color)
{
switch (widgetNumber)
{
case 0:
if (m_PlaneNode1.IsNotNull())
{
m_PlaneNode1->SetColor(color);
}
break;
case 1:
if (m_PlaneNode2.IsNotNull())
{
m_PlaneNode2->SetColor(color);
}
break;
case 2:
if (m_PlaneNode3.IsNotNull())
{
m_PlaneNode3->SetColor(color);
}
break;
case 3:
m_DecorationColorWidget4 = color;
break;
default:
MITK_ERROR << "Decoration color for unknown widget!";
break;
}
}
void QmitkStdMultiWidget::ResetCrosshair()
{
if (m_DataStorage.IsNotNull())
{
m_RenderingManager->InitializeViewsByBoundingObjects(m_DataStorage);
// m_RenderingManager->InitializeViews( m_DataStorage->ComputeVisibleBoundingGeometry3D() );
// reset interactor to normal slicing
this->SetWidgetPlaneMode(PLANE_MODE_SLICING);
}
}
void QmitkStdMultiWidget::EnableColoredRectangles()
{
m_RectangleProps[0]->SetVisibility(1);
m_RectangleProps[1]->SetVisibility(1);
m_RectangleProps[2]->SetVisibility(1);
m_RectangleProps[3]->SetVisibility(1);
}
void QmitkStdMultiWidget::DisableColoredRectangles()
{
m_RectangleProps[0]->SetVisibility(0);
m_RectangleProps[1]->SetVisibility(0);
m_RectangleProps[2]->SetVisibility(0);
m_RectangleProps[3]->SetVisibility(0);
}
bool QmitkStdMultiWidget::IsColoredRectanglesEnabled() const
{
return m_RectangleProps[0]->GetVisibility() > 0;
}
mitk::MouseModeSwitcher *QmitkStdMultiWidget::GetMouseModeSwitcher()
{
return m_MouseModeSwitcher;
}
mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane1()
{
return this->m_PlaneNode1;
}
mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane2()
{
return this->m_PlaneNode2;
}
mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane3()
{
return this->m_PlaneNode3;
}
mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane(int id)
{
switch (id)
{
case 1:
return this->m_PlaneNode1;
break;
case 2:
return this->m_PlaneNode2;
break;
case 3:
return this->m_PlaneNode3;
break;
default:
return NULL;
}
}