diff --git a/code/algorithms/files.cmake b/code/algorithms/files.cmake index 5d47974..247adf6 100644 --- a/code/algorithms/files.cmake +++ b/code/algorithms/files.cmake @@ -1,26 +1,46 @@ SET(CPP_FILES rttbDoseStatistics.cpp rttbDoseStatisticsCalculator.cpp rttbArithmetic.cpp + + rttbVolumeToDoseMeasureCalculator.cpp rttbDxVolumeToDoseMeasureCalculator.cpp rttbMOHxVolumeToDoseMeasureCalculator.cpp - rttbVolumeToDoseMeasureCalculator.cpp + rttbMOCxVolumeToDoseMeasureCalculator.cpp + rttbMinOCxVolumeToDoseMeasureCalculator.cpp + rttbMaxOHxVolumeToDoseMeasureCalculator.cpp + + rttbDoseToVolumeMeasureCalculator.cpp + rttbVxDoseToVolumeMeasureCalculator.cpp + + rttbMeasureInterface.cpp rttbVolumeToDoseMeasure.cpp + rttbDoseToVolumeMeasure.cpp ) SET(H_FILES rttbDoseStatistics.h rttbDoseStatisticsCalculator.h rttbArithmetic.h rttbBinaryFunctorAccessor.h + + rttbVolumeToDoseMeasureCalculator.h rttbDxVolumeToDoseMeasureCalculator.h rttbMOHxVolumeToDoseMeasureCalculator.h - rttbVolumeToDoseMeasureCalculator.h + rttbMOCxVolumeToDoseMeasureCalculator.h + rttbMinOCxVolumeToDoseMeasureCalculator.h + rttbMaxOHxVolumeToDoseMeasureCalculator.h + + rttbDoseToVolumeMeasureCalculator.h + rttbVxDoseToVolumeMeasureCalculator.h + + rttbMeasureInterface.h rttbVolumeToDoseMeasure.h + rttbDoseToVolumeMeasure.h ) SET(TXX_FILES rttbArithmetic.tpp rttbBinaryFunctorAccessor.tpp ) diff --git a/code/algorithms/rttbDoseStatisticsCalculator.cpp b/code/algorithms/rttbDoseStatisticsCalculator.cpp index b5a5fb4..bf2b4f7 100644 --- a/code/algorithms/rttbDoseStatisticsCalculator.cpp +++ b/code/algorithms/rttbDoseStatisticsCalculator.cpp @@ -1,400 +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 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; } - DxVolumeToDoseMeasureCalculator Dx = DxVolumeToDoseMeasureCalculator(precomputeVolumeValuesNonConst, _statistics->getVolume(), - this->_doseVector, this->_voxelProportionVector, this->_doseIterator->getCurrentVoxelVolume(), _statistics->getMinimum(), VolumeToDoseMeasure::Dx); - Dx.compute(); VxDoseToVolumeMeasureCalculator Vx = VxDoseToVolumeMeasureCalculator(precomputeDoseValuesNonConst, referenceDose, _doseIterator, DoseToVolumeMeasure::Vx); Vx.compute(); + DxVolumeToDoseMeasureCalculator Dx = DxVolumeToDoseMeasureCalculator(precomputeVolumeValuesNonConst, _statistics->getVolume(), + this->_doseVector, this->_voxelProportionVector, this->_doseIterator->getCurrentVoxelVolume(), _statistics->getMinimum(), VolumeToDoseMeasure::Dx); + Dx.compute(); + MOHxVolumeToDoseMeasureCalculator MOHx = MOHxVolumeToDoseMeasureCalculator(precomputeVolumeValuesNonConst, _statistics->getVolume(), this->_doseVector, this->_voxelProportionVector, this->_doseIterator->getCurrentVoxelVolume(), VolumeToDoseMeasure::MOHx); MOHx.compute(); MOCxVolumeToDoseMeasureCalculator MOCx = MOCxVolumeToDoseMeasureCalculator(precomputeVolumeValuesNonConst, _statistics->getVolume(), this->_doseVector, this->_voxelProportionVector, this->_doseIterator->getCurrentVoxelVolume(), VolumeToDoseMeasure::MOCx); MOCx.compute(); MaxOHxVolumeToDoseMeasureCalculator MaxOHx = MaxOHxVolumeToDoseMeasureCalculator(precomputeVolumeValuesNonConst, _statistics->getVolume(), this->_doseVector, this->_voxelProportionVector, this->_doseIterator->getCurrentVoxelVolume(), VolumeToDoseMeasure::MaxOHx); MaxOHx.compute(); MinOCxVolumeToDoseMeasureCalculator MinOCx = MinOCxVolumeToDoseMeasureCalculator(precomputeVolumeValuesNonConst, _statistics->getVolume(), this->_doseVector, this->_voxelProportionVector, this->_doseIterator->getCurrentVoxelVolume(), _statistics->getMinimum(), _statistics->getMaximum(), VolumeToDoseMeasure::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 index d78e495..713572b 100644 --- a/code/algorithms/rttbDoseToVolumeMeasure.cpp +++ b/code/algorithms/rttbDoseToVolumeMeasure.cpp @@ -1,96 +1,69 @@ #include "rttbDoseToVolumeMeasure.h" -#include "rttbDataNotAvailableException.h" #include "rttbInvalidParameterException.h" namespace rttb { namespace algorithms { DoseToVolumeMeasure::DoseToVolumeMeasure(complexStatistics name, DoseToVolumeFunctionType values, DoseTypeGy referenceDose) : name(name), values(values), _referenceDose(referenceDose) {} - + + void DoseToVolumeMeasure::setReferenceDose(DoseTypeGy referenceDose) + { + this->_referenceDose = referenceDose; + } + void DoseToVolumeMeasure::insertValue(std::pair value) { this->values.insert(value); } VolumeType DoseToVolumeMeasure::getValue(DoseTypeGy xVolumeAbsolute) const { VolumeType dummy; - return getSpecificValue(xVolumeAbsolute, false, dummy); + return getSpecificValue(values, xVolumeAbsolute, false, dummy); } VolumeType DoseToVolumeMeasure::getValue(DoseTypeGy xDoseAbsolute, bool findNearestValue, DoseTypeGy & nearestXDose) const { - return getSpecificValue(xDoseAbsolute, findNearestValue, nearestXDose); + 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(xDoseAbsolute, false, 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(xDoseAbsolute, findNearestValue, nearestXDose); + 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; } - void DoseToVolumeMeasure::setReferenceDose(DoseTypeGy referenceDose) - { - this->_referenceDose = referenceDose; - } - - double DoseToVolumeMeasure::getSpecificValue(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"); - } - } - } - } - 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/rttbDoseToVolumeMeasure.h b/code/algorithms/rttbDoseToVolumeMeasure.h index 31a6f1b..668b89c 100644 --- a/code/algorithms/rttbDoseToVolumeMeasure.h +++ b/code/algorithms/rttbDoseToVolumeMeasure.h @@ -1,59 +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 #include "rttbMeasureInterface.h" namespace rttb { namespace algorithms { class RTTBAlgorithms_EXPORT DoseToVolumeMeasure : public MeasureInterface { public: typedef std::map DoseToVolumeFunctionType; private: complexStatistics name; - DoseToVolumeFunctionType values; DoseTypeGy _referenceDose; + DoseToVolumeFunctionType values; public: DoseToVolumeMeasure(complexStatistics name, DoseToVolumeFunctionType values = std::map(), DoseTypeGy referenceDose = -1); + + void setReferenceDose(DoseTypeGy referenceDose); void insertValue(std::pair value); + + /*! @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); - void setReferenceDose(DoseTypeGy referenceDose); - private: - double getSpecificValue(double key, bool findNearestValueInstead, double& storedKey) const; }; } } #endif diff --git a/code/algorithms/rttbDoseToVolumeMeasureCalculator.cpp b/code/algorithms/rttbDoseToVolumeMeasureCalculator.cpp index 5e75f4a..c2e3b8a 100644 --- a/code/algorithms/rttbDoseToVolumeMeasureCalculator.cpp +++ b/code/algorithms/rttbDoseToVolumeMeasureCalculator.cpp @@ -1,47 +1,47 @@ #include "rttbDoseToVolumeMeasureCalculator.h" #include //#include namespace rttb { namespace algorithms { - DoseToVolumeMeasureCalculator::DoseToVolumeMeasureCalculator(const std::vector& precomputeVolumeValues, const DoseTypeGy& referenceDose, + DoseToVolumeMeasureCalculator::DoseToVolumeMeasureCalculator(const std::vector& precomputeDoseValues, const DoseTypeGy& referenceDose, const core::DoseIteratorInterface::DoseIteratorPointer doseIterator, DoseToVolumeMeasure::complexStatistics name) : - measure(DoseToVolumeMeasure(name)), _precomputeVolumeValues(precomputeVolumeValues), + measure(DoseToVolumeMeasure(name)), _precomputeDoseValues(precomputeDoseValues), _referenceDose(referenceDose), _doseIterator(doseIterator) {} void DoseToVolumeMeasureCalculator::compute() { std::vector threads; - for (size_t i = 0; i < _precomputeVolumeValues.size(); ++i) + for (size_t i = 0; i < _precomputeDoseValues.size(); ++i) { if (false)//_multiThreading) { - threads.push_back(boost::thread(&DoseToVolumeMeasureCalculator::computeSpecificValue, this, _precomputeVolumeValues.at(i) * _referenceDose)); + threads.push_back(boost::thread(&DoseToVolumeMeasureCalculator::computeSpecificValue, this, _precomputeDoseValues.at(i) * _referenceDose)); } else { - this->computeSpecificValue(_precomputeVolumeValues.at(i) * _referenceDose); + this->computeSpecificValue(_precomputeDoseValues.at(i) * _referenceDose); } } for (unsigned int i = 0; i(xAbsolute, resultVolume)); } } } diff --git a/code/algorithms/rttbDoseToVolumeMeasureCalculator.h b/code/algorithms/rttbDoseToVolumeMeasureCalculator.h index 8d6a950..02cb56a 100644 --- a/code/algorithms/rttbDoseToVolumeMeasureCalculator.h +++ b/code/algorithms/rttbDoseToVolumeMeasureCalculator.h @@ -1,69 +1,72 @@ // ----------------------------------------------------------------------- // RTToolbox - DKFZ radiotherapy quantitative evaluation library // // Copyright (c) German Cancer Research Center (DKFZ), // Software development for Integrated Diagnostics and Therapy (SIDT). // ALL RIGHTS RESERVED. // See rttbCopyright.txt or // http://www.dkfz.de/en/sidt/projects/rttb/copyright.html // // This software is distributed WITHOUT ANY WARRANTY; without even // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // PURPOSE. See the above copyright notices for more information. // //------------------------------------------------------------------------ /*! // @file // @version $Revision: 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_CALCULATOR_H #define __DOSE_TO_VOLUME_MEASURE_CALCULATOR_H #include #include #include "rttbBaseType.h" #include "RTTBAlgorithmsExports.h" #include "rttbDoseToVolumeMeasure.h" #include "rttbDoseIteratorInterface.h" namespace rttb { namespace algorithms { class RTTBAlgorithms_EXPORT DoseToVolumeMeasureCalculator { public: typedef std::map VolumeToDoseFunctionType; protected: core::DoseIteratorInterface::DoseIteratorPointer _doseIterator; private: DoseTypeGy _referenceDose; DoseToVolumeMeasure measure; - std::vector _precomputeVolumeValues; + std::vector _precomputeDoseValues; public: - DoseToVolumeMeasureCalculator(const std::vector& precomputeVolumeValues, - const DoseTypeGy& referenceDose, const core::DoseIteratorInterface::DoseIteratorPointer doseIterator, DoseToVolumeMeasure::complexStatistics name); + /*! @brief Computes the measure. Algorithm for the specific complex Statistic has to be implemented in the corresponding subclass. + */ void compute(); DoseToVolumeMeasure getMeasure(); - virtual void computeSpecificValue(double xAbsolute) = 0; protected: + DoseToVolumeMeasureCalculator(const std::vector& precomputeDoseValues, + const DoseTypeGy& referenceDose, const core::DoseIteratorInterface::DoseIteratorPointer doseIterator, DoseToVolumeMeasure::complexStatistics name); + void insertIntoMeasure(DoseTypeGy xAbsolute, VolumeType resultVolume); + virtual void computeSpecificValue(double xAbsolute) = 0; }; } } #endif diff --git a/code/algorithms/rttbDxVolumeToDoseMeasureCalculator.h b/code/algorithms/rttbDxVolumeToDoseMeasureCalculator.h index e4c76e6..f870966 100644 --- a/code/algorithms/rttbDxVolumeToDoseMeasureCalculator.h +++ b/code/algorithms/rttbDxVolumeToDoseMeasureCalculator.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 #include "rttbVolumeToDoseMeasureCalculator.h" namespace rttb { namespace algorithms { class RTTBAlgorithms_EXPORT DxVolumeToDoseMeasureCalculator: public VolumeToDoseMeasureCalculator { private: DoseStatisticType _minimum; public: 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); - private: + protected: void computeSpecificValue(double xAbsolute); }; } } #endif diff --git a/code/algorithms/rttbMOCxVolumeToDoseMeasureCalculator.h b/code/algorithms/rttbMOCxVolumeToDoseMeasureCalculator.h index 67f82a5..fe09aa1 100644 --- a/code/algorithms/rttbMOCxVolumeToDoseMeasureCalculator.h +++ b/code/algorithms/rttbMOCxVolumeToDoseMeasureCalculator.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 #include "rttbVolumeToDoseMeasureCalculator.h" namespace rttb { namespace algorithms { class RTTBAlgorithms_EXPORT MOCxVolumeToDoseMeasureCalculator : public VolumeToDoseMeasureCalculator { public: MOCxVolumeToDoseMeasureCalculator(const std::vector& precomputeVolumeValues, const VolumeType& volume, const std::vector& doseVector, const std::vector& voxelProportionVector, const DoseVoxelVolumeType& currentVoxelVolume, VolumeToDoseMeasure::complexStatistics name); - private: + protected: void computeSpecificValue(double xAbsolute); }; } } #endif diff --git a/code/algorithms/rttbMOHxVolumeToDoseMeasureCalculator.h b/code/algorithms/rttbMOHxVolumeToDoseMeasureCalculator.h index b51df11..b4c1f90 100644 --- a/code/algorithms/rttbMOHxVolumeToDoseMeasureCalculator.h +++ b/code/algorithms/rttbMOHxVolumeToDoseMeasureCalculator.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 #include "rttbVolumeToDoseMeasureCalculator.h" namespace rttb { namespace algorithms { class RTTBAlgorithms_EXPORT MOHxVolumeToDoseMeasureCalculator : public VolumeToDoseMeasureCalculator { private: DoseStatisticType _minimum; public: MOHxVolumeToDoseMeasureCalculator(const std::vector& precomputeVolumeValues, const VolumeType& volume, const std::vector& doseVector, const std::vector& voxelProportionVector, const DoseVoxelVolumeType& currentVoxelVolume, VolumeToDoseMeasure::complexStatistics name); - private: + protected: void computeSpecificValue(double xAbsolute); }; } } #endif diff --git a/code/algorithms/rttbMaxOHxVolumeToDoseMeasureCalculator.h b/code/algorithms/rttbMaxOHxVolumeToDoseMeasureCalculator.h index 7ad868f..51c94a6 100644 --- a/code/algorithms/rttbMaxOHxVolumeToDoseMeasureCalculator.h +++ b/code/algorithms/rttbMaxOHxVolumeToDoseMeasureCalculator.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 #include "rttbVolumeToDoseMeasureCalculator.h" namespace rttb { namespace algorithms { class RTTBAlgorithms_EXPORT MaxOHxVolumeToDoseMeasureCalculator : public VolumeToDoseMeasureCalculator { private: public: MaxOHxVolumeToDoseMeasureCalculator(const std::vector& precomputeVolumeValues, const VolumeType& volume, const std::vector& doseVector, const std::vector& voxelProportionVector, const DoseVoxelVolumeType& currentVoxelVolume, VolumeToDoseMeasure::complexStatistics name); - private: + protected: void computeSpecificValue(double xAbsolute); }; } } #endif diff --git a/code/algorithms/rttbMeasureInterface.cpp b/code/algorithms/rttbMeasureInterface.cpp index 3a1ab9b..7c6432d 100644 --- a/code/algorithms/rttbMeasureInterface.cpp +++ b/code/algorithms/rttbMeasureInterface.cpp @@ -1,49 +1,79 @@ #include "rttbMeasureInterface.h" +#include "rttbDataNotAvailableException.h" namespace rttb { namespace algorithms { MeasureInterface::complexStatistics MeasureInterface::getName() const { return this->name; } + double MeasureInterface::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( - const std::map& aMap, + const std::map& values, double key) const { double minDistance = 1e19; double minDistanceLast = 1e20; - auto iterator = std::begin(aMap); + auto iterator = std::begin(values); - while (iterator != std::end(aMap)) + while (iterator != std::end(values)) { minDistanceLast = minDistance; minDistance = fabs(iterator->first - key); if (minDistanceLast > minDistance) { ++iterator; } else { - if (iterator != std::begin(aMap)) + if (iterator != std::begin(values)) { --iterator; return iterator; } else { - return std::begin(aMap); + return std::begin(values); } } } --iterator; return iterator; } } } \ No newline at end of file diff --git a/code/algorithms/rttbMeasureInterface.h b/code/algorithms/rttbMeasureInterface.h index 346d53e..d471805 100644 --- a/code/algorithms/rttbMeasureInterface.h +++ b/code/algorithms/rttbMeasureInterface.h @@ -1,55 +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) */ #ifndef __MEASURE_INTERFACE_H #define __MEASURE_INTERFACE_H #include #include #include "rttbBaseType.h" #include "RTTBAlgorithmsExports.h" namespace rttb { namespace algorithms { class RTTBAlgorithms_EXPORT MeasureInterface { public: enum complexStatistics { Dx, Vx, MOHx, MOCx, MaxOHx, MinOCx }; protected: complexStatistics name; public: complexStatistics getName() const; protected: - std::map::const_iterator findNearestKeyInMap(const std::map& aMap, double key) const; + 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.h b/code/algorithms/rttbMinOCxVolumeToDoseMeasureCalculator.h index d9536be..b77c41f 100644 --- a/code/algorithms/rttbMinOCxVolumeToDoseMeasureCalculator.h +++ b/code/algorithms/rttbMinOCxVolumeToDoseMeasureCalculator.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 #include "rttbVolumeToDoseMeasureCalculator.h" namespace rttb { namespace algorithms { class RTTBAlgorithms_EXPORT MinOCxVolumeToDoseMeasureCalculator : public VolumeToDoseMeasureCalculator { private: DoseStatisticType _minimum; DoseStatisticType _maximum; public: 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); - private: + protected: void computeSpecificValue(double xAbsolute); }; } } #endif diff --git a/code/algorithms/rttbVolumeToDoseMeasure.cpp b/code/algorithms/rttbVolumeToDoseMeasure.cpp index 67c5a49..67217f7 100644 --- a/code/algorithms/rttbVolumeToDoseMeasure.cpp +++ b/code/algorithms/rttbVolumeToDoseMeasure.cpp @@ -1,97 +1,69 @@ #include "rttbVolumeToDoseMeasure.h" -#include "rttbDataNotAvailableException.h" #include "rttbInvalidParameterException.h" namespace rttb { namespace algorithms { VolumeToDoseMeasure::VolumeToDoseMeasure(complexStatistics name, VolumeToDoseFunctionType values, VolumeType volume) : name(name), values(values), _volume(volume) {} + void VolumeToDoseMeasure::setVolume(VolumeType volume) + { + this->_volume = volume; + } + void VolumeToDoseMeasure::insertValue(std::pair value) { this->values.insert(value); } DoseTypeGy VolumeToDoseMeasure::getValue(VolumeType xVolumeAbsolute) const { VolumeType dummy; - return getSpecificValue(xVolumeAbsolute, false, dummy); + return getSpecificValue(values, xVolumeAbsolute, false, dummy); } DoseTypeGy VolumeToDoseMeasure::getValue(VolumeType xVolumeAbsolute, bool findNearestValue, VolumeType & nearestXVolume) const { - return getSpecificValue(xVolumeAbsolute, findNearestValue, nearestXVolume); + return getSpecificValue(values, xVolumeAbsolute, findNearestValue, nearestXVolume); } + DoseTypeGy VolumeToDoseMeasure::getValueRelative(VolumeType xVolumeRelative) const { if (xVolumeRelative >= 0 && xVolumeRelative <= 1) { DoseTypeGy xVolumeAbsolute = xVolumeRelative * _volume; VolumeType dummy; - return getSpecificValue(xVolumeAbsolute, false, 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 (xVolumeRelative >= 0 && xVolumeRelative <= 1) { DoseTypeGy xVolumeAbsolute = xVolumeRelative * _volume; - return getSpecificValue(xVolumeAbsolute, findNearestValue, nearestXVolume); + 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; } - void VolumeToDoseMeasure::setVolume(VolumeType volume) - { - this->_volume = volume; - } - - double VolumeToDoseMeasure::getSpecificValue(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"); - } - } - } - } - 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/rttbVolumeToDoseMeasure.h b/code/algorithms/rttbVolumeToDoseMeasure.h index 4e54da7..678e7a1 100644 --- a/code/algorithms/rttbVolumeToDoseMeasure.h +++ b/code/algorithms/rttbVolumeToDoseMeasure.h @@ -1,59 +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 #include "rttbMeasureInterface.h" namespace rttb { namespace algorithms { class RTTBAlgorithms_EXPORT VolumeToDoseMeasure : public MeasureInterface { public: typedef std::map VolumeToDoseFunctionType; private: + VolumeType _volume; complexStatistics name; VolumeToDoseFunctionType values; - VolumeType _volume; public: VolumeToDoseMeasure(complexStatistics name, VolumeToDoseFunctionType values = std::map(), VolumeType volume = -1); + + void setVolume(VolumeType volume); void insertValue(std::pair value); + + /*! @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); - void setVolume(VolumeType volume); - private: - double getSpecificValue(double key, bool findNearestValueInstead, double& storedKey) const; }; } } #endif diff --git a/code/algorithms/rttbVolumeToDoseMeasureCalculator.h b/code/algorithms/rttbVolumeToDoseMeasureCalculator.h index 886ffe1..a246278 100644 --- a/code/algorithms/rttbVolumeToDoseMeasureCalculator.h +++ b/code/algorithms/rttbVolumeToDoseMeasureCalculator.h @@ -1,63 +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 __VOLUME_TO_DOSE_MEASURE_CALCULATOR_H #define __VOLUME_TO_DOSE_MEASURE_CALCULATOR_H #include "rttbVolumeToDoseMeasure.h" namespace rttb { namespace algorithms { class RTTBAlgorithms_EXPORT VolumeToDoseMeasureCalculator { public: typedef std::map VolumeToDoseFunctionType; protected: std::vector _doseVector; DoseVoxelVolumeType _currentVoxelVolume; std::vector _voxelProportionVector; private: VolumeType _volume; VolumeToDoseMeasure measure; std::vector _precomputeVolumeValues; public: - VolumeToDoseMeasureCalculator(const std::vector& precomputeVolumeValues, const VolumeType& volume, - const std::vector& doseVector, const std::vector& voxelProportionVector, - const DoseVoxelVolumeType& currentVoxelVolume, VolumeToDoseMeasure::complexStatistics name); + /*! @brief Computes the measure. Algorithm for the specific complex Statistic has to be implemented in the corresponding subclass. + */ void compute(); VolumeToDoseMeasure getMeasure(); - virtual void computeSpecificValue(double xAbsolute) = 0; protected: + VolumeToDoseMeasureCalculator(const std::vector& precomputeVolumeValues, const VolumeType& volume, + const std::vector& doseVector, const std::vector& voxelProportionVector, + const DoseVoxelVolumeType& currentVoxelVolume, VolumeToDoseMeasure::complexStatistics name); void insertIntoMeasure(VolumeType xAbsolute, DoseTypeGy resultDose); + virtual void computeSpecificValue(double xAbsolute) = 0; }; } } #endif diff --git a/code/algorithms/rttbVxDoseToVolumeMeasureCalculator.cpp b/code/algorithms/rttbVxDoseToVolumeMeasureCalculator.cpp index 554fe04..ede6240 100644 --- a/code/algorithms/rttbVxDoseToVolumeMeasureCalculator.cpp +++ b/code/algorithms/rttbVxDoseToVolumeMeasureCalculator.cpp @@ -1,33 +1,33 @@ #include "rttbVxDoseToVolumeMeasureCalculator.h" namespace rttb { namespace algorithms { - VxDoseToVolumeMeasureCalculator::VxDoseToVolumeMeasureCalculator(const std::vector& precomputeVolumeValues, + VxDoseToVolumeMeasureCalculator::VxDoseToVolumeMeasureCalculator(const std::vector& precomputeDoseValues, const DoseTypeGy& referenceDose, const core::DoseIteratorInterface::DoseIteratorPointer doseIterator, DoseToVolumeMeasure::complexStatistics name) : - DoseToVolumeMeasureCalculator(precomputeVolumeValues, referenceDose, doseIterator, name) {} + DoseToVolumeMeasureCalculator(precomputeDoseValues, referenceDose, doseIterator, name) {} void VxDoseToVolumeMeasureCalculator::computeSpecificValue(double xAbsolute) { rttb::FractionType count = 0; _doseIterator->reset(); DoseTypeGy currentDose = 0; while (_doseIterator->isPositionValid()) { currentDose = _doseIterator->getCurrentDoseValue(); if (currentDose >= xAbsolute) { count += _doseIterator->getCurrentRelevantVolumeFraction(); } _doseIterator->next(); } insertIntoMeasure(xAbsolute, count * this->_doseIterator->getCurrentVoxelVolume()); } } } \ No newline at end of file diff --git a/code/algorithms/rttbVxDoseToVolumeMeasureCalculator.h b/code/algorithms/rttbVxDoseToVolumeMeasureCalculator.h index f559ebe..b9d8821 100644 --- a/code/algorithms/rttbVxDoseToVolumeMeasureCalculator.h +++ b/code/algorithms/rttbVxDoseToVolumeMeasureCalculator.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" namespace rttb { namespace algorithms { class RTTBAlgorithms_EXPORT VxDoseToVolumeMeasureCalculator : public DoseToVolumeMeasureCalculator { private: DoseStatisticType _minimum; public: - VxDoseToVolumeMeasureCalculator(const std::vector& precomputeVolumeValues, + VxDoseToVolumeMeasureCalculator(const std::vector& precomputeDoseValues, const DoseTypeGy& referenceDose, const core::DoseIteratorInterface::DoseIteratorPointer doseIterator, DoseToVolumeMeasure::complexStatistics name); - private: + protected: void computeSpecificValue(double xAbsolute); }; } } #endif