diff --git a/code/algorithms/rttbDoseStatisticsCalculator.cpp b/code/algorithms/rttbDoseStatisticsCalculator.cpp
index 2e70a5b..5a2fb8a 100644
--- a/code/algorithms/rttbDoseStatisticsCalculator.cpp
+++ b/code/algorithms/rttbDoseStatisticsCalculator.cpp
@@ -1,675 +1,674 @@
 // -----------------------------------------------------------------------
 // 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 <boost/shared_ptr.hpp>
 #include <boost/make_shared.hpp>
 #include <boost/assign/list_of.hpp>
 
 #include "rttbNullPointerException.h"
 #include "rttbInvalidDoseException.h"
 #include "rttbInvalidParameterException.h"
 
-#include <thread>
+#include <boost/thread/thread.hpp>
 
 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;
 		}
 
 
 		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<double>(),
 					std::vector<double>());
 			}
 			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<double>(), std::vector<double>());
 
 			return _statistics;
 		}
 
 		DoseStatisticsCalculator::DoseStatisticsPointer DoseStatisticsCalculator::calculateDoseStatistics(
 			const std::vector<double>& precomputeDoseValues,
 			const std::vector<double>& 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<double, int> doseValueVSIndexMap;
 			std::vector<double> voxelProportionVectorTemp;
 
 
 			DoseStatisticType maximumDose = 0;
 			DoseStatisticType minimumDose = std::numeric_limits<DoseStatisticType>::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<double, int>(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<DoseStatistics>(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<double>& precomputeDoseValues,
 			const std::vector<double>& precomputeVolumeValues)
 		{
 			if (!_simpleDoseStatisticsCalculated)
 			{
 				throw core::InvalidDoseException("simple DoseStatistics have to be computed in order to call calculateComplexDoseStatistics()");
 			}
 
 			std::vector<double> precomputeDoseValuesNonConst = precomputeDoseValues;
 			std::vector<double> precomputeVolumeValuesNonConst = precomputeVolumeValues;
 
 			//set default values
 			if (precomputeDoseValues.empty())
 			{
 				std::vector<double> defaultPrecomputeDoseValues = boost::assign::list_of(0.02)(0.05)(0.1)(0.9)(
 					0.95)(0.98);
 				precomputeDoseValuesNonConst = defaultPrecomputeDoseValues;
 			}
 
 			if (precomputeVolumeValues.empty())
 			{
 				std::vector<double> defaultPrecomputeVolumeValues = boost::assign::list_of(0.02)(0.05)(0.1)(0.9)(
 					0.95)(0.98);
 				precomputeVolumeValuesNonConst = defaultPrecomputeVolumeValues;
 			}
 
 			DoseToVolumeFunctionType Vx = computeDoseToVolumeFunctionMulti(referenceDose,
 				precomputeDoseValuesNonConst, DoseStatistics::Vx);
 			VolumeToDoseFunctionType Dx = computeVolumeToDoseFunctionMulti(precomputeVolumeValuesNonConst,
 				DoseStatistics::Dx);
 			VolumeToDoseFunctionType MOHx = computeVolumeToDoseFunctionMulti(precomputeVolumeValuesNonConst,
 				DoseStatistics::MOHx);
 			VolumeToDoseFunctionType MOCx = computeVolumeToDoseFunctionMulti(precomputeVolumeValuesNonConst,
 				DoseStatistics::MOCx);
 			VolumeToDoseFunctionType MaxOHx = computeVolumeToDoseFunctionMulti(precomputeVolumeValuesNonConst,
 				DoseStatistics::MaxOHx);
 			VolumeToDoseFunctionType MinOCx = computeVolumeToDoseFunctionMulti(precomputeVolumeValuesNonConst,
 				DoseStatistics::MinOCx);
 
 			_statistics->setVx(Vx);
 			_statistics->setDx(Dx);
 			_statistics->setMOHx(MOHx);
 			_statistics->setMOCx(MOCx);
 			_statistics->setMaxOHx(MaxOHx);
 			_statistics->setMinOCx(MinOCx);
 			_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<std::vector<std::pair<DoseTypeGy, VoxelGridID> > >();
 
 			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<DoseTypeGy, VoxelGridID> 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<std::vector<std::pair<DoseTypeGy, VoxelGridID> > >();
 
 			/*! @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<DoseTypeGy, VoxelGridID> voxel(doseValue, currentID);
 					minVoxelVector->push_back(voxel);
 					count++;
 				}
 
 				_doseIterator->next();
 			}
 
 			return minVoxelVector;
 		}
 
 		VolumeType DoseStatisticsCalculator::computeVx(DoseTypeGy xDoseAbsolute) const
 		{
 			rttb::FractionType count = 0;
 			_doseIterator->reset();
 
 			DoseTypeGy currentDose = 0;
 
 			while (_doseIterator->isPositionValid())
 			{
 				currentDose = _doseIterator->getCurrentDoseValue();
 
 				if (currentDose >= xDoseAbsolute)
 				{
 					count += _doseIterator->getCurrentRelevantVolumeFraction();
 				}
 
 				_doseIterator->next();
 			}
 
 			return count * this->_doseIterator->getCurrentVoxelVolume();
 		}
 
 		DoseTypeGy DoseStatisticsCalculator::computeDx(VolumeType xVolumeAbsolute) const
 		{
 			double noOfVoxel = xVolumeAbsolute / _doseIterator->getCurrentVoxelVolume();
 			DoseTypeGy resultDose = 0;
 
 			double countVoxels = 0;
 			int i = _doseVector.size() - 1;
 			for (; i >= 0; i--)
 			{
 				countVoxels += _voxelProportionVector.at(i);
 
 				if (countVoxels >= noOfVoxel)
 				{
 					break;
 				}
 			}
 
 			if (i >= 0)
 			{
 				resultDose = _doseVector.at(i);
 			}
 			else
 			{
 				resultDose = _statistics->getMinimum();
 			}
 
 			return resultDose;
 		}
 
 		DoseTypeGy DoseStatisticsCalculator::computeMOHx(VolumeType xVolumeAbsolute) const
 		{
 			double noOfVoxel = xVolumeAbsolute / _doseIterator->getCurrentVoxelVolume();
 
 
 			if (noOfVoxel == 0)
 			{
 				return 0;
 			}
 			else
 			{
 				double countVoxels = 0;
 				double sum = 0;
 
 				for (size_t i = _doseVector.size() - 1; i >= 0; i--)
 				{
 					double voxelProportion = _voxelProportionVector.at(i);
 					countVoxels += voxelProportion;
 					sum += _doseVector.at(i) * voxelProportion;
 
 					if (countVoxels >= noOfVoxel)
 					{
 						break;
 					}
 				}
 
 				return (DoseTypeGy)(sum / noOfVoxel);
 			}
 		}
 
 		DoseTypeGy DoseStatisticsCalculator::computeMOCx(DoseTypeGy xVolumeAbsolute) const
 		{
 			double noOfVoxel = xVolumeAbsolute / _doseIterator->getCurrentVoxelVolume();
 
 
 			if (noOfVoxel == 0)
 			{
 				return 0;
 			}
 			else
 			{
 				double countVoxels = 0;
 				double sum = 0;
 				std::vector<DoseTypeGy>::const_iterator it = _doseVector.begin();
 				std::vector<double>::const_iterator itD = _voxelProportionVector.begin();
 
 				for (; it != _doseVector.end(); ++it, ++itD)
 				{
 					double voxelProportion = *itD;
 					countVoxels += voxelProportion;
 					sum += (*it) * voxelProportion;
 
 					if (countVoxels >= noOfVoxel)
 					{
 						break;
 					}
 				}
 
 				return (DoseTypeGy)(sum / noOfVoxel);
 			}
 		}
 
 		DoseTypeGy DoseStatisticsCalculator::computeMaxOHx(DoseTypeGy xVolumeAbsolute) const
 		{
 			double noOfVoxel = xVolumeAbsolute / _doseIterator->getCurrentVoxelVolume();
 			DoseTypeGy resultDose = 0;
 
 			double countVoxels = 0;
 			int i = _doseVector.size() - 1;
 			for (; i >= 0; i--)
 			{
 				countVoxels += _voxelProportionVector.at(i);
 
 				if (countVoxels >= noOfVoxel)
 				{
 					break;
 				}
 			}
 
 			if (i - 1 >= 0)
 			{
 				resultDose = _doseVector.at(i - 1);
 			}
 
 			return resultDose;
 		}
 
 		DoseTypeGy DoseStatisticsCalculator::computeMinOCx(DoseTypeGy xVolumeAbsolute) const
 		{
 			double noOfVoxel = xVolumeAbsolute / _doseIterator->getCurrentVoxelVolume();
 			DoseTypeGy resultDose = 0;
 
 			double countVoxels = 0;
 			std::vector<DoseTypeGy>::const_iterator it = _doseVector.begin();
 			std::vector<double>::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)_statistics->getMaximum();
 				}
 			}
 			else
 			{
 				resultDose = (DoseTypeGy)_statistics->getMinimum();
 			}
 
 			return resultDose;
 		}
 
 		DoseStatisticsCalculator::DoseToVolumeFunctionType
 			DoseStatisticsCalculator::computeDoseToVolumeFunctionMulti(DoseTypeGy referenceDose,
 			const std::vector<double>& precomputeDoseValues, DoseStatistics::complexStatistics name) const
 		{
-			std::vector<std::thread> threads;
+			std::vector<boost::thread> threads;
 
 			DoseToVolumeFunctionType VxMulti;
 
 			for (size_t i = 0; i < precomputeDoseValues.size(); ++i)
 			{
 				if (_multiThreading)
 				{
-					threads.push_back(std::thread(&DoseStatisticsCalculator::computeDoseToVolumeSingle, this,
+					threads.push_back(boost::thread(&DoseStatisticsCalculator::computeDoseToVolumeSingle, this,
 						referenceDose, precomputeDoseValues.at(i), name, std::ref(VxMulti)));
 				}
 				else
 				{
 					DoseStatisticsCalculator::computeDoseToVolumeSingle(referenceDose, precomputeDoseValues.at(i),
 						name, std::ref(VxMulti));
 				}
 			}
 
-			for (auto& t : threads)
+			for (unsigned int i=0; i<threads.size();i++)
 			{
-				t.join();
-
+				threads.at(i).join();
 			}
 
 			return VxMulti;
 		}
 
 		void DoseStatisticsCalculator::computeDoseToVolumeSingle(DoseTypeGy referenceDose,
 			double precomputeDoseValue, DoseStatistics::complexStatistics name, DoseToVolumeFunctionType& VxMulti) const
 		{
 			if (name == DoseStatistics::Vx)
 			{
 				double xAbsolue = precomputeDoseValue * referenceDose;
 				VxMulti.insert(std::pair<DoseTypeGy, VolumeType>(xAbsolue,
 					computeVx(xAbsolue)));
 			}
 			else
 			{
 				throw core::InvalidParameterException("unknown DoseStatistics name!");
 			}
 		}
 
 		DoseStatisticsCalculator::VolumeToDoseFunctionType
 			DoseStatisticsCalculator::computeVolumeToDoseFunctionMulti(
 			const std::vector<double>& precomputeVolumeValues, DoseStatistics::complexStatistics name) const
 		{
 			
-			std::vector<std::thread> threads;
+			std::vector<boost::thread> threads;
 
 			VolumeToDoseFunctionType multiValues;
 			VolumeType volume = _statistics->getVolume();
 
 			for (size_t i = 0; i < precomputeVolumeValues.size(); ++i)
 			{
 				if (_multiThreading)
 				{
-					threads.push_back(std::thread(&DoseStatisticsCalculator::computeVolumeToDoseSingle, this,
+					threads.push_back(boost::thread(&DoseStatisticsCalculator::computeVolumeToDoseSingle, this,
 						precomputeVolumeValues.at(i), name, std::ref(multiValues), volume));
 				}
 				else
 				{
 					DoseStatisticsCalculator::computeVolumeToDoseSingle(precomputeVolumeValues.at(i),
 							name, std::ref(multiValues), volume);
 				}
 			}
 			
-			for (auto& t : threads)
+			for (unsigned int i=0; i<threads.size();i++)
 			{
-				t.join();
+				threads.at(i).join();
 			}
 			
 			return multiValues;
 		}
 		
 		void DoseStatisticsCalculator::computeVolumeToDoseSingle(const double& precomputeVolumeValue,
 			DoseStatistics::complexStatistics name, VolumeToDoseFunctionType& multiValues, VolumeType volume) const
 		{
 			double xAbsolute = precomputeVolumeValue * volume;
 
 			switch (name)
 			{
 			case DoseStatistics::Dx:
 				multiValues.insert(std::pair<VolumeType, DoseTypeGy>(xAbsolute,
 					computeDx(xAbsolute)));
 				break;
 
 			case DoseStatistics::MOHx:
 				multiValues.insert(std::pair<VolumeType, DoseTypeGy>(xAbsolute,
 					computeMOHx(xAbsolute)));
 				break;
 
 			case DoseStatistics::MOCx:
 				multiValues.insert(std::pair<VolumeType, DoseTypeGy>(xAbsolute,
 					computeMOCx(xAbsolute)));
 				break;
 
 			case DoseStatistics::MaxOHx:
 				multiValues.insert(std::pair<VolumeType, DoseTypeGy>(xAbsolute,
 					computeMaxOHx(xAbsolute)));
 				break;
 
 			case DoseStatistics::MinOCx:
 				multiValues.insert(std::pair<VolumeType, DoseTypeGy>(xAbsolute,
 					computeMinOCx(xAbsolute)));
 				break;
 
 			default:
 				throw core::InvalidParameterException("unknown DoseStatistics name!");
 			}
 		}
 
 		void DoseStatisticsCalculator::setMultiThreading(const bool choice) 
 		{
 			_multiThreading = choice;
 		}
 
 	}//end namespace algorithms
 }//end namespace rttb
 
diff --git a/code/core/rttbStrVectorStructureSetGenerator.cpp b/code/core/rttbStrVectorStructureSetGenerator.cpp
index afa7260..43c1746 100644
--- a/code/core/rttbStrVectorStructureSetGenerator.cpp
+++ b/code/core/rttbStrVectorStructureSetGenerator.cpp
@@ -1,65 +1,66 @@
 // -----------------------------------------------------------------------
 // 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 "rttbStrVectorStructureSetGenerator.h"
 
 #include <regex>
 
 namespace rttb
 {
 	namespace core
 	{
 
 
 		StrVectorStructureSetGenerator::StrVectorStructureSetGenerator(std::vector<StructTypePointer>&
-		        aStructureVector, IDType aPatientUID)
+			aStructureVector, IDType aPatientUID)
 		{
 
 			_patientUID = aPatientUID;
 			_strVector = aStructureVector;
 
 		}
 
 		StrVectorStructureSetGenerator::StructureSetPointer
-		StrVectorStructureSetGenerator::generateStructureSet()
+			StrVectorStructureSetGenerator::generateStructureSet()
 		{
-      std::vector<StructTypePointer> _filteredStructs = _strVector;
+			std::vector<StructTypePointer> _filteredStructs = _strVector;
 
-      if (this->getStructureLabelFilterActive())
-      {
-        _filteredStructs.clear();
+			if (this->getStructureLabelFilterActive())
+			{
+				_filteredStructs.clear();
 
-			  std::regex e(this->getFilterRegEx());
+				std::regex e(this->getFilterRegEx());
 
-        for(auto aStruct : _strVector)
-        {
-  				if (std::regex_match(aStruct->getLabel(), e))
-	  			{
-		  			_filteredStructs.push_back(aStruct);
-			  	}
-        }
+				std::vector<StructTypePointer>::iterator it;
+				for(it= _strVector.begin();it!=_strVector.end();++it)
+				{
+					if (std::regex_match((*it)->getLabel(), e))
+					{
+						_filteredStructs.push_back((*it));
+					}
+				}
 
-      }
-      
-      return boost::make_shared<core::StructureSet>(_filteredStructs, _patientUID);
+			}
+
+			return boost::make_shared<core::StructureSet>(_filteredStructs, _patientUID);
 		}
 	}
 }//end namespace rttb
diff --git a/code/io/other/rttbDoseStatisticsXMLReader.cpp b/code/io/other/rttbDoseStatisticsXMLReader.cpp
index bed370d..d73e24f 100644
--- a/code/io/other/rttbDoseStatisticsXMLReader.cpp
+++ b/code/io/other/rttbDoseStatisticsXMLReader.cpp
@@ -1,178 +1,179 @@
 // -----------------------------------------------------------------------
 // RTToolbox - DKFZ radiotherapy quantitative evaluation library
 //
 // Copyright (c) German Cancer Research Center (DKFZ),
 // Software development for Integrated Diagnostics and Therapy (SIDT).
 // ALL RIGHTS RESERVED.
 // See rttbCopyright.txt or
 // http://www.dkfz.de/en/sidt/projects/rttb/copyright.html
 //
 // This software is distributed WITHOUT ANY WARRANTY; without even
 // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 // PURPOSE.  See the above copyright notices for more information.
 //
 //------------------------------------------------------------------------
 /*!
 // @file
 // @version $Revision: 1328 $ (last changed revision)
 // @date    $Date: 2016-04-22 09:50:01 +0200 (Fr, 22 Apr 2016) $ (last change date)
 // @author  $Author: hentsch $ (last changed by)
 */
 
 #include <boost/foreach.hpp>
 #include <boost/lexical_cast.hpp>
 
 
 #include "rttbDoseStatisticsXMLReader.h"
 
 #include "rttbInvalidParameterException.h"
 
 namespace rttb
 {
 	namespace io
 	{
 		namespace other
 		{
 			typedef boost::shared_ptr<rttb::algorithms::DoseStatistics> DoseStatisticsPtr;
 
 
 			DoseStatisticsXMLReader::DoseStatisticsXMLReader(const std::string& filename) : _filename(filename), _newFile(true){
 			}
 
 			DoseStatisticsXMLReader::~DoseStatisticsXMLReader(){
 			}
 
 
 			void DoseStatisticsXMLReader::setFilename(const std::string& filename){
 				_filename = filename;
 				_newFile = true;
 			}
 
 			DoseStatisticsPtr DoseStatisticsXMLReader::generateDoseStatistic(){
 				if (_newFile){
 					this->createDoseStatistic();
 				}
 
 				return _doseStatistic;
 			}
 
 			void DoseStatisticsXMLReader::createDoseStatistic(){
 
 				boost::property_tree::ptree pt;
 
 				// Load the XML file into the property tree. If reading fails
 				// (cannot open file, parse error), an exception is thrown.
 				try
 				{
 					read_xml(_filename, pt);
 				}
 				catch (boost::property_tree::xml_parser_error& /*e*/)
 				{
 					throw rttb::core::InvalidParameterException("DoseStatistics file name invalid: could not open the xml file!");
 				}
 
 				// data to fill the parameter for the DoseStatistics
 				std::string name;
 				std::string datum;
 				unsigned int x;
 				std::pair<double, int> voxelid;
 				std::vector < std::pair<double, int>> vec;
 
 				//parameter for the DoseSTatistics
 				double minimum;
 				double maximum;
 				double numVoxels;
 				double volume;
 				double referenceDose = -1;
 				double mean;
 				double stdDeviation;
 				boost::shared_ptr<std::vector<std::pair<double, int> > > minimumVoxelPositions = nullptr;
 				boost::shared_ptr<std::vector<std::pair<double, int> > > maximumVoxelPositions = nullptr;
 				std::map<DoseTypeGy, VolumeType> Dx;
 				std::map<DoseTypeGy, VolumeType> Vx;
 				std::map<VolumeType, DoseTypeGy> MOHx;
 				std::map<VolumeType, DoseTypeGy> MOCx;
 				std::map<VolumeType, DoseTypeGy> MaxOHx;
 				std::map<VolumeType, DoseTypeGy> MinOCx;
 	
 
 				BOOST_FOREACH(boost::property_tree::ptree::value_type & data, pt.get_child("statistics.results")){
 					datum = data.second.data();
 					BOOST_FOREACH(boost::property_tree::ptree::value_type & middel, data.second){
 						BOOST_FOREACH(boost::property_tree::ptree::value_type & innernode, middel.second){
 							std::string mia = innernode.first;
 							if (innernode.first == "name"){
 								name = innernode.second.data();
 							}
 							else if (innernode.first == "voxelGridID"){
 								datum.erase(std::remove(datum.begin(), datum.end(), '\t'), datum.end());
 								datum.erase(std::remove(datum.begin(), datum.end(), '\n'), datum.end());
 								voxelid.first = boost::lexical_cast<double>(datum);
 								voxelid.second = boost::lexical_cast<unsigned int>(innernode.second.data());
 								vec.push_back(voxelid);
 							}
 							else if (innernode.first == "x"){
 								x = boost::lexical_cast<unsigned int>(innernode.second.data());
 							}
 						}
 					}
 
 					// fill with the extracted data
 						if (name == "numberOfVoxels"){
 							numVoxels = boost::lexical_cast<double>(datum);
 						}
 						else if (name == "volume"){
 							volume = boost::lexical_cast<double>(datum);
 						}
 						else if (name == "referenceDose"){
 							referenceDose = boost::lexical_cast<double>(datum);
 						}
 						else if (name == "mean"){
 							mean = boost::lexical_cast<double>(datum);
 						}
 						else if (name == "standardDeviation"){
 							stdDeviation = boost::lexical_cast<double>(datum);
 						}
 						else if (name == "minimum"){
 							minimum = boost::lexical_cast<double>(datum);
 							if (!vec.empty()){
 								minimumVoxelPositions = boost::make_shared<std::vector<std::pair<double, int>>>(vec);
 								vec.clear();
 							}
 						}
 						else if (name == "maximum"){
 							maximum = boost::lexical_cast<double>(datum);
 							if (!vec.empty()){
 								maximumVoxelPositions = boost::make_shared<std::vector<std::pair<double, int>>>(vec);
 								vec.clear();
 							}
 						}
 						else if (name == "Dx"){
 							Dx[boost::lexical_cast<double>(x)*volume / 100] = boost::lexical_cast<double>(datum);
 						}
 						else if (name == "Vx"){
 							Vx[boost::lexical_cast<double>(x)*referenceDose / 100] = boost::lexical_cast<double>(datum);
 						}
 						else if (name == "MOHx"){
 							MOHx[boost::lexical_cast<double>(x)*volume / 100] = boost::lexical_cast<double>(datum);
 						}
 						else if (name == "MOCx"){
 							MOCx[boost::lexical_cast<double>(x)*volume / 100] = boost::lexical_cast<double>(datum);
 						}
 						else if (name == "MaxOHx"){
 							MaxOHx[boost::lexical_cast<double>(x)*volume / 100] = boost::lexical_cast<double>(datum);
 						}
 						else if (name == "MinOCx"){
 							MinOCx[boost::lexical_cast<double>(x)*volume / 100] = boost::lexical_cast<double>(datum);
 						}
 				}
 				
 				// make DoseStatistcs
-				_doseStatistic = boost::make_shared<rttb::algorithms::DoseStatistics>(
+
+				_doseStatistic = boost::make_shared<rttb::algorithms::DoseStatistics>(rttb::algorithms::DoseStatistics(
 					minimum, maximum, mean, stdDeviation, numVoxels, volume, minimumVoxelPositions, maximumVoxelPositions
-					,Dx, Vx, MOHx, MOCx, MaxOHx, MinOCx, referenceDose);
+					,Dx, Vx, MOHx, MOCx, MaxOHx, MinOCx, referenceDose));
 			}
 }//end namespace other
 	}//end namespace io
 }//end namespace rttb