diff --git a/apps/VoxelizerTool/VoxelizerTool.cpp b/apps/VoxelizerTool/VoxelizerTool.cpp
index 9e70d48..789b713 100644
--- a/apps/VoxelizerTool/VoxelizerTool.cpp
+++ b/apps/VoxelizerTool/VoxelizerTool.cpp
@@ -1,149 +1,144 @@
// -----------------------------------------------------------------------
// 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.
//
//------------------------------------------------------------------------
-/*!
-// @file
-// @version $Revision: 1390 $ (last changed revision)
-// @date $Date: 2016-07-13 09:57:44 +0200 (Mi, 13 Jul 2016) $ (last change date)
-// @author $Author: strubel $ (last changed by)
-*/
+
#include <iostream>
#include "VoxelizerToolHelper.h"
#include "VoxelizerToolCmdLineParser.h"
#include "VoxelizerToolApplicationData.h"
#include "rttbDoseLoader.cpp"
#include "rttbStructLoader.cpp"
int main(int argc, const char** argv)
{
rttb::apps::voxelizerTool::ApplicationData appData;
const std::string appCategory = "RT-Toolbox App";
const std::string appName = "VoxelizerTool";
const std::string appDesc = "An App to voxelize RT structures in a reference image.";
const std::string appContributor = "SIDT@DKFZ";
const std::string appVersion = RTTB_FULL_VERSION_STRING;
boost::shared_ptr<rttb::apps::voxelizerTool::VoxelizerCmdLineParser> argParser;
try
{
argParser = boost::make_shared<rttb::apps::voxelizerTool::VoxelizerCmdLineParser>(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::voxelizerTool::populateAppData(argParser, appData);
std::cout << std::endl << "*******************************************" << std::endl;
std::cout << "Struct file: " << appData._structFile << std::endl;
std::cout << "Reference Image: " << appData._referenceFile << std::endl;
std::cout << "Output file: " << appData._outputFilename << std::endl;
std::cout << "Struct regex: " << appData._regEx << std::endl;
std::cout << "Add structures: " << appData._addStructures << std::endl;
std::cout << "Multiple Struct: " << appData._multipleStructs << std::endl;
std::cout << "Strict voxelization: " << !appData._noStrictVoxelization << std::endl << std::endl;
std::cout << "reading reference and structure file..." << std::endl;
try
{
appData._dose = rttb::io::utils::loadDose(appData._referenceFile, appData._referenceFileLoadStyle);
}
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 input dose image." << std::endl;
return 2;
}
try
{
appData._struct = rttb::io::utils::loadStruct(appData._structFile, appData._structFileLoadStyle, appData._regEx);
}
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 input struct image." << std::endl;
return 2;
}
std::cout << "done." << std::endl;
try
{
rttb::apps::voxelizerTool::processData(appData);
}
catch (rttb::core::Exception& e)
{
std::cerr << "RTTB Error while doing voxelization!!!" << std::endl;
std::cerr << e.what() << std::endl;
return 2;
}
catch (itk::ExceptionObject& err)
{
std::cerr << "ExceptionObject caught !" << std::endl;
std::cerr << err << std::endl;
return 3;
}
catch (const std::exception& e)
{
std::cerr << "Error!!!" << std::endl;
std::cerr << e.what() << std::endl;
return 3;
}
catch (...)
{
std::cerr << "Error!!! unknown error while doing voxelization." << std::endl;
return 3;
}
return 0;
}
diff --git a/apps/VoxelizerTool/VoxelizerToolApplicationData.h b/apps/VoxelizerTool/VoxelizerToolApplicationData.h
index db8e74f..2ea07f6 100644
--- a/apps/VoxelizerTool/VoxelizerToolApplicationData.h
+++ b/apps/VoxelizerTool/VoxelizerToolApplicationData.h
@@ -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.
//
//------------------------------------------------------------------------
-
#ifndef __VoxelizerApplicationData_h
#define __VoxelizerApplicationData_h
#include "boost/shared_ptr.hpp"
#include "rttbDoseAccessorInterface.h"
#include "rttbStructureSetGeneratorInterface.h"
#include <vector>
#include <string>
namespace rttb
{
namespace apps
{
namespace voxelizerTool
{
class VoxelizerCmdLineParser;
/*! @class ApplicationData
@brief Class for storing all relevant variables needed in VoxelizerTool
*/
class ApplicationData
{
public:
core::DoseAccessorInterface::Pointer _dose;
core::StructureSet::Pointer _struct;
std::string _structFile;
std::string _referenceFile;
std::string _outputFilename;
std::string _regEx;
std::string _referenceFileLoadStyle;
std::string _structFileLoadStyle;
bool _multipleStructs;
bool _binaryVoxelization;
bool _addStructures;
bool _noStrictVoxelization;
/*! @brief Resets the variables.
*/
void reset();
ApplicationData();
};
/*! @brief Reads the necessary arguments from the VoxelizerCmdLineParser and writes them in the respective variables of ApplicationData.
*/
void populateAppData(boost::shared_ptr<VoxelizerCmdLineParser> argParser, ApplicationData& appData);
}
}
}
#endif
diff --git a/apps/VoxelizerTool/VoxelizerToolCmdLineParser.h b/apps/VoxelizerTool/VoxelizerToolCmdLineParser.h
index 5a54c71..9ec9e91 100644
--- a/apps/VoxelizerTool/VoxelizerToolCmdLineParser.h
+++ b/apps/VoxelizerTool/VoxelizerToolCmdLineParser.h
@@ -1,65 +1,59 @@
// -----------------------------------------------------------------------
// 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.
//
//------------------------------------------------------------------------
-/*!
-// @file
-// @version $Revision: 1221 $ (last changed revision)
-// @date $Date: 2015-12-01 13:43:31 +0100 (Di, 01 Dez 2015) $ (last change date)
-// @author $Author: hentsch $ (last changed by)
-*/
#ifndef __VoxelizerCmdLineParser_h
#define __VoxelizerCmdLineParser_h
#include "CmdLineParserBase.h"
namespace rttb
{
namespace apps
{
namespace voxelizerTool
{
/*! @class VoxelizerCmdLineParser
@brief Argument parsing is parametrized here based on ArgParserLib
@see cmdlineparsing::CmdLineParserBase
*/
class VoxelizerCmdLineParser : public cmdlineparsing::CmdLineParserBase
{
public:
VoxelizerCmdLineParser(int argc, const char** argv, const std::string& name, const std::string& version,
const std::string& description, const std::string& contributor, const std::string& category);
void validateInput() const override;
void printHelp() const override;
// Option groups
const std::string OPTION_GROUP_REQUIRED = "Required Arguments";
const std::string OPTION_GROUP_OPTIONAL = "Optional Arguments";
// Parameters
const std::string OPTION_STRUCT_FILE = "structFile";
const std::string OPTION_REFERENCE_FILE = "referenceFile";
const std::string OPTION_REFERENCE_FILE_LOAD_STYLE = "referenceFileLoadStyle";
const std::string OPTION_OUTPUT_FILE_NAME = "output";
const std::string OPTION_REGEX = "struct";
const std::string OPTION_MULTIPLE_STRUCTS = "multipleStructs";
const std::string OPTION_BINARY_VOXELIZATION = "binaryVoxelization";
const std::string OPTION_ADDSTRUCTURES = "addStructures";
const std::string OPTION_NO_STRICT_VOXELIZATION = "noStrictVoxelization";
};
}
}
}
#endif
\ No newline at end of file
diff --git a/apps/VoxelizerTool/VoxelizerToolHelper.cpp b/apps/VoxelizerTool/VoxelizerToolHelper.cpp
index d53f3a5..a946e7b 100644
--- a/apps/VoxelizerTool/VoxelizerToolHelper.cpp
+++ b/apps/VoxelizerTool/VoxelizerToolHelper.cpp
@@ -1,216 +1,211 @@
// -----------------------------------------------------------------------
// 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.
//
//------------------------------------------------------------------------
-/*!
-// @file
-// @version $Revision: 1127 $ (last changed revision)
-// @date $Date: 2015-10-01 13:33:33 +0200 (Do, 01 Okt 2015) $ (last change date)
-// @author $Author: hentsch $ (last changed by)
-*/
+
#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 <regex>
#include <boost/algorithm/string/case_conv.hpp>
#include "rttbUtils.h"
#include "rttbDicomFileStructureSetGenerator.h"
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
diff --git a/apps/VoxelizerTool/VoxelizerToolHelper.h b/apps/VoxelizerTool/VoxelizerToolHelper.h
index 14482aa..a8dae7e 100644
--- a/apps/VoxelizerTool/VoxelizerToolHelper.h
+++ b/apps/VoxelizerTool/VoxelizerToolHelper.h
@@ -1,67 +1,61 @@
// -----------------------------------------------------------------------
// 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.
//
//------------------------------------------------------------------------
-/*!
-// @file
-// @version $Revision: 1127 $ (last changed revision)
-// @date $Date: 2015-10-01 13:33:33 +0200 (Do, 01 Okt 2015) $ (last change date)
-// @author $Author: hentsch $ (last changed by)
-*/
#include <string>
#include <vector>
#include "rttbStructure.h"
#include "rttbMaskAccessorInterface.h"
#include "rttbITKImageMaskAccessor.h"
#include "rttbDoseAccessorInterface.h"
namespace rttb
{
namespace apps
{
namespace voxelizerTool
{
class ApplicationData;
void processData(ApplicationData& appData);
/**@brief Search the label with the position from index
@return a label from the list as string
*/
void removeSpecialCharacters(std::string& label);
/**@brief create a mask with _rtStructureSet and _doseAccessor object.
@return a mask object
*/
core::MaskAccessorInterface::Pointer createMask(
core::DoseAccessorInterface::Pointer doseAccessorPtr,
rttb::core::Structure::Pointer structurePtr,
bool strict);
/**@brief write the mask into the outputfile
@param Outputfilename
*/
void writeMaskToFile(std::vector<core::MaskAccessorInterface::Pointer> maskVector,
const std::string& outputFileName, bool voxelization);
io::itk::ITKImageMaskAccessor::ITKMaskImageType::ConstPointer addMultipleStructsToImage(
std::vector<core::MaskAccessorInterface::Pointer> maskVector);
io::itk::ITKImageMaskAccessor::ITKMaskImageType::ConstPointer applyThresholdFilter(
io::itk::ITKImageMaskAccessor::ITKMaskImageType::ConstPointer itkImage);
}
}
}
\ No newline at end of file
diff --git a/testing/apps/VoxelizerTool/VoxelizerToolDifferentCommandsTest.cpp b/testing/apps/VoxelizerTool/VoxelizerToolDifferentCommandsTest.cpp
index 527fe02..c7f3cc3 100644
--- a/testing/apps/VoxelizerTool/VoxelizerToolDifferentCommandsTest.cpp
+++ b/testing/apps/VoxelizerTool/VoxelizerToolDifferentCommandsTest.cpp
@@ -1,136 +1,130 @@
// -----------------------------------------------------------------------
// 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.
//
//------------------------------------------------------------------------
-/*!
-// @file
-// @version $Revision: 1333 $ (last changed revision)
-// @date $Date: 2016-04-22 11:12:14 +0200 (Fr, 22 Apr 2016) $ (last change date)
-// @author $Author: hentsch $ (last changed by)
-*/
#include "litCheckMacros.h"
#include <iostream>
#include <boost/filesystem.hpp>
#include "itkImage.h"
#include "itkImageFileReader.h"
#include <vector>
/*! @brief VoxelizerToolTest3.
Test the output, multipleStructs and the booleanVoxelization parameter.
*/
namespace rttb
{
namespace testing
{
//path to the current running directory. VoxelizerTool is in the same directory (Debug/Release)
extern const char* _callingAppPath;
int VoxelizerToolDifferentCommandsTest(int argc, char* argv[])
{
PREPARE_DEFAULT_TEST_REPORTING;
typedef itk::Image< double, 3 > ImageType;
typedef itk::ImageFileReader<ImageType> ReaderType;
std::string voxelizerToolExe;
std::string tempDirectory;
std::string structFile;
std::string referenceFile;
if (argc > 4)
{
voxelizerToolExe = argv[1];
tempDirectory = argv[2];
structFile = argv[3];
referenceFile = argv[4];
}
std::vector<std::string> commands;
commands.push_back("\"Niere.*\" -m -o Test.hdr");
commands.push_back("\"Rueckenmark\" -o Boolean.hdr -z");
std::vector<std::string> filenames;
filenames.push_back("Test_Niere li");
filenames.push_back("Test_Niere re");
filenames.push_back("Boolean");
std::vector<std::pair<ImageType::IndexType, ImageType::PixelType> > voxelsToTestInside;
std::vector<std::pair<ImageType::IndexType, ImageType::PixelType> > voxelsToTestOutside;
voxelsToTestInside.push_back(std::make_pair(ImageType::IndexType{ 48, 31, 18 }, 1.0)); //Niere li inside
voxelsToTestOutside.push_back(std::make_pair(ImageType::IndexType{ 19, 31, 18 }, 0.0)); //Niere li outside
voxelsToTestInside.push_back(std::make_pair(ImageType::IndexType{ 19, 31, 18 }, 1.0)); //Niere re inside
voxelsToTestOutside.push_back(std::make_pair(ImageType::IndexType{ 48, 31, 18 }, 0.0)); //Niere re outside
voxelsToTestInside.push_back(std::make_pair(ImageType::IndexType{ 35, 32, 30 }, 1.0)); //Rueckenmark inside
voxelsToTestOutside.push_back(std::make_pair(ImageType::IndexType{ 35, 30, 23 }, 0.0)); //Rueckenmark outside
boost::filesystem::path callingPath(_callingAppPath);
std::string voxelizerToolExeWithPath = callingPath.parent_path().string() + "/" + voxelizerToolExe;
std::string baseCommand = voxelizerToolExeWithPath;
baseCommand += " -s \"" + structFile + "\"";
baseCommand += " -r \"" + referenceFile + "\"";
baseCommand += " -e ";
for (size_t i = 0; i < commands.size(); i++)
{
std::string command = baseCommand + commands.at(i);
int returnValue = system(command.c_str());
std::cout << "Command line call: " + command << std::endl;
CHECK_EQUAL(returnValue, 0);
}
for (size_t i = 0; i < filenames.size(); i++)
{
const std::string HDRfileName = tempDirectory + "/" + filenames.at(i) + ".hdr";
boost::filesystem::path HDRFile(HDRfileName);
const std::string IMGfileName = tempDirectory + "/" + filenames.at(i) + ".img";
boost::filesystem::path IMGFile(IMGfileName);
CHECK_EQUAL(boost::filesystem::exists(HDRFile), true);
CHECK_EQUAL(boost::filesystem::exists(IMGFile), true);
//check voxel values
if (boost::filesystem::exists(HDRFile))
{
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(HDRfileName);
reader->Update();
ReaderType::OutputImageType::ConstPointer image = reader->GetOutput();
ImageType::PixelType voxelValueInside = image->GetPixel(voxelsToTestInside.at(i).first);
ImageType::PixelType expectedVoxelValueInside = voxelsToTestInside.at(i).second;
CHECK_EQUAL(voxelValueInside, expectedVoxelValueInside);
ImageType::PixelType voxelValueOutside = image->GetPixel(voxelsToTestOutside.at(i).first);
ImageType::PixelType expectedVoxelValueOutside = voxelsToTestOutside.at(i).second;
CHECK_EQUAL(voxelValueOutside, expectedVoxelValueOutside);
}
if (boost::filesystem::exists(IMGFile))
{
boost::filesystem::remove(IMGFile);
}
if (boost::filesystem::exists(HDRFile))
{
boost::filesystem::remove(HDRFile);
}
}
RETURN_AND_REPORT_TEST_SUCCESS;
}
}
}
diff --git a/testing/apps/VoxelizerTool/VoxelizerToolIncorrectCommandsTest.cpp b/testing/apps/VoxelizerTool/VoxelizerToolIncorrectCommandsTest.cpp
index 398b55d..7b112d1 100644
--- a/testing/apps/VoxelizerTool/VoxelizerToolIncorrectCommandsTest.cpp
+++ b/testing/apps/VoxelizerTool/VoxelizerToolIncorrectCommandsTest.cpp
@@ -1,120 +1,114 @@
// -----------------------------------------------------------------------
// 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.
//
//------------------------------------------------------------------------
-/*!
-// @file
-// @version $Revision: 1221 $ (last changed revision)
-// @date $Date: 2015-12-01 13:43:31 +0100 (Di, 01 Dez 2015) $ (last change date)
-// @author $Author: hentsch $ (last changed by)
-*/
#include <iostream>
#include "litCheckMacros.h"
#include <boost/filesystem.hpp>
/*! @brief VoxelizerToolTest4.
Test incorrect commands with a wrong structfile, referencefile and a wrong struct.
if the command return one, the program could not run to the end.
return zero the command is correct
*/
namespace rttb
{
namespace testing
{
//path to the current running directory. VoxelizerTool is in the same directory (Debug/Release)
extern const char* _callingAppPath;
int VoxelizerToolIncorrectCommandsTest(int argc, char* argv[])
{
PREPARE_DEFAULT_TEST_REPORTING;
std::string voxelizerToolExe;
std::string structFile;
std::string invalidStructFile;
std::string invalidReferenceFile;
std::string referenceFile;
std::string structureName;
std::string invalidStructureName;
if (argc > 7)
{
voxelizerToolExe = argv[1];
structFile = argv[2];
invalidStructFile = argv[3];
referenceFile = argv[4];
invalidReferenceFile = argv[5];
structureName = argv[6];
invalidStructureName = argv[7];
}
boost::filesystem::path callingPath(_callingAppPath);
std::string voxelizerToolExeWithPath = callingPath.parent_path().string() + "/" + voxelizerToolExe;
std::string tooFewArgumentsCommand = voxelizerToolExeWithPath;
tooFewArgumentsCommand += " -s " + invalidStructFile;
tooFewArgumentsCommand += " -r " + referenceFile;
std::cout << "Command line call: " + tooFewArgumentsCommand << std::endl;
CHECK_EQUAL(system(tooFewArgumentsCommand.c_str()) != 0, true);
tooFewArgumentsCommand = voxelizerToolExeWithPath;
tooFewArgumentsCommand += " -s " + invalidStructFile;
tooFewArgumentsCommand += " -e " + structureName;
std::cout << "Command line call: " + tooFewArgumentsCommand << std::endl;
CHECK_EQUAL(system(tooFewArgumentsCommand.c_str()) != 0, true);
tooFewArgumentsCommand = voxelizerToolExeWithPath;
std::cout << "Command line call: " + tooFewArgumentsCommand << std::endl;
CHECK_EQUAL(system(tooFewArgumentsCommand.c_str()) != 0, true);
std::string noOutputEndingCommand = voxelizerToolExeWithPath;
noOutputEndingCommand += " -s " + invalidStructFile;
noOutputEndingCommand += " -r " + referenceFile;
noOutputEndingCommand += " -e " + structureName;
noOutputEndingCommand += " -o bla";
std::cout << "Command line call: " + noOutputEndingCommand << std::endl;
CHECK_EQUAL(system(noOutputEndingCommand.c_str()) != 0, true);
std::string structCommand = voxelizerToolExeWithPath;
structCommand += " -s " + invalidStructFile;
structCommand += " -r " + referenceFile;
structCommand += " -e " + structureName;
std::cout << "Command line call: " + structCommand << std::endl;
CHECK_EQUAL(system(structCommand.c_str()) != 0, true);
std::string referenceCommand = voxelizerToolExeWithPath;
referenceCommand += " -s " + structFile;
referenceCommand += " -r " + invalidReferenceFile;
referenceCommand += " -e " + structureName;
std::cout << "Command line call: " + referenceCommand << std::endl;
CHECK_EQUAL(system(referenceCommand.c_str()) != 0, true);
std::string structureNameCommand = voxelizerToolExeWithPath;
structureNameCommand += " -s " + structFile;
structureNameCommand += " -r " + referenceFile;
structureNameCommand += +" -e " + invalidStructureName;
std::cout << "Command line call: " + structureNameCommand << std::endl;
CHECK_EQUAL(system(structureNameCommand.c_str()), 0);
std::string referenceLoadingStyleCommand = voxelizerToolExeWithPath;
referenceLoadingStyleCommand += " -s " + structFile;
referenceLoadingStyleCommand += " -r " + referenceFile;
referenceLoadingStyleCommand += +" -e " + invalidStructureName;
referenceLoadingStyleCommand += +" -y nonsense";
std::cout << "Command line call: " + referenceLoadingStyleCommand << std::endl;
CHECK_EQUAL(system(referenceLoadingStyleCommand.c_str()) != 0, true);
RETURN_AND_REPORT_TEST_SUCCESS;
}
}
}
diff --git a/testing/apps/VoxelizerTool/VoxelizerToolVoxelValueTest.cpp b/testing/apps/VoxelizerTool/VoxelizerToolVoxelValueTest.cpp
index 380bc25..6a2a124 100644
--- a/testing/apps/VoxelizerTool/VoxelizerToolVoxelValueTest.cpp
+++ b/testing/apps/VoxelizerTool/VoxelizerToolVoxelValueTest.cpp
@@ -1,133 +1,127 @@
// -----------------------------------------------------------------------
// 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.
//
//------------------------------------------------------------------------
-/*!
-// @file
-// @version $Revision: 1333 $ (last changed revision)
-// @date $Date: 2016-04-22 11:12:14 +0200 (Fr, 22 Apr 2016) $ (last change date)
-// @author $Author: hentsch $ (last changed by)
-*/
#include "litCheckMacros.h"
#include <boost/filesystem.hpp>
#include "itkImage.h"
#include "itkImageFileReader.h"
#include <vector>
#include <boost/assign/list_of.hpp>
/*! @brief VoxelizerToolTest5.
Search the coordinate at the Image and return the Voxel(Pixel) value.
*/
namespace rttb
{
namespace testing
{
//path to the current running directory. VoxelizerTool is in the same directory (Debug/Release)
extern const char* _callingAppPath;
int VoxelizerToolVoxelValue(int argc, char* argv[])
{
PREPARE_DEFAULT_TEST_REPORTING;
typedef itk::Image< double, 3 > ImageType;
typedef itk::ImageFileReader<ImageType> ReaderType;
std::string voxelizerToolExe;
std::string tempDirectory;
std::string structFile;
std::string referenceFile;
std::string structName;
if (argc > 5)
{
voxelizerToolExe = argv[1];
tempDirectory = argv[2];
structFile = argv[3];
referenceFile = argv[4];
structName = argv[5];
}
boost::filesystem::path callingPath(_callingAppPath);
std::string voxelizerToolExeWithPath = callingPath.parent_path().string() + "/" + voxelizerToolExe;
std::string command = voxelizerToolExeWithPath;
command += " -s \"" + structFile + "\"";
command += " -r \"" + referenceFile + "\"";
command += " -e " + structName;
command += " -o testOutputVoxelValue.hdr";
int returnValue = system(command.c_str());
CHECK_EQUAL(returnValue, 0);
//image values taken in Mevislab
//Index inside
ImageType::IndexType voxelInside1 = {{20, 30, 30}};
ImageType::IndexType voxelInside2 = {{30, 10, 40}};
//Outside index
ImageType::IndexType voxelOutside1 = {{40, 30, 30}};
ImageType::IndexType voxelOutside2 = {{10, 40, 30}};
//Border index
ImageType::IndexType voxelBorder1 = {{12, 23, 27}};
ImageType::IndexType voxelBorder2 = {{34, 21, 31}};
std::vector<ImageType::IndexType> voxelIndices = boost::assign::list_of(voxelInside1)(voxelInside2)(
voxelOutside1)(
voxelOutside2)(voxelBorder1)(voxelBorder2);
std::vector<ImageType::PixelType> expectedVoxelValues = boost::assign::list_of(1.0)(1.0)(0.0)(0.0)(
0.265865)(0.819613);
std::string filenameHDRWithVoxelization = tempDirectory + "/testOutputVoxelValue.hdr";
std::string filenameIMGWithVoxelization = tempDirectory + "/testOutputVoxelValue.img";
CHECK(boost::filesystem::exists(filenameHDRWithVoxelization));
CHECK(boost::filesystem::exists(filenameIMGWithVoxelization));
if (boost::filesystem::exists(filenameHDRWithVoxelization))
{
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(filenameHDRWithVoxelization);
reader->Update();
ReaderType::OutputImageType::ConstPointer image = reader->GetOutput();
for (size_t i = 0; i < voxelIndices.size(); i++)
{
ImageType::PixelType voxelValue = image->GetPixel(voxelIndices.at(i));
ImageType::PixelType expectedVoxelValue = expectedVoxelValues.at(i);
if (expectedVoxelValue == 0.0 || expectedVoxelValue == 1.0)
{
CHECK_EQUAL(voxelValue, expectedVoxelValue);
}
else
{
CHECK_CLOSE(voxelValue, expectedVoxelValue, 1e-4);
}
}
boost::filesystem::remove(filenameHDRWithVoxelization);
if (boost::filesystem::exists(filenameIMGWithVoxelization))
{
boost::filesystem::remove(filenameIMGWithVoxelization);
}
}
RETURN_AND_REPORT_TEST_SUCCESS;
}
}
}