diff --git a/code/masks/boost/rttbBoostMaskRedesign.cpp b/code/masks/boost/rttbBoostMaskRedesign.cpp
index bd1bf60..2b38494 100644
--- a/code/masks/boost/rttbBoostMaskRedesign.cpp
+++ b/code/masks/boost/rttbBoostMaskRedesign.cpp
@@ -1,579 +1,581 @@
 #include <iostream>
 #include <deque>
 #include <algorithm>
 #include <limits>
 
 #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 <boost/thread/thread.hpp>
 
 #include "rttbBoostMaskRedesign.h"
 #include "rttbNullPointerException.h"
 #include "rttbInvalidParameterException.h"
 #include "rttbBoostMaskGenerateMaskVoxelListThread.h"
 #include "rttbBoostMaskVoxelizationThread.h"
 
 
 
 namespace rttb
 {
 	namespace masks
 	{
 		namespace boostRedesign
 		{
 
 
 			BoostMask::BoostMask(BoostMask::GeometricInfoPointer aDoseGeoInfo,
 			                     BoostMask::StructPointer aStructure, bool strict, unsigned int numberOfThreads)
 				: _geometricInfo(aDoseGeoInfo), _structure(aStructure),
 				  _strict(strict), _numberOfThreads(numberOfThreads),
 				  _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!");
 				}
 
 				if (_numberOfThreads == 0)
 				{
 					_numberOfThreads = boost::thread::hardware_concurrency();
 				}
 
 				if (_numberOfThreads <= 0)
 				{
 					throw rttb::core::InvalidParameterException("Error: the given number of threads must > 0, or detection of the number of hardwore thread is not possible.");
 				}
 
 				std::cout << "number of threads: " << _numberOfThreads << std::endl;
 
 			}
 
 			BoostMask::MaskVoxelListPointer BoostMask::getRelevantVoxelVector()
 			{
 				if (!_isUpToDate)
 				{
 					calcMask();
 				}
 
 				return _voxelInStructure;
 			}
 
 			void BoostMask::calcMask()
 			{
 				preprocessing();
 				voxelization();
 				generateMaskVoxelList();
 				_isUpToDate = true;
 			}
 
 			void BoostMask::preprocessing()
 			{
 				rttb::PolygonSequenceType polygonSequence = _structure->getStructureVector();
 
 				//Convert world coordinate polygons to the polygons with geometry coordinate
 				rttb::PolygonSequenceType geometryCoordinatePolygonVector;
 				rttb::PolygonSequenceType::iterator it;
 				rttb::DoubleVoxelGridIndex3D globalMaxGridIndex(std::numeric_limits<double>::min(),
 				        std::numeric_limits<double>::min(), std::numeric_limits<double>::min());
 				rttb::DoubleVoxelGridIndex3D globalMinGridIndex(_geometricInfo->getNumColumns(),
 				        _geometricInfo->getNumRows(), 0);
 
 				for (it = polygonSequence.begin(); it != polygonSequence.end(); ++it)
 				{
 					PolygonType rttbPolygon = *it;
 					PolygonType geometryCoordinatePolygon;
 
 					//1. convert polygon to geometry coordinate polygons
 					//2. calculate global min/max
 					//3. check if polygon is planar
 					if (!preprocessingPolygon(rttbPolygon, geometryCoordinatePolygon, globalMinGridIndex,
 					                          globalMaxGridIndex, errorConstant))
 					{
 						throw rttb::core::Exception("TiltedMaskPlaneException");
 					}
 
 					geometryCoordinatePolygonVector.push_back(geometryCoordinatePolygon);
 				}
 
 				rttb::VoxelGridIndex3D minIndex = VoxelGridIndex3D(GridIndexType(globalMinGridIndex(0) + 0.5),
 				                                  GridIndexType(globalMinGridIndex(1) + 0.5), GridIndexType(globalMinGridIndex(2) + 0.5));
 				rttb::VoxelGridIndex3D maxIndex = VoxelGridIndex3D(GridIndexType(globalMaxGridIndex(0) + 0.5),
 				                                  GridIndexType(globalMaxGridIndex(1) + 0.5), GridIndexType(globalMaxGridIndex(2) + 0.5));
 				_globalBoundingBox.push_back(minIndex);
 				_globalBoundingBox.push_back(maxIndex);
 
 				//convert rttb polygon sequence to a map of z index and a vector of boost ring 2d (without holes)
 				_ringMap = convertRTTBPolygonSequenceToBoostRingMap(geometryCoordinatePolygonVector);
 
 			}
 
 			void BoostMask::voxelization()
 			{
 				BoostPolygonMap::iterator it;
 
 				if (_globalBoundingBox.size() < 2)
 				{
 					throw rttb::core::InvalidParameterException("Bounding box calculation failed! ");
 				}
 
 				unsigned int ringMapSize = _ringMap.size();
 
 				BoostRingMap::iterator itMap;
 
 				unsigned int mapSizeInAThread = _ringMap.size() / _numberOfThreads;
 				unsigned int count = 0;
 				unsigned int countThread = 0;
 				BoostPolygonMap polygonMap;
 				std::vector<BoostPolygonMap> polygonMapVector;
 
 				//check donut and convert to a map of z index and a vector of boost polygon 2d (with or without holes)
 				for (itMap = _ringMap.begin(); itMap != _ringMap.end(); ++itMap)
 				{
 					//the vector of all boost 2d polygons with the same z grid index(donut polygon is accepted).
 					BoostPolygonVector polygonVector = checkDonutAndConvert((*itMap).second);
 
 					if (count == mapSizeInAThread && countThread < (_numberOfThreads - 1))
 					{
 						polygonMapVector.push_back(polygonMap);
 						polygonMap.clear();
 						count = 0;
 						countThread++;
 					}
 
 					polygonMap.insert(std::pair<double, BoostPolygonVector>((*itMap).first,
 					                  polygonVector));
 					count++;
 
 				}
 
 				polygonMapVector.push_back(polygonMap); //insert the last one
 
 				//generate voxelization map, multi-threading
 				::boost::thread_group threads;
 				BoostMaskVoxelizationThread::VoxelizationQueuePointer resultQueue
 				    = ::boost::make_shared<::boost::lockfree::queue<BoostArray2D*>>
 				      (ringMapSize);
 				BoostMaskVoxelizationThread::VoxelizationIndexQueuePointer resultIndexQueue
 				    = ::boost::make_shared<::boost::lockfree::queue<double>>
 				      (ringMapSize);
 
 				for (int i = 0; i < polygonMapVector.size(); ++i)
 				{
 					BoostMaskVoxelizationThread t(polygonMapVector.at(i), _globalBoundingBox, resultIndexQueue,
 					                              resultQueue);
 					threads.create_thread(t);
 				}
 
 				threads.join_all();
 
 
 				BoostArray2D* array;
 				double index;
 
 				//generate voxelization map using resultQueue and resultIndexQueue
 				while (resultIndexQueue->pop(index) && resultQueue->pop(array))
 				{
 					_voxelizationMap.insert(std::pair<double, BoostArray2D>(index, *array));
 				}
 
 			}
 
 			void BoostMask::generateMaskVoxelList()
 			{
 				if (_globalBoundingBox.size() < 2)
 				{
 					throw rttb::core::InvalidParameterException("Bounding box calculation failed! ");
 				}
 
 				//check homogeneus of the voxelization plane (the contours plane)
 				if (!calcVoxelizationThickness(_voxelizationThickness))
 				{
 					throw rttb::core::InvalidParameterException("Error: The contour plane should be homogeneus!");
 				}
 
 
 				::boost::shared_ptr<::boost::lockfree::queue<core::MaskVoxel*>> resultQueue
 				        = ::boost::make_shared<::boost::lockfree::queue<core::MaskVoxel*>>
 				          (_geometricInfo->getNumberOfVoxels());
 
 
 				::boost::thread_group threads;
 
 				unsigned int sliceNumberInAThread = _geometricInfo->getNumSlices() / _numberOfThreads;
 
 				//generate mask voxel list, multi-threading
 				for (unsigned int i = 0; i < _numberOfThreads; ++i)
 				{
 					unsigned int beginSlice = i * sliceNumberInAThread;
 					unsigned int endSlice;
 
 					if (i < _numberOfThreads - 1)
 					{
 						endSlice = (i + 1) * sliceNumberInAThread;
 					}
 					else
 					{
 						endSlice = _geometricInfo->getNumSlices();
 					}
 
 
 					BoostMaskGenerateMaskVoxelListThread t(_globalBoundingBox, _geometricInfo, _voxelizationMap,
 					                                       _voxelizationThickness, beginSlice, endSlice,
 					                                       resultQueue);
 
 					threads.create_thread(t);
 
 				}
 
 				threads.join_all();
 
 				core::MaskVoxel* voxel;
 
 				//generate _voxelInStructure using resultQueue
 				while (resultQueue->pop(voxel))
 				{
 					_voxelInStructure->push_back(*voxel);//push back the mask voxel in structure
 				}
 
 			}
 
 			bool BoostMask::preprocessingPolygon(const rttb::PolygonType& aRTTBPolygon,
 			                                     rttb::PolygonType& geometryCoordinatePolygon, rttb::DoubleVoxelGridIndex3D& minimum,
 			                                     rttb::DoubleVoxelGridIndex3D& maximum, double aErrorConstant) const
 			{
 
 				double minZ = _geometricInfo->getNumSlices();
 				double maxZ =  0.0;
 
 				for (unsigned int i = 0; i < aRTTBPolygon.size(); i++)
 				{
 					rttb::WorldCoordinate3D worldCoordinatePoint = aRTTBPolygon.at(i);
 
 					//convert to geometry coordinate polygon
 					rttb::DoubleVoxelGridIndex3D geometryCoordinatePoint;
-					_geometricInfo->worldCoordinateToGeometryCoordinate(worldCoordinatePoint, geometryCoordinatePoint);
+
+					bool inside = _geometricInfo->worldCoordinateToGeometryCoordinate(worldCoordinatePoint,
+					              geometryCoordinatePoint);
 
 					geometryCoordinatePolygon.push_back(geometryCoordinatePoint);
 
 					//calculate the current global min/max
 					//min and max for x
 					if (geometryCoordinatePoint(0) < minimum(0))
 					{
 						minimum(0) = geometryCoordinatePoint(0);
 					}
 
 					if (geometryCoordinatePoint(0) > maximum(0))
 					{
 						maximum(0) = geometryCoordinatePoint(0);
 					}
 
 					//min and max for y
 					if (geometryCoordinatePoint(1) < minimum(1))
 					{
 						minimum(1) = geometryCoordinatePoint(1);
 					}
 
 					if (geometryCoordinatePoint(1) > maximum(1))
 					{
 						maximum(1) = geometryCoordinatePoint(1);
 					}
 
 					//min and max for z
 					if (geometryCoordinatePoint(2) < minimum(2))
 					{
 						minimum(2) = geometryCoordinatePoint(2);
 					}
 
 					if (geometryCoordinatePoint(2) > maximum(2))
 					{
 						maximum(2) = geometryCoordinatePoint(2);
 					}
 
 					//check planar
 					if (geometryCoordinatePoint(2) < minZ)
 					{
 						minZ = geometryCoordinatePoint(2);
 					}
 
 					if (geometryCoordinatePoint(2) > maxZ)
 					{
 						maxZ = geometryCoordinatePoint(2);
 					}
 
 				}
 
 				return (abs(maxZ - minZ) <= aErrorConstant);
 			}
 
 
 			BoostMask::BoostRing2D BoostMask::convertRTTBPolygonToBoostRing(const rttb::PolygonType&
 			        aRTTBPolygon) const
 			{
 				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::BoostRingMap BoostMask::convertRTTBPolygonSequenceToBoostRingMap(
 			    const rttb::PolygonSequenceType& aRTTBPolygonVector)
 			{
 				rttb::PolygonSequenceType::const_iterator it;
 				BoostMask::BoostRingMap aRingMap;
 
 				for (it = aRTTBPolygonVector.begin(); it != aRTTBPolygonVector.end(); ++it)
 				{
 					rttb::PolygonType rttbPolygon = *it;
 					double zIndex = rttbPolygon.at(0)[2];//get the first z index of the polygon
 					bool isFirstZ = true;
 
 					if (!aRingMap.empty())
 					{
 						BoostMask::BoostRingMap::iterator findIt = findNearestKey(aRingMap, zIndex, errorConstant);
 
 						//if the z index is found (same slice), add the polygon to vector
 						if (findIt != aRingMap.end())
 						{
 							//BoostRingVector ringVector = ;
 							(*findIt).second.push_back(convertRTTBPolygonToBoostRing(rttbPolygon));
 							isFirstZ = false;
 						}
 					}
 
 					//if it is the first z index in the map, insert vector with the polygon
 					if (isFirstZ)
 					{
 						BoostRingVector ringVector;
 						ringVector.push_back(convertRTTBPolygonToBoostRing(rttbPolygon));
 						aRingMap.insert(std::pair<double, BoostRingVector>(zIndex, ringVector));
 					}
 
 				}
 
 				return aRingMap;
 			}
 
 			BoostMask::BoostRingMap::iterator BoostMask::findNearestKey(BoostMask::BoostRingMap&
 			        aBoostRingMap, double aIndex, double aErrorConstant)
 			{
 				BoostMask::BoostRingMap::iterator find = aBoostRingMap.find(aIndex);
 
 				//if find a key equivalent to aIndex, found
 				if (find != aBoostRingMap.end())
 				{
 					return find;
 				}
 				else
 				{
 					BoostMask::BoostRingMap::iterator lowerBound = aBoostRingMap.lower_bound(aIndex);
 
 					//if all keys go before aIndex, check the last key
 					if (lowerBound == aBoostRingMap.end())
 					{
 						lowerBound = --aBoostRingMap.end();
 					}
 
 					//if the lower bound very close to aIndex, found
 					if (abs((*lowerBound).first - aIndex) <= aErrorConstant)
 					{
 						return lowerBound;
 					}
 					else
 					{
 						//if the lower bound is the beginning, not found
 						if (lowerBound == aBoostRingMap.begin())
 						{
 							return aBoostRingMap.end();
 						}
 						else
 						{
 							BoostMask::BoostRingMap::iterator lowerBound1 = --lowerBound;//the key before the lower bound
 
 							//if the key before the lower bound very close to a Index, found
 							if (abs((*lowerBound1).first - aIndex) <= aErrorConstant)
 							{
 								return lowerBound1;
 							}
 							//else, not found
 							else
 							{
 								return aBoostRingMap.end();
 							}
 						}
 					}
 
 				}
 			}
 
 			BoostMask::BoostPolygonVector BoostMask::checkDonutAndConvert(const BoostMask::BoostRingVector&
 			        aRingVector) const
 			{
 				//check donut
 				BoostMask::BoostRingVector::const_iterator it1;
 				BoostMask::BoostRingVector::const_iterator it2;
 				BoostMask::BoostPolygonVector boostPolygonVector;
 				std::vector<unsigned int> donutIndexVector;//store the outer and inner ring index
 				BoostMask::BoostPolygonVector donutVector;//store new generated donut polygon
 
 				//Get donut index and donut polygon
 				unsigned int index1 = 0;
 
 				for (it1 = aRingVector.begin(); it1 != aRingVector.end(); it1++, index1++)
 				{
 					bool it1IsDonut = false;
 
 					//check if the ring is already determined as a donut
 					for (unsigned int i = 0; i < donutIndexVector.size(); i++)
 					{
 						if (donutIndexVector.at(i) == index1)
 						{
 							it1IsDonut = true;
 							break;
 						}
 					}
 
 					//if not jet, check now
 					if (!it1IsDonut)
 					{
 						bool it2IsDonut = false;
 						unsigned int index2 = 0;
 
 						for (it2 = aRingVector.begin(); it2 != aRingVector.end(); it2++, index2++)
 						{
 							if (it2 != it1)
 							{
 								BoostMask::BoostPolygon2D polygon2D;
 
 								if (::boost::geometry::within(*it1, *it2))
 								{
 									::boost::geometry::append(polygon2D, *it2);//append an outer ring to the polygon
 									::boost::geometry::interior_rings(polygon2D).resize(1);//create an interior ring
 									::boost::geometry::append(polygon2D, *it1, 0);//append a ring to the interior ring
 									it2IsDonut = true;
 								}
 								//if donut
 								else if (::boost::geometry::within(*it2, *it1))
 								{
 									::boost::geometry::append(polygon2D, *it1);//append an outer ring to the polygon
 									::boost::geometry::interior_rings(polygon2D).resize(1);//create an interior ring
 									::boost::geometry::append(polygon2D, *it2, 0);//append a ring to the interior ring
 									it2IsDonut = true;
 								}
 
 								if (it2IsDonut)
 								{
 									donutIndexVector.push_back(index1);
 									donutIndexVector.push_back(index2);
 									donutVector.push_back(polygon2D);//store donut polygon
 									break;//Only store the first donut!
 								}
 							}
 						}
 					}
 				}
 
 				//Store no donut polygon to boostPolygonVector
 				index1 = 0;
 
 				for (it1 = aRingVector.begin(); it1 != aRingVector.end(); it1++, index1++)
 				{
 					bool it1IsDonut = false;
 
 					//check if the ring is the outer or inner of a donut
 					for (unsigned int i = 0; i < donutIndexVector.size(); i++)
 					{
 						if (donutIndexVector.at(i) == index1)
 						{
 							it1IsDonut = true;
 							break;
 						}
 					}
 
 					if (!it1IsDonut)
 					{
 						BoostMask::BoostPolygon2D polygon2D;
 						::boost::geometry::append(polygon2D, *it1);
 						boostPolygonVector.push_back(polygon2D);//insert the ring, which is not a part of donut
 					}
 				}
 
 				//Append donut polygon to boostPolygonVector
 				BoostMask::BoostPolygonVector::iterator itDonut;
 
 				for (itDonut = donutVector.begin(); itDonut != donutVector.end(); itDonut++)
 				{
 					boostPolygonVector.push_back(*itDonut);//append donuts
 				}
 
 				return boostPolygonVector;
 			}
 
 			bool BoostMask::calcVoxelizationThickness(double& aThickness) const
 			{
 				BoostArrayMap::const_iterator it = _voxelizationMap.begin();
 				BoostArrayMap::const_iterator it2 = ++_voxelizationMap.begin();
 
 				if (_voxelizationMap.size() <= 1)
 				{
 					aThickness = 1;
 					return true;
 				}
 
 				double thickness = 0;
 
 				for (;
 				     it != _voxelizationMap.end(), it2 != _voxelizationMap.end(); ++it, ++it2)
 				{
 					if (thickness == 0)
 					{
 						thickness = (*it2).first - (*it).first;
 					}
 					else
 					{
 						//if no homogeneous, return false
-						if (thickness != ((*it2).first - (*it).first))
+						if (abs(thickness - ((*it2).first - (*it).first)) > errorConstant)
 						{
 							return false;
 						}
 					}
 
 				}
 
 				if (thickness != 0)
 				{
 					aThickness = thickness;
 				}
 				else
 				{
 					aThickness = 1;
 				}
 
 				return true;
 			}
 		}
 	}
 }
