diff --git a/apps/BioModelCalc/BioModelCalc.cpp b/apps/BioModelCalc/BioModelCalc.cpp
index 8bbd785..2fcef63 100644
--- a/apps/BioModelCalc/BioModelCalc.cpp
+++ b/apps/BioModelCalc/BioModelCalc.cpp
@@ -1,149 +1,143 @@
// -----------------------------------------------------------------------
// 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.
//
//------------------------------------------------------------------------
#include "BioModelCalcApplicationData.h"
#include "BioModelCalcHelper.h"
#include "BioModelCmdLineParser.h"
-
-#include "boost/shared_ptr.hpp"
#include "boost/make_shared.hpp"
-#include "RTToolboxConfigure.h"
-
-#include "rttbException.h"
-
#include "rttbDoseLoader.cpp"
int main(int argc, const char** argv)
{
int result = 0;
rttb::apps::bioModelCalc::ApplicationData appData;
boost::shared_ptr<rttb::apps::bioModelCalc::BioModelCmdLineParser> argParser;
const std::string appCategory = "RT-Toolbox App";
const std::string appName = "BioModelCalc";
const std::string appDesc = "An App to calculate the Linear quadratic (LQ) BioModel. The GUI for this app is currently under development and in an experimental state.";
const std::string appContributor = "SIDT@DKFZ";
const std::string appVersion = RTTB_FULL_VERSION_STRING;
try
{
argParser = boost::make_shared<rttb::apps::bioModelCalc::BioModelCmdLineParser>(argc, argv, appName,
appVersion, appDesc, appContributor, appCategory);
}
catch (const std::exception& e)
{
std::cerr << e.what() << std::endl;
return -1;
}
// This is vital. The application needs to exit if the "help" or "version" parameter is set
// because this means the other parameters won't be parsed.
if (argParser->isSet(argParser->OPTION_HELP) || argParser->isSet(argParser->OPTION_VERSION) || argParser->isSet(argParser->OPTION_XML))
{
return 0;
}
rttb::apps::bioModelCalc::populateAppData(argParser, appData);
std::cout << std::endl << "*******************************************" << std::endl;
std::cout << "Dose file: " << appData._doseFileName << std::endl;
std::cout << "Bio model output file: " << appData._outputFileName << std::endl;
std::cout << "Model: " << appData._model << std::endl;
std::cout << "Model parameters: ";
for (size_t i = 0; i < appData._modelParameters.size(); i++)
{
if (i != 0)
{
std::cout << ", ";
}
std::cout << appData._modelParameters.at(i);
}
for (size_t i = 0; i < appData._modelParameterMapsFilename.size(); i++)
{
if (i != 0)
{
std::cout << ", ";
}
std::cout << appData._modelParameterMapsFilename.at(i);
}
std::cout << std::endl;
std::cout << "Dose scaling: " << appData._doseScaling << std::endl;
if (argParser->isSet(argParser->OPTION_N_FRACTIONS)){
std::cout << "#Fractions: " << appData._nFractions << std::endl;
}
std::cout << std::endl;
std::cout << std::endl << "read dose file... ";
try
{
appData._dose = rttb::io::utils::loadDose(appData._doseFileName, appData._doseLoadStyle);
for (const auto& filename : appData._modelParameterMapsFilename){
appData._modelParameterMaps.push_front(rttb::io::utils::loadDose(filename, appData._parameterMapsLoadStyle));
}
std::cout << "done." << std::endl;
}
catch (rttb::core::Exception& e)
{
std::cerr << "RTTB Error!!!" << std::endl;
std::cerr << e.what() << std::endl;
return 1;
}
catch (const std::exception& e)
{
std::cerr << "Error!!!" << std::endl;
std::cerr << e.what() << std::endl;
return 1;
}
catch (...)
{
std::cerr << "Error!!! unknown error while reading input image." << std::endl;
return 1;
}
try
{
rttb::apps::bioModelCalc::processData(appData);
}
catch (rttb::core::Exception& e)
{
std::cerr << "RTTB Error!!!" << std::endl;
std::cerr << e.what() << std::endl;
return 2;
}
catch (std::exception& e)
{
std::cerr << "Error!!!" << std::endl;
std::cerr << e.what() << std::endl;
return 2;
}
catch (...)
{
std::cerr << "Error!!! unknown error while calculating the bioModel or writing the image." <<
std::endl;
return 2;
}
return result;
}
diff --git a/apps/BioModelCalc/BioModelCalcHelper.cpp b/apps/BioModelCalc/BioModelCalcHelper.cpp
index bfe7da7..be6ed18 100644
--- a/apps/BioModelCalc/BioModelCalcHelper.cpp
+++ b/apps/BioModelCalc/BioModelCalcHelper.cpp
@@ -1,89 +1,86 @@
// -----------------------------------------------------------------------
// 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.
//
//------------------------------------------------------------------------
#include "BioModelCalcHelper.h"
-
+#include "BioModelCalcApplicationData.h"
#include "boost/make_shared.hpp"
-#include "boost/shared_ptr.hpp"
#include "rttbExceptionMacros.h"
-
-#include "BioModelCalcApplicationData.h"
-#include "rttbITKImageAccessorConverter.h"
#include "rttbImageWriter.h"
+#include "rttbITKImageAccessorConverter.h"
#include "rttbLQModelAccessor.h"
void
rttb::apps::bioModelCalc::processData(rttb::apps::bioModelCalc::ApplicationData& appData)
{
rttb::core::DoseAccessorInterface::Pointer outputAccessor;
std::cout << std::endl << "generate biomodel... ";
rttb::core::AccessorInterface::Pointer bioModelAccessor;
if (!appData._modelParameters.empty()){
bioModelAccessor = generateBioModel(appData._dose, appData._model, appData._modelParameters, appData._nFractions,
appData._doseScaling);
}
else {
bioModelAccessor = generateBioModelWithMaps(appData._dose, appData._model, appData._modelParameterMaps, appData._nFractions,
appData._doseScaling);
}
std::cout << "done." << std::endl;
std::cout << std::endl << "generate output image... ";
io::itk::ITKImageAccessorConverter converter(bioModelAccessor);
converter.setFailOnInvalidIDs(true);
converter.process();
io::itk::ITKImageAccessorConverter::ITKImageType::Pointer itkImage = converter.getITKImage();
std::cout << "done." << std::endl;
std::cout << std::endl << "write output image... ";
io::itk::ImageWriter writer(appData._outputFileName, itkImage.GetPointer());
writer.writeFile();
std::cout << "done." << std::endl;
}
rttb::core::AccessorInterface::Pointer rttb::apps::bioModelCalc::generateBioModel(
rttb::core::DoseAccessorInterface::Pointer dose, const std::string& model,
const std::vector<double>& modelParameters, unsigned int nFractions, double doseScaling)
{
if (model == "LQ")
{
return boost::make_shared<rttb::models::LQModelAccessor>(dose, modelParameters.at(0),
modelParameters.at(1), nFractions,
doseScaling);
}
else
{
rttbDefaultExceptionStaticMacro( << "Unknown model selected. Cannot load data. Selected model: "
<< model);
}
}
rttb::core::AccessorInterface::Pointer rttb::apps::bioModelCalc::generateBioModelWithMaps(
rttb::core::DoseAccessorInterface::Pointer dose, const std::string& model,
const std::deque<rttb::core::AccessorInterface::Pointer>& modelParameterMaps, unsigned int nFractions, double doseScaling)
{
if (model == "LQ")
{
return boost::make_shared<rttb::models::LQModelAccessor>(dose, modelParameterMaps.at(0),
modelParameterMaps.at(1), nFractions, doseScaling);
}
else
{
rttbDefaultExceptionStaticMacro(<< "Unknown model selected. Cannot load data. Selected model: "
<< model);
}
}
diff --git a/apps/DoseAcc/DoseAcc.cpp b/apps/DoseAcc/DoseAcc.cpp
index 7f60cd5..de9d7ce 100644
--- a/apps/DoseAcc/DoseAcc.cpp
+++ b/apps/DoseAcc/DoseAcc.cpp
@@ -1,173 +1,169 @@
// -----------------------------------------------------------------------
// 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.
//
//------------------------------------------------------------------------
#include "DoseAccApplicationData.h"
#include "DoseAccHelper.h"
#include "DoseAccCmdLineParser.h"
-
-#include "boost/shared_ptr.hpp"
#include "boost/make_shared.hpp"
-#include "RTToolboxConfigure.h"
-
#include "rttbDoseLoader.cpp"
int main(int argc, const char** argv)
{
int result = 0;
rttb::apps::doseAcc::ApplicationData appData;
boost::shared_ptr<rttb::apps::doseAcc::DoseAccCmdLineParser> argParser;
const std::string appCategory = "RT-Toolbox App";
const std::string appName = "DoseAcc";
const std::string appDesc = "An App to accumulate two doses. The GUI for this app is currently under development and in an experimental state.";
const std::string appContributor = "SIDT@DKFZ";
const std::string appVersion = RTTB_FULL_VERSION_STRING;
try
{
argParser = boost::make_shared<rttb::apps::doseAcc::DoseAccCmdLineParser>(argc, argv, appName,
appVersion, appDesc, appContributor, appCategory);
}
catch (const std::exception& e)
{
std::cerr << e.what() << std::endl;
return 5;
}
// This is vital. The application needs to exit if the "help" or "version" parameter is set
// because this means the other parameters won't be parsed.
if (argParser->isSet(argParser->OPTION_HELP) || argParser->isSet(argParser->OPTION_VERSION) || argParser->isSet(argParser->OPTION_XML))
{
return 0;
}
rttb::apps::doseAcc::populateAppData(argParser, appData);
std::cout << std::endl << "*******************************************" << std::endl;
std::cout << "Dose 1 file: " << appData._dose1FileName << std::endl;
std::cout << "Dose 2 file: " << appData._dose2FileName << std::endl;
std::cout << "Dose output file: " << appData._outputFileName << std::endl;
if (!(appData._regFileName.empty()))
{
std::cout << "Registration file: " << appData._regFileName << std::endl;
}
std::cout << "Dose 1 weight: " << appData._weightDose1 << std::endl;
std::cout << "Dose 2 weight: " << appData._weightDose2 << std::endl;
std::cout << "Operator: " << appData._operator << std::endl;
std::cout << std::endl << "read dose file... ";
try
{
appData._dose1 = rttb::io::utils::loadDose(appData._dose1FileName, appData._dose1LoadStyle);
}
catch (::itk::ExceptionObject& e)
{
std::cerr << "Error!!!" << std::endl;
std::cerr << e << std::endl;
return 4;
}
catch (std::exception& e)
{
std::cerr << "Error!!!" << std::endl;
std::cerr << e.what() << std::endl;
return 4;
}
catch (...)
{
std::cerr << "Error!!! unknown error while reading input image." << std::endl;
return 4;
}
try
{
appData._dose2 = rttb::io::utils::loadDose(appData._dose2FileName, appData._dose2LoadStyle);
std::cout << "done." << std::endl;
}
catch (::itk::ExceptionObject& e)
{
std::cerr << "Error!!!" << std::endl;
std::cerr << e << std::endl;
return 4;
}
catch (std::exception& e)
{
std::cerr << "Error!!!" << std::endl;
std::cerr << e.what() << std::endl;
return 4;
}
catch (...)
{
std::cerr << "Error!!! unknown error while reading input image." << std::endl;
return 4;
}
if (!(appData._regFileName.empty()))
{
try
{
appData._spReg = rttb::apps::doseAcc::loadRegistration(appData._regFileName);
}
catch (::itk::ExceptionObject& e)
{
std::cerr << "Error!!!" << std::endl;
std::cerr << e << std::endl;
return 5;
}
catch (std::exception& e)
{
std::cerr << "Error!!!" << std::endl;
std::cerr << e.what() << std::endl;
return 5;
}
catch (...)
{
std::cerr << "Error!!! unknown error while reading registration file." << std::endl;
return 5;
}
}
try
{
rttb::apps::doseAcc::processData(appData);
}
catch (::itk::ExceptionObject& e)
{
std::cerr << "Error!!!" << std::endl;
std::cerr << e << std::endl;
return 9;
}
catch (std::exception& e)
{
std::cerr << "Error!!!" << std::endl;
std::cerr << e.what() << std::endl;
return 9;
}
catch (...)
{
std::cerr << "Error!!! unknown error while mapping and writing image." << std::endl;
return 9;
}
std::cout << std::endl;
return result;
}
diff --git a/apps/DoseAcc/DoseAccHelper.cpp b/apps/DoseAcc/DoseAccHelper.cpp
index 20dfecd..0ecf7f1 100644
--- a/apps/DoseAcc/DoseAccHelper.cpp
+++ b/apps/DoseAcc/DoseAccHelper.cpp
@@ -1,165 +1,160 @@
// -----------------------------------------------------------------------
// 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.
//
//------------------------------------------------------------------------
#include "DoseAccHelper.h"
-
-#include "boost/make_shared.hpp"
-
#include "mapRegistrationFileReader.h"
+#include "rttbArithmetic.h"
+#include "rttbBinaryFunctorAccessor.h"
#include "rttbExceptionMacros.h"
-
+#include "rttbImageWriter.h"
#include "rttbITKImageAccessorConverter.h"
-#include "rttbSimpleMappableDoseAccessor.h"
#include "rttbMatchPointTransformation.h"
-#include "rttbLinearInterpolation.h"
#include "rttbNearestNeighborInterpolation.h"
#include "rttbRosuMappableDoseAccessor.h"
-#include "rttbArithmetic.h"
-#include "rttbBinaryFunctorAccessor.h"
-#include "rttbImageWriter.h"
+#include "rttbSimpleMappableDoseAccessor.h"
rttb::apps::doseAcc::ApplicationData::RegistrationType::Pointer
rttb::apps::doseAcc::loadRegistration(const std::string& fileName)
{
map::io::RegistrationFileReader::Pointer spRegReader = map::io::RegistrationFileReader::New();
map::io::RegistrationFileReader::LoadedRegistrationPointer spReg;
std::cout << std::endl << "read registration file... ";
spReg = spRegReader->read(fileName);
std::cout << "done." << std::endl;
ApplicationData::RegistrationType::Pointer resultPtr =
dynamic_cast<ApplicationData::RegistrationType*>(spReg.GetPointer());
if (resultPtr.IsNull())
{
rttbDefaultExceptionStaticMacro( <<
"Loaded registration cannot be used. Only 3D 3D registrations are allowed.");
}
return resultPtr;
};
rttb::core::DoseAccessorInterface::Pointer generateNNMappableAccessor(
const rttb::core::GeometricInfo& geoInfoTargetImage,
const rttb::core::DoseAccessorInterface::Pointer doseMovingImage,
const rttb::interpolation::TransformationInterface::Pointer aTransformation)
{
auto interpolate = boost::make_shared<rttb::interpolation::NearestNeighborInterpolation>();
return boost::make_shared<rttb::interpolation::SimpleMappableDoseAccessor>(geoInfoTargetImage, doseMovingImage,
aTransformation, interpolate);
}
rttb::core::DoseAccessorInterface::Pointer generateLinearMappableAccessor(
const rttb::core::GeometricInfo& geoInfoTargetImage,
const rttb::core::DoseAccessorInterface::Pointer doseMovingImage,
const rttb::interpolation::TransformationInterface::Pointer aTransformation)
{
auto interpolate = boost::make_shared<rttb::interpolation::LinearInterpolation>();
return boost::make_shared<rttb::interpolation::SimpleMappableDoseAccessor>(geoInfoTargetImage, doseMovingImage,
aTransformation, interpolate);
}
rttb::core::DoseAccessorInterface::Pointer generateRosuMappableAccessor(
const rttb::core::GeometricInfo& geoInfoTargetImage,
const rttb::core::DoseAccessorInterface::Pointer doseMovingImage,
const rttb::interpolation::TransformationInterface::Pointer aTransformation)
{
return boost::make_shared<rttb::interpolation::RosuMappableDoseAccessor>(geoInfoTargetImage, doseMovingImage,
aTransformation);
}
/**Private helper function for processData(). Generates a suitable output accessor
* (depending on the configuration in appData a suitable accessor pipeline is established)
* which performs the accumulation of the doses and returns the output.to */
rttb::core::DoseAccessorInterface::Pointer
assembleOutputAccessor(rttb::apps::doseAcc::ApplicationData& appData)
{
rttb::core::DoseAccessorInterface::Pointer dose2Accessor = appData._dose2;
if (appData._spReg.IsNotNull())
{
auto transform = boost::make_shared<rttb::interpolation::MatchPointTransformation>(appData._spReg);
if (appData._interpolatorName == "rosu")
{
dose2Accessor = generateRosuMappableAccessor(appData._dose1->getGeometricInfo(), appData._dose2,
transform);
}
else if (appData._interpolatorName == "nn")
{
dose2Accessor = generateNNMappableAccessor(appData._dose1->getGeometricInfo(), appData._dose2,
transform);
}
else if (appData._interpolatorName == "linear")
{
dose2Accessor = generateLinearMappableAccessor(appData._dose1->getGeometricInfo(), appData._dose2,
transform);
}
else
{
rttbDefaultExceptionStaticMacro( <<
"Unkown interpolation type selected. Cannot map dose. Interpolation type: " <<
appData._interpolatorName);
}
}
rttb::core::DoseAccessorInterface::Pointer outputAccessor;
if (appData._operator == "+")
{
rttb::algorithms::arithmetic::doseOp::AddWeighted addOp(appData._weightDose1, appData._weightDose2);
outputAccessor = boost::make_shared<rttb::algorithms::BinaryFunctorAccessor<rttb::algorithms::arithmetic::doseOp::AddWeighted> >(appData._dose1, dose2Accessor, addOp);
}
else if (appData._operator == "*")
{
outputAccessor =
boost::make_shared<rttb::algorithms::BinaryFunctorAccessor<rttb::algorithms::arithmetic::doseOp::Multiply> >
(appData._dose1, dose2Accessor, rttb::algorithms::arithmetic::doseOp::Multiply());
}
else
{
rttbDefaultExceptionStaticMacro( <<
"Unkown operator selected. Cannot map dose. Operator: " <<
appData._interpolatorName);
}
return outputAccessor;
}
void
rttb::apps::doseAcc::processData(rttb::apps::doseAcc::ApplicationData& appData)
{
rttb::core::DoseAccessorInterface::Pointer outputAccessor = assembleOutputAccessor(
appData);
std::cout << std::endl << "generate output image... ";
io::itk::ITKImageAccessorConverter converter(outputAccessor);
converter.setFailOnInvalidIDs(true);
converter.process();
io::itk::ITKImageAccessorConverter::ITKImageType::Pointer itkImage = converter.getITKImage();
std::cout << "done." << std::endl;
std::cout << std::endl << "write output image... ";
io::itk::ImageWriter writer(appData._outputFileName, itkImage.GetPointer());
writer.writeFile();
std::cout << "done." << std::endl;
};
diff --git a/apps/DoseMap/DoseMap.cpp b/apps/DoseMap/DoseMap.cpp
index 3cd9386..6ec78f1 100644
--- a/apps/DoseMap/DoseMap.cpp
+++ b/apps/DoseMap/DoseMap.cpp
@@ -1,208 +1,199 @@
// -----------------------------------------------------------------------
// 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.
//
//------------------------------------------------------------------------
-#include "DoseMapApplicationData.h"
-#include "DoseMapHelper.h"
-#include "DoseMapCmdLineParser.h"
-
-#include "boost/shared_ptr.hpp"
#include "boost/make_shared.hpp"
-
-#include "RTToolboxConfigure.h"
-
-#include "rttbException.h"
-
+#include "DoseMapCmdLineParser.h"
+#include "DoseMapHelper.h"
#include "mapDummyRegistrationAlgorithm.h"
-
#include "rttbDoseLoader.cpp"
/**
Main function of dose mapper.
@retval 0 normal program execution
@retval 2 not enough required input files.
@retval 4 Error loading input dose file
@retval 5 Error loading reference dose file
@retval 6 Error loading registration
@retval 9 Error while mapping or storing result.
*/
int main(int argc, const char** argv)
{
int result = 0;
rttb::apps::doseMap::ApplicationData appData;
boost::shared_ptr<rttb::apps::doseMap::DoseMapCmdLineParser> argParser;
try
{
std::string appName = "DoseMap";
std::string appVersion = RTTB_FULL_VERSION_STRING;
argParser = boost::make_shared<rttb::apps::doseMap::DoseMapCmdLineParser>(argc, argv, appName,
appVersion);
}
catch (const std::exception& e)
{
std::cerr << e.what() << std::endl;
return 2;
}
// This is vital. The application needs to exit if the "help" or "version" parameter is set
// because this means the other parameters won't be parsed.
if (argParser->isSet(argParser->OPTION_HELP) || argParser->isSet(argParser->OPTION_VERSION))
{
return 0;
}
try{
rttb::apps::doseMap::populateAppData(argParser, appData);
}
catch (const std::exception& e)
{
std::cerr << e.what() << std::endl;
}
std::cout << std::endl << "*******************************************" << std::endl;
std::cout << "Input dose file: " << appData._inputDoseFileName << std::endl;
std::cout << "Input dose file load style: " << appData._inputDoseLoadStyle.at(0) << std::endl;
std::cout << "Output file: " << appData._outputFileName << std::endl;
if (!(appData._regFileName.empty()))
{
std::cout << "Registration file: " << appData._regFileName << std::endl;
}
if (!(appData._refDoseFileName.empty()))
{
std::cout << "Reference dose file: " << appData._refDoseFileName << std::endl;
std::cout << "Reference dose style: " << appData._refDoseLoadStyle.at(0) << std::endl;
}
std::cout << std::endl << "read dose file... ";
try
{
appData._inputDose = rttb::io::utils::loadDose(appData._inputDoseFileName,
appData._inputDoseLoadStyle);
std::cout << "done." << std::endl;
}
catch (::itk::ExceptionObject& e)
{
std::cerr << "Error!!!" << std::endl;
std::cerr << e << std::endl;
return 4;
}
catch (std::exception& e)
{
std::cerr << "Error!!!" << std::endl;
std::cerr << e.what() << std::endl;
return 4;
}
catch (...)
{
std::cerr << "Error!!! unknown error while reading input image." << std::endl;
return 4;
}
if (!(appData._refDoseFileName.empty()))
{
try
{
appData._refDose = rttb::io::utils::loadDose(appData._refDoseFileName,
appData._refDoseLoadStyle);
}
catch (::itk::ExceptionObject& e)
{
std::cerr << "Error!!!" << std::endl;
std::cerr << e << std::endl;
return 5;
}
catch (std::exception& e)
{
std::cerr << "Error!!!" << std::endl;
std::cerr << e.what() << std::endl;
return 5;
}
catch (...)
{
std::cerr << "Error!!! unknown error while reading reference image." << std::endl;
return 5;
}
}
else
{
appData._refDose = appData._inputDose;
}
if (!(appData._regFileName.empty()))
{
try
{
appData._spReg = rttb::apps::doseMap::loadRegistration(appData._regFileName);
}
catch (::itk::ExceptionObject& e)
{
std::cerr << "Error!!!" << std::endl;
std::cerr << e << std::endl;
return 6;
}
catch (std::exception& e)
{
std::cerr << "Error!!!" << std::endl;
std::cerr << e.what() << std::endl;
return 6;
}
catch (...)
{
std::cerr << "Error!!! unknown error while reading registration file." << std::endl;
return 6;
}
}
else
{
//generate dummy identity registration
using DummyRegType = map::algorithm::DummyRegistrationAlgorithm<3>;
DummyRegType::Pointer regAlg = DummyRegType::New();
appData._spReg = regAlg->getRegistration();
}
try
{
rttb::apps::doseMap::processData(appData);
}
catch (::itk::ExceptionObject& e)
{
std::cerr << "Error!!!" << std::endl;
std::cerr << e << std::endl;
return 9;
}
catch (std::exception& e)
{
std::cerr << "Error!!!" << std::endl;
std::cerr << e.what() << std::endl;
return 9;
}
catch (...)
{
std::cerr << "Error!!! unknown error while mapping and writing image." << std::endl;
return 9;
}
std::cout << std::endl;
return result;
}
diff --git a/apps/DoseMap/DoseMapApplicationData.cpp b/apps/DoseMap/DoseMapApplicationData.cpp
index 3af2ef6..05265fb 100644
--- a/apps/DoseMap/DoseMapApplicationData.cpp
+++ b/apps/DoseMap/DoseMapApplicationData.cpp
@@ -1,66 +1,65 @@
// -----------------------------------------------------------------------
// 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.
//
//------------------------------------------------------------------------
#include "DoseMapApplicationData.h"
-
#include "DoseMapCmdLineParser.h"
namespace rttb
{
namespace apps
{
namespace doseMap
{
ApplicationData::
ApplicationData()
{
this->reset();
}
void
ApplicationData::
reset()
{
_inputDoseFileName = "";
_refDoseFileName = "";
_outputFileName = "";
_regFileName = "";
_interpolatorName = "linear";
}
void populateAppData(boost::shared_ptr<rttb::apps::doseMap::DoseMapCmdLineParser> argParser, ApplicationData& appData)
{
appData.reset();
appData._inputDoseFileName = argParser->get<std::string>(argParser->OPTION_INPUT_DOSE_FILE_NAME);
appData._outputFileName = argParser->get<std::string>(argParser->OPTION_OUTPUT_FILE_NAME);
appData._interpolatorName = argParser->get<std::string>(argParser->OPTION_INTERPOLATOR);
appData._regFileName = argParser->get<std::string>(argParser->OPTION_REG_FILE_NAME);
appData._inputDoseLoadStyle = argParser->get<std::string>(argParser->OPTION_INPUT_DOSE_LOAD_STYLE);
if (!argParser->isSet(argParser->OPTION_REF_DOSE_FILE)){
appData._refDoseFileName = argParser->get<std::string>(argParser->OPTION_INPUT_DOSE_FILE_NAME);
appData._refDoseLoadStyle = argParser->get<std::string>(argParser->OPTION_INPUT_DOSE_LOAD_STYLE);
} else {
appData._refDoseFileName = argParser->get<std::string>(argParser->OPTION_REF_DOSE_FILE);
appData._refDoseLoadStyle = argParser->get<std::string>(argParser->OPTION_REF_DOSE_LOAD_STYLE);
}
}
}
}
}
\ No newline at end of file
diff --git a/apps/DoseMap/DoseMapHelper.cpp b/apps/DoseMap/DoseMapHelper.cpp
index db54354..6b9f02e 100644
--- a/apps/DoseMap/DoseMapHelper.cpp
+++ b/apps/DoseMap/DoseMapHelper.cpp
@@ -1,113 +1,106 @@
// -----------------------------------------------------------------------
// 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.
//
//------------------------------------------------------------------------
#include "DoseMapHelper.h"
-
-#include <boost/make_shared.hpp>
-
#include "mapRegistrationFileReader.h"
#include "rttbITKImageAccessorConverter.h"
#include "rttbSimpleMappableDoseAccessor.h"
#include "rttbMatchPointTransformation.h"
-#include "rttbLinearInterpolation.h"
#include "rttbNearestNeighborInterpolation.h"
#include "rttbRosuMappableDoseAccessor.h"
-#include "rttbArithmetic.h"
-#include "rttbBinaryFunctorAccessor.h"
-#include "rttbExceptionMacros.h"
#include "rttbImageWriter.h"
rttb::apps::doseMap::ApplicationData::RegistrationType::Pointer
rttb::apps::doseMap::loadRegistration(const std::string& fileName)
{
map::io::RegistrationFileReader::Pointer spRegReader = map::io::RegistrationFileReader::New();
map::io::RegistrationFileReader::LoadedRegistrationPointer spReg;
std::cout << std::endl << "read registration file... ";
spReg = spRegReader->read(fileName);
std::cout << "done." << std::endl;
ApplicationData::RegistrationType::Pointer resultPtr =
dynamic_cast<ApplicationData::RegistrationType*>(spReg.GetPointer());
if (resultPtr.IsNull())
{
mapDefaultExceptionStaticMacro( <<
"Loaded registration cannot be used. Only 3D 3D registrations are allowed.");
}
return resultPtr;
};
/**Private helper function for processData(). Generates a suitable output accessor
* (depending on the configuration in appData a suitable accessor pipeline is established)
* which performs the accumulation of the doses and returns the output.to */
rttb::core::DoseAccessorInterface::Pointer
assembleOutputAccessor(rttb::apps::doseMap::ApplicationData& appData)
{
rttb::core::DoseAccessorInterface::Pointer outputAccessor = appData._inputDose;
auto transform = boost::make_shared<rttb::interpolation::MatchPointTransformation>(appData._spReg);
if (appData._interpolatorName == "rosu")
{
outputAccessor = boost::make_shared<rttb::interpolation::RosuMappableDoseAccessor>(appData._refDose->getGeometricInfo(),
appData._inputDose, transform);
}
else
{
rttb::interpolation::InterpolationBase::Pointer interpolate = boost::make_shared<rttb::interpolation::LinearInterpolation>();
if (appData._interpolatorName == "nn")
{
interpolate = boost::make_shared<rttb::interpolation::NearestNeighborInterpolation>();
}
else if (appData._interpolatorName != "linear")
{
mapDefaultExceptionStaticMacro( <<
"Unkown interpolation type selected. Cannot map dose. Interpolation type: " <<
appData._interpolatorName);
}
outputAccessor = boost::make_shared<rttb::interpolation::SimpleMappableDoseAccessor>(appData._refDose->getGeometricInfo(),
appData._inputDose, transform, interpolate);
}
return outputAccessor;
}
void
rttb::apps::doseMap::processData(rttb::apps::doseMap::ApplicationData& appData)
{
rttb::core::DoseAccessorInterface::Pointer outputAccessor = assembleOutputAccessor(
appData);
std::cout << std::endl << "generate output image... ";
io::itk::ITKImageAccessorConverter converter(outputAccessor);
converter.setFailOnInvalidIDs(true);
converter.process();
io::itk::ITKImageAccessorConverter::ITKImageType::Pointer itkImage = converter.getITKImage();
std::cout << "done." << std::endl;
std::cout << std::endl << "write output image... ";
io::itk::ImageWriter writer(appData._outputFileName, itkImage.GetPointer());
writer.writeFile();
std::cout << "done." << std::endl;
};
diff --git a/apps/DoseTool/DoseTool.cpp b/apps/DoseTool/DoseTool.cpp
index 7ea8b3d..1106475 100644
--- a/apps/DoseTool/DoseTool.cpp
+++ b/apps/DoseTool/DoseTool.cpp
@@ -1,164 +1,157 @@
// -----------------------------------------------------------------------
// 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.
//
//------------------------------------------------------------------------
#include "DoseToolApplicationData.h"
#include "DoseToolHelper.h"
#include "DoseToolCmdLineParser.h"
-#include "boost/shared_ptr.hpp"
-#include "boost/make_shared.hpp"
-
-#include "RTToolboxConfigure.h"
-
-#include "rttbException.h"
-
#include "rttbDoseLoader.cpp"
#include "rttbStructLoader.cpp"
/*! \file DoseTool.cpp main function for DoseTool
*/
int main(int argc, const char** argv)
{
int result = 0;
rttb::apps::doseTool::ApplicationData appData;
boost::shared_ptr<rttb::apps::doseTool::DoseToolCmdLineParser> argParser;
const std::string appCategory = "RT-Toolbox App";
const std::string appName = "DoseTool";
const std::string appDesc = "An App to calculate the dose statistics and compute the DVH. The GUI for this app is currently under development and in an experimental state.";
const std::string appContributor = "SIDT@DKFZ";
const std::string appVersion = RTTB_FULL_VERSION_STRING;
try
{
argParser = boost::make_shared<rttb::apps::doseTool::DoseToolCmdLineParser>(argc, argv, appName,
appVersion, appDesc, appContributor, appCategory);
}
catch (const std::exception& e)
{
std::cerr << e.what() << std::endl;
return 5;
}
// This is vital. The application needs to exit if the "help" or "version" parameter is set
// because this means the other parameters won't be parsed.
if (argParser->isSet(argParser->OPTION_HELP) || argParser->isSet(argParser->OPTION_VERSION) || argParser->isSet(argParser->OPTION_XML))
{
return 0;
}
rttb::apps::doseTool::populateAppData(argParser, appData);
std::cout << std::endl << "*******************************************" << std::endl;
std::cout << "Dose file: " << appData._doseFileName << std::endl;
std::cout << "Struct file: " << appData._structFileName << std::endl;
std::cout << "Struct name: " << appData._structNameRegex << std::endl;
if (appData._computeDoseStatistics)
{
std::cout << "Dose statistic output file: " << appData._doseStatisticOutputFileName << std::endl;
std::cout << "Compute complex statistics: " << appData._computeComplexDoseStatistics << std::endl;
if (appData._computeComplexDoseStatistics)
{
std::cout << "Prescribed dose: " << appData._prescribedDose << std::endl;
}
std::cout << "Allow self intersections: " << appData._allowSelfIntersection << std::endl;
}
if (appData._computeDVH)
{
std::cout << "DVH output file: " << appData._dvhOutputFilename << std::endl;
}
std::cout << std::endl << "read dose file... ";
try
{
appData._dose = rttb::io::utils::loadDose(appData._doseFileName, appData._doseLoadStyle);
std::cout << "done." << std::endl;
}
catch (rttb::core::Exception& e)
{
std::cerr << "RTTB Error!!!" << std::endl;
std::cerr << e.what() << std::endl;
return 1;
}
catch (const std::exception& e)
{
std::cerr << "Error!!!" << std::endl;
std::cerr << e.what() << std::endl;
return 1;
}
catch (...)
{
std::cerr << "Error!!! unknown error while reading dose image." << std::endl;
return 1;
}
//loading of structure file not necessary in ITK case as it can be used directly as mask input.
if (appData._structLoadStyle != "itk" && appData._structLoadStyle != "itkDicom")
{
try
{
appData._struct = rttb::io::utils::loadStruct(appData._structFileName,
appData._structLoadStyle, appData._structNameRegex);
}
catch (rttb::core::Exception& e)
{
std::cerr << "RTTB Error!!!" << std::endl;
std::cerr << e.what() << std::endl;
return 2;
}
catch (const std::exception& e)
{
std::cerr << "Error!!!" << std::endl;
std::cerr << e.what() << std::endl;
return 2;
}
catch (...)
{
std::cerr << "Error!!! unknown error while reading struct image." << std::endl;
return 2;
}
}
try
{
rttb::apps::doseTool::processData(appData);
}
catch (rttb::core::Exception& e)
{
std::cerr << "RTTB Error!!!" << std::endl;
std::cerr << e.what() << std::endl;
return 3;
}
catch (std::exception& e)
{
std::cerr << "Error!!!" << std::endl;
std::cerr << e.what() << std::endl;
return 3;
}
catch (...)
{
std::cerr << "Error!!! unknown error while processing the data or writing the image." << std::endl;
return 3;
}
return result;
}
diff --git a/apps/DoseTool/DoseToolHelper.cpp b/apps/DoseTool/DoseToolHelper.cpp
index cbcc797..53fa6c9 100644
--- a/apps/DoseTool/DoseToolHelper.cpp
+++ b/apps/DoseTool/DoseToolHelper.cpp
@@ -1,212 +1,206 @@
// -----------------------------------------------------------------------
// 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.
//
//------------------------------------------------------------------------
#include "DoseToolHelper.h"
-#include "boost/make_shared.hpp"
-#include "boost/shared_ptr.hpp"
-#include "boost/property_tree/ptree.hpp"
#include "boost/property_tree/xml_parser.hpp"
#include "boost/filesystem.hpp"
#include "DoseToolApplicationData.h"
-#include "rttbDicomFileStructureSetGenerator.h"
#include "rttbITKImageFileMaskAccessorGenerator.h"
-#include "rttbDoseStatistics.h"
-#include "rttbDVH.h"
#include "rttbDVHCalculator.h"
#include "rttbDVHXMLFileWriter.h"
#include "rttbDoseStatisticsCalculator.h"
#include "rttbBoostMaskAccessor.h"
#include "rttbGenericMaskedDoseIterator.h"
#include "rttbDoseStatisticsXMLWriter.h"
std::vector<rttb::core::MaskAccessorInterface::Pointer>
rttb::apps::doseTool::generateMasks(
rttb::apps::doseTool::ApplicationData& appData)
{
std::vector<core::MaskAccessorInterface::Pointer> maskAccessorPtrVector;
if (appData._structLoadStyle == "itk" || appData._structLoadStyle == "itkDicom") {
maskAccessorPtrVector.push_back(rttb::io::itk::ITKImageFileMaskAccessorGenerator(appData._structFileName).generateMaskAccessor());
appData._structNames.push_back(appData._structNameRegex);
} else {
if (appData._struct->getNumberOfStructures() > 0) {
//default behavior: read only first struct that matches the regex
unsigned int maxIterationCount = 1;
//only if specified: read all structs that matches the regex
if (appData._multipleStructsMode) {
maxIterationCount = appData._struct->getNumberOfStructures();
}
bool strict = !appData._allowSelfIntersection;
for (size_t i = 0; i < maxIterationCount; i++) {
maskAccessorPtrVector.emplace_back(boost::make_shared<rttb::masks::boost::BoostMaskAccessor>(appData._struct->getStructure(i), appData._dose->getGeometricInfo(), strict));
maskAccessorPtrVector.at(i)->updateMask();
appData._structNames.push_back(appData._struct->getStructure(i)->getLabel());
}
} else {
std::cout << "no structures in structure set!" << std::endl;
}
}
return maskAccessorPtrVector;
}
rttb::core::DoseIteratorInterface::Pointer
rttb::apps::doseTool::generateMaskedDoseIterator(
rttb::core::MaskAccessorInterface::Pointer maskAccessorPtr,
rttb::core::DoseAccessorInterface::Pointer doseAccessorPtr)
{
boost::shared_ptr<core::GenericMaskedDoseIterator> maskedDoseIterator =
boost::make_shared<core::GenericMaskedDoseIterator>(maskAccessorPtr, doseAccessorPtr);
rttb::core::DoseIteratorInterface::Pointer doseIterator(maskedDoseIterator);
return doseIterator;
}
rttb::algorithms::DoseStatistics::Pointer
calculateDoseStatistics(
rttb::core::DoseIteratorInterface::Pointer doseIterator, bool calculateComplexDoseStatistics,
rttb::DoseTypeGy prescribedDose)
{
rttb::algorithms::DoseStatisticsCalculator doseStatsCalculator(doseIterator);
if (calculateComplexDoseStatistics) {
return doseStatsCalculator.calculateDoseStatistics(prescribedDose);
} else {
return doseStatsCalculator.calculateDoseStatistics();
}
}
rttb::core::DVH::Pointer calculateDVH(
rttb::core::DoseIteratorInterface::Pointer
doseIterator, rttb::IDType structUID, rttb::IDType doseUID)
{
rttb::core::DVHCalculator calc(doseIterator, structUID, doseUID);
rttb::core::DVH::Pointer dvh = calc.generateDVH();
return dvh;
}
std::string rttb::apps::doseTool::assembleFilenameWithStruct(const std::string& originalFilename, const std::string& structName) {
boost::filesystem::path originalFile(originalFilename);
std::string newFilename = originalFile.stem().string() + "_" + structName + originalFile.extension().string();
boost::filesystem::path newFile(originalFile.parent_path() / newFilename);
return newFile.string();
}
/*! @brief Writes the dose statistics as XML to a file
@details adds a <config>....</config> part to the RTTB generated xml where the used files and struct names are stored.
*/
void writeDoseStatisticsFile(
rttb::algorithms::DoseStatistics::Pointer statistics,
const std::string& filename, const std::string& structName,
rttb::apps::doseTool::ApplicationData& appData)
{
auto doseStatisticsXMLWriter = rttb::io::other::DoseStatisticsXMLWriter();
boost::property_tree::ptree originalTree = doseStatisticsXMLWriter.writeDoseStatistics(statistics);
//add config part to xml
originalTree.add("statistics.config.requestedStructRegex", appData._structNameRegex);
originalTree.add("statistics.config.structName", structName);
originalTree.add("statistics.config.doseUID", appData._dose->getUID());
originalTree.add("statistics.config.doseFile", appData._doseFileName);
originalTree.add("statistics.config.structFile", appData._structFileName);
boost::property_tree::ptree reorderedTree, configTree, resultsTree;
configTree = originalTree.get_child("statistics.config");
resultsTree = originalTree.get_child("statistics.results");
reorderedTree.add_child("statistics.config", configTree);
reorderedTree.add_child("statistics.results", resultsTree);
boost::property_tree::write_xml(filename, reorderedTree, std::locale(), boost::property_tree::xml_writer_make_settings<std::string>('\t', 1));
}
void writeDVHFile(rttb::core::DVH::Pointer dvh, const std::string& filename)
{
rttb::DVHType typeCum = { rttb::DVHType::Cumulative };
rttb::io::other::DVHXMLFileWriter dvhWriter(filename, typeCum);
dvhWriter.writeDVH(dvh);
}
void rttb::apps::doseTool::processData(rttb::apps::doseTool::ApplicationData& appData) {
std::cout << std::endl << "generating masks... ";
std::vector<core::MaskAccessorInterface::Pointer> maskAccessorPtrVector = generateMasks(
appData);
std::cout << "done." << std::endl;
for (size_t i = 0; i < maskAccessorPtrVector.size(); i++) {
core::DoseIteratorInterface::Pointer spDoseIterator(generateMaskedDoseIterator(
maskAccessorPtrVector.at(i),
appData._dose));
if (appData._computeDoseStatistics) {
std::cout << std::endl << "computing dose statistics... ";
auto statistics = calculateDoseStatistics(
spDoseIterator,
appData._computeComplexDoseStatistics, appData._prescribedDose);
std::cout << "done." << std::endl;
std::cout << std::endl << "writing dose statistics to file... ";
std::string outputFilename;
if (appData._multipleStructsMode) {
outputFilename = assembleFilenameWithStruct(appData._doseStatisticOutputFileName,
appData._structNames.at(i));
} else {
outputFilename = appData._doseStatisticOutputFileName;
}
writeDoseStatisticsFile(statistics, outputFilename, appData._structNames.at(i), appData);
std::cout << "done." << std::endl;
}
if (appData._computeDVH) {
std::cout << std::endl << "computing DVH... ";
rttb::IDType structUID;
rttb::IDType doseUID;
//Generate random UID
if (appData._structLoadStyle == "itk") {
structUID = "struct.fromVoxelizedITK";
doseUID = "dose.fromVoxelizedITK";
} else {
structUID = appData._struct->getUID();
doseUID = appData._dose->getUID();
}
core::DVH::Pointer dvh = calculateDVH(spDoseIterator, structUID,
doseUID);
std::cout << "done." << std::endl;
std::cout << std::endl << "writing DVH to file... ";
std::string outputFilename;
if (appData._multipleStructsMode) {
outputFilename = assembleFilenameWithStruct(appData._dvhOutputFilename, appData._structNames.at(i));
} else {
outputFilename = appData._dvhOutputFilename;
}
writeDVHFile(dvh, outputFilename);
std::cout << "done." << std::endl;
}
}
}
diff --git a/apps/VoxelizerTool/VoxelizerToolHelper.cpp b/apps/VoxelizerTool/VoxelizerToolHelper.cpp
index a946e7b..ad898ad 100644
--- a/apps/VoxelizerTool/VoxelizerToolHelper.cpp
+++ b/apps/VoxelizerTool/VoxelizerToolHelper.cpp
@@ -1,211 +1,209 @@
// -----------------------------------------------------------------------
// 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.
//
//------------------------------------------------------------------------
#include <iostream>
#include "rttbBoostMaskAccessor.h"
#include "itkMacro.h"
#include "VoxelizerToolHelper.h"
-#include "VoxelizerToolApplicationData.h"
-
-#include "rttbITKImageMaskAccessorConverter.h"
-#include "rttbImageWriter.h"
-#include "itkBinaryThresholdImageFilter.h"
#include "itkAddImageFilter.h"
+#include "itkBinaryThresholdImageFilter.h"
-#include <regex>
-
-#include <boost/algorithm/string/case_conv.hpp>
-
+#include "rttbBoostMaskAccessor.h"
+#include "rttbDicomFileStructureSetGenerator.h"
+#include "rttbImageWriter.h"
+#include "rttbITKImageMaskAccessorConverter.h"
#include "rttbUtils.h"
-#include "rttbDicomFileStructureSetGenerator.h"
+#include "VoxelizerToolApplicationData.h"
+
+#include <iostream>
void rttb::apps::voxelizerTool::removeSpecialCharacters(std::string& label)
{
//Replace / to avoid problems with directories (struct "Magen/DD" --> Magen/DD.mhd), delete trailing . to avoid filenames with two trailing points (Niere re. --> Niere re..mhd)
while (label.find("/") != std::string::npos)
{
label.replace(label.find("/"), 1, "_");
}
if (*label.rbegin() == '.')
{
label.replace(label.size() - 1, 1, "");
}
}
rttb::core::MaskAccessorInterface::Pointer rttb::apps::voxelizerTool::createMask(
rttb::core::DoseAccessorInterface::Pointer doseAccessorPtr,
rttb::core::Structure::Pointer structurePtr,
bool strict)
{
rttb::core::MaskAccessorInterface::Pointer maskAccessorPtr;
if (doseAccessorPtr != nullptr && structurePtr != nullptr)
{
maskAccessorPtr = boost::make_shared<rttb::masks::boost::BoostMaskAccessor>
(structurePtr, doseAccessorPtr->getGeometricInfo(),
strict);
maskAccessorPtr->updateMask();
}
return maskAccessorPtr;
}
void rttb::apps::voxelizerTool::writeMaskToFile(std::vector<core::MaskAccessorInterface::Pointer> maskVector,
const std::string& outputFileName, bool voxelization)
{
if (!maskVector.empty())
{
io::itk::ITKImageMaskAccessor::ITKMaskImageType::ConstPointer itkImage;
if (maskVector.size() > 1)
{
itkImage = addMultipleStructsToImage(maskVector);
}
else
{
io::itk::ITKImageMaskAccessorConverter maskAccessorConverter(maskVector.at(0));
maskAccessorConverter.process();
itkImage = maskAccessorConverter.getITKImage();
}
if (voxelization)
{
itkImage = applyThresholdFilter(itkImage);
}
io::itk::ImageWriter writer(outputFileName, itkImage);
writer.writeFile();
}
}
rttb::io::itk::ITKImageMaskAccessor::ITKMaskImageType::ConstPointer rttb::apps::voxelizerTool::addMultipleStructsToImage(
std::vector<core::MaskAccessorInterface::Pointer> maskVector)
{
std::vector<io::itk::ITKImageMaskAccessor::ITKMaskImageType::Pointer> listOfITKImages;
for (const auto & i : maskVector)
{
io::itk::ITKImageMaskAccessorConverter maskAccessorConverter(i);
maskAccessorConverter.process();
listOfITKImages.push_back(maskAccessorConverter.getITKImage());
}
itk::AddImageFilter <itk::Image<rttb::DoseTypeGy, 3>, itk::Image<rttb::DoseTypeGy, 3>>::Pointer addFilter =
itk::AddImageFilter <itk::Image<rttb::DoseTypeGy, 3>, itk::Image<rttb::DoseTypeGy, 3>>::New();
io::itk::ITKImageMaskAccessor::ITKMaskImageType::Pointer filterResult;
for (int k = 1; k < listOfITKImages.size(); k++)
{
if (k == 1)
{
addFilter->SetInput1(listOfITKImages.at(0));
}
else
{
addFilter->SetInput1(filterResult);
}
addFilter->SetInput2(listOfITKImages.at(k));
addFilter->Update();
filterResult = addFilter->GetOutput();
}
return filterResult.GetPointer();
}
rttb::io::itk::ITKImageMaskAccessor::ITKMaskImageType::ConstPointer rttb::apps::voxelizerTool::applyThresholdFilter(
io::itk::ITKImageMaskAccessor::ITKMaskImageType::ConstPointer itkImage)
{
itk::BinaryThresholdImageFilter< itk::Image<rttb::DoseTypeGy, 3>, itk::Image<rttb::DoseTypeGy, 3> >::Pointer filter =
itk::BinaryThresholdImageFilter< itk::Image<rttb::DoseTypeGy, 3>, itk::Image<rttb::DoseTypeGy, 3> >::New();
filter->SetInput(itkImage);
filter->SetLowerThreshold(0.5);
filter->SetUpperThreshold(1.0);
filter->SetInsideValue(1.0);
filter->Update();
return filter->GetOutput();
}
void rttb::apps::voxelizerTool::processData(rttb::apps::voxelizerTool::ApplicationData& appData) {
if (appData._struct->getNumberOfStructures()>0)
{
std::vector<core::MaskAccessorInterface::Pointer> maskVector;
if (appData._addStructures)
{
for (size_t i=0; i<appData._struct->getNumberOfStructures(); i++ )
{
std::cout << "creating mask #" << i << "...";
maskVector.push_back(createMask(appData._dose, appData._struct->getStructure(i),
!appData._noStrictVoxelization));
std::cout << "done" << std::endl;
}
std::cout << "writing mask to file...";
writeMaskToFile(maskVector, appData._outputFilename, appData._binaryVoxelization);
std::cout << "done" << std::endl;
}
else
{
//default behavior: read only first struct that matches the regex
unsigned int maxIterationCount = 1;
//only if specified: read all structs that matches the regex
if (appData._multipleStructs)
{
maxIterationCount = appData._struct->getNumberOfStructures();
}
for (size_t i = 0; i<maxIterationCount; i++)
{
std::cout << "creating mask #" << i << "...";
auto currentMask = createMask(appData._dose, appData._struct->getStructure(i),
!appData._noStrictVoxelization);
std::cout << "done" << std::endl;
std::string labelOfInterest = appData._struct->getStructure(i)->getLabel();
removeSpecialCharacters(labelOfInterest);
std::string outputName = appData._outputFilename;
if (appData._multipleStructs)
{
std::string fileName = rttb::core::getFilenameWithoutEnding(
appData._outputFilename);
std::string fileEnding = rttb::core::getFileEnding(appData._outputFilename);
outputName = fileName + "_" + labelOfInterest + fileEnding;
}
std::vector<rttb::core::MaskAccessorInterface::Pointer> currenMaskVector{ currentMask };
std::cout << "writing mask #" << i << " to file...";
writeMaskToFile(currenMaskVector, outputName, appData._binaryVoxelization);
std::cout << "done" << std::endl;
}
}
}
else
{
std::cout << "No struct found" << std::endl;
}
}
\ No newline at end of file