diff --git a/CMakeLists.txt b/CMakeLists.txt
index b5c2775..d651f56 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,311 +1,312 @@
#-----------------------------------------------------------------------------
# This is the root RTToolbox CMakeList file.
#-----------------------------------------------------------------------------
PROJECT(RTToolbox)
CMAKE_MINIMUM_REQUIRED(VERSION 3.1)
# RTToolbox version number.
SET(RTToolbox_VERSION_MAJOR "5")
SET(RTToolbox_VERSION_MINOR "1")
SET(RTToolbox_VERSION_PATCH "0")
# Version string should not include patch level. The major.minor is
# enough to distinguish available features of the toolbox.
SET(RTToolbox_VERSION_STRING "${RTToolbox_VERSION_MAJOR}.${RTToolbox_VERSION_MINOR}")
SET(RTToolbox_FULL_VERSION_STRING "${RTToolbox_VERSION_MAJOR}.${RTToolbox_VERSION_MINOR}.${RTToolbox_VERSION_PATCH}")
+SET(RTToolbox_PREFIX "RTTB")
# default build type
SET(CMAKE_BUILD_TYPE Release)
MARK_AS_ADVANCED(BUILD_SHARED_LIBS)
IF (WIN32)
IF (MSVC_VERSION LESS 1800)
MESSAGE(FATAL_ERROR "RTToolbox requires at least Visual Studio 2013.")
ELSEIF (MSVC_VERSION GREATER_EQUAL 1910)
IF (${CMAKE_VERSION} VERSION_LESS "3.10.3")
MESSAGE(AUTHOR_WARNING "Please use CMake version 3.10.3 or newer for Visual Studio 2017 as new boost versions are not recognized using old CMake versions.")
ENDIF()
ENDIF()
add_definitions(-D_SCL_SECURE_NO_WARNINGS)
ELSE (WIN32)
IF (CMAKE_COMPILER_IS_GNUCC)
IF (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0 OR CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 7.3)
MESSAGE(AUTHOR_WARNING "RTToolbox was tested with GCC 5 and GCC 7 only. You are using GCC " ${CMAKE_CXX_COMPILER_VERSION} ". You might need to change some code in order to compile RT Toolbox.")
ENDIF()
ELSE()
MESSAGE(AUTHOR_WARNING "RTToolbox was only tested with GCC. This compiler might not work.")
ENDIF()
ENDIF(WIN32)
#-----------------------------------------------------------------------------
# CMake Function(s) and Macro(s)
#-----------------------------------------------------------------------------
include(cmake/MacroParseArguments.cmake)
include(cmake/rttbMacroCreateModuleConf.cmake)
include(cmake/rttbMacroCreateModule.cmake)
include(cmake/rttbMacroCreateApplication.cmake)
include(cmake/rttbMacroCheckModule.cmake)
include(cmake/rttbMacroUseModule.cmake)
include(cmake/rttbMacroCreateTestModule.cmake)
include(cmake/rttbFunctionOrganizeSources.cmake)
include(cmake/rttbMacroCreateApplicationTests.cmake)
#-----------------------------------------------------------------------------
# Basis config RTTB module infrastructure
#-----------------------------------------------------------------------------
set(RTTB_MODULES_CONF_DIR ${RTToolbox_BINARY_DIR}/modulesConf CACHE INTERNAL "Modules Conf")
set(RTTB_MODULES_PACKAGE_DEPENDS_DIR ${RTToolbox_SOURCE_DIR}/cmake/PackageDepends)
set(MODULES_PACKAGE_DEPENDS_DIRS ${RTTB_MODULES_PACKAGE_DEPENDS_DIR})
#-----------------------------------------------------------------------------
# Testing setup
# Configure Dart testing support. This should be done before any
# MESSAGE(FATAL_ERROR ...) commands are invoked.
#-----------------------------------------------------------------------------
#build no tests as default
OPTION(BUILD_TESTING "build tests" OFF)
IF(BUILD_TESTING)
SET(CTEST_NEW_FORMAT 1)
INCLUDE(CTest)
ENABLE_TESTING()
CONFIGURE_FILE(${RTToolbox_SOURCE_DIR}/cmake/RemoveTemporaryFiles.cmake.in
${RTToolbox_BINARY_DIR}/cmake/RemoveTemporaryFiles.cmake @ONLY IMMEDIATE)
CONFIGURE_FILE(${RTToolbox_SOURCE_DIR}/cmake/rttbSampleBuildTest.cmake.in
${RTToolbox_BINARY_DIR}/cmake/rttbSampleBuildTest.cmake @ONLY)
CONFIGURE_FILE(${RTToolbox_SOURCE_DIR}/cmake/CTestCustom.ctest.in
${RTToolbox_BINARY_DIR}/cmake/CTestCustom.ctest @ONLY)
FILE(WRITE ${RTToolbox_BINARY_DIR}/CTestCustom.cmake
"INCLUDE(\"${RTToolbox_BINARY_DIR}/cmake/CTestCustom.ctest\")\n")
SET(BUILDNAME "${BUILDNAME}" CACHE STRING "Name of build on the dashboard")
MARK_AS_ADVANCED(BUILDNAME)
ENDIF(BUILD_TESTING)
#-----------------------------------------------------------------------------
# Output directories.
#-----------------------------------------------------------------------------
IF(NOT LIBRARY_OUTPUT_PATH)
SET (LIBRARY_OUTPUT_PATH ${RTToolbox_BINARY_DIR}/bin CACHE PATH "Single output directory for building all libraries.")
ENDIF(NOT LIBRARY_OUTPUT_PATH)
IF(NOT EXECUTABLE_OUTPUT_PATH)
SET (EXECUTABLE_OUTPUT_PATH ${RTToolbox_BINARY_DIR}/bin CACHE PATH "Single output directory for building all executables.")
ENDIF(NOT EXECUTABLE_OUTPUT_PATH)
MARK_AS_ADVANCED(EXECUTABLE_OUTPUT_PATH LIBRARY_OUTPUT_PATH)
MARK_AS_ADVANCED(LIBRARY_OUTPUT_PATH EXECUTABLE_OUTPUT_PATH)
SET(RTToolbox_LIBRARY_PATH "${LIBRARY_OUTPUT_PATH}")
SET(RTToolbox_EXECUTABLE_PATH "${EXECUTABLE_OUTPUT_PATH}")
#-----------------------------------------------------------------------------
# Find Doxygen.
#-----------------------------------------------------------------------------
FIND_PROGRAM(DOXYGEN_EXECUTABLE "doxygen")
#-----------------------------------------------------------------------------
# Installation vars.
# RTToolbox_INSTALL_BIN_DIR - binary dir (executables)
# RTToolbox_INSTALL_LIB_DIR - library dir (libs)
# RTToolbox_INSTALL_INCLUDE_DIR - include dir (headers)
# RTToolbox_INSTALL_NO_DEVELOPMENT - do not install development files
# RTToolbox_INSTALL_NO_RUNTIME - do not install runtime files
# RTToolbox_INSTALL_NO_DOCUMENTATION - do not install documentation files
#-----------------------------------------------------------------------------
IF(NOT RTTOOLBOX_INSTALL_BIN_DIR)
SET(RTTOOLBOX_INSTALL_BIN_DIR "bin")
ENDIF(NOT RTTOOLBOX_INSTALL_BIN_DIR)
IF(NOT RTTOOLBOX_INSTALL_LIB_DIR)
SET(RTTOOLBOX_INSTALL_LIB_DIR "lib")
ENDIF(NOT RTTOOLBOX_INSTALL_LIB_DIR)
IF(NOT RTTOOLBOX_INSTALL_PACKAGE_DIR)
SET(RTTOOLBOX_INSTALL_PACKAGE_DIR "lib")
ENDIF(NOT RTTOOLBOX_INSTALL_PACKAGE_DIR)
IF(NOT RTTOOLBOX_INSTALL_INCLUDE_DIR)
SET(RTTOOLBOX_INSTALL_INCLUDE_DIR "include")
ENDIF(NOT RTTOOLBOX_INSTALL_INCLUDE_DIR)
IF(NOT RTTOOLBOX_INSTALL_NO_DEVELOPMENT)
SET(RTTOOLBOX_INSTALL_NO_DEVELOPMENT 0)
ENDIF(NOT RTTOOLBOX_INSTALL_NO_DEVELOPMENT)
IF(NOT RTTOOLBOX_INSTALL_NO_RUNTIME)
SET(RTTOOLBOX_INSTALL_NO_RUNTIME 0)
ENDIF(NOT RTTOOLBOX_INSTALL_NO_RUNTIME)
IF(NOT RTTOOLBOX_INSTALL_NO_DOCUMENTATION)
SET(RTTOOLBOX_INSTALL_NO_DOCUMENTATION 0)
ENDIF(NOT RTTOOLBOX_INSTALL_NO_DOCUMENTATION)
SET(RTTOOLBOX_INSTALL_NO_LIBRARIES)
IF(RTTOOLBOX_BUILD_SHARED_LIBS)
IF(RTTOOLBOX_INSTALL_NO_RUNTIME AND RTTOOLBOX_INSTALL_NO_DEVELOPMENT)
SET(RTTOOLBOX_INSTALL_NO_LIBRARIES 1)
ENDIF(RTTOOLBOX_INSTALL_NO_RUNTIME AND RTTOOLBOX_INSTALL_NO_DEVELOPMENT)
ELSE(RTTOOLBOX_BUILD_SHARED_LIBS)
IF(RTTOOLBOX_INSTALL_NO_DEVELOPMENT)
SET(RTTOOLBOX_INSTALL_NO_LIBRARIES 1)
ENDIF(RTTOOLBOX_INSTALL_NO_DEVELOPMENT)
ENDIF(RTTOOLBOX_BUILD_SHARED_LIBS)
# set RTToolbox_DIR so it can be used by subprojects
SET(RTToolbox_DIR "${CMAKE_BINARY_DIR}" CACHE INTERNAL "RTToolbox dir to be used by subprojects")
#-----------------------------------------------------------------------------
# DCMTK MT-Flag treat
#-----------------------------------------------------------------------------
option(RTTB_DCMTK_COMPLIANCE_ENFORCE_MT "This enforces the whole RTToolbox to be compiled with /MT,/MTd to be compliant with DCMTK" OFF)
string(FIND ${CMAKE_GENERATOR} "Visual Studio" RTTB_VS_USED)
if(RTTB_DCMTK_COMPLIANCE_ENFORCE_MT AND RTTB_VS_USED EQUAL 0)
message(STATUS "Enforce DCMTK compliance: /MT and /MTd flags are used")
string(REPLACE "/MD" "/MT" CMAKE_C_FLAGS_DEBUG ${CMAKE_C_FLAGS_DEBUG})
message(STATUS "CMAKE_C_FLAGS_DEBUG set to: ${CMAKE_C_FLAGS_DEBUG}")
string(REPLACE "/MD" "/MT" CMAKE_C_FLAGS_RELEASE ${CMAKE_C_FLAGS_RELEASE})
message(STATUS "CMAKE_C_FLAGS_RELEASE set to: ${CMAKE_C_FLAGS_RELEASE}")
string(REPLACE "/MD" "/MT" CMAKE_C_FLAGS_MINSIZEREL ${CMAKE_C_FLAGS_MINSIZEREL})
message(STATUS "CMAKE_C_FLAGS_MINSIZEREL set to: ${CMAKE_C_FLAGS_MINSIZEREL}")
string(REPLACE "/MD" "/MT" CMAKE_C_FLAGS_RELWITHDEBINFO ${CMAKE_C_FLAGS_RELWITHDEBINFO})
message(STATUS "CMAKE_C_FLAGS_RELWITHDEBINFO set to: ${CMAKE_C_FLAGS_RELWITHDEBINFO}")
string(REPLACE "/MD" "/MT" CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG})
message(STATUS "CMAKE_CXX_FLAGS_DEBUG set to: ${CMAKE_CXX_FLAGS_DEBUG}")
string(REPLACE "/MD" "/MT" CMAKE_CXX_FLAGS_RELEASE ${CMAKE_CXX_FLAGS_RELEASE})
message(STATUS "CMAKE_CXX_FLAGS_RELEASE set to: ${CMAKE_CXX_FLAGS_RELEASE}")
string(REPLACE "/MD" "/MT" CMAKE_CXX_FLAGS_MINSIZEREL ${CMAKE_CXX_FLAGS_MINSIZEREL})
message(STATUS "CMAKE_CXX_FLAGS_MINSIZEREL set to: ${CMAKE_CXX_FLAGS_MINSIZEREL}")
string(REPLACE "/MD" "/MT" CMAKE_CXX_FLAGS_RELWITHDEBINFO ${CMAKE_CXX_FLAGS_RELWITHDEBINFO})
message(STATUS "CMAKE_CXX_FLAGS_RELWITHDEBINFO set to: ${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
endif()
#-----------------------------------------------------------------------------
# Advanced RTToolbox configuration
#-----------------------------------------------------------------------------
#-----------------------------------------------------------------------------
# RTToolbox build configuration options.
IF (NOT RTTB_CXX_STANDARD)
set(RTTB_CXX_STANDARD 11)
ENDIF (NOT RTTB_CXX_STANDARD)
set(CMAKE_CXX_STANDARD ${RTTB_CXX_STANDARD} CACHE STRING "")
set(CMAKE_CXX_STANDARD_REQUIRED 1)
OPTION(CMAKE_CXX_EXTENSIONS "" ON)
MARK_AS_ADVANCED(CMAKE_CXX_STANDARD CMAKE_CXX_STANDARD_REQUIRED CMAKE_CXX_EXTENSIONS)
IF (WIN32)
OPTION(BUILD_SHARED_LIBS "Build RTToolbox with shared libraries." OFF)
ELSE (WIN32)
OPTION(BUILD_SHARED_LIBS "Build RTToolbox with shared libraries." ON)
ENDIF (WIN32)
IF(NOT BUILD_SHARED_LIBS)
IF(UNIX)
MESSAGE(FATAL_ERROR "RTToolbox currently does not support a static build on unix like systems. We are working on that...")
ENDIF(UNIX)
ENDIF(NOT BUILD_SHARED_LIBS)
SET(RTTB_BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS})
#Raise warning level (MSVC has W3 default warning level)
IF (WIN32)
IF(NOT BUILD_SHARED_LIBS)
set(CMAKE_CXX_FLAGS "/W4 /EHsc")
ENDIF()
ELSE()
IF (CMAKE_COMPILER_IS_GNUCC)
set(CMAKE_CXX_FLAGS "-Wall")
ENDIF()
ENDIF()
IF(NOT RTToolbox_NO_LIBRARY_VERSION)
# This setting of SOVERSION assumes that any API change
# will increment either the minor or major version number of RTToolbox.
SET(RTToolbox_LIBRARY_PROPERTIES
VERSION "${RTToolbox_VERSION_MAJOR}.${RTToolbox_VERSION_MINOR}.${RTToolbox_VERSION_PATCH}"
SOVERSION "${RTToolbox_VERSION_MAJOR}.${RTToolbox_VERSION_MINOR}"
)
ENDIF(NOT RTToolbox_NO_LIBRARY_VERSION)
#-----------------------------------------------------------------------------
# Configure files with settings for use by the build.
#
#-----------------------------------------------------------------------------
CONFIGURE_FILE(${RTToolbox_SOURCE_DIR}/RTToolboxConfigure.h.in
${RTToolbox_BINARY_DIR}/RTToolboxConfigure.h)
IF(NOT RTTOOLBOX_INSTALL_NO_DEVELOPMENT)
INSTALL(FILES ${RTToolbox_BINARY_DIR}/RTToolboxConfigure.h
DESTINATION ${RTTOOLBOX_INSTALL_INCLUDE_DIR}
COMPONENT Development)
ENDIF(NOT RTTOOLBOX_INSTALL_NO_DEVELOPMENT)
#-----------------------------------------------------------------------------
# The entire RTToolbox tree should use the same include path
#-----------------------------------------------------------------------------
#Default include dir. Others dirs will be defined by activated subprojects
INCLUDE_DIRECTORIES(${RTToolbox_BINARY_DIR})
LINK_DIRECTORIES(${LIBARY_OUTPUT_PATH})
#Prepare the correct target information export by the subprojects
SET(RTToolbox_TARGETS_FILE "${RTToolbox_BINARY_DIR}/RTToolboxTargets.cmake")
FILE(WRITE ${RTToolbox_TARGETS_FILE} "# Generated by CMake, do not edit!")
#-----------------------------------------------------------------------------
# Dispatch the build into the proper subdirectories.
#-----------------------------------------------------------------------------
OPTION(BUILD_All_Modules "All modules will be built" OFF)
OPTION(BUILD_Apps "Determine if the CLI applications will be generated." OFF)
MESSAGE (STATUS "generating Project RTToolbox")
ADD_SUBDIRECTORY (code)
IF (BUILD_Apps)
ADD_SUBDIRECTORY (apps)
ENDIF()
IF (BUILD_TESTING)
ADD_SUBDIRECTORY (testing)
ENDIF (BUILD_TESTING)
ADD_SUBDIRECTORY (documentation)
#-----------------------------------------------------------------------------
# Help other projects use RTToolbox.
#-----------------------------------------------------------------------------
EXPORT(PACKAGE RTToolbox)
# Create the RTToolboxConfig.cmake file containing the RTToolbox configuration.
INCLUDE (${RTToolbox_SOURCE_DIR}/rttbGenerateRTToolboxConfig.cmake)
IF(NOT RTToolbox_INSTALL_NO_DEVELOPMENT)
INSTALL(FILES
${RTToolbox_BINARY_DIR}/RTToolboxConfig.cmake
DESTINATION ${RTTOOLBOX_INSTALL_PACKAGE_DIR}
COMPONENT Development
)
INSTALL(EXPORT RTToolboxTargets
FILE RTToolboxTargets.cmake
DESTINATION ${RTTOOLBOX_INSTALL_PACKAGE_DIR}
COMPONENT Development
)
ENDIF(NOT RTToolbox_INSTALL_NO_DEVELOPMENT)
diff --git a/cmake/rttbMacroCreateTestModule.cmake b/cmake/rttbMacroCreateTestModule.cmake
index 278d976..9c03e26 100644
--- a/cmake/rttbMacroCreateTestModule.cmake
+++ b/cmake/rttbMacroCreateTestModule.cmake
@@ -1,175 +1,175 @@
##################################################################
#
# RTTB_CREATE_MODULE
#
#! Creates a module for the automatic module dependency system within RTTB.
#! Configurations are generated in the moduleConf directory.
#!
#! USAGE:
#!
#! \code
#! RTTB_CREATE_MODULE( <moduleName>
#! [INCLUDE_DIRS <include directories>]
#! [INTERNAL_INCLUDE_DIRS <internally used include directories>]
#! [DEPENDS <modules we need>]
#! [PROVIDES <library name which is built>]
#! [PACKAGE_DEPENDS <packages we need, like ITK, VTK, QT>]
#! [HEADER_TEST]
#! \endcode
#!
#! \param MODULE_NAME_IN The name for the new module
#
##################################################################
MACRO(RTTB_CREATE_TEST_MODULE MODULE_NAME_IN)
MACRO_PARSE_ARGUMENTS(MODULE
"INCLUDE_DIRS;INTERNAL_INCLUDE_DIRS;DEPENDS;DEPENDS_INTERNAL;PROVIDES;PACKAGE_DEPENDS;ADDITIONAL_LIBS"
"HEADER_TESTS"
${ARGN})
- SET(MODULE_NAME "RTTB${MODULE_NAME_IN}Tests")
+ SET(MODULE_NAME "${RTToolbox_PREFIX}${MODULE_NAME_IN}Tests")
SET(WAIT_FOR_DEPENDENCY_LIBS "Litmus") #each test depends on Litmus
# assume worst case
SET(MODULE_IS_ENABLED 0)
# first we check if we have an explicit module build list
IF(RTTB_MODULES_TO_BUILD)
LIST(FIND RTTB_MODULES_TO_BUILD ${MODULE_NAME} _MOD_INDEX)
IF(_MOD_INDEX EQUAL -1)
SET(MODULE_IS_EXCLUDED 1)
ENDIF()
ENDIF()
IF(NOT MODULE_IS_EXCLUDED)
MESSAGE(STATUS "configuring Tests ${MODULE_NAME}...")
# first of all we check for the dependencies
RTTB_CHECK_MODULE(_MISSING_DEP ${MODULE_DEPENDS})
IF(_MISSING_DEP)
MESSAGE("Module ${MODULE_NAME} won't be built, missing dependency: ${_MISSING_DEP}")
SET(MODULE_IS_ENABLED 0)
ELSE(_MISSING_DEP)
SET(MODULE_IS_ENABLED 1)
# now check for every package if it is enabled. This overlaps a bit with
# RTTB_CHECK_MODULE ...
FOREACH(_package ${MODULE_PACKAGE_DEPENDS})
IF((DEFINED RTTB_USE_${_package}) AND NOT (RTTB_USE_${_package}))
MESSAGE("Module ${MODULE_NAME} won't be built. Turn on RTTB_USE_${_package} if you want to use it.")
SET(MODULE_IS_ENABLED 0)
ENDIF()
ENDFOREACH()
IF(NOT MODULE_PROVIDES)
SET(MODULE_PROVIDES ${MODULE_NAME})
ENDIF(NOT MODULE_PROVIDES)
SET(DEPENDS "${MODULE_DEPENDS}")
SET(DEPENDS_BEFORE "not initialized")
SET(PACKAGE_DEPENDS "${MODULE_PACKAGE_DEPENDS}")
RTTB_USE_MODULE("${MODULE_DEPENDS}")
# ok, now create the module itself
INCLUDE_DIRECTORIES(. ${ALL_INCLUDE_DIRECTORIES})
INCLUDE(files.cmake)
ORGANIZE_SOURCES(SOURCE ${CPP_FILES}
HEADER ${H_FILES}
TXX ${TXX_FILES}
DOC ${DOX_FILES}
)
IF(ALL_LIBRARY_DIRS)
# LINK_DIRECTORIES applies only to targets which are added after the call to LINK_DIRECTORIES
LINK_DIRECTORIES(${ALL_LIBRARY_DIRS})
ENDIF(ALL_LIBRARY_DIRS)
SET(coverage_sources ${CPP_FILES} ${H_FILES} ${TXX_FILES})
ADD_EXECUTABLE(${MODULE_PROVIDES} ${coverage_sources} ${CPP_FILES_GENERATED})
IF(ALL_LIBRARIES)
TARGET_LINK_LIBRARIES(${MODULE_PROVIDES} ${ALL_LIBRARIES})
ENDIF(ALL_LIBRARIES)
IF(MODULE_HEADER_TESTS)
MESSAGE(STATUS "generating header tests ${MODULE_NAME}...")
- SET(HEADER_TEST_CPP "${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME_IN}HeaderTests.cpp")
+ SET(HEADER_TEST_CPP "${CMAKE_CURRENT_BINARY_DIR}/${RTToolbox_PREFIX}${MODULE_NAME_IN}HeaderTest.cpp")
MESSAGE(STATUS "generating header tests ${HEADER_TEST_CPP}")
FILE(WRITE ${HEADER_TEST_CPP} ${RTTB_HEADER_TESTS_HEADER})
FOREACH(_h_file ${H_FILES})
FILE(APPEND ${HEADER_TEST_CPP} "#include <${_h_file}>\n")
ENDFOREACH()
FILE(APPEND ${HEADER_TEST_CPP} ${RTTB_HEADER_TESTS_FOOTER})
- ADD_EXECUTABLE(${MODULE_NAME_IN}HeaderTests ${HEADER_TEST_CPP})
+ ADD_EXECUTABLE(${RTToolbox_PREFIX}${MODULE_NAME_IN}HeaderTest ${HEADER_TEST_CPP})
IF(ALL_LIBRARIES)
- TARGET_LINK_LIBRARIES(${MODULE_NAME_IN}HeaderTests ${ALL_LIBRARIES})
+ TARGET_LINK_LIBRARIES(${RTToolbox_PREFIX}${MODULE_NAME_IN}HeaderTest ${ALL_LIBRARIES})
ENDIF(ALL_LIBRARIES)
ENDIF(MODULE_HEADER_TESTS)
# Necessary so the build waits for libs to build
ADD_DEPENDENCIES(${MODULE_NAME} ${WAIT_FOR_DEPENDENCY_LIBS})
#-----------------------------------------------------------------------------
IF(RTToolbox_BINARY_DIR)
SET(RTToolbox_SYSTEM_INFORMATION_DIR ${RTToolbox_BINARY_DIR})
ELSE(RTToolbox_BINARY_DIR)
SET(RTToolbox_SYSTEM_INFORMATION_DIR ${RTTBTesting_BINARY_DIR})
ENDIF(RTToolbox_BINARY_DIR)
WRITE_FILE(
"${RTToolbox_SYSTEM_INFORMATION_DIR}/testing/HTML/TestingResults/Sites/${SITE}/${BUILDNAME}/BuildNameNotes.xml"
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<Site BuildName=\"CMakeCache\" Name=\"crd\">\n"
"<BuildNameNotes>\n"
"<Note>\n"
"<DateTime>Wed Oct 24 1:00:00 EST</DateTime>\n"
"<Text>\n"
"Here is some basic information:\n"
"RTToolbox_SOURCE_DIR = ${RTToolbox_SOURCE_DIR}\n"
"RTToolbox_BINARY_DIR = ${RTToolbox_BINARY_DIR}\n"
"RTTBTesting_SOURCE_DIR = ${RTTBTesting_SOURCE_DIR}\n"
"RTTBTesting_BINARY_DIR = ${RTTBTesting_BINARY_DIR}\n"
"CMAKE_C_COMPILER = ${CMAKE_C_COMPILER}\n"
"CMAKE_C_FLAGS = ${CMAKE_C_FLAGS}\n"
"CMAKE_CXX_COMPILER = ${CMAKE_CXX_COMPILER}\n"
"CMAKE_CXX_FLAGS = ${CMAKE_CXX_FLAGS}\n"
"CMAKE_SYSTEM = ${CMAKE_SYSTEM}\n"
"CMAKE_MAKE_PROGRAM = ${CMAKE_MAKE_PROGRAM}\n"
"</Text>\n"
"</Note>\n"
"</BuildNameNotes>\n"
"</Site>\n"
)
ENDIF(_MISSING_DEP)
ENDIF(NOT MODULE_IS_EXCLUDED)
ENDMACRO(RTTB_CREATE_TEST_MODULE)
SET(RTTB_HEADER_TESTS_HEADER
"// -----------------------------------------------------------------------\n"
"// RTToolbox - DKFZ radiotherapy quantitative evaluation library\n"
"//\n"
"// (c) Copyright 2007, DKFZ, Heidelberg, Germany\n"
"// ALL RIGHTS RESERVED\n"
"//\n"
"// THIS FILE CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION OF DKFZ.\n"
"// ANY DUPLICATION, MODIFICATION, DISTRIBUTION, OR\n"
"// DISCLOSURE IN ANY FORM, IN WHOLE, OR IN PART, IS STRICTLY PROHIBITED\n"
"// WITHOUT THE PRIOR EXPRESS WRITTEN PERMISSION OF DKFZ.\n"
"//\n"
"//------------------------------------------------------------------------\n"
"// Automatically generated header test file \n"
"#if defined(_MSC_VER)\n"
"#pragma warning ( disable : 4786 )\n"
"#endif\n"
"#include <iostream>\n")
SET(RTTB_HEADER_TESTS_FOOTER
"\nint main ( int , char* )\n"
"{\n"
" return EXIT_SUCCESS;\n"
"}\n")
diff --git a/code/masks/rttbBoostMaskAccessor.h b/code/masks/rttbBoostMaskAccessor.h
index 5a02dd4..d615ba7 100644
--- a/code/masks/rttbBoostMaskAccessor.h
+++ b/code/masks/rttbBoostMaskAccessor.h
@@ -1,116 +1,116 @@
// -----------------------------------------------------------------------
// RTToolbox - DKFZ radiotherapy quantitative evaluation library
//
// Copyright (c) German Cancer Research Center (DKFZ),
// Software development for Integrated Diagnostics and Therapy (SIDT).
// ALL RIGHTS RESERVED.
// See rttbCopyright.txt or
// http://www.dkfz.de/en/sidt/projects/rttb/copyright.html
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notices for more information.
//
//------------------------------------------------------------------------
#ifndef __BOOST_MASK_R_ACCESSOR__H
#define __BOOST_MASK_R_ACCESSOR__H
#include "rttbBaseType.h"
#include "rttbGeometricInfo.h"
#include "rttbMaskAccessorInterface.h"
#include "rttbStructure.h"
-#include "RTTBBoostMaskExports.h"
+#include "RTTBMaskExports.h"
namespace rttb
{
namespace masks
{
namespace boost
{
/*! @class BoostMaskAccessor
* @brief Using the voxelization based on boost::geometry and generate the mask accessor.
* @attention If "strict" is set to true, an exception will be thrown when the given structure has self intersection.
* (A structure without self intersection means all contours of the structure have no self intersection, and
* the polygons on the same slice have no intersection between each other, unless the case of a donut. A donut is accepted.)
* If "strict" is set to false, debug information will be displayed when the given structure has self intersection. Self intersections will be ignored
* and the mask will be calculated, however, it may cause errors in the mask results.
*/
- class RTTBBoostMask_EXPORT BoostMaskAccessor : public core::MaskAccessorInterface
+ class RTTBMask_EXPORT BoostMaskAccessor : public core::MaskAccessorInterface
{
public:
using MaskVoxelList = core::MaskAccessorInterface::MaskVoxelList;
using MaskVoxelListPointer = core::MaskAccessorInterface::MaskVoxelListPointer;
using StructTypePointer = core::Structure::Pointer;
private:
StructTypePointer _spStructure;
core::GeometricInfo _geoInfo;
bool _strict;
/*! vector containing list of mask voxels*/
MaskVoxelListPointer _spRelevantVoxelVector;
IDType _maskUID;
public:
/*! @brief Constructor with a structure pointer and a geometric info pointer
* @param aStructurePointer smart pointer of the structure
* @param aGeometricInfo smart pointer of the geometricInfo of the dose
* @param strict indicates whether to allow self intersection in the structure. If it is set to true, an exception will be thrown when the given structure has self intersection.
* @exception InvalidParameterException thrown if strict is true and the structure has self intersections
*/
BoostMaskAccessor(StructTypePointer aStructurePointer, const core::GeometricInfo& aGeometricInfo,
bool strict = true);
/*! @brief destructor*/
~BoostMaskAccessor() override;
/*! @brief voxelization of the given structures using boost algorithms*/
void updateMask() override;
/*! @brief get vector containing all relevant voxels that are inside the given structure*/
MaskVoxelListPointer getRelevantVoxelVector() override;
/*! @brief get vector containing all relevant voxels that have a relevant volume above the given threshold and are inside the given structure*/
MaskVoxelListPointer getRelevantVoxelVector(float lowerThreshold) override;
/*!@brief determine how a given voxel on the dose grid is masked
* @param aID ID of the voxel in grid.
* @param voxel Reference to the voxel.
* @post after a valid call voxel containes the information of the specified grid voxel. If aID is not valid, voxel values are undefined.
* The relevant volume fraction will be set to zero.
* @return Indicates of the voxel exists and therefore if parameter voxel containes valid values.*/
bool getMaskAt(const VoxelGridID aID, core::MaskVoxel& voxel) const override;
/*!@brief determine how a given voxel on the dose grid is masked
* @param aIndex 3d index of the voxel in grid.
* @param voxel Reference to the voxel.
* @return Indicates of the voxel exists and therefore if parameter voxel containes valid values.*/
bool getMaskAt(const VoxelGridIndex3D& aIndex, core::MaskVoxel& voxel) const override;
/*! @brief give access to GeometricInfo*/
const core::GeometricInfo& getGeometricInfo() const override;
/* @ brief is true if dose is on a homogeneous grid
* @remark Inhomogeneous grids are not supported at the moment, but if they will be supported in the future the interface does not need to change.*/
bool isGridHomogeneous() const override
{
return true;
};
IDType getMaskUID() const override
{
return _maskUID;
};
};
}
}
}
#endif
diff --git a/testing/algorithms/CMakeLists.txt b/testing/algorithms/CMakeLists.txt
index 81a5bc5..3ab837c 100644
--- a/testing/algorithms/CMakeLists.txt
+++ b/testing/algorithms/CMakeLists.txt
@@ -1,20 +1,20 @@
#-----------------------------------------------------------------------------
# Setup the system information test. Write out some basic failsafe
# information in case the test doesn't run.
#-----------------------------------------------------------------------------
-SET(ALGORITHMS_TESTS ${EXECUTABLE_OUTPUT_PATH}/rttbAlgorithmsTests)
-SET(ALGORITHMS_HEADER_TEST ${EXECUTABLE_OUTPUT_PATH}/rttbAlgorithmsHeaderTest)
+SET(ALGORITHMS_TESTS ${EXECUTABLE_OUTPUT_PATH}/${RTToolbox_PREFIX}AlgorithmsTests)
+SET(ALGORITHMS_HEADER_TEST ${EXECUTABLE_OUTPUT_PATH}/${RTToolbox_PREFIX}AlgorithmsHeaderTest)
SET(TEMP ${RTTBTesting_BINARY_DIR}/temporary)
#-----------------------------------------------------------------------------
ADD_TEST(DoseStatisticsTest ${ALGORITHMS_TESTS} DoseStatisticsTest)
ADD_TEST(ArithmeticTest ${ALGORITHMS_TESTS} ArithmeticTest)
ADD_TEST(DoseStatisticsCalculatorTest ${ALGORITHMS_TESTS} DoseStatisticsCalculatorTest "${TEST_DATA_ROOT}/DoseStatistics/XML/dicom_heartComplex.xml" "${TEST_DATA_ROOT}/Dose/DICOM/dicompylerTestDose.dcm" "${TEST_DATA_ROOT}/StructureSet/DICOM/rtss.dcm")
ADD_TEST(BinaryFunctorAccessorTest ${ALGORITHMS_TESTS} BinaryFunctorAccessorTest "${TEST_DATA_ROOT}/Dose/DICOM/ConstantTwo.dcm" "${TEST_DATA_ROOT}/Dose/DICOM/dicompylerTestDose.dcm")
RTTB_CREATE_TEST_MODULE(Algorithms DEPENDS RTTBAlgorithms RTTBMask RTTBDicomIO PACKAGE_DEPENDS Boost Litmus RTTBData DCMTK)
diff --git a/testing/apps/BioModelCalc/CMakeLists.txt b/testing/apps/BioModelCalc/CMakeLists.txt
index f6c954b..7403584 100644
--- a/testing/apps/BioModelCalc/CMakeLists.txt
+++ b/testing/apps/BioModelCalc/CMakeLists.txt
@@ -1,30 +1,30 @@
#-----------------------------------------------------------------------------
# Setup the system information test. Write out some basic failsafe
# information in case the test doesn't run.
#-----------------------------------------------------------------------------
-SET(BIOMODELCALC_TEST ${EXECUTABLE_OUTPUT_PATH}/rttbBioModelCalcTests)
+SET(BIOMODELCALC_TEST ${EXECUTABLE_OUTPUT_PATH}/${RTToolbox_PREFIX}BioModelCalcTests)
SET(TEMP ${RTTBTesting_BINARY_DIR}/temporary)
#-----------------------------------------------------------------------------
IF(MSVC)
ADD_DEFINITIONS(/bigobj)
ENDIF()
IF (WIN32)
SET(BIOMODELCALCEXE "BioModelCalc.exe")
ELSE (WIN32)
SET(BIOMODELCALCEXE "./BioModelCalc")
ENDIF (WIN32)
ADD_TEST(BioModelCalcInvalidParametersTest ${BIOMODELCALC_TEST} BioModelCalcInvalidParametersTest ${BIOMODELCALCEXE})
ADD_TEST(BioModelCalcSimpleTest ${BIOMODELCALC_TEST} BioModelCalcSimpleTest ${BIOMODELCALCEXE} "${TEST_DATA_ROOT}/Dose/DICOM/ConstantTwo.dcm" "dicom" "LQ" "0.1 0.01"
"${TEST_DATA_ROOT}/BioModel/Images/simpleReference.nrrd" "${TEST_DATA_ROOT}/BioModel/Images/simpleReferenceWithNFractions.nrrd")
ADD_TEST(BioModelCalcParameterMapsTest ${BIOMODELCALC_TEST} BioModelCalcParameterMapsTest ${BIOMODELCALCEXE} "${TEST_DATA_ROOT}/Dose/DICOM/ConstantTwo.dcm" "dicom" "LQ"
"${TEST_DATA_ROOT}/Dose/ITK/constant01.nrrd ${TEST_DATA_ROOT}/Dose/ITK/constant001.nrrd" "itk" "${TEST_DATA_ROOT}/BioModel/Images/parameterMapsReference.nrrd")
RTTB_CREATE_APPLICATION_TESTS(BioModelCalc DEPENDS RTTBITKIO PACKAGE_DEPENDS Litmus ITK BoostBinaries RTTBData)
diff --git a/testing/apps/DoseAcc/CMakeLists.txt b/testing/apps/DoseAcc/CMakeLists.txt
index 804f298..10aca93 100644
--- a/testing/apps/DoseAcc/CMakeLists.txt
+++ b/testing/apps/DoseAcc/CMakeLists.txt
@@ -1,28 +1,28 @@
#-----------------------------------------------------------------------------
# Setup the system information test. Write out some basic failsafe
# information in case the test doesn't run.
#-----------------------------------------------------------------------------
-SET(DOSEACC_TEST ${EXECUTABLE_OUTPUT_PATH}/rttbDoseAccTests)
+SET(DOSEACC_TEST ${EXECUTABLE_OUTPUT_PATH}/${RTToolbox_PREFIX}DoseAccTests)
SET(TEMP ${RTTBTesting_BINARY_DIR}/temporary)
#-----------------------------------------------------------------------------
IF(MSVC)
ADD_DEFINITIONS(/bigobj)
ENDIF()
IF (WIN32)
SET(DOSEACCEXE "DoseAcc.exe")
ELSE (WIN32)
SET(DOSEACCEXE "./DoseAcc")
ENDIF (WIN32)
ADD_TEST(DoseAccInvalidParametersTest ${DOSEACC_TEST} DoseAccInvalidParametersTest ${DOSEACCEXE})
ADD_TEST(DoseAccSimpleTest ${DOSEACC_TEST} DoseAccSimpleTest ${DOSEACCEXE} "${TEST_DATA_ROOT}/Dose/DICOM/ConstantTwo.dcm" "${TEST_DATA_ROOT}/Dose/DICOM/ConstantFifty.dcm" "${TEST_DATA_ROOT}/Images/ITK/doseAccReference.nrrd")
ADD_TEST(DoseAccNeutralWeightTest ${DOSEACC_TEST} DoseAccNeutralWeightTest ${DOSEACCEXE} "${TEST_DATA_ROOT}/Dose/DICOM/ConstantFifty.dcm" "${TEST_DATA_ROOT}/Dose/ITK/constantFifty.nrrd" "${TEST_DATA_ROOT}/Dose/ITK/constant2500.nrrd")
RTTB_CREATE_APPLICATION_TESTS(DoseAcc DEPENDS RTTBITKIO PACKAGE_DEPENDS Litmus ITK BoostBinaries RTTBData)
diff --git a/testing/apps/DoseTool/CMakeLists.txt b/testing/apps/DoseTool/CMakeLists.txt
index eb75ad3..03e9937 100644
--- a/testing/apps/DoseTool/CMakeLists.txt
+++ b/testing/apps/DoseTool/CMakeLists.txt
@@ -1,37 +1,37 @@
#-----------------------------------------------------------------------------
# Setup the system information test. Write out some basic failsafe
# information in case the test doesn't run.
#-----------------------------------------------------------------------------
-SET(DOSETOOL_TEST ${EXECUTABLE_OUTPUT_PATH}/rttbDoseToolTests)
+SET(DOSETOOL_TEST ${EXECUTABLE_OUTPUT_PATH}/${RTToolbox_PREFIX}DoseToolTests)
SET(TEMP ${RTTBTesting_BINARY_DIR}/temporary)
#-----------------------------------------------------------------------------
IF(MSVC)
ADD_DEFINITIONS(/bigobj)
ENDIF()
IF (WIN32)
SET(DOSETOOLEXE "DoseTool.exe")
ELSE (WIN32)
SET(DOSETOOLEXE "./DoseTool")
ENDIF (WIN32)
ADD_TEST(DoseToolInvalidParametersTest ${DOSETOOL_TEST} DoseToolInvalidParametersTest ${DOSETOOLEXE})
ADD_TEST(DoseToolDicomDoseDicomStructTest ${DOSETOOL_TEST} DoseToolDicomDoseTest ${DOSETOOLEXE} "${TEST_DATA_ROOT}/Dose/DICOM/dicompylerTestDose.dcm" "${TEST_DATA_ROOT}/StructureSet/DICOM/rtss.dcm" "Nodes"
"${TEST_DATA_ROOT}/DoseStatistics/XML/dicom.xml" "${TEST_DATA_ROOT}/DVH/XML/dicompylerDVH.xml" "${TEST_DATA_ROOT}/DoseStatistics/XML/dicomComplex.xml")
ADD_TEST(DoseToolDicomDoseVoxelizedStructTest ${DOSETOOL_TEST} DoseToolDicomDoseTest ${DOSETOOLEXE} "${TEST_DATA_ROOT}/Dose/DICOM/dicompylerTestDose.dcm" "${TEST_DATA_ROOT}/StructureSet/ITK/voxelizedNodes.nrrd" ""
"${TEST_DATA_ROOT}/DoseStatistics/XML/dicom.xml" "${TEST_DATA_ROOT}/DVH/XML/dicompylerDVH_voxelizedITK.xml" "${TEST_DATA_ROOT}/DoseStatistics/XML/dicomComplex.xml")
ADD_TEST(DoseToolITKDoseDicomStructTest ${DOSETOOL_TEST} DoseToolITKDoseTest ${DOSETOOLEXE} "${TEST_DATA_ROOT}/Dose/ITK/dicompylerTestDose.mhd" "${TEST_DATA_ROOT}/StructureSet/DICOM/rtss.dcm" "Nodes"
"${TEST_DATA_ROOT}/DoseStatistics/XML/itkDicomStruct.xml" "${TEST_DATA_ROOT}/DoseStatistics/XML/itkDicomStructComplex.xml" "dicomOutput.xml" "dicomOutputComplex.xml")
ADD_TEST(DoseToolITKDoseITKStructTest ${DOSETOOL_TEST} DoseToolITKDoseTest ${DOSETOOLEXE} "${TEST_DATA_ROOT}/Dose/ITK/dicompylerTestDose.mhd" "${TEST_DATA_ROOT}/StructureSet/ITK/voxelizedNodes.nrrd" "Nodes"
"${TEST_DATA_ROOT}/DoseStatistics/XML/itkDicomStruct.xml" "${TEST_DATA_ROOT}/DoseStatistics/XML/itkDicomStructComplex.xml" "itkOutput.xml" "itkOutputComplex.xml")
ADD_TEST(DoseToolDicomDoseDicomStructRegexTest ${DOSETOOL_TEST} DoseToolRegexTest ${DOSETOOLEXE} "${TEST_DATA_ROOT}/Dose/DICOM/dicompylerTestDose.dcm" "dicom" "${TEST_DATA_ROOT}/StructureSet/DICOM/rtss.dcm" "dicom" "Nodes|Heart"
"${TEST_DATA_ROOT}/DoseStatistics/XML/dicom.xml" "${TEST_DATA_ROOT}/DoseStatistics/XML/dicom_heart.xml")
ADD_TEST(DoseToolDVHTest ${DOSETOOL_TEST} DoseToolDVHTest ${DOSETOOLEXE} "${TEST_DATA_ROOT}/Dose/DICOM/dicompylerTestDose.dcm" "${TEST_DATA_ROOT}/StructureSet/DICOM/rtss.dcm" "Nodes"
"${TEST_DATA_ROOT}/DVH/XML/dicompylerDVH.xml")
RTTB_CREATE_APPLICATION_TESTS(DoseTool DEPENDS RTTBOtherIO PACKAGE_DEPENDS Litmus BoostBinaries RTTBData)
diff --git a/testing/apps/VoxelizerTool/CMakeLists.txt b/testing/apps/VoxelizerTool/CMakeLists.txt
index 34179ff..066b5bb 100644
--- a/testing/apps/VoxelizerTool/CMakeLists.txt
+++ b/testing/apps/VoxelizerTool/CMakeLists.txt
@@ -1,31 +1,31 @@
#-----------------------------------------------------------------------------
# Setup the system information test. Write out some basic failsafe
# information in case the test doesn't run.
#-----------------------------------------------------------------------------
-SET(VoxelizerTool_TESTS ${EXECUTABLE_OUTPUT_PATH}/rttbVoxelizerToolTests)
+SET(VoxelizerTool_TESTS ${EXECUTABLE_OUTPUT_PATH}/${RTToolbox_PREFIX}VoxelizerToolTests)
SET(TEST_DATA ${RTToolbox_BINARY_DIR}/testing/apps/VoxelizerTool)
IF (WIN32)
SET(VOXELIZERTOOL_EXE "VoxelizerTool")
ELSE (WIN32)
SET(VOXELIZERTOOL_EXE "./VoxelizerTool")
ENDIF (WIN32)
SET(STRUCT_FILE "${TEST_DATA_ROOT}/StructureSet/DICOM/RS1.3.6.1.4.1.2452.6.841242143.1311652612.1170940299.4217870819.dcm")
SET(REFERENCE_FILE "${TEST_DATA_ROOT}/Dose/DICOM/ConstantTwo.dcm")
#-----------------------------------------------------------------------------
ADD_TEST(VoxelizerToolIncorrectCommandsTest ${VoxelizerTool_TESTS} VoxelizerToolIncorrectCommandsTest
"${VOXELIZERTOOL_EXE}" ${STRUCT_FILE} "${TEST_DATA_ROOT}/StructureSet/DICOM/Wrong_Data_Struct_file.dicom"
${REFERENCE_FILE} "${TEST_DATA_ROOT}/Dose/DICOM/Wrong_Reference_file.dicom" "Rueckenmark" "blabla")
ADD_TEST(VoxelizerToolVoxelizerAllStructsTest ${VoxelizerTool_TESTS} VoxelizerToolVoxelizerAllStructsTest
"${VOXELIZERTOOL_EXE}" ${TEST_DATA} ${STRUCT_FILE} ${REFERENCE_FILE} )
ADD_TEST(VoxelizerToolVoxelizerStructTest ${VoxelizerTool_TESTS} VoxelizerToolVoxelizerStructTest
"${VOXELIZERTOOL_EXE}" ${TEST_DATA} "${TEST_DATA_ROOT}/StructureSet/ITK/singleFiles/rtss.dcm" "${TEST_DATA_ROOT}/StructureSet/ITK/singleFiles/ct.0" )
ADD_TEST(VoxelizerToolDifferentCommandsTest ${VoxelizerTool_TESTS} VoxelizerToolDifferentCommandsTest
"${VOXELIZERTOOL_EXE}" ${TEST_DATA} ${STRUCT_FILE} ${REFERENCE_FILE})
ADD_TEST(VoxelizerToolVoxelValueTest ${VoxelizerTool_TESTS} VoxelizerToolVoxelValue
"${VOXELIZERTOOL_EXE}" ${TEST_DATA} ${STRUCT_FILE} ${REFERENCE_FILE} "Leber")
RTTB_CREATE_APPLICATION_TESTS(VoxelizerTool PACKAGE_DEPENDS Litmus ITK BoostBinaries RTTBData)
diff --git a/testing/core/CMakeLists.txt b/testing/core/CMakeLists.txt
index c2017ab..77b7708 100644
--- a/testing/core/CMakeLists.txt
+++ b/testing/core/CMakeLists.txt
@@ -1,29 +1,29 @@
#-----------------------------------------------------------------------------
# Setup the system information test. Write out some basic failsafe
# information in case the test doesn't run.
#-----------------------------------------------------------------------------
-SET(CORE_TESTS ${EXECUTABLE_OUTPUT_PATH}/rttbCoreTests)
-SET(CORE_HEADER_TEST ${EXECUTABLE_OUTPUT_PATH}/rttbCoreHeaderTest)
+SET(CORE_TESTS ${EXECUTABLE_OUTPUT_PATH}/${RTToolbox_PREFIX}CoreTests)
+SET(CORE_HEADER_TEST ${EXECUTABLE_OUTPUT_PATH}/${RTToolbox_PREFIX}CoreHeaderTest)
SET(TEMP ${RTTBTesting_BINARY_DIR}/temporary)
#-----------------------------------------------------------------------------
ADD_TEST(GeometricInfoTest ${CORE_TESTS} GeometricInfoTest)
ADD_TEST(MaskVoxelTest ${CORE_TESTS} MaskVoxelTest)
ADD_TEST(GenericDoseIteratorTest ${CORE_TESTS} GenericDoseIteratorTest)
ADD_TEST(GenericMaskedDoseIteratorTest ${CORE_TESTS} GenericMaskedDoseIteratorTest)
ADD_TEST(DVHCalculatorTest ${CORE_TESTS} DVHCalculatorTest)
ADD_TEST(DVHTest ${CORE_TESTS} DVHTest)
ADD_TEST(DVHSetTest ${CORE_TESTS} DVHSetTest)
ADD_TEST(StructureTest ${CORE_TESTS} StructureTest)
ADD_TEST(StrVectorStructureSetGeneratorTest ${CORE_TESTS} StrVectorStructureSetGeneratorTest)
ADD_TEST(StructureSetTest ${CORE_TESTS} StructureSetTest)
ADD_TEST(BaseTypeTest ${CORE_TESTS} BaseTypeTest)
RTTB_CREATE_TEST_MODULE(Core DEPENDS RTTBCore PACKAGE_DEPENDS Boost Litmus)
diff --git a/testing/examples/CMakeLists.txt b/testing/examples/CMakeLists.txt
index 0ebf7ee..9a19d08 100644
--- a/testing/examples/CMakeLists.txt
+++ b/testing/examples/CMakeLists.txt
@@ -1,26 +1,26 @@
#-----------------------------------------------------------------------------
# Setup the system information test. Write out some basic failsafe
# information in case the test doesn't run.
#-----------------------------------------------------------------------------
-SET(CORE_TEST_EXAMPLES ${EXECUTABLE_OUTPUT_PATH}/rttbExamplesTests)
+SET(CORE_TEST_EXAMPLES ${EXECUTABLE_OUTPUT_PATH}/${RTToolbox_PREFIX}ExamplesTests)
SET(TEMP ${RTTBTesting_BINARY_DIR}/Temporary)
#-----------------------------------------------------------------------------
ADD_TEST(RTBioModelExampleTest ${CORE_TEST_EXAMPLES} RTBioModelExampleTest
"${TEST_DATA_ROOT}/DVH/XML/dvh_PTV_HIT.xml" "${TEST_DATA_ROOT}/DVH/XML/dvh_test_HT1.xml"
"${TEST_DATA_ROOT}/DVH/XML/dvh_test_HT2.xml" "${TEST_DATA_ROOT}/DVH/XML/dvh_test_HT3.xml"
"${TEST_DATA_ROOT}/DVH/XML/dvh_test_TV.xml" "${TEST_DATA_ROOT}/DVH/XML/dvh_virtuos_diff_trunk6.xml"
"${TEST_DATA_ROOT}/DVH/XML/dvh_virtuos_diff_trunk8.xml")
ADD_TEST(RTDoseIndexTest ${CORE_TEST_EXAMPLES} RTDoseIndexTest
"${TEST_DATA_ROOT}/DVH/XML/dvh_test_TV.xml" "${TEST_DATA_ROOT}/DVH/XML/dvh_test_HT1.xml"
"${TEST_DATA_ROOT}/DVH/XML/dvh_test_HT2.xml" "${TEST_DATA_ROOT}/DVH/XML/dvh_test_HT3.xml")
ADD_TEST(RTDoseStatisticsDicomTest ${CORE_TEST_EXAMPLES} RTDoseStatisticsDicomTest
"${TEST_DATA_ROOT}/Dose/DICOM/ConstantTwo_withDoseGridScaling.dcm")
ADD_TEST(RTDVHTest ${CORE_TEST_EXAMPLES} RTDVHTest "${TEST_DATA_ROOT}/DVH/XML/dvh_test.xml")
ADD_TEST(RTBioModelScatterPlotExampleTest ${CORE_TEST_EXAMPLES} RTBioModelScatterPlotExampleTest
"${TEST_DATA_ROOT}/DVH/XML/dvh_PTV_HIT.xml" "${TEST_DATA_ROOT}/DVH/XML/dvh_test_HT1.xml" "${TEST_DATA_ROOT}/DVH/XML/dvh_test_TV.xml")
RTTB_CREATE_TEST_MODULE(Examples DEPENDS RTTBCore RTTBAlgorithms RTTBMask RTTBIndices RTTBDicomIO RTTBITKIO RTTBOtherIO RTTBModels PACKAGE_DEPENDS Litmus RTTBData)
diff --git a/testing/interpolation/CMakeLists.txt b/testing/interpolation/CMakeLists.txt
index a6712ea..d9e4fb9 100644
--- a/testing/interpolation/CMakeLists.txt
+++ b/testing/interpolation/CMakeLists.txt
@@ -1,24 +1,24 @@
#-----------------------------------------------------------------------------
# Setup the system information test. Write out some basic failsafe
# information in case the test doesn't run.
#-----------------------------------------------------------------------------
-SET(INTERPOLATION_TESTS ${EXECUTABLE_OUTPUT_PATH}/rttbInterpolationTests)
+SET(INTERPOLATION_TESTS ${EXECUTABLE_OUTPUT_PATH}/${RTToolbox_PREFIX}InterpolationTests)
SET(TEMP ${RTTBTesting_BINARY_DIR}/temporary)
#-----------------------------------------------------------------------------
ADD_TEST(SimpleMappableDoseAccessorTest ${INTERPOLATION_TESTS} SimpleMappableDoseAccessorTest "${TEST_DATA_ROOT}/Dose/DICOM/ConstantTwo.dcm" "${TEST_DATA_ROOT}/Dose/DICOM/LinearIncreaseX.dcm")
ADD_TEST(RosuMappableDoseAccessorTest ${INTERPOLATION_TESTS} RosuMappableDoseAccessorTest "${TEST_DATA_ROOT}/Dose/DICOM/ConstantTwo.dcm" "${TEST_DATA_ROOT}/Dose/DICOM/LinearIncreaseX.dcm")
ADD_TEST(InterpolationTest ${INTERPOLATION_TESTS} InterpolationTest "${TEST_DATA_ROOT}/Dose/DICOM/ConstantTwo.dcm" "${TEST_DATA_ROOT}/Dose/DICOM/LinearIncreaseX.dcm")
ADD_SUBDIRECTORY(InterpolationITKTransformation)
IF(BUILD_InterpolationMatchPointTransformation)
ADD_SUBDIRECTORY(InterpolationMatchPointTransformation)
ENDIF(BUILD_InterpolationMatchPointTransformation)
RTTB_CREATE_TEST_MODULE(Interpolation DEPENDS RTTBInterpolation RTTBDicomIO PACKAGE_DEPENDS Litmus RTTBData)
diff --git a/testing/interpolation/InterpolationITKTransformation/CMakeLists.txt b/testing/interpolation/InterpolationITKTransformation/CMakeLists.txt
index 2cb73ef..1e15646 100644
--- a/testing/interpolation/InterpolationITKTransformation/CMakeLists.txt
+++ b/testing/interpolation/InterpolationITKTransformation/CMakeLists.txt
@@ -1,14 +1,14 @@
#-----------------------------------------------------------------------------
# Setup the system information test. Write out some basic failsafe
# information in case the test doesn't run.
#-----------------------------------------------------------------------------
-SET(INTERPOLATION_ITK_TRANSFORMATION_TESTS ${EXECUTABLE_OUTPUT_PATH}/rttbInterpolationITKTransformationTests)
+SET(INTERPOLATION_ITK_TRANSFORMATION_TESTS ${EXECUTABLE_OUTPUT_PATH}/${RTToolbox_PREFIX}InterpolationITKTransformationTests)
SET(TEMP ${RTTBTesting_BINARY_DIR}/temporary)
#-----------------------------------------------------------------------------
ADD_TEST(SimpleMappableDoseAccessorWithITKTest ${INTERPOLATION_ITK_TRANSFORMATION_TESTS} SimpleMappableDoseAccessorWithITKTest "${TEST_DATA_ROOT}/Dose/DICOM/ConstantTwo.dcm" "${TEST_DATA_ROOT}/Dose/DICOM/LinearIncreaseX.dcm")
RTTB_CREATE_TEST_MODULE(InterpolationITKTransformation DEPENDS RTTBInterpolation RTTBInterpolationITKTransformation RTTBDicomIO PACKAGE_DEPENDS Litmus RTTBData ITK)
diff --git a/testing/interpolation/InterpolationMatchPointTransformation/CMakeLists.txt b/testing/interpolation/InterpolationMatchPointTransformation/CMakeLists.txt
index 7162d2d..dd0e0a7 100644
--- a/testing/interpolation/InterpolationMatchPointTransformation/CMakeLists.txt
+++ b/testing/interpolation/InterpolationMatchPointTransformation/CMakeLists.txt
@@ -1,14 +1,14 @@
#-----------------------------------------------------------------------------
# Setup the system information test. Write out some basic failsafe
# information in case the test doesn't run.
#-----------------------------------------------------------------------------
-SET(INTERPOLATION_MP_TRANSFORMATION_TESTS ${EXECUTABLE_OUTPUT_PATH}/rttbInterpolationMPTransformationTests)
+SET(INTERPOLATION_MP_TRANSFORMATION_TESTS ${EXECUTABLE_OUTPUT_PATH}/${RTToolbox_PREFIX}InterpolationMPTransformationTests)
SET(TEMP ${RTTBTesting_BINARY_DIR}/temporary)
#-----------------------------------------------------------------------------
ADD_TEST(SimpleMappableDoseAccessorWithMatchPointTest ${INTERPOLATION_MP_TRANSFORMATION_TESTS} SimpleMappableDoseAccessorWithMatchPointTest "${TEST_DATA_ROOT}/Dose/DICOM/ConstantTwo.dcm" "${TEST_DATA_ROOT}/Dose/DICOM/LinearIncreaseX.dcm")
RTTB_CREATE_TEST_MODULE(InterpolationMPTransformation DEPENDS RTTBInterpolation RTTBInterpolationMatchPointTransformation RTTBDicomIO PACKAGE_DEPENDS Litmus MatchPoint RTTBData)
diff --git a/testing/io/dicom/CMakeLists.txt b/testing/io/dicom/CMakeLists.txt
index 85bca60..022e5f1 100644
--- a/testing/io/dicom/CMakeLists.txt
+++ b/testing/io/dicom/CMakeLists.txt
@@ -1,38 +1,38 @@
#-----------------------------------------------------------------------------
# Setup the system information test. Write out some basic failsafe
# information in case the test doesn't run.
#-----------------------------------------------------------------------------
-SET(DICOMIO_TEST ${EXECUTABLE_OUTPUT_PATH}/rttbDicomIOTests)
+SET(DICOMIO_TEST ${EXECUTABLE_OUTPUT_PATH}/${RTToolbox_PREFIX}DicomIOTests)
SET(TEMP ${RTTBTesting_BINARY_DIR}/temporary)
#-----------------------------------------------------------------------------
ADD_TEST(DicomDoseAccessorConverterTest ${DICOMIO_TEST} DicomDoseAccessorConverterTest
"${TEST_DATA_ROOT}/Dose/DICOM/LinearIncrease3D.dcm"
"${TEMP}/dose_w.dcm" )
ADD_TEST(DicomDoseAccessorGeneratorTest ${DICOMIO_TEST} DicomDoseAccessorGeneratorTest
"${TEST_DATA_ROOT}/Dose/DICOM/ConstantTwo.dcm"
"${TEST_DATA_ROOT}/Dose/DICOM/ConstantFifty.dcm" "${TEST_DATA_ROOT}/Dose/DICOM/LinearIncrease3D.dcm" )
ADD_TEST(DicomFileReaderHelperTest ${DICOMIO_TEST} DicomFileReaderHelperTest
"${TEST_DATA_ROOT}/Dose/DICOM/Helax/"
"${TEST_DATA_ROOT}/Dose/DICOM/Helax/____mm_1_1.2.276.0.28.19.977891832855880720695789165493875543457754809556.dcm"
"${TEST_DATA_ROOT}/Dose/DICOM/Helax/____mm__1.2.276.0.28.19.142087956198378746376227895256244905653791675016.dcm"
)
ADD_TEST(DicomIOTest ${DICOMIO_TEST} DicomIOTest
"${TEST_DATA_ROOT}/StructureSet/DICOM/RS1.3.6.1.4.1.2452.6.841242143.1311652612.1170940299.4217870819.dcm" "${TEST_DATA_ROOT}/Dose/DICOM/ConstantTwo.dcm"
"${TEST_DATA_ROOT}/Dose/DICOM/ConstantFifty.dcm" "${TEST_DATA_ROOT}/Dose/DICOM/LinearIncrease3D.dcm" "${TEST_DATA_ROOT}/Dose/DICOM/dicompylerTestDose.dcm"
"${TEST_DATA_ROOT}/Dose/DICOM/InhomogeneousGrid.dcm" )
ADD_TEST(DicomStructureSetGeneratorTest ${DICOMIO_TEST} DicomStructureSetGeneratorTest
"${TEST_DATA_ROOT}/StructureSet/DICOM/RS1.3.6.1.4.1.2452.6.841242143.1311652612.1170940299.4217870819.dcm" )
RTTB_CREATE_TEST_MODULE(DicomIO DEPENDS RTTBDicomIO PACKAGE_DEPENDS Boost Litmus RTTBData DCMTK)
diff --git a/testing/io/helax/CMakeLists.txt b/testing/io/helax/CMakeLists.txt
index a516d7a..8c09b8b 100644
--- a/testing/io/helax/CMakeLists.txt
+++ b/testing/io/helax/CMakeLists.txt
@@ -1,23 +1,23 @@
#-----------------------------------------------------------------------------
# Setup the system information test. Write out some basic failsafe
# information in case the test doesn't run.
#-----------------------------------------------------------------------------
-SET(HelaxIO_TEST ${EXECUTABLE_OUTPUT_PATH}/rttbHelaxIOTests)
+SET(HelaxIO_TEST ${EXECUTABLE_OUTPUT_PATH}/${RTToolbox_PREFIX}HelaxIOTests)
SET(TEMP ${RTTBTesting_BINARY_DIR}/temporary)
#-----------------------------------------------------------------------------
ADD_TEST(DicomHelaxDoseAccessorGeneratorTest ${HelaxIO_TEST} DicomHelaxDoseAccessorGeneratorTest
"${TEST_DATA_ROOT}/Dose/DICOM/Helax/" "${TEST_DATA_ROOT}/Dose/DICOM/ConstantTwo.dcm"
"${TEST_DATA_ROOT}/Dose/DICOM/ConstantFifty.dcm" "${TEST_DATA_ROOT}/Dose/DICOM/LinearIncrease3D.dcm"
)
ADD_TEST(DicomHelaxIOTest ${HelaxIO_TEST} DicomHelaxIOTest
"${TEST_DATA_ROOT}/Dose/DICOM/Helax/"
)
RTTB_CREATE_TEST_MODULE(HelaxIO DEPENDS RTTBHelaxIO RTTBDicomIO PACKAGE_DEPENDS BoostBinaries Litmus RTTBData DCMTK)
diff --git a/testing/io/itk/CMakeLists.txt b/testing/io/itk/CMakeLists.txt
index 934afa9..34e0113 100644
--- a/testing/io/itk/CMakeLists.txt
+++ b/testing/io/itk/CMakeLists.txt
@@ -1,27 +1,27 @@
#-----------------------------------------------------------------------------
# Setup the system information test. Write out some basic failsafe
# information in case the test doesn't run.
#-----------------------------------------------------------------------------
-SET(ITKIO_TEST ${EXECUTABLE_OUTPUT_PATH}/rttbITKIOTests)
+SET(ITKIO_TEST ${EXECUTABLE_OUTPUT_PATH}/${RTToolbox_PREFIX}ITKIOTests)
SET(TEMP ${RTTBTesting_BINARY_DIR}/temporary)
#-----------------------------------------------------------------------------
ADD_TEST(ITKDoseAccessorGeneratorTest ${ITKIO_TEST} ITKDoseAccessorGeneratorTest "${TEST_DATA_ROOT}/Images/ITK/MatchPointLogoSmall.nrrd" "${TEST_DATA_ROOT}/Images/ITK/doseAccReference.nrrd" "${TEST_DATA_ROOT}/Images/ITK/emptyImageVector.png" "${TEST_DATA_ROOT}/Images/ITK/Png2D-bw.png")
ADD_TEST(ITKIOTest ${ITKIO_TEST} ITKIOTest "${TEST_DATA_ROOT}/Images/ITK/MatchPointLogoSmall.nrrd" "${TEST_DATA_ROOT}/StructureSet/ITK/voxelizedNodes.nrrd")
ADD_TEST(ITKDoseAccessorConverterTest ${ITKIO_TEST} ITKDoseAccessorConverterTest "${TEST_DATA_ROOT}/Dose/DICOM/ConstantTwo.dcm" "${TEST_DATA_ROOT}/Images/ITK/MatchPointLogoSmall.nrrd" )
ADD_TEST(ITKBioModelAccessorConverterTest ${ITKIO_TEST} ITKBioModelAccessorConverterTest "${TEST_DATA_ROOT}/Dose/DICOM/ConstantTwo.dcm")
ADD_TEST(ITKMaskAccessorGeneratorTest ${ITKIO_TEST} ITKMaskAccessorGeneratorTest "${TEST_DATA_ROOT}/StructureSet/ITK/Nodes.nrrd")
ADD_TEST(ITKMaskAccessorConverterTest ${ITKIO_TEST} ITKMaskAccessorConverterTest "${TEST_DATA_ROOT}/StructureSet/DICOM/RS1.3.6.1.4.1.2452.6.841242143.1311652612.1170940299.4217870819.dcm"
"${TEST_DATA_ROOT}/Dose/DICOM/ConstantTwo.dcm" "${TEST_DATA_ROOT}/StructureSet/ITK/Nodes.nrrd")
RTTB_CREATE_TEST_MODULE(ITKIO DEPENDS RTTBITKIO RTTBDicomIO RTTBMask RTTBModels PACKAGE_DEPENDS Boost Litmus ITK DCMTK RTTBData)
diff --git a/testing/io/models/CMakeLists.txt b/testing/io/models/CMakeLists.txt
index 69c4e24..ab4adad 100644
--- a/testing/io/models/CMakeLists.txt
+++ b/testing/io/models/CMakeLists.txt
@@ -1,16 +1,16 @@
#-----------------------------------------------------------------------------
# Setup the system information test. Write out some basic failsafe
# information in case the test doesn't run.
#-----------------------------------------------------------------------------
-SET(MODELSIO_TEST ${EXECUTABLE_OUTPUT_PATH}/rttbModelsIOTests)
+SET(MODELSIO_TEST ${EXECUTABLE_OUTPUT_PATH}/${RTToolbox_PREFIX}ModelsIOTests)
SET(TEMP ${RTTBTesting_BINARY_DIR}/temporary)
#-----------------------------------------------------------------------------
ADD_TEST(ModelsIOTest ${MODELSIO_TEST} ModelsIOTest "${TEST_DATA_ROOT}/BioModel/XML/referenceBioModeltcpleqIOTest.xml" "${TEST_DATA_ROOT}/BioModel/XML/referenceBioModelntcplkIOTest.xml" )
RTTB_CREATE_TEST_MODULE(ModelsIO DEPENDS RTTBModelsIO RTTBModels PACKAGE_DEPENDS Boost Litmus RTTBData)
diff --git a/testing/io/other/CMakeLists.txt b/testing/io/other/CMakeLists.txt
index fbf7349..add8322 100644
--- a/testing/io/other/CMakeLists.txt
+++ b/testing/io/other/CMakeLists.txt
@@ -1,17 +1,17 @@
#-----------------------------------------------------------------------------
# Setup the system information test. Write out some basic failsafe
# information in case the test doesn't run.
#-----------------------------------------------------------------------------
-SET(OTHERIO_TEST ${EXECUTABLE_OUTPUT_PATH}/rttbOtherIOTests)
+SET(OTHERIO_TEST ${EXECUTABLE_OUTPUT_PATH}/${RTToolbox_PREFIX}OtherIOTests)
SET(TEMP ${RTTBTesting_BINARY_DIR}/temporary)
#-----------------------------------------------------------------------------
ADD_TEST(DoseStatisticsIOTest ${OTHERIO_TEST} DoseStatisticsIOTest)
ADD_TEST(DVHXMLIOTest ${OTHERIO_TEST} DVHXMLIOTest)
RTTB_CREATE_TEST_MODULE(OtherIO DEPENDS RTTBOtherIO PACKAGE_DEPENDS Boost Litmus RTTBData)
diff --git a/testing/masks/CMakeLists.txt b/testing/masks/CMakeLists.txt
index 65e4c24..b92df68 100644
--- a/testing/masks/CMakeLists.txt
+++ b/testing/masks/CMakeLists.txt
@@ -1,20 +1,20 @@
#-----------------------------------------------------------------------------
# Setup the system information test. Write out some basic failsafe
# information in case the test doesn't run.
#-----------------------------------------------------------------------------
-SET(Boost_Mask_TESTS ${EXECUTABLE_OUTPUT_PATH}/rttbBoostMaskTests)
+SET(Boost_Mask_TESTS ${EXECUTABLE_OUTPUT_PATH}/${RTToolbox_PREFIX}MaskTests)
SET(TEMP ${RTTBTesting_BINARY_DIR}/temporary)
#-----------------------------------------------------------------------------
ADD_TEST(BoostMaskTest ${Boost_Mask_TESTS} BoostMaskTest)
RTTB_CREATE_TEST_MODULE(Mask DEPENDS RTTBDicomIO RTTBMask PACKAGE_DEPENDS BoostBinaries Litmus DCMTK)
IF (CMAKE_COMPILER_IS_GNUCC)
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fext-numeric-literals")
ENDIF()
\ No newline at end of file
diff --git a/testing/models/CMakeLists.txt b/testing/models/CMakeLists.txt
index 1694542..8aff449 100644
--- a/testing/models/CMakeLists.txt
+++ b/testing/models/CMakeLists.txt
@@ -1,19 +1,19 @@
#-----------------------------------------------------------------------------
# Setup the system information test. Write out some basic failsafe
# information in case the test doesn't run.
#-----------------------------------------------------------------------------
-SET(MODELS_TESTS ${EXECUTABLE_OUTPUT_PATH}/rttbModelTests)
-SET(MODELS_HEADER_TEST ${EXECUTABLE_OUTPUT_PATH}/rttbModelsHeaderTest)
+SET(MODELS_TESTS ${EXECUTABLE_OUTPUT_PATH}/${RTToolbox_PREFIX}ModelTests)
+SET(MODELS_HEADER_TEST ${EXECUTABLE_OUTPUT_PATH}/${RTToolbox_PREFIX}ModelsHeaderTest)
SET(TEMP ${RTTBTesting_BINARY_DIR}/temporary)
#-----------------------------------------------------------------------------
ADD_TEST(BioModelTest ${MODELS_TESTS} BioModelTest)
ADD_TEST(BioModelScatterPlotTest ${MODELS_TESTS} BioModelScatterPlotTest)
ADD_TEST(DvhBasedModelsTest ${MODELS_TESTS} DvhBasedModelsTest)
ADD_TEST(LQModelAccessorTest ${MODELS_TESTS} LQModelAccessorTest "${TEST_DATA_ROOT}/Dose/DICOM/ConstantTwo.dcm" "${TEST_DATA_ROOT}/Dose/DICOM/LinearIncreaseX.dcm")
RTTB_CREATE_TEST_MODULE(Model DEPENDS RTTBModels RTTBDicomIO PACKAGE_DEPENDS Boost Litmus DCMTK RTTBData)
diff --git a/testing/validation/CMakeLists.txt b/testing/validation/CMakeLists.txt
index 73c758b..c20b2c9 100644
--- a/testing/validation/CMakeLists.txt
+++ b/testing/validation/CMakeLists.txt
@@ -1,28 +1,28 @@
#-----------------------------------------------------------------------------
# Setup the system information test. Write out some basic failsafe
# information in case the test doesn't run.
#-----------------------------------------------------------------------------
-SET(CORE_TEST_VALIDATION ${EXECUTABLE_OUTPUT_PATH}/rttbValidationTests)
+SET(CORE_TEST_VALIDATION ${EXECUTABLE_OUTPUT_PATH}/${RTToolbox_PREFIX}ValidationTests)
SET(TEMP ${RTTBTesting_BINARY_DIR}/Temporary)
#-----------------------------------------------------------------------------
ADD_TEST(VoxelizationDVHComparisonTest ${CORE_TEST_VALIDATION} VoxelizationDVHComparisonTest
"${TEST_DATA_ROOT}/StructureSet/DICOM/RS1.3.6.1.4.1.2452.6.841242143.1311652612.1170940299.4217870819.dcm" "${TEST_DATA_ROOT}/Dose/DICOM/LinearIncrease3D.dcm"
"${TEST_DATA_ROOT}/DVH/XML/1.3.6.1.4.1.2452.6.2037938358.1234393433.864109958.30410275/OTBMask/"
"${TEST_DATA_ROOT}/DVH/XML/1.3.6.1.4.1.2452.6.2037938358.1234393433.864109958.30410275/BoostMask_LEGACY/"
"${RTTBTesting_BINARY_DIR}/validation/1.3.6.1.4.1.2452.6.2037938358.1234393433.864109958.30410275/BoostMask/")
ADD_TEST(VoxelizationValidationTest ${CORE_TEST_VALIDATION} VoxelizationValidationTest
"${TEST_DATA_ROOT}/StructureSet/DICOM/RS1.3.6.1.4.1.2452.6.841242143.1311652612.1170940299.4217870819.dcm"
"${TEST_DATA_ROOT}/Dose/DICOM/LinearIncrease3D.dcm"
"${TEMP}/Mask/1.3.6.1.4.1.2452.6.2037938358.1234393433.864109958.30410275/BoostMask/"
"${TEST_DATA_ROOT}/Mask/1.3.6.1.4.1.2452.6.2037938358.1234393433.864109958.30410275/OTBMask/")
RTTB_CREATE_TEST_MODULE(Validation DEPENDS RTTBCore RTTBMask RTTBDicomIO RTTBITKIO RTTBOtherIO PACKAGE_DEPENDS Litmus ITK RTTBData)
IF (CMAKE_COMPILER_IS_GNUCC)
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fext-numeric-literals")
ENDIF()