diff --git a/testing/examples/CMakeLists.txt b/testing/examples/CMakeLists.txt
index e443665..1491ba9 100644
--- a/testing/examples/CMakeLists.txt
+++ b/testing/examples/CMakeLists.txt
@@ -1,41 +1,42 @@
 #-----------------------------------------------------------------------------
 # Setup the system information test.  Write out some basic failsafe
 # information in case the test doesn't run.
 #-----------------------------------------------------------------------------
 
 
 SET(CORE_TEST_EXAMPLES ${EXECUTABLE_OUTPUT_PATH}/rttbExamplesTests)
 
 SET(TEST_DATA_ROOT ${RTTBTesting_SOURCE_DIR}/data)
 
 SET(TEMP ${RTTBTesting_BINARY_DIR}/temporary)
 
 
 #-----------------------------------------------------------------------------
 ADD_TEST(RTBioModelExampleTest ${CORE_TEST_EXAMPLES} RTBioModelExampleTest
 "${TEST_DATA_ROOT}/TestDVH/dvh_PTV_HIT.txt" "${TEST_DATA_ROOT}/TestDVH/dvh_test_HT1.txt"
 "${TEST_DATA_ROOT}/TestDVH/dvh_test_HT2.txt" "${TEST_DATA_ROOT}/TestDVH/dvh_test_HT3.txt"
 "${TEST_DATA_ROOT}/TestDVH/dvh_test_TV.txt" "${TEST_DATA_ROOT}/TestDVH/dvh_virtuos_diff_trunk6.txt"
 "${TEST_DATA_ROOT}/TestDVH/dvh_virtuos_diff_trunk8.txt")
 ADD_TEST(DVHCalculatorExampleTest ${CORE_TEST_EXAMPLES} DVHCalculatorExampleTest
 "${TEST_DATA_ROOT}/DICOM/StructureSet/RS1.3.6.1.4.1.2452.6.841242143.1311652612.1170940299.4217870819.dcm" "${TEST_DATA_ROOT}/DICOM/TestDose/ConstantTwoGridScaling.dcm"
 "${TEST_DATA_ROOT}/DICOM/TestDose/ConstantTwoGridScaling05.dcm" "${TEST_DATA_ROOT}/DICOM/TestDose/ConstantFiftyGridScaling01.dcm")
 ADD_TEST(RTDoseIndexTest ${CORE_TEST_EXAMPLES} RTDoseIndexTest
 "${TEST_DATA_ROOT}/TestDVH/dvh_test_TV.txt" "${TEST_DATA_ROOT}/TestDVH/dvh_test_HT1.txt"
 "${TEST_DATA_ROOT}/TestDVH/dvh_test_HT2.txt" "${TEST_DATA_ROOT}/TestDVH/dvh_test_HT3.txt")
 ADD_TEST(RTDoseStatisticsTest ${CORE_TEST_EXAMPLES} RTDoseStatisticsTest
 "${TEST_DATA_ROOT}/DICOM/TestDose/ConstantTwo_withDoseGridScaling.dcm"
 "${TEST_DATA_ROOT}/Virtuos/prostate_ac/prostate_ac101.dos.gz"
 "${TEST_DATA_ROOT}/Virtuos/prostate_ac/prostate_ac000.vdx"
 "${TEST_DATA_ROOT}/Virtuos/prostate_ac/prostate_ac101.pln")
 ADD_TEST(RTDVHTest ${CORE_TEST_EXAMPLES} RTDVHTest "${TEST_DATA_ROOT}/TestDVH/dvh_test.txt")
 ADD_TEST(DVHCalculatorExampleTest ${CORE_TEST_EXAMPLES} DVHCalculatorExampleTest
 "${TEST_DATA_ROOT}/DICOM/StructureSet/RS1.3.6.1.4.1.2452.6.841242143.1311652612.1170940299.4217870819.dcm" "${TEST_DATA_ROOT}/DICOM/TestDose/ConstantTwo_withDoseGridScaling.dcm"
 "${TEST_DATA_ROOT}/DICOM/TestDose/LinearIncrease3D.dcm" "${TEST_DATA_ROOT}/DICOM/TestDose/LinearIncreaseX.dcm")
 ADD_TEST(RTBioModelScatterPlotExampleTest ${CORE_TEST_EXAMPLES} RTBioModelScatterPlotExampleTest
 "${TEST_DATA_ROOT}/TestDVH/dvh_PTV_HIT.txt" "${TEST_DATA_ROOT}/TestDVH/dvh_test_HT1.txt" "${TEST_DATA_ROOT}/TestDVH/dvh_test_TV.txt")
 ADD_TEST(VoxelizationValidationTest ${CORE_TEST_EXAMPLES} VoxelizationValidationTest
 "${TEST_DATA_ROOT}/DICOM/StructureSet/RS1.3.6.1.4.1.2452.6.841242143.1311652612.1170940299.4217870819.dcm"
-"${TEST_DATA_ROOT}/DICOM/TestDose/LinearIncrease3D.dcm" "${TEST_DATA_ROOT}/BoostMask/" "${TEST_DATA_ROOT}/OTBMask/" "${TEST_DATA_ROOT}/BoostMaskRedesign/")
+"${TEST_DATA_ROOT}/DICOM/TestDose/LinearIncrease3D.dcm" "${TEST_DATA_ROOT}/BoostMask/" "${TEST_DATA_ROOT}/OTBMask/" "${TEST_DATA_ROOT}/BoostMaskRedesign/"
+"${TEST_DATA_ROOT}/ValidationData/dose/PatBM116__RTDOSE_Main_corr.mhd" "${TEST_DATA_ROOT}/ValidationData/structure/__1__mm__1.2.276.0.28.19.640188827224102750711261838091512821903075578763.4195312189")
 
 RTTB_CREATE_TEST_MODULE(rttbExamples DEPENDS RTTBCore RTTBAlgorithms RTTBMasks RTTBOTBMask RTTBBoostMask RTTBIndices RTTBDicomIO RTTBVirtuosIO RTTBITKIO RTTBOtherIO RTTBModels PACKAGE_DEPENDS Litmus)
