diff --git a/code/io/helax/rttbDicomHelaxDoseAccessor.cpp b/code/io/helax/rttbDicomHelaxDoseAccessor.cpp
index 0df602e..733cc4f 100644
--- a/code/io/helax/rttbDicomHelaxDoseAccessor.cpp
+++ b/code/io/helax/rttbDicomHelaxDoseAccessor.cpp
@@ -1,326 +1,319 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
#include "rttbDicomHelaxDoseAccessor.h"
#include "boost/lexical_cast.hpp"
#include "boost/filesystem/operations.hpp"
#include "boost/filesystem/path.hpp"
#include "boost/numeric/ublas/matrix.hpp"
#include <cstdlib>
-
#include "rttbInvalidDoseException.h"
#include "rttbDcmrtException.h"
#include "rttbInvalidParameterException.h"
namespace rttb
{
namespace io
{
namespace helax
{
DicomHelaxDoseAccessor::~DicomHelaxDoseAccessor()
= default;
DicomHelaxDoseAccessor::DicomHelaxDoseAccessor(std::vector<DRTDoseIODPtr> aDICOMRTDoseVector)
{
for (const auto & i : aDICOMRTDoseVector)
{
_doseVector.push_back(i);
}
this->begin();
}
bool DicomHelaxDoseAccessor::begin()
{
if (_doseVector.size() == 0)
{
throw core::InvalidParameterException(" The size of aDICOMRTDoseVector is 0!");
}
assembleGeometricInfo();
_doseData.clear();
OFString doseGridScalingStr;
_doseVector.at(0)->getDoseGridScaling(
doseGridScalingStr);//get the first dose grid scaling as _doseGridScaling
try
{
_doseGridScaling = boost::lexical_cast<double>(doseGridScalingStr.c_str());
}
catch (boost::bad_lexical_cast&)
{
throw core::InvalidDoseException("Dose grid scaling not readable or = 0!") ;
}
for (auto dose : _doseVector)
{
OFString currentDoseGridScalingStr;
dose->getDoseGridScaling(currentDoseGridScalingStr);
double currentDoseGridScaling;
try
{
currentDoseGridScaling = boost::lexical_cast<double>(currentDoseGridScalingStr.c_str());
}
catch (boost::bad_lexical_cast&)
{
throw core::InvalidDoseException("Dose grid scaling not readable or = 0!") ;
}
OFCondition status;
DcmFileFormat fileformat;
DcmItem doseitem;
status = dose->write(doseitem);
if (status.good())
{
unsigned long count;
const Uint16* pixelData;
status = doseitem.findAndGetUint16Array(DcmTagKey(0x7fe0, 0x0010), pixelData, &count);
if (status.good())
{
for (unsigned int j = 0;
j < static_cast<unsigned int>(_geoInfo.getNumColumns()*_geoInfo.getNumRows()); j++)
{
auto data = static_cast<Uint16>(pixelData[j] * currentDoseGridScaling /
_doseGridScaling);
this->_doseData.push_back(data); //recalculate dose data
}
}
else
{
throw dicom::DcmrtException("Read Pixel Data (7FE0,0010) failed!");
}
}
else
{
throw dicom::DcmrtException("Read DICOM-RT Dose file failed!");
}
}
return true;
}
void DicomHelaxDoseAccessor::assembleGeometricInfo()
{
DRTDoseIODPtr dose = _doseVector.at(0);
Uint16 temp = 0;
dose->getColumns(temp);
_geoInfo.setNumColumns(temp);
temp = 0;
dose->getRows(temp);
_geoInfo.setNumRows(temp);
OFString numberOfFramesStr;
dose->getNumberOfFrames(numberOfFramesStr);
if (!numberOfFramesStr.empty())
{
_geoInfo.setNumSlices(boost::lexical_cast<int>(numberOfFramesStr.c_str()));
}
else
{
_geoInfo.setNumSlices((VoxelGridDimensionType)_doseVector.size());
}
if (_geoInfo.getNumColumns() == 0 || _geoInfo.getNumRows() == 0 || _geoInfo.getNumSlices() == 0)
{
throw core::InvalidDoseException("Empty dicom dose!") ;
}
OFString imageOrientationRowX;
dose->getImageOrientationPatient(imageOrientationRowX, 0);
OFString imageOrientationRowY;
dose->getImageOrientationPatient(imageOrientationRowY, 1);
OFString imageOrientationRowZ;
dose->getImageOrientationPatient(imageOrientationRowZ, 2);
OFString imageOrientationColumnX;
dose->getImageOrientationPatient(imageOrientationColumnX, 3);
OFString imageOrientationColumnY;
dose->getImageOrientationPatient(imageOrientationColumnY, 4);
OFString imageOrientationColumnZ;
dose->getImageOrientationPatient(imageOrientationColumnZ, 5);
WorldCoordinate3D imageOrientationRow;
WorldCoordinate3D imageOrientationColumn;
try
{
imageOrientationRow(0) = boost::lexical_cast<WorldCoordinate>(imageOrientationRowX.c_str());
imageOrientationRow(1) = boost::lexical_cast<WorldCoordinate>(imageOrientationRowY.c_str());
imageOrientationRow(2) = boost::lexical_cast<WorldCoordinate>(imageOrientationRowZ.c_str());
imageOrientationColumn(0) = boost::lexical_cast<WorldCoordinate>(imageOrientationColumnX.c_str());
imageOrientationColumn(1) = boost::lexical_cast<WorldCoordinate>(imageOrientationColumnY.c_str());
imageOrientationColumn(2) = boost::lexical_cast<WorldCoordinate>(imageOrientationColumnZ.c_str());
}
catch (boost::bad_lexical_cast&)
{
throw core::InvalidDoseException("boost::lexical_cast WorldCoordinate failed! Can not read image orientation X/Y/Z!")
;
}
OrientationMatrix orientation;
orientation(0, 0) = imageOrientationRow.x();
orientation(1, 0) = imageOrientationRow.y();
orientation(2, 0) = imageOrientationRow.z();
orientation(0, 1) = imageOrientationColumn.x();
orientation(1, 1) = imageOrientationColumn.y();
orientation(2, 1) = imageOrientationColumn.z();
WorldCoordinate3D perpendicular = imageOrientationRow.cross(imageOrientationColumn);
orientation(0, 2) = perpendicular.x();
orientation(1, 2) = perpendicular.y();
orientation(2, 2) = perpendicular.z();
_geoInfo.setOrientationMatrix(orientation);
OFString imagePositionX;
dose->getImagePositionPatient(imagePositionX, 0);
OFString imagePositionY;
dose->getImagePositionPatient(imagePositionY, 1);
OFString imagePositionZ;
dose->getImagePositionPatient(imagePositionZ, 2);
WorldCoordinate3D imagePositionPatient;
try
{
imagePositionPatient(0) = boost::lexical_cast<WorldCoordinate>(imagePositionX.c_str());
imagePositionPatient(1) = boost::lexical_cast<WorldCoordinate>(imagePositionY.c_str());
imagePositionPatient(2) = boost::lexical_cast<WorldCoordinate>(imagePositionZ.c_str());
}
catch (boost::bad_lexical_cast&)
{
throw core::InvalidDoseException("boost::lexical_cast ImagePosition failed! Can not read image position X/Y/Z!")
;
}
_geoInfo.setImagePositionPatient(imagePositionPatient);
SpacingVectorType3D spacingVector;
OFString pixelSpacingRowStr;
dose->getPixelSpacing(pixelSpacingRowStr, 0);
OFString pixelSpacingColumnStr;
dose->getPixelSpacing(pixelSpacingColumnStr, 1);
try
{
spacingVector(1) = boost::lexical_cast<GridVolumeType>(pixelSpacingRowStr.c_str());
spacingVector(0) = boost::lexical_cast<GridVolumeType>(pixelSpacingColumnStr.c_str());
}
catch (boost::bad_lexical_cast&)
{
throw core::InvalidDoseException("Can not read Pixel Spacing Row/Column!") ;
}
_geoInfo.setSpacing(spacingVector);
if (_geoInfo.getSpacing()(0) == 0 || _geoInfo.getSpacing()(1) == 0)
{
throw core::InvalidDoseException("Pixel spacing not readable or = 0!");
}
OFString sliceThicknessStr;
dose->getSliceThickness(sliceThicknessStr);
try
{
spacingVector(2) = boost::lexical_cast<GridVolumeType>(sliceThicknessStr.c_str());
}
catch (boost::bad_lexical_cast&)
{
spacingVector(2) = 0
;//if no information about slice thickness, set to 0 and calculate it using z coordinate difference between 1. and 2. dose
}
if (spacingVector(2) == 0)
{
if (_doseVector.size() > 1)
{
DRTDoseIODPtr dose2 = _doseVector.at(1);//get the 2. dose
OFString imagePositionZ2;
dose2->getImagePositionPatient(imagePositionZ2, 2);
try
{
spacingVector(2) = boost::lexical_cast<GridVolumeType>(imagePositionZ2.c_str()) -
imagePositionPatient(
2); //caculate slicethickness
}
catch (boost::bad_lexical_cast&)
{
throw core::InvalidDoseException("Can not read image position Z of the 2. dose!");
}
}
else
{
std::cerr << "sliceThickness == 0! It will be replaced with pixelSpacingRow=" <<
_geoInfo.getSpacing()(0)
<< "!" << std::endl;
spacingVector(2) = spacingVector(0);
}
}
_geoInfo.setSpacing(spacingVector);
}
GenericValueType DicomHelaxDoseAccessor::getValueAt(const VoxelGridID aID) const
{
return _doseData.at(aID) * _doseGridScaling;
}
GenericValueType DicomHelaxDoseAccessor::getValueAt(const VoxelGridIndex3D& aIndex) const
{
VoxelGridID aVoxelGridID;
if (_geoInfo.convert(aIndex, aVoxelGridID))
{
return getValueAt(aVoxelGridID);
}
else
{
return -1;
}
}
}
}
}
diff --git a/code/io/helax/rttbDicomHelaxDoseAccessor.h b/code/io/helax/rttbDicomHelaxDoseAccessor.h
index ba0d8a0..0d5929d 100644
--- a/code/io/helax/rttbDicomHelaxDoseAccessor.h
+++ b/code/io/helax/rttbDicomHelaxDoseAccessor.h
@@ -1,101 +1,94 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
+
#ifndef __DICOM_HELAX_DOSE_ACCESSOR_H
#define __DICOM_HELAX_DOSE_ACCESSOR_H
#include <vector>
#include "dcmtk/config/osconfig.h" /* make sure OS specific configuration is included first */
#include "drtdose.h"
#include "rttbBaseType.h"
#include "rttbAccessorWithGeoInfoBase.h"
-
-
namespace rttb
{
namespace io
{
namespace helax
{
/*! @class DicomHelaxDoseAccessor
@brief Load dose data from a directory containing dicom dose files, each file describes the helax dose in one slice.
*/
class DicomHelaxDoseAccessor: public core::AccessorWithGeoInfoBase
{
public:
using DRTDoseIODPtr = boost::shared_ptr<DRTDoseIOD>;
private:
/*! vector of DRTDoseIOD shared pointers, each DRTDoseIOD pointer presents the dose in one slice*/
std::vector<DRTDoseIODPtr> _doseVector;
/*! vector of dose data(absolute Gy dose/doseGridScaling)*/
std::vector<Uint16> _doseData;
double _doseGridScaling;
IDType _doseUID;
DicomHelaxDoseAccessor() = delete;
protected:
/*! @brief Initialize dose data
@exception InvalidDoseException Thrown if any DRTDoseIOD pointer of _doseVector is invalid: one of column/row/numberOfFrames/doseGridScaling/pixelSpacing=0
@exception DcmrtException Throw if dcmrt error
@exception boost/bad_lexical_cast Thrown if the imported header tags are not numerical.
*/
bool begin();
/*! @brief get all required data from dicom information contained in _dose
@exception boost/bad_lexical_cast Thrown if the imported header tags are not numerical.
*/
void assembleGeometricInfo() override;
public:
~DicomHelaxDoseAccessor() override;
/*! @brief Constructor. Initialisation with a vector of DRTDoseIOD pointers
@exception InvalidDoseException Thrown if any DRTDoseIOD pointer of _doseVector is invalid: one of column/row/numberOfFrames/doseGridScaling/pixelSpacing=0
@exception DcmrtException Throw if dcmrt error
*/
DicomHelaxDoseAccessor(std::vector<DRTDoseIODPtr> aDICOMRTDoseVector);
GenericValueType getValueAt(const VoxelGridID aID) const override;
GenericValueType getValueAt(const VoxelGridIndex3D& aIndex) const override;
const IDType getUID() const override
{
return _doseUID;
};
};
}
}
}
#endif
diff --git a/code/io/helax/rttbDicomHelaxFileDoseAccessorGenerator.cpp b/code/io/helax/rttbDicomHelaxFileDoseAccessorGenerator.cpp
index 408767f..2c15a74 100644
--- a/code/io/helax/rttbDicomHelaxFileDoseAccessorGenerator.cpp
+++ b/code/io/helax/rttbDicomHelaxFileDoseAccessorGenerator.cpp
@@ -1,94 +1,88 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/lexical_cast.hpp>
#include "boost/filesystem/operations.hpp"
#include "boost/filesystem/path.hpp"
#include "boost/progress.hpp"
#include "rttbDicomHelaxFileDoseAccessorGenerator.h"
#include "rttbDicomHelaxDoseAccessor.h"
#include "rttbInvalidDoseException.h"
#include "rttbDcmrtException.h"
#include "rttbIndexOutOfBoundsException.h"
#include "rttbInvalidParameterException.h"
#include "rttbDicomFileReaderHelper.h"
namespace rttb
{
namespace io
{
namespace helax
{
DicomHelaxFileDoseAccessorGenerator::~DicomHelaxFileDoseAccessorGenerator() = default;
DicomHelaxFileDoseAccessorGenerator::DicomHelaxFileDoseAccessorGenerator(
FileNameType aDICOMRTDoseDirName)
{
_doseDirName = aDICOMRTDoseDirName;
}
core::DoseAccessorGeneratorInterface::DoseAccessorPointer
DicomHelaxFileDoseAccessorGenerator::generateDoseAccessor()
{
rttb::io::dicom::Modality doseModality = {rttb::io::dicom::Modality::RTDOSE};
std::vector<FileNameType> fileVector = rttb::io::dicom::getFileNamesWithSameUID(_doseDirName,
doseModality);
OFCondition status;
DcmFileFormat fileformat;
std::vector<DRTDoseIODPtr> doseVector;
for (auto & i : fileVector)
{
DRTDoseIODPtr dose = boost::make_shared<DRTDoseIOD>();
status = fileformat.loadFile(i.c_str());
if (!status.good())
{
throw core::InvalidDoseException("Error: load dose fileformat.loadFile failed!");
}
status = dose->read(*fileformat.getDataset());
if (!status.good())
{
throw core::InvalidDoseException("Error: read DRTDoseIOD failed!");
}
doseVector.push_back(dose);
}
_doseAccessor = boost::make_shared<io::helax::DicomHelaxDoseAccessor>(doseVector);
return _doseAccessor;
}
}
}
}
diff --git a/code/io/helax/rttbDicomHelaxFileDoseAccessorGenerator.h b/code/io/helax/rttbDicomHelaxFileDoseAccessorGenerator.h
index e3e9552..6a6a50c 100644
--- a/code/io/helax/rttbDicomHelaxFileDoseAccessorGenerator.h
+++ b/code/io/helax/rttbDicomHelaxFileDoseAccessorGenerator.h
@@ -1,79 +1,73 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
+
#ifndef __DICOM_HELAX_FILE_DOSE_ACCESSOR_GENERATOR_H
#define __DICOM_HELAX_FILE_DOSE_ACCESSOR_GENERATOR_H
#include <string>
#include <vector>
#include <exception>
#include "dcmtk/config/osconfig.h" /* make sure OS specific configuration is included first */
#include "drtdose.h"
#include "rttbDoseAccessorGeneratorBase.h"
#include "rttbBaseType.h"
-
namespace rttb
{
namespace io
{
namespace helax
{
/*! @class DicomHelaxFileDoseAccessorGenerator
@brief Load dose data from dicom helax files and generate DoseAccessor
*/
class DicomHelaxFileDoseAccessorGenerator: public core::DoseAccessorGeneratorBase
{
public:
using DRTDoseIODPtr = boost::shared_ptr<DRTDoseIOD>;
protected:
private:
FileNameType _doseDirName;
DicomHelaxFileDoseAccessorGenerator() = delete;
public:
~DicomHelaxFileDoseAccessorGenerator() override;
/*! @brief Constructor. Initialisation with a directory name
*/
DicomHelaxFileDoseAccessorGenerator(FileNameType aDICOMRTDoseDirName);
/*! @brief Generate DoseAccessor
@return Return shared pointer of DoseAccessor.
@exception InvalidParameterException Thrown if aDICOMRTDoseDirName is not found
@exception InvalidDoseException Thrown if any loaded dose is invalid: one of column/row/numberOfFrames/doseGridScaling/pixelSpacing=0
@exception DcmrtException Throw if dcmrt error
*/
DoseAccessorPointer generateDoseAccessor() override ;
};
}
}
}
#endif
diff --git a/code/io/helax/rttbDicomHelaxIODVecDoseAccessorGenerator.cpp b/code/io/helax/rttbDicomHelaxIODVecDoseAccessorGenerator.cpp
index 801211e..820a131 100644
--- a/code/io/helax/rttbDicomHelaxIODVecDoseAccessorGenerator.cpp
+++ b/code/io/helax/rttbDicomHelaxIODVecDoseAccessorGenerator.cpp
@@ -1,56 +1,50 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
#include <boost/make_shared.hpp>
#include "rttbDicomHelaxIODVecDoseAccessorGenerator.h"
#include "rttbDicomHelaxDoseAccessor.h"
namespace rttb
{
namespace io
{
namespace helax
{
DicomHelaxIODVecDoseAccessorGenerator::~DicomHelaxIODVecDoseAccessorGenerator() = default;
DicomHelaxIODVecDoseAccessorGenerator::DicomHelaxIODVecDoseAccessorGenerator(
std::vector<DRTDoseIODPtr>&
aDICOMRTDoseVector)
{
_dosePtrVector = aDICOMRTDoseVector;
}
core::DoseAccessorGeneratorInterface::DoseAccessorPointer
DicomHelaxIODVecDoseAccessorGenerator::generateDoseAccessor()
{
_doseAccessor = boost::make_shared<io::helax::DicomHelaxDoseAccessor>(_dosePtrVector);
return _doseAccessor;
}
}
}
}
diff --git a/code/io/helax/rttbDicomHelaxIODVecDoseAccessorGenerator.h b/code/io/helax/rttbDicomHelaxIODVecDoseAccessorGenerator.h
index 2ed0def..86716f8 100644
--- a/code/io/helax/rttbDicomHelaxIODVecDoseAccessorGenerator.h
+++ b/code/io/helax/rttbDicomHelaxIODVecDoseAccessorGenerator.h
@@ -1,74 +1,68 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
+
#ifndef __DICOM_HELAX_IOD_VEC_DOSE_ACCESSOR_GENERATOR_H
#define __DICOM_HELAX_IOD_VEC_DOSE_ACCESSOR_GENERATOR_H
#include <vector>
#include "dcmtk/config/osconfig.h" /* make sure OS specific configuration is included first */
#include "drtdose.h"
#include "rttbDoseAccessorGeneratorBase.h"
-
namespace rttb
{
namespace io
{
namespace helax
{
/*! @class DicomHelaxIODVecDoseAccessorGenerator
@brief Generate DoseAccessor with a vector of DRTDoseIOD.
*/
class DicomHelaxIODVecDoseAccessorGenerator: public core::DoseAccessorGeneratorBase
{
public:
using DRTDoseIODPtr = boost::shared_ptr<DRTDoseIOD>;
protected:
private:
std::vector<DRTDoseIODPtr> _dosePtrVector;
DicomHelaxIODVecDoseAccessorGenerator() = delete;
public:
~DicomHelaxIODVecDoseAccessorGenerator() override;
/*! @brief Constructor. Initialisation with a vector of DRTDoseIOD pointers
*/
DicomHelaxIODVecDoseAccessorGenerator(std::vector<DRTDoseIODPtr>& aDICOMRTDoseVector);
/*! @brief Generate DoseAccessor
@return Return shared pointer of DoseAccessor.
@exception InvalidDoseException Thrown if any DRTDoseIOD pointer of _doseVector is invalid: one of column/row/numberOfFrames/doseGridScaling/pixelSpacing=0
@exception DcmrtException Throw if dcmrt error
*/
DoseAccessorPointer generateDoseAccessor() override ;
};
}
}
}
#endif
diff --git a/code/io/itk/itkDoseAccessorImageFilter.cpp b/code/io/itk/itkDoseAccessorImageFilter.cpp
index e5c9331..2be3390 100644
--- a/code/io/itk/itkDoseAccessorImageFilter.cpp
+++ b/code/io/itk/itkDoseAccessorImageFilter.cpp
@@ -1,84 +1,76 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
-
#include "itkDoseAccessorImageFilter.h"
#include "itkImageRegionIterator.h"
#include "itkImageRegionConstIteratorWithIndex.h"
#include "itkProgressReporter.h"
-
namespace itk
{
/**
* Constructor
*/
DoseAccessorImageFilter
::DoseAccessorImageFilter()
{
this->SetNumberOfRequiredInputs(1);
}
void
DoseAccessorImageFilter
::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
ThreadIdType threadId)
{
ProgressReporter progress(this, threadId,
outputRegionForThread.GetNumberOfPixels());
using ImageRegionConstIteratorType = ImageRegionConstIteratorWithIndex<InputImageType>;
using OutputImageRegionIteratorType = ImageRegionIterator<OutputImageType>;
InputImagePointer inputPtr = dynamic_cast< InputImageType* >(ProcessObject::GetInput(0));
ImageRegionConstIteratorType inputItr;
if (inputPtr)
{
inputItr = ImageRegionConstIteratorType(inputPtr, outputRegionForThread);
}
OutputImagePointer outputPtr = dynamic_cast< OutputImageType* >(ProcessObject::GetOutput(0));
OutputImageRegionIteratorType outputItr;
if (outputPtr)
{
outputItr = OutputImageRegionIteratorType(outputPtr, outputRegionForThread);
}
if (inputPtr && outputPtr)
{
while (!(outputItr.IsAtEnd()))
{
ImageRegionConstIteratorType::IndexType index = inputItr.GetIndex();
rttb::VoxelGridIndex3D doseIndex(index[0], index[1], index[2]);
outputItr.Set(m_Accessor->getValueAt(doseIndex));
++outputItr;
++inputItr;
progress.CompletedPixel();
}
}
}
} // end namespace itk
diff --git a/code/io/itk/itkDoseAccessorImageFilter.h b/code/io/itk/itkDoseAccessorImageFilter.h
index f41e9a9..9d072f6 100644
--- a/code/io/itk/itkDoseAccessorImageFilter.h
+++ b/code/io/itk/itkDoseAccessorImageFilter.h
@@ -1,118 +1,112 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
#ifndef __itkDoseAccessorImageFilter_h
#define __itkDoseAccessorImageFilter_h
#include "itkImageToImageFilter.h"
#include "rttbDoseAccessorInterface.h"
#include "rttbITKImageAccessor.h"
namespace itk
{
/** \class DoseAccessorImageFilter
* \brief Perform a generic pixel-wise operation on the input image by setting its pixel values according to the dose accessor output.
*
* \ingroup IntensityImageFilters MultiThreaded
* \ingroup ITKImageIntensity
*/
typedef rttb::io::itk::ITKImageAccessor::ITKImageType RTTBDoseImageType;
class ITK_EXPORT DoseAccessorImageFilter:
public ImageToImageFilter< RTTBDoseImageType, RTTBDoseImageType >
{
public:
/** Standard class typedefs. */
typedef DoseAccessorImageFilter Self;
typedef ImageToImageFilter< RTTBDoseImageType, RTTBDoseImageType > Superclass;
typedef SmartPointer< Self > Pointer;
typedef SmartPointer< const Self > ConstPointer;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Run-time type information (and related methods). */
itkTypeMacro(DoseAccessorImageFilter, ImageToImageFilter);
/** Some typedefs. */
typedef RTTBDoseImageType InputImageType;
typedef InputImageType::Pointer InputImagePointer;
typedef InputImageType::RegionType InputImageRegionType;
typedef InputImageType::PixelType InputImagePixelType;
typedef RTTBDoseImageType OutputImageType;
typedef OutputImageType::Pointer OutputImagePointer;
typedef OutputImageType::RegionType OutputImageRegionType;
typedef OutputImageType::PixelType OutputImagePixelType;
typedef rttb::core::DoseAccessorInterface DoseAccessorType;
typedef rttb::core::DoseAccessorInterface::Pointer DoseAccessorPointer;
/** Get the accessor pointer. */
DoseAccessorPointer GetAccessor()
{
return m_Accessor;
}
/** Set the accessor pointer. */
void SetAccessor(DoseAccessorPointer accessor)
{
if (m_Accessor != accessor)
{
m_Accessor = accessor;
this->Modified();
}
}
/** ImageDimension constants */
itkStaticConstMacro(
InputImageDimension, unsigned int, InputImageType::ImageDimension);
itkStaticConstMacro(
OutputImageDimension, unsigned int, OutputImageType::ImageDimension);
protected:
DoseAccessorImageFilter();
~DoseAccessorImageFilter() override {}
/** DoseAccessorImageFilter can be implemented as a multi threaded filter.
* Therefore, this implementation provides a ThreadedGenerateData() routine
* which is called for each processing thread. The output image data is
* allocated automatically by the superclass prior to calling
* ThreadedGenerateData(). ThreadedGenerateData can only write to the
* portion of the output image specified by the parameter
* "outputRegionForThread"
*
* \sa ImageToImageFilter::ThreadedGenerateData(),
* ImageToImageFilter::GenerateData() */
void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
ThreadIdType threadId) override;
private:
DoseAccessorImageFilter(const Self&); //purposely not implemented
void operator=(const Self&); //purposely not implemented
DoseAccessorPointer m_Accessor;
};
} // end namespace itk
#endif
diff --git a/code/io/itk/itkMaskAccessorImageSource.cpp b/code/io/itk/itkMaskAccessorImageSource.cpp
index b781774..2a523f9 100644
--- a/code/io/itk/itkMaskAccessorImageSource.cpp
+++ b/code/io/itk/itkMaskAccessorImageSource.cpp
@@ -1,108 +1,101 @@
// -----------------------------------------------------------------------
// 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: 1233 $ (last changed revision)
-// @date $Date: 2016-01-20 15:47:47 +0100 (Mi, 20 Jan 2016) $ (last change date)
-// @author $Author: hentsch $ (last changed by)
-*/
-
#include "itkMaskAccessorImageSource.h"
#include "itkImageRegionIterator.h"
#include "itkImageRegionConstIteratorWithIndex.h"
#include "itkProgressReporter.h"
#include "itkExceptionObject.h"
#include "rttbGeometricInfo.h"
namespace itk
{
/**
* Constructor
*/
MaskAccessorImageSource
::MaskAccessorImageSource()
= default;
void
MaskAccessorImageSource
::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
ThreadIdType threadId)
{
ProgressReporter progress(this, threadId,
outputRegionForThread.GetNumberOfPixels());
using OutputImageRegionIteratorType = ImageRegionIterator<OutputImageType>;
OutputImagePointer outputPtr = dynamic_cast< OutputImageType* >(ProcessObject::GetOutput(0));
OutputImageRegionIteratorType outputItr;
if (outputPtr)
{
outputItr = OutputImageRegionIteratorType(outputPtr, outputRegionForThread);
for (; !(outputItr.IsAtEnd()); ++outputItr)
{
OutputImageType::IndexType index = outputItr.GetIndex();
rttb::VoxelGridIndex3D maskIndex(index[0], index[1], index[2]);
rttb::VoxelGridID id = 0;
if (m_Accessor->getGeometricInfo().convert(maskIndex, id))
{
auto finding = m_idMap.find(id);
if (finding != m_idMap.end())
{
// Set the current pixel
outputItr.Set(m_MaskedVoxels->at(finding->second).getRelevantVolumeFraction());
}
}
else
{
if (m_FailsOnInvalidIDs)
{
itkExceptionMacro(<<"invalid Mask index. Index:"<<index);
}
else
{
outputItr.Set(m_InvalidMaskValue);
}
}
progress.CompletedPixel();
}
}
}
void
MaskAccessorImageSource
::BeforeThreadedGenerateData()
{
OutputImagePointer outputPtr = dynamic_cast< OutputImageType* >(ProcessObject::GetOutput(0));
outputPtr->FillBuffer(0.0);
//The id map approach and working with relevant voxel vector is a workarround till task T22067 is solved and and can be used again.
m_MaskedVoxels = m_Accessor->getRelevantVoxelVector();
m_idMap.clear();
for (rttb::core::MaskAccessorInterface::MaskVoxelList::size_type pos = 0; pos < m_MaskedVoxels->size(); ++pos)
{
m_idMap.insert(std::make_pair((*m_MaskedVoxels)[pos].getVoxelGridID(), pos));
}
}
} // end namespace itk
diff --git a/code/io/itk/itkMaskAccessorImageSource.h b/code/io/itk/itkMaskAccessorImageSource.h
index 543d992..c16a034 100644
--- a/code/io/itk/itkMaskAccessorImageSource.h
+++ b/code/io/itk/itkMaskAccessorImageSource.h
@@ -1,111 +1,105 @@
// -----------------------------------------------------------------------
// 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 __itkMaskAccessorImageSource_h
#define __itkMaskAccessorImageSource_h
#include "itkGenerateImageSource.h"
#include "rttbMaskAccessorInterface.h"
#include "rttbITKImageMaskAccessor.h"
namespace itk
{
/** \class MaskAccessorImageSource
* \brief Converts a given mask accessor into an itk image.
*
*/
typedef rttb::io::itk::ITKImageMaskAccessor::ITKMaskImageType RTTBMaskImageType;
class ITK_EXPORT MaskAccessorImageSource:
public GenerateImageSource< RTTBMaskImageType>
{
public:
/** Standard class typedefs. */
typedef MaskAccessorImageSource Self;
typedef GenerateImageSource< RTTBMaskImageType > Superclass;
typedef SmartPointer< Self > Pointer;
typedef SmartPointer< const Self > ConstPointer;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Run-time type information (and related methods). */
itkTypeMacro(MaskAccessorImageSource, ImageToImageFilter);
/** Some typedefs. */
typedef RTTBMaskImageType OutputImageType;
typedef OutputImageType::Pointer OutputImagePointer;
typedef OutputImageType::RegionType OutputImageRegionType;
typedef OutputImageType::PixelType OutputImagePixelType;
typedef rttb::core::MaskAccessorInterface AccessorType;
typedef rttb::core::MaskAccessorInterface::Pointer AccessorPointer;
/** Get the accessor pointer. */
itkGetConstMacro(Accessor, AccessorPointer);
/** Set the accessor pointer. */
void SetAccessor(AccessorPointer accessor)
{
if (m_Accessor != accessor)
{
m_Accessor = accessor;
this->Modified();
}
}
itkSetMacro(FailsOnInvalidIDs, bool);
itkGetConstMacro(FailsOnInvalidIDs, bool);
itkSetMacro(InvalidMaskValue, OutputImageType::ValueType);
itkGetConstMacro(InvalidMaskValue, OutputImageType::ValueType);
/** ImageDimension constants */
itkStaticConstMacro(
OutputImageDimension, unsigned int, OutputImageType::ImageDimension);
protected:
MaskAccessorImageSource();
~MaskAccessorImageSource() override {}
void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
ThreadIdType threadId) override;
void BeforeThreadedGenerateData() override;
private:
MaskAccessorImageSource(const Self&); //purposely not implemented
void operator=(const Self&); //purposely not implemented
typedef std::map <rttb::VoxelGridID, rttb::core::MaskAccessorInterface::MaskVoxelList::size_type> VoxelMapType;
VoxelMapType m_idMap;
rttb::core::MaskAccessorInterface::MaskVoxelListPointer m_MaskedVoxels;
AccessorPointer m_Accessor;
bool m_FailsOnInvalidIDs{true};
OutputImageType::ValueType m_InvalidMaskValue{0};
};
} // end namespace itk
#endif
diff --git a/code/io/itk/rttbDoseAccessorConversionSettingInterface.h b/code/io/itk/rttbDoseAccessorConversionSettingInterface.h
index 5548fdc..5cdd88d 100644
--- a/code/io/itk/rttbDoseAccessorConversionSettingInterface.h
+++ b/code/io/itk/rttbDoseAccessorConversionSettingInterface.h
@@ -1,77 +1,72 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
+
#ifndef __DOSE_ACCESSOR_CONVERSION_SETTING_INTERFACE_H
#define __DOSE_ACCESSOR_CONVERSION_SETTING_INTERFACE_H
namespace rttb
{
namespace core
{
/*! @class DoseAccessorConversionSettingInterface
@brief Interface for specifying settings for dose accessor converters (e.g. how to handle invalid dose voxels)
*/
class DoseAccessorConversionSettingInterface
{
public:
/* Defines if the conversion process should fail (with an exception) if an invalid id/voxel occurs.*/
void setFailOnInvalidIDs(bool failOnInvalid)
{
_failedOnInvalidID = failOnInvalid;
}
/* Indicates how the conversion should handle invalid ids/voxels.\n
* true: fails with an exception
* false: uses the specified "invalid dose value".*/
bool failsOnInvalidIDs() const
{
return _failedOnInvalidID;
}
/* Sets the value that should be used for invalid ids/voxels.*/
void setInvalidDoseValue(DoseTypeGy value)
{
_invalidDoseValue = value;
}
/* Returns the value that is used for invalid ids/voxels.*/
DoseTypeGy getInvalidDoseValue() const
{
return _invalidDoseValue;
}
DoseAccessorConversionSettingInterface() = default;
virtual ~DoseAccessorConversionSettingInterface() = default;
private:
DoseAccessorConversionSettingInterface(const
DoseAccessorConversionSettingInterface&) = delete; //not implemented on purpose -> non-copyable
DoseAccessorConversionSettingInterface& operator=(const
DoseAccessorConversionSettingInterface&) = delete;//not implemented on purpose -> non-copyable
protected:
bool _failedOnInvalidID{false};
DoseTypeGy _invalidDoseValue{-1.0};
};
}
}
#endif
diff --git a/code/io/itk/rttbDoseAccessorProcessorBase.h b/code/io/itk/rttbDoseAccessorProcessorBase.h
index 7283f31..893c827 100644
--- a/code/io/itk/rttbDoseAccessorProcessorBase.h
+++ b/code/io/itk/rttbDoseAccessorProcessorBase.h
@@ -1,61 +1,56 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
+
#ifndef __DOSE_ACCESSOR_PROCESSOR_BASE_H
#define __DOSE_ACCESSOR_PROCESSOR_BASE_H
#include <boost/shared_ptr.hpp>
#include "rttbDoseAccessorProcessorInterface.h"
namespace rttb
{
namespace core
{
/*! @class DoseAccessorProcessorBase
@brief Abstract class for all DoseAccessor generating classes
*/
class DoseAccessorProcessorBase: public DoseAccessorProcessorInterface
{
public:
using DoseAccessorPointer = core::DoseAccessorInterface::Pointer;
void setDoseAccessor(DoseAccessorPointer accessor) override
{
_doseAccessor = accessor;
};
private:
DoseAccessorProcessorBase(const
DoseAccessorProcessorBase&) = delete; //not implemented on purpose -> non-copyable
DoseAccessorProcessorBase& operator=(const
DoseAccessorProcessorBase&) = delete;//not implemented on purpose -> non-copyable
protected:
DoseAccessorProcessorBase() = default;
~DoseAccessorProcessorBase() override = default;
/*! @brief Dose accessor which should be generated */
DoseAccessorPointer _doseAccessor;
};
}
}
#endif
diff --git a/code/io/itk/rttbDoseAccessorProcessorInterface.h b/code/io/itk/rttbDoseAccessorProcessorInterface.h
index 52abd1f..ead9576 100644
--- a/code/io/itk/rttbDoseAccessorProcessorInterface.h
+++ b/code/io/itk/rttbDoseAccessorProcessorInterface.h
@@ -1,65 +1,60 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
+
#ifndef __DOSE_ACCESSOR_PROCESSOR_INTERFACE_H
#define __DOSE_ACCESSOR_PROCESSOR_INTERFACE_H
#include "rttbDoseAccessorInterface.h"
namespace rttb
{
namespace core
{
/*! @class DoseAccessorProcessorInterface
@brief Interface for all DoseAccessor generating classes
*/
class DoseAccessorProcessorInterface
{
public:
using DoseAccessorPointer = core::DoseAccessorInterface::Pointer;
private:
DoseAccessorProcessorInterface(const
DoseAccessorProcessorInterface&) = delete; //not implemented on purpose -> non-copyable
DoseAccessorProcessorInterface& operator=(const
DoseAccessorProcessorInterface&) = delete;//not implemented on purpose -> non-copyable
protected:
DoseAccessorProcessorInterface() = default;
virtual ~DoseAccessorProcessorInterface() = default;
public:
/*! @brief Sets the DoseAccessor that should be processed
@pre passed accessor must point to a valid instance.
*/
virtual void setDoseAccessor(DoseAccessorPointer accessor) = 0;
/*! @brief Process the passed DoseAccessor
@return if the processing was successful.
*/
virtual bool process() = 0;
};
}
}
#endif
diff --git a/code/io/itk/rttbFileDispatch.cpp b/code/io/itk/rttbFileDispatch.cpp
index b06e21b..e82e298 100644
--- a/code/io/itk/rttbFileDispatch.cpp
+++ b/code/io/itk/rttbFileDispatch.cpp
@@ -1,127 +1,120 @@
// -----------------------------------------------------------------------
// MatchPoint - DKFZ translational registration framework
//
// Copyright (c) German Cancer Research Center (DKFZ),
// Software development for Integrated Diagnostics and Therapy (SIDT).
// ALL RIGHTS RESERVED.
// See mapCopyright.txt or
// http://www.dkfz.de/en/sidt/projects/MatchPoint/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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-// Subversion HeadURL: $HeadURL: https://svn/sbr/Sources/SBR-Projects/MatchPoint/trunk/Code/Core/source/mapFileDispatch.cpp $
-*/
#include "rttbFileDispatch.h"
#include "itksys/SystemTools.hxx"
namespace rttb
{
namespace core
{
FileNameString
FileDispatch::
getName(const FileNameString& sFilePath)
{
FileNameString result = itksys::SystemTools::GetFilenameWithoutLastExtension(sFilePath);
return result;
};
FileNameString
FileDispatch::
getExtension(const FileNameString& sFilePath)
{
FileNameString result = itksys::SystemTools::GetFilenameLastExtension(sFilePath);
return result;
};
FileNameString
FileDispatch::
getFullName(const FileNameString& sFilePath)
{
FileNameString result = itksys::SystemTools::GetFilenameName(sFilePath);
return result;
};
FileNameString
FileDispatch::
getPath(const FileNameString& sFilePath)
{
FileNameString result = itksys::SystemTools::GetFilenamePath(sFilePath);
return ensureCorrectOSPathSeparator(result);
};
FileNameString
FileDispatch::
getName()
{
return getName(_fileName);
};
FileNameString
FileDispatch::
getExtension()
{
return getExtension(_fileName);
};
FileNameString
FileDispatch::
getFullName()
{
return getFullName(_fileName);
};
FileNameString
FileDispatch::
getPath()
{
return getPath(_fileName);
};
FileDispatch::
FileDispatch(const FileNameString& filePath)
{
_fileName = filePath;
};
/** Convertes all path seperators in the seperators used in the current OS.*/
FileNameString
FileDispatch::
ensureCorrectOSPathSeparator(const FileNameString& path)
{
FileNameString ret = path;
#ifdef _WIN32
const FileNameString curSep = "\\";
const char wrongSep = '/';
#else
const FileNameString curSep = "/";
const char wrongSep = '\\';
#endif
FileNameString::size_type pos = ret.find_first_of(wrongSep);
while (pos != FileNameString::npos)
{
ret.replace(pos, 1, curSep);
pos = ret.find_first_of(wrongSep);
}
return ret;
}
}
}
\ No newline at end of file
diff --git a/code/io/itk/rttbFileDispatch.h b/code/io/itk/rttbFileDispatch.h
index 58d66d5..71128da 100644
--- a/code/io/itk/rttbFileDispatch.h
+++ b/code/io/itk/rttbFileDispatch.h
@@ -1,70 +1,62 @@
// -----------------------------------------------------------------------
// MatchPoint - DKFZ translational registration framework
//
// Copyright (c) German Cancer Research Center (DKFZ),
// Software development for Integrated Diagnostics and Therapy (SIDT).
// ALL RIGHTS RESERVED.
// See mapCopyright.txt or
// http://www.dkfz.de/en/sidt/projects/MatchPoint/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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-// Subversion HeadURL: $HeadURL: https://svn/sbr/Sources/SBR-Projects/MatchPoint/trunk/Code/Core/include/mapFileDispatch.h $
-*/
-
#ifndef __RTTB_FILE_DISPATCH_H
#define __RTTB_FILE_DISPATCH_H
#include <string>
#include "rttbBaseType.h"
namespace rttb
{
namespace core
{
/*! @class FileDispatch
@brief Convenience functions for working with files and path
@note code copied from MatchPoint, see documentation (http://sourceforge.net/projects/matchpoint/)
*/
class FileDispatch
{
public:
/** Returns the name of the file (without extension).*/
static FileNameString getName(const FileNameString& sFilePath);
/** Returns the extansion of the file (dot included).*/
static FileNameString getExtension(const FileNameString& sFilePath);
/** Returns name of the file plus extension.*/
static FileNameString getFullName(const FileNameString& sFilePath);
/** Returns the directory the file is located in (without trailing slash).
* @remark this function always removes the last element of the path. Thus
* if you pass a path without a file, it will return the parent directory.*/
static FileNameString getPath(const FileNameString& sFilePath);
/** Convertes all path seperators in the seperators used in the current OS.*/
static FileNameString ensureCorrectOSPathSeparator(const FileNameString& path);
FileNameString getName();
FileNameString getExtension();
FileNameString getFullName();
FileNameString getPath();
FileDispatch(const FileNameString& filePath);
private:
FileNameString _fileName;
};
}//end namespace core
}//end namespace rttb
#endif
diff --git a/code/io/itk/rttbGenericImageReader.cpp b/code/io/itk/rttbGenericImageReader.cpp
index 0fb76ab..9d3d872 100644
--- a/code/io/itk/rttbGenericImageReader.cpp
+++ b/code/io/itk/rttbGenericImageReader.cpp
@@ -1,301 +1,294 @@
// -----------------------------------------------------------------------
// MatchPoint - DKFZ translational registration framework
//
// Copyright (c) German Cancer Research Center (DKFZ),
// Software development for Integrated Diagnostics and Therapy (SIDT).
// ALL RIGHTS RESERVED.
// See mapCopyright.txt or
// http://www.dkfz.de/en/sidt/projects/MatchPoint/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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-// Subversion HeadURL: $HeadURL: https://svn/sbr/Sources/SBR-Projects/MatchPoint/trunk/Code/IO/source/mapGenericImageReader.cpp $
-*/
#include "rttbGenericImageReader.h"
namespace rttb
{
namespace io
{
namespace itk
{
void GenericImageReader::load()
{
_spImage = nullptr;
FileNameString probeFileName = this->_fileName;
if (this->_seriesReadStyle == ImageSeriesReadStyle::Numeric)
{
using NamesType = ::itk::NumericSeriesFileNames;
NamesType::Pointer names = NamesType::New();
names->SetStartIndex(1);
names->SetEndIndex(1);
names->SetSeriesFormat(this->_fileName.c_str());
probeFileName = names->GetFileNames()[0];
}
::itk::ImageIOBase::Pointer imageIO =
::itk::ImageIOFactory::CreateImageIO(probeFileName.c_str(),
::itk::ImageIOFactory::ReadMode);
if (!imageIO)
{
throw ::itk::ExceptionObject("No ImageIO found for given file. Please check if the file exists and has a supported format. File:"
+ probeFileName);
}
// Now that we found the appropriate ImageIO class, ask it to
// read the meta data from the image file.
imageIO->SetFileName(probeFileName.c_str());
imageIO->ReadImageInformation();
this->_loadedComponentType = imageIO->GetComponentType();
this->_loadedPixelType = imageIO->GetPixelType();
if (this->_loadedPixelType == ::itk::ImageIOBase::RGB && imageIO->GetNumberOfComponents() == 1)
{
//if only one channel per pixel handle as scalar as long as RGB etc. is not supported
this->_loadedPixelType = ::itk::ImageIOBase::SCALAR;
}
this->_loadedComponentTypeStr = imageIO->GetComponentTypeAsString(this->_loadedComponentType);
this->_loadedPixelTypeStr = imageIO->GetPixelTypeAsString(this->_loadedPixelType);
this->_loadedDimensions = imageIO->GetNumberOfDimensions();
if (this->_seriesReadStyle == ImageSeriesReadStyle::Numeric &&
this->_loadedDimensions == 2)
{
this->_loadedDimensions = 3; //it is a stack of 2D images -> 3D
}
if (this->_loadedDimensions < 2 || this->_loadedDimensions > 3)
{
throw ::itk::ExceptionObject("The file uses a number of dimensions that is not supported in this application. Only dim<=3 supported ");
}
switch (_loadedPixelType)
{
case ::itk::ImageIOBase::SCALAR:
{
if (this->_loadedDimensions == 2)
{
loadScalar<2>();
}
else
{
loadScalar<3>();
}
break;
}
default:
{
throw ::itk::ExceptionObject("The file uses a pixel type that is not supported in this application. Only SCALAR pixel type supported ");
}
}
_upToDate = true;
};
template <unsigned int IDimension>
void
GenericImageReader::
loadScalar()
{
// Use the pixel type to instantiate the appropriate reader
switch (this->_loadedComponentType)
{
case ::itk::ImageIOBase::UCHAR:
{
this->_spImage = readImage<unsigned char, unsigned char, IDimension>(_fileName, _seriesReadStyle,
false, 0, 0, _upperSeriesLimit, &_dictionaryArray);
break;
}
case ::itk::ImageIOBase::CHAR:
{
this->_spImage = readImage<char, char, IDimension>(_fileName, _seriesReadStyle, false, 0, 0,
_upperSeriesLimit, &_dictionaryArray);
break;
}
case ::itk::ImageIOBase::USHORT:
{
this->_spImage = readImage<unsigned short, unsigned short, IDimension>(_fileName, _seriesReadStyle,
false, 0, 0, _upperSeriesLimit, &_dictionaryArray);
break;
}
case ::itk::ImageIOBase::SHORT:
{
this->_spImage = readImage<short, short, IDimension>(_fileName, _seriesReadStyle, false, 0, 0,
_upperSeriesLimit, &_dictionaryArray);
break;
}
case ::itk::ImageIOBase::UINT:
{
this->_spImage = readImage<unsigned int, unsigned int, IDimension>(_fileName, _seriesReadStyle,
false, 0, 0, _upperSeriesLimit, &_dictionaryArray);
break;
}
case ::itk::ImageIOBase::INT:
{
this->_spImage = readImage<int, int, IDimension>(_fileName, _seriesReadStyle, false, 0, 0,
_upperSeriesLimit, &_dictionaryArray);
break;
}
case ::itk::ImageIOBase::ULONG:
{
this->_spImage = readImage<unsigned long, unsigned long, IDimension>(_fileName, _seriesReadStyle,
false, 0, 0, _upperSeriesLimit, &_dictionaryArray);
break;
}
case ::itk::ImageIOBase::LONG:
{
this->_spImage = readImage<long, long, IDimension>(_fileName, _seriesReadStyle, false, 0, 0,
_upperSeriesLimit, &_dictionaryArray);
break;
}
case ::itk::ImageIOBase::FLOAT:
{
this->_spImage = readImage<float, float, IDimension>(_fileName, _seriesReadStyle, false, 0, 0,
_upperSeriesLimit, &_dictionaryArray);
break;
}
case ::itk::ImageIOBase::DOUBLE:
{
this->_spImage = readImage<double, double, IDimension>(_fileName, _seriesReadStyle, false, 0, 0,
_upperSeriesLimit, &_dictionaryArray);
break;
}
default:
{
throw ::itk::ExceptionObject("The file uses a pixel component type that is not supported in this application. ComponentType: "
+ this->_loadedComponentTypeStr);
}
}
};
const FileNameString&
GenericImageReader::
getFileName() const
{
return _fileName;
};
void
GenericImageReader::
setFileName(const FileNameString& fileName)
{
if (fileName != _fileName)
{
_upToDate = false;
_fileName = fileName;
}
}
const unsigned int
GenericImageReader::
getUpperSeriesLimit() const
{
return _upperSeriesLimit;
};
void
GenericImageReader::
setUpperSeriesLimit(const unsigned int upperLimit)
{
if (upperLimit != _upperSeriesLimit)
{
_upToDate = false;
_upperSeriesLimit = upperLimit;
};
};
const ImageSeriesReadStyle::Type
GenericImageReader::
getSeriesReadStyle() const
{
return _seriesReadStyle;
};
void
GenericImageReader::
setSeriesReadStyle(ImageSeriesReadStyle::Type readStyle)
{
if (readStyle != _seriesReadStyle)
{
_upToDate = false;
_seriesReadStyle = readStyle;
};
};
GenericImageReader::GenericOutputImageType*
GenericImageReader::
GetOutput(unsigned int& loadedDimensions, LoadedPixelType& loadedPixelType,
LoadedComponentType& loadedComponentType)
{
if (!_upToDate)
{
load();
loadedPixelType = _loadedPixelType;
loadedComponentType = _loadedComponentType;
loadedDimensions = _loadedDimensions;
};
return _spImage;
};
GenericImageReader::
GenericImageReader() : _fileName()
{
};
GenericImageReader::
~GenericImageReader()
= default;
const GenericImageReader::MetaDataDictionaryArrayType&
GenericImageReader::
getMetaDictionaryArray()
{
return _dictionaryArray;
};
}//end namespace itk
}//end namespace io
}//end namespace rttb
diff --git a/code/io/itk/rttbGenericImageReader.h b/code/io/itk/rttbGenericImageReader.h
index 037a154..cfead1f 100644
--- a/code/io/itk/rttbGenericImageReader.h
+++ b/code/io/itk/rttbGenericImageReader.h
@@ -1,163 +1,156 @@
// -----------------------------------------------------------------------
// MatchPoint - DKFZ translational registration framework
//
// Copyright (c) German Cancer Research Center (DKFZ),
// Software development for Integrated Diagnostics and Therapy (SIDT).
// ALL RIGHTS RESERVED.
// See mapCopyright.txt or
// http://www.dkfz.de/en/sidt/projects/MatchPoint/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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-// Subversion HeadURL: $HeadURL: https://svn/sbr/Sources/SBR-Projects/MatchPoint/trunk/Code/IO/include/mapGenericImageReader.h $
-*/
#ifndef __RTTB_GENERIC_IMAGE_READER_H
#define __RTTB_GENERIC_IMAGE_READER_H
#include "rttbImageReader.h"
namespace rttb
{
namespace io
{
namespace itk
{
/** @class ImageReader
* @brief Helper class manages the generic loading (unspecified dimension and pixel type) of 2D/3D images ...
*
* GenericImageReader uses the ImageReader class and dispatches the dimension and pixel type information from the specified image file.
* GenericImageReader supports 2D and 3D images and the following pixel types:
* - (unsigned) char
* - (unsigned) short
* - (unsigned) int
* - (unsigned) long
* - float
* - double
* .
* Due to the fact that it builds upon the itk io infrastructure, all formats supported by ITK
* can be read.
* For further information regarding the usage see documentation of ImageReader.
* @sa ImageReader
* @note code copied from MatchPoint, see documentation (http://sourceforge.net/projects/matchpoint/)
*/
class GenericImageReader : public ::itk::Object
{
public:
using Self = rttb::io::itk::GenericImageReader;
using Superclass = ::itk::Object;
using Pointer = ::itk::SmartPointer<Self>;
using ConstPointer = ::itk::SmartPointer<const Self>;
itkTypeMacro(GenericImageReader, ::itk::Object);
itkNewMacro(Self);
using GenericOutputImageType = ::itk::DataObject;
using LoadedPixelType = ::itk::ImageIOBase::IOPixelType;
using LoadedComponentType = ::itk::ImageIOBase::IOComponentType;
using MetaDataDictionaryArrayType = std::vector< ::itk::MetaDataDictionary>;
private:
/** Loaded Image.*/
GenericOutputImageType::Pointer _spImage;
/** The file name of the image. */
FileNameString _fileName;
/** The upper limit for the searching of series files in the path.*/
unsigned int _upperSeriesLimit{255};
/** Indicates if the image data is up to date or should be read again.*/
bool _upToDate{false};
/** Defines if the specified image file is part of a series and the
* whole series should be read into one image. Only relevant for 3D images.*/
ImageSeriesReadStyle::Type _seriesReadStyle{ImageSeriesReadStyle::Default};
unsigned int _loadedDimensions;
LoadedPixelType _loadedPixelType;
LoadedComponentType _loadedComponentType;
std::string _loadedComponentTypeStr;
std::string _loadedPixelTypeStr;
MetaDataDictionaryArrayType _dictionaryArray;
/** Loads the image. First identifies pixel type and dimension and then deligates according
* to the pixel type.
* @exception map::core::ExceptionObject If no ImageIO is found.
* @exception map::core::ExceptionObject If dimension of the image is not supported. Only 2D/3D is supported.
* @exception map::core::ExceptionObject If pixel type is not supported. Currently only scalar pixels are supported.
*/
void load();
/** Loads an scalar image.
* @exception map::core::ExceptionObject If pixel component type is not supported.
*/
template <unsigned int IDimension>
void loadScalar();
//template <unsigned int IDimension>
//void loadRGB();
public:
/** Function to access the member variable _FileName. _FileName represents the filename of the
* headerfile. The path must be included, the file extension may left away.
* @return File name of the header file.*/
const FileNameString& getFileName() const;
/** Function to access the member variable _FileName. _FileName represents the filename of the
* headerfile. The path must be included, the file extension may left away.
* @param [in] sFileName The file name of the header file.*/
void setFileName(const FileNameString& sFileName);
/** Function to access the member variable _upperSeriesLimit. _upperSeriesLimit represents
* the upper limit for the series file search.
* @return The upper limit of the series search.*/
const unsigned int getUpperSeriesLimit() const;
/** Function to access the member variable _upperSeriesLimit. _upperSeriesLimit represents
* the upper limit for the series file search. Changing the series limit out dates the ImageReader.
* @remark It is only relevant if series style is set to "Numeric".
* @param [in] upperLimit The upper limit of the header file.*/
void setUpperSeriesLimit(const unsigned int upperLimit);
/** Function to access the member variable _seriesReadStyle (see member description for more information).*/
const ImageSeriesReadStyle::Type getSeriesReadStyle() const;
/** Function to access the member variable _seriesReadStyle (see member description for more information).
* Changing the style out dates the ImageReader.*/
void setSeriesReadStyle(ImageSeriesReadStyle::Type readStyle);
/** Function loads the image if needed and returns the data.
* @return Pointer to loaded image.
* @exception map::core::ExceptionObject If no ImageIO is found.
* @exception map::core::ExceptionObject If dimension of the image is not supported. Only 2D/3D is supported.
* @exception map::core::ExceptionObject If pixel type is not supported. Currently only scalar pixels are supported.
* @exception map::core::ExceptionObject If pixel component type is not supported.
*/
GenericOutputImageType* GetOutput(unsigned int& loadedDimensions, LoadedPixelType& loadedPixelType,
LoadedComponentType& loadedComponentType);
/** Function returns the reference to the meta data dictionary(ies) of the latest file(s) loaded by this class.
* Array may be empty if no MetaDictionary exists.*/
const MetaDataDictionaryArrayType& getMetaDictionaryArray();
protected:
GenericImageReader();
~GenericImageReader() override;
};
}//end namespace itk
}//end namespace io
}//end namespace rttb
#endif
diff --git a/code/io/itk/rttbITKException.h b/code/io/itk/rttbITKException.h
index 0cfb43b..13e66da 100644
--- a/code/io/itk/rttbITKException.h
+++ b/code/io/itk/rttbITKException.h
@@ -1,49 +1,43 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
#ifndef __ITK_EXCEPTION_H
#define __ITK_EXCEPTION_H
#include <string>
#include "rttbException.h"
namespace rttb
{
namespace io
{
namespace itk
{
/*! @class ITKException
@brief This class represents a ITKException. Any itk error will throw this exception.
*/
class ITKException: public core::Exception
{
public:
ITKException(const std::string& aWhat): Exception(aWhat) {}
};
}
}
}
#endif
diff --git a/code/io/itk/rttbITKIOHelper.cpp b/code/io/itk/rttbITKIOHelper.cpp
index f9f56b6..be8ee1d 100644
--- a/code/io/itk/rttbITKIOHelper.cpp
+++ b/code/io/itk/rttbITKIOHelper.cpp
@@ -1,167 +1,165 @@
// -----------------------------------------------------------------------
// 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 "rttbITKIOHelper.h"
#include "rttbException.h"
#include "rttbInvalidDoseException.h"
#include "rttbInvalidParameterException.h"
-
namespace rttb
{
namespace io
{
namespace itk
{
ITKImageType::Pointer readITKDoubleImage(FileNameType aITKImageFile, bool isDicom)
{
ITKImageType::Pointer itkDoubleImage;
GenericImageReader::Pointer spReader = GenericImageReader::New();
if (isDicom) {
spReader->setSeriesReadStyle(ImageSeriesReadStyle::Type::Dicom);
}
spReader->setFileName(aITKImageFile);
GenericImageReader::GenericOutputImageType::Pointer itkGenericImage;
ITKImageType::ConstPointer itkDoubleImageConst;
try
{
unsigned int loadedDimensions;
GenericImageReader::LoadedPixelType loadedPixelType;
GenericImageReader::LoadedComponentType loadedComponentType;
itkGenericImage = spReader->GetOutput(loadedDimensions, loadedPixelType, loadedComponentType);
if (loadedDimensions != 3)
{
throw core::InvalidParameterException("image dimensions != 3. Only dim = 3 supported.");
}
if (loadedPixelType != ::itk::ImageIOBase::SCALAR)
{
throw core::InvalidParameterException("image component type != SCALAR. Only SCALAR supported.");
}
if (loadedComponentType == ::itk::ImageIOBase::DOUBLE)
{
itkDoubleImage = dynamic_cast<ITKImageType*>(itkGenericImage.GetPointer());
}
else
{
itkDoubleImage = handleGenericImage(itkGenericImage, loadedComponentType);
}
if (itkDoubleImage.IsNull())
{
throw core::InvalidDoseException("Error!!! unable to load input image. File is not existing or has an unsupported format.");
}
}
catch (::itk::ExceptionObject& e)
{
std::cerr << "Error!!!" << std::endl;
std::cerr << e << std::endl;
throw rttb::core::InvalidDoseException(e.GetDescription());
}
return itkDoubleImage;
}
ITKImageType::Pointer handleGenericImage(
GenericImageReader::GenericOutputImageType* itkGenericImage,
::itk::ImageIOBase::IOComponentType& loadedComponentType)
{
ITKImageType::Pointer itkDoubleImage;
switch (loadedComponentType)
{
case ::itk::ImageIOBase::UCHAR:
{
itkDoubleImage = doCasting<unsigned char>(itkGenericImage);
break;
}
case ::itk::ImageIOBase::CHAR:
{
itkDoubleImage = doCasting<char>(itkGenericImage);
break;
}
case ::itk::ImageIOBase::USHORT:
{
itkDoubleImage = doCasting<unsigned short>(itkGenericImage);
break;
}
case ::itk::ImageIOBase::SHORT:
{
itkDoubleImage = doCasting<short>(itkGenericImage);
break;
}
case ::itk::ImageIOBase::UINT:
{
itkDoubleImage = doCasting<unsigned int>(itkGenericImage);
break;
}
case ::itk::ImageIOBase::INT:
{
itkDoubleImage = doCasting<int>(itkGenericImage);
break;
}
case ::itk::ImageIOBase::ULONG:
{
itkDoubleImage = doCasting<unsigned long>(itkGenericImage);
break;
}
case ::itk::ImageIOBase::LONG:
{
itkDoubleImage = doCasting<long>(itkGenericImage);
break;
}
case ::itk::ImageIOBase::FLOAT:
{
itkDoubleImage = doCasting<float>(itkGenericImage);
break;
}
case ::itk::ImageIOBase::DOUBLE:
{
itkDoubleImage = doCasting<double>(itkGenericImage);
break;
}
default:
{
throw core::InvalidParameterException("image type unknown");
}
}
return itkDoubleImage;
}
}//end namespace itk
}//end namespace io
}//end namespace rttb
diff --git a/code/io/itk/rttbITKIOHelper.h b/code/io/itk/rttbITKIOHelper.h
index eb5598b..7757582 100644
--- a/code/io/itk/rttbITKIOHelper.h
+++ b/code/io/itk/rttbITKIOHelper.h
@@ -1,60 +1,58 @@
// -----------------------------------------------------------------------
// 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 __ITK_IO_HELPER_H
#define __ITK_IO_HELPER_H
#include "rttbBaseType.h"
#include "rttbGenericImageReader.h"
#include "itkImage.h"
-
-
namespace rttb
{
namespace io
{
namespace itk
{
typedef ::itk::Image<GenericValueType, 3> ITKImageType;
/*! @brief Read a itk image file into itkImage<DoseTypeGy,3>
*/
ITKImageType::Pointer readITKDoubleImage(FileNameType aITKImageFile, bool isDicom = false);
/*! @brief Converts a generic image to itkImage<DoseTypeGy,3>
@param itkGenericImage the image read by GenericImageReader
@param loadedComponentType the component type (used for casting later on)
@exception InvalidParameterException if component type is not supported
@sa GenericImageReader
*/
ITKImageType::Pointer handleGenericImage(GenericImageReader::GenericOutputImageType*
itkGenericImage,
::itk::ImageIOBase::IOComponentType& loadedComponentType);
/*! @brief Casts into itkImage<DoseTypeGy,3>
*/
template <typename TPixelType> ITKImageType::Pointer doCasting(
GenericImageReader::GenericOutputImageType*
genericImage);
}//end namespace itk
}//end namespace io
}//end namespace rttb
#include "rttbITKIOHelper.tpp"
#endif
diff --git a/code/io/itk/rttbITKIOHelper.tpp b/code/io/itk/rttbITKIOHelper.tpp
index d80a09d..aba6330 100644
--- a/code/io/itk/rttbITKIOHelper.tpp
+++ b/code/io/itk/rttbITKIOHelper.tpp
@@ -1,65 +1,58 @@
// -----------------------------------------------------------------------
// MatchPoint - DKFZ translational registration framework
//
// Copyright (c) German Cancer Research Center (DKFZ),
// Software development for Integrated Diagnostics and Therapy (SIDT).
// ALL RIGHTS RESERVED.
// See mapCopyright.txt or
// http://www.dkfz.de/en/sidt/projects/MatchPoint/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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-// Subversion HeadURL: $HeadURL: https://svn/sbr/Sources/SBR-Projects/MatchPoint/trunk/Code/IO/include/mapImageReader.tpp $
-*/
#ifndef __RTTB_ITK_IO_HELPER_TPP
#define __RTTB_ITK_IO_HELPER_TPP
#include "rttbITKImageAccessor.h"
#include "itkCastImageFilter.h"
namespace rttb
{
namespace io
{
namespace itk
{
template <typename TPixelType> ITKImageType::Pointer doCasting(
GenericImageReader::GenericOutputImageType* genericImage)
{
ITKImageType::Pointer itkDoubleImage;
typedef ::itk::Image<TPixelType, 3> InputImageType;
using OutputImageType = ITKImageType;
typename InputImageType::Pointer pCastedInput = dynamic_cast<InputImageType*>(genericImage);
typedef ::itk::CastImageFilter<InputImageType, OutputImageType> CastFilterType;
typename CastFilterType::Pointer castFilter = CastFilterType::New();
castFilter->SetInput(pCastedInput);
try
{
//important to update the filter!
castFilter->Update();
itkDoubleImage = castFilter->GetOutput();
}
catch (::itk::ExceptionObject& e)
{
std::cerr << "ITK Error!!!" << std::endl;
std::cerr << e << std::endl;
}
return itkDoubleImage;
}
}
}
}
#endif
diff --git a/code/io/itk/rttbITKImageAccessor.cpp b/code/io/itk/rttbITKImageAccessor.cpp
index 73f74cc..9ce23cd 100644
--- a/code/io/itk/rttbITKImageAccessor.cpp
+++ b/code/io/itk/rttbITKImageAccessor.cpp
@@ -1,114 +1,108 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
#include <cassert>
#include "rttbITKImageAccessor.h"
#include "rttbException.h"
#include "rttbInvalidDoseException.h"
namespace rttb
{
namespace io
{
namespace itk
{
ITKImageAccessor::~ITKImageAccessor()
= default;
ITKImageAccessor::ITKImageAccessor(ITKImageType::ConstPointer image)
{
_data = image;
if (_data.IsNull())
{
throw core::InvalidDoseException("Dose image = 0!") ;
}
assembleGeometricInfo();
}
GenericValueType ITKImageAccessor::getValueAt(const VoxelGridID aID) const
{
VoxelGridIndex3D aVoxelGridIndex;
if (_geoInfo.convert(aID, aVoxelGridIndex))
{
return getValueAt(aVoxelGridIndex);
}
else
{
return -1;
}
}
GenericValueType ITKImageAccessor::getValueAt(const VoxelGridIndex3D& aIndex) const
{
if (_geoInfo.validIndex(aIndex))
{
const ITKImageType::IndexType pixelIndex = {{aIndex[0], aIndex[1], aIndex[2]}};
return _data->GetPixel(pixelIndex);
}
else
{
return -1;
}
}
void ITKImageAccessor::assembleGeometricInfo()
{
_geoInfo.setSpacing(SpacingVectorType3D(_data->GetSpacing()[0], _data->GetSpacing()[1],
_data->GetSpacing()[2]));
if (_geoInfo.getSpacing()[0] == 0 || _geoInfo.getSpacing()[1] == 0 || _geoInfo.getSpacing()[2] == 0)
{
throw core::InvalidDoseException("Pixel spacing = 0!");
}
_geoInfo.setImagePositionPatient(WorldCoordinate3D(_data->GetOrigin()[0], _data->GetOrigin()[1],
_data->GetOrigin()[2]));
OrientationMatrix OM(0);
for (unsigned int col = 0; col < 3; ++col)
{
for (unsigned int row = 0; row < 3; ++row)
{
OM(col, row) = _data->GetDirection()(col, row);
}
}
_geoInfo.setOrientationMatrix(OM);
_geoInfo.setNumColumns(_data->GetLargestPossibleRegion().GetSize()[0]);
_geoInfo.setNumRows(_data->GetLargestPossibleRegion().GetSize()[1]);
_geoInfo.setNumSlices(_data->GetLargestPossibleRegion().GetSize()[2]);
if (_geoInfo.getNumColumns() == 0 || _geoInfo.getNumRows() == 0 || _geoInfo.getNumSlices() == 0)
{
throw core::InvalidDoseException("Empty dicom dose!") ;
}
}
}
}
}
diff --git a/code/io/itk/rttbITKImageAccessor.h b/code/io/itk/rttbITKImageAccessor.h
index a02a26d..655a759 100644
--- a/code/io/itk/rttbITKImageAccessor.h
+++ b/code/io/itk/rttbITKImageAccessor.h
@@ -1,89 +1,84 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
+
#ifndef __ITK_IMAGE_ACCESSOR_H
#define __ITK_IMAGE_ACCESSOR_H
#include "rttbAccessorWithGeoInfoBase.h"
#include "rttbBaseType.h"
#include "itkImage.h"
#include "RTTBITKIOExports.h"
namespace rttb
{
namespace io
{
namespace itk
{
/*! @class ITKImageAccessor
@brief This class gives access to information stored in an itk image
@details There is no value scaling, i.e., it is assumed that the values in the itkImage are absolute.
*/
class RTTBITKIO_EXPORT ITKImageAccessor : public core::AccessorWithGeoInfoBase
{
public:
typedef ::itk::Image<GenericValueType, 3> ITKImageType;
private:
/** @brief The dose as itkImage */
ITKImageType::ConstPointer _data;
IDType _UID;
/*! @brief constructor
@exception InvalidDoseException if _dose is nullptr
*/
ITKImageAccessor() = delete;
/*! @brief get all required data from the itk image contained in _dose
@exception InvalidDoseException if PixelSpacing is 0 or size in any dimension is 0.
*/
void assembleGeometricInfo() override;
public:
~ITKImageAccessor() override;
/*! @brief Constructor. Initialization with a itk image
@pre image must be a valid instance (and !nullptr)
@note the doseImage pixels are assumed absolute
*/
ITKImageAccessor(ITKImageType::ConstPointer image);
/*! @brief returns the dose for an id
*/
GenericValueType getValueAt(const VoxelGridID aID) const override;
/*! @brief returns the dose for an index
*/
GenericValueType getValueAt(const VoxelGridIndex3D& aIndex) const override;
const IDType getUID() const override
{
return _UID;
};
};
}
}
}
#endif
diff --git a/code/io/itk/rttbITKImageAccessorConverter.cpp b/code/io/itk/rttbITKImageAccessorConverter.cpp
index cf1caae..64aead4 100644
--- a/code/io/itk/rttbITKImageAccessorConverter.cpp
+++ b/code/io/itk/rttbITKImageAccessorConverter.cpp
@@ -1,111 +1,105 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
#include <cassert>
#include <boost/shared_ptr.hpp>
#include "rttbITKImageAccessorConverter.h"
#include "rttbException.h"
#include "rttbInvalidDoseException.h"
#include "rttbGeometricInfo.h"
#include "itkDoseAccessorImageFilter.h"
namespace rttb
{
namespace io
{
namespace itk
{
ITKImageAccessorConverter::ITKImageAccessorConverter(DoseAccessorPointer accessor)
{
setDoseAccessor(accessor);
}
bool ITKImageAccessorConverter::process()
{
//Transfer GeometricInfo to ITK Properties
core::GeometricInfo geoInfo = _doseAccessor->getGeometricInfo();
ITKImageType::RegionType region;
ITKImageType::IndexType start;
for (unsigned int i = 0; i < 3; ++i)
{
start[i] = 0;
}
ITKImageType::SizeType size;
size[0] = geoInfo.getNumColumns();
size[1] = geoInfo.getNumRows();
size[2] = geoInfo.getNumSlices();
ITKImageType::SpacingType spacing;
for (unsigned int i = 0; i < 3; ++i)
{
spacing[i] = geoInfo.getSpacing()[i];
}
ITKImageType::PointType origin;
for (unsigned int i = 0; i < 3; ++i)
{
origin[i] = geoInfo.getImagePositionPatient()[i];
}
ITKImageType::DirectionType direction;
OrientationMatrix OM = geoInfo.getOrientationMatrix();
for (unsigned int col = 0; col < 3; ++col)
{
for (unsigned int row = 0; row < 3; ++row)
{
direction(col, row) = OM(col, row);
}
}
//Create image, assign properties
region.SetSize(size);
region.SetIndex(start);
_itkImage = ITKImageType::New();
_itkImage->SetRegions(region);
_itkImage->SetSpacing(spacing);
_itkImage->SetDirection(direction);
_itkImage->SetOrigin(origin);
_itkImage->Allocate();
::itk::DoseAccessorImageFilter::Pointer accessorFilter = ::itk::DoseAccessorImageFilter::New();
accessorFilter->SetInput(_itkImage);
accessorFilter->SetAccessor(_doseAccessor);
accessorFilter->Update();
_itkImage = accessorFilter->GetOutput();
return true;
}
}//end namespace itk
}//end namespace io
}//end namespace rttb
diff --git a/code/io/itk/rttbITKImageAccessorConverter.h b/code/io/itk/rttbITKImageAccessorConverter.h
index 2ff380c..a4be81a 100644
--- a/code/io/itk/rttbITKImageAccessorConverter.h
+++ b/code/io/itk/rttbITKImageAccessorConverter.h
@@ -1,69 +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.
//
//------------------------------------------------------------------------
-/*!
-// @file
-// @version $Revision$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
+
#ifndef __ITK_IMAGE_ACCESSOR_CONVERTER_H
#define __ITK_IMAGE_ACCESSOR_CONVERTER_H
#include "rttbDoseAccessorProcessorBase.h"
#include "rttbDoseAccessorConversionSettingInterface.h"
#include "itkImage.h"
#include "RTTBITKIOExports.h"
+
namespace rttb
{
namespace io
{
namespace itk
{
/*! @class ITKImageAccessorConverter
@brief Class converts/dumps the processed accessor into an itk image
@remark DoseAccessorConversionInterface defines how the converter should react on non valid dose values.
*/
class RTTBITKIO_EXPORT ITKImageAccessorConverter : public core::DoseAccessorProcessorBase,
public core::DoseAccessorConversionSettingInterface
{
public:
typedef ::itk::Image<GenericValueType, 3> ITKImageType;
using DoseAccessorPointer = core::DoseAccessorInterface::Pointer;
bool process() override;
ITKImageType::Pointer getITKImage()
{
return _itkImage;
}
ITKImageAccessorConverter(DoseAccessorPointer accessor);
~ITKImageAccessorConverter() override = default;
private:
ITKImageAccessorConverter(const
ITKImageAccessorConverter&) = delete; //not implemented on purpose -> non-copyable
ITKImageAccessorConverter& operator=(const
ITKImageAccessorConverter&) = delete;//not implemented on purpose -> non-copyable
ITKImageType::Pointer _itkImage;
};
}
}
}
#endif
diff --git a/code/io/itk/rttbITKImageAccessorGenerator.cpp b/code/io/itk/rttbITKImageAccessorGenerator.cpp
index f47270e..3012752 100644
--- a/code/io/itk/rttbITKImageAccessorGenerator.cpp
+++ b/code/io/itk/rttbITKImageAccessorGenerator.cpp
@@ -1,60 +1,53 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
#include <cassert>
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include "rttbITKImageAccessor.h"
#include "rttbITKImageAccessorGenerator.h"
#include "rttbException.h"
#include "rttbInvalidDoseException.h"
-
namespace rttb
{
namespace io
{
namespace itk
{
ITKImageAccessorGenerator::ITKImageAccessorGenerator(const ITKImageType* aDoseImage)
{
if (aDoseImage == nullptr)
{
throw core::InvalidDoseException("doseImage is nullptr");
}
_dosePtr = aDoseImage;
}
core::DoseAccessorGeneratorBase::DoseAccessorPointer
ITKImageAccessorGenerator::generateDoseAccessor()
{
_doseAccessor = boost::make_shared<ITKImageAccessor>(_dosePtr);
return _doseAccessor;
}
}//end namespace itk
}//end namespace io
}//end namespace rttb
diff --git a/code/io/itk/rttbITKImageAccessorGenerator.h b/code/io/itk/rttbITKImageAccessorGenerator.h
index 82a527d..e972f20 100644
--- a/code/io/itk/rttbITKImageAccessorGenerator.h
+++ b/code/io/itk/rttbITKImageAccessorGenerator.h
@@ -1,71 +1,66 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
+
#ifndef __ITK_IMAGE_ACCESSOR_GENERATOR_H
#define __ITK_IMAGE_ACCESSOR_GENERATOR_H
#include "rttbDoseAccessorGeneratorBase.h"
#include "itkImage.h"
#include "RTTBITKIOExports.h"
namespace rttb
{
namespace io
{
namespace itk
{
/*! @class ITKImageAccessorGenerator
@brief Generate ITKImageAccessor wrapping an itk image as object (not as file).
@note it implies that the information is stored in absolute values.
*/
class RTTBITKIO_EXPORT ITKImageAccessorGenerator : public core::DoseAccessorGeneratorBase
{
public:
typedef ::itk::Image<GenericValueType, 3> ITKImageType;
using DoseAccessorPointer = DoseAccessorGeneratorBase::DoseAccessorPointer;
private:
/** @brief The dose as itkImage */
ITKImageType::ConstPointer _dosePtr;
ITKImageAccessorGenerator() = delete;
public:
~ITKImageAccessorGenerator() override = default;
/*!
@pre aDoseImage must point to a valid instance.
@exception InvalidDoseException Thrown if aDoseImage is invalid.
*/
ITKImageAccessorGenerator(const ITKImageType* aDoseImage);
/*! @brief Generate DoseAccessor
@return Return shared pointer of DoseAccessor.
*/
DoseAccessorPointer generateDoseAccessor() override ;
};
}
}
}
#endif
diff --git a/code/io/itk/rttbITKImageFileAccessorGenerator.cpp b/code/io/itk/rttbITKImageFileAccessorGenerator.cpp
index 0e11d04..03f4395 100644
--- a/code/io/itk/rttbITKImageFileAccessorGenerator.cpp
+++ b/code/io/itk/rttbITKImageFileAccessorGenerator.cpp
@@ -1,49 +1,48 @@
// -----------------------------------------------------------------------
// 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 <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include "rttbITKImageFileAccessorGenerator.h"
#include "rttbITKImageAccessorConverter.h"
#include "rttbITKIOHelper.h"
-
namespace rttb
{
namespace io
{
namespace itk
{
ITKImageFileAccessorGenerator::~ITKImageFileAccessorGenerator()
= default;
ITKImageFileAccessorGenerator::ITKImageFileAccessorGenerator(const FileNameType& fileName, const bool& useDicom)
{
_fileName = fileName;
_useDicom = useDicom;
}
rttb::core::DoseAccessorGeneratorBase::DoseAccessorPointer ITKImageFileAccessorGenerator::generateDoseAccessor() {
_itkDoubleImage = readITKDoubleImage(_fileName, _useDicom);
_doseAccessor = boost::make_shared<ITKImageAccessor>(_itkDoubleImage.GetPointer());
return _doseAccessor;
}
}//end namespace itk
}//end namespace io
}//end namespace rttb
diff --git a/code/io/itk/rttbITKImageFileAccessorGenerator.h b/code/io/itk/rttbITKImageFileAccessorGenerator.h
index 3425aa9..e290ac0 100644
--- a/code/io/itk/rttbITKImageFileAccessorGenerator.h
+++ b/code/io/itk/rttbITKImageFileAccessorGenerator.h
@@ -1,73 +1,72 @@
// -----------------------------------------------------------------------
// 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 __ITK_IMAGE_FILE_ACCESSOR_GENERATOR_H
#define __ITK_IMAGE_FILE_ACCESSOR_GENERATOR_H
#include "rttbDoseAccessorGeneratorBase.h"
#include "rttbBaseType.h"
#include "itkImage.h"
-
namespace rttb
{
namespace io
{
namespace itk
{
/*! @class ITKImageFileAccessorGenerator
@brief Load image data using the itk loading methods and wraps the resulting itk image in a ITKImageAccessor.
* this can be used if dose distributions are stored in formats like meta image, nrrd...
* @note it implies that the dose information is stored in absolute Gy values.
*/
class ITKImageFileAccessorGenerator: public core::DoseAccessorGeneratorBase
{
public:
typedef ::itk::Image<GenericValueType, 3> ITKImageType;
using DoseAccessorPointer = DoseAccessorGeneratorBase::DoseAccessorPointer;
private:
FileNameType _fileName;
/** @brief The dose as itkImage */
ITKImageType::Pointer _itkDoubleImage;
bool _useDicom;
ITKImageFileAccessorGenerator() = delete;
public:
~ITKImageFileAccessorGenerator() override;
ITKImageFileAccessorGenerator(const FileNameType& fileName, const bool& useDicom = false);
/*! @brief Generate DoseAccessor
@return Return shared pointer of DoseAccessor.
@exception InvalidDoseException Thrown if file could not be read
@exception InvalidParameterException Thrown if file has imageDimension !=3 or image component type != SCALAR
@details is always converted into a itkImage<DoseTypeGy,3> by using a CastImageFilter
@sa doCasting, handleGenericImage
*/
DoseAccessorPointer generateDoseAccessor() override;
};
}//end namespace itk
}//end namespace io
}//end namespace rttb
#endif
diff --git a/code/io/itk/rttbITKImageFileMaskAccessorGenerator.cpp b/code/io/itk/rttbITKImageFileMaskAccessorGenerator.cpp
index 6c19ee0..b1dfd6f 100644
--- a/code/io/itk/rttbITKImageFileMaskAccessorGenerator.cpp
+++ b/code/io/itk/rttbITKImageFileMaskAccessorGenerator.cpp
@@ -1,57 +1,50 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include "rttbITKImageFileMaskAccessorGenerator.h"
#include "rttbInvalidDoseException.h"
#include "rttbInvalidParameterException.h"
#include "../itk/rttbITKIOHelper.h"
-
namespace rttb
{
namespace io
{
namespace itk
{
ITKImageFileMaskAccessorGenerator::~ITKImageFileMaskAccessorGenerator()
= default;
ITKImageFileMaskAccessorGenerator::ITKImageFileMaskAccessorGenerator(const FileNameType& fileName)
{
_itkMaskFileName = fileName;
}
rttb::core::MaskAccessorGeneratorBase::MaskAccessorPointer
ITKImageFileMaskAccessorGenerator::generateMaskAccessor()
{
_itkDoubleImage = rttb::io::itk::readITKDoubleImage(_itkMaskFileName);
_maskAccessor = boost::make_shared<ITKImageMaskAccessor>(_itkDoubleImage.GetPointer());
return _maskAccessor;
}
}//end namespace itk
}//end namespace io
}//end namespace rttb
diff --git a/code/io/itk/rttbITKImageFileMaskAccessorGenerator.h b/code/io/itk/rttbITKImageFileMaskAccessorGenerator.h
index aa09e6e..2593c53 100644
--- a/code/io/itk/rttbITKImageFileMaskAccessorGenerator.h
+++ b/code/io/itk/rttbITKImageFileMaskAccessorGenerator.h
@@ -1,73 +1,67 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
+
#ifndef __ITK_IMAGE_MASK_FILE_ACCESSOR_GENERATOR_H
#define __ITK_IMAGE_MASK_FILE_ACCESSOR_GENERATOR_H
#include "rttbMaskAccessorGeneratorBase.h"
#include "rttbBaseType.h"
#include "rttbITKImageMaskAccessor.h"
-
namespace rttb
{
namespace io
{
namespace itk
{
/*! @class ITKImageFileMaskAccessorGenerator
@brief Load 3D Mask data using the itk loading methods and wraps the resulting itk image in a ITKImageMaskAccessor.
* this is normally used if Mask distributions are stored in formats like meta image, nrrd...
*/
class ITKImageFileMaskAccessorGenerator: public core::MaskAccessorGeneratorBase
{
public:
using MaskAccessorPointer = MaskAccessorGeneratorBase::MaskAccessorPointer;
private:
FileNameType _itkMaskFileName;
/** @brief The mask as itkImage */
ITKImageMaskAccessor::ITKMaskImageType::Pointer _itkDoubleImage;
ITKImageFileMaskAccessorGenerator() = delete;
public:
~ITKImageFileMaskAccessorGenerator() override;
ITKImageFileMaskAccessorGenerator(const FileNameType& fileName);
/*! @brief Generate MaskAccessor
@return Return shared pointer of MaskAccessor.
@exception InvalidDoseException Thrown if file could not be read
@exception InvalidParameterException Thrown if file has imageDimension !=3 or image component type != SCALAR
@details is always converted into a itkImage<DoseTypeGy,3> by using a CastImageFilter
@sa doCasting, handleGenericImage
*/
MaskAccessorPointer generateMaskAccessor() override;
};
}//end namespace itk
}//end namespace io
}//end namespace rttb
#endif
diff --git a/code/io/itk/rttbITKImageMaskAccessor.cpp b/code/io/itk/rttbITKImageMaskAccessor.cpp
index e9f7551..830af89 100644
--- a/code/io/itk/rttbITKImageMaskAccessor.cpp
+++ b/code/io/itk/rttbITKImageMaskAccessor.cpp
@@ -1,176 +1,170 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include "rttbITKImageMaskAccessor.h"
#include "rttbGeometricInfo.h"
#include "rttbInvalidDoseException.h"
namespace rttb
{
namespace io
{
namespace itk
{
ITKImageMaskAccessor::ITKImageMaskAccessor(ITKMaskImageType::ConstPointer aMaskImage)
: _mask(aMaskImage)
{
if (_mask.IsNull())
{
throw core::InvalidDoseException("Mask image = 0!") ;
}
assembleGeometricInfo();
}
ITKImageMaskAccessor::~ITKImageMaskAccessor()
= default;
bool ITKImageMaskAccessor::assembleGeometricInfo()
{
_geoInfo = boost::make_shared<core::GeometricInfo>();
_geoInfo->setSpacing(SpacingVectorType3D(_mask->GetSpacing()[0], _mask->GetSpacing()[1],
_mask->GetSpacing()[2]));
if (_geoInfo->getSpacing()[0] == 0 || _geoInfo->getSpacing()[1] == 0
|| _geoInfo->getSpacing()[2] == 0)
{
throw core::InvalidDoseException("Pixel spacing = 0!");
}
_geoInfo->setImagePositionPatient(WorldCoordinate3D(_mask->GetOrigin()[0], _mask->GetOrigin()[1],
_mask->GetOrigin()[2]));
OrientationMatrix OM(0);
for (unsigned int col = 0; col < 3; ++col)
{
for (unsigned int row = 0; row < 3; ++row)
{
OM(col, row) = _mask->GetDirection()(col, row);
}
}
_geoInfo->setOrientationMatrix(OM);
_geoInfo->setNumColumns(_mask->GetLargestPossibleRegion().GetSize()[0]);
_geoInfo->setNumRows(_mask->GetLargestPossibleRegion().GetSize()[1]);
_geoInfo->setNumSlices(_mask->GetLargestPossibleRegion().GetSize()[2]);
if (_geoInfo->getNumColumns() == 0 || _geoInfo->getNumRows() == 0 || _geoInfo->getNumSlices() == 0)
{
throw core::InvalidDoseException("Empty mask!") ;
}
return true;
}
void ITKImageMaskAccessor::updateMask()
{
return;
}
ITKImageMaskAccessor::MaskVoxelListPointer ITKImageMaskAccessor::getRelevantVoxelVector()
{
updateMask();
_relevantVoxelVector = getRelevantVoxelVector(0);
return _relevantVoxelVector;
}
ITKImageMaskAccessor::MaskVoxelListPointer ITKImageMaskAccessor::getRelevantVoxelVector(
float lowerThreshold)
{
auto filteredVoxelVectorPointer = boost::make_shared<MaskVoxelList>();
updateMask();
unsigned int size = _geoInfo->getNumColumns() * _geoInfo->getNumRows() * _geoInfo->getNumSlices();
filteredVoxelVectorPointer->reserve(size);
for (unsigned int gridIndex = 0 ; gridIndex < size; gridIndex++)
{
core::MaskVoxel currentVoxel = core::MaskVoxel(gridIndex);
if (getMaskAt(gridIndex, currentVoxel))
{
if (currentVoxel.getRelevantVolumeFraction() > lowerThreshold)
{
filteredVoxelVectorPointer->push_back(currentVoxel);
}
}
}
return filteredVoxelVectorPointer;
}
bool ITKImageMaskAccessor::getMaskAt(VoxelGridID aID, core::MaskVoxel& voxel) const
{
VoxelGridIndex3D aVoxelGridIndex;
if (_geoInfo->convert(aID, aVoxelGridIndex))
{
return getMaskAt(aVoxelGridIndex, voxel);
}
else
{
return false;
}
}
bool ITKImageMaskAccessor::getMaskAt(const VoxelGridIndex3D& aIndex, core::MaskVoxel& voxel) const
{
voxel.setRelevantVolumeFraction(0);
if (_geoInfo->validIndex(aIndex))
{
const ITKMaskImageType::IndexType pixelIndex = {{aIndex[0], aIndex[1], aIndex[2]}};
double value = _mask->GetPixel(pixelIndex);
VoxelGridID gridId;
_geoInfo->convert(aIndex, gridId);
if (value >= 0 && value <= 1)
{
voxel.setRelevantVolumeFraction(value);
return true;
}
else
{
std::cerr << "The pixel value of the mask should be >=0 and <=1!" << std::endl;
return false;
}
}
else
{
return false;
}
}
const core::GeometricInfo& ITKImageMaskAccessor::getGeometricInfo() const
{
return *_geoInfo;
};
}
}
}
diff --git a/code/io/itk/rttbITKImageMaskAccessor.h b/code/io/itk/rttbITKImageMaskAccessor.h
index 19ed4ee..2dca57c 100644
--- a/code/io/itk/rttbITKImageMaskAccessor.h
+++ b/code/io/itk/rttbITKImageMaskAccessor.h
@@ -1,120 +1,115 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
+
#ifndef __ITK_IMAGE_MASK_ACCESSOR_H
#define __ITK_IMAGE_MASK_ACCESSOR_H
#include "rttbMaskAccessorInterface.h"
#include "rttbBaseType.h"
#include "rttbGeometricInfo.h"
#include "itkImage.h"
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4251)
#endif
namespace rttb
{
namespace io
{
namespace itk
{
/*! @class ITKImageMaskAccessor
@brief This class gives access to mask information stored in an itk image
*/
class ITKImageMaskAccessor: public core::MaskAccessorInterface
{
public:
typedef ::itk::Image<DoseTypeGy, 3> ITKMaskImageType;
using ITKImageBaseType = ::itk::ImageBase<3>;
using MaskVoxelList = core::MaskAccessorInterface::MaskVoxelList;
using MaskVoxelListPointer = core::MaskAccessorInterface::MaskVoxelListPointer;
private:
/** @brief The mask as itkImage */
ITKMaskImageType::ConstPointer _mask;
IDType _maskUID;
core::GeometricInfo::Pointer _geoInfo;
/*! vector containing list of mask voxels*/
MaskVoxelListPointer _relevantVoxelVector;
/*! @brief get all required data from the itk image contained in _Mask
@exception InvalidDoseException if PixelSpacing is 0 or size in any dimension is 0.
*/
bool assembleGeometricInfo();
public:
~ITKImageMaskAccessor() override;
ITKImageMaskAccessor(ITKMaskImageType::ConstPointer aMaskImage);
/*! @brief voxelization of the given structures according to the original RTToolbox algorithm*/
void updateMask() override;
/*! @brief get vector conatining al relevant voxels that are inside the given structure*/
MaskVoxelListPointer getRelevantVoxelVector() override;
/*! @brief get vector conatining al 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 contains 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 contains valid values.*/
bool getMaskAt(const VoxelGridID aID, core::MaskVoxel& voxel) const override;
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 Mask is on a homogeneous grid */
// 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;
};
};
}
}
}
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#endif
diff --git a/code/io/itk/rttbITKImageMaskAccessorConverter.cpp b/code/io/itk/rttbITKImageMaskAccessorConverter.cpp
index 44c2873..7982d28 100644
--- a/code/io/itk/rttbITKImageMaskAccessorConverter.cpp
+++ b/code/io/itk/rttbITKImageMaskAccessorConverter.cpp
@@ -1,92 +1,85 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
-
#include <boost/shared_ptr.hpp>
#include "rttbITKImageMaskAccessorConverter.h"
#include "rttbGeometricInfo.h"
#include "itkMaskAccessorImageSource.h"
namespace rttb
{
namespace io
{
namespace itk
{
ITKImageMaskAccessorConverter::ITKImageMaskAccessorConverter(MaskAccessorPointer accessor)
{
setMaskAccessor(accessor);
}
bool ITKImageMaskAccessorConverter::process()
{
//Transfer GeometricInfo to ITK Properties
core::GeometricInfo geoInfo = _maskAccessor->getGeometricInfo();
ITKImageMaskAccessor::ITKMaskImageType::IndexType start = {{0, 0, 0}};
ITKImageMaskAccessor::ITKMaskImageType::SizeType size = {{geoInfo.getNumColumns(), geoInfo.getNumRows(), geoInfo.getNumSlices()}};
ITKImageMaskAccessor::ITKMaskImageType::SpacingType spacing;
for (unsigned int i = 0; i < 3; ++i)
{
spacing[i] = geoInfo.getSpacing()[i];
}
ITKImageMaskAccessor::ITKMaskImageType::PointType origin;
for (unsigned int i = 0; i < 3; ++i)
{
origin[i] = geoInfo.getImagePositionPatient()[i];
}
ITKImageMaskAccessor::ITKMaskImageType::DirectionType direction;
OrientationMatrix OM = geoInfo.getOrientationMatrix();
for (unsigned int col = 0; col < 3; ++col)
{
for (unsigned int row = 0; row < 3; ++row)
{
direction(col, row) = OM(col, row);
}
}
::itk::MaskAccessorImageSource::Pointer imagesource = ::itk::MaskAccessorImageSource::New();
imagesource->SetSize(size);
imagesource->SetSpacing(spacing);
imagesource->SetDirection(direction);
imagesource->SetOrigin(origin);
imagesource->SetAccessor(_maskAccessor);
imagesource->SetFailsOnInvalidIDs(failsOnInvalidIDs());
imagesource->SetInvalidMaskValue(_invalidDoseValue);
imagesource->Update();
_itkImage = imagesource->GetOutput();
return true;
}
}//end namespace mask
}//end namespace io
}//end namespace rttb
diff --git a/code/io/itk/rttbITKImageMaskAccessorConverter.h b/code/io/itk/rttbITKImageMaskAccessorConverter.h
index 9bde713..fba46e6 100644
--- a/code/io/itk/rttbITKImageMaskAccessorConverter.h
+++ b/code/io/itk/rttbITKImageMaskAccessorConverter.h
@@ -1,70 +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.
//
//------------------------------------------------------------------------
-/*!
-// @file
-// @version $Revision$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
+
#ifndef __ITK_IMAGE_MASK_ACCESSOR_CONVERTER_H
#define __ITK_IMAGE_MASK_ACCESSOR_CONVERTER_H
#include "rttbITKImageMaskAccessor.h"
#include "rttbMaskAccessorProcessorBase.h"
#include "../itk/rttbDoseAccessorConversionSettingInterface.h"
#include "RTTBITKIOExports.h"
namespace rttb
{
namespace io
{
namespace itk
{
/*! @class ITKImageMaskAccessorConverter
@brief Class converts/dumps the processed accessor into an itk image
@remark MaskAccessorConversionInterface defines how the converter should react on non valid Mask values.
*/
class RTTBITKIO_EXPORT ITKImageMaskAccessorConverter : public core::MaskAccessorProcessorBase,
public rttb::core::DoseAccessorConversionSettingInterface
{
public:
using MaskAccessorPointer = core::MaskAccessorInterface::Pointer;
bool process() override;
const ITKImageMaskAccessor::ITKMaskImageType::Pointer getITKImage()
{
return _itkImage;
}
ITKImageMaskAccessorConverter(MaskAccessorPointer accessor);
~ITKImageMaskAccessorConverter() override = default;
private:
ITKImageMaskAccessorConverter(const
ITKImageMaskAccessorConverter&) = delete; //not implemented on purpose -> non-copyable
ITKImageMaskAccessorConverter& operator=(const
ITKImageMaskAccessorConverter&) = delete;//not implemented on purpose -> non-copyable
ITKImageMaskAccessor::ITKMaskImageType::Pointer _itkImage;
};
}
}
}
#endif
diff --git a/code/io/itk/rttbITKImageMaskAccessorGenerator.cpp b/code/io/itk/rttbITKImageMaskAccessorGenerator.cpp
index b649b5d..102605d 100644
--- a/code/io/itk/rttbITKImageMaskAccessorGenerator.cpp
+++ b/code/io/itk/rttbITKImageMaskAccessorGenerator.cpp
@@ -1,59 +1,51 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
-
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include "rttbITKImageMaskAccessorGenerator.h"
#include "rttbException.h"
#include "rttbInvalidDoseException.h"
-
namespace rttb
{
namespace io
{
namespace itk
{
ITKImageMaskAccessorGenerator::ITKImageMaskAccessorGenerator(const
ITKImageMaskAccessor::ITKMaskImageType* aMaskImage)
{
if (aMaskImage == nullptr)
{
throw core::InvalidDoseException("MaskImage is nullptr");
}
_maskPtr = aMaskImage;
}
core::MaskAccessorGeneratorBase::MaskAccessorPointer
ITKImageMaskAccessorGenerator::generateMaskAccessor()
{
_maskAccessor = boost::make_shared<ITKImageMaskAccessor>(_maskPtr);
return _maskAccessor;
}
}//end namespace mask
}//end namespace io
}//end namespace rttb
diff --git a/code/io/itk/rttbITKImageMaskAccessorGenerator.h b/code/io/itk/rttbITKImageMaskAccessorGenerator.h
index 1a82579..f93dddd 100644
--- a/code/io/itk/rttbITKImageMaskAccessorGenerator.h
+++ b/code/io/itk/rttbITKImageMaskAccessorGenerator.h
@@ -1,68 +1,63 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
+
#ifndef __ITK_IMAGE_MASK_ACCESSOR_GENERATOR_H
#define __ITK_IMAGE_MASK_ACCESSOR_GENERATOR_H
#include "rttbITKImageMaskAccessor.h"
#include "rttbMaskAccessorGeneratorBase.h"
#include "RTTBITKIOExports.h"
namespace rttb
{
namespace io
{
namespace itk
{
/*! @class ITKImageMaskAccessorGenerator
@brief Generate ITKImageMaskAccessor wrapping an itk image as object (not as file).
*/
class RTTBITKIO_EXPORT ITKImageMaskAccessorGenerator : public core::MaskAccessorGeneratorBase
{
public:
using MaskAccessorPointer = MaskAccessorGeneratorBase::MaskAccessorPointer;
private:
/** @brief The Mask as itkImage */
ITKImageMaskAccessor::ITKMaskImageType::ConstPointer _maskPtr;
ITKImageMaskAccessorGenerator() = delete;
public:
~ITKImageMaskAccessorGenerator() override = default;
/*!
@pre aMaskImage must point to a valid instance.
@exception InvalidDoseException Thrown if aMaskImage is invalid.
*/
ITKImageMaskAccessorGenerator(const ITKImageMaskAccessor::ITKMaskImageType* aMaskImage);
/*! @brief Generate MaskAccessor
@return Return shared pointer of MaskAccessor.
*/
MaskAccessorPointer generateMaskAccessor() override ;
};
}
}
}
#endif
diff --git a/code/io/itk/rttbImageReader.h b/code/io/itk/rttbImageReader.h
index df3db02..ca9153c 100644
--- a/code/io/itk/rttbImageReader.h
+++ b/code/io/itk/rttbImageReader.h
@@ -1,224 +1,216 @@
// -----------------------------------------------------------------------
// MatchPoint - DKFZ translational registration framework
//
// Copyright (c) German Cancer Research Center (DKFZ),
// Software development for Integrated Diagnostics and Therapy (SIDT).
// ALL RIGHTS RESERVED.
// See mapCopyright.txt or
// http://www.dkfz.de/en/sidt/projects/MatchPoint/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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-// Subversion HeadURL: $HeadURL: https://svn/sbr/Sources/SBR-Projects/MatchPoint/trunk/Code/IO/include/mapImageReader.h $
-*/
-
#ifndef __RTTB_IMAGE_READER_H
#define __RTTB_IMAGE_READER_H
#include "itkImage.h"
#include "itkImageSource.h"
namespace rttb
{
namespace io
{
namespace itk
{
struct ImageSeriesReadStyle
{
enum Type
{
Default = 0, //* - Depending on the file extension (DICOM images (*.dcm, *.ima): Dicom; others: None; No image file: Dicom)
None = 1, //* - No series reading, only the specified file
Dicom = 2, //* - Use series reader and DCMTKSeriesFileNames
Numeric = 3, //* - Use series reader and NumericSeriesFileNames
GDCM = 4 //* - Use series reader and GDCMSeriesFileNames
};
};
/** @class ImageReader
* @brief Helper class manages the loading of 2D/3D images based on itk but with some convenience features ...
*
* ImageReader is used to load 2D or 3D images in an itk like style, but also offers
* some convenience features and the specialties of different formats into account.\n
* 2D images will be loaded directly by the IO classes of itk, so in this case the
* ImageReader is only a layer of abstraction.\n
* 3D images will be handled different, depending on the type of files and the chosen
* series read style:\n
* - Default: Depending on the file extension (DICOM images (*.dcm, *.ima): Dicom; others: None; No image file: Dicom
* - None: directly by the itk io (no series reading)
* - Dicom: uses itk series reader, currently a list of files will be generated
that is similar to GDCM (old ::itk::DICOMKSeriesFileNames is not supported any more by itk > 4.3.x.)
* - GDCM: uses itk series reader, the list of files will be generated
* by the ::itk::GDCMSeriesFileNames in the specified path ordered by
* imagePositionPatient.
* - Numeric: Will be considered as series of images. The list of files will be
* created by ::itk::NumericSeriesFileNames, so in this case the given
* file name is already masked by %d for the increasing index within
* the file name.
* .
* @note code copied from MatchPoint, see documentation (http://sourceforge.net/projects/matchpoint/)
*/
template <typename TInputPixel, typename TOutputPixel, unsigned int iDimension = 2>
class ImageReader
{
public:
typedef ::itk::Image<TInputPixel, iDimension> InputImageType;
typedef ::itk::Image<TOutputPixel, iDimension> OutputImageType;
using RescaleValueType = TInputPixel;
using MetaDataDictionaryArrayType = std::vector< ::itk::MetaDataDictionary>;
using String = std::string;
using OStringStream = std::ostringstream;
using IStringStream = std::istringstream;
virtual const char* GetNameOfClass() const
{
return "ImageReader";
}
private:
/** Loaded Image.*/
typename OutputImageType::Pointer _spImage;
/** The file name of the image. */
String _fileName;
/** The upper limit for the searching of series files in the path.*/
unsigned int _upperSeriesLimit;
/** Indicates if the image data is up to date or should be read again.*/
bool _upToDate;
/** Indicates if the output image intensity should be rescaled.*/
bool _rescaleImage;
/** Indicates the minimum of the output.*/
RescaleValueType _rescaleMin;
/** Indicates the maximum of the output.*/
RescaleValueType _rescaleMax;
/** Defines if the specified image file is part of a series and the
* whole series should be read into one image. Only relevant for 3D images.*/
typename ImageSeriesReadStyle::Type _seriesReadStyle;
MetaDataDictionaryArrayType _dictionaryArray;
void load2D();
typename ::itk::ImageSource<InputImageType>::Pointer prepareNumericSource() const;
typename ::itk::ImageSource<InputImageType>::Pointer prepareDICOMSource() const;
typename ::itk::ImageSource<InputImageType>::Pointer prepareNormalSource() const;
typename ::itk::ImageSource<InputImageType>::Pointer prepareGDCMSource() const;
void load3D();
using ITKMetaDataDictionaryArray = std::vector< ::itk::MetaDataDictionary *>;
void copyMetaDictionaryArray(const ITKMetaDataDictionaryArray* fromArray,
MetaDataDictionaryArrayType& toArray);
public:
/** Function to access the member variable _FileName. _FileName represents the filename of the
* headerfile. The path must be included, the file extension may left away.
* @return File name of the header file.*/
const String& getFileName() const;
/** Function to access the member variable _FileName. _FileName represents the filename of the
* headerfile. The path must be included, the file extension may left away.
* @param [in] sFileName The file name of the header file.*/
void setFileName(const String& sFileName);
/** Function to access the member variable _rescaleMin. _rescaleMin represents
* the minimum of the intensity rescale filter.
* @return The minimum of the intensity rescale filter.*/
const RescaleValueType& getRescaleMinimum() const;
/** Function to access the member variable _rescaleMin. _rescaleMin represents
* the minimum of the intensity rescale filter. Changing the rescale minimum out dates the ImageReader.
* @param [in] rescaleMin The minimum of the intensity rescale filter.*/
void setRescaleMinimum(const RescaleValueType& rescaleMin);
/** Function to access the member variable _rescaleMin. _rescaleMax represents
* the minimum of the intensity rescale filter.
* @return The minimum of the intensity rescale filter.*/
const RescaleValueType& getRescaleMaximum() const;
/** Function to access the member variable _rescaleMin. _rescaleMax represents
* the minimum of the intensity rescale filter. Changing the rescale maximum out dates the ImageReader.
* @param [in] rescaleMax The minimum of the intensity rescale filter.*/
void setRescaleMaximum(const RescaleValueType& rescaleMax);
/** Function to access the member variable _rescaleImage. _rescaleImage indicates if a
* loaded image should be rescaled regarding its intensities.
* @return If the ImageReader converts images to iso-voxel.*/
const bool getRescaleImage() const;
/** Function to access the member variable _rescaleImage. _rescaleImage indicates if a
* loaded image should be rescaled regarding its intensities. Changing the rescale option out dates the ImageReader.
* @param [in] rescaleImage Specifies if image should be converted to isovoxel.*/
void setRescaleImage(const bool rescaleImage);
/** Function to access the member variable _upperSeriesLimit. _upperSeriesLimit represents
* the upper limit for the series file search.
* @return The upper limit of the series search.*/
const unsigned int getUpperSeriesLimit() const;
/** Function to access the member variable _upperSeriesLimit. _upperSeriesLimit represents
* the upper limit for the series file search. Changing the series limit out dates the ImageReader.
* @remark It is only relevant if series style is set to "Numeric".
* @param [in] upperLimit The upper limit of the header file.*/
void setUpperSeriesLimit(const unsigned int upperLimit);
/** Function to access the member variable _seriesReadStyle (see member description for more information).*/
const typename ImageSeriesReadStyle::Type getSeriesReadStyle() const;
/** Function to access the member variable _seriesReadStyle (see member description for more information).
* Changing the style out dates the ImageReader.*/
void setSeriesReadStyle(typename ImageSeriesReadStyle::Type readStyle);
/** Function loads the image if needed and returns the data.
* @return Pointer to loaded image.*/
OutputImageType* GetOutput();
/** Function returns the reference to the meta data dictionary(ies) of the latest file(s) loaded by this class.
* Array may be empty if no MetaDictionary exists.*/
const MetaDataDictionaryArrayType& getMetaDictionaryArray();
ImageReader();
virtual ~ImageReader();
};
/**
* @brief Helper function for the use of ImageReader in on statement ...
*
* for specific informations please see the documentation of ImageReader.
* @param pLoadedDictArray Pass a pointer to valid array to receive the meta dictionaries
* loaded with the image. If the pointer is null, no dictionaries will be transfered. The array
* will be reseted before the loaded dictionaries will be added.
* @sa ImageReader
* @ingroup Utils
*/
template <typename TInputPixel, typename TOutputPixel, unsigned int iDimension>
typename ImageReader<TInputPixel, TOutputPixel, iDimension>::OutputImageType::Pointer
readImage(const std::string& fileName,
ImageSeriesReadStyle::Type readStyle = ImageSeriesReadStyle::Default,
bool rescaleImage = false,
typename ImageReader<TInputPixel, TOutputPixel, iDimension>::RescaleValueType rescaleMin = 0,
typename ImageReader<TInputPixel, TOutputPixel, iDimension>::RescaleValueType rescaleMax = 255,
unsigned int upperNumericSeriesLimit = 100,
typename ImageReader<TInputPixel, TOutputPixel, iDimension>::MetaDataDictionaryArrayType*
pLoadedDictArray = NULL);
}//end namespace itk
}//end namespace io
}//end namespace rttb
#include "rttbImageReader.tpp"
#endif
diff --git a/code/io/itk/rttbImageReader.tpp b/code/io/itk/rttbImageReader.tpp
index 2611246..7a1f9ee 100644
--- a/code/io/itk/rttbImageReader.tpp
+++ b/code/io/itk/rttbImageReader.tpp
@@ -1,532 +1,524 @@
// -----------------------------------------------------------------------
// MatchPoint - DKFZ translational registration framework
//
// Copyright (c) German Cancer Research Center (DKFZ),
// Software development for Integrated Diagnostics and Therapy (SIDT).
// ALL RIGHTS RESERVED.
// See mapCopyright.txt or
// http://www.dkfz.de/en/sidt/projects/MatchPoint/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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-// Subversion HeadURL: $HeadURL: https://svn/sbr/Sources/SBR-Projects/MatchPoint/trunk/Code/IO/include/mapImageReader.tpp $
-*/
#ifndef __RTTB_IMAGE_READER_TPP
#define __RTTB_IMAGE_READER_TPP
#include "rttbImageReader.h"
#include "rttbFileDispatch.h"
#include "RTToolboxConfigure.h"
#ifdef RTTB_DISABLE_ITK_IO_FACTORY_AUTO_REGISTER
#undef ITK_IO_FACTORY_REGISTER_MANAGER
#endif
#include "itkImageFileReader.h"
#include "itkImageSeriesReader.h"
#include "itkImageSeriesWriter.h"
#include "itkNumericSeriesFileNames.h"
#include "itkGDCMSeriesFileNames.h"
#include "itkRescaleIntensityImageFilter.h"
#include "itkCastImageFilter.h"
#include "itkFixedArray.h"
#include "itksys/SystemTools.hxx"
#include <iostream>
#include <locale>
-
namespace rttb
{
namespace io
{
namespace itk
{
template <typename TInputPixel, typename TOutputPixel, unsigned int iDimension>
void
ImageReader<TInputPixel, TOutputPixel, iDimension>::
load2D()
{
using ImageReaderType = ::itk::ImageFileReader< InputImageType >;
typedef ::itk::RescaleIntensityImageFilter< InputImageType, InputImageType > RescaleFilterType;
typedef ::itk::CastImageFilter< InputImageType, OutputImageType > CastFilterType;
typename CastFilterType::Pointer imageCaster = CastFilterType::New();
typename ImageReaderType::Pointer imageReader = ImageReaderType::New();
typename RescaleFilterType::Pointer rescaleFilter = RescaleFilterType::New();
rescaleFilter->SetOutputMinimum(static_cast<TInputPixel>(_rescaleMin));
rescaleFilter->SetOutputMaximum(static_cast<TInputPixel>(_rescaleMax));
imageReader->SetFileName(_fileName.c_str());
rescaleFilter->SetInput(imageReader->GetOutput());
if (_rescaleImage)
{
imageCaster->SetInput(rescaleFilter->GetOutput());
}
else
{
imageCaster->SetInput(imageReader->GetOutput());
}
_spImage = imageCaster->GetOutput();
imageCaster->Update();
_dictionaryArray.clear();
_dictionaryArray.push_back(imageReader->GetImageIO()->GetMetaDataDictionary());
_upToDate = true;
};
template <typename TInputPixel, typename TOutputPixel, unsigned int iDimension>
const typename ImageReader<TInputPixel, TOutputPixel, iDimension>::MetaDataDictionaryArrayType&
ImageReader<TInputPixel, TOutputPixel, iDimension>::
getMetaDictionaryArray()
{
return _dictionaryArray;
};
template <typename TInputPixel, typename TOutputPixel, unsigned int iDimension>
void
ImageReader<TInputPixel, TOutputPixel, iDimension>::
copyMetaDictionaryArray(const ITKMetaDataDictionaryArray* fromArray,
MetaDataDictionaryArrayType& toArray)
{
toArray.clear();
auto itr = fromArray->begin();
auto end = fromArray->end();
while (itr != end)
{
toArray.push_back(*(*itr));
++itr;
}
};
template <typename TInputPixel, typename TOutputPixel, unsigned int iDimension>
typename ::itk::ImageSource<typename ImageReader<TInputPixel, TOutputPixel, iDimension>::InputImageType>::Pointer
ImageReader<TInputPixel, TOutputPixel, iDimension>::
prepareNumericSource() const
{
//mumeric series image reader
using SeriesReaderType = ::itk::ImageSeriesReader<InputImageType>;
using NamesType = ::itk::NumericSeriesFileNames;
typename SeriesReaderType::Pointer seriesReader = SeriesReaderType::New();
NamesType::Pointer names = NamesType::New();
names->SetStartIndex(1);
names->SetEndIndex(_upperSeriesLimit);
names->SetSeriesFormat(_fileName.c_str());
seriesReader->SetFileNames(names->GetFileNames());
if (seriesReader->GetFileNames().size() == 0)
{
throw ::itk::ExceptionObject("Image reader is not correctly configured. Preparing a series reading of a numeric source no(!) files were found.");
}
typename ::itk::ImageSource<typename ImageReader<TInputPixel, TOutputPixel, iDimension>::InputImageType>::Pointer
genericReader = seriesReader.GetPointer();
return genericReader;
};
template <typename TInputPixel, typename TOutputPixel, unsigned int iDimension>
typename ::itk::ImageSource<typename ImageReader<TInputPixel, TOutputPixel, iDimension>::InputImageType>::Pointer
ImageReader<TInputPixel, TOutputPixel, iDimension>::
prepareDICOMSource() const
{
//ITK > v4.3.x removed old DICOMSeriesFileNames. Thus currently only support GDCM as source by default
return prepareGDCMSource();
};
template <typename TInputPixel, typename TOutputPixel, unsigned int iDimension>
typename ::itk::ImageSource<typename ImageReader<TInputPixel, TOutputPixel, iDimension>::InputImageType>::Pointer
ImageReader<TInputPixel, TOutputPixel, iDimension>::
prepareGDCMSource() const
{
core::FileDispatch dispatch(_fileName);
FileNameString dir = dispatch.getPath();
FileNameString strippedFileName = dispatch.getFullName();
using NamesGeneratorType = ::itk::GDCMSeriesFileNames;
NamesGeneratorType::Pointer nameGenerator = NamesGeneratorType::New();
nameGenerator->SetInputDirectory(dir);
nameGenerator->SetUseSeriesDetails(true);
::itk::FilenamesContainer fileNames;
if (strippedFileName.empty())
{
std::cerr << "No file name specified. Use first DICOM series found in directory." << std::endl;
fileNames = nameGenerator->GetInputFileNames();
}
else
{
::itk::SerieUIDContainer seriesUIDs = nameGenerator->GetSeriesUIDs();
std::cerr << "Checking found DICOM series." << std::endl;
//check the found series for the filename to pick the right series correlated to the passed filename
while (seriesUIDs.size() > 0)
{
fileNames = nameGenerator->GetFileNames(seriesUIDs.back());
std::cerr << "Checking series: " << seriesUIDs.back() << " (file count: " <<
fileNames.size() << ")" << std::endl;
seriesUIDs.pop_back();
for (::itk::SerieUIDContainer::const_iterator pos = fileNames.begin(); pos != fileNames.end();
++pos)
{
if (pos->find(strippedFileName) != FileNameString::npos)
{
//this series containes the passed filename ->
//we have the right block of files -> we are done.
std::cerr << "Found right series!" << std::endl;
seriesUIDs.clear();
break;
}
}
}
}
using SeriesReaderType = ::itk::ImageSeriesReader<InputImageType>;
typename SeriesReaderType::Pointer seriesReader = SeriesReaderType::New();
seriesReader->SetFileNames(fileNames);
if (seriesReader->GetFileNames().size() == 0)
{
throw ::itk::ExceptionObject("Image reader is not correctly configured. Preparing a series reading of a DICOM source no(!) dicom files were found. search location: "
+ _fileName);
}
typename ::itk::ImageSource<typename ImageReader<TInputPixel, TOutputPixel, iDimension>::InputImageType>::Pointer
genericReader = seriesReader.GetPointer();
return genericReader;
};
template <typename TInputPixel, typename TOutputPixel, unsigned int iDimension>
typename ::itk::ImageSource<typename ImageReader<TInputPixel, TOutputPixel, iDimension>::InputImageType>::Pointer
ImageReader<TInputPixel, TOutputPixel, iDimension>::
prepareNormalSource() const
{
//Normal image reader (no series read style)
using ImageReaderType = ::itk::ImageFileReader< InputImageType >;
typename ImageReaderType::Pointer imageReader = ImageReaderType::New();
imageReader->SetFileName(_fileName.c_str());
typename ::itk::ImageSource<typename ImageReader<TInputPixel, TOutputPixel, iDimension>::InputImageType>::Pointer
genericReader = imageReader.GetPointer();
return genericReader;
};
template <typename TInputPixel, typename TOutputPixel, unsigned int iDimension>
void
ImageReader<TInputPixel, TOutputPixel, iDimension>::
load3D()
{
core::FileDispatch dispatch(_fileName);
FileNameString sTemp = dispatch.getExtension();
//Convert to lowercase
for (char & spos : sTemp)
{
spos = std::tolower(spos, std::locale(""));
}
typedef ::itk::RescaleIntensityImageFilter< InputImageType, InputImageType > RescaleFilterType;
typedef ::itk::CastImageFilter< InputImageType, OutputImageType > CastFilterType;
typename CastFilterType::Pointer imageCaster = CastFilterType::New();
typename RescaleFilterType::Pointer rescaleFilter = RescaleFilterType::New();
typename ::itk::ImageSource<InputImageType>::Pointer spReader;
rescaleFilter->SetOutputMinimum(static_cast<TInputPixel>(_rescaleMin));
rescaleFilter->SetOutputMaximum(static_cast<TInputPixel>(_rescaleMax));
if (_seriesReadStyle == ImageSeriesReadStyle::Numeric)
{
spReader = prepareNumericSource();
}
else if (_seriesReadStyle == ImageSeriesReadStyle::Dicom)
{
spReader = prepareDICOMSource();
}
else if (_seriesReadStyle == ImageSeriesReadStyle::GDCM)
{
spReader = prepareGDCMSource();
}
else if (_seriesReadStyle == ImageSeriesReadStyle::Default)
{
bool isDir = itksys::SystemTools::FileIsDirectory(_fileName.c_str());
if (isDir || sTemp == ".dcm" || sTemp == ".ima")
{
spReader = prepareDICOMSource();
}
else
{
spReader = prepareNormalSource();
}
}
else
{
//style is none
spReader = prepareNormalSource();
}
if (_rescaleImage)
{
rescaleFilter->SetInput(spReader->GetOutput());
imageCaster->SetInput(rescaleFilter->GetOutput());
}
else
{
imageCaster->SetInput(spReader->GetOutput());
}
imageCaster->Update();
_spImage = imageCaster->GetOutput();
using ImageReaderType = ::itk::ImageFileReader< InputImageType >;
using ImageSeriesReaderType = ::itk::ImageSeriesReader<InputImageType>;
auto* pFileReader = dynamic_cast<ImageReaderType*>(spReader.GetPointer());
auto* pSeriesReader = dynamic_cast<ImageSeriesReaderType*>(spReader.GetPointer());
if (pFileReader)
{
_dictionaryArray.clear();
_dictionaryArray.push_back(pFileReader->GetImageIO()->GetMetaDataDictionary());
}
else if (pSeriesReader)
{
copyMetaDictionaryArray(pSeriesReader->GetMetaDataDictionaryArray(), _dictionaryArray);
}
else
{
throw ::itk::ExceptionObject("Image reader is not valid. Internal reader seams not to be itk::ImageFileReader or itk::ImageSeriesReader.");
}
_upToDate = true;
};
template <typename TInputPixel, typename TOutputPixel, unsigned int iDimension>
const FileNameString&
ImageReader<TInputPixel, TOutputPixel, iDimension>::
getFileName() const
{
return _fileName;
};
template <typename TInputPixel, typename TOutputPixel, unsigned int iDimension>
void
ImageReader<TInputPixel, TOutputPixel, iDimension>::
setFileName(const FileNameString& fileName)
{
if (fileName != _fileName)
{
_upToDate = false;
_fileName = fileName;
}
}
template <typename TInputPixel, typename TOutputPixel, unsigned int iDimension>
const typename ImageReader<TInputPixel, TOutputPixel, iDimension>::RescaleValueType&
ImageReader<TInputPixel, TOutputPixel, iDimension>::
getRescaleMinimum() const
{
return _rescaleMin;
};
template <typename TInputPixel, typename TOutputPixel, unsigned int iDimension>
void
ImageReader<TInputPixel, TOutputPixel, iDimension>::
setRescaleMinimum(const RescaleValueType& dRescaleMin)
{
if (dRescaleMin != _rescaleMin)
{
_upToDate = false;
_rescaleMin = dRescaleMin;
};
};
template <typename TInputPixel, typename TOutputPixel, unsigned int iDimension>
const typename ImageReader<TInputPixel, TOutputPixel, iDimension>::RescaleValueType&
ImageReader<TInputPixel, TOutputPixel, iDimension>::
getRescaleMaximum() const
{
return _rescaleMax;
};
template <typename TInputPixel, typename TOutputPixel, unsigned int iDimension>
void
ImageReader<TInputPixel, TOutputPixel, iDimension>::
setRescaleMaximum(const RescaleValueType& dRescaleMax)
{
if (dRescaleMax != _rescaleMax)
{
_upToDate = false;
_rescaleMax = dRescaleMax;
};
};
template <typename TInputPixel, typename TOutputPixel, unsigned int iDimension>
const bool
ImageReader<TInputPixel, TOutputPixel, iDimension>::
getRescaleImage() const
{
return _rescaleImage;
};
template <typename TInputPixel, typename TOutputPixel, unsigned int iDimension>
void
ImageReader<TInputPixel, TOutputPixel, iDimension>::
setRescaleImage(const bool rescaleImage)
{
if (rescaleImage != _rescaleImage)
{
_upToDate = false;
_rescaleImage = rescaleImage;
};
};
template <typename TInputPixel, typename TOutputPixel, unsigned int iDimension>
const unsigned int
ImageReader<TInputPixel, TOutputPixel, iDimension>::
getUpperSeriesLimit() const
{
return _upperSeriesLimit;
};
template <typename TInputPixel, typename TOutputPixel, unsigned int iDimension>
void
ImageReader<TInputPixel, TOutputPixel, iDimension>::
setUpperSeriesLimit(const unsigned int upperLimit)
{
if (upperLimit != _upperSeriesLimit)
{
_upToDate = false;
_upperSeriesLimit = upperLimit;
};
};
template <typename TInputPixel, typename TOutputPixel, unsigned int iDimension>
const ImageSeriesReadStyle::Type
ImageReader<TInputPixel, TOutputPixel, iDimension>::
getSeriesReadStyle() const
{
return _seriesReadStyle;
};
template <typename TInputPixel, typename TOutputPixel, unsigned int iDimension>
void
ImageReader<TInputPixel, TOutputPixel, iDimension>::
setSeriesReadStyle(ImageSeriesReadStyle::Type readStyle)
{
if (readStyle != _seriesReadStyle)
{
_upToDate = false;
_seriesReadStyle = readStyle;
};
};
template <typename TInputPixel, typename TOutputPixel, unsigned int iDimension>
typename ImageReader<TInputPixel, TOutputPixel, iDimension>::OutputImageType*
ImageReader<TInputPixel, TOutputPixel, iDimension>::
GetOutput()
{
if (!_upToDate)
{
switch (OutputImageType::GetImageDimension())
{
case 2:
load2D();
break;
case 3:
load3D();
break;
default:
throw ::itk::ExceptionObject("Image reader only accepts 2 or 3 dimensional images.");
};
};
return _spImage;
};
template <typename TInputPixel, typename TOutputPixel, unsigned int iDimension>
ImageReader<TInputPixel, TOutputPixel, iDimension>::
ImageReader()
{
_fileName = "";
_upperSeriesLimit = 255;
_upToDate = false;
_rescaleImage = false;
_rescaleMax = 255;
_rescaleMin = 0;
_seriesReadStyle = ImageSeriesReadStyle::Default;
};
template <typename TInputPixel, typename TOutputPixel, unsigned int iDimension>
ImageReader<TInputPixel, TOutputPixel, iDimension>::
~ImageReader()
= default;
template <typename TInputPixel, typename TOutputPixel, unsigned int iDimension>
typename ImageReader<TInputPixel, TOutputPixel, iDimension>::OutputImageType::Pointer readImage(
const FileNameString& fileName,
ImageSeriesReadStyle::Type readStyle,
bool rescaleImage,
typename ImageReader<TInputPixel, TOutputPixel, iDimension>::RescaleValueType rescaleMin,
typename ImageReader<TInputPixel, TOutputPixel, iDimension>::RescaleValueType rescaleMax,
unsigned int upperNumericSeriesLimit,
typename ImageReader<TInputPixel, TOutputPixel, iDimension>::MetaDataDictionaryArrayType*
pLoadedDictArray)
{
ImageReader<TInputPixel, TOutputPixel, iDimension> reader;
reader.setFileName(fileName);
reader.setSeriesReadStyle(readStyle);
reader.setRescaleImage(rescaleImage);
reader.setRescaleMaximum(rescaleMax);
reader.setRescaleMinimum(rescaleMin);
reader.setUpperSeriesLimit(upperNumericSeriesLimit);
typename ImageReader<TInputPixel, TOutputPixel, iDimension>::OutputImageType::Pointer spResult =
reader.GetOutput();
if (pLoadedDictArray)
{
*pLoadedDictArray = reader.getMetaDictionaryArray();
};
return spResult;
};
}
}
}
#endif
diff --git a/code/io/itk/rttbImageWriter.cpp b/code/io/itk/rttbImageWriter.cpp
index 8ea3b66..0130969 100644
--- a/code/io/itk/rttbImageWriter.cpp
+++ b/code/io/itk/rttbImageWriter.cpp
@@ -1,61 +1,55 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
#include "rttbImageWriter.h"
#include "rttbITKException.h"
namespace rttb
{
namespace io
{
namespace itk
{
ImageWriter::ImageWriter(const FileNameString& aFileName, ITKImageTypeConstPointer aITKImage)
: _fileName(aFileName), _itkImage(aITKImage)
{
}
bool ImageWriter::writeFile()
{
WriterType::Pointer writer = WriterType::New();
writer->SetFileName(_fileName);
writer->SetUseCompression(true);
writer->SetInput(_itkImage);
try
{
writer->Update();
}
catch (::itk::ExceptionObject& excp)
{
std::cerr << "Error: ITK Exception caught " << excp << std::endl;
throw rttb::io::itk::ITKException("ITK Exception in writing image: writer->Update()!");
return false;
}
return true;
}
}//end namespace itk
}//end namespace io
}//end namespace rttb
diff --git a/code/io/itk/rttbImageWriter.h b/code/io/itk/rttbImageWriter.h
index 70778fa..d3505ca 100644
--- a/code/io/itk/rttbImageWriter.h
+++ b/code/io/itk/rttbImageWriter.h
@@ -1,76 +1,70 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
#ifndef __RTTB_IMAGE_WRITER_H
#define __RTTB_IMAGE_WRITER_H
#include "RTToolboxConfigure.h"
#ifdef RTTB_DISABLE_ITK_IO_FACTORY_AUTO_REGISTER
#undef ITK_IO_FACTORY_REGISTER_MANAGER
#endif
#include "itkImage.h"
#include "itkImageFileWriter.h"
#include "rttbBaseType.h"
#include "RTTBITKIOExports.h"
namespace rttb
{
namespace io
{
namespace itk
{
/** @class ImageWriter
* @brief Helper class writing 3D images to file ...
*
*/
class RTTBITKIO_EXPORT ImageWriter
{
typedef ::itk::Image<DoseTypeGy, 3> ITKMaskImageType;
using ITKImageTypeConstPointer = ITKMaskImageType::ConstPointer;
using WriterType = ::itk::ImageFileWriter<ITKMaskImageType>;
private:
FileNameString _fileName;
ITKImageTypeConstPointer _itkImage;
public:
ImageWriter(const FileNameString& aFileName, ITKImageTypeConstPointer aITKImage);
/*! @brief Write itk image to file
@return Return true if successful.
@exception InvalidParameterException thrown if itk exception by writing the image
*/
bool writeFile();
};
}//end namespace itk
}//end namespace io
}//end namespace rttb
#endif
diff --git a/code/io/models/rttbModelXMLWriter.cpp b/code/io/models/rttbModelXMLWriter.cpp
index 81a2bb0..b187d7c 100644
--- a/code/io/models/rttbModelXMLWriter.cpp
+++ b/code/io/models/rttbModelXMLWriter.cpp
@@ -1,148 +1,142 @@
// -----------------------------------------------------------------------
// 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: 1328 $ (last changed revision)
-// @date $Date: 2016-04-22 09:50:01 +0200 (Fr, 22 Apr 2016) $ (last change date)
-// @author $Author: hentsch $ (last changed by)
-*/
#include "rttbModelXMLWriter.h"
#include <cmath>
/*boost includes*/
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include <boost/make_shared.hpp>
#include "rttbInvalidParameterException.h"
#include "rttbDVHXMLFileWriter.h"
#include "rttbDoseStatisticsXMLWriter.h"
namespace rttb
{
namespace io
{
namespace models
{
ModelXMLWriter::ModelXMLWriter(const std::string& filename,
rttb::models::BioModel::Pointer model, bool printDVH) : _filename(filename),
_model(model), _printDVH(printDVH)
{
}
void ModelXMLWriter::setFilename(FileNameString filename)
{
_filename = filename;
}
FileNameString ModelXMLWriter::getFilename() const
{
return _filename;
}
void ModelXMLWriter::setModel(rttb::models::BioModel::Pointer model)
{
_model = model;
}
rttb::models::BioModel::Pointer ModelXMLWriter::getModel() const
{
return _model;
}
void ModelXMLWriter::setPrintDVH(bool printDVH)
{
_printDVH = printDVH;
}
bool ModelXMLWriter::getPrintDVH() const
{
return _printDVH;
}
void ModelXMLWriter::writeModel()
{
std::setprecision(2);
boost::property_tree::ptree pt;
std::string xmlattrNameTag = "<xmlattr>.name";
std::string modelTag = "BioModel";
std::string propertyTag = "property";
std::string configTag = "config";
std::string resultsTag = "results";
std::string valueTag = "value";
auto dvh = _model->getDVH();
boost::property_tree::ptree propertynode;
boost::property_tree::ptree confignode;
confignode.put("BioModelType", _model->getModelType());
confignode.put("StructureID", dvh->getStructureID());
confignode.put("DoseID", dvh->getDoseID());
if (_printDVH)
{
FileNameString filename = "dvhfor" + _model->getModelType() + ".xml";
DVHType typeDiff = { DVHType::Differential };
io::other::DVHXMLFileWriter dvhWriter(filename, typeDiff);
dvhWriter.writeDVH(dvh);
confignode.put("DVHReference", filename);
}
pt.add_child(modelTag + "." + configTag, confignode);
propertynode.put("", _model->getValue());
propertynode.put(xmlattrNameTag, valueTag);
pt.add_child(modelTag + "." + resultsTag + "." + propertyTag, propertynode);
std::map<std::string, double> parameterMap = _model->getParameterMap();
for (std::map<std::string, double>::const_iterator it = parameterMap.begin();
it != parameterMap.end(); ++it)
{
double value = it->second;
if (value - static_cast<double>(std::round(value)) < errorConstant)
{
propertynode.put("", static_cast<int>(value));
}
else
{
propertynode.put("", static_cast<float>(value));
}
propertynode.put(xmlattrNameTag, it->first);
pt.add_child(modelTag + "." + resultsTag + "." + propertyTag, propertynode);
}
try
{
boost::property_tree::xml_parser::xml_writer_settings<std::string> settings =
boost::property_tree::xml_writer_make_settings<std::string>('\t', 1);
boost::property_tree::xml_parser::write_xml(_filename, pt, std::locale(), settings);
}
catch (const boost::property_tree::xml_parser_error& e)
{
std::cout << e.what();
throw core::InvalidParameterException("Write xml failed: xml_parser_error!");
}
}
}
}
}
diff --git a/code/io/models/rttbModelXMLWriter.h b/code/io/models/rttbModelXMLWriter.h
index f21417c..7a1e779 100644
--- a/code/io/models/rttbModelXMLWriter.h
+++ b/code/io/models/rttbModelXMLWriter.h
@@ -1,66 +1,57 @@
// -----------------------------------------------------------------------
// 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: 1250 $ (last changed revision)
-// @date $Date: 2016-02-18 15:25:55 +0100 (Do, 18 Feb 2016) $ (last change date)
-// @author $Author: zhangl $ (last changed by)
-*/
+
#ifndef __MODELS_XML_WRITER_H
#define __MODELS_XML_WRITER_H
-
-
#include "rttbBioModel.h"
-
-
namespace rttb
{
namespace io
{
namespace models
{
/*! @class ModelXMLWriter
@brief Writes a model (TCP, NTCP, ...) to an xml file
*/
class ModelXMLWriter
{
private:
std::string _filename;
rttb::models::BioModel::Pointer _model;
bool _printDVH;
public:
ModelXMLWriter(const std::string& filename, rttb::models::BioModel::Pointer model,
bool printDVH = true);
void setFilename(std::string filename);
std::string getFilename() const;
void setModel(rttb::models::BioModel::Pointer model);
rttb::models::BioModel::Pointer getModel() const;
void setPrintDVH(bool printDVH);
bool getPrintDVH() const;
void writeModel();
};
}
}
}
#endif
diff --git a/code/io/other/rttbDVHXMLFileReader.cpp b/code/io/other/rttbDVHXMLFileReader.cpp
index 506a671..6616a50 100644
--- a/code/io/other/rttbDVHXMLFileReader.cpp
+++ b/code/io/other/rttbDVHXMLFileReader.cpp
@@ -1,154 +1,148 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include <boost/foreach.hpp>
#include <boost/lexical_cast.hpp>
#include "rttbDVHXMLFileReader.h"
#include "rttbInvalidParameterException.h"
namespace rttb
{
namespace io
{
namespace other
{
DVHXMLFileReader::DVHXMLFileReader(FileNameString aFileName)
{
_fileName = aFileName;
_resetFile = true;
}
DVHXMLFileReader::~DVHXMLFileReader() = default;
void DVHXMLFileReader::resetFileName(FileNameString aFileName)
{
_fileName = aFileName;
_resetFile = true;
}
void DVHXMLFileReader::createDVH()
{
boost::property_tree::ptree pt;
// Load the XML file into the property tree. If reading fails
// (cannot open file, parse error), an exception is thrown.
try
{
read_xml(_fileName, pt);
}
catch (boost::property_tree::xml_parser_error& /*e*/)
{
throw rttb::core::InvalidParameterException("DVH file name invalid: could not open the xml file!");
}
std::string dvhType;
std::deque<DoseTypeGy> dataDifferential, dataCumulative;
DoseTypeGy deltaD = 0;
DoseVoxelVolumeType deltaV = 0;
IDType strID;
IDType doseID;
bool normalized;
dvhType = pt.get<std::string>("dvh.type");
deltaD = pt.get<DoseTypeGy>("dvh.deltaD");
deltaV = pt.get<DoseVoxelVolumeType>("dvh.deltaV");
strID = pt.get<IDType>("dvh.structureID");
doseID = pt.get<IDType>("dvh.doseID");
boost::optional<bool> dvhNormalized = pt.get_optional<bool>("dvh.normalized");
if (dvhNormalized)
{
normalized = dvhNormalized.get();
}
else
{
normalized = false;
}
if (dvhType != "DIFFERENTIAL" && dvhType != "CUMULATIVE")
{
throw core::InvalidParameterException("DVH Type invalid! Only: DIFFERENTIAL/CUMULATIVE!");
}
BOOST_FOREACH(boost::property_tree::ptree::value_type & v, pt.get_child("dvh.data"))
{
if (dvhType == "DIFFERENTIAL")
{
dataDifferential.push_back(boost::lexical_cast<DoseTypeGy>(v.second.data()) / (normalized ? deltaV : 1));
}
else if (dvhType == "CUMULATIVE")
{
dataCumulative.push_back(boost::lexical_cast<DoseTypeGy>(v.second.data()) / (normalized ? deltaV : 1));
}
}
unsigned int numberOfBins = static_cast<unsigned int>(std::max(dataDifferential.size(),
dataCumulative.size()));
if (dvhType == "CUMULATIVE") //dataDifferential should be calculated
{
DoseCalcType differentialDVHi = 0;
std::deque<DoseCalcType>::iterator it;
for (it = dataCumulative.begin(); it != dataCumulative.end(); ++it)
{
if (dataDifferential.size() == numberOfBins - 1)
{
differentialDVHi = *it;
}
else
{
differentialDVHi = *it - *(it + 1);
}
dataDifferential.push_back(differentialDVHi);
}
}
_dvh = boost::make_shared<core::DVH>(dataDifferential, deltaD, deltaV, strID, doseID);
_resetFile = false;
}
core::DVH::Pointer DVHXMLFileReader::generateDVH()
{
if (_resetFile)
{
this->createDVH();
}
return _dvh;
}
}//end namespace other
}//end namespace io
}//end namespace rttb
diff --git a/code/io/other/rttbDVHXMLFileReader.h b/code/io/other/rttbDVHXMLFileReader.h
index 6a7cf52..5b1cd6f 100644
--- a/code/io/other/rttbDVHXMLFileReader.h
+++ b/code/io/other/rttbDVHXMLFileReader.h
@@ -1,69 +1,64 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
+
#ifndef __DVH_XML_FILE_READER_H
#define __DVH_XML_FILE_READER_H
#include "rttbBaseType.h"
#include "rttbDVHGeneratorInterface.h"
namespace rttb
{
namespace io
{
namespace other
{
/*! @class DVHXMLFileReader
@brief Reads DVH data from xml files.
*/
class DVHXMLFileReader: public core::DVHGeneratorInterface
{
private:
FileNameString _fileName;
bool _resetFile;
/*! @brief Create new DVH object using the info from dvh txt file
@exception InvalidParameterException Thrown if _fileName invalid
*/
void createDVH();
public:
/*! @brief Constructor.
*/
DVHXMLFileReader(FileNameString aFileName);
~DVHXMLFileReader();
/*! @brief Change file name.
*/
void resetFileName(FileNameString aFileName);
/*! @brief Generate DVH, createDVH() will be called
@return Return new shared pointer of DVH.
@exception InvalidParameterException Thrown if _fileName invalid
*/
core::DVH::Pointer generateDVH() override;
};
}
}
}
#endif
diff --git a/code/io/other/rttbDVHXMLFileWriter.cpp b/code/io/other/rttbDVHXMLFileWriter.cpp
index 1114ec3..edede47 100644
--- a/code/io/other/rttbDVHXMLFileWriter.cpp
+++ b/code/io/other/rttbDVHXMLFileWriter.cpp
@@ -1,146 +1,139 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
-
#include "rttbDVHXMLFileWriter.h"
#include "rttbNullPointerException.h"
#include "rttbInvalidParameterException.h"
#include "rttbException.h"
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
namespace rttb
{
namespace io
{
namespace other
{
DVHXMLFileWriter::DVHXMLFileWriter(FileNameString aFileName, DVHType aDVHType)
{
this->setFileName(aFileName);
this->setDVHType(aDVHType);
}
void DVHXMLFileWriter::setDVHType(DVHType aDVHType)
{
_dvhType = aDVHType;
}
FileNameString DVHXMLFileWriter::getFileName() const
{
return _fileName;
}
void DVHXMLFileWriter::setFileName(FileNameString aFileName)
{
_fileName = aFileName;
}
DVHType DVHXMLFileWriter::getDVHType() const
{
return _dvhType;
}
void DVHXMLFileWriter::writeDVH(core::DVH::Pointer aDvh, bool normalized)
{
if (aDvh == nullptr)
{
throw core::NullPointerException("aDvh must not be nullptr! ");
}
using boost::property_tree::ptree;
ptree pt;
DataDifferentialType data;
std::map <DoseTypeGy, PercentType> normalizedData;
if (_dvhType.Type == DVHType::Differential)
{
pt.put("dvh.type", "DIFFERENTIAL");
if (normalized) {
normalizedData = aDvh->getNormalizedDVH({ DVHType::Cumulative });
}
else
{
data = aDvh->getDataDifferential();
}
}
else if (_dvhType.Type == DVHType::Cumulative)
{
pt.put("dvh.type", "CUMULATIVE");
if (normalized) {
normalizedData = aDvh->getNormalizedDVH();
}
else
{
data = aDvh->getDataCumulative();
}
}
else
{
throw core::InvalidParameterException("DVH Type not acceptable: Only: DIFFERENTIAL/CUMULATIVE!");
}
pt.put("dvh.deltaD", aDvh->getDeltaD());
pt.put("dvh.deltaV", aDvh->getDeltaV());
pt.put("dvh.structureID", aDvh->getStructureID());
pt.put("dvh.doseID", aDvh->getDoseID());
pt.put("dvh.normalized", normalized);
if (normalized) {
for (auto elem : normalizedData)
{
boost::property_tree::ptree node;
node.put("", elem.second);
node.put("<xmlattr>.doseGy", elem.first);
pt.add_child("dvh.data.volumeInCcm", node);
}
}
else
{
for (size_t i = 0; i < data.size(); i++)
{
boost::property_tree::ptree node;
node.put("", data[i]);
node.put("<xmlattr>.dosebin", i);
pt.add_child("dvh.data.volume", node);
}
}
try
{
boost::property_tree::xml_parser::xml_writer_settings<std::string> settings =
boost::property_tree::xml_writer_make_settings<std::string> ('\t', 1);
boost::property_tree::xml_parser::write_xml(_fileName, pt, std::locale(), settings);
}
catch (boost::property_tree::xml_parser_error& /*e*/)
{
throw core::InvalidParameterException("Write xml failed: xml_parser_error!");
}
}
}
}
}
diff --git a/code/io/other/rttbDVHXMLFileWriter.h b/code/io/other/rttbDVHXMLFileWriter.h
index 4e8a8f0..5157b99 100644
--- a/code/io/other/rttbDVHXMLFileWriter.h
+++ b/code/io/other/rttbDVHXMLFileWriter.h
@@ -1,84 +1,79 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
+
#ifndef __DVH_XML_FILE_WRITER_H
#define __DVH_XML_FILE_WRITER_H
#include "rttbDVH.h"
#include "../rttbDVHWriterInterface.h"
#include "rttbBaseType.h"
#include "RTTBOtherIOExports.h"
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4251)
#endif
namespace rttb
{
namespace io
{
namespace other
{
/*! @class DVHXMLFileWriter
@brief Writes DVHs to xml files.
*/
class RTTBOtherIO_EXPORT DVHXMLFileWriter : public DVHWriterInterface
{
public:
using DataDifferentialType = core::DVH::DataDifferentialType;
private:
FileNameString _fileName;
DVHType _dvhType;
public:
/*! @brief Constructor
@param aFileName a xml file name to write
@param aDVHType: DIFFERENTIAL or CUMULATIVE.
*/
DVHXMLFileWriter(FileNameString aFileName, DVHType aDVHType);
void setFileName(FileNameString aFileName);
FileNameString getFileName() const;
void setDVHType(DVHType aDVHType);
DVHType getDVHType() const;
/*! @brief Write aDvh to xml file with the name: _fileName
@exception NullPointerException Thrown if _aDvh is nullptr
@exception InvalidParameterException Thrown if _fileName invalid: could not open;
or if _dvhType invalid: only DIFFERENTIAL or CUMULATIVE is accepted!
@exception Exception thrown if dvh init error
*/
void writeDVH(core::DVH::Pointer aDvh, bool normalized = false) override;
};
}
}
}
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#endif
diff --git a/code/io/rttbDVHWriterInterface.h b/code/io/rttbDVHWriterInterface.h
index 86b06a0..890a265 100644
--- a/code/io/rttbDVHWriterInterface.h
+++ b/code/io/rttbDVHWriterInterface.h
@@ -1,47 +1,41 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
+
#ifndef __DVH_WRITER_INTERFACE_H
#define __DVH_WRITER_INTERFACE_H
-
#include "rttbDVH.h"
#include "RTTBOtherIOExports.h"
namespace rttb
{
namespace io
{
/*! @class DVHWriterInterface
@brief Interface for classes that write DVH data to files.
*/
class RTTBOtherIO_EXPORT DVHWriterInterface
{
/*! @brief Write aDvh
*/
public:
virtual void writeDVH(core::DVH::Pointer aDvh, bool normalized = false) = 0;
};
}
}
#endif
diff --git a/testing/io/helax/DicomHelaxDoseAccessorGeneratorTest.cpp b/testing/io/helax/DicomHelaxDoseAccessorGeneratorTest.cpp
index 13da8eb..0d400dd 100644
--- a/testing/io/helax/DicomHelaxDoseAccessorGeneratorTest.cpp
+++ b/testing/io/helax/DicomHelaxDoseAccessorGeneratorTest.cpp
@@ -1,136 +1,129 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
// this file defines the rttbCoreTests for the test driver
// and all it expects is that you have a function called RegisterTests
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include <iomanip>
#include "litCheckMacros.h"
#include "rttbBaseType.h"
#include "rttbDicomHelaxFileDoseAccessorGenerator.h"
#include "rttbDicomHelaxIODVecDoseAccessorGenerator.h"
#include "rttbDicomHelaxDoseAccessor.h"
#include "rttbInvalidDoseException.h"
#include "rttbInvalidParameterException.h"
-
namespace rttb
{
namespace testing
{
/*!@brief DicomHelaxDoseAccessorGeneratorTest - test the IO for dicom helax data
1) test dicom helax file generator generateDoseAccessor()
2) test dicom helax IOD vector generator generateDoseAccessor()
*/
int DicomHelaxDoseAccessorGeneratorTest(int argc, char* argv[])
{
typedef boost::shared_ptr<DRTDoseIOD> DRTDoseIODPtr;
PREPARE_DEFAULT_TEST_REPORTING;
//ARGUMENTS: 1: dose directory name
// 2: dose1 file name
// 3: dose2 file name
// 4: dose3 file name
std::string RTDOSE_DIRNAME;
std::string RTDOSE1_FILENAME;
std::string RTDOSE2_FILENAME;
std::string RTDOSE3_FILENAME;
if (argc > 1)
{
RTDOSE_DIRNAME = argv[1];
}
if (argc > 2)
{
RTDOSE1_FILENAME = argv[2];
}
if (argc > 3)
{
RTDOSE2_FILENAME = argv[3];
}
if (argc > 4)
{
RTDOSE3_FILENAME = argv[4];
}
OFCondition status;
DcmFileFormat fileformat;
/* test dicom helax file generator generateDoseAccessor() */
CHECK_THROW_EXPLICIT(
io::helax::DicomHelaxFileDoseAccessorGenerator("/testAsInvalidDirectoryName/").generateDoseAccessor(),
core::InvalidParameterException);
CHECK_NO_THROW(io::helax::DicomHelaxFileDoseAccessorGenerator(
RTDOSE_DIRNAME.c_str()).generateDoseAccessor());
/* test dicom helax IOD vector generator generateDoseAccessor()*/
DRTDoseIODPtr dose1 = boost::make_shared<DRTDoseIOD>();
DRTDoseIODPtr dose2 = boost::make_shared<DRTDoseIOD>();
DRTDoseIODPtr dose3 = boost::make_shared<DRTDoseIOD>();
std::vector<DRTDoseIODPtr> doseVector;
//test empty vector
CHECK_THROW_EXPLICIT(io::helax::DicomHelaxIODVecDoseAccessorGenerator(
doseVector).generateDoseAccessor(), core::InvalidParameterException);
doseVector.push_back(dose1);
doseVector.push_back(dose2);
doseVector.push_back(dose3);
//test vector with all empty dose IODs
CHECK_THROW_EXPLICIT(io::helax::DicomHelaxIODVecDoseAccessorGenerator(
doseVector).generateDoseAccessor(), core::InvalidDoseException);
fileformat.loadFile(RTDOSE1_FILENAME.c_str());
dose1->read(*fileformat.getDataset());
fileformat.loadFile(RTDOSE2_FILENAME.c_str());
dose2->read(*fileformat.getDataset());
//test vector with one empty dose IOD
CHECK_THROW_EXPLICIT(io::helax::DicomHelaxIODVecDoseAccessorGenerator(
doseVector).generateDoseAccessor(), core::InvalidDoseException);
fileformat.loadFile(RTDOSE3_FILENAME.c_str());
dose3->read(*fileformat.getDataset());
CHECK_NO_THROW(io::helax::DicomHelaxIODVecDoseAccessorGenerator(doseVector).generateDoseAccessor());
RETURN_AND_REPORT_TEST_SUCCESS;
}
}//testing
}//rttb
diff --git a/testing/io/helax/DicomHelaxIOTest.cpp b/testing/io/helax/DicomHelaxIOTest.cpp
index e27dba4..70714e8 100644
--- a/testing/io/helax/DicomHelaxIOTest.cpp
+++ b/testing/io/helax/DicomHelaxIOTest.cpp
@@ -1,128 +1,121 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
// this file defines the rttbCoreTests for the test driver
// and all it expects is that you have a function called RegisterTests
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include <iomanip>
#include "litCheckMacros.h"
#include "rttbBaseType.h"
#include "rttbGeometricInfo.h"
#include "rttbDoseIteratorInterface.h"
#include "rttbDicomHelaxFileDoseAccessorGenerator.h"
#include "rttbDicomHelaxIODVecDoseAccessorGenerator.h"
#include "rttbDicomHelaxDoseAccessor.h"
#include "rttbDicomFileStructureSetGenerator.h"
-
namespace rttb
{
namespace testing
{
/*!@brief DicomHelaxIOTest - test the IO for dicom helax data
1) test dicom helax dose import if geometric info was set correctly
2) test dicom helax dose import accessing dose data and converting
3) test dicom helax structure import
WARNING: The values for comparison need to be adjusted if the input files are changed!
*/
int DicomHelaxIOTest(int argc, char* argv[])
{
typedef core::DoseIteratorInterface::DoseAccessorPointer DoseAccessorPointer;
typedef core::StructureSet::Pointer StructureSetPointer;
PREPARE_DEFAULT_TEST_REPORTING;
//ARGUMENTS: 1: directory name
std::string RT_DIRNAME;
if (argc > 1)
{
RT_DIRNAME = argv[1];
}
OFCondition status;
DcmFileFormat fileformat;
/* read dicom-rt dose */
io::helax::DicomHelaxFileDoseAccessorGenerator doseAccessorGenerator1(RT_DIRNAME.c_str());
DoseAccessorPointer doseAccessor1(doseAccessorGenerator1.generateDoseAccessor());
//1) test dicom dose import if geometric info was set correctly
core::GeometricInfo geoInfo = doseAccessor1->getGeometricInfo();
CHECK_EQUAL(64, geoInfo.getNumRows());
CHECK_EQUAL(54, geoInfo.getNumColumns());
CHECK_EQUAL(52, geoInfo.getNumSlices());
CHECK_EQUAL(OrientationMatrix(), geoInfo.getOrientationMatrix());
const VoxelGridID start = 0;
const VoxelGridIndex3D start3D(0);
VoxelGridID end, inbetween;
VoxelGridIndex3D end3D, inbetween3D;
//2) test dicom dose import accessing dose data and converting
CHECK_EQUAL(doseAccessor1->getValueAt(start), doseAccessor1-> getValueAt(start3D));
inbetween = int(std::floor(doseAccessor1->getGridSize() / 2.0));
doseAccessor1->getGeometricInfo().convert(inbetween, inbetween3D);
CHECK_EQUAL(doseAccessor1->getValueAt(inbetween), doseAccessor1-> getValueAt(inbetween3D));
end = doseAccessor1->getGridSize() - 1;
doseAccessor1->getGeometricInfo().convert(end, end3D);
CHECK_EQUAL(doseAccessor1->getValueAt(end), doseAccessor1-> getValueAt(end3D));
/* structure set */
StructureSetPointer rtStructureSet = io::dicom::DicomFileStructureSetGenerator(
RT_DIRNAME.c_str()).generateStructureSet();
//3) test structure import
CHECK_EQUAL(8, rtStructureSet->getNumberOfStructures());
CHECK_EQUAL("Patient outline", (rtStructureSet->getStructure(0))->getLabel());
CHECK_EQUAL("boost", (rtStructureSet->getStructure(1))->getLabel());
CHECK_EQUAL("Chiasma", (rtStructureSet->getStructure(2))->getLabel());
CHECK_EQUAL("Sehnerv li.", (rtStructureSet->getStructure(3))->getLabel());
CHECK_EQUAL("Sehnerv re.", (rtStructureSet->getStructure(4))->getLabel());
CHECK_EQUAL("Auge li.", (rtStructureSet->getStructure(5))->getLabel());
CHECK_EQUAL("Auge re.", (rtStructureSet->getStructure(6))->getLabel());
CHECK_EQUAL("Hirnstamm", (rtStructureSet->getStructure(7))->getLabel());
RETURN_AND_REPORT_TEST_SUCCESS;
}
}//testing
}//rttb
diff --git a/testing/io/helax/rttbHelaxIOTests.cpp b/testing/io/helax/rttbHelaxIOTests.cpp
index 80bbbf3..4390d18 100644
--- a/testing/io/helax/rttbHelaxIOTests.cpp
+++ b/testing/io/helax/rttbHelaxIOTests.cpp
@@ -1,62 +1,56 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
// this file defines the rttbCoreTests for the test driver
// and all it expects is that you have a function called RegisterTests
#if defined(_MSC_VER)
#pragma warning ( disable : 4786 )
#endif
#include "litMultiTestsMain.h"
namespace rttb
{
namespace testing
{
void registerTests()
{
LIT_REGISTER_TEST(DicomHelaxDoseAccessorGeneratorTest);
LIT_REGISTER_TEST(DicomHelaxIOTest);
}
}
}
int main(int argc, char* argv[])
{
int result = 0;
rttb::testing::registerTests();
try
{
result = lit::multiTestsMain(argc, argv);
}
catch (...)
{
result = -1;
}
return result;
}
diff --git a/testing/io/itk/ITKBioModelAccessorConverterTest.cpp b/testing/io/itk/ITKBioModelAccessorConverterTest.cpp
index 000ee32..39798cc 100644
--- a/testing/io/itk/ITKBioModelAccessorConverterTest.cpp
+++ b/testing/io/itk/ITKBioModelAccessorConverterTest.cpp
@@ -1,112 +1,105 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
// this file defines the rttbCoreTests for the test driver
// and all it expects is that you have a function called RegisterTests
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include "litCheckMacros.h"
#include "itkImage.h"
#include "itkImageFileReader.h"
#include "rttbBaseType.h"
#include "rttbDoseIteratorInterface.h"
#include "rttbAccessorInterface.h"
#include "rttbDicomFileDoseAccessorGenerator.h"
#include "rttbDicomDoseAccessor.h"
#include "rttbLQModelAccessor.h"
#include "rttbITKImageAccessor.h"
#include "rttbITKImageFileAccessorGenerator.h"
#include "rttbITKImageAccessorGenerator.h"
#include "rttbITKImageAccessorConverter.h"
#include "rttbDoseAccessorProcessorBase.h"
#include "rttbDoseAccessorConversionSettingInterface.h"
#include "rttbInvalidDoseException.h"
-
namespace rttb
{
namespace testing
{
/*!@brief ITKBioModelAccessorConverterTest - test the conversion rttb BioModel accessor ->itk
1) test with dicom file (DicomDoseAccessorGenerator)
*/
int ITKBioModelAccessorConverterTest(int argc, char* argv[])
{
typedef core::AccessorInterface::Pointer AccessorPointer;
typedef core::DoseAccessorInterface::Pointer DoseAccessorPointer;
PREPARE_DEFAULT_TEST_REPORTING;
std::string RTDOSE_FILENAME;
if (argc > 1)
{
RTDOSE_FILENAME = argv[1];
}
//1) Read dicomFile and test process() and getITKImage()
io::dicom::DicomFileDoseAccessorGenerator doseAccessorGenerator(RTDOSE_FILENAME.c_str());
DoseAccessorPointer doseAccessor(doseAccessorGenerator.generateDoseAccessor());
AccessorPointer LQWithConstantDose = boost::make_shared<models::LQModelAccessor>(doseAccessor, 0.2,
0.02);
io::itk::ITKImageAccessorConverter itkConverter(LQWithConstantDose);
CHECK_NO_THROW(itkConverter.process());
CHECK_NO_THROW(itkConverter.getITKImage());
io::itk::ITKImageAccessor::ITKImageType::IndexType itkIndex;
itkIndex[0] = itkIndex[1] = itkIndex[2] = 0;
VoxelGridIndex3D rttbIndex(0, 0, 0);
CHECK_EQUAL(itkConverter.getITKImage()->GetPixel(itkIndex),
LQWithConstantDose->getValueAt(rttbIndex));
itkIndex[0] = rttbIndex[0] = doseAccessor->getGeometricInfo().getNumColumns() / 2;
itkIndex[1] = rttbIndex[1] = doseAccessor->getGeometricInfo().getNumRows() / 2;
itkIndex[2] = rttbIndex[2] = doseAccessor->getGeometricInfo().getNumSlices() / 2;
CHECK_EQUAL(itkConverter.getITKImage()->GetPixel(itkIndex),
LQWithConstantDose->getValueAt(rttbIndex));
itkIndex[0] = rttbIndex[0] = doseAccessor->getGeometricInfo().getNumColumns() - 1;
itkIndex[1] = rttbIndex[1] = doseAccessor->getGeometricInfo().getNumRows() - 1;
itkIndex[2] = rttbIndex[2] = doseAccessor->getGeometricInfo().getNumSlices() - 1;
CHECK_EQUAL(itkConverter.getITKImage()->GetPixel(itkIndex),
LQWithConstantDose->getValueAt(rttbIndex));
RETURN_AND_REPORT_TEST_SUCCESS;
}
}//testing
}//rttb
diff --git a/testing/io/itk/ITKDoseAccessorConverterTest.cpp b/testing/io/itk/ITKDoseAccessorConverterTest.cpp
index 464ff41..f21ee7a 100644
--- a/testing/io/itk/ITKDoseAccessorConverterTest.cpp
+++ b/testing/io/itk/ITKDoseAccessorConverterTest.cpp
@@ -1,134 +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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
// this file defines the rttbCoreTests for the test driver
// and all it expects is that you have a function called RegisterTests
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include "litCheckMacros.h"
#include "litImageTester.h"
#include "litTestImageIO.h"
#include "itkImage.h"
#include "itkImageFileReader.h"
#include "rttbBaseType.h"
#include "rttbDoseIteratorInterface.h"
#include "rttbDicomFileDoseAccessorGenerator.h"
#include "rttbDicomDoseAccessor.h"
#include "rttbITKImageAccessorConverter.h"
#include "rttbITKImageFileAccessorGenerator.h"
#include "rttbDoseAccessorProcessorBase.h"
#include "rttbDoseAccessorConversionSettingInterface.h"
#include "rttbInvalidDoseException.h"
-
namespace rttb
{
namespace testing
{
/*!@brief ITKDoseAccessorConverterTest - test the conversion rttb dose accessor ->itk
1) test with dicom file (DicomDoseAccessorGenerator)
2) test with mhd file (ITKImageFileDoseAccessorGenerator)
*/
int ITKDoseAccessorConverterTest(int argc, char* argv[])
{
typedef core::DoseIteratorInterface::DoseAccessorPointer DoseAccessorPointer;
PREPARE_DEFAULT_TEST_REPORTING;
//ARGUMENTS:
// 1: dose1 file name
// 2: dose2 file name
std::string RTDOSE_FILENAME;
std::string RTDOSE2_FILENAME;
if (argc > 1)
{
RTDOSE_FILENAME = argv[1];
}
if (argc > 2)
{
RTDOSE2_FILENAME = argv[2];
}
//1) Read dicomFile and test getITKImage()
io::dicom::DicomFileDoseAccessorGenerator doseAccessorGenerator(RTDOSE_FILENAME.c_str());
DoseAccessorPointer doseAccessor(doseAccessorGenerator.generateDoseAccessor());
io::itk::ITKImageAccessorConverter itkConverter(doseAccessor);
CHECK_NO_THROW(itkConverter.process());
CHECK_NO_THROW(itkConverter.getITKImage());
io::itk::ITKImageAccessorConverter::ITKImageType::IndexType itkIndex;
itkIndex[0] = itkIndex[1] = itkIndex[2] = 0;
VoxelGridIndex3D rttbIndex(0, 0, 0);
CHECK_EQUAL(itkConverter.getITKImage()->GetPixel(itkIndex), doseAccessor->getValueAt(rttbIndex));
itkIndex[0] = rttbIndex[0] = doseAccessor->getGeometricInfo().getNumColumns() / 2;
itkIndex[1] = rttbIndex[1] = doseAccessor->getGeometricInfo().getNumRows() / 2;
itkIndex[2] = rttbIndex[2] = doseAccessor->getGeometricInfo().getNumSlices() / 2;
CHECK_EQUAL(itkConverter.getITKImage()->GetPixel(itkIndex), doseAccessor->getValueAt(rttbIndex));
itkIndex[0] = rttbIndex[0] = doseAccessor->getGeometricInfo().getNumColumns() - 1;
itkIndex[1] = rttbIndex[1] = doseAccessor->getGeometricInfo().getNumRows() - 1;
itkIndex[2] = rttbIndex[2] = doseAccessor->getGeometricInfo().getNumSlices() - 1;
CHECK_EQUAL(itkConverter.getITKImage()->GetPixel(itkIndex), doseAccessor->getValueAt(rttbIndex));
//2) Read mhdFile and test getITKImage() with Litmus TestImageIO
io::itk::ITKImageFileAccessorGenerator doseAccessorGenerator2(RTDOSE2_FILENAME.c_str());
DoseAccessorPointer doseAccessor2(doseAccessorGenerator2.generateDoseAccessor());
io::itk::ITKImageAccessorConverter itkConverter2(doseAccessor2);
CHECK_NO_THROW(itkConverter2.process());
CHECK_NO_THROW(itkConverter2.getITKImage());
io::itk::ITKImageAccessorConverter::ITKImageType::Pointer expectedImage =
lit::TestImageIO<unsigned char, io::itk::ITKImageAccessorConverter::ITKImageType>::readImage(
RTDOSE2_FILENAME);
::lit::ImageTester<io::itk::ITKImageAccessorConverter::ITKImageType, io::itk::ITKImageAccessorConverter::ITKImageType >
tester;
tester.setExpectedImage(expectedImage);
tester.setActualImage(itkConverter2.getITKImage());
CHECK_TESTER(tester);
RETURN_AND_REPORT_TEST_SUCCESS;
}
}//testing
}//rttb
diff --git a/testing/io/itk/ITKDoseAccessorGeneratorTest.cpp b/testing/io/itk/ITKDoseAccessorGeneratorTest.cpp
index a215841..d19514c 100644
--- a/testing/io/itk/ITKDoseAccessorGeneratorTest.cpp
+++ b/testing/io/itk/ITKDoseAccessorGeneratorTest.cpp
@@ -1,106 +1,100 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
// this file defines the rttbCoreTests for the test driver
// and all it expects is that you have a function called RegisterTests
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include "litCheckMacros.h"
#include "itkImage.h"
#include "itkImageFileReader.h"
#include "itkExceptionObject.h"
#include "rttbBaseType.h"
#include "rttbITKImageAccessorConverter.h"
#include "rttbITKImageAccessorGenerator.h"
#include "rttbITKImageFileAccessorGenerator.h"
#include "rttbInvalidDoseException.h"
#include "rttbInvalidParameterException.h"
namespace rttb
{
namespace testing
{
/*!@brief ITKDoseAccessorGeneratorTest - test the generators for dicom data
1) test itk file generator generateDoseAccessor()
2) test itk generator generateDoseAccessor()
*/
int ITKDoseAccessorGeneratorTest(int argc, char* argv[])
{
PREPARE_DEFAULT_TEST_REPORTING;
//ARGUMENTS:
// 1: mhd/raw file name with short image type
// 2: mhd/raw file name with double image type
std::string ITKSHORTFILE_FILENAME, ITKDOUBLEFILE_FILENAME, ITK2DVECTORFILE_FILENAME, ITK2DFILE_FILENAME;
if (argc > 4)
{
ITKSHORTFILE_FILENAME = argv[1];
ITKDOUBLEFILE_FILENAME = argv[2];
ITK2DVECTORFILE_FILENAME = argv[3];
ITK2DFILE_FILENAME = argv[4];
}
/* test ITKFileDoseAccessorGenerator generateDoseAccessor()*/
CHECK_THROW_EXPLICIT(io::itk::ITKImageFileAccessorGenerator("test.test").generateDoseAccessor(),
core::InvalidDoseException);
CHECK_NO_THROW(io::itk::ITKImageFileAccessorGenerator(
ITKSHORTFILE_FILENAME.c_str()).generateDoseAccessor());
CHECK_NO_THROW(io::itk::ITKImageFileAccessorGenerator(
ITKDOUBLEFILE_FILENAME.c_str()).generateDoseAccessor());
CHECK_THROW_EXPLICIT(io::itk::ITKImageFileAccessorGenerator(
ITK2DFILE_FILENAME.c_str()).generateDoseAccessor(), core::InvalidParameterException);
CHECK_THROW(io::itk::ITKImageFileAccessorGenerator(
ITK2DVECTORFILE_FILENAME.c_str()).generateDoseAccessor());
/* test ITKDoseAccessorGenerator generateDoseAccessor()*/
typedef itk::Image< DoseTypeGy, 3 > DoseImageType;
typedef itk::ImageFileReader<DoseImageType> ReaderType;
DoseImageType::Pointer invalidDose = DoseImageType::New();
ReaderType::Pointer reader = ReaderType::New();
CHECK_THROW_EXPLICIT(io::itk::ITKImageAccessorGenerator(
invalidDose.GetPointer()).generateDoseAccessor(), core::InvalidDoseException);
reader->SetFileName(ITKSHORTFILE_FILENAME);
//important to update the reader (won't work without)
reader->Update();
CHECK_NO_THROW(io::itk::ITKImageAccessorGenerator(reader->GetOutput()).generateDoseAccessor());
RETURN_AND_REPORT_TEST_SUCCESS;
}
}//testing
}//rttb
diff --git a/testing/io/itk/ITKIOTest.cpp b/testing/io/itk/ITKIOTest.cpp
index caae969..3d179f1 100644
--- a/testing/io/itk/ITKIOTest.cpp
+++ b/testing/io/itk/ITKIOTest.cpp
@@ -1,217 +1,210 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
// this file defines the rttbCoreTests for the test driver
// and all it expects is that you have a function called RegisterTests
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include "litCheckMacros.h"
#include "rttbBaseType.h"
#include "rttbGeometricInfo.h"
#include "rttbDoseIteratorInterface.h"
#include "rttbITKImageAccessorConverter.h"
#include "rttbITKImageAccessorGenerator.h"
#include "rttbITKImageFileAccessorGenerator.h"
#include "rttbITKImageFileMaskAccessorGenerator.h"
#include "rttbITKImageAccessor.h"
#include "rttbITKImageMaskAccessor.h"
#include "rttbInvalidDoseException.h"
#include "itkImageFileReader.h"
-
namespace rttb
{
namespace testing
{
/*!@brief ITKIOTest - test the IO for ITK data
1) test ITK dose import if geometric info was set correctly
2) test ITKImageFileDoseAccessorGenerator accessing dose data and converting (*.mhd file)
3) test ITKImageDoseAccessorGenerator accessing dose data and converting (*.mhd file)
WARNING: The values for comparison need to be adjusted if the input files are changed!
*/
int ITKIOTest(int argc, char* argv[])
{
typedef core::DoseIteratorInterface::DoseAccessorPointer DoseAccessorPointer;
typedef core::MaskAccessorInterface::Pointer MaskAccessorPointer;
PREPARE_DEFAULT_TEST_REPORTING;
//ARGUMENTS:
// 1: mhd file name
// 2: mask file name
std::string RTDOSE_FILENAME, VOXELIZEDMASK_FILENAME;
if (argc > 2)
{
RTDOSE_FILENAME = argv[1];
VOXELIZEDMASK_FILENAME = argv[2];
}
/* read dose in *.mhd file */
io::itk::ITKImageFileAccessorGenerator doseAccessorGenerator1(RTDOSE_FILENAME.c_str());
DoseAccessorPointer doseAccessor1(doseAccessorGenerator1.generateDoseAccessor());
//1) test ITK dose import if geometric info was set correctly
core::GeometricInfo geoInfo = doseAccessor1->getGeometricInfo();
CHECK_EQUAL(25, geoInfo.getNumRows());
CHECK_EQUAL(25, geoInfo.getNumColumns());
CHECK_EQUAL(15, geoInfo.getNumSlices());
//orientation matrix equals identity matrix
CHECK_EQUAL(OrientationMatrix(), geoInfo.getOrientationMatrix());
const VoxelGridID start = 0;
const VoxelGridIndex3D start3D(0);
VoxelGridID end, inbetween, inbetween2, outside;
VoxelGridIndex3D end3D, inbetween3D, inbetween23D, outside3D;
//2) test ITK dose import accessing dose data and converting (*.mhd file)
CHECK(doseAccessor1->getGeometricInfo().validID(start));
CHECK(doseAccessor1->getGeometricInfo().validIndex(start3D));
CHECK(!(doseAccessor1->getGeometricInfo().validID(doseAccessor1->getGridSize())));
CHECK(!(doseAccessor1->getGeometricInfo().validIndex(VoxelGridIndex3D(
doseAccessor1->getGridSize()))));
CHECK_EQUAL(0, doseAccessor1->getValueAt(start));
CHECK_EQUAL(doseAccessor1->getValueAt(start), doseAccessor1-> getValueAt(start3D));
CHECK_NO_THROW(doseAccessor1->getUID());
inbetween = 4039;
doseAccessor1->getGeometricInfo().convert(inbetween, inbetween3D);
CHECK(doseAccessor1->getGeometricInfo().validID(inbetween));
CHECK(doseAccessor1->getGeometricInfo().validIndex(inbetween3D));
CHECK_EQUAL(162.0, doseAccessor1->getValueAt(inbetween));
CHECK_EQUAL(doseAccessor1->getValueAt(inbetween), doseAccessor1-> getValueAt(inbetween3D));
inbetween2 = 6086;
doseAccessor1->getGeometricInfo().convert(inbetween2, inbetween23D);
CHECK(doseAccessor1->getGeometricInfo().validID(inbetween2));
CHECK(doseAccessor1->getGeometricInfo().validIndex(inbetween23D));
CHECK_EQUAL(7.0, doseAccessor1->getValueAt(inbetween2));
CHECK_EQUAL(doseAccessor1->getValueAt(inbetween2), doseAccessor1-> getValueAt(inbetween23D));
end = doseAccessor1->getGridSize() - 1;
outside = end + 1;
doseAccessor1->getGeometricInfo().convert(end, end3D);
outside3D = VoxelGridIndex3D(end3D.x() + 2, end3D.y(), end3D.z());
CHECK(doseAccessor1->getGeometricInfo().validID(end));
CHECK(doseAccessor1->getGeometricInfo().validIndex(end3D));
CHECK_EQUAL(0, doseAccessor1->getValueAt(end));
CHECK_EQUAL(doseAccessor1->getValueAt(end), doseAccessor1-> getValueAt(end3D));
CHECK_EQUAL(-1, doseAccessor1->getValueAt(outside));
CHECK_EQUAL(-1, doseAccessor1->getValueAt(outside3D));
typedef itk::Image< DoseTypeGy, 3 > DoseImageType;
typedef itk::ImageFileReader<DoseImageType> ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(RTDOSE_FILENAME);
//important to update the reader (won't work without)
reader->Update();
io::itk::ITKImageAccessorGenerator doseAccessorGenerator2(reader->GetOutput());
DoseAccessorPointer doseAccessor2(doseAccessorGenerator2.generateDoseAccessor());
//3) test ITK dose import accessing dose data and converting (ITKImageDoseAccessor)
CHECK(doseAccessor2->getGeometricInfo().validID(start));
CHECK(doseAccessor2->getGeometricInfo().validIndex(start3D));
CHECK(!(doseAccessor2->getGeometricInfo().validID(doseAccessor2->getGridSize())));
CHECK(!(doseAccessor2->getGeometricInfo().validIndex(VoxelGridIndex3D(
doseAccessor2->getGridSize()))));
CHECK_EQUAL(0, doseAccessor2->getValueAt(start));
CHECK_EQUAL(doseAccessor2->getValueAt(start), doseAccessor2->getValueAt(start3D));
CHECK(doseAccessor2->getGeometricInfo().validID(inbetween));
CHECK(doseAccessor2->getGeometricInfo().validIndex(inbetween3D));
CHECK_EQUAL(162.0, doseAccessor2->getValueAt(inbetween));
CHECK_EQUAL(doseAccessor2->getValueAt(inbetween), doseAccessor2->getValueAt(inbetween3D));
CHECK(doseAccessor2->getGeometricInfo().validID(inbetween2));
CHECK(doseAccessor2->getGeometricInfo().validIndex(inbetween23D));
CHECK_EQUAL(7.0, doseAccessor2->getValueAt(inbetween2));
CHECK_EQUAL(doseAccessor2->getValueAt(inbetween2), doseAccessor2->getValueAt(inbetween23D));
end = doseAccessor2->getGridSize() - 1;
doseAccessor2->getGeometricInfo().convert(end, end3D);
CHECK(doseAccessor2->getGeometricInfo().validID(end));
CHECK(doseAccessor2->getGeometricInfo().validIndex(end3D));
CHECK_EQUAL(0, doseAccessor2->getValueAt(end));
CHECK_EQUAL(doseAccessor2->getValueAt(end), doseAccessor2-> getValueAt(end3D));
/* test ITKImageAccessor*/
typedef itk::Image< DoseTypeGy, 3 > DoseImageType;
DoseImageType::Pointer invalidDose = DoseImageType::New();
CHECK_THROW_EXPLICIT(io::itk::ITKImageAccessor(invalidDose.GetPointer()), core::InvalidDoseException);
/* test ITKImageMaskAccessor*/
CHECK_THROW_EXPLICIT(io::itk::ITKImageMaskAccessor(invalidDose.GetPointer()), core::InvalidDoseException);
io::itk::ITKImageFileMaskAccessorGenerator maskAccessorGenerator(VOXELIZEDMASK_FILENAME.c_str());
MaskAccessorPointer maskAccessor(maskAccessorGenerator.generateMaskAccessor());
auto imageSize = maskAccessor->getGeometricInfo().getImageSize();
end = imageSize.x()*imageSize.y()*imageSize.z() - 1;
outside = end + 1;
maskAccessor->getGeometricInfo().convert(end, end3D);
outside3D = VoxelGridIndex3D(end3D.x() + 2, end3D.y(), end3D.z());
inbetween3D = VoxelGridIndex3D(139, 61, 57);
maskAccessor->getGeometricInfo().convert(inbetween3D, inbetween);
core::MaskVoxel aVoxel(0);
CHECK_EQUAL(maskAccessor->getMaskAt(start, aVoxel), true);
CHECK_EQUAL(aVoxel.getRelevantVolumeFraction(), 0.0);
CHECK_EQUAL(maskAccessor->getMaskAt(end, aVoxel), true);
CHECK_EQUAL(aVoxel.getRelevantVolumeFraction(), 0.0);
CHECK_EQUAL(maskAccessor->getMaskAt(end3D, aVoxel), true);
CHECK_EQUAL(aVoxel.getRelevantVolumeFraction(), 0.0);
CHECK_EQUAL(maskAccessor->getMaskAt(outside, aVoxel), false);
CHECK_EQUAL(maskAccessor->getMaskAt(outside3D, aVoxel), false);
CHECK_EQUAL(maskAccessor->getMaskAt(inbetween, aVoxel), true);
CHECK_EQUAL(aVoxel.getRelevantVolumeFraction(), 1.0);
CHECK_EQUAL(maskAccessor->getMaskAt(inbetween3D, aVoxel), true);
CHECK_EQUAL(aVoxel.getRelevantVolumeFraction(), 1.0);
RETURN_AND_REPORT_TEST_SUCCESS;
}
}//testing
}//rttb
diff --git a/testing/io/itk/ITKMaskAccessorConverterTest.cpp b/testing/io/itk/ITKMaskAccessorConverterTest.cpp
index 83f4884..47350d4 100644
--- a/testing/io/itk/ITKMaskAccessorConverterTest.cpp
+++ b/testing/io/itk/ITKMaskAccessorConverterTest.cpp
@@ -1,178 +1,170 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
// this file defines the rttbCoreTests for the test driver
// and all it expects is that you have a function called RegisterTests
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include "litCheckMacros.h"
#include "litImageTester.h"
#include "litTestImageIO.h"
#include "itkImage.h"
#include "itkImageFileReader.h"
#include "rttbBaseType.h"
#include "rttbDoseIteratorInterface.h"
#include "rttbDicomFileDoseAccessorGenerator.h"
#include "rttbDicomDoseAccessor.h"
#include "rttbInvalidDoseException.h"
#include "rttbDicomFileStructureSetGenerator.h"
#include "rttbITKImageMaskAccessorConverter.h"
#include "rttbITKImageFileMaskAccessorGenerator.h"
#include "rttbBoostMaskAccessor.h"
-
-
namespace rttb
{
namespace testing
{
/*!@brief MaskAccessorConverterTest - test the conversion rttb dose accessor ->itk
1) test with dicom file (DicomDoseAccessorGenerator)
2) test with mhd file (ITKImageFileDoseAccessorGenerator)
*/
int ITKMaskAccessorConverterTest(int argc, char* argv[])
{
typedef core::DoseIteratorInterface::DoseAccessorPointer DoseAccessorPointer;
typedef core::StructureSet::Pointer StructureSetPointer;
typedef core::MaskAccessorInterface::Pointer MaskAccessorPointer;
typedef io::itk::ITKImageMaskAccessor::ITKMaskImageType::Pointer ITKImageTypePointer;
PREPARE_DEFAULT_TEST_REPORTING;
//ARGUMENTS:
//ARGUMENTS: 1: structure file name
// 2: dose1 file name
std::string RTStr_FILENAME;
std::string RTDose_FILENAME;
std::string Mask_FILENAME;
if (argc > 3)
{
RTStr_FILENAME = argv[1];
RTDose_FILENAME = argv[2];
Mask_FILENAME = argv[3];
}
//1) Read dicomFile and test getITKImage()
io::dicom::DicomFileDoseAccessorGenerator doseAccessorGenerator1(RTDose_FILENAME.c_str());
DoseAccessorPointer doseAccessor1(doseAccessorGenerator1.generateDoseAccessor());
StructureSetPointer rtStructureSet = io::dicom::DicomFileStructureSetGenerator(
RTStr_FILENAME.c_str()).generateStructureSet();
MaskAccessorPointer maskAccessorPtr = boost::make_shared<rttb::masks::boost::BoostMaskAccessor>
(rtStructureSet->getStructure(9), doseAccessor1->getGeometricInfo());
maskAccessorPtr->updateMask();//!Important: Update the mask before conversion.
io::itk::ITKImageMaskAccessorConverter maskAccessorConverter(maskAccessorPtr);
CHECK_NO_THROW(maskAccessorConverter.process());
CHECK_NO_THROW(maskAccessorConverter.getITKImage());
//2) Read itk image, generate mask and convert it back to itk image, check equal
MaskAccessorPointer maskAccessorPtr2 = io::itk::ITKImageFileMaskAccessorGenerator(
Mask_FILENAME.c_str()).generateMaskAccessor();
maskAccessorPtr2->updateMask();//!Important: Update the mask before conversion.
io::itk::ITKImageMaskAccessorConverter maskAccessorConverter2(maskAccessorPtr2);
maskAccessorConverter2.process();
typedef itk::Image< DoseTypeGy, 3 > MaskImageType;
ITKImageTypePointer convertedImagePtr = maskAccessorConverter2.getITKImage();
io::itk::ITKImageMaskAccessor::ITKMaskImageType::Pointer expectedImage =
lit::TestImageIO<unsigned char, io::itk::ITKImageMaskAccessor::ITKMaskImageType>::readImage(
Mask_FILENAME);
CHECK_EQUAL(convertedImagePtr->GetOrigin()[0], expectedImage->GetOrigin()[0]);
CHECK_EQUAL(convertedImagePtr->GetOrigin()[1], expectedImage->GetOrigin()[1]);
CHECK_EQUAL(convertedImagePtr->GetOrigin()[2], expectedImage->GetOrigin()[2]);
CHECK_EQUAL(convertedImagePtr->GetSpacing()[0], expectedImage->GetSpacing()[0]);
CHECK_EQUAL(convertedImagePtr->GetSpacing()[1], expectedImage->GetSpacing()[1]);
CHECK_EQUAL(convertedImagePtr->GetSpacing()[2], expectedImage->GetSpacing()[2]);
CHECK_EQUAL(convertedImagePtr->GetLargestPossibleRegion().GetSize()[0],
expectedImage->GetLargestPossibleRegion().GetSize()[0]);
CHECK_EQUAL(convertedImagePtr->GetLargestPossibleRegion().GetSize()[1],
expectedImage->GetLargestPossibleRegion().GetSize()[1]);
CHECK_EQUAL(convertedImagePtr->GetLargestPossibleRegion().GetSize()[2],
expectedImage->GetLargestPossibleRegion().GetSize()[2]);
unsigned int sizeX = convertedImagePtr->GetLargestPossibleRegion().GetSize()[0];
unsigned int sizeY = convertedImagePtr->GetLargestPossibleRegion().GetSize()[1];
unsigned int sizeZ = convertedImagePtr->GetLargestPossibleRegion().GetSize()[2];
io::itk::ITKImageMaskAccessor::ITKMaskImageType::IndexType index;
for (unsigned int i = 0; i < 20 && i < sizeX && i < sizeY && i < sizeZ; i++)
{
index[0] = i;
index[1] = i;
index[2] = i;
if (expectedImage->GetPixel(index) >= 0 && expectedImage->GetPixel(index) <= 1)
{
CHECK_EQUAL(convertedImagePtr->GetPixel(index), expectedImage->GetPixel(index));
}
}
for (unsigned int i = 0; i < 20; i++)
{
index[0] = sizeX - 1 - i;
index[1] = sizeY - 1 - i;
index[2] = sizeZ - 1 - i;
if (expectedImage->GetPixel(index) >= 0 && expectedImage->GetPixel(index) <= 1)
{
CHECK_EQUAL(convertedImagePtr->GetPixel(index), expectedImage->GetPixel(index));
}
}
for (unsigned int i = 0; i < 20 && (sizeX / 2 - i) < sizeX && (sizeY / 2 - i) < sizeY
&& (sizeZ / 2 - i) < sizeZ; i++)
{
index[0] = sizeX / 2 - i;
index[1] = sizeY / 2 - i;
index[2] = sizeZ / 2 - i;
if (expectedImage->GetPixel(index) >= 0 && expectedImage->GetPixel(index) <= 1)
{
CHECK_EQUAL(convertedImagePtr->GetPixel(index), expectedImage->GetPixel(index));
}
}
RETURN_AND_REPORT_TEST_SUCCESS;
}
}//testing
}//rttb
diff --git a/testing/io/itk/ITKMaskAccessorGeneratorTest.cpp b/testing/io/itk/ITKMaskAccessorGeneratorTest.cpp
index a4c011f..ac6cee6 100644
--- a/testing/io/itk/ITKMaskAccessorGeneratorTest.cpp
+++ b/testing/io/itk/ITKMaskAccessorGeneratorTest.cpp
@@ -1,101 +1,94 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
// this file defines the rttbCoreTests for the test driver
// and all it expects is that you have a function called RegisterTests
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include "litCheckMacros.h"
#include "itkImage.h"
#include "itkImageFileReader.h"
#include "rttbBaseType.h"
#include "rttbInvalidDoseException.h"
#include "rttbITKImageFileMaskAccessorGenerator.h"
#include "rttbITKImageMaskAccessorGenerator.h"
-
namespace rttb
{
namespace testing
{
/*!@brief MaskAccessorGeneratorTest - test the generators for dicom data
1) test itk file generator generateDoseAccessor()
2) test itk generator generateDoseAccessor()
*/
int ITKMaskAccessorGeneratorTest(int argc, char* argv[])
{
PREPARE_DEFAULT_TEST_REPORTING;
//ARGUMENTS:
// 1: mhd/raw file name
std::string Mask_FILENAME;
if (argc > 1)
{
Mask_FILENAME = argv[1];
}
/* test ITKImageFileMaskAccessorGenerator generateDoseAccessor()*/
CHECK_THROW_EXPLICIT(io::itk::ITKImageFileMaskAccessorGenerator("test.test").generateMaskAccessor(),
core::InvalidDoseException);
CHECK_NO_THROW(io::itk::ITKImageFileMaskAccessorGenerator(
Mask_FILENAME.c_str()).generateMaskAccessor());
/* test ITKImageMaskAccessorGenerator generateDoseAccessor()*/
typedef itk::Image< DoseTypeGy, 3 > MaskImageType;
typedef itk::ImageFileReader<MaskImageType> ReaderType;
MaskImageType::Pointer invalidDose = MaskImageType::New();
ReaderType::Pointer reader = ReaderType::New();
CHECK_THROW_EXPLICIT(io::itk::ITKImageMaskAccessorGenerator(
invalidDose.GetPointer()).generateMaskAccessor(), core::InvalidDoseException);
reader->SetFileName(Mask_FILENAME);
//important to update the reader (won't work without)
reader->Update();
CHECK_NO_THROW(io::itk::ITKImageMaskAccessorGenerator(reader->GetOutput()).generateMaskAccessor());
io::itk::ITKImageMaskAccessorGenerator::MaskAccessorPointer maskAcc =
io::itk::ITKImageMaskAccessorGenerator(reader->GetOutput()).generateMaskAccessor();
CHECK_NO_THROW(maskAcc->getRelevantVoxelVector());
CHECK_EQUAL(maskAcc->isGridHomogeneous(), true);
CHECK_NO_THROW(maskAcc->getMaskUID());
RETURN_AND_REPORT_TEST_SUCCESS;
}
}//testing
}//rttb
diff --git a/testing/io/itk/rttbITKIOTests.cpp b/testing/io/itk/rttbITKIOTests.cpp
index c05d662..6571fa2 100644
--- a/testing/io/itk/rttbITKIOTests.cpp
+++ b/testing/io/itk/rttbITKIOTests.cpp
@@ -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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
// this file defines the rttbCoreTests for the test driver
// and all it expects is that you have a function called RegisterTests
#if defined(_MSC_VER)
#pragma warning ( disable : 4786 )
#endif
#include "litMultiTestsMain.h"
namespace rttb
{
namespace testing
{
void registerTests()
{
LIT_REGISTER_TEST(ITKDoseAccessorGeneratorTest);
LIT_REGISTER_TEST(ITKDoseAccessorConverterTest);
LIT_REGISTER_TEST(ITKBioModelAccessorConverterTest);
LIT_REGISTER_TEST(ITKIOTest);
LIT_REGISTER_TEST(ITKMaskAccessorGeneratorTest);
LIT_REGISTER_TEST(ITKMaskAccessorConverterTest);
}
}
}
int main(int argc, char* argv[])
{
int result = 0;
rttb::testing::registerTests();
try
{
result = lit::multiTestsMain(argc, argv);
}
catch (...)
{
result = -1;
}
return result;
}
diff --git a/testing/io/models/ModelsIOTest.cpp b/testing/io/models/ModelsIOTest.cpp
index 3c73890..712d68c 100644
--- a/testing/io/models/ModelsIOTest.cpp
+++ b/testing/io/models/ModelsIOTest.cpp
@@ -1,142 +1,132 @@
// -----------------------------------------------------------------------
// RTToolbox - DKFZ radiotherapy quantitative evaluation library
//
// (c) Copyright 2007, DKFZ, Heidelberg, Germany
// ALL RIGHTS RESERVED
//
// THIS FILE CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION OF DKFZ.
// ANY DUPLICATION, MODIFICATION, DISTRIBUTION, OR
// DISCLOSURE IN ANY FORM, IN WHOLE, OR IN PART, IS STRICTLY PROHIBITED
// WITHOUT THE PRIOR EXPRESS WRITTEN PERMISSION OF DKFZ.
//
//------------------------------------------------------------------------
-/*!
-// @file
-// @version $Revision: 1221 $ (last changed revision)
-// @date $Date: 2015-12-01 13:43:31 +0100 (Di, 01 Dez 2015) $ (last change date)
-// @author zhangl (last changed by)
-// @author *none* (Reviewer)
-// @author zhangl (Programmer)
-//
-// Subversion HeadURL: $HeadURL: http://sidt-hpc1/dkfz_repository/NotMeVisLab/SIDT/RTToolbox/trunk/testing/core/DVHCalculatorTest.cpp $
-*/
// this file defines the rttbCoreTests for the test driver
// and all it expects is that you have a function called RegisterTests
#include <fstream>
#include "litCheckMacros.h"
#include "rttbBioModel.h"
#include "rttbTCPLQModel.h"
#include "rttbNTCPLKBModel.h"
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include "boost/filesystem.hpp"
#include "rttbModelXMLWriter.h"
namespace rttb
{
namespace testing
{
static std::string readFile(const std::string& filename);
int ModelsIOTest(int argc, char* argv[])
{
std::string expectedxmlfilenametcpleq;
std::string expectedxmlfilenamentcplk;
if (argc > 2)
{
expectedxmlfilenametcpleq = argv[1];
expectedxmlfilenamentcplk = argv[2];
}
typedef core::DVH::DataDifferentialType DataDifferentialType;
PREPARE_DEFAULT_TEST_REPORTING;
//generate artificial DVH and corresponding statistical values
DoseTypeGy binSize = DoseTypeGy(0.1);
DoseVoxelVolumeType voxelVolume = 8;
DataDifferentialType aDataDifferential;
DoseCalcType value = 0;
DVHVoxelNumber numberOfVoxels = 0;
// creat default values
for (int i = 0; i < 98; i++)
{
value = 0;
numberOfVoxels += value;
aDataDifferential.push_back(value);
}
aDataDifferential.push_back(10);
aDataDifferential.push_back(20);
const IDType structureID = "myStructure";
const IDType doseID = "myDose";
const IDType voxelizationID = "myVoxelization";
core::DVH::Pointer dvhPtr = boost::make_shared<core::DVH>(aDataDifferential, binSize,
voxelVolume, structureID,
doseID, voxelizationID);
//test TCP LQ Model
models::BioModelParamType alpha = 0.35;
models::BioModelParamType beta = 0.023333333333333;
models::BioModelParamType roh = 10000000;
int numFractions = 8;
boost::shared_ptr<rttb::models::TCPLQModel> tcplq = boost::make_shared<rttb::models::TCPLQModel>
(dvhPtr, roh, numFractions, alpha / beta, alpha, 0.08);
std::string filename = "BioModeltcpleqIOTest.xml";
rttb::io::models::ModelXMLWriter writer = rttb::io::models::ModelXMLWriter(filename, tcplq, false);
CHECK_NO_THROW(writer.writeModel());
CHECK_EQUAL(boost::filesystem::exists(filename), true);
std::string defaultAsIs = readFile(filename);
std::string defaultExpected = readFile(expectedxmlfilenametcpleq);
//Does not work due to double imprecisions. As long as we don't have a ModelXMLReader, a check does not makes sense. See T21832
//CHECK_EQUAL(defaultAsIs, defaultExpected);
CHECK_EQUAL(std::remove(filename.c_str()), 0);
//test NTCPLKBModel
models::BioModelParamType aVal = 10;
models::BioModelParamType mVal = 0.16;
models::BioModelParamType d50Val = 35;
boost::shared_ptr<rttb::models::NTCPLKBModel> ntcplk =
boost::make_shared<rttb::models::NTCPLKBModel>(dvhPtr, d50Val, mVal, aVal);
filename = "BioModelntcplkIOTest.xml";
rttb::io::models::ModelXMLWriter writer2 = rttb::io::models::ModelXMLWriter(filename, ntcplk);
CHECK_NO_THROW(writer2.writeModel());
CHECK_EQUAL(boost::filesystem::exists(filename), true);
defaultAsIs = readFile(filename);
defaultExpected = readFile(expectedxmlfilenamentcplk);
//Does not work due to double imprecisions. As long as we don't have a ModelXMLReader, a check does not makes sense. See T21832
//CHECK_EQUAL(defaultAsIs, defaultExpected);
CHECK_EQUAL(std::remove(filename.c_str()), 0);
std::string dvhFilename = "dvhfor" + ntcplk->getModelType() + ".xml";
CHECK_EQUAL(std::remove(dvhFilename.c_str()), 0);
RETURN_AND_REPORT_TEST_SUCCESS;
}
std::string readFile(const std::string& filename)
{
std::ifstream fileStream(filename.c_str());
std::string content((std::istreambuf_iterator<char>(fileStream)),
(std::istreambuf_iterator<char>()));
return content;
}
}
}
diff --git a/testing/io/models/rttbModelsIOTests.cpp b/testing/io/models/rttbModelsIOTests.cpp
index 6ce7276..dc954aa 100644
--- a/testing/io/models/rttbModelsIOTests.cpp
+++ b/testing/io/models/rttbModelsIOTests.cpp
@@ -1,60 +1,54 @@
// -----------------------------------------------------------------------
// 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)
-*/
// this file defines the rttbCoreTests for the test driver
// and all it expects is that you have a function called RegisterTests
#if defined(_MSC_VER)
#pragma warning ( disable : 4786 )
#endif
#include "litMultiTestsMain.h"
namespace rttb
{
namespace testing
{
void registerTests()
{
LIT_REGISTER_TEST(ModelsIOTest);
}
}
}
int main(int argc, char* argv[])
{
int result = 0;
rttb::testing::registerTests();
try
{
result = lit::multiTestsMain(argc, argv);
}
catch (...)
{
result = -1;
}
return result;
}
diff --git a/testing/io/other/DVHXMLIOTest.cpp b/testing/io/other/DVHXMLIOTest.cpp
index f7c4d97..eb7647c 100644
--- a/testing/io/other/DVHXMLIOTest.cpp
+++ b/testing/io/other/DVHXMLIOTest.cpp
@@ -1,107 +1,101 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
// this file defines the rttbCoreTests for the test driver
// and all it expects is that you have a function called RegisterTests
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/lexical_cast.hpp>
#include "litCheckMacros.h"
#include "rttbBaseType.h"
#include "rttbDVH.h"
#include "rttbDVHSet.h"
#include "rttbDVHXMLFileReader.h"
#include "rttbDVHXMLFileWriter.h"
#include "rttbInvalidParameterException.h"
#include "rttbNullPointerException.h"
#include "../../core/DummyDVHGenerator.h"
#include "CompareDVH.h"
namespace rttb
{
namespace testing
{
/*! @brief DVHXMLIOTest - test the IO for DVH xml data
1) test writing dvh to xml file
2) test reading DVH from xml file
*/
int DVHXMLIOTest(int argc, char* argv[])
{
typedef core::DVH::Pointer DVHPointer;
PREPARE_DEFAULT_TEST_REPORTING;
/* generate dummy DVH */
const IDType structureIDPrefix = "myStructure";
const IDType doseID = "myDose";
DummyDVHGenerator dvhGenerator;
DVHPointer spMyDVH = boost::make_shared<core::DVH>(dvhGenerator.generateDVH(structureIDPrefix,
doseID));
// 1) test writing DVH to xml file
DVHType typeCum = {DVHType::Cumulative};
DVHType typeDiff = {DVHType::Differential};
FileNameString fN1 = "test.xml";
CHECK_NO_THROW(io::other::DVHXMLFileWriter(fN1, typeDiff));
CHECK_NO_THROW(io::other::DVHXMLFileWriter(fN1, typeCum));
io::other::DVHXMLFileWriter dvhWriter(fN1, typeCum);
CHECK_EQUAL(fN1, dvhWriter.getFileName());
FileNameString fN2 = "otherFile.xml";
CHECK_NO_THROW(dvhWriter.setFileName(fN2));
CHECK_EQUAL(fN2, dvhWriter.getFileName());
CHECK_EQUAL(DVHType::Cumulative, dvhWriter.getDVHType().Type);
CHECK_NO_THROW(dvhWriter.setDVHType(typeDiff));
CHECK_EQUAL(DVHType::Differential, dvhWriter.getDVHType().Type);
DVHPointer emptyDvh;
CHECK_THROW_EXPLICIT(dvhWriter.writeDVH(emptyDvh), core::NullPointerException);
//CHECK_THROW_EXPLICIT(dvhWriter.writeDVH(spMyDVH), core::InvalidParameterException);
CHECK_NO_THROW(dvhWriter.setDVHType(typeDiff));
CHECK_NO_THROW(dvhWriter.writeDVH(spMyDVH));
// 2) test reading DVH from xml file
io::other::DVHXMLFileReader dvhReader(fN2);
DVHPointer importedDVH = dvhReader.generateDVH();
CHECK_EQUAL(*importedDVH, *spMyDVH);
RETURN_AND_REPORT_TEST_SUCCESS;
}
}//testing
}//rttb
diff --git a/testing/io/other/DoseStatisticsIOTest.cpp b/testing/io/other/DoseStatisticsIOTest.cpp
index 74a3f44..16ab4c2 100644
--- a/testing/io/other/DoseStatisticsIOTest.cpp
+++ b/testing/io/other/DoseStatisticsIOTest.cpp
@@ -1,138 +1,131 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
// this file defines the rttbCoreTests for the test driver
// and all it expects is that you have a function called RegisterTests
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/filesystem.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include "litCheckMacros.h"
#include "rttbDoseStatistics.h"
#include "rttbDoseStatisticsCalculator.h"
#include "rttbDoseStatisticsXMLWriter.h"
#include "rttbDoseStatisticsXMLReader.h"
#include "rttbGenericDoseIterator.h"
#include "rttbDoseIteratorInterface.h"
#include "rttbInvalidParameterException.h"
#include "rttbNullPointerException.h"
#include "../../core/DummyDoseAccessor.h"
#include "CompareDoseStatistic.h"
-
namespace rttb
{
namespace testing
{
/*! @brief DoseStatisticsIOTest - test the DoseStatisticsIO for dose statistics
1) test writing statistics to xml file
2) test reading statistics from XML file and compare DoseStatistics
3) test writing statistics to string
*/
int DoseStatisticsIOTest(int argc, char* argv[])
{
typedef core::GenericDoseIterator::DoseAccessorPointer DoseAccessorPointer;
typedef core::DoseIteratorInterface::Pointer DoseIteratorPointer;
PREPARE_DEFAULT_TEST_REPORTING;
/* generate dummy dose */
boost::shared_ptr<DummyDoseAccessor> spTestDoseAccessor = boost::make_shared<DummyDoseAccessor>();
DoseAccessorPointer spDoseAccessor(spTestDoseAccessor);
boost::shared_ptr<core::GenericDoseIterator> spTestDoseIterator =
boost::make_shared<core::GenericDoseIterator>(spDoseAccessor);
DoseIteratorPointer spDoseIterator(spTestDoseIterator);
rttb::algorithms::DoseStatisticsCalculator myDoseStatsCalculator(spDoseIterator);
auto myDoseStatsSimple = myDoseStatsCalculator.calculateDoseStatistics();
auto myDoseStatsComplex = myDoseStatsCalculator.calculateDoseStatistics(true);
auto doseStatisticsXMLWriter = io::other::DoseStatisticsXMLWriter();
//1) test writing statistics to xml file
CHECK_THROW_EXPLICIT(doseStatisticsXMLWriter.writeDoseStatistics(nullptr, "aFilename.txt"), core::NullPointerException);
FileNameString filenameSimple = "testStatisticsSimple.xml";
CHECK_NO_THROW(doseStatisticsXMLWriter.writeDoseStatistics(myDoseStatsSimple, filenameSimple));
CHECK(boost::filesystem::exists(filenameSimple));
FileNameString filenameComplex = "testStatisticsComplex.xml";
CHECK_NO_THROW(doseStatisticsXMLWriter.writeDoseStatistics(myDoseStatsComplex, filenameComplex));
CHECK(boost::filesystem::exists(filenameComplex));
//2) test reading statistics from XML file and compare DoseStatistics
io::other::DoseStatisticsXMLReader readerSimple= io::other::DoseStatisticsXMLReader(filenameSimple);
boost::shared_ptr<rttb::algorithms::DoseStatistics> rereadSimplyDose;
CHECK_NO_THROW(rereadSimplyDose = readerSimple.generateDoseStatistic());
CHECK(checkEqualDoseStatistic(myDoseStatsSimple, rereadSimplyDose));
io::other::DoseStatisticsXMLReader readerComplex = io::other::DoseStatisticsXMLReader(filenameComplex);
boost::shared_ptr<rttb::algorithms::DoseStatistics> rereadComplexDose;
CHECK_NO_THROW(rereadComplexDose = readerComplex.generateDoseStatistic());
CHECK(checkEqualDoseStatistic(myDoseStatsComplex, rereadComplexDose));
io::other::DoseStatisticsXMLReader readerInvalidFilename = io::other::DoseStatisticsXMLReader("invalidFilename.xml");
CHECK_THROW_EXPLICIT(readerInvalidFilename.generateDoseStatistic(), core::InvalidParameterException);
//delete files again
CHECK_EQUAL(std::remove(filenameSimple.c_str()), 0);
CHECK_EQUAL(std::remove(filenameComplex.c_str()),0);
//3) test writing statistics to string
boost::property_tree::ptree ptSimple = doseStatisticsXMLWriter.writeDoseStatistics(myDoseStatsSimple);
XMLString strSimple = doseStatisticsXMLWriter.writerDoseStatisticsToString(myDoseStatsSimple);
CHECK_THROW_EXPLICIT(doseStatisticsXMLWriter.writerDoseStatisticsToString(nullptr), core::NullPointerException);
boost::property_tree::ptree ptComplex = doseStatisticsXMLWriter.writeDoseStatistics(myDoseStatsComplex);
XMLString strComplex = doseStatisticsXMLWriter.writerDoseStatisticsToString(myDoseStatsComplex);
std::stringstream sstrSimple;
boost::property_tree::xml_parser::write_xml(sstrSimple, ptSimple,
boost::property_tree::xml_writer_make_settings<std::string>('\t',
1));
CHECK_EQUAL(strSimple, sstrSimple.str());
std::stringstream sstrComplex;
boost::property_tree::xml_parser::write_xml(sstrComplex, ptComplex,
boost::property_tree::xml_writer_make_settings<std::string>('\t',
1));
CHECK_EQUAL(strComplex, sstrComplex.str());
RETURN_AND_REPORT_TEST_SUCCESS;
}
}//testing
}//rttb
diff --git a/testing/io/other/rttbIOTests.cpp b/testing/io/other/rttbIOTests.cpp
index 6d552b4..712151e 100644
--- a/testing/io/other/rttbIOTests.cpp
+++ b/testing/io/other/rttbIOTests.cpp
@@ -1,61 +1,55 @@
// -----------------------------------------------------------------------
// 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$ (last changed revision)
-// @date $Date$ (last change date)
-// @author $Author$ (last changed by)
-*/
// this file defines the rttbCoreTests for the test driver
// and all it expects is that you have a function called RegisterTests
#if defined(_MSC_VER)
#pragma warning ( disable : 4786 )
#endif
#include "litMultiTestsMain.h"
namespace rttb
{
namespace testing
{
void registerTests()
{
LIT_REGISTER_TEST(DoseStatisticsIOTest);
LIT_REGISTER_TEST(DVHXMLIOTest);
}
}
}
int main(int argc, char* argv[])
{
int result = 0;
rttb::testing::registerTests();
try
{
result = lit::multiTestsMain(argc, argv);
}
catch (...)
{
result = -1;
}
return result;
}