diff --git a/code/algorithms/rttbDxVolumeToDoseMeasureCalculator.cpp b/code/algorithms/rttbDxVolumeToDoseMeasureCalculator.cpp new file mode 100644 index 0000000..7dd1fee --- /dev/null +++ b/code/algorithms/rttbDxVolumeToDoseMeasureCalculator.cpp @@ -0,0 +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) : VolumeToDoseMeasureCalculator(precomputeVolumeValues, volume, + doseVector, voxelProportionVector, currentVoxelVolume), _minimum(minimum) {} + + void rttb::algorithms::DxVolumeToDoseMeasureCalculator::computeSpecificValue(double xAbsolute) + { + 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); + } +} +} \ No newline at end of file diff --git a/code/algorithms/rttbDxVolumeToDoseMeasureCalculator.h b/code/algorithms/rttbDxVolumeToDoseMeasureCalculator.h new file mode 100644 index 0000000..a3dfbbf --- /dev/null +++ b/code/algorithms/rttbDxVolumeToDoseMeasureCalculator.h @@ -0,0 +1,58 @@ +// ----------------------------------------------------------------------- +// RTToolbox - DKFZ radiotherapy quantitative evaluation library +// +// Copyright (c) German Cancer Research Center (DKFZ), +// Software development for Integrated Diagnostics and Therapy (SIDT). +// ALL RIGHTS RESERVED. +// See rttbCopyright.txt or +// http://www.dkfz.de/en/sidt/projects/rttb/copyright.html +// +// This software is distributed WITHOUT ANY WARRANTY; without even +// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +// PURPOSE. See the above copyright notices for more information. +// +//------------------------------------------------------------------------ +/*! +// @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 +#include + +#include "rttbBaseType.h" + + +#include "RTTBAlgorithmsExports.h" +#include "rttbvolumetodosemeasureCalculator.h" +#include "rttbvolumetodosemeasure.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); + + private: + void computeSpecificValue(double xAbsolute); + }; + } +} + + +#endif +#pragma once diff --git a/code/algorithms/rttbVolumeToDoseMeasure.cpp b/code/algorithms/rttbVolumeToDoseMeasure.cpp new file mode 100644 index 0000000..3091107 --- /dev/null +++ b/code/algorithms/rttbVolumeToDoseMeasure.cpp @@ -0,0 +1,127 @@ +#include "rttbVolumeToDoseMeasure.h" +#include "rttbDataNotAvailableException.h" +#include "rttbInvalidParameterException.h" + +namespace rttb +{ + + namespace algorithms + { + VolumeToDoseMeasure::VolumeToDoseMeasure(DoseStatistics::complexStatistics name, VolumeToDoseFunctionType values) : + name(name), values(values) {} + + DoseStatistics::complexStatistics VolumeToDoseMeasure::getName() + { + return this->name; + } + + void VolumeToDoseMeasure::insertValue(std::pair value) + { + this->values.insert(value); + } + + DoseTypeGy VolumeToDoseMeasure::getValue(VolumeType xVolumeAbsolute) + { + VolumeType dummy; + return getValue(xVolumeAbsolute, false, dummy); + return DoseTypeGy(); + } + DoseTypeGy VolumeToDoseMeasure::getValue(VolumeType xVolumeAbsolute, bool findNearestValue, VolumeType & nearestXVolume) + { + return getValue(xVolumeAbsolute, findNearestValue, nearestXVolume); + return DoseTypeGy(); + } + DoseTypeGy VolumeToDoseMeasure::getValueRelative(VolumeType xVolumeRelative) + { + if (xVolumeRelative >= 0 && xVolumeRelative <= 1) { + DoseTypeGy xVolumeAbsolute = xVolumeRelative*_volume; + VolumeType dummy; + return getValue(xVolumeAbsolute, false, dummy); + } + else { + throw rttb::core::InvalidParameterException("Relative Volume must be >= 0 and <=1"); + } + return DoseTypeGy(); + } + DoseTypeGy VolumeToDoseMeasure::getValueRelative(VolumeType xVolumeRelative, bool findNearestValue, VolumeType & nearestXVolume) + { + if (xVolumeRelative >= 0 && xVolumeRelative <= 1) { + DoseTypeGy xVolumeAbsolute = xVolumeRelative*_volume; + return getValue(xVolumeAbsolute, findNearestValue, nearestXVolume); + } + else { + throw rttb::core::InvalidParameterException("Relative Volume must be >= 0 and <=1"); + } + return DoseTypeGy(); + } + VolumeToDoseMeasure::VolumeToDoseFunctionType VolumeToDoseMeasure::getAllValues() + { + return this->values; + } + + double VolumeToDoseMeasure::getValue(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 VolumeToDoseMeasure::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; + } + } +} diff --git a/code/algorithms/rttbVolumeToDoseMeasure.h b/code/algorithms/rttbVolumeToDoseMeasure.h new file mode 100644 index 0000000..e14e7f3 --- /dev/null +++ b/code/algorithms/rttbVolumeToDoseMeasure.h @@ -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) +*/ + +#ifndef __VOLUME_TO_DOSE_MEASURE_H +#define __VOLUME_TO_DOSE_MEASURE_H + +#include +#include + +#include "boost/shared_ptr.hpp" + +#include "rttbBaseType.h" + +#include "RTTBAlgorithmsExports.h" + +#include "rttbDoseStatistics.h" + +namespace rttb +{ + + namespace algorithms + { + class RTTBAlgorithms_EXPORT VolumeToDoseMeasure { + + public: + typedef std::map VolumeToDoseFunctionType; + + private: + DoseStatistics::complexStatistics name; + VolumeToDoseFunctionType values; + + public: + VolumeToDoseMeasure(DoseStatistics::complexStatistics name, VolumeToDoseFunctionType values); + DoseStatistics::complexStatistics getName(); + void insertValue(std::pair value); + DoseTypeGy getValue(VolumeType xVolumeAbsolute); + DoseTypeGy getValue(VolumeType xVolumeAbsolute, bool findNearestValue, VolumeType& nearestXDose); + DoseTypeGy getValueRelative(VolumeType xDoseRelative); + DoseTypeGy getValueRelative(VolumeType xDoseRelative, bool findNearestValue, VolumeType& nearestXDose); + VolumeToDoseFunctionType getAllValues(); + + private: + double getValue(double key, bool findNearestValueInstead, double& storedKey) const; + std::map::const_iterator findNearestKeyInMap(const std::map& aMap, double key) const; + }; + + } +} + + +#endif +#pragma once diff --git a/code/algorithms/rttbVolumeToDoseMeasureCalculator.cpp b/code/algorithms/rttbVolumeToDoseMeasureCalculator.cpp new file mode 100644 index 0000000..c236107 --- /dev/null +++ b/code/algorithms/rttbVolumeToDoseMeasureCalculator.cpp @@ -0,0 +1,46 @@ +#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) : + measure(VolumeToDoseMeasure(DoseStatistics::Dx, std::map())), _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) + { + if (false)//_multiThreading) + { + threads.push_back(boost::thread(&VolumeToDoseMeasureCalculator::computeSpecificValue, this, _precomputeVolumeValues.at(i) * _volume)); + } + else + { + this->computeSpecificValue(_precomputeVolumeValues.at(i) * _volume); + } + } + + for (unsigned int i = 0; i(xAbsolute, resultDose)); + } + } +} diff --git a/code/algorithms/rttbVolumeToDoseMeasureCalculator.h b/code/algorithms/rttbVolumeToDoseMeasureCalculator.h new file mode 100644 index 0000000..535a87d --- /dev/null +++ b/code/algorithms/rttbVolumeToDoseMeasureCalculator.h @@ -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) +*/ + +#ifndef __VOLUME_TO_DOSE_MEASURE_CALCULATOR_H +#define __VOLUME_TO_DOSE_MEASURE_CALCULATOR_H + +#include +#include + +#include "rttbBaseType.h" + + +#include "RTTBAlgorithmsExports.h" +#include "rttbVolumeToDoseMeasure.h" + +namespace rttb +{ + + namespace algorithms + { + class RTTBAlgorithms_EXPORT VolumeToDoseMeasureCalculator { + + public: + typedef DoseStatistics::VolumeToDoseFunctionType 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); + void compute(); + VolumeToDoseMeasure getMeasure(); + virtual void computeSpecificValue(double xAbsolute) = 0; + + protected: + void insertIntoMeasure(VolumeType xAbsolute, DoseTypeGy resultDose); + }; + + } +} + + +#endif +#pragma once