diff --git a/testing/examples/VoxelizationValidationTest.cpp b/testing/examples/VoxelizationValidationTest.cpp
index 4b1347a..9226a63 100644
--- a/testing/examples/VoxelizationValidationTest.cpp
+++ b/testing/examples/VoxelizationValidationTest.cpp
@@ -1,247 +1,290 @@
 // -----------------------------------------------------------------------
 // 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)
 */
 
 // 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 "rttbDicomDoseAccessor.h"
 #include "rttbDicomFileDoseAccessorGenerator.h"
 #include "rttbDicomFileStructureSetGenerator.h"
 #include "rttbOTBMaskAccessor.h"
 #include "rttbDVHTxtFileReader.h"
 #include "rttbBoostMaskAccessor.h"
 #include "rttbITKImageMaskAccessorConverter.h"
 #include "rttbImageWriter.h"
 #include "rttbBoostMaskRedesign.h"
 #include "rttbBoostMaskRedesignAccessor.h"
+#include "rttbITKImageAccessorGenerator.h"
+#include "rttbITKImageFileAccessorGenerator.h"
+#include "rttbInvalidParameterException.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;
 			std::string BoostMaskRedesign_DIRNAME;
 
+			std::string RTDose_BoostFailed;
+			std::string RTStr_BoostFailed;
+
 			if (argc > 4)
 			{
 				RTSTRUCT_FILENAME = argv[1];
 				RTDOSE_FILENAME = argv[2];
 				BoostMask_DIRNAME = argv[3];
 				OTBMask_DIRNAME = argv[4];
 				BoostMaskRedesign_DIRNAME = argv[5];
+
+				RTDose_BoostFailed = argv[6];
+				RTStr_BoostFailed = argv[7];
 			}
 
 			OFCondition status;
 			DcmFileFormat fileformat;
 
 			/* read dicom-rt dose */
 			io::dicom::DicomFileDoseAccessorGenerator doseAccessorGenerator1(RTDOSE_FILENAME.c_str());
 			DoseAccessorPointer doseAccessor1(doseAccessorGenerator1.generateDoseAccessor());
 
 			//create a vector of MaskAccessors (one for each structure)
 			StructureSetPointer rtStructureSet = io::dicom::DicomFileStructureSetGenerator(
 			        RTSTRUCT_FILENAME.c_str()).generateStructureSet();
 
 
 			if (rtStructureSet->getNumberOfStructures() > 0)
 			{
 				for (size_t j = 0; j < rtStructureSet->getNumberOfStructures(); j++)
 				{
-					if (j != 2 && j != 3)
-					{
 					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->getUID());
 					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);
+						*/
+					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());*/
+					CHECK(writer.writeFile());
 
 
 
 					clock_t start2(clock());
 					//create Boost MaskAccessor
 					MaskAccessorPointer boostMaskAccessorPtr
 					    = ::boost::make_shared<rttb::masks::boost::BoostMaskAccessor>
 					      (rtStructureSet->getStructure(j), doseAccessor1->getGeometricInfo());
 
 					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->getUID());
 					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);
