diff --git a/code/core/rttbBaseType.h b/code/core/rttbBaseType.h
index 64b7fac..67cc429 100644
--- a/code/core/rttbBaseType.h
+++ b/code/core/rttbBaseType.h
@@ -1,613 +1,613 @@
 // -----------------------------------------------------------------------
 // RTToolbox - DKFZ radiotherapy quantitative evaluation library
 //
 // Copyright (c) German Cancer Research Center (DKFZ),
 // Software development for Integrated Diagnostics and Therapy (SIDT).
 // ALL RIGHTS RESERVED.
 // See rttbCopyright.txt or
 // http://www.dkfz.de/en/sidt/projects/rttb/copyright.html
 //
 // This software is distributed WITHOUT ANY WARRANTY; without even
 // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 // PURPOSE.  See the above copyright notices for more information.
 //
 //------------------------------------------------------------------------
 
 #ifndef __BASE_TYPE_NEW_H
 #define __BASE_TYPE_NEW_H
 
 #include <string>
 #include <vector>
 #include <list>
 #include <ostream>
 
 #include <boost/serialization/array_wrapper.hpp>
 #include <boost/numeric/ublas/vector.hpp>
 #include <boost/numeric/ublas/matrix.hpp>
 
 #include <RTTBCoreExports.h>
 
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable: 4251)
 #endif
 
 namespace rttb
 {
 
 	const double errorConstant = 1e-5;
 	const double reducedErrorConstant = 0.0001;
 
-	using UnsignedIndex1D = unsigned short;
+	using Index1D = unsigned short;
 
 	/*! @class Index3D
 		@brief 3D index.
 	*/
-	class Index3D: public boost::numeric::ublas::vector<UnsignedIndex1D>
+	class Index3D: public boost::numeric::ublas::vector<Index1D>
 	{
 	public:
-		Index3D() : boost::numeric::ublas::vector<UnsignedIndex1D>(3,0) {}
-		explicit Index3D(const UnsignedIndex1D value) : boost::numeric::ublas::vector<UnsignedIndex1D>(3,
+		Index3D() : boost::numeric::ublas::vector<Index1D>(3,0) {}
+		explicit Index3D(const Index1D value) : boost::numeric::ublas::vector<Index1D>(3,
 			        value) {}
-		Index3D(const UnsignedIndex1D  xValue, const UnsignedIndex1D  yValue,
-		                const UnsignedIndex1D  zValue)
-			: boost::numeric::ublas::vector<UnsignedIndex1D >(3, xValue)
+		Index3D(const Index1D  xValue, const Index1D  yValue,
+		                const Index1D  zValue)
+			: boost::numeric::ublas::vector<Index1D >(3, xValue)
 		{
 			(*this)(1) = yValue;
 			(*this)(2) = zValue;
 		}
 
-		const UnsignedIndex1D x() const
+		const Index1D x() const
 		{
 			return (*this)(0);
 		}
-		const UnsignedIndex1D y() const
+		const Index1D y() const
 		{
 			return (*this)(1);
 		}
-		const UnsignedIndex1D z() const
+		const Index1D z() const
 		{
 			return (*this)(2);
 		}
 		friend bool operator==(const Index3D& gi1, const Index3D& gi2)
 		{
 			if (gi1.size() != gi2.size())
 			{
 				return false;
 			}
 
 			for (size_t i = 0; i < gi1.size(); i++)
 			{
 				if (gi1(i) != gi2(i))
 				{
 					return false;
 				}
 			}
 
 			return true;
 		}
 
 		friend std::ostream& operator<<(std::ostream& s, const Index3D& aVector)
 		{
 			s << "[ " << aVector(0) << ", " << aVector(1) << ", " << aVector(2) << " ]";
 			return s;
 		}
 	};
 
-	using UnsignedIndexList = std::list<Index3D>;
+	using IndexList = std::list<Index3D>;
 
 	using FileNameString = std::string;
 
 	using ContourGeometricTypeString = std::string;
 
 	using WorldCoordinate = double;
 
 	/*! @class WorldCoordinate3D
 		@brief 3D coordinate in real world coordinates like in DICOM to define ImagePositionPatient.
 	*/
 	class WorldCoordinate3D: public boost::numeric::ublas::vector<WorldCoordinate>
 	{
 	public:
 		WorldCoordinate3D() : boost::numeric::ublas::vector<WorldCoordinate>(3,0) {}
 		explicit WorldCoordinate3D(const WorldCoordinate value) : boost::numeric::ublas::vector<WorldCoordinate>(3,
 			        value) {}
 		WorldCoordinate3D(const WorldCoordinate xValue, const WorldCoordinate yValue,
 		                  const WorldCoordinate zValue)
 			: boost::numeric::ublas::vector<WorldCoordinate>(3, xValue)
 		{
 			(*this)(1) = yValue;
 			(*this)(2) = zValue;
 		}
 		WorldCoordinate3D(const WorldCoordinate3D& w): boost::numeric::ublas::vector<WorldCoordinate>(3)
 		{
 			(*this)(0) = w.x();
 			(*this)(1) = w.y();
 			(*this)(2) = w.z();
 		}
 
 		const WorldCoordinate x() const
 		{
 			return (*this)(0);
 		}
 		const WorldCoordinate y() const
 		{
 			return (*this)(1);
 		}
 		const WorldCoordinate z() const
 		{
 			return (*this)(2);
 		}
 
 		//vector cross product (not included in boost.ublas)
 		WorldCoordinate3D cross(WorldCoordinate3D aVector) const
 		{
 			WorldCoordinate3D result;
 			WorldCoordinate x = (*this)(0);
 			WorldCoordinate y = (*this)(1);
 			WorldCoordinate z = (*this)(2);
 
 			result(0) = y * aVector(2) - z * aVector(1);
 			result(1) = z * aVector(0) - x * aVector(2);
 			result(2) = x * aVector(1) - y * aVector(0);
 
 			return result;
 		}
 
 		const std::string toString() const
 		{
       std::string s = std::to_string(x()) + " " + std::to_string(y()) + " " + std::to_string(z());
 			return s;
 		}
 
 		WorldCoordinate3D& operator=(const WorldCoordinate3D& wc)
 		{
 			(*this)(0) = wc.x();
 			(*this)(1) = wc.y();
 			(*this)(2) = wc.z();
 			return (*this);
 		}
 
 		WorldCoordinate3D& operator=(const boost::numeric::ublas::vector<WorldCoordinate> wc)
 		{
 			(*this)(0) = wc(0);
 			(*this)(1) = wc(1);
 			(*this)(2) = wc(2);
 			return (*this);
 		}
 
 		WorldCoordinate3D operator-(const boost::numeric::ublas::vector<WorldCoordinate> wc)
 		{
 			return WorldCoordinate3D((*this)(0) - wc(0), (*this)(1) - wc(1), (*this)(2) - wc(2));
 		}
 
 		WorldCoordinate3D operator+(const boost::numeric::ublas::vector<WorldCoordinate> wc)
 		{
 			return WorldCoordinate3D((*this)(0) + wc(0), (*this)(1) + wc(1), (*this)(2) + wc(2));
 		}
 
 		friend bool operator==(const WorldCoordinate3D& wc1, const WorldCoordinate3D& wc2)
 		{
 			if (wc1.size() != wc2.size())
 			{
 				return false;
 			}
 
 			for (size_t i = 0; i < wc1.size(); i++)
 			{
 				if (wc1(i) != wc2(i))
 				{
 					return false;
 				}
 			}
 
 			return true;
 		}
 
 		bool equalsAlmost(const WorldCoordinate3D& another, double errorConstantWC = 1e-5) const
 		{
 			if (size() != another.size())
 			{
 				return false;
 			}
 
 			double dist = norm_2(*this - another);
 			return dist < errorConstantWC;
 		}
 
 		friend std::ostream& operator<<(std::ostream& s, const WorldCoordinate3D& aVector)
 		{
 			s << "[ " << aVector(0) << ", " << aVector(1) << ", " << aVector(2) << " ]";
 			return s;
 		}
 
 	};
 
     /* ! @brief continuous index */
 	using ContinousVoxelGridIndex3D = rttb::WorldCoordinate3D;
 
 	using ImageSize = rttb::Index3D;
 
 	using GridVolumeType = double;
 
 	/*! @class SpacingVectorType3D
 		@brief 3D spacing vector.
 		@pre values of this vector may not be negative.
 	*/
 	class SpacingVectorType3D: public boost::numeric::ublas::vector<GridVolumeType>
 	{
 	public:
 		SpacingVectorType3D() : boost::numeric::ublas::vector<GridVolumeType>(3,0) {}
 		explicit SpacingVectorType3D(const GridVolumeType value) : boost::numeric::ublas::vector<GridVolumeType>(3,
 			        value) 
 		{
 			if (value < 0) {
 				throw std::invalid_argument("received negative value");
 			}
 		}
 
 		SpacingVectorType3D(const GridVolumeType xValue, const GridVolumeType yValue,
 		                    const GridVolumeType zValue)
 			: boost::numeric::ublas::vector<GridVolumeType>(3)
 		{
 			if (xValue < 0 || yValue < 0 || zValue < 0) {
 				throw std::invalid_argument("received negative value");
 			}
 			(*this)(0) = xValue;
 			(*this)(1) = yValue;
 			(*this)(2) = zValue;
 		}
 
 		SpacingVectorType3D(const SpacingVectorType3D& w) : SpacingVectorType3D(w.x(), w.y(), w.z()) { }
 
 		const GridVolumeType x() const
 		{
 			return (*this)(0);
 		}
 
 		const GridVolumeType y() const
 		{
 			return (*this)(1);
 		}
 
 		const GridVolumeType z() const
 		{
 			return (*this)(2);
 		}
 
 		const std::string toString() const
 		{
       std::string s = std::to_string(x()) + " " + std::to_string(y()) + " " + std::to_string(z());
       return s;
 		}
 
 		SpacingVectorType3D& operator=(const SpacingVectorType3D& wc)
 		{
 			(*this)(0) = wc.x();
 			(*this)(1) = wc.y();
 			(*this)(2) = wc.z();
 			return (*this);
 		}
 
 		SpacingVectorType3D& operator=(const WorldCoordinate3D& wc)
 		{
 			(*this)(0) = GridVolumeType(wc.x());
 			(*this)(1) = GridVolumeType(wc.y());
 			(*this)(2) = GridVolumeType(wc.z());
 			return (*this);
 		}
 
 		SpacingVectorType3D& operator=(const boost::numeric::ublas::vector<GridVolumeType> wc)
 		{
 			(*this)(0) = wc(0);
 			(*this)(1) = wc(1);
 			(*this)(2) = wc(2);
 			return (*this);
 		}
 
 		friend bool operator==(const SpacingVectorType3D& wc1, const SpacingVectorType3D& wc2)
 		{
 			if (wc1.size() != wc2.size())
 			{
 				return false;
 			}
 
 			for (size_t i = 0; i < wc1.size(); i++)
 			{
 				if (wc1(i) != wc2(i))
 				{
 					return false;
 				}
 			}
 
 			return true;
 		}
 
 		bool equalsAlmost(const SpacingVectorType3D& another, double errorConstantSV = 1e-5) const
 		{
 			if ((*this).size() != another.size())
 			{
 				return false;
 			}
 
 			double dist = norm_2(*this - another);
 			return dist < errorConstantSV;
 		}
 
 		friend std::ostream& operator<<(std::ostream& s, const SpacingVectorType3D& aVector)
 		{
 			s << "[ " << aVector(0) << ", " << aVector(1) << ", " << aVector(2) << " ]";
 			return s;
 		}
 	};
 
 	/*!	@class OrientationMatrix
 		@brief Used to store image orientation information
 	*/
 	class OrientationMatrix : public boost::numeric::ublas::matrix<WorldCoordinate>
 	{
 	public:
 		/*! The default constructor generates a 3x3 unit matrix
 		*/
 		OrientationMatrix() : boost::numeric::ublas::matrix<WorldCoordinate>(3, 3, 0)
 		{
 			for (std::size_t m = 0; m < (*this).size1(); m++)
 			{
 				(*this)(m, m) = 1;
 			}
 		}
 		explicit OrientationMatrix(const WorldCoordinate value) : boost::numeric::ublas::matrix<WorldCoordinate>(3,
 			        3, value) {}
 
 		bool equalsAlmost(const OrientationMatrix& anOrientationMatrix, double errorConstantOM=1e-5) const
 		{
 			if (anOrientationMatrix.size1() == (*this).size1())
 			{
 				if (anOrientationMatrix.size2() == (*this).size2())
 				{
 					for (std::size_t m = 0; m < anOrientationMatrix.size1(); m++)
 					{
 						for (std::size_t n = 0; n < anOrientationMatrix.size2(); n++)
 						{
 							if ((std::abs((*this)(m, n) - anOrientationMatrix(m, n)) > errorConstantOM))
 							{
 								return false;
 							}
 						}
 					}// end element comparison
 				}
 				else
 				{
 					return false;
 				}
 			}
 			else
 			{
 				return false;
 			}
 
 			return true;
 		}
 
 		friend bool operator==(const OrientationMatrix& om1, const OrientationMatrix& om2)
 		{
 			return om1.equalsAlmost(om2, 0.0);
 		}
 
 		friend std::ostream& operator<<(std::ostream& s, const OrientationMatrix& anOrientationMatrix)
 		{
 			s << "[ ";
 
 			for (std::size_t m = 0; m < anOrientationMatrix.size1(); m++)
 			{
 				s << "[ ";
 
 				for (std::size_t n = 0; n < anOrientationMatrix.size2(); n++)
 				{
 					if (n == 0)
 					{
 						s << anOrientationMatrix(m, n);
 					}
 					else
 					{
 						s << ", " << anOrientationMatrix(m, n);
 					}
 				}
 
 				s << " ]";
 			}
 
 			s << " ]";
 			return s;
 		}
 	};
 
 
 	/*! base for 2D and 3D VoxelIndex; Therefore required beside VoxelGridID
 	*/
 	using GridIndexType = unsigned int;
 
 	/*! @class VoxelGridIndex3D
 		@brief 3D voxel grid index in a discret geometry (matrix/image).
         @details analogous to DICOM where ImagePositionPatient gives the position of the center of the first coordinate (0/0/0)
 	*/
 	class VoxelGridIndex3D: public boost::numeric::ublas::vector<GridIndexType>
 	{
 	public:
 		VoxelGridIndex3D() : boost::numeric::ublas::vector<GridIndexType>(3,0) {}
 		explicit VoxelGridIndex3D(const GridIndexType value) : boost::numeric::ublas::vector<GridIndexType>(3,
 			        value) {}
 		VoxelGridIndex3D(const GridIndexType xValue, const GridIndexType yValue, const GridIndexType zValue)
 			: boost::numeric::ublas::vector<GridIndexType>(3, xValue)
 		{
 			(*this)(1) = yValue;
 			(*this)(2) = zValue;
 		}
 
 		const GridIndexType x() const
 		{
 			return (*this)(0);
 		}
 		const GridIndexType y() const
 		{
 			return (*this)(1);
 		}
 		const GridIndexType z() const
 		{
 			return (*this)(2);
 		}
 
 		const std::string toString() const
 		{
       std::string s = std::to_string(x()) + " " + std::to_string(y()) + " " + std::to_string(z());
       return s;
 		}
 
 		VoxelGridIndex3D& operator=(const Index3D& ui)
 		{
 			(*this)(0) = ui(0);
 			(*this)(1) = ui(1);
 			(*this)(2) = ui(2);
 			return (*this);
 		}
 
 		friend bool operator==(const VoxelGridIndex3D& gi1, const VoxelGridIndex3D& gi2)
 		{
 			if (gi1.size() != gi2.size())
 			{
 				return false;
 			}
 
 			for (size_t i = 0; i < gi1.size(); i++)
 			{
 				if (gi1(i) != gi2(i))
 				{
 					return false;
 				}
 			}
 
 			return true;
 		}
 
 		friend std::ostream& operator<<(std::ostream& s, const VoxelGridIndex3D& aVector)
 		{
 			s << "[ " << aVector(0) << ", " << aVector(1) << ", " << aVector(2) << " ]";
 			return s;
 		}
 	};
 
 
 	/*! @class VoxelGridIndex3D
 		@brief 2D voxel grid index.
 	*/
 	class VoxelGridIndex2D: public boost::numeric::ublas::vector<GridIndexType>
 	{
 	public:
 		VoxelGridIndex2D() : boost::numeric::ublas::vector<GridIndexType>(2,0) {}
 		explicit VoxelGridIndex2D(const GridIndexType value) : boost::numeric::ublas::vector<GridIndexType>(2,
 			        value) {}
 		VoxelGridIndex2D(const GridIndexType xValue, const GridIndexType yValue)
 			: boost::numeric::ublas::vector<GridIndexType>(2, xValue)
 		{
 			(*this)(1) = yValue;
 		}
 
 		const GridIndexType x() const
 		{
 			return (*this)(0);
 		}
 		const GridIndexType y() const
 		{
 			return (*this)(1);
 		}
 
 		const std::string toString() const
 		{
       std::string s = std::to_string(x()) + " " + std::to_string(y());
       return s;
 		}
 
 		friend bool operator==(const VoxelGridIndex2D& gi1, const VoxelGridIndex2D& gi2)
 		{
 			if (gi1.size() != gi2.size())
 			{
 				return false;
 			}
 
 			for (size_t i = 0; i < gi1.size(); i++)
 			{
 				if (gi1(i) != gi2(i))
 				{
 					return false;
 				}
 			}
 
 			return true;
 		}
 
 		friend std::ostream& operator<<(std::ostream& s, const VoxelGridIndex2D& aVector)
 		{
 			s << "[ " << aVector(0) << ", " << aVector(1) << " ]";
 			return s;
 		}
 	};
 
 	using GridSizeType = long;
 
 	using VoxelGridID = int; //starts from 0 and is continuously counting all positions on the grid
 	using VoxelGridDimensionType = unsigned int;
 
 	typedef double FractionType, DVHVoxelNumber;
 
 	typedef double DoseCalcType, DoseTypeGy, GenericValueType, DoseVoxelVolumeType, VolumeType,
 	        GridVolumeType, PercentType,
 	        VoxelNumberType, BEDType,
 	        LQEDType;
 
 	using IDType = std::string;
 
 	using StructureLabel = std::string;
 
 	struct DVHRole
 	{
 		enum Type
 		{
 			TargetVolume = 1,
 			HealthyTissue = 2,
 			WholeVolume = 4,
 			UserDefined = 128
 		} Type;
 	};
 
 	struct DVHType
 	{
 		enum Type
 		{
 			Differential = 1,
 			Cumulative = 2
 		} Type;
 	};
 
   using FileNameType = std::string;
 
 	using PolygonType = std::vector<WorldCoordinate3D>;
 
 	using PolygonSequenceType = std::vector<PolygonType>;
 
 	using IndexValueType = double;
 
 	using DoseStatisticType = double;
 
 	using DICOMRTFileNameString = std::string;
 
 	using Uint16 = unsigned short;
 
 	typedef std::string XMLString, StatisticsString;
 
 
 }//end: namespace rttb
 
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
 
 #endif
diff --git a/code/core/rttbGeometricInfo.cpp b/code/core/rttbGeometricInfo.cpp
index 6cde4fc..f161f52 100644
--- a/code/core/rttbGeometricInfo.cpp
+++ b/code/core/rttbGeometricInfo.cpp
@@ -1,304 +1,304 @@
 // -----------------------------------------------------------------------
 // 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.
 //
 //------------------------------------------------------------------------
 
 #include "rttbGeometricInfo.h"
 
 #include <boost/numeric/ublas/matrix.hpp>
 #include <boost/numeric/ublas/lu.hpp>
 #include <boost/numeric/ublas/io.hpp>
 
 namespace rttb
 {
 	namespace core
 	{
 
 		void GeometricInfo::setSpacing(const SpacingVectorType3D& aSpacingVector)
 		{
 			_spacing = aSpacingVector;
 		}
 
 		const SpacingVectorType3D& GeometricInfo::getSpacing() const
 		{
 			return _spacing;
 		}
 
 		void GeometricInfo::setImagePositionPatient(const WorldCoordinate3D& aImagePositionPatient)
 		{
 			_imagePositionPatient = aImagePositionPatient;
 		}
 
 		const WorldCoordinate3D& GeometricInfo::getImagePositionPatient() const
 		{
 			return _imagePositionPatient;
 		}
 
 		void GeometricInfo::setOrientationMatrix(const OrientationMatrix& anOrientationMatrix)
 		{
 			_orientationMatrix = anOrientationMatrix;
 			computeInvertOrientation();
 		}
 
 		bool GeometricInfo::computeInvertOrientation()
 		{
 			using pmatrix = boost::numeric::ublas::permutation_matrix<std::size_t>;
 
 			boost::numeric::ublas::matrix<WorldCoordinate> A(_orientationMatrix);
 
 			// create a permutation matrix for the LU-factorization
 			pmatrix pm(A.size1());
 
 			size_t res = boost::numeric::ublas::lu_factorize(A, pm);
 
 			if (res != 0)
 			{
 				return false;
 			}
 
 			_invertedOrientationMatrix.assign(boost::numeric::ublas::identity_matrix<WorldCoordinate>
 			                                  (A.size1()));
 
 			// backsubstitute to get the inverse
 			boost::numeric::ublas::lu_substitute(A, pm, _invertedOrientationMatrix);
 
 			return true;
 		}
 
 		void GeometricInfo::setImageSize(const ImageSize& aSize)
 		{
 			setNumColumns(aSize(0));
 			setNumRows(aSize(1));
 			setNumSlices(aSize(2));
 		}
 
 		const ImageSize GeometricInfo::getImageSize() const
 		{
-			return ImageSize(static_cast<UnsignedIndex1D>(getNumColumns()), static_cast<UnsignedIndex1D>(getNumRows()), static_cast<UnsignedIndex1D>(getNumSlices()));
+			return ImageSize(static_cast<Index1D>(getNumColumns()), static_cast<Index1D>(getNumRows()), static_cast<Index1D>(getNumSlices()));
 		}
 
 		void GeometricInfo::setNumColumns(const VoxelGridDimensionType aValue)
 		{
 			_numberOfColumns = aValue;
 		}
 
 		const VoxelGridDimensionType GeometricInfo::getNumColumns() const
 		{
 			return _numberOfColumns;
 		}
 
 		void GeometricInfo::setNumRows(const VoxelGridDimensionType aValue)
 		{
 			_numberOfRows = aValue;
 		}
 
 		const VoxelGridDimensionType GeometricInfo::getNumRows() const
 		{
 			return _numberOfRows;
 		}
 
 		void GeometricInfo::setNumSlices(const VoxelGridDimensionType aValue)
 		{
 			_numberOfFrames = aValue;
 		}
 
 		const VoxelGridDimensionType GeometricInfo::getNumSlices() const
 		{
 			return _numberOfFrames;
 		}
 
 		bool operator==(const GeometricInfo& gInfo, const GeometricInfo& gInfo1)
 		{
 			return (gInfo.getImagePositionPatient() == gInfo1.getImagePositionPatient()
 			        && gInfo.getOrientationMatrix() == gInfo1.getOrientationMatrix()
 			        && gInfo.getSpacing() == gInfo1.getSpacing() && gInfo.getNumColumns() == gInfo1.getNumColumns()
 			        && gInfo.getNumRows() == gInfo1.getNumRows() && gInfo.getNumSlices() == gInfo1.getNumSlices());
 		}
 
 
 		bool GeometricInfo::equalsAlmost(const GeometricInfo& another,
 		                                 double errorConstantGI /*= 1e-5*/) const
 		{
 			return (getImagePositionPatient().equalsAlmost(another.getImagePositionPatient(), errorConstantGI)
 			        && getOrientationMatrix().equalsAlmost(another.getOrientationMatrix(), errorConstantGI)
 			        && getSpacing().equalsAlmost(another.getSpacing(), errorConstantGI)
 			        && getNumColumns() == another.getNumColumns()
 			        && getNumRows() == another.getNumRows() && getNumSlices() == another.getNumSlices());
 		}
 
 		bool GeometricInfo::worldCoordinateToGeometryCoordinate(const WorldCoordinate3D& aWorldCoordinate,
 			ContinousVoxelGridIndex3D& aIndex)
 		const
 		{
 			WorldCoordinate3D distanceToIP;
 			distanceToIP = aWorldCoordinate - _imagePositionPatient;
 
 			boost::numeric::ublas::vector<WorldCoordinate> result = boost::numeric::ublas::prod(
 			            _invertedOrientationMatrix,
 			            distanceToIP);
 
 			boost::numeric::ublas::vector<WorldCoordinate> resultS = boost::numeric::ublas::element_div(result,
 			        _spacing);
 
 			aIndex = ContinousVoxelGridIndex3D(resultS(0), resultS(1), resultS(2));
 
             //if we convert ContinousVoxelGridIndex3D (double) to VoxelGridIndex3D (unsigned int), we can't find out if it's negative. 
             //So we have to check before.
             if (aIndex(0) < -0.5 || aIndex(1) < -0.5 || aIndex(2) < -0.5){
                 return false;
             }
             else {
                 //check if it is inside
                 VoxelGridIndex3D indexInt = VoxelGridIndex3D(GridIndexType(aIndex(0) + 0.5),
                     GridIndexType(aIndex(1) + 0.5),
                     GridIndexType(aIndex(2) + 0.5));
 
                 return isInside(indexInt);
             }
 		}
 
 		bool GeometricInfo::worldCoordinateToIndex(const WorldCoordinate3D& aWorldCoordinate,
 		        VoxelGridIndex3D& aIndex)
 		const
 		{
 			ContinousVoxelGridIndex3D doubleIndex;
 			bool inside = worldCoordinateToGeometryCoordinate(aWorldCoordinate, doubleIndex);
 
 			aIndex = VoxelGridIndex3D(GridIndexType(doubleIndex(0)+0.5), GridIndexType(doubleIndex(1)+0.5),
 			                          GridIndexType(doubleIndex(2)+0.5));
 
 			return inside;
 		}
 
 
 		bool GeometricInfo::continousIndexToWorldCoordinate(const ContinousVoxelGridIndex3D& aIndex,
 		        WorldCoordinate3D& aWorldCoordinate)
 		const
 		{
 
 			boost::numeric::ublas::vector<WorldCoordinate> resultS = boost::numeric::ublas::element_prod(
 			            aIndex,
 			            _spacing);
 
 			boost::numeric::ublas::vector<WorldCoordinate> result = boost::numeric::ublas::prod(
 			            _orientationMatrix,
 			            resultS);
 
 			aWorldCoordinate = result + _imagePositionPatient;
 
             //if we convert ContinousVoxelGridIndex3D (double) to VoxelGridIndex3D (unsigned int), we can't find out if it's negative. 
             //So we have to check before.
             if (aIndex(0) < -0.5 || aIndex(1) < -0.5 || aIndex(2) < -0.5){
                 return false;
             }
             else {
                 VoxelGridIndex3D indexInt = VoxelGridIndex3D(GridIndexType(aIndex(0) + 0.5),
                     GridIndexType(aIndex(1) + 0.5),
                     GridIndexType(aIndex(2) + 0.5));
                 return isInside(indexInt);
             }
 		}
 
 
 		bool GeometricInfo::indexToWorldCoordinate(const VoxelGridIndex3D& aIndex,
 		        WorldCoordinate3D& aWorldCoordinate)
 		const
 		{
 			ContinousVoxelGridIndex3D indexDouble = ContinousVoxelGridIndex3D(aIndex(0), aIndex(1),
 			                                     aIndex(2));
 			return continousIndexToWorldCoordinate(indexDouble, aWorldCoordinate);
 		}
 
 		bool GeometricInfo::isInside(const VoxelGridIndex3D& aIndex) const
 		{
 			return (aIndex(0) >= 0 && aIndex(1) >= 0 && aIndex(2) >= 0
 			        && aIndex(0) < static_cast<unsigned int>(_numberOfColumns)
 			        && aIndex(1) < static_cast<unsigned int>(_numberOfRows)
 			        && aIndex(2) < static_cast<unsigned int>(_numberOfFrames));
 		}
 
 		bool GeometricInfo::isInside(const WorldCoordinate3D& aWorldCoordinate) const
 		{
 			VoxelGridIndex3D currentIndex;
 			return (worldCoordinateToIndex(aWorldCoordinate, currentIndex));
 		}
 
 		const GridSizeType GeometricInfo::getNumberOfVoxels() const
 		{
 			auto nVoxels = static_cast<GridSizeType>(_numberOfRows * _numberOfColumns * _numberOfFrames);
 			return nVoxels;
 		}
 
 		bool GeometricInfo::convert(const VoxelGridID& gridID, VoxelGridIndex3D& gridIndex) const
 		{
 			if (validID(gridID))
 			{
 				gridIndex(0) = gridID % getNumColumns();
 				VoxelGridID tempID = (gridID - gridIndex.x()) / getNumColumns();
 				gridIndex(1) = tempID % getNumRows();
 				gridIndex(2) = (tempID - gridIndex.y()) / getNumRows();
 				return true;
 			}
 
 			return false;
 		}
 
 		bool GeometricInfo::convert(const VoxelGridIndex3D& gridIndex, VoxelGridID& gridID) const
 		{
 			if ((gridIndex.x() >= static_cast<unsigned int>(getNumColumns()))
 			    || (gridIndex.y() >= static_cast<unsigned int>(getNumRows()))
 			    || (gridIndex.z() >= static_cast<unsigned int>(getNumSlices())))
 			{
 				return false;
 			}
 			else
 			{
 				gridID = gridIndex.z() * getNumColumns() * getNumRows() + gridIndex.y() *
 				         getNumColumns()
 				         + gridIndex.x();
 				return validID(gridID);
 			}
 		}
 
 		bool GeometricInfo::validID(const VoxelGridID aID) const
 		{
 			return (aID >= 0 && aID < getNumberOfVoxels());
 		}
 
 		bool GeometricInfo::validIndex(const VoxelGridIndex3D& aIndex) const
 		{
 			VoxelGridID aID;
 
 			if (!convert(aIndex, aID))
 			{
 				return false;
 			}
 			else
 			{
 				return validID(aID);
 			}
 		}
 
 		std::ostream& operator<<(std::ostream& s, const GeometricInfo& anGeometricInfo)
 		{
 			s << "[ " << anGeometricInfo.getImagePositionPatient() << "; " <<
 			  anGeometricInfo.getOrientationMatrix()
 			  << "; " << anGeometricInfo.getSpacing() << "; " << "; " << anGeometricInfo.getNumColumns()
 			  << "; " << anGeometricInfo.getNumRows() << "; " << anGeometricInfo.getNumSlices() << " ]";
 			return s;
 		}
 
 	}//end namespace core
 }//end namespace rttb