diff --git a/code/algorithms/rttbDoseToVolumeMeasureCalculator.cpp b/code/algorithms/rttbDoseToVolumeMeasureCalculator.cpp index c2e3b8a..f23ce0b 100644 --- a/code/algorithms/rttbDoseToVolumeMeasureCalculator.cpp +++ b/code/algorithms/rttbDoseToVolumeMeasureCalculator.cpp @@ -1,47 +1,49 @@ #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::computeSpecificValue, this, _precomputeDoseValues.at(i) * _referenceDose)); + threads.push_back(boost::thread(&DoseToVolumeMeasureCalculator::insertIntoMeasure, this , xAbsolute, computeSpecificValue(xAbsolute))); } else { - this->computeSpecificValue(_precomputeDoseValues.at(i) * _referenceDose); + + insertIntoMeasure(xAbsolute, this->computeSpecificValue(xAbsolute)); } } for (unsigned int i = 0; i(xAbsolute, resultVolume)); } } } diff --git a/code/algorithms/rttbDoseToVolumeMeasureCalculator.h b/code/algorithms/rttbDoseToVolumeMeasureCalculator.h index 02cb56a..67a02fe 100644 --- a/code/algorithms/rttbDoseToVolumeMeasureCalculator.h +++ b/code/algorithms/rttbDoseToVolumeMeasureCalculator.h @@ -1,72 +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 _precomputeDoseValues; public: /*! @brief Computes the measure. Algorithm for the specific complex Statistic has to be implemented in the corresponding subclass. */ void compute(); DoseToVolumeMeasure getMeasure(); 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; + virtual VolumeType computeSpecificValue(double xAbsolute) const = 0; }; } } #endif diff --git a/code/algorithms/rttbDxVolumeToDoseMeasureCalculator.cpp b/code/algorithms/rttbDxVolumeToDoseMeasureCalculator.cpp index 0befc90..6706926 100644 --- a/code/algorithms/rttbDxVolumeToDoseMeasureCalculator.cpp +++ b/code/algorithms/rttbDxVolumeToDoseMeasureCalculator.cpp @@ -1,38 +1,38 @@ #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, + 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) {} - void DxVolumeToDoseMeasureCalculator::computeSpecificValue(double xAbsolute) + 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; } - insertIntoMeasure(xAbsolute, resultDose); + return resultDose; } } } \ No newline at end of file diff --git a/code/algorithms/rttbDxVolumeToDoseMeasureCalculator.h b/code/algorithms/rttbDxVolumeToDoseMeasureCalculator.h index f870966..690f506 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, + 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); + const DoseVoxelVolumeType currentVoxelVolume, const DoseStatisticType minimum, VolumeToDoseMeasure::complexStatistics name); protected: - void computeSpecificValue(double xAbsolute); + DoseTypeGy computeSpecificValue(double xAbsolute) const; }; } } #endif diff --git a/code/algorithms/rttbMOCxVolumeToDoseMeasureCalculator.cpp b/code/algorithms/rttbMOCxVolumeToDoseMeasureCalculator.cpp index 8a0ffd5..e5faa1f 100644 --- a/code/algorithms/rttbMOCxVolumeToDoseMeasureCalculator.cpp +++ b/code/algorithms/rttbMOCxVolumeToDoseMeasureCalculator.cpp @@ -1,41 +1,41 @@ #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, + const VolumeType volume, const std::vector& doseVector, const std::vector& voxelProportionVector, + const DoseVoxelVolumeType currentVoxelVolume, VolumeToDoseMeasure::complexStatistics name) : VolumeToDoseMeasureCalculator(precomputeVolumeValues, volume, doseVector, voxelProportionVector, currentVoxelVolume, name) {} - void MOCxVolumeToDoseMeasureCalculator::computeSpecificValue(double xAbsolute) + DoseTypeGy MOCxVolumeToDoseMeasureCalculator::computeSpecificValue(double xAbsolute) const { double noOfVoxel = xAbsolute / _currentVoxelVolume; if (noOfVoxel == 0) { - return insertIntoMeasure(xAbsolute, 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; } } - insertIntoMeasure(xAbsolute, (DoseTypeGy)(sum / noOfVoxel)); + return (DoseTypeGy)(sum / noOfVoxel); } } } } \ No newline at end of file diff --git a/code/algorithms/rttbMOCxVolumeToDoseMeasureCalculator.h b/code/algorithms/rttbMOCxVolumeToDoseMeasureCalculator.h index fe09aa1..2fa8cf1 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, + MOCxVolumeToDoseMeasureCalculator(const std::vector& precomputeVolumeValues, const VolumeType volume, const std::vector& doseVector, const std::vector& voxelProportionVector, - const DoseVoxelVolumeType& currentVoxelVolume, VolumeToDoseMeasure::complexStatistics name); + const DoseVoxelVolumeType currentVoxelVolume, VolumeToDoseMeasure::complexStatistics name); protected: - void computeSpecificValue(double xAbsolute); + DoseTypeGy computeSpecificValue(double xAbsolute) const; }; } } #endif diff --git a/code/algorithms/rttbMOHxVolumeToDoseMeasureCalculator.cpp b/code/algorithms/rttbMOHxVolumeToDoseMeasureCalculator.cpp index 8567791..7eb677b 100644 --- a/code/algorithms/rttbMOHxVolumeToDoseMeasureCalculator.cpp +++ b/code/algorithms/rttbMOHxVolumeToDoseMeasureCalculator.cpp @@ -1,40 +1,40 @@ #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, + const VolumeType volume, const std::vector& doseVector, const std::vector& voxelProportionVector, + const DoseVoxelVolumeType currentVoxelVolume, VolumeToDoseMeasure::complexStatistics name) : VolumeToDoseMeasureCalculator(precomputeVolumeValues, volume, doseVector, voxelProportionVector, currentVoxelVolume, name) {} - void MOHxVolumeToDoseMeasureCalculator::computeSpecificValue(double xAbsolute) + DoseTypeGy MOHxVolumeToDoseMeasureCalculator::computeSpecificValue(double xAbsolute) const { double noOfVoxel = xAbsolute / _currentVoxelVolume; if (noOfVoxel == 0) { - return insertIntoMeasure(xAbsolute, 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; } } - insertIntoMeasure(xAbsolute, (DoseTypeGy)(sum / noOfVoxel)); + return (DoseTypeGy)(sum / noOfVoxel); } } } } \ No newline at end of file diff --git a/code/algorithms/rttbMOHxVolumeToDoseMeasureCalculator.h b/code/algorithms/rttbMOHxVolumeToDoseMeasureCalculator.h index b4c1f90..6d35036 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, + MOHxVolumeToDoseMeasureCalculator(const std::vector& precomputeVolumeValues, const VolumeType volume, const std::vector& doseVector, const std::vector& voxelProportionVector, - const DoseVoxelVolumeType& currentVoxelVolume, VolumeToDoseMeasure::complexStatistics name); + const DoseVoxelVolumeType currentVoxelVolume, VolumeToDoseMeasure::complexStatistics name); protected: - void computeSpecificValue(double xAbsolute); + DoseTypeGy computeSpecificValue(double xAbsolute) const; }; } } #endif diff --git a/code/algorithms/rttbMaxOHxVolumeToDoseMeasureCalculator.cpp b/code/algorithms/rttbMaxOHxVolumeToDoseMeasureCalculator.cpp index 2c38f51..0ff0b5f 100644 --- a/code/algorithms/rttbMaxOHxVolumeToDoseMeasureCalculator.cpp +++ b/code/algorithms/rttbMaxOHxVolumeToDoseMeasureCalculator.cpp @@ -1,35 +1,35 @@ #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, + const VolumeType volume, const std::vector& doseVector, const std::vector& voxelProportionVector, + const DoseVoxelVolumeType currentVoxelVolume, VolumeToDoseMeasure::complexStatistics name) : VolumeToDoseMeasureCalculator(precomputeVolumeValues, volume, doseVector, voxelProportionVector, currentVoxelVolume, name) {} - void MaxOHxVolumeToDoseMeasureCalculator::computeSpecificValue(double xAbsolute) + 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; } } - insertIntoMeasure(xAbsolute, resultDose); + return resultDose; } } } \ No newline at end of file diff --git a/code/algorithms/rttbMaxOHxVolumeToDoseMeasureCalculator.h b/code/algorithms/rttbMaxOHxVolumeToDoseMeasureCalculator.h index 51c94a6..1918bac 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, + MaxOHxVolumeToDoseMeasureCalculator(const std::vector& precomputeVolumeValues, const VolumeType volume, const std::vector& doseVector, const std::vector& voxelProportionVector, - const DoseVoxelVolumeType& currentVoxelVolume, VolumeToDoseMeasure::complexStatistics name); + const DoseVoxelVolumeType currentVoxelVolume, VolumeToDoseMeasure::complexStatistics name); protected: - void computeSpecificValue(double xAbsolute); + DoseTypeGy computeSpecificValue(double xAbsolute) const; }; } } #endif diff --git a/code/algorithms/rttbMeasureInterface.h b/code/algorithms/rttbMeasureInterface.h index d471805..d7f15df 100644 --- a/code/algorithms/rttbMeasureInterface.h +++ b/code/algorithms/rttbMeasureInterface.h @@ -1,56 +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 -#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: 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 index 90db490..fde483c 100644 --- a/code/algorithms/rttbMinOCxVolumeToDoseMeasureCalculator.cpp +++ b/code/algorithms/rttbMinOCxVolumeToDoseMeasureCalculator.cpp @@ -1,51 +1,51 @@ #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, + 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) {} - void MinOCxVolumeToDoseMeasureCalculator::computeSpecificValue(double xAbsolute) + 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; } - insertIntoMeasure(xAbsolute, resultDose); + return resultDose; } } } \ No newline at end of file diff --git a/code/algorithms/rttbMinOCxVolumeToDoseMeasureCalculator.h b/code/algorithms/rttbMinOCxVolumeToDoseMeasureCalculator.h index b77c41f..9371c72 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, + 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); + const DoseVoxelVolumeType currentVoxelVolume, const DoseStatisticType minimum, const DoseStatisticType maximum, VolumeToDoseMeasure::complexStatistics name); protected: - void computeSpecificValue(double xAbsolute); + DoseTypeGy computeSpecificValue(double xAbsolute) const; }; } } #endif diff --git a/code/algorithms/rttbVolumeToDoseMeasureCalculator.cpp b/code/algorithms/rttbVolumeToDoseMeasureCalculator.cpp index 92b7e6f..4f9a533 100644 --- a/code/algorithms/rttbVolumeToDoseMeasureCalculator.cpp +++ b/code/algorithms/rttbVolumeToDoseMeasureCalculator.cpp @@ -1,47 +1,48 @@ #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, + 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::computeSpecificValue, this, _precomputeVolumeValues.at(i) * _volume)); + threads.push_back(boost::thread(&VolumeToDoseMeasureCalculator::insertIntoMeasure, this, xAbsolute, computeSpecificValue(xAbsolute))); } else { - this->computeSpecificValue(_precomputeVolumeValues.at(i) * _volume); + insertIntoMeasure(xAbsolute, this->computeSpecificValue(xAbsolute)); } } for (unsigned int i = 0; i(xAbsolute, resultDose)); } } } diff --git a/code/algorithms/rttbVolumeToDoseMeasureCalculator.h b/code/algorithms/rttbVolumeToDoseMeasureCalculator.h index a246278..6c78bbf 100644 --- a/code/algorithms/rttbVolumeToDoseMeasureCalculator.h +++ b/code/algorithms/rttbVolumeToDoseMeasureCalculator.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 __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: /*! @brief Computes the measure. Algorithm for the specific complex Statistic has to be implemented in the corresponding subclass. */ void compute(); VolumeToDoseMeasure getMeasure(); protected: - VolumeToDoseMeasureCalculator(const std::vector& precomputeVolumeValues, const VolumeType& volume, + VolumeToDoseMeasureCalculator(const std::vector& precomputeVolumeValues, const VolumeType volume, const std::vector& doseVector, const std::vector& voxelProportionVector, - const DoseVoxelVolumeType& currentVoxelVolume, VolumeToDoseMeasure::complexStatistics name); + const DoseVoxelVolumeType currentVoxelVolume, VolumeToDoseMeasure::complexStatistics name); void insertIntoMeasure(VolumeType xAbsolute, DoseTypeGy resultDose); - virtual void computeSpecificValue(double xAbsolute) = 0; + virtual DoseTypeGy computeSpecificValue(double xAbsolute) const = 0; }; } } #endif diff --git a/code/algorithms/rttbVxDoseToVolumeMeasureCalculator.cpp b/code/algorithms/rttbVxDoseToVolumeMeasureCalculator.cpp index ede6240..d1fed6c 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& precomputeDoseValues, - const DoseTypeGy& referenceDose, const core::DoseIteratorInterface::DoseIteratorPointer doseIterator, DoseToVolumeMeasure::complexStatistics name) : + const DoseTypeGy referenceDose, const core::DoseIteratorInterface::DoseIteratorPointer doseIterator, DoseToVolumeMeasure::complexStatistics name) : DoseToVolumeMeasureCalculator(precomputeDoseValues, referenceDose, doseIterator, name) {} - void VxDoseToVolumeMeasureCalculator::computeSpecificValue(double xAbsolute) + 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(); } - insertIntoMeasure(xAbsolute, count * this->_doseIterator->getCurrentVoxelVolume()); + return count * this->_doseIterator->getCurrentVoxelVolume(); } } } \ No newline at end of file diff --git a/code/algorithms/rttbVxDoseToVolumeMeasureCalculator.h b/code/algorithms/rttbVxDoseToVolumeMeasureCalculator.h index b9d8821..47b43a4 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& precomputeDoseValues, - const DoseTypeGy& referenceDose, const core::DoseIteratorInterface::DoseIteratorPointer doseIterator, DoseToVolumeMeasure::complexStatistics name); + const DoseTypeGy referenceDose, const core::DoseIteratorInterface::DoseIteratorPointer doseIterator, DoseToVolumeMeasure::complexStatistics name); protected: - void computeSpecificValue(double xAbsolute); + VolumeType computeSpecificValue(double xAbsolute) const; }; } } #endif