+					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());*/
-
-						//create Boost MaskAccessor redesign
-						clock_t startR(clock());
-
-						MaskAccessorPointer boostMaskRPtr
-						    = ::boost::make_shared<rttb::masks::boostRedesign::BoostMaskAccessor>
-						      (rtStructureSet->getStructure(j), doseAccessor1->getGeometricInfo());
-						CHECK_NO_THROW(boostMaskRPtr->updateMask());
-						::boost::shared_ptr<core::GenericMaskedDoseIterator> spMaskedDoseIteratorTmpR =
-						    ::boost::make_shared<core::GenericMaskedDoseIterator>(boostMaskRPtr, doseAccessor1);
-						DoseIteratorPointer spMaskedDoseIteratorR(spMaskedDoseIteratorTmpR);
-						rttb::core::DVHCalculator calcR(spMaskedDoseIteratorR, (rtStructureSet->getStructure(j))->getUID(),
-						                                doseAccessor1->getUID());
-						rttb::core::DVH dvhR = *(calcR.generateDVH());
-						clock_t finishR(clock());
-						std::cout << "Boost Mask Redesign Calculation and write file time: " << finishR - startR << " 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 itkConverterR(boostMaskRPtr);
-						CHECK(itkConverterR.process());
+					CHECK(writer2.writeFile());
 
 
-						std::stringstream fileNameSstrR;
-						fileNameSstrR << BoostMaskRedesign_DIRNAME << j << ".mhd";
-						rttb::io::itk::ImageWriter writerR(fileNameSstrR.str(), itkConverterR.getITKImage());
-						CHECK(writerR.writeFile());*/
+					//create Boost MaskAccessor redesign
+					clock_t startR(clock());
+
+					MaskAccessorPointer boostMaskRPtr
+					    = ::boost::make_shared<rttb::masks::boostRedesign::BoostMaskAccessor>
+					      (rtStructureSet->getStructure(j), doseAccessor1->getGeometricInfo());
+					CHECK_NO_THROW(boostMaskRPtr->updateMask());
+					::boost::shared_ptr<core::GenericMaskedDoseIterator> spMaskedDoseIteratorTmpR =
+					    ::boost::make_shared<core::GenericMaskedDoseIterator>(boostMaskRPtr, doseAccessor1);
+					DoseIteratorPointer spMaskedDoseIteratorR(spMaskedDoseIteratorTmpR);
+					rttb::core::DVHCalculator calcR(spMaskedDoseIteratorR, (rtStructureSet->getStructure(j))->getUID(),
+					                                doseAccessor1->getUID());
+					rttb::core::DVH dvhR = *(calcR.generateDVH());
+					clock_t finishR(clock());
+					std::cout << "Boost Mask Redesign Calculation and write file time: " << finishR - startR << " 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 itkConverterR(boostMaskRPtr);
+					CHECK(itkConverterR.process());
+
+
+					std::stringstream fileNameSstrR;
+					fileNameSstrR << BoostMaskRedesign_DIRNAME << j << ".mhd";
+					rttb::io::itk::ImageWriter writerR(fileNameSstrR.str(), itkConverterR.getITKImage());
+					CHECK(writerR.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)
+					if (j != 7)
 					{
 						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%
 					}
 
