diff --git a/code/algorithms/rttbDoseStatistics.h b/code/algorithms/rttbDoseStatistics.h
index d6a8e6b..6bd70bb 100644
--- a/code/algorithms/rttbDoseStatistics.h
+++ b/code/algorithms/rttbDoseStatistics.h
@@ -1,170 +1,178 @@
// -----------------------------------------------------------------------
// RTToolbox - DKFZ radiotherapy quantitative evaluation library
//
// Copyright (c) German Cancer Research Center (DKFZ),
// Software development for Integrated Diagnostics and Therapy (SIDT).
// ALL RIGHTS RESERVED.
// See rttbCopyright.txt or
// http://www.dkfz.de/en/sidt/projects/rttb/copyright.html
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notices for more information.
//
//------------------------------------------------------------------------
/*!
// @file
// @version $Revision$ (last changed revision)
// @date $Date$ (last change date)
// @author $Author$ (last changed by)
*/
#ifndef __DOSE_STATISTICS_H
#define __DOSE_STATISTICS_H
#include <vector>
#include <map>
#include <rttbCommon.h>
#include <boost/make_shared.hpp>
#include "rttbBaseType.h"
#include "RTTBAlgorithmsExports.h"
#include "rttbVolumeToDoseMeasureCollection.h"
#include "rttbDoseToVolumeMeasureCollection.h"
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4251)
+#endif
+
namespace rttb
{
namespace algorithms
{
/*! @class DoseStatistics
@brief This is a data class storing different statistical values from a rt dose distribution
@sa DoseStatisticsCalculator
*/
class RTTBAlgorithms_EXPORT DoseStatistics
{
public:
rttbClassMacroNoParent(DoseStatistics);
typedef boost::shared_ptr<std::vector<std::pair<DoseTypeGy, VoxelGridID> > > ResultListPointer;
private:
double getValue(const std::map<double, double>& aMap, double key, bool findNearestValueInstead,
double& storedKey) const;
std::map<double, double>::const_iterator findNearestKeyInMap(const std::map<double, double>& aMap,
double key) const;
DoseStatisticType _minimum;
DoseStatisticType _maximum;
DoseStatisticType _mean;
DoseStatisticType _stdDeviation;
VoxelNumberType _numVoxels;
VolumeType _volume;
ResultListPointer _minimumVoxelPositions;
ResultListPointer _maximumVoxelPositions;
VolumeToDoseMeasureCollection::Pointer _Dx;
DoseToVolumeMeasureCollection::Pointer _Vx;
VolumeToDoseMeasureCollection::Pointer _MOHx;
VolumeToDoseMeasureCollection::Pointer _MOCx;
VolumeToDoseMeasureCollection::Pointer _MaxOHx;
VolumeToDoseMeasureCollection::Pointer _MinOCx;
DoseTypeGy _referenceDose; //for Vx computation
public:
/*! @brief Standard Constructor
*/
//DoseStatistics();
/*! @brief Constructor
@details the dose statistic values are set. Complex values maximumVoxelLocation, maximumVoxelLocation, Dx, Vx, MOHx, MOCx, MaxOHx and MinOCx are optional
*/
DoseStatistics(DoseStatisticType minimum, DoseStatisticType maximum, DoseStatisticType mean,
DoseStatisticType stdDeviation, VoxelNumberType numVoxels, VolumeType volume,
ResultListPointer minimumVoxelPositions = nullptr,
ResultListPointer maximumVoxelPositions = nullptr,
VolumeToDoseMeasureCollection Dx = VolumeToDoseMeasureCollection(VolumeToDoseMeasureCollection::Dx),
DoseToVolumeMeasureCollection Vx = DoseToVolumeMeasureCollection(DoseToVolumeMeasureCollection::Vx),
VolumeToDoseMeasureCollection MOHx = VolumeToDoseMeasureCollection(VolumeToDoseMeasureCollection::MOHx),
VolumeToDoseMeasureCollection MOCx = VolumeToDoseMeasureCollection(VolumeToDoseMeasureCollection::MOCx),
VolumeToDoseMeasureCollection MaxOHx = VolumeToDoseMeasureCollection(VolumeToDoseMeasureCollection::MaxOHx),
VolumeToDoseMeasureCollection MinOCx = VolumeToDoseMeasureCollection(VolumeToDoseMeasureCollection::MinOCx),
DoseTypeGy referenceDose = -1);
~DoseStatistics();
void setMinimumVoxelPositions(ResultListPointer minimumVoxelPositions);
void setMaximumVoxelPositions(ResultListPointer maximumVoxelPositions);
void setDx(VolumeToDoseMeasureCollection::Pointer DxValues);
void setVx(DoseToVolumeMeasureCollection::Pointer VxValues);
void setMOHx(VolumeToDoseMeasureCollection::Pointer MOHxValues);
void setMOCx(VolumeToDoseMeasureCollection::Pointer MOCxValues);
void setMaxOHx(VolumeToDoseMeasureCollection::Pointer MaxOHxValues);
void setMinOCx(VolumeToDoseMeasureCollection::Pointer MinOCxValues);
void setReferenceDose(DoseTypeGy referenceDose);
/*! @brief Get number of voxels in doseIterator, with sub-voxel accuracy.
*/
VoxelNumberType getNumberOfVoxels() const;
/*! @brief Get the volume of the voxels in doseIterator (in cm3), with sub-voxel accuracy
*/
VolumeType getVolume() const;
/*! @brief Get the reference dose for Vx computation
*/
DoseTypeGy getReferenceDose() const;
/*! @brief Get the maximum of the current dose distribution.
@return Return the maximum dose in Gy
*/
DoseStatisticType getMaximum() const;
/*! @brief Get a vector of the the maximum dose VoxelGridIDs together with their dose value in Gy
@exception InvalidDoseException if the vector has not been set (i.e. is empty)
*/
ResultListPointer getMaximumVoxelPositions() const;
/*! @brief Get the minimum of the current dose distribution.
@return Return the minimum dose in Gy
*/
DoseStatisticType getMinimum() const;
/*! @brief Get a vector of the the minimum dose VoxelGridIDs together with their dose value in Gy
@exception InvalidDoseException if the vector has not been set (i.e. is empty)
*/
ResultListPointer getMinimumVoxelPositions() const;
/*! @brief Get the mean of the current dose distribution.
@return Return the mean dose in Gy
*/
DoseStatisticType getMean() const;
/*! @brief Get the standard deviation of the current dose distribution.
@return Return the standard deviation in Gy
*/
DoseStatisticType getStdDeviation() const;
/*! @brief Get the variance of of the current dose distribution.
@return Return the variance in Gy
*/
DoseStatisticType getVariance() const;
VolumeToDoseMeasureCollection getDx() const;
DoseToVolumeMeasureCollection getVx() const;
VolumeToDoseMeasureCollection getMOHx() const;
VolumeToDoseMeasureCollection getMOCx() const;
VolumeToDoseMeasureCollection getMaxOHx() const;
VolumeToDoseMeasureCollection getMinOCx() const;
};
}
}
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
#endif
diff --git a/code/algorithms/rttbDoseStatisticsCalculator.h b/code/algorithms/rttbDoseStatisticsCalculator.h
index a66091f..431850a 100644
--- a/code/algorithms/rttbDoseStatisticsCalculator.h
+++ b/code/algorithms/rttbDoseStatisticsCalculator.h
@@ -1,199 +1,207 @@
// -----------------------------------------------------------------------
// RTToolbox - DKFZ radiotherapy quantitative evaluation library
//
// Copyright (c) German Cancer Research Center (DKFZ),
// Software development for Integrated Diagnostics and Therapy (SIDT).
// ALL RIGHTS RESERVED.
// See rttbCopyright.txt or
// http://www.dkfz.de/en/sidt/projects/rttb/copyright.html
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notices for more information.
//
//------------------------------------------------------------------------
/*!
// @file
// @version $Revision$ (last changed revision)
// @date $Date$ (last change date)
// @author $Author$ (last changed by)
*/
#ifndef __DOSE_STATISTICS_CALCULATOR_H
#define __DOSE_STATISTICS_CALCULATOR_H
#include <vector>
#include <boost/shared_ptr.hpp>
#include <boost/thread/shared_mutex.hpp>
#include "rttbDoseIteratorInterface.h"
#include "rttbDoseStatistics.h"
#include "RTTBAlgorithmsExports.h"
#include "rttbDxVolumeToDoseMeasureCollectionCalculator.h"
#include "rttbVxDoseToVolumeMeasureCollectionCalculator.h"
#include "rttbMOHxVolumeToDoseMeasureCollectionCalculator.h"
#include "rttbMOCxVolumeToDoseMeasureCollectionCalculator.h"
#include "rttbMaxOHxVolumeToDoseMeasureCollectionCalculator.h"
#include "rttbMinOCxVolumeToDoseMeasureCollectionCalculator.h"
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4251)
+#endif
+
namespace rttb
{
namespace algorithms
{
/*! @class DoseStatisticsCalculator
@brief Class for calculating different statistical values from a RT dose distribution
@details These values range from standard statistical values such as minimum, maximum and mean to more
complex dose specific measures such as Vx (volume irradiated with a dose >=x), Dx (minimal dose delivered
to x% of the VOI) or MOHx (mean in the hottest volume). For a complete list, see calculateDoseStatistics().
@note the complex dose statistics are precomputed and cannot be computed "on the fly" lateron! The doses/volumes that should be used for precomputation have to be set in calculateDoseStatistics()
*/
class RTTBAlgorithms_EXPORT DoseStatisticsCalculator
{
public:
using DoseIteratorPointer = core::DoseIteratorInterface::Pointer;
using ResultListPointer = DoseStatistics::ResultListPointer;
using DoseStatisticsPointer = DoseStatistics::Pointer;
private:
DoseIteratorPointer _doseIterator;
/*! @brief Contains relevant dose values sorted in descending order.
*/
std::vector<DoseTypeGy> _doseVector;
/*! @brief Contains the corresponding voxel proportions to the values in doseVector.
*/
std::vector<double> _voxelProportionVector;
/*! @brief The doseStatistics are stored here.
*/
DoseStatisticsPointer _statistics;
bool _simpleDoseStatisticsCalculated;
bool _complexDoseStatisticsCalculated;
bool _multiThreading;
::boost::shared_ptr<boost::shared_mutex> _mutex;
VxDoseToVolumeMeasureCollectionCalculator::Pointer _Vx;
DxVolumeToDoseMeasureCollectionCalculator::Pointer _Dx;
MOHxVolumeToDoseMeasureCollectionCalculator::Pointer _MOHx;
MOCxVolumeToDoseMeasureCollectionCalculator::Pointer _MOCx;
MaxOHxVolumeToDoseMeasureCollectionCalculator::Pointer _MaxOHx;
MinOCxVolumeToDoseMeasureCollectionCalculator::Pointer _MinOCx;
/*! @brief Calculates the positions where the dose has its maximum
@param maxNumberMaximaPositions the maximal amount of computed positions
@pre maximumDose must be defined in _statistics with the correct value
*/
ResultListPointer computeMaximumPositions(unsigned int maxNumberMaximaPositions) const;
/*! @brief Calculates the positions where the dose has its minimum
@param maxNumberMinimaPositions the maximal amount of computed positions (they are read sequentially using the iterator until maxNumberMinimaPositions have been read, other positions are not considered)
@pre minimumDose must be defined in _statistics with the correct value
*/
ResultListPointer computeMinimumPositions(unsigned int maxNumberMinimaPositions) const;
/*! @brief Calculates simple dose statistics (min, mean, max, stdDev, minDosePositions, maxDosePositions)
@param maxNumberMinimaPositions the maximal amount of computed positions where the dose has its minimum that is computed
@param maxNumberMaximaPositions the maximal amount of computed positions where the dose has its maximum that is computed
*/
void calculateSimpleDoseStatistics(unsigned int maxNumberMinimaPositions,
unsigned int maxNumberMaximaPositions);
/*! @brief Calculates complex dose statistics (Dx, Vx, MOHx, MOCx, MaxOHx, MinOCx)
@warning computations can take quite long (>1 min) for large structures as many statistics are precomputed
*/
void calculateComplexDoseStatistics(DoseTypeGy referenceDose,
const std::vector<double>& precomputeDoseValues,
const std::vector<double>& precomputeVolumeValues);
public:
~DoseStatisticsCalculator();
/*! @brief Constructor
@param aDoseIterator the dose to be analyzed
*/
DoseStatisticsCalculator(DoseIteratorPointer aDoseIterator);
DoseIteratorPointer getDoseIterator() const;
/*! @brief Compute simple or complex dose statistics with default relative x values and the maximum dose as default reference dose (for Vx computation)
@details The following statistics are calculated always (i.e. also if computeComplexMeasures=false):
<ul>
<li>minimum dose
<li>mean dose
<li>maximum dose
<li>standard deviation dose
<li>voxel positions of minimum dose
<li>voxel positions of maximum dose
</ul>
Additionally, these statistics are computed if computeComplexMeasures=true:
<ul>
<li>Dx (the minimal dose delivered to a volume >= x)
<li>Vx (the volume irradiated with a dose >= x)
<li>MOHx (mean dose of the hottest x volume)
<li>MOCx (mean dose of the coldest x volume)
<li>MaxOHx (Maximum outside of the hottest x volume)
<li>MinOCx (Minimum outside of the coldest x volume)
</ul>
Default x values for Vx are 0.02, 0.05, 0.1, 0.9, 0.95 and 0.98, with respect to maxDose.
Default x values for Dx, MOHx, MOCx, MaxOHx and MinOCx are 0.02, 0.05, 0.1, 0.9, 0.95 and 0.98, with respect to volume.
@param computeComplexMeasures should complex statistics be calculated? If it is true, the complex dose statistics will be calculated with default relative x values and the maximum dose as reference dose
@param maxNumberMinimaPositions the maximal amount of computed positions where the dose has its minimum that is computed
@param maxNumberMaximaPositions the maximal amount of computed positions where the dose has its maximum that is computed
@warning If computeComplexMeasures==true, computations can take quite long (>1 min) for large structures as many statistics are precomputed
@note The complex dose statistics are precomputed and cannot be computed "on the fly" lateron! Only the default x values can be requested in DoseStatistics!
*/
DoseStatisticsPointer calculateDoseStatistics(bool computeComplexMeasures = false,
unsigned int maxNumberMinimaPositions = 10,
unsigned int maxNumberMaximaPositions = 10);
/*! @brief Compute complex dose statistics with given reference dose and default relative x values
@param referenceDose the reference dose to compute Vx, normally it should be the prescribed dose
@param maxNumberMinimaPositions the maximal amount of computed positions where the dose has its minimum that is computed
@param maxNumberMaximaPositions the maximal amount of computed positions where the dose has its maximum that is computed
@exception InvalidParameterException thrown if referenceDose <= 0
@warning Computations can take quite long (>1 min) for large structures as many statistics are precomputed
@note The complex dose statistics are precomputed and cannot be computed "on the fly" lateron! Only the default x values can be requested in DoseStatistics!
*/
DoseStatisticsPointer calculateDoseStatistics(DoseTypeGy referenceDose,
unsigned int maxNumberMinimaPositions = 10,
unsigned int maxNumberMaximaPositions = 10);
/*! @brief Compute complex dose statistics with given relative x values and reference dose
@param precomputeDoseValues the relative dose values for Vx precomputation, e.g. 0.02, 0.05, 0.95...
@param precomputeVolumeValues the relative volume values for Dx, MOHx, MOCx, MaxOHx and MinOCx precomputation, e.g. 0.02, 0.05, 0.95...
@param referenceDose the reference dose to compute Vx, normally it should be the prescribed dose. Default value is the maximum dose.
@param maxNumberMinimaPositions the maximal amount of computed positions where the dose has its minimum that is computed
@param maxNumberMaximaPositions the maximal amount of computed positions where the dose has its maximum that is computed
@warning Computations can take quite long (>1 min) for large structures as many statistics are precomputed
@note The complex dose statistics are precomputed and cannot be computed "on the fly" lateron! The doses/volumes that should be used for precomputation have to be set by in precomputeDoseValues and precomputeVolumeValues. Only these values can be requested in DoseStatistics!
*/
DoseStatisticsPointer calculateDoseStatistics(const std::vector<double>& precomputeDoseValues,
const std::vector<double>& precomputeVolumeValues, DoseTypeGy referenceDose = -1,
unsigned int maxNumberMinimaPositions = 10,
unsigned int maxNumberMaximaPositions = 10);
/*! @brief Adds additonal precompute values for all complex Dose Statistics
@exception InvalidDoseException if complexDoseStatistics are not already calculated
*/
void addPrecomputeValues(const std::vector<double>& values);
/*! @brief Recalculates the DoseMeasures for all complex Dose Statistics
@exception InvalidDoseException if complexDoseStatistics are not already calculated
*/
void recalculateDoseStatistics();
void setMultiThreading(bool choice);
};
}
}
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
#endif
diff --git a/code/interpolation/rttbInterpolationBase.h b/code/interpolation/rttbInterpolationBase.h
index 72aec88..b007b8f 100644
--- a/code/interpolation/rttbInterpolationBase.h
+++ b/code/interpolation/rttbInterpolationBase.h
@@ -1,91 +1,100 @@
// -----------------------------------------------------------------------
// RTToolbox - DKFZ radiotherapy quantitative evaluation library
//
// Copyright (c) German Cancer Research Center (DKFZ),
// Software development for Integrated Diagnostics and Therapy (SIDT).
// ALL RIGHTS RESERVED.
// See rttbCopyright.txt or
// http://www.dkfz.de/en/sidt/projects/rttb/copyright.html
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notices for more information.
//
//------------------------------------------------------------------------
/*!
// @file
// @version $Revision$ (last changed revision)
// @date $Date$ (last change date)
// @author $Author$ (last changed by)
*/
#ifndef __INTERPOLATION_BASE_H
#define __INTERPOLATION_BASE_H
#include <boost/shared_ptr.hpp>
#include <array>
#include <rttbCommon.h>
#include "rttbAccessorInterface.h"
#include "RTTBInterpolationExports.h"
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4251)
+#endif
+
namespace rttb
{
namespace interpolation
{
/*! @class InterpolationBase
@brief Base class for interpolation.
@ingroup interpolation
*/
class RTTBInterpolation_EXPORT InterpolationBase
{
public:
rttbClassMacroNoParent(InterpolationBase)
/*! @brief Constructor
*/
InterpolationBase() = default;
/*! @brief Virtual destructor of base class
*/
virtual ~InterpolationBase() = default;
/*! @brief Sets the AccessorPointer
@pre originalData initialized
@exception core::NullPointerException if originalData==nullptr
*/
void setAccessorPointer(core::AccessorInterface::ConstPointer originalData);
/*! @brief Returns the interpolated value for the given world coordinate
*/
virtual DoseTypeGy getValue(const WorldCoordinate3D& aWorldCoordinate) const = 0;
protected:
rttb::core::AccessorInterface::ConstPointer _spOriginalData;
/*! @brief determines voxels in a certain neighborhood of a physical based coordinate and converts in a standard cube with corner points [0 0 0], [1 0 0], [0 1 0], [1 1 0], [0 0 1], [1 0 1], [0 1 1], [1 1 1].
@param aWorldCoordinate the coordinate where to start
@param neighborhood voxel around coordinate (currently only 0 and 8 implemented)
@param target coordinates inside the standard cube with values [0 1] in each dimension.
@param values dose values at all corner points of the standard cube. Is of type boost:shared_ptr[neighborhood]
@pre target and values have to be correctly initialized (e.g. std::array<double, 3> target = {0.0, 0.0, 0.0}; boost::shared_ptr<DoseTypeGy> values(new DoseTypeGy[8]()); where 8 is neighborhood)
@exception core::InvalidParameterException if neighborhood =! 0 && !=8
@exception core::MappingOutsideOfImageException if initial mapping of aWorldCoordinate is outside image
@exception core::NullPointerException if dose is nullptr
*/
void getNeighborhoodVoxelValues(const WorldCoordinate3D& aWorldCoordinate,
unsigned int neighborhood, std::array<double, 3>& target,
boost::shared_ptr<DoseTypeGy[]> values) const;
/*! @brief returns the nearest inside voxel value
@pre the voxelGridIndex is outside the image and voxelGridIndex>image.size() for all dimensions. Also voxelGridIndex[]>=0 for all dimensions
@note used for virtually expanding the image by one voxel as edge handling
*/
DoseTypeGy getNearestInsideVoxelValue(const VoxelGridIndex3D& currentVoxelIndex) const;
};
}
}
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
#endif
diff --git a/code/interpolation/rttbTransformationInterface.h b/code/interpolation/rttbTransformationInterface.h
index 235c037..407e52e 100644
--- a/code/interpolation/rttbTransformationInterface.h
+++ b/code/interpolation/rttbTransformationInterface.h
@@ -1,71 +1,81 @@
// -----------------------------------------------------------------------
// RTToolbox - DKFZ radiotherapy quantitative evaluation library
//
// Copyright (c) German Cancer Research Center (DKFZ),
// Software development for Integrated Diagnostics and Therapy (SIDT).
// ALL RIGHTS RESERVED.
// See rttbCopyright.txt or
// http://www.dkfz.de/en/sidt/projects/rttb/copyright.html
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notices for more information.
//
//------------------------------------------------------------------------
/*!
// @file
// @version $Revision$ (last changed revision)
// @date $Date$ (last change date)
// @author $Author$ (last changed by)
*/
#ifndef __TRANSFORMATION_INTERFACE_H
#define __TRANSFORMATION_INTERFACE_H
#include <rttbCommon.h>
#include "rttbBaseType.h"
#include "RTTBInterpolationExports.h"
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4251)
+#endif
+
namespace rttb
{
namespace interpolation
{
/*! @class TransformationInterface
@brief Base class for transformation (in World coordinates).
@ingroup interpolation
*/
class RTTBInterpolation_EXPORT TransformationInterface
{
public:
rttbClassMacroNoParent(TransformationInterface)
protected:
/*! @brief Constructor
*/
TransformationInterface() = default;
/*! @brief Virtual destructor of interface class
*/
virtual ~TransformationInterface() = default;
public:
/*! @brief performs a transformation targetImage --> movingImage
*/
virtual bool transformInverse(const WorldCoordinate3D& worldCoordinateTarget,
WorldCoordinate3D& worldCoordinateMoving) const = 0;
/*! @brief performs a transformation movingImage --> targetImage
*/
virtual bool transform(const WorldCoordinate3D& worldCoordinateMoving,
WorldCoordinate3D& worldCoordinateTarget) const = 0;
private:
TransformationInterface(const TransformationInterface&) = delete;//not implemented on purpose -> non-copyable
TransformationInterface& operator=(const
TransformationInterface&) = delete;//not implemented on purpose -> non-copyable
};
}
}
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
#endif
diff --git a/code/io/itk/rttbITKImageMaskAccessor.h b/code/io/itk/rttbITKImageMaskAccessor.h
index 9fad60c..19ed4ee 100644
--- a/code/io/itk/rttbITKImageMaskAccessor.h
+++ b/code/io/itk/rttbITKImageMaskAccessor.h
@@ -1,111 +1,120 @@
// -----------------------------------------------------------------------
// RTToolbox - DKFZ radiotherapy quantitative evaluation library
//
// Copyright (c) German Cancer Research Center (DKFZ),
// Software development for Integrated Diagnostics and Therapy (SIDT).
// ALL RIGHTS RESERVED.
// See rttbCopyright.txt or
// http://www.dkfz.de/en/sidt/projects/rttb/copyright.html
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notices for more information.
//
//------------------------------------------------------------------------
/*!
// @file
// @version $Revision$ (last changed revision)
// @date $Date$ (last change date)
// @author $Author$ (last changed by)
*/
#ifndef __ITK_IMAGE_MASK_ACCESSOR_H
#define __ITK_IMAGE_MASK_ACCESSOR_H
#include "rttbMaskAccessorInterface.h"
#include "rttbBaseType.h"
#include "rttbGeometricInfo.h"
#include "itkImage.h"
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4251)
+#endif
+
namespace rttb
{
namespace io
{
namespace itk
{
/*! @class ITKImageMaskAccessor
@brief This class gives access to mask information stored in an itk image
*/
class ITKImageMaskAccessor: public core::MaskAccessorInterface
{
public:
typedef ::itk::Image<DoseTypeGy, 3> ITKMaskImageType;
using ITKImageBaseType = ::itk::ImageBase<3>;
using MaskVoxelList = core::MaskAccessorInterface::MaskVoxelList;
using MaskVoxelListPointer = core::MaskAccessorInterface::MaskVoxelListPointer;
private:
/** @brief The mask as itkImage */
ITKMaskImageType::ConstPointer _mask;
IDType _maskUID;
core::GeometricInfo::Pointer _geoInfo;
/*! vector containing list of mask voxels*/
MaskVoxelListPointer _relevantVoxelVector;
/*! @brief get all required data from the itk image contained in _Mask
@exception InvalidDoseException if PixelSpacing is 0 or size in any dimension is 0.
*/
bool assembleGeometricInfo();
public:
~ITKImageMaskAccessor() override;
ITKImageMaskAccessor(ITKMaskImageType::ConstPointer aMaskImage);
/*! @brief voxelization of the given structures according to the original RTToolbox algorithm*/
void updateMask() override;
/*! @brief get vector conatining al relevant voxels that are inside the given structure*/
MaskVoxelListPointer getRelevantVoxelVector() override;
/*! @brief get vector conatining al relevant voxels that have a relevant volume above the given threshold and are inside the given structure*/
MaskVoxelListPointer getRelevantVoxelVector(float lowerThreshold) override;
/*!@brief determine how a given voxel on the dose grid is masked
* @param aID ID of the voxel in grid.
* @param voxel Reference to the voxel.
* @post after a valid call voxel contains the information of the specified grid voxel. If aID is not valid, voxel values are undefined.
* The relevant volume fraction will be set to zero.
* @return Indicates of the voxel exists and therefore if parameter voxel contains valid values.*/
bool getMaskAt(const VoxelGridID aID, core::MaskVoxel& voxel) const override;
bool getMaskAt(const VoxelGridIndex3D& aIndex, core::MaskVoxel& voxel) const override;
/*! @brief give access to GeometricInfo*/
const core::GeometricInfo& getGeometricInfo() const override;
/* @ brief is true if Mask is on a homogeneous grid */
// Inhomogeneous grids are not supported at the moment, but if they will
// be supported in the future the interface does not need to change.
bool isGridHomogeneous() const override
{
return true;
};
IDType getMaskUID() const override
{
return _maskUID;
};
};
}
}
}
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
#endif
diff --git a/code/io/other/rttbDVHXMLFileWriter.h b/code/io/other/rttbDVHXMLFileWriter.h
index ecde0ff..4e8a8f0 100644
--- a/code/io/other/rttbDVHXMLFileWriter.h
+++ b/code/io/other/rttbDVHXMLFileWriter.h
@@ -1,74 +1,84 @@
// -----------------------------------------------------------------------
// RTToolbox - DKFZ radiotherapy quantitative evaluation library
//
// Copyright (c) German Cancer Research Center (DKFZ),
// Software development for Integrated Diagnostics and Therapy (SIDT).
// ALL RIGHTS RESERVED.
// See rttbCopyright.txt or
// http://www.dkfz.de/en/sidt/projects/rttb/copyright.html
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notices for more information.
//
//------------------------------------------------------------------------
/*!
// @file
// @version $Revision$ (last changed revision)
// @date $Date$ (last change date)
// @author $Author$ (last changed by)
*/
#ifndef __DVH_XML_FILE_WRITER_H
#define __DVH_XML_FILE_WRITER_H
#include "rttbDVH.h"
#include "../rttbDVHWriterInterface.h"
#include "rttbBaseType.h"
#include "RTTBOtherIOExports.h"
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4251)
+#endif
+
namespace rttb
{
namespace io
{
namespace other
{
/*! @class DVHXMLFileWriter
@brief Writes DVHs to xml files.
*/
class RTTBOtherIO_EXPORT DVHXMLFileWriter : public DVHWriterInterface
{
public:
using DataDifferentialType = core::DVH::DataDifferentialType;
private:
FileNameString _fileName;
DVHType _dvhType;
public:
/*! @brief Constructor
@param aFileName a xml file name to write
@param aDVHType: DIFFERENTIAL or CUMULATIVE.
*/
DVHXMLFileWriter(FileNameString aFileName, DVHType aDVHType);
void setFileName(FileNameString aFileName);
FileNameString getFileName() const;
void setDVHType(DVHType aDVHType);
DVHType getDVHType() const;
/*! @brief Write aDvh to xml file with the name: _fileName
@exception NullPointerException Thrown if _aDvh is nullptr
@exception InvalidParameterException Thrown if _fileName invalid: could not open;
or if _dvhType invalid: only DIFFERENTIAL or CUMULATIVE is accepted!
@exception Exception thrown if dvh init error
*/
void writeDVH(core::DVH::Pointer aDvh, bool normalized = false) override;
};
}
}
}
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
#endif
diff --git a/code/io/other/rttbDoseStatisticsXMLWriter.h b/code/io/other/rttbDoseStatisticsXMLWriter.h
index f4a9dde..b0d26f7 100644
--- a/code/io/other/rttbDoseStatisticsXMLWriter.h
+++ b/code/io/other/rttbDoseStatisticsXMLWriter.h
@@ -1,94 +1,104 @@
// -----------------------------------------------------------------------
// RTToolbox - DKFZ radiotherapy quantitative evaluation library
//
// Copyright (c) German Cancer Research Center (DKFZ),
// Software development for Integrated Diagnostics and Therapy (SIDT).
// ALL RIGHTS RESERVED.
// See rttbCopyright.txt or
// http://www.dkfz.de/en/sidt/projects/rttb/copyright.html
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notices for more information.
//
//------------------------------------------------------------------------
#ifndef __DOSE_STATISTICS_XML_WRITER_H
#define __DOSE_STATISTICS_XML_WRITER_H
#include "rttbDoseStatistics.h"
#include <boost/property_tree/ptree.hpp>
#include "RTTBOtherIOExports.h"
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4251)
+#endif
+
namespace rttb
{
namespace io
{
namespace other
{
class RTTBOtherIO_EXPORT DoseStatisticsXMLWriter
{
public:
using DoseStatisticsPtr = boost::shared_ptr<rttb::algorithms::DoseStatistics>;
/*! @brief Write statistics to boost::property_tree::ptree.
@param aDoseStatistics DoseStatistics to write
@pre aReferenceDose must >0
@exception rttb::core::InvalidParameterException Thrown if aReferenceDose<=0 or xml_parse_error
@note The precision is float
*/
boost::property_tree::ptree writeDoseStatistics(DoseStatisticsPtr aDoseStatistics);
/*! @brief Write statistics to String.
@param aDoseStatistics DoseStatistics to write
@pre aReferenceDose must >0
@exception rttb::core::InvalidParameterException Thrown if aReferenceDose<=0 or xml_parse_error
@note The precision is float
*/
XMLString writerDoseStatisticsToString(DoseStatisticsPtr aDoseStatistics);
/*! @brief Write statistics to xml file.
@details includes the following statistics:
- numberOfVoxels,
- volume,
- minimum,
- maximum,
- mean,
- standard deviation,
- variance,
- D2,D5,D10,D90,D95,D98,
- V2,V5,V10,V90,V95,V98,
- MOH2,MOH5,MOH10,
- MOC2,MOC5,MOC10,
- MaxOH2,MaxOH5,MaxOH10,
- MinOC2,MinOC5,MinOC10.
@param aDoseStatistics DoseStatistics to write
@param aFileName To write dose statistics
@pre aReferenceDose must >0
@exception rttb::core::InvalidParameterException Thrown if aReferenceDose<=0 or xml_parse_error
@note The precision is float
*/
void writeDoseStatistics(DoseStatisticsPtr aDoseStatistics, FileNameString aFileName);
boost::property_tree::ptree createNodeWithNameAttribute(DoseTypeGy doseValue, const std::string& attributeName);
boost::property_tree::ptree createNodeWithNameAndXAttribute(DoseTypeGy doseValue, const std::string& attributeName, int xValue);
/*! @brief Write statistics to String to generate a table
@details The table is: "Volume mm3@Max@Min@Mean@Std.Dev.@Variance@D2@D5@D10@D90@D95@D98@V2@V5@V10@V90@V95@V98@MOH2@MOH5@MOH10@MOC2@MOC5@MOC10@MaxOH2@MaxOH5@MaxOH10@MinOC2@MinOC5@MinOC10"
@param aDoseStatistics DoseStatistics to write
@pre aReferenceDose must >0
@exception rttb::core::InvalidParameterException Thrown if aReferenceDose<=0 or xml_parse_error
@note is used for the Mevislab-Linking of RTTB
@note The precision is float
*/
StatisticsString writerDoseStatisticsToTableString(DoseStatisticsPtr aDoseStatistics);
double convertToPercent(double value, double maximum);
};
}
}
}
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
#endif