diff --git a/code/masks/boost/rttbBoostMask.cpp b/code/masks/boost/rttbBoostMask.cpp
index 9abc23f..58be82e 100644
--- a/code/masks/boost/rttbBoostMask.cpp
+++ b/code/masks/boost/rttbBoostMask.cpp
@@ -1,300 +1,300 @@
 #include <iostream>
 #include <deque>
 #include <algorithm>
 
 #include <boost/geometry/geometries/register/point.hpp>
 #include <boost/geometry/geometries/register/ring.hpp>
 #include <boost/geometry/io/wkt/wkt.hpp>
 #include <boost/geometry/multi/geometries/multi_polygon.hpp>
 #include <boost/make_shared.hpp>
 
 #include "rttbBoostMask.h"
 #include "rttbNullPointerException.h"
 #include "rttbInvalidParameterException.h"
 
 namespace rttb
 {
 	namespace masks
 	{
 		namespace boost
 		{
 			BoostMask::BoostMask(BoostMask::GeometricInfoPointer aDoseGeoInfo, BoostMask::StructPointer aStructure)
 				:_geometricInfo(aDoseGeoInfo), _structure(aStructure), _voxelInStructure(::boost::make_shared<MaskVoxelList>()){
 
 					_isUpToDate = false;
 					if(! _geometricInfo ){
 						throw rttb::core::NullPointerException("Error: Geometric info is NULL!");
 					}
 					else if(!_structure){
 						throw rttb::core::NullPointerException("Error: Structure is NULL!");
 					}
 
 			}
 
 			void BoostMask::calcMask(){
 				if(hasSelfIntersections()){
 					throw rttb::core::InvalidParameterException("Error: structure has self intersections!");
 				}
 
 				std::vector<BoostMask::BoostRingVector> intersectionSlicePolygonsVector;//store the polygons of intersection slice of each index z
 
 				//For each dose slice, get intersection structure slice and the contours on the structure slice
 				for(unsigned int indexZ=0; indexZ< _geometricInfo->getNumSlices(); indexZ++){
 					BoostMask::BoostRingVector boostPolygons = getIntersectionSlicePolygons(indexZ);
 					BoostMask::BoostRingVector::iterator it;
 					for(it = boostPolygons.begin(); it != boostPolygons.end(); ++it){
 						::boost::geometry::correct(*it);
 					}
 					intersectionSlicePolygonsVector.push_back(boostPolygons);
 				}
 
 				/* Use simple nearest neighbour interpolation (NNI) if dose and structure has different z spacing:
 				If dose slice (indexZ) has no intersection with structure slice, but the last and the next do, that means the dose
 				slice lies between two structure slices -> use the last slice intersection contours for this slice 			
 				*/
 				for(unsigned int indexZ=1; indexZ<_geometricInfo->getNumSlices()-1; indexZ++){
 					if(intersectionSlicePolygonsVector.at(indexZ).size() == 0 && intersectionSlicePolygonsVector.at(indexZ-1).size() > 0
 						&& intersectionSlicePolygonsVector.at(indexZ+1).size() > 0)
 						intersectionSlicePolygonsVector.at(indexZ) = intersectionSlicePolygonsVector.at(indexZ-1);
 				}
 
 				for(unsigned int indexZ=0; indexZ< _geometricInfo->getNumSlices(); indexZ++){
 					BoostMask::BoostRingVector intersectionSlicePolygons = intersectionSlicePolygonsVector.at(indexZ);
 
 					//Get bounding box of this dose slice
 					VoxelIndexVector voxelList = getBoundingBox(indexZ, intersectionSlicePolygons);
 					rttb::VoxelGridIndex3D gridIndex3D0 = voxelList.at(0);
 					rttb::VoxelGridIndex3D gridIndex3D1 = voxelList.at(1);
 
 					for(unsigned int indexX = gridIndex3D0[0] ; indexX <= gridIndex3D1[0]; indexX ++  ){
 						for(unsigned int indexY = gridIndex3D0[1]; indexY <= gridIndex3D1[1]; indexY ++){
 							rttb::VoxelGridIndex3D currentIndex;
 							currentIndex[0] = indexX;
 							currentIndex[1] = indexY;
 							currentIndex[2] = indexZ;
 
 							rttb::VoxelGridID gridID; 
 							_geometricInfo->convert(currentIndex, gridID);
 
 							//Get intersection polygons of the dose voxel and the structure
 							std::deque<BoostMask::BoostPolygon2D> polygons = getIntersections(currentIndex, intersectionSlicePolygons);
 
 							//Calc areas of all intersection polygons
 							double intersectionArea = calcArea(polygons);
 
 							double voxelSize = _geometricInfo->getSpacing()[0] * _geometricInfo->getSpacing()[1];
 
 							if(intersectionArea > 0) {
 								double volumeFraction = intersectionArea/voxelSize;
 								if(volumeFraction > 1 && (volumeFraction-1) <= 0.0001){
 									volumeFraction = 1;
 								}
 								core::MaskVoxel maskVoxel = core::MaskVoxel(gridID, (volumeFraction));
 								_voxelInStructure->push_back(maskVoxel);//push back the mask voxel in structure
 							}
 						}
 					}
 				}
 
 				sort(_voxelInStructure->begin(), _voxelInStructure->end());
 			}
 
 			bool BoostMask::hasSelfIntersections(){
 				bool hasSelfIntersection = false;
 
 				for(unsigned int indexZ=0; indexZ< _geometricInfo->getNumSlices(); indexZ++){
 					rttb::VoxelGridIndex3D currentIndex(0,0,indexZ);
 
 					BoostMask::BoostRingVector boostPolygons = getIntersectionSlicePolygons(currentIndex[2]);
 
 					BoostMask::BoostRingVector::iterator it;
 					BoostMask::BoostRingVector::iterator it2;
 					for(it = boostPolygons.begin(); it != boostPolygons.end(); ++it){
 						::boost::geometry::correct(*it);
 						//test if polygon has self intersection
 						if(::boost::geometry::detail::overlay::has_self_intersections(*it)){
 							hasSelfIntersection = true;
 							std::cout << "Has self intersection polygon! Slice: "<< indexZ << ". " <<std::endl;
 							break;
 						}
 
 						//test if the polygons on the same slice has intersection
 						for(it2 = boostPolygons.begin(); it2 != boostPolygons.end() && it2 != it; ++it2){
 							::boost::geometry::correct(*it2);
 							BoostPolygonDeque intersection;
 							::boost::geometry::intersection(*it, *it2, intersection);
 							if(intersection.size()>0){
 								hasSelfIntersection = true;
 								std::cout << "Two polygons on the same slice has intersection! Slice: "<< indexZ << "." <<std::endl;
 								break;
 							}
 						}
 					}	
 
 				}
 
 				return hasSelfIntersection;
 			}
 
 
 			/*Get the 4 voxel index of the bounding box of the polygon in the slice with sliceNumber*/
 			BoostMask::VoxelIndexVector BoostMask::getBoundingBox(unsigned int sliceNumber, const BoostRingVector& intersectionSlicePolygons){
 				if(sliceNumber<0 || sliceNumber >= _geometricInfo->getNumSlices()){
 					throw rttb::core::InvalidParameterException(std::string("Error: slice number is invalid!"));
 				}
 
 				rttb::VoxelGridIndex3D currentIndex(0,0,sliceNumber);
 
 				double xMin = 0;
 				double yMin = 0;
 				double xMax = 0; 
 				double yMax = 0;
 
 				BoostRingVector::const_iterator it;
 				for(it = intersectionSlicePolygons.begin(); it != intersectionSlicePolygons.end(); ++it){
 					::boost::geometry::model::box<BoostPoint2D> box;
 					::boost::geometry::envelope(*it, box);
 					BoostPoint2D minPoint = box.min_corner();
 					BoostPoint2D maxPoint = box.max_corner();
 					if(it == intersectionSlicePolygons.begin()){
 						xMin = minPoint.x();
 						yMin = minPoint.y();
 						xMax = maxPoint.x();
 						yMax = maxPoint.y();
 					}
 					xMin = std::min(xMin, minPoint.x());
 					yMin = std::min(yMin, minPoint.y());
 					xMax = std::max(xMax, maxPoint.x());
 					yMax = std::max(yMax, maxPoint.y());
 				}
 
 				rttb::WorldCoordinate3D nullWorldCoord;
 				_geometricInfo->indexToWorldCoordinate(VoxelGridIndex3D(0,0,0),nullWorldCoord);
 				rttb::WorldCoordinate3D minWorldCoord(xMin, yMin, nullWorldCoord.z());
 				rttb::WorldCoordinate3D maxWorldCoord(xMax, yMax, nullWorldCoord.z());
 
 				rttb::VoxelGridIndex3D index0;
 				rttb::VoxelGridIndex3D index1;
 				_geometricInfo->worldCoordinateToIndex(minWorldCoord, index0);
 				_geometricInfo->worldCoordinateToIndex(maxWorldCoord, index1);
 
 				VoxelIndexVector voxelList;
 				voxelList.push_back(index0);
 				voxelList.push_back(index1);
 
 				return voxelList;
 			} 
 
 
 			/*Get intersection polygons of the contour and a voxel polygon*/
 			BoostMask::BoostPolygonDeque BoostMask::getIntersections(const rttb::VoxelGridIndex3D& aVoxelIndex3D, const BoostRingVector& intersectionSlicePolygons){
 				BoostMask::BoostPolygonDeque polygonDeque;
 
 				BoostRing2D voxelPolygon = get2DContour(aVoxelIndex3D);
 				::boost::geometry::correct(voxelPolygon);
 
 				BoostRingVector::const_iterator it;
 				for(it = intersectionSlicePolygons.begin(); it != intersectionSlicePolygons.end(); ++it){
 					BoostRing2D contour = *it;
 					::boost::geometry::correct(contour);
 					BoostPolygonDeque intersection;
 					::boost::geometry::intersection(voxelPolygon, contour, intersection);
 
 					polygonDeque.insert(polygonDeque.end(), intersection.begin(), intersection.end());
 				}
 
 				return polygonDeque;
 			}
 
 
 			/*Calculate the intersection area*/
-			double BoostMask::calcArea(const std::deque<BoostMask::BoostPolygon2D> aPolygonDeque){
+			double BoostMask::calcArea(const BoostPolygonDeque& aPolygonDeque){
 				double area = 0;
 
-				std::deque<BoostMask::BoostPolygon2D>::iterator it;
-				for(unsigned int i=0; i<aPolygonDeque.size(); i++){
-					area += ::boost::geometry::area(aPolygonDeque.at(i));
+				BoostPolygonDeque::const_iterator it;
+				for(it = aPolygonDeque.begin(); it != aPolygonDeque.end(); ++it){
+					area += ::boost::geometry::area(*it);
 				}
 				return area;
 			}
 
 			VoxelGridIndex3D BoostMask::getGridIndex3D(const core::MaskVoxel& aMaskVoxel){
 				rttb::VoxelGridIndex3D gridIndex3D; 
 				_geometricInfo->convert(aMaskVoxel.getVoxelGridID(), gridIndex3D);
 				return gridIndex3D;
 			}
 
 			BoostMask::MaskVoxelListPointer BoostMask::getRelevantVoxelVector(){
 				if(!_isUpToDate){
 					calcMask();
 				}
 				return _voxelInStructure;
 			}
 
 			BoostMask::BoostRing2D BoostMask::convert(const rttb::PolygonType& aRTTBPolygon){
 				BoostMask::BoostRing2D polygon2D;
 				BoostPoint2D firstPoint;
 				for(unsigned int i=0; i<aRTTBPolygon.size(); i++){
 					rttb::WorldCoordinate3D rttbPoint = aRTTBPolygon.at(i);
 					BoostPoint2D boostPoint(rttbPoint[0], rttbPoint[1]); 
 					if(i==0){
 						firstPoint = boostPoint;
 					}
 					::boost::geometry::append(polygon2D, boostPoint);
 				}
 				::boost::geometry::append(polygon2D, firstPoint);
 				return polygon2D;
 
 			}
 
 			BoostMask::BoostRingVector BoostMask::getIntersectionSlicePolygons(const rttb::GridIndexType aVoxelGridIndexZ){
 				BoostRingVector boostPolygonVector;
 
 				rttb::PolygonSequenceType polygonSequence = _structure->getStructureVector();
 				rttb::PolygonSequenceType::iterator it;
 				for(it = polygonSequence.begin(); it != polygonSequence.end(); ++it){
 					PolygonType rttbPolygon = *it;
 					if(!rttbPolygon.empty()){
 						double polygonZCoor = rttbPolygon.at(0)[2];
 						rttb::WorldCoordinate3D polygonPoint(0,0, polygonZCoor);
 						rttb::VoxelGridIndex3D polygonPointIndex3D;
 						_geometricInfo->worldCoordinateToIndex(polygonPoint, polygonPointIndex3D);
 
 						//if the z
 						if(aVoxelGridIndexZ == polygonPointIndex3D[2]){
 							boostPolygonVector.push_back(convert(rttbPolygon));
 						}
 					}
 				}
 
 				return boostPolygonVector;
 			}
 
 			BoostMask::BoostRing2D BoostMask::get2DContour(const rttb::VoxelGridIndex3D& aVoxelGrid3D){
 				BoostMask::BoostRing2D polygon;
 				rttb::WorldCoordinate3D rttbPoint;
 				_geometricInfo->indexToWorldCoordinate(aVoxelGrid3D, rttbPoint);
 
 				BoostPoint2D point1 (rttbPoint[0], rttbPoint[1]);
 				::boost::geometry::append(polygon, point1);
 
 				double xSpacing = _geometricInfo->getSpacing()[0];
 				double ySpacing = _geometricInfo->getSpacing()[1];
 
 				BoostPoint2D point2(rttbPoint[0]+xSpacing, rttbPoint[1]);
 				::boost::geometry::append(polygon, point2);
 
 				BoostPoint2D point3(rttbPoint[0]+xSpacing, rttbPoint[1]+ySpacing);
 				::boost::geometry::append(polygon, point3);
 
 				BoostPoint2D point4(rttbPoint[0], rttbPoint[1]+ySpacing);
 				::boost::geometry::append(polygon, point4);
 
 				::boost::geometry::append(polygon, point1);
 
 				return polygon;
 
 			}
 		}
 	}
 }
\ No newline at end of file
diff --git a/code/masks/boost/rttbBoostMask.h b/code/masks/boost/rttbBoostMask.h
index b82a806..d8cfa85 100644
--- a/code/masks/boost/rttbBoostMask.h
+++ b/code/masks/boost/rttbBoostMask.h
@@ -1,136 +1,136 @@
 // -----------------------------------------------------------------------
 // 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: 707 $ (last changed revision)
 // @date    $Date: 2014-09-04 16:37:24 +0200 (Do, 04 Sep 2014) $ (last change date)
 // @author  $Author: floca $ (last changed by)
 */
 
 
 #ifndef __BOOST_MASK_H
 #define __BOOST_MASK_H
 
 #include "rttbBaseType.h"
 #include "rttbStructure.h"
 #include "rttbGeometricInfo.h"
 #include "rttbMaskVoxel.h"
 #include "rttbMaskAccessorInterface.h"
 
 #include <boost/geometry.hpp>
 #include <boost/geometry/geometries/point_xy.hpp>
 #include <boost/geometry/geometries/polygon.hpp>
 #include <boost/geometry/geometries/ring.hpp>
 #include <boost/shared_ptr.hpp>
 
 namespace rttb
 {
 	namespace masks
 	{
 		namespace boost
 		{
 			class BoostMask
 			{	
 
 			public:
 				typedef ::boost::shared_ptr<rttb::core::GeometricInfo> GeometricInfoPointer;
 				typedef core::Structure::StructTypePointer StructPointer;
 				typedef core::MaskAccessorInterface::MaskVoxelList MaskVoxelList;
 				typedef core::MaskAccessorInterface::MaskVoxelListPointer MaskVoxelListPointer;
 
 				/*! @brief Constructor
 				* @exception rttb::core::NullPointerException thrown if aDoseGeoInfo or aStructure is NULL
 				*/
 				BoostMask(GeometricInfoPointer aDoseGeoInfo, StructPointer aStructure);
 
 				/*! @brief Generate mask and return the voxels in the mask
 				* @exception rttb::core::InvalidParameterException thrown if the structure has self intersections
 				*/
 				MaskVoxelListPointer getRelevantVoxelVector();
 
 			private:
 				typedef ::boost::geometry::model::d2::point_xy<double> BoostPoint2D;
 				typedef ::boost::geometry::model::polygon<::boost::geometry::model::d2::point_xy<double> > BoostPolygon2D;
 				typedef ::boost::geometry::model::ring<::boost::geometry::model::d2::point_xy<double> > BoostRing2D;
 				typedef std::deque<BoostPolygon2D> BoostPolygonDeque;
 				typedef std::vector<BoostRing2D> BoostRingVector;
 				typedef std::vector<rttb::VoxelGridIndex3D> VoxelIndexVector;
 
 				GeometricInfoPointer _geometricInfo;
 
 				StructPointer _structure;
 
 				//vector of the MaskVoxel inside the structure
 				MaskVoxelListPointer _voxelInStructure;
 
 				/*! @brief If the mask is up to date
 				*/
 				bool _isUpToDate;
 
 				/*! @brief Voxelization and generate mask
 				*/
 				void calcMask();
 
 				/*! @brief Check if the structure has self intersections*/
 				bool hasSelfIntersections();
 
 				/*! @brief Get the min/max voxel index of the bounding box of the polygon in the slice with sliceNumber
 				 * @param sliceNumber slice number between 0 and _geometricInfo->getNumSlices()
 				 * @param intersectionSlicePolygons Get the polygons intersecting the slice
 				 * @exception InvalidParameterException thrown if sliceNumber < 0 or sliceNumber >=  _geometricInfo->getNumSlices()
 				 * @return Return the 4 voxel index of the bounding box
 				*/
 				VoxelIndexVector getBoundingBox(unsigned int sliceNumber, const BoostRingVector& intersectionSlicePolygons);
 
 				/*! @brief Get intersection polygons of the contour and a voxel polygon
 				 * @param aVoxelIndex3D The 3d grid index of the voxel
 				 * @param intersectionSlicePolygons The polygons of the slice intersecting the voxel
 				 * @return Return all intersetion polygons of the structure and the voxel
 				*/
 				BoostPolygonDeque getIntersections(const rttb::VoxelGridIndex3D& aVoxelIndex3D, const BoostRingVector& intersectionSlicePolygons);
 
 				/*! @brief Calculate the area of all polygons
 				 * @param aPolygonDeque The deque of polygons
 				 * @return Return the area of all polygons
 				*/
-				double calcArea(const BoostPolygonDeque aPolygonDeque);
+				double calcArea(const BoostPolygonDeque& aPolygonDeque);
 
 				/*! @brief Get grid index of a mask voxel
 				 * @param aMaskVoxel A mask voxel
 				 * @return Return the 3d grid index of the mask voxel 
 				*/
 				VoxelGridIndex3D getGridIndex3D(const core::MaskVoxel& aMaskVoxel);
 
 				/*! @brief Convert RTTB polygon to boost polygon*/
 				BoostRing2D convert(const rttb::PolygonType& aRTTBPolygon);
 
 				/*! @brief Get the intersection slice of the voxel, return the polygons in the slice
 				 * @param aVoxelGridIndexZ The z grid index (slice number) of the voxel
 				 * @return Return the structure polygons intersecting the slice 
 				*/
 				BoostRingVector getIntersectionSlicePolygons(const rttb::GridIndexType aVoxelGridIndexZ);
 
 				/*! @brief Get the voxel 2d contour polygon*/
 				BoostRing2D get2DContour(const rttb::VoxelGridIndex3D& aVoxelGrid3D);
 
 			};
 
 		}
 
 
 	}
 }
 
 #endif
\ No newline at end of file
diff --git a/testing/examples/VoxelizationValidationTest.cpp b/testing/examples/VoxelizationValidationTest.cpp
index 1b48950..a2671be 100644
--- a/testing/examples/VoxelizationValidationTest.cpp
+++ b/testing/examples/VoxelizationValidationTest.cpp
@@ -1,188 +1,192 @@
 // -----------------------------------------------------------------------
 // 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: 929 $ (last changed revision)
 // @date $Date: 2015-04-08 14:50:57 +0200 (Mi, 08 Apr 2015) $ (last change date)
 // @author $Author: zhangl $ (last changed by)
 */
 
 // this file defines the rttbCoreTests for the test driver
 // and all it expects is that you have a function called RegisterTests
 
 #include <boost/make_shared.hpp>
 #include <boost/shared_ptr.hpp>
 
 #include <iomanip>
 
 #include "litCheckMacros.h"
 
 #include "rttbBaseType.h"
 #include "rttbDVHCalculator.h"
 #include "rttbGenericMaskedDoseIterator.h"
 #include "rttbGenericDoseIterator.h"
 #include "rttbNullPointerException.h"
 #include "rttbInvalidParameterException.h"
 #include "rttbDicomDoseAccessor.h"
 #include "rttbDicomFileDoseAccessorGenerator.h"
 #include "rttbDicomFileStructureSetGenerator.h"
 #include "rttbOTBMaskAccessor.h"
 #include "rttbDVHTxtFileReader.h"
 #include "rttbBoostMaskAccessor.h"
 #include "rttbITKImageMaskAccessorConverter.h"
 #include "rttbImageWriter.h"
 
 
 namespace rttb
 {
 
 	namespace testing
 	{
 
 		/*! @brief VoxelizationValidationTest.
 		Compare two differnt voxelizations: OTB and Boost. 
 		Check dvh maximum and minimum for each structure.
 		Check write mask to itk file for further validation.
 		*/
 
 		int VoxelizationValidationTest(int argc, char* argv[])
 		{
 			typedef core::GenericDoseIterator::DoseAccessorPointer DoseAccessorPointer;
 			typedef core::GenericMaskedDoseIterator::MaskAccessorPointer MaskAccessorPointer;
 			typedef core::DVHCalculator::DoseIteratorPointer DoseIteratorPointer;
 			typedef core::StructureSetGeneratorInterface::StructureSetPointer StructureSetPointer;
 
 			PREPARE_DEFAULT_TEST_REPORTING;
 			//ARGUMENTS: 1: structure file name
 			//           2: dose1 file name
 			//           3: directory name to write boost mask of all structures
 			//           4: directory name to write OTB mask of all structures
 
 
 			std::string RTSTRUCT_FILENAME ;
 			std::string RTDOSE_FILENAME;
 			std::string BoostMask_DIRNAME;
 			std::string OTBMask_DIRNAME;
 
 
 			if (argc > 4)
 			{
 				RTSTRUCT_FILENAME = argv[1];
 				RTDOSE_FILENAME = argv[2];
 				BoostMask_DIRNAME = argv[3];
 				OTBMask_DIRNAME = argv[4];
 			}
 
 			OFCondition status;
 			DcmFileFormat fileformat;
 
 			/* read dicom-rt dose */
 			io::dicom::DicomFileDoseAccessorGenerator doseAccessorGenerator1(RTDOSE_FILENAME.c_str());
 			DoseAccessorPointer doseAccessor1(doseAccessorGenerator1.generateDoseAccessor());
 			boost::shared_ptr<core::GeometricInfo> geometricPtr = boost::make_shared<core::GeometricInfo>(doseAccessor1->getGeometricInfo());
 
 			//create a vector of MaskAccessors (one for each structure)
 			StructureSetPointer rtStructureSet = io::dicom::DicomFileStructureSetGenerator(
 				RTSTRUCT_FILENAME.c_str()).generateStructureSet();
 
 			std::vector<MaskAccessorPointer> rtStructSetMaskAccessorVec;
 
 
 			if (rtStructureSet->getNumberOfStructures() > 0)
 			{
-				for (int j = 2; j < rtStructureSet->getNumberOfStructures(); j++)
+				for (int j = 0; j < rtStructureSet->getNumberOfStructures(); j++)
 				{
 					std::cout << j << ": "<< rtStructureSet->getStructure(j)->getLabel()<<std::endl;
 					clock_t start(clock());
 					//create OTB MaskAccessor
 					::boost::shared_ptr<masks::legacy::OTBMaskAccessor> spOTBMaskAccessor =
 						::boost::make_shared<masks::legacy::OTBMaskAccessor>(rtStructureSet->getStructure(j),
 						doseAccessor1->getGeometricInfo());
 					spOTBMaskAccessor->updateMask();
 					MaskAccessorPointer spMaskAccessor(spOTBMaskAccessor);
 
 					::boost::shared_ptr<core::GenericMaskedDoseIterator> spMaskedDoseIteratorTmp =
 						::boost::make_shared<core::GenericMaskedDoseIterator>(spMaskAccessor, doseAccessor1);
 					DoseIteratorPointer spMaskedDoseIterator(spMaskedDoseIteratorTmp);
 					rttb::core::DVHCalculator calc(spMaskedDoseIterator, (rtStructureSet->getStructure(j))->getUID(),
 						doseAccessor1->getDoseUID());
 					rttb::core::DVH dvh = *(calc.generateDVH());
 
 					clock_t finish(clock());
 					std::cout << "OTB Mask Calculation time: " << finish - start << " ms" << std::endl;
 
 					//Write the mask image to a file. 
 					/*! It takes a long time to write all mask files so that RUN_TESTS causes a timeout error. 
 						To write all mask files, please use the outcommented code and call the .exe directly!
 					*/
 					/*rttb::io::itk::ITKImageMaskAccessorConverter itkConverter(spOTBMaskAccessor);
 					CHECK(itkConverter.process());
 					std::stringstream fileNameSstr;
 					fileNameSstr<<OTBMask_DIRNAME<<j<<".mhd";
 					rttb::io::itk::ImageWriter writer(fileNameSstr.str(), itkConverter.getITKImage());
 					CHECK(writer.writeFile());*/
 
 
-
-
 					clock_t start2(clock());
 					//create Boost MaskAccessor		
 					MaskAccessorPointer boostMaskAccessorPtr = ::boost::make_shared<rttb::masks::boost::BoostMaskAccessor>(rtStructureSet->getStructure(j), geometricPtr);
 					CHECK_NO_THROW(boostMaskAccessorPtr->updateMask());
 
 					::boost::shared_ptr<core::GenericMaskedDoseIterator> spMaskedDoseIteratorTmp2 =
 						::boost::make_shared<core::GenericMaskedDoseIterator>(boostMaskAccessorPtr, doseAccessor1);
 					DoseIteratorPointer spMaskedDoseIterator2(spMaskedDoseIteratorTmp2);
 					rttb::core::DVHCalculator calc2(spMaskedDoseIterator2, (rtStructureSet->getStructure(j))->getUID(),
 						doseAccessor1->getDoseUID());
 					rttb::core::DVH dvh2 = *(calc2.generateDVH());
 
 					clock_t finish2(clock());
 					std::cout << "Boost Mask Calculation and write file time: " << finish2 - start2 << " ms" << std::endl;
 
 					//Write the mask image to a file. 
 					/*! It takes a long time to write all mask files so that RUN_TESTS causes a timeout error. 
 						To write all mask files, please use the outcommented code and call the .exe directly!
 					*/
 					/*rttb::io::itk::ITKImageMaskAccessorConverter itkConverter2(boostMaskAccessorPtr);
 					CHECK(itkConverter2.process());
 					std::stringstream fileNameSstr2;
 					fileNameSstr2<<BoostMask_DIRNAME<<j<<".mhd";
 					rttb::io::itk::ImageWriter writer2(fileNameSstr2.str(), itkConverter2.getITKImage());
 					CHECK(writer2.writeFile());*/
 
 
 					//check close of 2 voxelizatin: OTB and Boost
 					CHECK_CLOSE(dvh.getMaximum(), dvh2.getMaximum(), 0.1);
 					CHECK_CLOSE(dvh.getMinimum(), dvh2.getMinimum(), 0.1);
+					if(j!=7)//7: Ref.Pkt, mean = -1.#IND
+					{
+					CHECK_CLOSE(dvh.getMean(), dvh2.getMean(), 0.1);
+					}
+					CHECK_CLOSE(dvh.getMedian(), dvh2.getMedian(), 0.1);
+					CHECK_CLOSE(dvh.getModal(), dvh2.getModal(), 0.1);
 
 					//0: Aussenkontur and 3: Niere li. failed. 
 					if(j!=0 && j!=3){
 						CHECK_CLOSE(dvh.getVx(0), dvh2.getVx(0), dvh.getVx(0)*0.05);//check volume difference < 5% 
 					}
 
 				}
 			}
 
 
 
 			RETURN_AND_REPORT_TEST_SUCCESS;
 
 
 		}
 
 	}//testing
 }//rttb
 
diff --git a/testing/io/itk/ITKMaskAccessorConverterTest.cpp b/testing/io/itk/ITKMaskAccessorConverterTest.cpp
index b2cde03..60b0e1e 100644
--- a/testing/io/itk/ITKMaskAccessorConverterTest.cpp
+++ b/testing/io/itk/ITKMaskAccessorConverterTest.cpp
@@ -1,167 +1,162 @@
 // -----------------------------------------------------------------------
 // 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: 793 $ (last changed revision)
 // @date $Date: 2014-10-10 10:24:45 +0200 (Fr, 10 Okt 2014) $ (last change date)
 // @author $Author: hentsch $ (last changed by)
 */
 
 // this file defines the rttbCoreTests for the test driver
 // and all it expects is that you have a function called RegisterTests
 
 #include <boost/make_shared.hpp>
 #include <boost/shared_ptr.hpp>
 
 #include "litCheckMacros.h"
 #include "litImageTester.h"
 #include "litTestImageIO.h"
 
 #include "itkImage.h"
 #include "itkImageFileReader.h"
 
 #include "rttbBaseType.h"
 #include "rttbDoseIteratorInterface.h"
 #include "rttbDicomFileDoseAccessorGenerator.h"
 #include "rttbDicomDoseAccessor.h"
 #include "rttbInvalidDoseException.h"
 #include "rttbDicomFileStructureSetGenerator.h"
 #include "rttbITKImageMaskAccessorConverter.h"
 #include "rttbITKImageFileMaskAccessorGenerator.h"
 #include "rttbOTBMaskAccessor.h"
 
 
 
 namespace rttb
 {
 
 	namespace testing
 	{
 
 		/*!@brief MaskAccessorConverterTest - test the conversion rttb dose accessor ->itk
 		1) test with dicom file (DicomDoseAccessorGenerator)
 		2) test with mhd file (ITKImageFileDoseAccessorGenerator)
 		*/
 
 		int ITKMaskAccessorConverterTest(int argc, char* argv[])
 		{
 			typedef core::DoseIteratorInterface::DoseAccessorPointer DoseAccessorPointer;
 			typedef core::StructureSetGeneratorInterface::StructureSetPointer StructureSetPointer;
 			typedef core::MaskAccessorInterface::MaskAccessorPointer MaskAccessorPointer;
 			typedef io::itk::ITKImageMaskAccessor::ITKMaskImageType::Pointer ITKImageTypePointer;
 
 			PREPARE_DEFAULT_TEST_REPORTING;
 			//ARGUMENTS:
 			//ARGUMENTS: 1: structure file name
 			//           2: dose1 file name
 
 			std::string RTStr_FILENAME;
 			std::string RTDose_FILENAME;
 			std::string Mask_FILENAME;
 
 			if (argc > 3)
 			{
 				RTStr_FILENAME = argv[1];
 				RTDose_FILENAME = argv[2];
 				Mask_FILENAME = argv[3];
 			}
 
-			RTStr_FILENAME = "D:/RTToolboxProj/RTToolbox_sbr_branch/testing/data/DICOM/StructureSet/RS1.3.6.1.4.1.2452.6.841242143.1311652612.1170940299.4217870819.dcm";
-			RTDose_FILENAME = "D:/RTToolboxProj/RTToolbox_sbr_branch/testing/data/DICOM/TestDose/ConstantTwo.dcm" ;
-			Mask_FILENAME = "D:/RTToolboxProj/RTToolbox_sbr_branch/testing/data/MatchPointLogo.mhd";
-
-
 			//1) Read dicomFile and test getITKImage()
 			io::dicom::DicomFileDoseAccessorGenerator doseAccessorGenerator1(RTDose_FILENAME.c_str());
 			DoseAccessorPointer doseAccessor1(doseAccessorGenerator1.generateDoseAccessor());
 
 			StructureSetPointer rtStructureSet = io::dicom::DicomFileStructureSetGenerator(
 			        RTStr_FILENAME.c_str()).generateStructureSet();
 
 
 			MaskAccessorPointer maskAccessorPtr = boost::make_shared<rttb::masks::legacy::OTBMaskAccessor>(rtStructureSet->getStructure(0), doseAccessor1->getGeometricInfo());
 			
 			maskAccessorPtr->updateMask();//!Important: Update the mask before conversion.
 
 			io::itk::ITKImageMaskAccessorConverter maskAccessorConverter(maskAccessorPtr);
 
 			CHECK_NO_THROW(maskAccessorConverter.process());
 			CHECK_NO_THROW(maskAccessorConverter.getITKImage());
 
 			//2) Read itk image, generate mask and convert it back to itk image, check equal
 			MaskAccessorPointer maskAccessorPtr2 = io::itk::ITKImageFileMaskAccessorGenerator(Mask_FILENAME.c_str()).generateMaskAccessor();
 			maskAccessorPtr2->updateMask();//!Important: Update the mask before conversion.
 			io::itk::ITKImageMaskAccessorConverter maskAccessorConverter2(maskAccessorPtr2);
 			maskAccessorConverter2.process();
 
 			typedef itk::Image< DoseTypeGy, 3 >         MaskImageType;
 			typedef itk::ImageFileReader<MaskImageType> ReaderType;
 
 			ITKImageTypePointer convertedImagePtr = maskAccessorConverter2.getITKImage();
 
 			io::itk::ITKImageMaskAccessor::ITKMaskImageType::ConstPointer expectedImage =
 			    lit::TestImageIO<unsigned char, io::itk::ITKImageMaskAccessor::ITKMaskImageType>::readImage(
 			        Mask_FILENAME);
 
 			CHECK_EQUAL(convertedImagePtr->GetOrigin()[0], expectedImage->GetOrigin()[0]);
 			CHECK_EQUAL(convertedImagePtr->GetOrigin()[1], expectedImage->GetOrigin()[1]);
 			CHECK_EQUAL(convertedImagePtr->GetOrigin()[2], expectedImage->GetOrigin()[2]);
 
 			CHECK_EQUAL(convertedImagePtr->GetSpacing()[0], expectedImage->GetSpacing()[0]);
 			CHECK_EQUAL(convertedImagePtr->GetSpacing()[1], expectedImage->GetSpacing()[1]);
 			CHECK_EQUAL(convertedImagePtr->GetSpacing()[2], expectedImage->GetSpacing()[2]);
 
 			int sizeX = convertedImagePtr->GetLargestPossibleRegion().GetSize()[0];
 			int sizeY = convertedImagePtr->GetLargestPossibleRegion().GetSize()[1];
 			int sizeZ = convertedImagePtr->GetLargestPossibleRegion().GetSize()[2];
 
 			io::itk::ITKImageMaskAccessor::ITKMaskImageType::IndexType index;
 
 			for(unsigned int i=0; i<20 && i<sizeX && i<sizeY && i<sizeZ; i++){
 				index[0] = i;
 				index[1] = i;
 				index[2] = i;
 				if(expectedImage->GetPixel(index) >= 0 && expectedImage->GetPixel(index)<=1){
 					CHECK_EQUAL(convertedImagePtr->GetPixel(index), expectedImage->GetPixel(index));
 				}
 			}
 
 			for(unsigned int i=0; i<20; i++){
 				index[0] = sizeX -1-i;
 				index[1] = sizeY -1-i;
 				index[2] = sizeZ -1-i;
 
 				if(expectedImage->GetPixel(index) >= 0 && expectedImage->GetPixel(index)<=1){
 					CHECK_EQUAL(convertedImagePtr->GetPixel(index), expectedImage->GetPixel(index));
 				}
 			}
 
 			for(unsigned int i=0; i<20 && (sizeX/2 -i) < sizeX && (sizeY/2 -i) < sizeY && (sizeZ/2 -i) < sizeZ; i++){
 				index[0] = sizeX/2 -i;
 				index[1] = sizeY/2 -i;
 				index[2] = sizeZ/2 -i;
 
 				if(expectedImage->GetPixel(index) >= 0 && expectedImage->GetPixel(index)<=1){
 					CHECK_EQUAL(convertedImagePtr->GetPixel(index), expectedImage->GetPixel(index));
 				}
 			}
 
 
 			RETURN_AND_REPORT_TEST_SUCCESS;
 		}
 
 	}//testing
 }//rttb