diff --git a/CMake/PackageDepends/MITK_VTK_Config.cmake b/CMake/PackageDepends/MITK_VTK_Config.cmake
index 9ba1798589..f13834dd55 100644
--- a/CMake/PackageDepends/MITK_VTK_Config.cmake
+++ b/CMake/PackageDepends/MITK_VTK_Config.cmake
@@ -1,9 +1,8 @@
find_package(VTK COMPONENTS ${VTK_REQUIRED_COMPONENTS_BY_MODULE} REQUIRED)
if(MITK_USE_Qt5)
find_package(Qt5Widgets REQUIRED QUIET)
endif()
list(APPEND ALL_INCLUDE_DIRECTORIES ${VTK_INCLUDE_DIRS})
list(APPEND ALL_LIBRARIES ${VTK_LIBRARIES})
-list(APPEND ALL_COMPILE_DEFINITIONS ${VTK_DEFINITIONS})
diff --git a/CMake/mitkFunctionUseModules.cmake b/CMake/mitkFunctionUseModules.cmake
index 173e0a5a95..0654f319be 100644
--- a/CMake/mitkFunctionUseModules.cmake
+++ b/CMake/mitkFunctionUseModules.cmake
@@ -1,163 +1,173 @@
function(_mitk_parse_package_args)
set(package_list ${ARGN})
set(PUBLIC_PACKAGE_NAMES )
set(PRIVATE_PACKAGE_NAMES )
set(INTERFACE_PACKAGE_NAMES )
set(_package_visibility PRIVATE)
foreach(_package ${package_list})
if(_package STREQUAL "PUBLIC" OR _package STREQUAL "PRIVATE" OR _package STREQUAL "INTERFACE")
set(_package_visibility ${_package})
else()
list(APPEND packages ${_package})
set(_package_name )
set(_package_components_list )
string(REPLACE "|" ";" _package_list ${_package})
if("${_package_list}" STREQUAL "${_package}")
set(_package_name ${_package})
else()
list(GET _package_list 0 _package_name)
list(GET _package_list 1 _package_components)
string(REPLACE "+" ";" _package_components_list "${_package_components}")
if(NOT _package_name OR NOT _package_components)
message(SEND_ERROR "PACKAGE argument syntax wrong. ${_package} is not of the form PACKAGE[|COMPONENT1[+COMPONENT2]...]")
endif()
endif()
list(APPEND ${_package_visibility}_PACKAGE_NAMES ${_package_name})
list(APPEND ${_package_visibility}_${_package_name}_REQUIRED_COMPONENTS ${_package_components_list})
endif()
endforeach()
# remove duplicates and set package components in parent scope
foreach(_package_visibility PUBLIC PRIVATE INTERFACE)
foreach(_package_name ${${_package_visibility}_PACKAGE_NAMES})
if(${_package_visibility}_${_package_name}_REQUIRED_COMPONENTS)
list(REMOVE_DUPLICATES ${_package_visibility}_${_package_name}_REQUIRED_COMPONENTS)
endif()
set(${_package_visibility}_${_package_name}_REQUIRED_COMPONENTS ${${_package_visibility}_${_package_name}_REQUIRED_COMPONENTS} PARENT_SCOPE)
endforeach()
endforeach()
set(PUBLIC_PACKAGE_NAMES ${PUBLIC_PACKAGE_NAMES} PARENT_SCOPE)
set(PRIVATE_PACKAGE_NAMES ${PRIVATE_PACKAGE_NAMES} PARENT_SCOPE)
set(INTERFACE_PACKAGE_NAMES ${INTERFACE_PACKAGE_NAMES} PARENT_SCOPE)
set(PACKAGE_NAMES ${PUBLIC_PACKAGE_NAMES} ${PRIVATE_PACKAGE_NAMES} ${INTERFACE_PACKAGE_NAMES} PARENT_SCOPE)
endfunction()
function(_include_package_config pkg_config_file)
# wrap the inclusion of the MITK_<pkg>_Config.cmake file in a
# function to create a scope for its variables; this allows
# multiple inclusions of the file in the parent scope
include(${pkg_config_file})
set(ALL_INCLUDE_DIRECTORIES ${ALL_INCLUDE_DIRECTORIES} PARENT_SCOPE)
set(ALL_LIBRARIES ${ALL_LIBRARIES} PARENT_SCOPE)
set(ALL_COMPILE_DEFINITIONS ${ALL_COMPILE_DEFINITIONS} PARENT_SCOPE)
set(ALL_COMPILE_OPTIONS ${ALL_COMPILE_OPTIONS} PARENT_SCOPE)
endfunction()
#! This CMake function sets up the necessary include directories,
#! linker dependencies, and compile flags for a given target which
#! depends on a set of MITK modules or packages.
#!
#! A package argument is of the form
#!
#! [PUBLIC|PRIVATE|INTERFACE] PACKAGE[|COMPONENT1[+COMPONENT2]...]
#!
#! where PACKAGE is the package name (e.g. VTK) and components are
#! the names of required package components or libraries.
#!
#! If a dependency is not available, an error is thrown.
function(mitk_use_modules)
set(_macro_params
TARGET # The target name (required)
)
set(_macro_multiparams
MODULES # MITK modules which the given TARGET uses
PACKAGES # MITK packages which the given TARGET uses
)
set(_macro_options )
cmake_parse_arguments(USE "${_macro_options}" "${_macro_params}" "${_macro_multiparams}" ${ARGN})
# Sanity checks
if(NOT USE_TARGET)
message(SEND_ERROR "Required TARGET argument missing.")
elseif(NOT TARGET ${USE_TARGET})
message(SEND_ERROR "The given TARGET argument ${USE_TARGET} is not a valid target")
endif()
set(depends ${USE_MODULES})
set(package_depends ${USE_PACKAGES})
if(depends)
# Iterate over all module dependencies
foreach(dependency ${depends})
if(TARGET ${dependency} AND NOT MODULE_IS_DEPRECATED)
get_target_property(_is_interface_lib ${dependency} TYPE)
if(NOT _is_interface_lib)
get_target_property(_dependency_deprecated_since ${dependency} MITK_MODULE_DEPRECATED_SINCE)
if(_dependency_deprecated_since)
message(WARNING "Module ${dependency} is deprecated since ${_dependency_deprecated_since}")
endif()
endif()
endif()
endforeach()
target_link_libraries(${USE_TARGET} PUBLIC ${depends})
endif()
# Parse package dependencies
if(package_depends)
_mitk_parse_package_args(${package_depends})
# Some package config files like MITK_Qt5_Config.cmake rely on a
# properly set "MODULE_NAME" variable for the current target.
set(MODULE_NAME ${USE_TARGET})
# Read all package information
foreach(_package_visibility INTERFACE PUBLIC PRIVATE)
foreach(_package ${${_package_visibility}_PACKAGE_NAMES})
set(ALL_INCLUDE_DIRECTORIES)
set(ALL_LIBRARIES)
set(ALL_COMPILE_DEFINITIONS)
set(ALL_COMPILE_OPTIONS)
set(${_package}_REQUIRED_COMPONENTS_BY_MODULE ${${_package_visibility}_${_package}_REQUIRED_COMPONENTS})
set(_package_found 0)
foreach(dir ${MODULES_PACKAGE_DEPENDS_DIRS})
if((NOT DEFINED MITK_USE_${_package} OR MITK_USE_${_package}) AND EXISTS "${dir}/MITK_${_package}_Config.cmake")
_include_package_config("${dir}/MITK_${_package}_Config.cmake")
set(_package_found 1)
break()
endif()
endforeach()
if(_package_found)
if(ALL_INCLUDE_DIRECTORIES)
list(REMOVE_DUPLICATES ALL_INCLUDE_DIRECTORIES)
target_include_directories(${USE_TARGET} SYSTEM ${_package_visibility} ${ALL_INCLUDE_DIRECTORIES})
endif()
if(ALL_LIBRARIES)
# Don't remove "duplicats" because ALL_LIBRARIES may be of the form:
# "general;bla;debug;blad;general;foo;debug;food"
target_link_libraries(${USE_TARGET} ${_package_visibility} ${ALL_LIBRARIES})
endif()
if(ALL_COMPILE_DEFINITIONS)
list(REMOVE_DUPLICATES ALL_COMPILE_DEFINITIONS)
# Compile definitions are always added "PRIVATE" to avoid multiple definitions
# on the command line due to transitive and direct dependencies adding the
# same definitions.
target_compile_definitions(${USE_TARGET} PRIVATE ${ALL_COMPILE_DEFINITIONS})
endif()
if(ALL_COMPILE_OPTIONS)
list(REMOVE_DUPLICATES ALL_COMPILE_OPTIONS)
target_compile_options(${USE_TARGET} ${_package_visibility} ${ALL_COMPILE_OPTIONS})
endif()
+ if("VTK" STREQUAL _package)
+ # VTK module autoinit
+ unset(_vtk_modules)
+ foreach(_vtk_module ${VTK_REQUIRED_COMPONENTS_BY_MODULE})
+ list(APPEND _vtk_modules "VTK::${_vtk_module}")
+ endforeach()
+ if(_vtk_modules)
+ vtk_module_autoinit(TARGETS ${USE_TARGET} MODULES ${_vtk_modules})
+ endif()
+ endif()
else()
message(SEND_ERROR "Missing package: ${_package}")
endif()
endforeach()
endforeach()
endif()
endfunction()
diff --git a/Modules/MapperExt/src/mitkVolumeMapperVtkSmart3D.cpp b/Modules/MapperExt/src/mitkVolumeMapperVtkSmart3D.cpp
index 9924013819..ee9a32ef57 100644
--- a/Modules/MapperExt/src/mitkVolumeMapperVtkSmart3D.cpp
+++ b/Modules/MapperExt/src/mitkVolumeMapperVtkSmart3D.cpp
@@ -1,239 +1,237 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkVolumeMapperVtkSmart3D.h"
#include "mitkTransferFunctionProperty.h"
#include "mitkTransferFunctionInitializer.h"
#include "mitkLevelWindowProperty.h"
#include <vtkObjectFactory.h>
#include <vtkColorTransferFunction.h>
#include <vtkPiecewiseFunction.h>
#include <vtkAutoInit.h>
-VTK_MODULE_INIT(vtkRenderingVolumeOpenGL2);
-
void mitk::VolumeMapperVtkSmart3D::GenerateDataForRenderer(mitk::BaseRenderer *renderer)
{
bool value;
this->GetDataNode()->GetBoolProperty("volumerendering", value, renderer);
if (!value)
{
m_Volume->VisibilityOff();
return;
}
else
{
m_Volume->VisibilityOn();
}
UpdateTransferFunctions(renderer);
UpdateRenderMode(renderer);
this->Modified();
}
vtkProp* mitk::VolumeMapperVtkSmart3D::GetVtkProp(mitk::BaseRenderer *)
{
if (!m_Volume->GetMapper())
{
createMapper(GetInputImage());
createVolume();
createVolumeProperty();
}
return m_Volume;
}
void mitk::VolumeMapperVtkSmart3D::ApplyProperties(vtkActor *, mitk::BaseRenderer *)
{
}
void mitk::VolumeMapperVtkSmart3D::SetDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer, bool overwrite)
{
// GPU_INFO << "SetDefaultProperties";
node->AddProperty("volumerendering", mitk::BoolProperty::New(false), renderer, overwrite);
node->AddProperty("volumerendering.usemip", mitk::BoolProperty::New(false), renderer, overwrite);
node->AddProperty("volumerendering.cpu.ambient", mitk::FloatProperty::New(0.10f), renderer, overwrite);
node->AddProperty("volumerendering.cpu.diffuse", mitk::FloatProperty::New(0.50f), renderer, overwrite);
node->AddProperty("volumerendering.cpu.specular", mitk::FloatProperty::New(0.40f), renderer, overwrite);
node->AddProperty("volumerendering.cpu.specular.power", mitk::FloatProperty::New(16.0f), renderer, overwrite);
node->AddProperty("volumerendering.usegpu", mitk::BoolProperty::New(false), renderer, overwrite);
node->AddProperty("volumerendering.useray", mitk::BoolProperty::New(false), renderer, overwrite);
node->AddProperty("volumerendering.gpu.ambient", mitk::FloatProperty::New(0.25f), renderer, overwrite);
node->AddProperty("volumerendering.gpu.diffuse", mitk::FloatProperty::New(0.50f), renderer, overwrite);
node->AddProperty("volumerendering.gpu.specular", mitk::FloatProperty::New(0.40f), renderer, overwrite);
node->AddProperty("volumerendering.gpu.specular.power", mitk::FloatProperty::New(16.0f), renderer, overwrite);
node->AddProperty("binary", mitk::BoolProperty::New(false), renderer, overwrite);
mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(node->GetData());
if (image.IsNotNull() && image->IsInitialized())
{
if ((overwrite) || (node->GetProperty("TransferFunction", renderer) == nullptr))
{
// add a default transfer function
mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New();
mitk::TransferFunctionInitializer::Pointer tfInit = mitk::TransferFunctionInitializer::New(tf);
tfInit->SetTransferFunctionMode(0);
node->SetProperty("TransferFunction", mitk::TransferFunctionProperty::New(tf.GetPointer()));
}
}
Superclass::SetDefaultProperties(node, renderer, overwrite);
}
vtkImageData* mitk::VolumeMapperVtkSmart3D::GetInputImage()
{
auto input = dynamic_cast<mitk::Image*>(this->GetDataNode()->GetData());
return input->GetVtkImageData(this->GetTimestep());
}
void mitk::VolumeMapperVtkSmart3D::createMapper(vtkImageData* imageData)
{
Vector3D spacing;
FillVector3D(spacing, 1.0, 1.0, 1.0);
m_ImageChangeInformation->SetInputData(imageData);
m_ImageChangeInformation->SetOutputSpacing(spacing.GetDataPointer());
m_SmartVolumeMapper->SetBlendModeToComposite();
m_SmartVolumeMapper->SetInputConnection(m_ImageChangeInformation->GetOutputPort());
}
void mitk::VolumeMapperVtkSmart3D::createVolume()
{
m_Volume->VisibilityOff();
m_Volume->SetMapper(m_SmartVolumeMapper);
m_Volume->SetProperty(m_VolumeProperty);
}
void mitk::VolumeMapperVtkSmart3D::createVolumeProperty()
{
m_VolumeProperty->ShadeOn();
m_VolumeProperty->SetInterpolationType(VTK_LINEAR_INTERPOLATION);
}
void mitk::VolumeMapperVtkSmart3D::UpdateTransferFunctions(mitk::BaseRenderer *renderer)
{
vtkSmartPointer<vtkPiecewiseFunction> opacityTransferFunction;
vtkSmartPointer<vtkPiecewiseFunction> gradientTransferFunction;
vtkSmartPointer<vtkColorTransferFunction> colorTransferFunction;
bool isBinary = false;
this->GetDataNode()->GetBoolProperty("binary", isBinary, renderer);
if (isBinary)
{
colorTransferFunction = vtkSmartPointer<vtkColorTransferFunction>::New();
float rgb[3];
if (!GetDataNode()->GetColor(rgb, renderer))
rgb[0] = rgb[1] = rgb[2] = 1;
colorTransferFunction->AddRGBPoint(0, rgb[0], rgb[1], rgb[2]);
colorTransferFunction->Modified();
opacityTransferFunction = vtkSmartPointer<vtkPiecewiseFunction>::New();
gradientTransferFunction = vtkSmartPointer<vtkPiecewiseFunction>::New();
}
else
{
auto *transferFunctionProp =
dynamic_cast<mitk::TransferFunctionProperty *>(this->GetDataNode()->GetProperty("TransferFunction", renderer));
if (transferFunctionProp)
{
opacityTransferFunction = transferFunctionProp->GetValue()->GetScalarOpacityFunction();
gradientTransferFunction = transferFunctionProp->GetValue()->GetGradientOpacityFunction();
colorTransferFunction = transferFunctionProp->GetValue()->GetColorTransferFunction();
}
else
{
opacityTransferFunction = vtkSmartPointer<vtkPiecewiseFunction>::New();
gradientTransferFunction = vtkSmartPointer<vtkPiecewiseFunction>::New();
colorTransferFunction = vtkSmartPointer<vtkColorTransferFunction>::New();
}
}
m_VolumeProperty->SetColor(colorTransferFunction);
m_VolumeProperty->SetScalarOpacity(opacityTransferFunction);
m_VolumeProperty->SetGradientOpacity(gradientTransferFunction);
}
void mitk::VolumeMapperVtkSmart3D::UpdateRenderMode(mitk::BaseRenderer *renderer)
{
bool usegpu = false;
bool useray = false;
bool usemip = false;
this->GetDataNode()->GetBoolProperty("volumerendering.usegpu", usegpu);
this->GetDataNode()->GetBoolProperty("volumerendering.useray", useray);
this->GetDataNode()->GetBoolProperty("volumerendering.usemip", usemip);
if (usegpu)
m_SmartVolumeMapper->SetRequestedRenderModeToGPU();
else if (useray)
m_SmartVolumeMapper->SetRequestedRenderModeToRayCast();
else
m_SmartVolumeMapper->SetRequestedRenderModeToDefault();
int blendMode;
if (this->GetDataNode()->GetIntProperty("volumerendering.blendmode", blendMode))
m_SmartVolumeMapper->SetBlendMode(blendMode);
else if (usemip)
m_SmartVolumeMapper->SetBlendMode(vtkSmartVolumeMapper::MAXIMUM_INTENSITY_BLEND);
// shading parameter
if (m_SmartVolumeMapper->GetRequestedRenderMode() == vtkSmartVolumeMapper::GPURenderMode)
{
float value = 0;
if (this->GetDataNode()->GetFloatProperty("volumerendering.gpu.ambient", value, renderer))
m_VolumeProperty->SetAmbient(value);
if (this->GetDataNode()->GetFloatProperty("volumerendering.gpu.diffuse", value, renderer))
m_VolumeProperty->SetDiffuse(value);
if (this->GetDataNode()->GetFloatProperty("volumerendering.gpu.specular", value, renderer))
m_VolumeProperty->SetSpecular(value);
if (this->GetDataNode()->GetFloatProperty("volumerendering.gpu.specular.power", value, renderer))
m_VolumeProperty->SetSpecularPower(value);
}
else
{
float value = 0;
if (this->GetDataNode()->GetFloatProperty("volumerendering.cpu.ambient", value, renderer))
m_VolumeProperty->SetAmbient(value);
if (this->GetDataNode()->GetFloatProperty("volumerendering.cpu.diffuse", value, renderer))
m_VolumeProperty->SetDiffuse(value);
if (this->GetDataNode()->GetFloatProperty("volumerendering.cpu.specular", value, renderer))
m_VolumeProperty->SetSpecular(value);
if (this->GetDataNode()->GetFloatProperty("volumerendering.cpu.specular.power", value, renderer))
m_VolumeProperty->SetSpecularPower(value);
}
}
mitk::VolumeMapperVtkSmart3D::VolumeMapperVtkSmart3D()
{
m_SmartVolumeMapper = vtkSmartPointer<vtkSmartVolumeMapper>::New();
m_SmartVolumeMapper->SetBlendModeToComposite();
m_ImageChangeInformation = vtkSmartPointer<vtkImageChangeInformation>::New();
m_VolumeProperty = vtkSmartPointer<vtkVolumeProperty>::New();
m_Volume = vtkSmartPointer<vtkVolume>::New();
}
mitk::VolumeMapperVtkSmart3D::~VolumeMapperVtkSmart3D()
{
}