-						//check close of 2 voxelization: Boost and BoostRedesign
-						CHECK_CLOSE(dvhR.getMaximum(), dvh2.getMaximum(), 0.1);
-						CHECK_CLOSE(dvhR.getMinimum(), dvh2.getMinimum(), 0.1);
+					//check close of 2 voxelization: Boost and BoostRedesign
+					CHECK_CLOSE(dvhR.getMaximum(), dvh2.getMaximum(), 0.1);
+					CHECK_CLOSE(dvhR.getMinimum(), dvh2.getMinimum(), 0.1);
 
-						if (j != 7)
-						{
-							CHECK_CLOSE(dvhR.getMean(), dvh2.getMean(), 0.1);
-				}
+					if (j != 7)
+					{
+						CHECK_CLOSE(dvhR.getMean(), dvh2.getMean(), 0.1);
+					}
 
-						CHECK_CLOSE(dvhR.getMedian(), dvh2.getMedian(), 0.1);
-						CHECK_CLOSE(dvhR.getModal(), dvh2.getModal(), 0.1);
+					CHECK_CLOSE(dvhR.getMedian(), dvh2.getMedian(), 0.1);
+					CHECK_CLOSE(dvhR.getModal(), dvh2.getModal(), 0.1);
 
-						//0: Aussenkontur and 3: Niere li. failed.
-						CHECK_CLOSE(dvhR.getVx(0), dvh2.getVx(0), dvhR.getVx(0) * 0.05); //check volume difference < 5%
+					//0: Aussenkontur and 3: Niere li. failed.
+					CHECK_CLOSE(dvhR.getVx(0), dvh2.getVx(0), dvhR.getVx(0) * 0.05); //check volume difference < 5%
 
