diff --git a/code/algorithms/files.cmake b/code/algorithms/files.cmake index 247adf6..417a976 100644 --- a/code/algorithms/files.cmake +++ b/code/algorithms/files.cmake @@ -1,46 +1,46 @@ SET(CPP_FILES rttbDoseStatistics.cpp rttbDoseStatisticsCalculator.cpp rttbArithmetic.cpp - rttbVolumeToDoseMeasureCalculator.cpp - rttbDxVolumeToDoseMeasureCalculator.cpp - rttbMOHxVolumeToDoseMeasureCalculator.cpp - rttbMOCxVolumeToDoseMeasureCalculator.cpp - rttbMinOCxVolumeToDoseMeasureCalculator.cpp - rttbMaxOHxVolumeToDoseMeasureCalculator.cpp + rttbVolumeToDoseMeasureCollectionCalculator.cpp + rttbDxVolumeToDoseMeasureCollectionCalculator.cpp + rttbMOHxVolumeToDoseMeasureCollectionCalculator.cpp + rttbMOCxVolumeToDoseMeasureCollectionCalculator.cpp + rttbMinOCxVolumeToDoseMeasureCollectionCalculator.cpp + rttbMaxOHxVolumeToDoseMeasureCollectionCalculator.cpp - rttbDoseToVolumeMeasureCalculator.cpp - rttbVxDoseToVolumeMeasureCalculator.cpp + rttbDoseToVolumeMeasureCollectionCalculator.cpp + rttbVxDoseToVolumeMeasureCollectionCalculator.cpp - rttbMeasureInterface.cpp - rttbVolumeToDoseMeasure.cpp - rttbDoseToVolumeMeasure.cpp + rttbMeasureCollection.cpp + rttbVolumeToDoseMeasureCollection.cpp + rttbDoseToVolumeMeasureCollection.cpp ) SET(H_FILES rttbDoseStatistics.h rttbDoseStatisticsCalculator.h rttbArithmetic.h rttbBinaryFunctorAccessor.h - rttbVolumeToDoseMeasureCalculator.h - rttbDxVolumeToDoseMeasureCalculator.h - rttbMOHxVolumeToDoseMeasureCalculator.h - rttbMOCxVolumeToDoseMeasureCalculator.h - rttbMinOCxVolumeToDoseMeasureCalculator.h - rttbMaxOHxVolumeToDoseMeasureCalculator.h + rttbVolumeToDoseMeasureCollectionCalculator.h + rttbDxVolumeToDoseMeasureCollectionCalculator.h + rttbMOHxVolumeToDoseMeasureCollectionCalculator.h + rttbMOCxVolumeToDoseMeasureCollectionCalculator.h + rttbMinOCxVolumeToDoseMeasureCollectionCalculator.h + rttbMaxOHxVolumeToDoseMeasureCollectionCalculator.h - rttbDoseToVolumeMeasureCalculator.h - rttbVxDoseToVolumeMeasureCalculator.h + rttbDoseToVolumeMeasureCollectionCalculator.h + rttbVxDoseToVolumeMeasureCollectionCalculator.h - rttbMeasureInterface.h - rttbVolumeToDoseMeasure.h - rttbDoseToVolumeMeasure.h + rttbMeasureCollection.h + rttbVolumeToDoseMeasureCollection.h + rttbDoseToVolumeMeasureCollection.h ) SET(TXX_FILES rttbArithmetic.tpp rttbBinaryFunctorAccessor.tpp ) diff --git a/code/algorithms/rttbDoseStatistics.cpp b/code/algorithms/rttbDoseStatistics.cpp index b289693..afb0f01 100644 --- a/code/algorithms/rttbDoseStatistics.cpp +++ b/code/algorithms/rttbDoseStatistics.cpp @@ -1,292 +1,292 @@ // ----------------------------------------------------------------------- // 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 "rttbDoseStatistics.h" #include "boost/make_shared.hpp" #include "rttbDataNotAvailableException.h" #include "rttbInvalidParameterException.h" namespace rttb { namespace algorithms { DoseStatistics::DoseStatistics(DoseStatisticType minimum, DoseStatisticType maximum, DoseStatisticType mean, DoseStatisticType stdDeviation, VoxelNumberType numVoxels, VolumeType volume, ResultListPointer maximumVoxelPositions /*= ResultListPointer()*/, ResultListPointer minimumVoxelPositions /*= ResultListPointer()*/, - VolumeToDoseMeasure Dx, - DoseToVolumeMeasure Vx, - VolumeToDoseMeasure MOHx, - VolumeToDoseMeasure MOCx, - VolumeToDoseMeasure MaxOHx, - VolumeToDoseMeasure MinOCx, + VolumeToDoseMeasureCollection Dx, + DoseToVolumeMeasureCollection Vx, + VolumeToDoseMeasureCollection MOHx, + VolumeToDoseMeasureCollection MOCx, + VolumeToDoseMeasureCollection MaxOHx, + VolumeToDoseMeasureCollection MinOCx, DoseTypeGy referenceDose /*=-1*/): _minimum(minimum), _maximum(maximum), _mean(mean), _stdDeviation(stdDeviation), _numVoxels(numVoxels), _volume(volume), _Dx(Dx), _Vx(Vx), _MOHx(MOHx), _MOCx(MOCx), _MaxOHx(MaxOHx), _MinOCx(MinOCx) { if (maximumVoxelPositions == NULL) { _maximumVoxelPositions = boost::make_shared > > (std::vector >()); } else { _maximumVoxelPositions = maximumVoxelPositions; } if (minimumVoxelPositions == NULL) { _minimumVoxelPositions = boost::make_shared > > (std::vector >()); } else { _minimumVoxelPositions = minimumVoxelPositions; } if (referenceDose <= 0) { _referenceDose = _maximum; } else { _referenceDose = referenceDose; } } DoseStatistics::~DoseStatistics() { } void DoseStatistics::setMinimumVoxelPositions(ResultListPointer minimumVoxelPositions) { _minimumVoxelPositions = minimumVoxelPositions; } void DoseStatistics::setMaximumVoxelPositions(ResultListPointer maximumVoxelPositions) { _maximumVoxelPositions = maximumVoxelPositions; } - void DoseStatistics::setDx(const VolumeToDoseMeasure& DxValues) + void DoseStatistics::setDx(const VolumeToDoseMeasureCollection& DxValues) { _Dx = DxValues; } - void DoseStatistics::setVx(const DoseToVolumeMeasure& VxValues) + void DoseStatistics::setVx(const DoseToVolumeMeasureCollection& VxValues) { _Vx = VxValues; } - void DoseStatistics::setMOHx(const VolumeToDoseMeasure& MOHxValues) + void DoseStatistics::setMOHx(const VolumeToDoseMeasureCollection& MOHxValues) { _MOHx = MOHxValues; } - void DoseStatistics::setMOCx(const VolumeToDoseMeasure& MOCxValues) + void DoseStatistics::setMOCx(const VolumeToDoseMeasureCollection& MOCxValues) { _MOCx = MOCxValues; } - void DoseStatistics::setMaxOHx(const VolumeToDoseMeasure& MaxOHValues) + void DoseStatistics::setMaxOHx(const VolumeToDoseMeasureCollection& MaxOHValues) { _MaxOHx = MaxOHValues; } - void DoseStatistics::setMinOCx(const VolumeToDoseMeasure& MinOCValues) + void DoseStatistics::setMinOCx(const VolumeToDoseMeasureCollection& MinOCValues) { _MinOCx = MinOCValues; } void DoseStatistics::setReferenceDose(DoseTypeGy referenceDose) { if (referenceDose <= 0) { _referenceDose = _maximum; } else { _referenceDose = referenceDose; } } VoxelNumberType DoseStatistics::getNumberOfVoxels() const { return _numVoxels; } VolumeType DoseStatistics::getVolume() const { return _volume; } DoseTypeGy DoseStatistics::getReferenceDose() const { return _referenceDose; } DoseStatisticType DoseStatistics::getMaximum() const { return _maximum; } DoseStatisticType DoseStatistics::getMinimum() const { return _minimum; } DoseStatisticType DoseStatistics::getMean() const { return _mean; } DoseStatisticType DoseStatistics::getStdDeviation() const { return _stdDeviation; } DoseStatisticType DoseStatistics::getVariance() const { return _stdDeviation * _stdDeviation; } double DoseStatistics::getValue(const std::map& aMap, double key, bool findNearestValueInstead, double& storedKey) const { if (aMap.find(key) != std::end(aMap)) { return aMap.find(key)->second; } else { //value not in map. We have to find the nearest value if (aMap.empty()) { throw core::DataNotAvailableException("No Vx values are defined"); } else { if (findNearestValueInstead) { auto iterator = findNearestKeyInMap(aMap, key); storedKey = iterator->first; return iterator->second; } else { throw core::DataNotAvailableException("No Vx value with required dose is defined"); } } } } std::map::const_iterator DoseStatistics::findNearestKeyInMap( const std::map& aMap, double key) const { double minDistance = 1e19; double minDistanceLast = 1e20; auto iterator = std::begin(aMap); while (iterator != std::end(aMap)) { minDistanceLast = minDistance; minDistance = fabs(iterator->first - key); if (minDistanceLast > minDistance) { ++iterator; } else { if (iterator != std::begin(aMap)) { --iterator; return iterator; } else { return std::begin(aMap); } } } --iterator; return iterator; } DoseStatistics::ResultListPointer DoseStatistics::getMaximumVoxelPositions() const { return _maximumVoxelPositions; } DoseStatistics::ResultListPointer DoseStatistics::getMinimumVoxelPositions() const { return _minimumVoxelPositions; } - DoseToVolumeMeasure DoseStatistics::getVx() const + DoseToVolumeMeasureCollection DoseStatistics::getVx() const { return _Vx; } - VolumeToDoseMeasure DoseStatistics::getDx() const + VolumeToDoseMeasureCollection DoseStatistics::getDx() const { return _Dx; } - VolumeToDoseMeasure DoseStatistics::getMOHx() const + VolumeToDoseMeasureCollection DoseStatistics::getMOHx() const { return _MOHx; } - VolumeToDoseMeasure DoseStatistics::getMOCx() const + VolumeToDoseMeasureCollection DoseStatistics::getMOCx() const { return _MOCx; } - VolumeToDoseMeasure DoseStatistics::getMaxOHx() const + VolumeToDoseMeasureCollection DoseStatistics::getMaxOHx() const { return _MaxOHx; } - VolumeToDoseMeasure DoseStatistics::getMinOCx() const + VolumeToDoseMeasureCollection DoseStatistics::getMinOCx() const { return _MinOCx; } }//end namespace algorithms }//end namespace rttb diff --git a/code/algorithms/rttbDoseStatistics.h b/code/algorithms/rttbDoseStatistics.h index 7138e0f..3b0cb4c 100644 --- a/code/algorithms/rttbDoseStatistics.h +++ b/code/algorithms/rttbDoseStatistics.h @@ -1,170 +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) */ #ifndef __DOSE_STATISTICS_H #define __DOSE_STATISTICS_H #include #include #include "boost/shared_ptr.hpp" #include "rttbBaseType.h" #include "RTTBAlgorithmsExports.h" -#include "rttbVolumeToDoseMeasure.h" -#include "rttbDoseToVolumeMeasure.h" +#include "rttbVolumeToDoseMeasureCollection.h" +#include "rttbDoseToVolumeMeasureCollection.h" namespace rttb { namespace algorithms { /*! @class DoseStatistics @brief This is a data class storing different statistical values from a rt dose distribution @sa DoseStatisticsCalculator */ class RTTBAlgorithms_EXPORT DoseStatistics { public: enum complexStatistics { Dx, Vx, MOHx, MOCx, MaxOHx, MinOCx }; typedef boost::shared_ptr > > ResultListPointer; typedef boost::shared_ptr DoseStatisticsPointer; private: double getValue(const std::map& aMap, double key, bool findNearestValueInstead, double& storedKey) const; std::map::const_iterator findNearestKeyInMap(const std::map& aMap, double key) const; DoseStatisticType _maximum; DoseStatisticType _minimum; ResultListPointer _maximumVoxelPositions; ResultListPointer _minimumVoxelPositions; DoseStatisticType _mean; DoseStatisticType _stdDeviation; VoxelNumberType _numVoxels; VolumeType _volume; DoseTypeGy _referenceDose; //for Vx computation - VolumeToDoseMeasure _Dx; - DoseToVolumeMeasure _Vx; - VolumeToDoseMeasure _MOHx; - VolumeToDoseMeasure _MOCx; - VolumeToDoseMeasure _MaxOHx; - VolumeToDoseMeasure _MinOCx; + VolumeToDoseMeasureCollection _Dx; + DoseToVolumeMeasureCollection _Vx; + VolumeToDoseMeasureCollection _MOHx; + VolumeToDoseMeasureCollection _MOCx; + VolumeToDoseMeasureCollection _MaxOHx; + VolumeToDoseMeasureCollection _MinOCx; public: /*! @brief Standard Constructor */ //DoseStatistics(); /*! @brief Constructor @details the dose statistic values are set. Complex values maximumVoxelLocation, maximumVoxelLocation, Dx, Vx, MOHx, MOCx, MaxOHx and MinOCx are optional */ DoseStatistics(DoseStatisticType minimum, DoseStatisticType maximum, DoseStatisticType mean, DoseStatisticType stdDeviation, VoxelNumberType numVoxels, VolumeType volume, - ResultListPointer minimumVoxelPositions = NULL, - ResultListPointer maximumVoxelPositions = NULL, - VolumeToDoseMeasure Dx = VolumeToDoseMeasure(VolumeToDoseMeasure::Dx), - DoseToVolumeMeasure Vx = DoseToVolumeMeasure(DoseToVolumeMeasure::Vx), - VolumeToDoseMeasure MOHx = VolumeToDoseMeasure(VolumeToDoseMeasure::MOHx), - VolumeToDoseMeasure MOCx = VolumeToDoseMeasure(VolumeToDoseMeasure::MOCx), - VolumeToDoseMeasure MaxOHx = VolumeToDoseMeasure(VolumeToDoseMeasure::MaxOHx), - VolumeToDoseMeasure MinOCx = VolumeToDoseMeasure(VolumeToDoseMeasure::MinOCx), + ResultListPointer minimumVoxelPositions = nullptr, + ResultListPointer maximumVoxelPositions = nullptr, + VolumeToDoseMeasureCollection Dx = VolumeToDoseMeasureCollection(VolumeToDoseMeasureCollection::Dx), + DoseToVolumeMeasureCollection Vx = DoseToVolumeMeasureCollection(DoseToVolumeMeasureCollection::Vx), + VolumeToDoseMeasureCollection MOHx = VolumeToDoseMeasureCollection(VolumeToDoseMeasureCollection::MOHx), + VolumeToDoseMeasureCollection MOCx = VolumeToDoseMeasureCollection(VolumeToDoseMeasureCollection::MOCx), + VolumeToDoseMeasureCollection MaxOHx = VolumeToDoseMeasureCollection(VolumeToDoseMeasureCollection::MaxOHx), + VolumeToDoseMeasureCollection MinOCx = VolumeToDoseMeasureCollection(VolumeToDoseMeasureCollection::MinOCx), DoseTypeGy referenceDose = -1); ~DoseStatistics(); void setMinimumVoxelPositions(ResultListPointer minimumVoxelPositions); void setMaximumVoxelPositions(ResultListPointer maximumVoxelPositions); - void setDx(const VolumeToDoseMeasure& DxValues); - void setVx(const DoseToVolumeMeasure& VxValues); - void setMOHx(const VolumeToDoseMeasure& MOHxValues); - void setMOCx(const VolumeToDoseMeasure& MOCxValues); - void setMaxOHx(const VolumeToDoseMeasure& MaxOHxValues); - void setMinOCx(const VolumeToDoseMeasure& MinOCxValues); + void setDx(const VolumeToDoseMeasureCollection& DxValues); + void setVx(const DoseToVolumeMeasureCollection& VxValues); + void setMOHx(const VolumeToDoseMeasureCollection& MOHxValues); + void setMOCx(const VolumeToDoseMeasureCollection& MOCxValues); + void setMaxOHx(const VolumeToDoseMeasureCollection& MaxOHxValues); + void setMinOCx(const VolumeToDoseMeasureCollection& MinOCxValues); void setReferenceDose(DoseTypeGy referenceDose); /*! @brief Get number of voxels in doseIterator, with sub-voxel accuracy. */ VoxelNumberType getNumberOfVoxels() const; /*! @brief Get the volume of the voxels in doseIterator (in cm3), with sub-voxel accuracy */ VolumeType getVolume() const; /*! @brief Get the reference dose for Vx computation */ DoseTypeGy getReferenceDose() const; /*! @brief Get the maximum of the current dose distribution. @return Return the maximum dose in Gy */ DoseStatisticType getMaximum() const; /*! @brief Get a vector of the the maximum dose VoxelGridIDs together with their dose value in Gy @exception InvalidDoseException if the vector has not been set (i.e. is empty) */ ResultListPointer getMaximumVoxelPositions() const; /*! @brief Get the minimum of the current dose distribution. @return Return the minimum dose in Gy */ DoseStatisticType getMinimum() const; /*! @brief Get a vector of the the minimum dose VoxelGridIDs together with their dose value in Gy @exception InvalidDoseException if the vector has not been set (i.e. is empty) */ ResultListPointer getMinimumVoxelPositions() const; /*! @brief Get the mean of the current dose distribution. @return Return the mean dose in Gy */ DoseStatisticType getMean() const; /*! @brief Get the standard deviation of the current dose distribution. @return Return the standard deviation in Gy */ DoseStatisticType getStdDeviation() const; /*! @brief Get the variance of of the current dose distribution. @return Return the variance in Gy */ DoseStatisticType getVariance() const; - VolumeToDoseMeasure getDx() const; - DoseToVolumeMeasure getVx() const; - VolumeToDoseMeasure getMOHx() const; - VolumeToDoseMeasure getMOCx() const; - VolumeToDoseMeasure getMaxOHx() const; - VolumeToDoseMeasure getMinOCx() const; + VolumeToDoseMeasureCollection getDx() const; + DoseToVolumeMeasureCollection getVx() const; + VolumeToDoseMeasureCollection getMOHx() const; + VolumeToDoseMeasureCollection getMOCx() const; + VolumeToDoseMeasureCollection getMaxOHx() const; + VolumeToDoseMeasureCollection getMinOCx() const; }; } } #endif diff --git a/code/algorithms/rttbDoseStatisticsCalculator.cpp b/code/algorithms/rttbDoseStatisticsCalculator.cpp index bf2b4f7..f076e6d 100644 --- a/code/algorithms/rttbDoseStatisticsCalculator.cpp +++ b/code/algorithms/rttbDoseStatisticsCalculator.cpp @@ -1,401 +1,401 @@ // ----------------------------------------------------------------------- // 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 "rttbDoseStatisticsCalculator.h" #include #include #include #include #include "rttbNullPointerException.h" #include "rttbInvalidDoseException.h" #include "rttbInvalidParameterException.h" -#include "rttbDxVolumeToDoseMeasureCalculator.h" -#include "rttbVxDoseToVolumeMeasureCalculator.h" -#include "rttbMOHxVolumeToDoseMeasureCalculator.h" -#include "rttbMOCxVolumeToDoseMeasureCalculator.h" -#include "rttbMaxOHxVolumeToDoseMeasureCalculator.h" -#include "rttbMinOCxVolumeToDoseMeasureCalculator.h" +#include "rttbDxVolumeToDoseMeasureCollectionCalculator.h" +#include "rttbVxDoseToVolumeMeasureCollectionCalculator.h" +#include "rttbMOHxVolumeToDoseMeasureCollectionCalculator.h" +#include "rttbMOCxVolumeToDoseMeasureCollectionCalculator.h" +#include "rttbMaxOHxVolumeToDoseMeasureCollectionCalculator.h" +#include "rttbMinOCxVolumeToDoseMeasureCollectionCalculator.h" #include namespace rttb { namespace algorithms { DoseStatisticsCalculator::DoseStatisticsCalculator(DoseIteratorPointer aDoseIterator) { if (aDoseIterator == NULL) { throw core::NullPointerException("DoseIterator must not be NULL"); } else { _doseIterator = aDoseIterator; } _simpleDoseStatisticsCalculated = false; _multiThreading = false; _mutex = ::boost::make_shared<::boost::shared_mutex>(); } DoseStatisticsCalculator::~DoseStatisticsCalculator() { } DoseStatisticsCalculator::DoseIteratorPointer DoseStatisticsCalculator::getDoseIterator() const { return _doseIterator; } DoseStatisticsCalculator::DoseStatisticsPointer DoseStatisticsCalculator::calculateDoseStatistics( bool computeComplexMeasures, unsigned int maxNumberMinimaPositions, unsigned int maxNumberMaximaPositions) { if (!_doseIterator) { throw core::NullPointerException("_doseIterator must not be NULL!"); } //"simple" dose statistics are mandatory calculateSimpleDoseStatistics(maxNumberMinimaPositions, maxNumberMaximaPositions); if (computeComplexMeasures) { //more complex dose statistics are optional with default maximum dose and default relative x values calculateComplexDoseStatistics(_statistics->getMaximum(), std::vector(), std::vector()); } return _statistics; } DoseStatisticsCalculator::DoseStatisticsPointer DoseStatisticsCalculator::calculateDoseStatistics( DoseTypeGy referenceDose, unsigned int maxNumberMinimaPositions, unsigned int maxNumberMaximaPositions) { if (!_doseIterator) { throw core::NullPointerException("_doseIterator must not be NULL!"); } if (referenceDose <= 0) { throw rttb::core::InvalidParameterException("Reference dose must be > 0 !"); } //simple dose statistics calculateSimpleDoseStatistics(maxNumberMinimaPositions, maxNumberMaximaPositions); //more complex dose statistics with given reference dose and default x values calculateComplexDoseStatistics(referenceDose, std::vector(), std::vector()); return _statistics; } DoseStatisticsCalculator::DoseStatisticsPointer DoseStatisticsCalculator::calculateDoseStatistics( const std::vector& precomputeDoseValues, const std::vector& precomputeVolumeValues, DoseTypeGy referenceDose, unsigned int maxNumberMinimaPositions, unsigned int maxNumberMaximaPositions) { if (!_doseIterator) { throw core::NullPointerException("_doseIterator must not be NULL!"); } //"simple" dose statistics calculateSimpleDoseStatistics(maxNumberMinimaPositions, maxNumberMaximaPositions); if (referenceDose <= 0) { //more complex dose statistics with default maximum dose and relative x values calculateComplexDoseStatistics(_statistics->getMaximum(), precomputeDoseValues, precomputeVolumeValues); } else { //more complex dose statistics with given reference dose and relative x values calculateComplexDoseStatistics(referenceDose, precomputeDoseValues, precomputeVolumeValues); } return _statistics; } void DoseStatisticsCalculator::calculateSimpleDoseStatistics(unsigned int maxNumberMinimaPositions, unsigned int maxNumberMaximaPositions) { _doseVector.clear(); _voxelProportionVector.clear(); std::multimap doseValueVSIndexMap; std::vector voxelProportionVectorTemp; DoseStatisticType maximumDose = 0; DoseStatisticType minimumDose = std::numeric_limits::max(); DoseStatisticType meanDose; DoseStatisticType stdDeviationDose; DoseTypeGy sum = 0; VolumeType numVoxels = 0.0; DoseTypeGy squareSum = 0; VolumeType volume = 0; _doseIterator->reset(); int i = 0; DoseTypeGy doseValue = 0; while (_doseIterator->isPositionValid()) { doseValue = _doseIterator->getCurrentDoseValue(); if (i == 0) { minimumDose = doseValue; volume = _doseIterator->getCurrentVoxelVolume(); } rttb::FractionType voxelProportion = _doseIterator->getCurrentRelevantVolumeFraction(); sum += doseValue * voxelProportion; numVoxels += voxelProportion; squareSum += doseValue * doseValue * voxelProportion; if (doseValue > maximumDose) { maximumDose = doseValue; } else if (doseValue < minimumDose) { minimumDose = doseValue; } voxelProportionVectorTemp.push_back(voxelProportion); doseValueVSIndexMap.insert(std::pair(doseValue, i)); i++; _doseIterator->next(); } if (numVoxels != 0) { meanDose = sum / numVoxels; //standard deviation is defined only for n>=2 if (numVoxels >= 2) { //uncorrected variance is calculated DoseStatisticType varianceDose = (squareSum / numVoxels - meanDose * meanDose); if (varianceDose < errorConstant) { stdDeviationDose = 0; } else { stdDeviationDose = pow(varianceDose, 0.5); } } else { stdDeviationDose = 0; } } //sort dose values and corresponding volume fractions in member variables for (auto it = doseValueVSIndexMap.begin(); it != doseValueVSIndexMap.end(); ++it) { _doseVector.push_back((float)(*it).first); _voxelProportionVector.push_back(voxelProportionVectorTemp.at((*it).second)); } volume *= numVoxels; _statistics = boost::make_shared(minimumDose, maximumDose, meanDose, stdDeviationDose, numVoxels, volume); _simpleDoseStatisticsCalculated = true; ResultListPointer minimumVoxelPositions = computeMinimumPositions(maxNumberMinimaPositions); ResultListPointer maximumVoxelPositions = computeMaximumPositions(maxNumberMaximaPositions); _statistics->setMinimumVoxelPositions(minimumVoxelPositions); _statistics->setMaximumVoxelPositions(maximumVoxelPositions); } void DoseStatisticsCalculator::calculateComplexDoseStatistics(DoseTypeGy referenceDose, const std::vector& precomputeDoseValues, const std::vector& precomputeVolumeValues) { if (!_simpleDoseStatisticsCalculated) { throw core::InvalidDoseException("simple DoseStatistics have to be computed in order to call calculateComplexDoseStatistics()"); } std::vector precomputeDoseValuesNonConst = precomputeDoseValues; std::vector precomputeVolumeValuesNonConst = precomputeVolumeValues; //set default values if (precomputeDoseValues.empty()) { std::vector defaultPrecomputeDoseValues = boost::assign::list_of(0.02)(0.05)(0.1)(0.9)( 0.95)(0.98); precomputeDoseValuesNonConst = defaultPrecomputeDoseValues; } if (precomputeVolumeValues.empty()) { std::vector defaultPrecomputeVolumeValues = boost::assign::list_of(0.02)(0.05)(0.1)(0.9)( 0.95)(0.98); precomputeVolumeValuesNonConst = defaultPrecomputeVolumeValues; } - VxDoseToVolumeMeasureCalculator Vx = VxDoseToVolumeMeasureCalculator(precomputeDoseValuesNonConst, referenceDose, _doseIterator, DoseToVolumeMeasure::Vx); + VxDoseToVolumeMeasureCollectionCalculator Vx(precomputeDoseValuesNonConst, referenceDose, _doseIterator, DoseToVolumeMeasureCollection::Vx); Vx.compute(); - DxVolumeToDoseMeasureCalculator Dx = DxVolumeToDoseMeasureCalculator(precomputeVolumeValuesNonConst, _statistics->getVolume(), - this->_doseVector, this->_voxelProportionVector, this->_doseIterator->getCurrentVoxelVolume(), _statistics->getMinimum(), VolumeToDoseMeasure::Dx); + DxVolumeToDoseMeasureCollectionCalculator Dx(precomputeVolumeValuesNonConst, _statistics->getVolume(), + this->_doseVector, this->_voxelProportionVector, this->_doseIterator->getCurrentVoxelVolume(), _statistics->getMinimum(), VolumeToDoseMeasureCollection::Dx); Dx.compute(); - MOHxVolumeToDoseMeasureCalculator MOHx = MOHxVolumeToDoseMeasureCalculator(precomputeVolumeValuesNonConst, _statistics->getVolume(), - this->_doseVector, this->_voxelProportionVector, this->_doseIterator->getCurrentVoxelVolume(), VolumeToDoseMeasure::MOHx); + MOHxVolumeToDoseMeasureCollectionCalculator MOHx(precomputeVolumeValuesNonConst, _statistics->getVolume(), + this->_doseVector, this->_voxelProportionVector, this->_doseIterator->getCurrentVoxelVolume(), VolumeToDoseMeasureCollection::MOHx); MOHx.compute(); - MOCxVolumeToDoseMeasureCalculator MOCx = MOCxVolumeToDoseMeasureCalculator(precomputeVolumeValuesNonConst, _statistics->getVolume(), - this->_doseVector, this->_voxelProportionVector, this->_doseIterator->getCurrentVoxelVolume(), VolumeToDoseMeasure::MOCx); + MOCxVolumeToDoseMeasureCollectionCalculator MOCx(precomputeVolumeValuesNonConst, _statistics->getVolume(), + this->_doseVector, this->_voxelProportionVector, this->_doseIterator->getCurrentVoxelVolume(), VolumeToDoseMeasureCollection::MOCx); MOCx.compute(); - MaxOHxVolumeToDoseMeasureCalculator MaxOHx = MaxOHxVolumeToDoseMeasureCalculator(precomputeVolumeValuesNonConst, _statistics->getVolume(), - this->_doseVector, this->_voxelProportionVector, this->_doseIterator->getCurrentVoxelVolume(), VolumeToDoseMeasure::MaxOHx); + MaxOHxVolumeToDoseMeasureCollectionCalculator MaxOHx(precomputeVolumeValuesNonConst, _statistics->getVolume(), + this->_doseVector, this->_voxelProportionVector, this->_doseIterator->getCurrentVoxelVolume(), VolumeToDoseMeasureCollection::MaxOHx); MaxOHx.compute(); - MinOCxVolumeToDoseMeasureCalculator MinOCx = MinOCxVolumeToDoseMeasureCalculator(precomputeVolumeValuesNonConst, _statistics->getVolume(), - this->_doseVector, this->_voxelProportionVector, this->_doseIterator->getCurrentVoxelVolume(), _statistics->getMinimum(), _statistics->getMaximum(), VolumeToDoseMeasure::MinOCx); + MinOCxVolumeToDoseMeasureCollectionCalculator MinOCx(precomputeVolumeValuesNonConst, _statistics->getVolume(), + this->_doseVector, this->_voxelProportionVector, this->_doseIterator->getCurrentVoxelVolume(), _statistics->getMinimum(), _statistics->getMaximum(), VolumeToDoseMeasureCollection::MinOCx); MinOCx.compute(); _statistics->setVx(Vx.getMeasure()); _statistics->setDx(Dx.getMeasure()); _statistics->setMOHx(MOHx.getMeasure()); _statistics->setMOCx(MOCx.getMeasure()); _statistics->setMaxOHx(MaxOHx.getMeasure()); _statistics->setMinOCx(MinOCx.getMeasure()); _statistics->setReferenceDose(referenceDose); } DoseStatisticsCalculator::ResultListPointer DoseStatisticsCalculator::computeMaximumPositions( unsigned int maxNumberMaxima) const { if (!_simpleDoseStatisticsCalculated) { throw core::InvalidDoseException("simple DoseStatistics have to be computed in order to call computeMaximumPositions()"); } ResultListPointer maxVoxelVector = boost::make_shared > >(); unsigned int count = 0; this->_doseIterator->reset(); DoseTypeGy doseValue = 0; while (_doseIterator->isPositionValid() && count < maxNumberMaxima) { doseValue = _doseIterator->getCurrentDoseValue(); if (doseValue == _statistics->getMaximum()) { VoxelGridID currentID = _doseIterator->getCurrentVoxelGridID(); std::pair voxel(doseValue, currentID); maxVoxelVector->push_back(voxel); count++; } _doseIterator->next(); } return maxVoxelVector; } DoseStatisticsCalculator::ResultListPointer DoseStatisticsCalculator::computeMinimumPositions( unsigned int maxNumberMinima) const { if (!_simpleDoseStatisticsCalculated) { throw core::InvalidDoseException("simple DoseStatistics have to be computed in order to call computeMinimumPositions()"); } ResultListPointer minVoxelVector = boost::make_shared > >(); /*! @todo: Architecture Annotation: Finding the positions for the minimum only once reduces computation time, but will require sensible use by the programmers. To be save the output vector minVoxelVector will be always cleared here to garantee that no false values are presented. This change may be revoced to increase computation speed later on (only compute if(minVoxelVector->size()==0)). */ unsigned int count = 0; this->_doseIterator->reset(); DoseTypeGy doseValue = 0; while (_doseIterator->isPositionValid() && count < maxNumberMinima) { doseValue = _doseIterator->getCurrentDoseValue(); if (doseValue == _statistics->getMinimum()) { VoxelGridID currentID = _doseIterator->getCurrentVoxelGridID(); std::pair voxel(doseValue, currentID); minVoxelVector->push_back(voxel); count++; } _doseIterator->next(); } return minVoxelVector; } void DoseStatisticsCalculator::setMultiThreading(const bool choice) { _multiThreading = choice; } }//end namespace algorithms }//end namespace rttb diff --git a/code/algorithms/rttbDoseToVolumeMeasure.cpp b/code/algorithms/rttbDoseToVolumeMeasure.cpp deleted file mode 100644 index b4b9165..0000000 --- a/code/algorithms/rttbDoseToVolumeMeasure.cpp +++ /dev/null @@ -1,70 +0,0 @@ -#include "rttbDoseToVolumeMeasure.h" -#include "rttbInvalidParameterException.h" -#include "rttbDataNotAvailableException.h" - -namespace rttb -{ - - namespace algorithms - { - DoseToVolumeMeasure::DoseToVolumeMeasure(complexStatistics name, DoseTypeGy referenceDose) : - name(name), values(std::map()), _referenceDose(referenceDose) {} - - void DoseToVolumeMeasure::setReferenceDose(DoseTypeGy referenceDose) - { - this->_referenceDose = referenceDose; - } - - void DoseToVolumeMeasure::insertValue(DoseTypeGy dose, VolumeType volume) - { - this->values.insert(std::pair(dose, volume)); - } - - VolumeType DoseToVolumeMeasure::getValue(DoseTypeGy xVolumeAbsolute) const - { - VolumeType dummy; - return getSpecificValue(values, xVolumeAbsolute, false, dummy); - } - - VolumeType DoseToVolumeMeasure::getValue(DoseTypeGy xDoseAbsolute, bool findNearestValue, DoseTypeGy & nearestXDose) const - { - return getSpecificValue(values, xDoseAbsolute, findNearestValue, nearestXDose); - } - - VolumeType DoseToVolumeMeasure::getValueRelative(DoseTypeGy xDoseRelative) const - { - if (_referenceDose != -1 && xDoseRelative >= 0 && xDoseRelative <= 1) { - DoseTypeGy xDoseAbsolute = xDoseRelative * _referenceDose; - DoseTypeGy dummy; - return getSpecificValue(values, xDoseAbsolute, false, dummy); - } - else { - throw rttb::core::InvalidParameterException("Reference dose must be > 0 and 0 <= relative Dose <= 1"); - } - } - - VolumeType DoseToVolumeMeasure::getValueRelative(DoseTypeGy xDoseRelative, bool findNearestValue, DoseTypeGy & nearestXDose) const - { - if (_referenceDose != -1 && xDoseRelative >= 0 && xDoseRelative <= 1) { - DoseTypeGy xDoseAbsolute = xDoseRelative * _referenceDose; - return getSpecificValue(values, xDoseAbsolute, findNearestValue, nearestXDose); - } - else { - throw rttb::core::InvalidParameterException("Reference dose must be > 0 and 0 <= relative Dose <= 1"); - } - } - - DoseToVolumeMeasure::DoseToVolumeFunctionType DoseToVolumeMeasure::getAllValues() const - { - return this->values; - } - - bool operator==(const DoseToVolumeMeasure& volumeToDoseMesure,const DoseToVolumeMeasure& otherVolumeToDoseMesure) - { - if (volumeToDoseMesure.getName() == otherVolumeToDoseMesure.getName() && volumeToDoseMesure.getAllValues() == otherVolumeToDoseMesure.getAllValues()) { - return true; - } - return false; - } - } -} diff --git a/code/algorithms/rttbDoseToVolumeMeasureCalculator.cpp b/code/algorithms/rttbDoseToVolumeMeasureCalculator.cpp deleted file mode 100644 index 972a4a9..0000000 --- a/code/algorithms/rttbDoseToVolumeMeasureCalculator.cpp +++ /dev/null @@ -1,49 +0,0 @@ -#include "rttbDoseToVolumeMeasureCalculator.h" -#include -//#include - -namespace rttb -{ - - namespace algorithms - { - DoseToVolumeMeasureCalculator::DoseToVolumeMeasureCalculator(const std::vector& precomputeDoseValues, const DoseTypeGy& referenceDose, - const core::DoseIteratorInterface::DoseIteratorPointer doseIterator, DoseToVolumeMeasure::complexStatistics name) : - measure(DoseToVolumeMeasure(name)), _precomputeDoseValues(precomputeDoseValues), - _referenceDose(referenceDose), _doseIterator(doseIterator) {} - - void DoseToVolumeMeasureCalculator::compute() - { - std::vector threads; - - for (size_t i = 0; i < _precomputeDoseValues.size(); ++i) - { - double xAbsolute = _precomputeDoseValues.at(i) * _referenceDose; - if (false)//_multiThreading) - { - threads.push_back(boost::thread(&DoseToVolumeMeasureCalculator::insertIntoMeasure, this , xAbsolute, computeSpecificValue(xAbsolute))); - } - else - { - - insertIntoMeasure(xAbsolute, this->computeSpecificValue(xAbsolute)); - } - } - - for (unsigned int i = 0; i()), _referenceDose(referenceDose) {} + + void DoseToVolumeMeasureCollection::setReferenceDose(DoseTypeGy referenceDose) + { + this->_referenceDose = referenceDose; + } + + void DoseToVolumeMeasureCollection::insertValue(DoseTypeGy dose, VolumeType volume) + { + this->values.insert(std::pair(dose, volume)); + } + + VolumeType DoseToVolumeMeasureCollection::getValue(DoseTypeGy xVolumeAbsolute) const + { + VolumeType dummy; + return getSpecificValue(values, xVolumeAbsolute, false, dummy); + } + + VolumeType DoseToVolumeMeasureCollection::getValue(DoseTypeGy xDoseAbsolute, bool findNearestValue, DoseTypeGy & nearestXDose) const + { + return getSpecificValue(values, xDoseAbsolute, findNearestValue, nearestXDose); + } + + VolumeType DoseToVolumeMeasureCollection::getValueRelative(DoseTypeGy xDoseRelative) const + { + if (_referenceDose != -1 && xDoseRelative >= 0 && xDoseRelative <= 1) { + DoseTypeGy xDoseAbsolute = xDoseRelative * _referenceDose; + DoseTypeGy dummy; + return getSpecificValue(values, xDoseAbsolute, false, dummy); + } + else { + throw rttb::core::InvalidParameterException("Reference dose must be > 0 and 0 <= relative Dose <= 1"); + } + } + + VolumeType DoseToVolumeMeasureCollection::getValueRelative(DoseTypeGy xDoseRelative, bool findNearestValue, DoseTypeGy & nearestXDose) const + { + if (_referenceDose != -1 && xDoseRelative >= 0 && xDoseRelative <= 1) { + DoseTypeGy xDoseAbsolute = xDoseRelative * _referenceDose; + return getSpecificValue(values, xDoseAbsolute, findNearestValue, nearestXDose); + } + else { + throw rttb::core::InvalidParameterException("Reference dose must be > 0 and 0 <= relative Dose <= 1"); + } + } + + DoseToVolumeMeasureCollection::DoseToVolumeFunctionType DoseToVolumeMeasureCollection::getAllValues() const + { + return this->values; + } + + bool operator==(const DoseToVolumeMeasureCollection& volumeToDoseMesureCollection, const DoseToVolumeMeasureCollection& otherVolumeToDoseMesureCollection) + { + if (volumeToDoseMesureCollection.getName() == otherVolumeToDoseMesureCollection.getName() && volumeToDoseMesureCollection.getAllValues() == otherVolumeToDoseMesureCollection.getAllValues()) { + return true; + } + return false; + } + } +} diff --git a/code/algorithms/rttbDoseToVolumeMeasure.h b/code/algorithms/rttbDoseToVolumeMeasureCollection.h similarity index 80% rename from code/algorithms/rttbDoseToVolumeMeasure.h rename to code/algorithms/rttbDoseToVolumeMeasureCollection.h index b113363..ede9ab8 100644 --- a/code/algorithms/rttbDoseToVolumeMeasure.h +++ b/code/algorithms/rttbDoseToVolumeMeasureCollection.h @@ -1,65 +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: 1674 $ (last changed revision) // @date $Date: 2017-01-27 10:34:46 +0100 (Fr, 27 Jan 2017) $ (last change date) // @author $Author: hentsch $ (last changed by) */ -#ifndef __DOSE_TO_VOLUME_MEASURE_H -#define __DOSE_TO_VOLUME_MEASURE_H +#ifndef __DOSE_TO_VOLUME_MEASURE_COLLECTION_H +#define __DOSE_TO_VOLUME_MEASURE_COLLECTION_H -#include "rttbMeasureInterface.h" +#include "rttbMeasureCollection.h" namespace rttb { namespace algorithms { - class RTTBAlgorithms_EXPORT DoseToVolumeMeasure : public MeasureInterface { + class RTTBAlgorithms_EXPORT DoseToVolumeMeasureCollection : public MeasureCollection { public: typedef std::map DoseToVolumeFunctionType; private: complexStatistics name; DoseTypeGy _referenceDose; DoseToVolumeFunctionType values; public: - DoseToVolumeMeasure(complexStatistics name, DoseTypeGy referenceDose = -1); + DoseToVolumeMeasureCollection(complexStatistics name, DoseTypeGy referenceDose = -1); void setReferenceDose(DoseTypeGy referenceDose); void insertValue(DoseTypeGy dose, VolumeType volume); /*! @brief Gets the volume irradiated with a dose >= x, depending on the complexStatistics name. @return Return absolute volume in absolute cm^3. @exception NoDataException if the Vx values have not been set (i.e. the vector is empty) @excon NoDataException if the requested Dose is not in the vector */ VolumeType getValue(DoseTypeGy xVolumeAbsolute) const; VolumeType getValue(DoseTypeGy xVolumeAbsolute, bool findNearestValue, DoseTypeGy& nearestXDose) const; VolumeType getValueRelative(DoseTypeGy xDoseRelative) const; VolumeType getValueRelative(DoseTypeGy xDoseRelative, bool findNearestValue, DoseTypeGy& nearestXDose) const; DoseToVolumeFunctionType getAllValues() const; - friend bool operator==(const DoseToVolumeMeasure& volumeToDoseMesure, const DoseToVolumeMeasure& otherVolumeToDoseMesure); + friend bool operator==(const DoseToVolumeMeasureCollection& volumeToDoseMesureCollection, const DoseToVolumeMeasureCollection& otherVolumeToDoseMesureCollection); }; } } #endif diff --git a/code/algorithms/rttbDoseToVolumeMeasureCollectionCalculator.cpp b/code/algorithms/rttbDoseToVolumeMeasureCollectionCalculator.cpp new file mode 100644 index 0000000..9a6926b --- /dev/null +++ b/code/algorithms/rttbDoseToVolumeMeasureCollectionCalculator.cpp @@ -0,0 +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: 1674 $ (last changed revision) +// @date $Date: 2017-01-27 10:34:46 +0100 (Fr, 27 Jan 2017) $ (last change date) +// @author $Author: hentsch $ (last changed by) +*/ + +#include "rttbDoseToVolumeMeasureCollectionCalculator.h" +#include +//#include + +namespace rttb +{ + + namespace algorithms + { + DoseToVolumeMeasureCollectionCalculator::DoseToVolumeMeasureCollectionCalculator(const std::vector& precomputeDoseValues, const DoseTypeGy& referenceDose, + const core::DoseIteratorInterface::DoseIteratorPointer doseIterator, DoseToVolumeMeasureCollection::complexStatistics name) : + measure(DoseToVolumeMeasureCollection(name)), _precomputeDoseValues(precomputeDoseValues), + _referenceDose(referenceDose), _doseIterator(doseIterator) {} + + void DoseToVolumeMeasureCollectionCalculator::compute() + { + std::vector threads; + + for (size_t i = 0; i < _precomputeDoseValues.size(); ++i) + { + double xAbsolute = _precomputeDoseValues.at(i) * _referenceDose; + if (false)//_multiThreading) + { + threads.push_back(boost::thread(&DoseToVolumeMeasureCollectionCalculator::insertIntoMeasureCollection, this , xAbsolute, computeSpecificValue(xAbsolute))); + } + else + { + + insertIntoMeasureCollection(xAbsolute, this->computeSpecificValue(xAbsolute)); + } + } + + for (unsigned int i = 0; i #include #include "rttbBaseType.h" #include "RTTBAlgorithmsExports.h" -#include "rttbDoseToVolumeMeasure.h" +#include "rttbDoseToVolumeMeasureCollection.h" #include "rttbDoseIteratorInterface.h" namespace rttb { namespace algorithms { - class RTTBAlgorithms_EXPORT DoseToVolumeMeasureCalculator { + class RTTBAlgorithms_EXPORT DoseToVolumeMeasureCollectionCalculator { public: typedef std::map VolumeToDoseFunctionType; protected: core::DoseIteratorInterface::DoseIteratorPointer _doseIterator; private: DoseTypeGy _referenceDose; - DoseToVolumeMeasure measure; + DoseToVolumeMeasureCollection measure; std::vector _precomputeDoseValues; public: /*! @brief Computes the measure. Algorithm for the specific complex Statistic has to be implemented in the corresponding subclass. */ void compute(); - DoseToVolumeMeasure getMeasure(); + DoseToVolumeMeasureCollection getMeasure(); protected: - DoseToVolumeMeasureCalculator(const std::vector& precomputeDoseValues, - const DoseTypeGy& referenceDose, const core::DoseIteratorInterface::DoseIteratorPointer doseIterator, DoseToVolumeMeasure::complexStatistics name); + DoseToVolumeMeasureCollectionCalculator(const std::vector& precomputeDoseValues, + const DoseTypeGy& referenceDose, const core::DoseIteratorInterface::DoseIteratorPointer doseIterator, DoseToVolumeMeasureCollection::complexStatistics name); - void insertIntoMeasure(DoseTypeGy xAbsolute, VolumeType resultVolume); + void insertIntoMeasureCollection(DoseTypeGy xAbsolute, VolumeType resultVolume); virtual VolumeType computeSpecificValue(double xAbsolute) const = 0; }; } } #endif diff --git a/code/algorithms/rttbDxVolumeToDoseMeasureCalculator.cpp b/code/algorithms/rttbDxVolumeToDoseMeasureCalculator.cpp deleted file mode 100644 index 6706926..0000000 --- a/code/algorithms/rttbDxVolumeToDoseMeasureCalculator.cpp +++ /dev/null @@ -1,38 +0,0 @@ -#include "rttbDxVolumeToDoseMeasureCalculator.h" -namespace rttb -{ - - namespace algorithms - { - DxVolumeToDoseMeasureCalculator::DxVolumeToDoseMeasureCalculator(const std::vector& precomputeVolumeValues, - const VolumeType volume, const std::vector& doseVector, const std::vector& voxelProportionVector, - const DoseVoxelVolumeType currentVoxelVolume, const DoseStatisticType minimum, VolumeToDoseMeasure::complexStatistics name) : VolumeToDoseMeasureCalculator(precomputeVolumeValues, volume, - doseVector, voxelProportionVector, currentVoxelVolume, name), _minimum(minimum) {} - - DoseTypeGy DxVolumeToDoseMeasureCalculator::computeSpecificValue(double xAbsolute) const - { - double noOfVoxel = xAbsolute / _currentVoxelVolume; - DoseTypeGy resultDose = 0; - - double countVoxels = 0; - bool voxelOverflow = false; - for (auto i = _doseVector.size() - 1; i != -1; i--) - { - countVoxels += _voxelProportionVector.at(i); - - if (countVoxels >= noOfVoxel) - { - voxelOverflow = true; - resultDose = _doseVector.at(i); - break; - } - } - - if (!voxelOverflow) - { - resultDose = _minimum; - } - return resultDose; - } - } -} \ No newline at end of file diff --git a/code/algorithms/rttbDxVolumeToDoseMeasureCollectionCalculator.cpp b/code/algorithms/rttbDxVolumeToDoseMeasureCollectionCalculator.cpp new file mode 100644 index 0000000..7cbe29a --- /dev/null +++ b/code/algorithms/rttbDxVolumeToDoseMeasureCollectionCalculator.cpp @@ -0,0 +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: 1674 $ (last changed revision) +// @date $Date: 2017-01-27 10:34:46 +0100 (Fr, 27 Jan 2017) $ (last change date) +// @author $Author: hentsch $ (last changed by) +*/ + +#include "rttbDxVolumeToDoseMeasureCollectionCalculator.h" + +namespace rttb +{ + + namespace algorithms + { + DxVolumeToDoseMeasureCollectionCalculator::DxVolumeToDoseMeasureCollectionCalculator(const std::vector& precomputeVolumeValues, + const VolumeType volume, const std::vector& doseVector, const std::vector& voxelProportionVector, + const DoseVoxelVolumeType currentVoxelVolume, const DoseStatisticType minimum, VolumeToDoseMeasureCollection::complexStatistics name) : + VolumeToDoseMeasureCollectionCalculator(precomputeVolumeValues, volume, doseVector, voxelProportionVector, currentVoxelVolume, name), _minimum(minimum) {} + + DoseTypeGy DxVolumeToDoseMeasureCollectionCalculator::computeSpecificValue(double xAbsolute) const + { + double noOfVoxel = xAbsolute / _currentVoxelVolume; + DoseTypeGy resultDose = 0; + + double countVoxels = 0; + bool voxelOverflow = false; + for (auto i = _doseVector.size() - 1; i != -1; i--) + { + countVoxels += _voxelProportionVector.at(i); + + if (countVoxels >= noOfVoxel) + { + voxelOverflow = true; + resultDose = _doseVector.at(i); + break; + } + } + + if (!voxelOverflow) + { + resultDose = _minimum; + } + return resultDose; + } + } +} \ No newline at end of file diff --git a/code/algorithms/rttbDxVolumeToDoseMeasureCalculator.h b/code/algorithms/rttbDxVolumeToDoseMeasureCollectionCalculator.h similarity index 71% rename from code/algorithms/rttbDxVolumeToDoseMeasureCalculator.h rename to code/algorithms/rttbDxVolumeToDoseMeasureCollectionCalculator.h index 8816781..36efc5e 100644 --- a/code/algorithms/rttbDxVolumeToDoseMeasureCalculator.h +++ b/code/algorithms/rttbDxVolumeToDoseMeasureCollectionCalculator.h @@ -1,49 +1,49 @@ // ----------------------------------------------------------------------- // 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: 1674 $ (last changed revision) // @date $Date: 2017-01-27 10:34:46 +0100 (Fr, 27 Jan 2017) $ (last change date) // @author $Author: hentsch $ (last changed by) */ -#ifndef __DX_VOLUME_TO_DOSE_MEASURE_CALCULATOR_H -#define __DX_VOLUME_TO_DOSE_MEASURE_CALCULATOR_H +#ifndef __DX_VOLUME_TO_DOSE_MEASURE_COLLECTION_CALCULATOR_H +#define __DX_VOLUME_TO_DOSE_MEASURE_COLLECTION_CALCULATOR_H -#include "rttbVolumeToDoseMeasureCalculator.h" +#include "rttbVolumeToDoseMeasureCollectionCalculator.h" namespace rttb { namespace algorithms { - class RTTBAlgorithms_EXPORT DxVolumeToDoseMeasureCalculator: public VolumeToDoseMeasureCalculator { + class RTTBAlgorithms_EXPORT DxVolumeToDoseMeasureCollectionCalculator: public VolumeToDoseMeasureCollectionCalculator { private: DoseStatisticType _minimum; public: - DxVolumeToDoseMeasureCalculator(const std::vector& precomputeVolumeValues, const VolumeType volume, + DxVolumeToDoseMeasureCollectionCalculator(const std::vector& precomputeVolumeValues, const VolumeType volume, const std::vector& doseVector, const std::vector& voxelProportionVector, - const DoseVoxelVolumeType currentVoxelVolume, const DoseStatisticType minimum, VolumeToDoseMeasure::complexStatistics name); + const DoseVoxelVolumeType currentVoxelVolume, const DoseStatisticType minimum, VolumeToDoseMeasureCollection::complexStatistics name); protected: DoseTypeGy computeSpecificValue(double xAbsolute) const override; }; } } #endif diff --git a/code/algorithms/rttbMOCxVolumeToDoseMeasureCalculator.cpp b/code/algorithms/rttbMOCxVolumeToDoseMeasureCalculator.cpp deleted file mode 100644 index e5faa1f..0000000 --- a/code/algorithms/rttbMOCxVolumeToDoseMeasureCalculator.cpp +++ /dev/null @@ -1,41 +0,0 @@ -#include "rttbMOCxVolumeToDoseMeasureCalculator.h" -namespace rttb -{ - - namespace algorithms - { - MOCxVolumeToDoseMeasureCalculator::MOCxVolumeToDoseMeasureCalculator(const std::vector& precomputeVolumeValues, - const VolumeType volume, const std::vector& doseVector, const std::vector& voxelProportionVector, - const DoseVoxelVolumeType currentVoxelVolume, VolumeToDoseMeasure::complexStatistics name) : VolumeToDoseMeasureCalculator(precomputeVolumeValues, volume, - doseVector, voxelProportionVector, currentVoxelVolume, name) {} - - DoseTypeGy MOCxVolumeToDoseMeasureCalculator::computeSpecificValue(double xAbsolute) const - { - double noOfVoxel = xAbsolute / _currentVoxelVolume; - if (noOfVoxel == 0) - { - return 0; - } - else - { - double countVoxels = 0; - double sum = 0; - std::vector::const_iterator it = _doseVector.begin(); - std::vector::const_iterator itD = _voxelProportionVector.begin(); - - for (; it != _doseVector.end(); ++it, ++itD) - { - double voxelProportion = *itD; - countVoxels += voxelProportion; - sum += (*it) * voxelProportion; - - if (countVoxels >= noOfVoxel) - { - break; - } - } - return (DoseTypeGy)(sum / noOfVoxel); - } - } - } -} \ No newline at end of file diff --git a/code/algorithms/rttbMOCxVolumeToDoseMeasureCollectionCalculator.cpp b/code/algorithms/rttbMOCxVolumeToDoseMeasureCollectionCalculator.cpp new file mode 100644 index 0000000..e102f65 --- /dev/null +++ b/code/algorithms/rttbMOCxVolumeToDoseMeasureCollectionCalculator.cpp @@ -0,0 +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: 1674 $ (last changed revision) +// @date $Date: 2017-01-27 10:34:46 +0100 (Fr, 27 Jan 2017) $ (last change date) +// @author $Author: hentsch $ (last changed by) +*/ + +#include "rttbMOCxVolumeToDoseMeasureCollectionCalculator.h" + +namespace rttb +{ + + namespace algorithms + { + MOCxVolumeToDoseMeasureCollectionCalculator::MOCxVolumeToDoseMeasureCollectionCalculator(const std::vector& precomputeVolumeValues, + const VolumeType volume, const std::vector& doseVector, const std::vector& voxelProportionVector, + const DoseVoxelVolumeType currentVoxelVolume, VolumeToDoseMeasureCollection::complexStatistics name) : VolumeToDoseMeasureCollectionCalculator(precomputeVolumeValues, volume, + doseVector, voxelProportionVector, currentVoxelVolume, name) {} + + DoseTypeGy MOCxVolumeToDoseMeasureCollectionCalculator::computeSpecificValue(double xAbsolute) const + { + double noOfVoxel = xAbsolute / _currentVoxelVolume; + if (noOfVoxel == 0) + { + return 0; + } + else + { + double countVoxels = 0; + double sum = 0; + std::vector::const_iterator it = _doseVector.begin(); + std::vector::const_iterator itD = _voxelProportionVector.begin(); + + for (; it != _doseVector.end(); ++it, ++itD) + { + double voxelProportion = *itD; + countVoxels += voxelProportion; + sum += (*it) * voxelProportion; + + if (countVoxels >= noOfVoxel) + { + break; + } + } + return (DoseTypeGy)(sum / noOfVoxel); + } + } + } +} \ No newline at end of file diff --git a/code/algorithms/rttbMOCxVolumeToDoseMeasureCalculator.h b/code/algorithms/rttbMOCxVolumeToDoseMeasureCollectionCalculator.h similarity index 71% rename from code/algorithms/rttbMOCxVolumeToDoseMeasureCalculator.h rename to code/algorithms/rttbMOCxVolumeToDoseMeasureCollectionCalculator.h index 2a43c51..cad3f35 100644 --- a/code/algorithms/rttbMOCxVolumeToDoseMeasureCalculator.h +++ b/code/algorithms/rttbMOCxVolumeToDoseMeasureCollectionCalculator.h @@ -1,46 +1,46 @@ // ----------------------------------------------------------------------- // 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: 1674 $ (last changed revision) // @date $Date: 2017-01-27 10:34:46 +0100 (Fr, 27 Jan 2017) $ (last change date) // @author $Author: hentsch $ (last changed by) */ -#ifndef __MOCX_VOLUME_TO_DOSE_MEASURE_CALCULATOR_H -#define __MOCX_VOLUME_TO_DOSE_MEASURE_CALCULATOR_H +#ifndef __MOCX_VOLUME_TO_DOSE_MEASURE_COLLECTION_CALCULATOR_H +#define __MOCX_VOLUME_TO_DOSE_MEASURE_COLLECTION_CALCULATOR_H -#include "rttbVolumeToDoseMeasureCalculator.h" +#include "rttbVolumeToDoseMeasureCollectionCalculator.h" namespace rttb { namespace algorithms { - class RTTBAlgorithms_EXPORT MOCxVolumeToDoseMeasureCalculator : public VolumeToDoseMeasureCalculator { + class RTTBAlgorithms_EXPORT MOCxVolumeToDoseMeasureCollectionCalculator : public VolumeToDoseMeasureCollectionCalculator { public: - MOCxVolumeToDoseMeasureCalculator(const std::vector& precomputeVolumeValues, const VolumeType volume, + MOCxVolumeToDoseMeasureCollectionCalculator(const std::vector& precomputeVolumeValues, const VolumeType volume, const std::vector& doseVector, const std::vector& voxelProportionVector, - const DoseVoxelVolumeType currentVoxelVolume, VolumeToDoseMeasure::complexStatistics name); + const DoseVoxelVolumeType currentVoxelVolume, VolumeToDoseMeasureCollection::complexStatistics name); protected: DoseTypeGy computeSpecificValue(double xAbsolute) const override; }; } } #endif diff --git a/code/algorithms/rttbMOHxVolumeToDoseMeasureCalculator.cpp b/code/algorithms/rttbMOHxVolumeToDoseMeasureCalculator.cpp deleted file mode 100644 index 7eb677b..0000000 --- a/code/algorithms/rttbMOHxVolumeToDoseMeasureCalculator.cpp +++ /dev/null @@ -1,40 +0,0 @@ -#include "rttbMOHxVolumeToDoseMeasureCalculator.h" -namespace rttb -{ - - namespace algorithms - { - MOHxVolumeToDoseMeasureCalculator::MOHxVolumeToDoseMeasureCalculator(const std::vector& precomputeVolumeValues, - const VolumeType volume, const std::vector& doseVector, const std::vector& voxelProportionVector, - const DoseVoxelVolumeType currentVoxelVolume, VolumeToDoseMeasure::complexStatistics name) : VolumeToDoseMeasureCalculator(precomputeVolumeValues, volume, - doseVector, voxelProportionVector, currentVoxelVolume, name) {} - - DoseTypeGy MOHxVolumeToDoseMeasureCalculator::computeSpecificValue(double xAbsolute) const - { - double noOfVoxel = xAbsolute / _currentVoxelVolume; - - if (noOfVoxel == 0) - { - return 0; - } - else - { - double countVoxels = 0; - double sum = 0; - - for (auto i = _doseVector.size() - 1; i != -1; i--) - { - double voxelProportion = _voxelProportionVector.at(i); - countVoxels += voxelProportion; - sum += _doseVector.at(i) * voxelProportion; - - if (countVoxels >= noOfVoxel) - { - break; - } - } - return (DoseTypeGy)(sum / noOfVoxel); - } - } - } -} \ No newline at end of file diff --git a/code/algorithms/rttbMOHxVolumeToDoseMeasureCollectionCalculator.cpp b/code/algorithms/rttbMOHxVolumeToDoseMeasureCollectionCalculator.cpp new file mode 100644 index 0000000..8264fad --- /dev/null +++ b/code/algorithms/rttbMOHxVolumeToDoseMeasureCollectionCalculator.cpp @@ -0,0 +1,62 @@ +// ----------------------------------------------------------------------- +// 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: 1674 $ (last changed revision) +// @date $Date: 2017-01-27 10:34:46 +0100 (Fr, 27 Jan 2017) $ (last change date) +// @author $Author: hentsch $ (last changed by) +*/ + +#include "rttbMOHxVolumeToDoseMeasureCollectionCalculator.h" + +namespace rttb +{ + + namespace algorithms + { + MOHxVolumeToDoseMeasureCollectionCalculator::MOHxVolumeToDoseMeasureCollectionCalculator(const std::vector& precomputeVolumeValues, + const VolumeType volume, const std::vector& doseVector, const std::vector& voxelProportionVector, + const DoseVoxelVolumeType currentVoxelVolume, VolumeToDoseMeasureCollection::complexStatistics name) : VolumeToDoseMeasureCollectionCalculator(precomputeVolumeValues, volume, + doseVector, voxelProportionVector, currentVoxelVolume, name) {} + + DoseTypeGy MOHxVolumeToDoseMeasureCollectionCalculator::computeSpecificValue(double xAbsolute) const + { + double noOfVoxel = xAbsolute / _currentVoxelVolume; + + if (noOfVoxel == 0) + { + return 0; + } + else + { + double countVoxels = 0; + double sum = 0; + + for (auto i = _doseVector.size() - 1; i != -1; i--) + { + double voxelProportion = _voxelProportionVector.at(i); + countVoxels += voxelProportion; + sum += _doseVector.at(i) * voxelProportion; + + if (countVoxels >= noOfVoxel) + { + break; + } + } + return (DoseTypeGy)(sum / noOfVoxel); + } + } + } +} \ No newline at end of file diff --git a/code/algorithms/rttbMOHxVolumeToDoseMeasureCalculator.h b/code/algorithms/rttbMOHxVolumeToDoseMeasureCollectionCalculator.h similarity index 72% rename from code/algorithms/rttbMOHxVolumeToDoseMeasureCalculator.h rename to code/algorithms/rttbMOHxVolumeToDoseMeasureCollectionCalculator.h index d1b2431..c5203e8 100644 --- a/code/algorithms/rttbMOHxVolumeToDoseMeasureCalculator.h +++ b/code/algorithms/rttbMOHxVolumeToDoseMeasureCollectionCalculator.h @@ -1,49 +1,49 @@ // ----------------------------------------------------------------------- // 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: 1674 $ (last changed revision) // @date $Date: 2017-01-27 10:34:46 +0100 (Fr, 27 Jan 2017) $ (last change date) // @author $Author: hentsch $ (last changed by) */ -#ifndef __MOHX_VOLUME_TO_DOSE_MEASURE_CALCULATOR_H -#define __MOHX_VOLUME_TO_DOSE_MEASURE_CALCULATOR_H +#ifndef __MOHX_VOLUME_TO_DOSE_MEASURE_COLLECTION_CALCULATOR_H +#define __MOHX_VOLUME_TO_DOSE_MEASURE_COLLECTION_CALCULATOR_H -#include "rttbVolumeToDoseMeasureCalculator.h" +#include "rttbVolumeToDoseMeasureCollectionCalculator.h" namespace rttb { namespace algorithms { - class RTTBAlgorithms_EXPORT MOHxVolumeToDoseMeasureCalculator : public VolumeToDoseMeasureCalculator { + class RTTBAlgorithms_EXPORT MOHxVolumeToDoseMeasureCollectionCalculator : public VolumeToDoseMeasureCollectionCalculator { private: DoseStatisticType _minimum; public: - MOHxVolumeToDoseMeasureCalculator(const std::vector& precomputeVolumeValues, const VolumeType volume, + MOHxVolumeToDoseMeasureCollectionCalculator(const std::vector& precomputeVolumeValues, const VolumeType volume, const std::vector& doseVector, const std::vector& voxelProportionVector, - const DoseVoxelVolumeType currentVoxelVolume, VolumeToDoseMeasure::complexStatistics name); + const DoseVoxelVolumeType currentVoxelVolume, VolumeToDoseMeasureCollection::complexStatistics name); protected: DoseTypeGy computeSpecificValue(double xAbsolute) const override; }; } } #endif diff --git a/code/algorithms/rttbMaxOHxVolumeToDoseMeasureCalculator.cpp b/code/algorithms/rttbMaxOHxVolumeToDoseMeasureCalculator.cpp deleted file mode 100644 index 0ff0b5f..0000000 --- a/code/algorithms/rttbMaxOHxVolumeToDoseMeasureCalculator.cpp +++ /dev/null @@ -1,35 +0,0 @@ -#include "rttbMaxOHxVolumeToDoseMeasureCalculator.h" -namespace rttb -{ - - namespace algorithms - { - MaxOHxVolumeToDoseMeasureCalculator::MaxOHxVolumeToDoseMeasureCalculator(const std::vector& precomputeVolumeValues, - const VolumeType volume, const std::vector& doseVector, const std::vector& voxelProportionVector, - const DoseVoxelVolumeType currentVoxelVolume, VolumeToDoseMeasure::complexStatistics name) : VolumeToDoseMeasureCalculator(precomputeVolumeValues, volume, - doseVector, voxelProportionVector, currentVoxelVolume, name) {} - - DoseTypeGy MaxOHxVolumeToDoseMeasureCalculator::computeSpecificValue(double xAbsolute) const - { - double noOfVoxel = xAbsolute / _currentVoxelVolume; - DoseTypeGy resultDose = 0; - - double countVoxels = 0; - for (auto i = _doseVector.size() - 1; i != -1; i--) - { - countVoxels += _voxelProportionVector.at(i); - - if (countVoxels >= noOfVoxel) - { - if (i > 0) - { - resultDose = _doseVector.at(i - 1); - } - break; - } - } - - return resultDose; - } - } -} \ No newline at end of file diff --git a/code/algorithms/rttbMaxOHxVolumeToDoseMeasureCollectionCalculator.cpp b/code/algorithms/rttbMaxOHxVolumeToDoseMeasureCollectionCalculator.cpp new file mode 100644 index 0000000..e08afb4 --- /dev/null +++ b/code/algorithms/rttbMaxOHxVolumeToDoseMeasureCollectionCalculator.cpp @@ -0,0 +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: 1674 $ (last changed revision) +// @date $Date: 2017-01-27 10:34:46 +0100 (Fr, 27 Jan 2017) $ (last change date) +// @author $Author: hentsch $ (last changed by) +*/ + +#include "rttbMaxOHxVolumeToDoseMeasureCollectionCalculator.h" + +namespace rttb +{ + + namespace algorithms + { + MaxOHxVolumeToDoseMeasureCollectionCalculator::MaxOHxVolumeToDoseMeasureCollectionCalculator(const std::vector& precomputeVolumeValues, + const VolumeType volume, const std::vector& doseVector, const std::vector& voxelProportionVector, + const DoseVoxelVolumeType currentVoxelVolume, VolumeToDoseMeasureCollection::complexStatistics name) : VolumeToDoseMeasureCollectionCalculator(precomputeVolumeValues, volume, + doseVector, voxelProportionVector, currentVoxelVolume, name) {} + + DoseTypeGy MaxOHxVolumeToDoseMeasureCollectionCalculator::computeSpecificValue(double xAbsolute) const + { + double noOfVoxel = xAbsolute / _currentVoxelVolume; + DoseTypeGy resultDose = 0; + + double countVoxels = 0; + for (auto i = _doseVector.size() - 1; i != -1; i--) + { + countVoxels += _voxelProportionVector.at(i); + + if (countVoxels >= noOfVoxel) + { + if (i > 0) + { + resultDose = _doseVector.at(i - 1); + } + break; + } + } + + return resultDose; + } + } +} \ No newline at end of file diff --git a/code/algorithms/rttbMaxOHxVolumeToDoseMeasureCalculator.h b/code/algorithms/rttbMaxOHxVolumeToDoseMeasureCollectionCalculator.h similarity index 71% rename from code/algorithms/rttbMaxOHxVolumeToDoseMeasureCalculator.h rename to code/algorithms/rttbMaxOHxVolumeToDoseMeasureCollectionCalculator.h index dd52aa8..64527e1 100644 --- a/code/algorithms/rttbMaxOHxVolumeToDoseMeasureCalculator.h +++ b/code/algorithms/rttbMaxOHxVolumeToDoseMeasureCollectionCalculator.h @@ -1,48 +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. // //------------------------------------------------------------------------ /*! // @file // @version $Revision: 1674 $ (last changed revision) // @date $Date: 2017-01-27 10:34:46 +0100 (Fr, 27 Jan 2017) $ (last change date) // @author $Author: hentsch $ (last changed by) */ -#ifndef __MAXOHX_VOLUME_TO_DOSE_MEASURE_CALCULATOR_H -#define __MAXOHX_VOLUME_TO_DOSE_MEASURE_CALCULATOR_H +#ifndef __MAXOHX_VOLUME_TO_DOSE_MEASURE_CALCULATOR_COLLECTION_H +#define __MAXOHX_VOLUME_TO_DOSE_MEASURE_CALCULATOR_COLLECTION_H -#include "rttbVolumeToDoseMeasureCalculator.h" +#include "rttbVolumeToDoseMeasureCollectionCalculator.h" namespace rttb { namespace algorithms { - class RTTBAlgorithms_EXPORT MaxOHxVolumeToDoseMeasureCalculator : public VolumeToDoseMeasureCalculator { + class RTTBAlgorithms_EXPORT MaxOHxVolumeToDoseMeasureCollectionCalculator : public VolumeToDoseMeasureCollectionCalculator { private: public: - MaxOHxVolumeToDoseMeasureCalculator(const std::vector& precomputeVolumeValues, const VolumeType volume, + MaxOHxVolumeToDoseMeasureCollectionCalculator(const std::vector& precomputeVolumeValues, const VolumeType volume, const std::vector& doseVector, const std::vector& voxelProportionVector, - const DoseVoxelVolumeType currentVoxelVolume, VolumeToDoseMeasure::complexStatistics name); + const DoseVoxelVolumeType currentVoxelVolume, VolumeToDoseMeasureCollection::complexStatistics name); protected: DoseTypeGy computeSpecificValue(double xAbsolute) const ; }; } } #endif diff --git a/code/algorithms/rttbMeasureInterface.cpp b/code/algorithms/rttbMeasureCollection.cpp similarity index 51% rename from code/algorithms/rttbMeasureInterface.cpp rename to code/algorithms/rttbMeasureCollection.cpp index 7c6432d..2d79e17 100644 --- a/code/algorithms/rttbMeasureInterface.cpp +++ b/code/algorithms/rttbMeasureCollection.cpp @@ -1,79 +1,100 @@ -#include "rttbMeasureInterface.h" +// ----------------------------------------------------------------------- +// 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: 1674 $ (last changed revision) +// @date $Date: 2017-01-27 10:34:46 +0100 (Fr, 27 Jan 2017) $ (last change date) +// @author $Author: hentsch $ (last changed by) +*/ + +#include "rttbMeasureCollection.h" #include "rttbDataNotAvailableException.h" namespace rttb { namespace algorithms { - MeasureInterface::complexStatistics MeasureInterface::getName() const + MeasureCollection::complexStatistics MeasureCollection::getName() const { return this->name; } - double MeasureInterface::getSpecificValue(const std::map& values, double key, bool findNearestValueInstead, double& storedKey) const + double MeasureCollection::getSpecificValue(const std::map& values, double key, bool findNearestValueInstead, double& storedKey) const { if (values.find(key) != std::end(values)) { return values.find(key)->second; } else { //value not in map. We have to find the nearest value if (values.empty()) { throw core::DataNotAvailableException("No Vx values are defined"); } else { if (findNearestValueInstead) { auto iterator = findNearestKeyInMap(values, key); storedKey = iterator->first; return iterator->second; } else { throw core::DataNotAvailableException("No Vx value with required dose is defined"); } } } } - std::map::const_iterator MeasureInterface::findNearestKeyInMap( + std::map::const_iterator MeasureCollection::findNearestKeyInMap( const std::map& values, double key) const { double minDistance = 1e19; double minDistanceLast = 1e20; auto iterator = std::begin(values); while (iterator != std::end(values)) { minDistanceLast = minDistance; minDistance = fabs(iterator->first - key); if (minDistanceLast > minDistance) { ++iterator; } else { if (iterator != std::begin(values)) { --iterator; return iterator; } else { return std::begin(values); } } } --iterator; return iterator; } } } \ No newline at end of file diff --git a/code/algorithms/rttbMeasureInterface.h b/code/algorithms/rttbMeasureCollection.h similarity index 92% rename from code/algorithms/rttbMeasureInterface.h rename to code/algorithms/rttbMeasureCollection.h index d7f15df..7a94da4 100644 --- a/code/algorithms/rttbMeasureInterface.h +++ b/code/algorithms/rttbMeasureCollection.h @@ -1,55 +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: 1674 $ (last changed revision) // @date $Date: 2017-01-27 10:34:46 +0100 (Fr, 27 Jan 2017) $ (last change date) // @author $Author: hentsch $ (last changed by) */ -#ifndef __MEASURE_INTERFACE_H -#define __MEASURE_INTERFACE_H +#ifndef __MEASURE_COLLECTION_H +#define __MEASURE_COLLECTION_H #include #include "rttbBaseType.h" #include "RTTBAlgorithmsExports.h" namespace rttb { namespace algorithms { - class RTTBAlgorithms_EXPORT MeasureInterface { + class RTTBAlgorithms_EXPORT MeasureCollection { public: enum complexStatistics { Dx, Vx, MOHx, MOCx, MaxOHx, MinOCx }; protected: complexStatistics name; public: complexStatistics getName() const; protected: double getSpecificValue(const std::map& values, double key, bool findNearestValueInstead, double& storedKey) const; std::map::const_iterator findNearestKeyInMap(const std::map& values, double key) const; }; } } #endif diff --git a/code/algorithms/rttbMinOCxVolumeToDoseMeasureCalculator.cpp b/code/algorithms/rttbMinOCxVolumeToDoseMeasureCalculator.cpp deleted file mode 100644 index fde483c..0000000 --- a/code/algorithms/rttbMinOCxVolumeToDoseMeasureCalculator.cpp +++ /dev/null @@ -1,51 +0,0 @@ -#include "rttbMinOCxVolumeToDoseMeasureCalculator.h" -namespace rttb -{ - - namespace algorithms - { - MinOCxVolumeToDoseMeasureCalculator::MinOCxVolumeToDoseMeasureCalculator(const std::vector& precomputeVolumeValues, - const VolumeType volume, const std::vector& doseVector, const std::vector& voxelProportionVector, - const DoseVoxelVolumeType currentVoxelVolume, const DoseStatisticType minimum, const DoseStatisticType maximum, VolumeToDoseMeasure::complexStatistics name) : VolumeToDoseMeasureCalculator(precomputeVolumeValues, volume, - doseVector, voxelProportionVector, currentVoxelVolume, name), _minimum(minimum), _maximum(maximum) {} - - DoseTypeGy MinOCxVolumeToDoseMeasureCalculator::computeSpecificValue(double xAbsolute) const - { - double noOfVoxel = xAbsolute / _currentVoxelVolume; - DoseTypeGy resultDose = 0; - - double countVoxels = 0; - std::vector::const_iterator it = _doseVector.begin(); - std::vector::const_iterator itD = _voxelProportionVector.begin(); - - for (; itD != _voxelProportionVector.end(); ++itD, ++it) - { - countVoxels += *itD; - - if (countVoxels >= noOfVoxel) - { - break; - } - } - - if (it != _doseVector.end()) - { - ++it; - - if (it != _doseVector.end()) - { - resultDose = *it; - } - else - { - resultDose = (DoseTypeGy)_maximum; - } - } - else - { - resultDose = (DoseTypeGy)_minimum; - } - return resultDose; - } - } -} \ No newline at end of file diff --git a/code/algorithms/rttbMinOCxVolumeToDoseMeasureCollectionCalculator.cpp b/code/algorithms/rttbMinOCxVolumeToDoseMeasureCollectionCalculator.cpp new file mode 100644 index 0000000..6bdb92b --- /dev/null +++ b/code/algorithms/rttbMinOCxVolumeToDoseMeasureCollectionCalculator.cpp @@ -0,0 +1,74 @@ +// ----------------------------------------------------------------------- +// 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: 1674 $ (last changed revision) +// @date $Date: 2017-01-27 10:34:46 +0100 (Fr, 27 Jan 2017) $ (last change date) +// @author $Author: hentsch $ (last changed by) +*/ + +#include "rttbMinOCxVolumeToDoseMeasureCollectionCalculator.h" + +namespace rttb +{ + + namespace algorithms + { + MinOCxVolumeToDoseMeasureCollectionCalculator::MinOCxVolumeToDoseMeasureCollectionCalculator(const std::vector& precomputeVolumeValues, + const VolumeType volume, const std::vector& doseVector, const std::vector& voxelProportionVector, + const DoseVoxelVolumeType currentVoxelVolume, const DoseStatisticType minimum, const DoseStatisticType maximum, + VolumeToDoseMeasureCollection::complexStatistics name) : VolumeToDoseMeasureCollectionCalculator(precomputeVolumeValues, volume, + doseVector, voxelProportionVector, currentVoxelVolume, name), _minimum(minimum), _maximum(maximum) {} + + DoseTypeGy MinOCxVolumeToDoseMeasureCollectionCalculator::computeSpecificValue(double xAbsolute) const + { + double noOfVoxel = xAbsolute / _currentVoxelVolume; + DoseTypeGy resultDose = 0; + + double countVoxels = 0; + std::vector::const_iterator it = _doseVector.begin(); + std::vector::const_iterator itD = _voxelProportionVector.begin(); + + for (; itD != _voxelProportionVector.end(); ++itD, ++it) + { + countVoxels += *itD; + + if (countVoxels >= noOfVoxel) + { + break; + } + } + + if (it != _doseVector.end()) + { + ++it; + + if (it != _doseVector.end()) + { + resultDose = *it; + } + else + { + resultDose = (DoseTypeGy)_maximum; + } + } + else + { + resultDose = (DoseTypeGy)_minimum; + } + return resultDose; + } + } +} \ No newline at end of file diff --git a/code/algorithms/rttbMinOCxVolumeToDoseMeasureCalculator.h b/code/algorithms/rttbMinOCxVolumeToDoseMeasureCollectionCalculator.h similarity index 73% rename from code/algorithms/rttbMinOCxVolumeToDoseMeasureCalculator.h rename to code/algorithms/rttbMinOCxVolumeToDoseMeasureCollectionCalculator.h index a96247a..f133015 100644 --- a/code/algorithms/rttbMinOCxVolumeToDoseMeasureCalculator.h +++ b/code/algorithms/rttbMinOCxVolumeToDoseMeasureCollectionCalculator.h @@ -1,50 +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: 1674 $ (last changed revision) // @date $Date: 2017-01-27 10:34:46 +0100 (Fr, 27 Jan 2017) $ (last change date) // @author $Author: hentsch $ (last changed by) */ -#ifndef __MINOCX_VOLUME_TO_DOSE_MEASURE_CALCULATOR_H -#define __MINOCX_VOLUME_TO_DOSE_MEASURE_CALCULATOR_H +#ifndef __MINOCX_VOLUME_TO_DOSE_MEASURE_COLLECTION_CALCULATOR_H +#define __MINOCX_VOLUME_TO_DOSE_MEASURE_COLLECTION_CALCULATOR_H -#include "rttbVolumeToDoseMeasureCalculator.h" +#include "rttbVolumeToDoseMeasureCollectionCalculator.h" namespace rttb { namespace algorithms { - class RTTBAlgorithms_EXPORT MinOCxVolumeToDoseMeasureCalculator : public VolumeToDoseMeasureCalculator { + class RTTBAlgorithms_EXPORT MinOCxVolumeToDoseMeasureCollectionCalculator : public VolumeToDoseMeasureCollectionCalculator { private: DoseStatisticType _minimum; DoseStatisticType _maximum; public: - MinOCxVolumeToDoseMeasureCalculator(const std::vector& precomputeVolumeValues, const VolumeType volume, + MinOCxVolumeToDoseMeasureCollectionCalculator(const std::vector& precomputeVolumeValues, const VolumeType volume, const std::vector& doseVector, const std::vector& voxelProportionVector, - const DoseVoxelVolumeType currentVoxelVolume, const DoseStatisticType minimum, const DoseStatisticType maximum, VolumeToDoseMeasure::complexStatistics name); + const DoseVoxelVolumeType currentVoxelVolume, const DoseStatisticType minimum, const DoseStatisticType maximum, VolumeToDoseMeasureCollection::complexStatistics name); protected: DoseTypeGy computeSpecificValue(double xAbsolute) const override; }; } } #endif diff --git a/code/algorithms/rttbVolumeToDoseMeasure.cpp b/code/algorithms/rttbVolumeToDoseMeasure.cpp deleted file mode 100644 index 5a715be..0000000 --- a/code/algorithms/rttbVolumeToDoseMeasure.cpp +++ /dev/null @@ -1,76 +0,0 @@ -#include "rttbVolumeToDoseMeasure.h" -#include "rttbInvalidParameterException.h" -#include "rttbDataNotAvailableException.h" - -namespace rttb -{ - - namespace algorithms - { - VolumeToDoseMeasure::VolumeToDoseMeasure(complexStatistics name, VolumeType volume) : - name(name), values(std::map()), _volume(volume) {} - - void VolumeToDoseMeasure::setVolume(VolumeType volume) - { - this->_volume = volume; - } - - void VolumeToDoseMeasure::insertValue(VolumeType volume, DoseTypeGy dose) - { - this->values.insert(std::pair(volume, dose)); - } - - DoseTypeGy VolumeToDoseMeasure::getValue(VolumeType xVolumeAbsolute) const - { - VolumeType dummy; - return getSpecificValue(values, xVolumeAbsolute, false, dummy); - } - - DoseTypeGy VolumeToDoseMeasure::getValue(VolumeType xVolumeAbsolute, bool findNearestValue, VolumeType & nearestXVolume) const - { - return getSpecificValue(values, xVolumeAbsolute, findNearestValue, nearestXVolume); - } - - DoseTypeGy VolumeToDoseMeasure::getValueRelative(VolumeType xVolumeRelative) const - { - if (_volume == -1) { - throw rttb::core::DataNotAvailableException("Volume is not set"); - } - if (xVolumeRelative >= 0 && xVolumeRelative <= 1) { - DoseTypeGy xVolumeAbsolute = xVolumeRelative * _volume; - VolumeType dummy; - return getSpecificValue(values, xVolumeAbsolute, false, dummy); - } - else { - throw rttb::core::InvalidParameterException("Relative Volume must be >= 0 and <=1"); - } - } - - DoseTypeGy VolumeToDoseMeasure::getValueRelative(VolumeType xVolumeRelative, bool findNearestValue, VolumeType & nearestXVolume) const - { - if (_volume == -1) { - throw rttb::core::DataNotAvailableException("Volume is not set"); - } - if (xVolumeRelative >= 0 && xVolumeRelative <= 1) { - DoseTypeGy xVolumeAbsolute = xVolumeRelative * _volume; - return getSpecificValue(values, xVolumeAbsolute, findNearestValue, nearestXVolume); - } - else { - throw rttb::core::InvalidParameterException("Relative Volume must be >= 0 and <=1"); - } - } - - VolumeToDoseMeasure::VolumeToDoseFunctionType VolumeToDoseMeasure::getAllValues() const - { - return this->values; - } - - bool operator==(const VolumeToDoseMeasure& volumeToDoseMesure,const VolumeToDoseMeasure& otherVolumeToDoseMesure) - { - if (volumeToDoseMesure.getName() == otherVolumeToDoseMesure.getName() && volumeToDoseMesure.getAllValues() == otherVolumeToDoseMesure.getAllValues()) { - return true; - } - return false; - } - } -} diff --git a/code/algorithms/rttbVolumeToDoseMeasureCalculator.cpp b/code/algorithms/rttbVolumeToDoseMeasureCalculator.cpp deleted file mode 100644 index f478fee..0000000 --- a/code/algorithms/rttbVolumeToDoseMeasureCalculator.cpp +++ /dev/null @@ -1,48 +0,0 @@ -#include "rttbVolumeToDoseMeasureCalculator.h" -#include -//#include - -namespace rttb -{ - - namespace algorithms - { - VolumeToDoseMeasureCalculator::VolumeToDoseMeasureCalculator(const std::vector& precomputeVolumeValues, const VolumeType volume, - const std::vector& doseVector, const std::vector& voxelProportionVector, const DoseVoxelVolumeType currentVoxelVolume, - VolumeToDoseMeasure::complexStatistics name) : measure(VolumeToDoseMeasure(name)), _precomputeVolumeValues(precomputeVolumeValues), - _volume(volume), _doseVector(doseVector), _voxelProportionVector(voxelProportionVector), _currentVoxelVolume(currentVoxelVolume) {} - - void VolumeToDoseMeasureCalculator::compute() - { - std::vector threads; - - for (size_t i = 0; i < _precomputeVolumeValues.size(); ++i) - { - double xAbsolute = _precomputeVolumeValues.at(i) * _volume; - if (false)//_multiThreading) - { - threads.push_back(boost::thread(&VolumeToDoseMeasureCalculator::insertIntoMeasure, this, xAbsolute, computeSpecificValue(xAbsolute))); - } - else - { - insertIntoMeasure(xAbsolute, this->computeSpecificValue(xAbsolute)); - } - } - - for (unsigned int i = 0; i()), _volume(volume) {} + + void VolumeToDoseMeasureCollection::setVolume(VolumeType volume) + { + this->_volume = volume; + } + + void VolumeToDoseMeasureCollection::insertValue(VolumeType volume, DoseTypeGy dose) + { + this->values.insert(std::pair(volume, dose)); + } + + DoseTypeGy VolumeToDoseMeasureCollection::getValue(VolumeType xVolumeAbsolute) const + { + VolumeType dummy; + return getSpecificValue(values, xVolumeAbsolute, false, dummy); + } + + DoseTypeGy VolumeToDoseMeasureCollection::getValue(VolumeType xVolumeAbsolute, bool findNearestValue, VolumeType & nearestXVolume) const + { + return getSpecificValue(values, xVolumeAbsolute, findNearestValue, nearestXVolume); + } + + DoseTypeGy VolumeToDoseMeasureCollection::getValueRelative(VolumeType xVolumeRelative) const + { + if (_volume == -1) { + throw rttb::core::DataNotAvailableException("Volume is not set"); + } + if (xVolumeRelative >= 0 && xVolumeRelative <= 1) { + DoseTypeGy xVolumeAbsolute = xVolumeRelative * _volume; + VolumeType dummy; + return getSpecificValue(values, xVolumeAbsolute, false, dummy); + } + else { + throw rttb::core::InvalidParameterException("Relative Volume must be >= 0 and <=1"); + } + } + + DoseTypeGy VolumeToDoseMeasureCollection::getValueRelative(VolumeType xVolumeRelative, bool findNearestValue, VolumeType & nearestXVolume) const + { + if (_volume == -1) { + throw rttb::core::DataNotAvailableException("Volume is not set"); + } + if (xVolumeRelative >= 0 && xVolumeRelative <= 1) { + DoseTypeGy xVolumeAbsolute = xVolumeRelative * _volume; + return getSpecificValue(values, xVolumeAbsolute, findNearestValue, nearestXVolume); + } + else { + throw rttb::core::InvalidParameterException("Relative Volume must be >= 0 and <=1"); + } + } + + VolumeToDoseMeasureCollection::VolumeToDoseFunctionType VolumeToDoseMeasureCollection::getAllValues() const + { + return this->values; + } + + bool operator==(const VolumeToDoseMeasureCollection& volumeToDoseMesureCollection,const VolumeToDoseMeasureCollection& otherVolumeToDoseMesureCollection) + { + if (volumeToDoseMesureCollection.getName() == otherVolumeToDoseMesureCollection.getName() && volumeToDoseMesureCollection.getAllValues() == otherVolumeToDoseMesureCollection.getAllValues()) { + return true; + } + return false; + } + } +} diff --git a/code/algorithms/rttbVolumeToDoseMeasure.h b/code/algorithms/rttbVolumeToDoseMeasureCollection.h similarity index 79% rename from code/algorithms/rttbVolumeToDoseMeasure.h rename to code/algorithms/rttbVolumeToDoseMeasureCollection.h index ef99138..d5f404c 100644 --- a/code/algorithms/rttbVolumeToDoseMeasure.h +++ b/code/algorithms/rttbVolumeToDoseMeasureCollection.h @@ -1,64 +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: 1674 $ (last changed revision) // @date $Date: 2017-01-27 10:34:46 +0100 (Fr, 27 Jan 2017) $ (last change date) // @author $Author: hentsch $ (last changed by) */ -#ifndef __VOLUME_TO_DOSE_MEASURE_H -#define __VOLUME_TO_DOSE_MEASURE_H +#ifndef __VOLUME_TO_DOSE_MEASURE_COLLECTION_H +#define __VOLUME_TO_DOSE_MEASURE_COLLECTION_H -#include "rttbMeasureInterface.h" +#include "rttbMeasureCollection.h" namespace rttb { namespace algorithms { - class RTTBAlgorithms_EXPORT VolumeToDoseMeasure : public MeasureInterface { + class RTTBAlgorithms_EXPORT VolumeToDoseMeasureCollection : public MeasureCollection { public: typedef std::map VolumeToDoseFunctionType; private: VolumeType _volume; complexStatistics name; VolumeToDoseFunctionType values; public: - VolumeToDoseMeasure(complexStatistics name, VolumeType volume = -1); + VolumeToDoseMeasureCollection(complexStatistics name, VolumeType volume = -1); void setVolume(VolumeType volume); void insertValue(VolumeType volume, DoseTypeGy dose); /*! @brief Gets the x of the current volume, depending on the complexStatistics name. @return Return dose value in Gy. @exception InvalidDoseException if the Dx values have not been set (i.e. the vector is empty) */ DoseTypeGy getValue(VolumeType xVolumeAbsolute) const; DoseTypeGy getValue(VolumeType xVolumeAbsolute, bool findNearestValue, VolumeType& nearestXDose) const; DoseTypeGy getValueRelative(VolumeType xDoseRelative) const; DoseTypeGy getValueRelative(VolumeType xDoseRelative, bool findNearestValue, VolumeType& nearestXDose) const; VolumeToDoseFunctionType getAllValues() const; - friend bool operator==(const VolumeToDoseMeasure& volumeToDoseMesure, const VolumeToDoseMeasure& otherVolumeToDoseMesure); + friend bool operator==(const VolumeToDoseMeasureCollection& volumeToDoseMesureCollection, const VolumeToDoseMeasureCollection& otherVolumeToDoseMesureCollection); }; } } #endif diff --git a/code/algorithms/rttbVolumeToDoseMeasureCollectionCalculator.cpp b/code/algorithms/rttbVolumeToDoseMeasureCollectionCalculator.cpp new file mode 100644 index 0000000..810cd94 --- /dev/null +++ b/code/algorithms/rttbVolumeToDoseMeasureCollectionCalculator.cpp @@ -0,0 +1,69 @@ +// ----------------------------------------------------------------------- +// 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: 1674 $ (last changed revision) +// @date $Date: 2017-01-27 10:34:46 +0100 (Fr, 27 Jan 2017) $ (last change date) +// @author $Author: hentsch $ (last changed by) +*/ + +#include "rttbVolumeToDoseMeasureCollectionCalculator.h" +#include +//#include + +namespace rttb +{ + + namespace algorithms + { + VolumeToDoseMeasureCollectionCalculator::VolumeToDoseMeasureCollectionCalculator(const std::vector& precomputeVolumeValues, const VolumeType volume, + const std::vector& doseVector, const std::vector& voxelProportionVector, const DoseVoxelVolumeType currentVoxelVolume, + VolumeToDoseMeasureCollection::complexStatistics name) : measure(VolumeToDoseMeasureCollection(name)), _precomputeVolumeValues(precomputeVolumeValues), + _volume(volume), _doseVector(doseVector), _voxelProportionVector(voxelProportionVector), _currentVoxelVolume(currentVoxelVolume) {} + + void VolumeToDoseMeasureCollectionCalculator::compute() + { + std::vector threads; + + for (size_t i = 0; i < _precomputeVolumeValues.size(); ++i) + { + double xAbsolute = _precomputeVolumeValues.at(i) * _volume; + if (false)//_multiThreading) + { + threads.push_back(boost::thread(&VolumeToDoseMeasureCollectionCalculator::insertIntoMeasure, this, xAbsolute, computeSpecificValue(xAbsolute))); + } + else + { + insertIntoMeasure(xAbsolute, this->computeSpecificValue(xAbsolute)); + } + } + + for (unsigned int i = 0; i VolumeToDoseFunctionType; protected: std::vector _doseVector; DoseVoxelVolumeType _currentVoxelVolume; std::vector _voxelProportionVector; private: VolumeType _volume; - VolumeToDoseMeasure measure; + VolumeToDoseMeasureCollection measure; std::vector _precomputeVolumeValues; public: /*! @brief Computes the measure. Algorithm for the specific complex Statistic has to be implemented in the corresponding subclass. */ void compute(); - VolumeToDoseMeasure getMeasure(); + VolumeToDoseMeasureCollection getMeasure(); protected: - VolumeToDoseMeasureCalculator(const std::vector& precomputeVolumeValues, const VolumeType volume, + VolumeToDoseMeasureCollectionCalculator(const std::vector& precomputeVolumeValues, const VolumeType volume, const std::vector& doseVector, const std::vector& voxelProportionVector, - const DoseVoxelVolumeType currentVoxelVolume, VolumeToDoseMeasure::complexStatistics name); + const DoseVoxelVolumeType currentVoxelVolume, VolumeToDoseMeasureCollection::complexStatistics name); void insertIntoMeasure(VolumeType xAbsolute, DoseTypeGy resultDose); virtual DoseTypeGy computeSpecificValue(double xAbsolute) const = 0; }; } } #endif diff --git a/code/algorithms/rttbVxDoseToVolumeMeasureCalculator.cpp b/code/algorithms/rttbVxDoseToVolumeMeasureCalculator.cpp deleted file mode 100644 index d1fed6c..0000000 --- a/code/algorithms/rttbVxDoseToVolumeMeasureCalculator.cpp +++ /dev/null @@ -1,33 +0,0 @@ -#include "rttbVxDoseToVolumeMeasureCalculator.h" -namespace rttb -{ - - namespace algorithms - { - VxDoseToVolumeMeasureCalculator::VxDoseToVolumeMeasureCalculator(const std::vector& precomputeDoseValues, - const DoseTypeGy referenceDose, const core::DoseIteratorInterface::DoseIteratorPointer doseIterator, DoseToVolumeMeasure::complexStatistics name) : - DoseToVolumeMeasureCalculator(precomputeDoseValues, referenceDose, doseIterator, name) {} - - VolumeType VxDoseToVolumeMeasureCalculator::computeSpecificValue(double xAbsolute) const - { - - rttb::FractionType count = 0; - _doseIterator->reset(); - - DoseTypeGy currentDose = 0; - - while (_doseIterator->isPositionValid()) - { - currentDose = _doseIterator->getCurrentDoseValue(); - - if (currentDose >= xAbsolute) - { - count += _doseIterator->getCurrentRelevantVolumeFraction(); - } - - _doseIterator->next(); - } - return count * this->_doseIterator->getCurrentVoxelVolume(); - } - } -} \ No newline at end of file diff --git a/code/algorithms/rttbVxDoseToVolumeMeasureCollectionCalculator.cpp b/code/algorithms/rttbVxDoseToVolumeMeasureCollectionCalculator.cpp new file mode 100644 index 0000000..5fec9ac --- /dev/null +++ b/code/algorithms/rttbVxDoseToVolumeMeasureCollectionCalculator.cpp @@ -0,0 +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: 1674 $ (last changed revision) +// @date $Date: 2017-01-27 10:34:46 +0100 (Fr, 27 Jan 2017) $ (last change date) +// @author $Author: hentsch $ (last changed by) +*/ + +#include "rttbVxDoseToVolumeMeasureCollectionCalculator.h" + +namespace rttb +{ + + namespace algorithms + { + VxDoseToVolumeMeasureCollectionCalculator::VxDoseToVolumeMeasureCollectionCalculator(const std::vector& precomputeDoseValues, + const DoseTypeGy referenceDose, const core::DoseIteratorInterface::DoseIteratorPointer doseIterator, + DoseToVolumeMeasureCollection::complexStatistics name) : + DoseToVolumeMeasureCollectionCalculator(precomputeDoseValues, referenceDose, doseIterator, name) {} + + VolumeType VxDoseToVolumeMeasureCollectionCalculator::computeSpecificValue(double xAbsolute) const + { + + rttb::FractionType count = 0; + _doseIterator->reset(); + + DoseTypeGy currentDose = 0; + + while (_doseIterator->isPositionValid()) + { + currentDose = _doseIterator->getCurrentDoseValue(); + + if (currentDose >= xAbsolute) + { + count += _doseIterator->getCurrentRelevantVolumeFraction(); + } + + _doseIterator->next(); + } + return count * this->_doseIterator->getCurrentVoxelVolume(); + } + } +} \ No newline at end of file diff --git a/code/algorithms/rttbVxDoseToVolumeMeasureCalculator.h b/code/algorithms/rttbVxDoseToVolumeMeasureCollectionCalculator.h similarity index 76% rename from code/algorithms/rttbVxDoseToVolumeMeasureCalculator.h rename to code/algorithms/rttbVxDoseToVolumeMeasureCollectionCalculator.h index 9eba4c3..29909f6 100644 --- a/code/algorithms/rttbVxDoseToVolumeMeasureCalculator.h +++ b/code/algorithms/rttbVxDoseToVolumeMeasureCollectionCalculator.h @@ -1,48 +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. // //------------------------------------------------------------------------ /*! // @file // @version $Revision: 1674 $ (last changed revision) // @date $Date: 2017-01-27 10:34:46 +0100 (Fr, 27 Jan 2017) $ (last change date) // @author $Author: hentsch $ (last changed by) */ #ifndef __DV_DOSE_TO_VOLUME_MEASURE_CALCULATOR_H #define __DV_DOSE_TO_VOLUME_MEASURE_CALCULATOR_H -#include "rttbDoseToVolumeMeasureCalculator.h" +#include "rttbDoseToVolumeMeasureCollectionCalculator.h" namespace rttb { namespace algorithms { - class RTTBAlgorithms_EXPORT VxDoseToVolumeMeasureCalculator : public DoseToVolumeMeasureCalculator { + class RTTBAlgorithms_EXPORT VxDoseToVolumeMeasureCollectionCalculator : public DoseToVolumeMeasureCollectionCalculator { private: DoseStatisticType _minimum; public: - VxDoseToVolumeMeasureCalculator(const std::vector& precomputeDoseValues, - const DoseTypeGy referenceDose, const core::DoseIteratorInterface::DoseIteratorPointer doseIterator, DoseToVolumeMeasure::complexStatistics name); + VxDoseToVolumeMeasureCollectionCalculator(const std::vector& precomputeDoseValues, + const DoseTypeGy referenceDose, const core::DoseIteratorInterface::DoseIteratorPointer doseIterator, DoseToVolumeMeasureCollection::complexStatistics name); protected: VolumeType computeSpecificValue(double xAbsolute) const override; }; } } #endif diff --git a/code/io/other/rttbDoseStatisticsXMLReader.cpp b/code/io/other/rttbDoseStatisticsXMLReader.cpp index 6c6e15a..84f579e 100644 --- a/code/io/other/rttbDoseStatisticsXMLReader.cpp +++ b/code/io/other/rttbDoseStatisticsXMLReader.cpp @@ -1,223 +1,223 @@ // ----------------------------------------------------------------------- // 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 #include #include #include #include #include #include "rttbDoseStatisticsXMLReader.h" #include "rttbInvalidParameterException.h" -#include "rttbVolumeToDoseMeasure.h" +#include "rttbVolumeToDoseMeasureCollection.h" namespace rttb { namespace io { namespace other { typedef boost::shared_ptr DoseStatisticsPtr; DoseStatisticsXMLReader::DoseStatisticsXMLReader(const std::string& filename) : _filename(filename), _newFile(true) { } DoseStatisticsXMLReader::~DoseStatisticsXMLReader() { } void DoseStatisticsXMLReader::setFilename(const std::string& filename) { _filename = filename; _newFile = true; } DoseStatisticsPtr DoseStatisticsXMLReader::generateDoseStatistic() { if (_newFile) { this->createDoseStatistic(); } return _doseStatistic; } void DoseStatisticsXMLReader::createDoseStatistic() { 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("DoseStatistics file name invalid: could not open the xml file!"); } // data to fill the parameter for the DoseStatistics std::string name; std::string datum; unsigned int x; std::pair voxelid; std::vector < std::pair> vec; //initialize all parameters for the DoseStatistics double minimum=-1; double maximum=-1; double numVoxels=-1; double volume=-1; double referenceDose = -1; double mean=-1; double stdDeviation=-1; boost::shared_ptr > > minimumVoxelPositions = nullptr; boost::shared_ptr > > maximumVoxelPositions = nullptr; - rttb::algorithms::VolumeToDoseMeasure Dx(rttb::algorithms::VolumeToDoseMeasure::Dx); - rttb::algorithms::DoseToVolumeMeasure Vx(rttb::algorithms::DoseToVolumeMeasure::Vx); - rttb::algorithms::VolumeToDoseMeasure MOHx(rttb::algorithms::VolumeToDoseMeasure::MOHx); - rttb::algorithms::VolumeToDoseMeasure MOCx(rttb::algorithms::VolumeToDoseMeasure::MOCx); - rttb::algorithms::VolumeToDoseMeasure MaxOHx(rttb::algorithms::VolumeToDoseMeasure::MaxOHx); - rttb::algorithms::VolumeToDoseMeasure MinOCx(rttb::algorithms::VolumeToDoseMeasure::MinOCx); + rttb::algorithms::VolumeToDoseMeasureCollection Dx(rttb::algorithms::VolumeToDoseMeasureCollection::Dx); + rttb::algorithms::DoseToVolumeMeasureCollection Vx(rttb::algorithms::DoseToVolumeMeasureCollection::Vx); + rttb::algorithms::VolumeToDoseMeasureCollection MOHx(rttb::algorithms::VolumeToDoseMeasureCollection::MOHx); + rttb::algorithms::VolumeToDoseMeasureCollection MOCx(rttb::algorithms::VolumeToDoseMeasureCollection::MOCx); + rttb::algorithms::VolumeToDoseMeasureCollection MaxOHx(rttb::algorithms::VolumeToDoseMeasureCollection::MaxOHx); + rttb::algorithms::VolumeToDoseMeasureCollection MinOCx(rttb::algorithms::VolumeToDoseMeasureCollection::MinOCx); BOOST_FOREACH(boost::property_tree::ptree::value_type & data, pt.get_child("statistics.results")) { datum = data.second.data(); BOOST_FOREACH(boost::property_tree::ptree::value_type & middle, data.second) { BOOST_FOREACH(boost::property_tree::ptree::value_type & innernode, middle.second) { std::string mia = innernode.first; if (innernode.first == "name") { name = innernode.second.data(); } else if (innernode.first == "voxelGridID") { boost::replace_all(datum, "\r\n", ""); boost::replace_all(datum, "\n", ""); boost::trim(datum); voxelid.first = boost::lexical_cast(datum); voxelid.second = boost::lexical_cast(innernode.second.data()); vec.push_back(voxelid); } else if (innernode.first == "x") { x = boost::lexical_cast(innernode.second.data()); } } } // fill with the extracted data if (name == "numberOfVoxels") { numVoxels = boost::lexical_cast(datum); } else if (name == "volume") { volume = boost::lexical_cast(datum); Dx.setVolume(volume); MOHx.setVolume(volume); MOCx.setVolume(volume); MaxOHx.setVolume(volume); } else if (name == "referenceDose") { referenceDose = boost::lexical_cast(datum); Vx.setReferenceDose(referenceDose); } else if (name == "mean") { mean = boost::lexical_cast(datum); } else if (name == "standardDeviation") { stdDeviation = boost::lexical_cast(datum); } else if (name == "minimum") { minimum = boost::lexical_cast(datum); if (!vec.empty()) { minimumVoxelPositions = boost::make_shared>>(vec); vec.clear(); } } else if (name == "maximum") { maximum = boost::lexical_cast(datum); if (!vec.empty()) { maximumVoxelPositions = boost::make_shared>>(vec); vec.clear(); } } else if (name == "Dx") { Dx.insertValue(static_cast(x)*volume / 100, boost::lexical_cast(datum)); } else if (name == "Vx") { Vx.insertValue(static_cast(x)*referenceDose / 100, boost::lexical_cast(datum)); } else if (name == "MOHx") { MOHx.insertValue(static_cast(x)*volume / 100, boost::lexical_cast(datum)); } else if (name == "MOCx") { MOCx.insertValue(static_cast(x)*volume / 100, boost::lexical_cast(datum)); } else if (name == "MaxOHx") { MaxOHx.insertValue(static_cast(x)*volume / 100, boost::lexical_cast(datum)); } else if (name == "MinOCx") { MinOCx.insertValue(static_cast(x)*volume / 100, boost::lexical_cast(datum)); } } // make DoseStatistcs _doseStatistic = boost::make_shared( minimum, maximum, mean, stdDeviation, numVoxels, volume, minimumVoxelPositions, maximumVoxelPositions , Dx, Vx, MOHx, MOCx, MaxOHx, MinOCx, referenceDose); } }//end namespace other }//end namespace io }//end namespace rttb diff --git a/code/io/other/rttbDoseStatisticsXMLWriter.cpp b/code/io/other/rttbDoseStatisticsXMLWriter.cpp index a12d786..bd12deb 100644 --- a/code/io/other/rttbDoseStatisticsXMLWriter.cpp +++ b/code/io/other/rttbDoseStatisticsXMLWriter.cpp @@ -1,302 +1,302 @@ // ----------------------------------------------------------------------- // 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 "rttbDoseStatisticsXMLWriter.h" #include #include #include #include "rttbInvalidParameterException.h" #include "rttbNullPointerException.h" -#include "rttbVolumeToDoseMeasure.h" -#include "rttbDoseToVolumeMeasure.h" +#include "rttbVolumeToDoseMeasureCollection.h" +#include "rttbDoseToVolumeMeasureCollection.h" namespace rttb { namespace io { namespace other { static const std::string xmlattrXTag = ".x"; static const std::string xmlattrNameTag = ".name"; static const std::string statisticsTag = "statistics.results"; static const std::string propertyTag = "property"; static const std::string columnSeparator = "@"; boost::property_tree::ptree writeDoseStatistics(DoseStatisticsPtr aDoseStatistics) { using boost::property_tree::ptree; ptree pt; if (aDoseStatistics == nullptr){ throw core::NullPointerException("dose statistics is nullptr!"); } ptree numberOfVoxelsNode = createNodeWithNameAttribute(aDoseStatistics->getNumberOfVoxels(), "numberOfVoxels"); pt.add_child(statisticsTag + "." + propertyTag, numberOfVoxelsNode); ptree volumeNode = createNodeWithNameAttribute(static_cast(aDoseStatistics->getVolume()), "volume"); pt.add_child(statisticsTag + "." + propertyTag, volumeNode); ptree referenceNode = createNodeWithNameAttribute(static_cast(aDoseStatistics->getReferenceDose()), "referenceDose"); pt.add_child(statisticsTag + "." + propertyTag, referenceNode); ptree minimumNode = createNodeWithNameAttribute(static_cast(aDoseStatistics->getMinimum()), "minimum"); auto minimumPositions = aDoseStatistics->getMinimumVoxelPositions(); std::vector >::iterator pairItMin = minimumPositions->begin(); int count = 0; for (; pairItMin != minimumPositions->end() && count < 100; ++pairItMin) //output max. 100 minimum { VoxelGridID voxelID = pairItMin->second; ptree voxelMinPositions; voxelMinPositions.add("voxelGridID", voxelID); minimumNode.add_child("voxel", voxelMinPositions); count++; } pt.add_child(statisticsTag + "." + propertyTag, minimumNode); ptree maximumNode = createNodeWithNameAttribute(static_cast(aDoseStatistics->getMaximum()), "maximum"); auto maximumPositions = aDoseStatistics->getMaximumVoxelPositions(); std::vector >::iterator pairItMax = maximumPositions->begin(); count = 0; for (; pairItMax != maximumPositions->end() && count < 100; ++pairItMax) //output max. 100 maximum { VoxelGridID voxelID = pairItMax->second; ptree voxelMaxPositions; voxelMaxPositions.add("voxelGridID", voxelID); maximumNode.add_child("voxel", voxelMaxPositions); count++; } pt.add_child(statisticsTag + "." + propertyTag, maximumNode); ptree meanNode = createNodeWithNameAttribute(static_cast(aDoseStatistics->getMean()), "mean"); pt.add_child(statisticsTag + "." + propertyTag, meanNode); ptree sdNode = createNodeWithNameAttribute(static_cast(aDoseStatistics->getStdDeviation()), "standardDeviation"); pt.add_child(statisticsTag + "." + propertyTag, sdNode); ptree varianceNode = createNodeWithNameAttribute(static_cast(aDoseStatistics->getVariance()), "variance"); pt.add_child(statisticsTag + "." + propertyTag, varianceNode); double absoluteVolume = aDoseStatistics->getVolume(); double referenceDose = aDoseStatistics->getReferenceDose(); - rttb::algorithms::DoseToVolumeMeasure::DoseToVolumeFunctionType AllVx = aDoseStatistics->getVx().getAllValues(); - rttb::algorithms::VolumeToDoseMeasure::VolumeToDoseFunctionType AllDx = aDoseStatistics->getDx().getAllValues(); - rttb::algorithms::VolumeToDoseMeasure::VolumeToDoseFunctionType AllMOHx = aDoseStatistics->getMOHx().getAllValues(); - rttb::algorithms::VolumeToDoseMeasure::VolumeToDoseFunctionType AllMOCx = aDoseStatistics->getMOCx().getAllValues(); - rttb::algorithms::VolumeToDoseMeasure::VolumeToDoseFunctionType AllMaxOHx = + rttb::algorithms::DoseToVolumeMeasureCollection::DoseToVolumeFunctionType AllVx = aDoseStatistics->getVx().getAllValues(); + rttb::algorithms::VolumeToDoseMeasureCollection::VolumeToDoseFunctionType AllDx = aDoseStatistics->getDx().getAllValues(); + rttb::algorithms::VolumeToDoseMeasureCollection::VolumeToDoseFunctionType AllMOHx = aDoseStatistics->getMOHx().getAllValues(); + rttb::algorithms::VolumeToDoseMeasureCollection::VolumeToDoseFunctionType AllMOCx = aDoseStatistics->getMOCx().getAllValues(); + rttb::algorithms::VolumeToDoseMeasureCollection::VolumeToDoseFunctionType AllMaxOHx = aDoseStatistics->getMaxOHx().getAllValues(); - rttb::algorithms::VolumeToDoseMeasure::VolumeToDoseFunctionType AllMinOCx = + rttb::algorithms::VolumeToDoseMeasureCollection::VolumeToDoseFunctionType AllMinOCx = aDoseStatistics->getMinOCx().getAllValues(); - rttb::algorithms::DoseToVolumeMeasure::DoseToVolumeFunctionType::iterator vxIt; - rttb::algorithms::VolumeToDoseMeasure::VolumeToDoseFunctionType::iterator it; + rttb::algorithms::DoseToVolumeMeasureCollection::DoseToVolumeFunctionType::iterator vxIt; + rttb::algorithms::VolumeToDoseMeasureCollection::VolumeToDoseFunctionType::iterator it; for (it = AllDx.begin(); it != AllDx.end(); ++it) { ptree DxNode = createNodeWithNameAndXAttribute(static_cast(it->second), "Dx", std::lround(convertToPercent(it->first, absoluteVolume))); pt.add_child(statisticsTag + "." + propertyTag, DxNode); } for (vxIt = AllVx.begin(); vxIt != AllVx.end(); ++vxIt) { ptree VxNode = createNodeWithNameAndXAttribute(static_cast(vxIt->second), "Vx", std::lround(convertToPercent(vxIt->first, referenceDose))); pt.add_child(statisticsTag + "." + propertyTag, VxNode); } for (it = AllMOHx.begin(); it != AllMOHx.end(); ++it) { ptree mohxNode = createNodeWithNameAndXAttribute(static_cast(it->second), "MOHx", std::lround(convertToPercent(it->first, absoluteVolume))); pt.add_child(statisticsTag + "." + propertyTag, mohxNode); } for (it = AllMOCx.begin(); it != AllMOCx.end(); ++it) { ptree mocxNode = createNodeWithNameAndXAttribute(static_cast(it->second), "MOCx", std::lround(convertToPercent(it->first, absoluteVolume))); pt.add_child(statisticsTag + "." + propertyTag, mocxNode); } for (it = AllMaxOHx.begin(); it != AllMaxOHx.end(); ++it) { ptree maxOhxNode = createNodeWithNameAndXAttribute(static_cast(it->second), "MaxOHx", std::lround(convertToPercent(it->first, absoluteVolume))); pt.add_child(statisticsTag + "." + propertyTag, maxOhxNode); } for (it = AllMinOCx.begin(); it != AllMinOCx.end(); ++it) { ptree minOCxNode = createNodeWithNameAndXAttribute(static_cast(it->second), "MinOCx", std::lround(convertToPercent(it->first, absoluteVolume))); pt.add_child(statisticsTag + "." + propertyTag, minOCxNode); } return pt; } void writeDoseStatistics(DoseStatisticsPtr aDoseStatistics, FileNameString aFileName) { boost::property_tree::ptree pt = writeDoseStatistics(aDoseStatistics); try { boost::property_tree::xml_parser::write_xml(aFileName, pt, std::locale(), boost::property_tree::xml_writer_make_settings('\t', 1)); } catch (boost::property_tree::xml_parser_error& /*e*/) { throw core::InvalidParameterException("Write xml failed: xml_parser_error!"); } } XMLString writerDoseStatisticsToString(DoseStatisticsPtr aDoseStatistics) { boost::property_tree::ptree pt = writeDoseStatistics(aDoseStatistics); std::stringstream sstr; try { boost::property_tree::xml_parser::write_xml(sstr, pt, boost::property_tree::xml_writer_make_settings('\t', 1)); } catch (boost::property_tree::xml_parser_error& /*e*/) { throw core::InvalidParameterException("Write xml to string failed: xml_parser_error!"); } return sstr.str(); } StatisticsString writerDoseStatisticsToTableString(DoseStatisticsPtr aDoseStatistics) { if (aDoseStatistics == nullptr){ throw core::NullPointerException("dose statistics is nullptr!"); } std::stringstream sstr; sstr << static_cast(aDoseStatistics->getVolume() * 1000) << columnSeparator; // cm3 to mm3 sstr << static_cast(aDoseStatistics->getMaximum()) << columnSeparator; sstr << static_cast(aDoseStatistics->getMinimum()) << columnSeparator; sstr << static_cast(aDoseStatistics->getMean()) << columnSeparator; sstr << static_cast(aDoseStatistics->getStdDeviation()) << columnSeparator; sstr << static_cast(aDoseStatistics->getVariance()) << columnSeparator; - rttb::algorithms::DoseToVolumeMeasure::DoseToVolumeFunctionType AllVx = aDoseStatistics->getVx().getAllValues(); - rttb::algorithms::VolumeToDoseMeasure::VolumeToDoseFunctionType AllDx = aDoseStatistics->getDx().getAllValues(); - rttb::algorithms::VolumeToDoseMeasure::VolumeToDoseFunctionType AllMOHx = aDoseStatistics->getMOHx().getAllValues(); - rttb::algorithms::VolumeToDoseMeasure::VolumeToDoseFunctionType AllMOCx = aDoseStatistics->getMOCx().getAllValues(); - rttb::algorithms::VolumeToDoseMeasure::VolumeToDoseFunctionType AllMaxOHx = + rttb::algorithms::DoseToVolumeMeasureCollection::DoseToVolumeFunctionType AllVx = aDoseStatistics->getVx().getAllValues(); + rttb::algorithms::VolumeToDoseMeasureCollection::VolumeToDoseFunctionType AllDx = aDoseStatistics->getDx().getAllValues(); + rttb::algorithms::VolumeToDoseMeasureCollection::VolumeToDoseFunctionType AllMOHx = aDoseStatistics->getMOHx().getAllValues(); + rttb::algorithms::VolumeToDoseMeasureCollection::VolumeToDoseFunctionType AllMOCx = aDoseStatistics->getMOCx().getAllValues(); + rttb::algorithms::VolumeToDoseMeasureCollection::VolumeToDoseFunctionType AllMaxOHx = aDoseStatistics->getMaxOHx().getAllValues(); - rttb::algorithms::VolumeToDoseMeasure::VolumeToDoseFunctionType AllMinOCx = + rttb::algorithms::VolumeToDoseMeasureCollection::VolumeToDoseFunctionType AllMinOCx = aDoseStatistics->getMinOCx().getAllValues(); - rttb::algorithms::DoseToVolumeMeasure::DoseToVolumeFunctionType::iterator vxIt; - rttb::algorithms::VolumeToDoseMeasure::VolumeToDoseFunctionType::iterator it; + rttb::algorithms::DoseToVolumeMeasureCollection::DoseToVolumeFunctionType::iterator vxIt; + rttb::algorithms::VolumeToDoseMeasureCollection::VolumeToDoseFunctionType::iterator it; for (it = AllDx.begin(); it != AllDx.end(); ++it) { sstr << static_cast((*it).second) << columnSeparator; } for (vxIt = AllVx.begin(); vxIt != AllVx.end(); ++vxIt) { // *1000 because of conversion cm3 to mm3 sstr << static_cast((*vxIt).second * 1000) << columnSeparator; } for (it = AllMOHx.begin(); it != AllMOHx.end(); ++it) { sstr << static_cast((*it).second) << columnSeparator; } for (it = AllMOCx.begin(); it != AllMOCx.end(); ++it) { sstr << static_cast((*it).second) << columnSeparator; } for (it = AllMaxOHx.begin(); it != AllMaxOHx.end(); ++it) { sstr << static_cast((*it).second) << columnSeparator; } for (it = AllMinOCx.begin(); it != AllMinOCx.end(); ++it) { sstr << static_cast((*it).second) << columnSeparator; } return sstr.str(); } boost::property_tree::ptree createNodeWithNameAttribute(DoseTypeGy doseValue, const std::string& attributeName) { boost::property_tree::ptree node; node.put("", doseValue); node.put(xmlattrNameTag, attributeName); return node; } boost::property_tree::ptree createNodeWithNameAndXAttribute(DoseTypeGy doseValue, const std::string& attributeName, int xValue) { boost::property_tree::ptree node; node.put("", doseValue); node.put(xmlattrNameTag, attributeName); node.put(xmlattrXTag, xValue); return node; } double convertToPercent(double value, double maximum) { return (value / maximum) * 100; } }//end namespace other }//end namespace io }//end namespace rttb \ No newline at end of file diff --git a/testing/algorithms/DoseStatisticsTest.cpp b/testing/algorithms/DoseStatisticsTest.cpp index ef897f6..d7a5ddd 100644 --- a/testing/algorithms/DoseStatisticsTest.cpp +++ b/testing/algorithms/DoseStatisticsTest.cpp @@ -1,251 +1,251 @@ // ----------------------------------------------------------------------- // 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 #include #include "litCheckMacros.h" #include "rttbBaseType.h" #include "rttbDoseStatistics.h" #include "rttbDataNotAvailableException.h" -#include "rttbVolumeToDoseMeasure.h" +#include "rttbVolumeToDoseMeasureCollection.h" namespace rttb { namespace testing { typedef rttb::algorithms::DoseStatistics::ResultListPointer ResultListPointer; /*! @brief DoseStatisticsTest - test the API of DoseStatistics 1) test constructors 2) test setters 3) test getters of complex statistics (with stored key and without stored key) */ int DoseStatisticsTest(int argc, char* argv[]) { PREPARE_DEFAULT_TEST_REPORTING; DoseStatisticType minimum = 1.0; DoseStatisticType mean = 5.5; DoseStatisticType maximum = 108.2; DoseStatisticType stdDeviation = 10.1; unsigned int numVoxels = 100000; VolumeType volume = numVoxels * (0.5 * 0.5 * 0.5); std::vector > minVoxels; std::vector > maxVoxels; minVoxels.push_back(std::make_pair(1.0, 11)); minVoxels.push_back(std::make_pair(1.0, 22)); minVoxels.push_back(std::make_pair(1.0, 33)); minVoxels.push_back(std::make_pair(1.0, 44)); maxVoxels.push_back(std::make_pair(108.2, 5)); maxVoxels.push_back(std::make_pair(108.2, 6)); maxVoxels.push_back(std::make_pair(108.2, 7)); maxVoxels.push_back(std::make_pair(108.2, 8)); ResultListPointer resultsMinVoxels = boost::make_shared > >(minVoxels); ResultListPointer resultsMaxVoxels = boost::make_shared > >(maxVoxels); - algorithms::DoseToVolumeMeasure Vx = algorithms::DoseToVolumeMeasure(algorithms::DoseToVolumeMeasure::Vx, maximum); + algorithms::DoseToVolumeMeasureCollection Vx(algorithms::DoseToVolumeMeasureCollection::Vx, maximum); Vx.insertValue(1.1, 1000); Vx.insertValue(106.9, 99000); - algorithms::VolumeToDoseMeasure Dx(algorithms::VolumeToDoseMeasure::Dx, volume); + algorithms::VolumeToDoseMeasureCollection Dx(algorithms::VolumeToDoseMeasureCollection::Dx, volume); Dx.insertValue(1000, 1.1); Dx.insertValue(99000, 106.9); - algorithms::VolumeToDoseMeasure MOHx(algorithms::VolumeToDoseMeasure::MOHx, volume); + algorithms::VolumeToDoseMeasureCollection MOHx(algorithms::VolumeToDoseMeasureCollection::MOHx, volume); MOHx.insertValue(1000, 5); MOHx.insertValue(99000, 105.5); - algorithms::VolumeToDoseMeasure MOCx(algorithms::VolumeToDoseMeasure::MOCx, volume); + algorithms::VolumeToDoseMeasureCollection MOCx(algorithms::VolumeToDoseMeasureCollection::MOCx, volume); MOCx.insertValue(1000, 10); MOCx.insertValue(99000, 99); - algorithms::VolumeToDoseMeasure MaxOHx(algorithms::VolumeToDoseMeasure::MaxOHx, volume); + algorithms::VolumeToDoseMeasureCollection MaxOHx(algorithms::VolumeToDoseMeasureCollection::MaxOHx, volume); MaxOHx.insertValue(1000, 40); MaxOHx.insertValue(99000, 98.3); - algorithms::VolumeToDoseMeasure MinOCx(algorithms::VolumeToDoseMeasure::MinOCx, volume); + algorithms::VolumeToDoseMeasureCollection MinOCx(algorithms::VolumeToDoseMeasureCollection::MinOCx, volume); MinOCx.insertValue(1000, 25.5); MinOCx.insertValue(99000, 102.7); //1) test constructors CHECK_NO_THROW(rttb::algorithms::DoseStatistics aDoseStatistic(minimum, maximum, mean, stdDeviation, numVoxels, volume)); rttb::algorithms::DoseStatistics aDoseStatistic(minimum, maximum, mean, stdDeviation, numVoxels, volume); CHECK_EQUAL(aDoseStatistic.getMinimum(), minimum); CHECK_EQUAL(aDoseStatistic.getMaximum(), maximum); CHECK_EQUAL(aDoseStatistic.getMean(), mean); CHECK_EQUAL(aDoseStatistic.getStdDeviation(), stdDeviation); CHECK_EQUAL(aDoseStatistic.getVariance(), stdDeviation * stdDeviation); CHECK_EQUAL(aDoseStatistic.getNumberOfVoxels(), numVoxels); CHECK_EQUAL(aDoseStatistic.getVolume(), volume); //check default values for unset complex values CHECK_EQUAL(aDoseStatistic.getMaximumVoxelPositions()->empty(), true); CHECK_EQUAL(aDoseStatistic.getMinimumVoxelPositions()->empty(), true); CHECK_EQUAL(aDoseStatistic.getDx().getAllValues().empty(), true); CHECK_EQUAL(aDoseStatistic.getVx().getAllValues().empty(), true); CHECK_EQUAL(aDoseStatistic.getMOHx().getAllValues().empty(), true); CHECK_EQUAL(aDoseStatistic.getMOCx().getAllValues().empty(), true); CHECK_EQUAL(aDoseStatistic.getMaxOHx().getAllValues().empty(), true); CHECK_EQUAL(aDoseStatistic.getMinOCx().getAllValues().empty(), true); CHECK_NO_THROW(rttb::algorithms::DoseStatistics aDoseStatisticComplex(minimum, maximum, mean, stdDeviation, numVoxels, volume, resultsMaxVoxels, resultsMinVoxels, Dx, Vx, MOHx, MOCx, MaxOHx, MinOCx)); rttb::algorithms::DoseStatistics aDoseStatisticComplex(minimum, maximum, mean, stdDeviation, numVoxels, volume, resultsMaxVoxels, resultsMinVoxels, Dx, Vx, MOHx, MOCx, MaxOHx, MinOCx); CHECK_EQUAL(aDoseStatisticComplex.getMaximumVoxelPositions(), resultsMaxVoxels); CHECK_EQUAL(aDoseStatisticComplex.getMinimumVoxelPositions(), resultsMinVoxels); CHECK_EQUAL(aDoseStatisticComplex.getDx() == Dx, true); CHECK_EQUAL(aDoseStatisticComplex.getVx() == Vx, true); CHECK_EQUAL(aDoseStatisticComplex.getMOHx() == MOHx, true); CHECK_EQUAL(aDoseStatisticComplex.getMOCx() == MOCx, true); CHECK_EQUAL(aDoseStatisticComplex.getMaxOHx() == MaxOHx, true); CHECK_EQUAL(aDoseStatisticComplex.getMinOCx() == MinOCx, true); //2) test setters (only complex statistics have setters) CHECK_NO_THROW(aDoseStatistic.setMaximumVoxelPositions(resultsMaxVoxels)); CHECK_NO_THROW(aDoseStatistic.setMinimumVoxelPositions(resultsMinVoxels)); CHECK_NO_THROW(aDoseStatistic.setDx(Dx)); CHECK_NO_THROW(aDoseStatistic.setVx(Vx)); CHECK_NO_THROW(aDoseStatistic.setMOHx(MOHx)); CHECK_NO_THROW(aDoseStatistic.setMOCx(MOCx)); CHECK_NO_THROW(aDoseStatistic.setMaxOHx(MaxOHx)); CHECK_NO_THROW(aDoseStatistic.setMinOCx(MinOCx)); CHECK_EQUAL(aDoseStatistic.getMaximumVoxelPositions(), resultsMaxVoxels); CHECK_EQUAL(aDoseStatistic.getMinimumVoxelPositions(), resultsMinVoxels); CHECK_EQUAL(aDoseStatistic.getDx() == Dx, true); CHECK_EQUAL(aDoseStatistic.getVx() == Vx, true); CHECK_EQUAL(aDoseStatistic.getMOHx() == MOHx, true); CHECK_EQUAL(aDoseStatistic.getMOCx() == MOCx, true); CHECK_EQUAL(aDoseStatistic.getMaxOHx() == MaxOHx, true); CHECK_EQUAL(aDoseStatistic.getMinOCx() == MinOCx, true); //3) test getters of complex statistics(with stored key and without stored key) //getAll*() already tested in (2) - Vx = algorithms::DoseToVolumeMeasure(algorithms::DoseToVolumeMeasure::Vx, maximum); + Vx = algorithms::DoseToVolumeMeasureCollection(algorithms::DoseToVolumeMeasureCollection::Vx, maximum); Vx.insertValue(1.1, 1000); Vx.insertValue(5.0, 2300); Vx.insertValue(90, 90500); Vx.insertValue(107, 99000); - Dx = algorithms::VolumeToDoseMeasure(algorithms::VolumeToDoseMeasure::Dx, volume); + Dx = algorithms::VolumeToDoseMeasureCollection(algorithms::VolumeToDoseMeasureCollection::Dx, volume); Dx.insertValue(1000, 1.1); Dx.insertValue(2000, 2.0); Dx.insertValue(5000, 10.8); Dx.insertValue(90000, 89.5); Dx.insertValue(98000, 104.4); Dx.insertValue(99000, 106.9); rttb::algorithms::DoseStatistics aDoseStatisticNewValues(minimum, maximum, mean, stdDeviation, numVoxels, volume); aDoseStatisticNewValues.setDx(Dx); aDoseStatisticNewValues.setVx(Vx); CHECK_NO_THROW(aDoseStatisticNewValues.getVx().getValue(1.1)); CHECK_NO_THROW(aDoseStatisticNewValues.getVx().getValue(90)); CHECK_NO_THROW(aDoseStatisticNewValues.getDx().getValue(1000)); CHECK_NO_THROW(aDoseStatisticNewValues.getDx().getValue(98000)); CHECK_EQUAL(aDoseStatisticNewValues.getVx().getValue(1.1), Vx.getAllValues().find(1.1)->second); CHECK_EQUAL(aDoseStatisticNewValues.getVx().getValue(90), Vx.getAllValues().find(90)->second); CHECK_EQUAL(aDoseStatisticNewValues.getDx().getValue(1000), Dx.getAllValues().find(1000)->second); CHECK_EQUAL(aDoseStatisticNewValues.getDx().getValue(98000), Dx.getAllValues().find(98000)->second); //test if key-value combination NOT in map CHECK_THROW_EXPLICIT(aDoseStatisticNewValues.getDx().getValue(1001), core::DataNotAvailableException); CHECK_THROW_EXPLICIT(aDoseStatisticNewValues.getVx().getValue(10), core::DataNotAvailableException); double closestDxKey, closestVxKey; CHECK_NO_THROW(aDoseStatisticNewValues.getDx().getValue(900, true, closestDxKey)); CHECK_NO_THROW(aDoseStatisticNewValues.getDx().getValue(99001, true, closestDxKey)); CHECK_NO_THROW(aDoseStatisticNewValues.getVx().getValue(10, true, closestVxKey)); CHECK_EQUAL(aDoseStatisticNewValues.getDx().getValue(900, true, closestDxKey), Dx.getAllValues().find(1000)->second); CHECK_EQUAL(aDoseStatisticNewValues.getDx().getValue(99001, true, closestDxKey), Dx.getAllValues().find(99000)->second); CHECK_EQUAL(aDoseStatisticNewValues.getVx().getValue(10, true, closestVxKey), Vx.getAllValues().find(5.0)->second); CHECK_EQUAL(closestDxKey, 99000); CHECK_EQUAL(closestVxKey, 5); // relatives only between 0 and 1 CHECK_NO_THROW(aDoseStatisticNewValues.getVx().getValueRelative(1.1 / aDoseStatistic.getReferenceDose())); CHECK_NO_THROW(aDoseStatisticNewValues.getDx().getValueRelative(1000 / aDoseStatistic.getVolume())); CHECK_THROW(aDoseStatisticNewValues.getVx().getValueRelative(-0.3)); CHECK_THROW(aDoseStatisticNewValues.getVx().getValueRelative(1.1)); CHECK_THROW(aDoseStatisticNewValues.getDx().getValueRelative(0.5)); CHECK_NO_THROW(aDoseStatisticNewValues.getDx().getValueRelative(900 / aDoseStatistic.getVolume(), true, closestDxKey)); CHECK_NO_THROW(aDoseStatisticNewValues.getDx().getValueRelative(0.5, true, closestDxKey)); CHECK_NO_THROW(aDoseStatisticNewValues.getVx().getValueRelative(10 / aDoseStatistic.getReferenceDose(), true, closestVxKey)); CHECK_EQUAL(aDoseStatisticNewValues.getDx().getValueRelative(900 / aDoseStatistic.getVolume(), true, closestDxKey), Dx.getAllValues().find(1000)->second); CHECK_EQUAL(aDoseStatisticNewValues.getVx().getValueRelative(10 / aDoseStatistic.getReferenceDose(), true, closestVxKey), Vx.getAllValues().find(5.0)->second); CHECK_EQUAL(closestVxKey, 5); //equal distance to two values. First value is returned. CHECK_NO_THROW(aDoseStatisticNewValues.getDx().getValue(1500, true, closestDxKey)); CHECK_NO_THROW(aDoseStatisticNewValues.getVx().getValue(98.5, true, closestVxKey)); CHECK_EQUAL(aDoseStatisticNewValues.getDx().getValue(1500, true, closestDxKey), Dx.getAllValues().find(1000)->second); CHECK_EQUAL(aDoseStatisticNewValues.getVx().getValue(98.5, true, closestVxKey), Vx.getAllValues().find(90.0)->second); CHECK_EQUAL(closestDxKey, 1000); CHECK_EQUAL(closestVxKey, 90.0); double dummy; CHECK_THROW_EXPLICIT(aDoseStatisticNewValues.getMinOCx().getValue(25), core::DataNotAvailableException); CHECK_THROW_EXPLICIT(aDoseStatisticNewValues.getMOHx().getValue(9999), core::DataNotAvailableException); CHECK_THROW_EXPLICIT(aDoseStatisticNewValues.getMinOCx().getValue(25, true, dummy), core::DataNotAvailableException); CHECK_THROW_EXPLICIT(aDoseStatisticNewValues.getMOHx().getValue(9999, true, dummy), core::DataNotAvailableException); CHECK_THROW_EXPLICIT(aDoseStatisticNewValues.getMinOCx().getValueRelative(25 / aDoseStatistic.getVolume()), core::DataNotAvailableException); CHECK_THROW_EXPLICIT(aDoseStatisticNewValues.getMOHx().getValueRelative(9999 / aDoseStatistic.getVolume()), core::DataNotAvailableException); CHECK_THROW_EXPLICIT(aDoseStatisticNewValues.getMinOCx().getValueRelative(25 / aDoseStatistic.getVolume(), true, dummy), core::DataNotAvailableException); CHECK_THROW_EXPLICIT(aDoseStatisticNewValues.getMOHx().getValueRelative(9999 / aDoseStatistic.getVolume(), true, dummy), core::DataNotAvailableException); RETURN_AND_REPORT_TEST_SUCCESS; } }//end namespace testing }//end namespace rttb