-			}
 				}
 			}
 
+			/* Exception tests using data with different z spacing of dose and structure */
+			io::itk::ITKImageFileAccessorGenerator doseAccessorGenerator2(RTDose_BoostFailed.c_str());
+			DoseAccessorPointer doseAccessor2(doseAccessorGenerator2.generateDoseAccessor());
+
+			StructureSetPointer rtStructureSet2 = io::dicom::DicomFileStructureSetGenerator(
+			        RTStr_BoostFailed.c_str()).generateStructureSet();
+
 
+			if (rtStructureSet2->getNumberOfStructures() > 0)
+			{
+				for (size_t j = 1; j < 20; j++)
+				{
+					std::cout << j << ": " << rtStructureSet2->getStructure(j)->getLabel() << std::endl;
+					clock_t start(clock());
+
+					//create Boost MaskAccessor
+					MaskAccessorPointer boostMaskAccessorPtr
+					    = ::boost::make_shared<rttb::masks::boost::BoostMaskAccessor>
+					      (rtStructureSet2->getStructure(j), doseAccessor2->getGeometricInfo());
+
+					//Two polygons in the same slice exception using boost mask, because of the different z spacing of dose and structure
+					if (j != 9)
+					{
+						CHECK_THROW_EXPLICIT(boostMaskAccessorPtr->updateMask(), rttb::core::InvalidParameterException);
+					}
+
+
+					//create Boost MaskAccessor redesign
+					MaskAccessorPointer boostMaskRPtr
+					    = ::boost::make_shared<rttb::masks::boostRedesign::BoostMaskAccessor>
+					      (rtStructureSet2->getStructure(j), doseAccessor2->getGeometricInfo());
+					//No exception using redesigned boost mask
+					CHECK_NO_THROW(boostMaskRPtr->updateMask());
+
+				}
+			}
 
 			RETURN_AND_REPORT_TEST_SUCCESS;
 
 
 		}
 
 	}//testing
 }//rttb