diff --git a/code/core/rttbBaseType.h b/code/core/rttbBaseType.h
index a761712..4e98c88 100644
--- a/code/core/rttbBaseType.h
+++ b/code/core/rttbBaseType.h
@@ -1,604 +1,610 @@
 // -----------------------------------------------------------------------
 // RTToolbox - DKFZ radiotherapy quantitative evaluation library
 //
 // Copyright (c) German Cancer Research Center (DKFZ),
 // Software development for Integrated Diagnostics and Therapy (SIDT).
 // ALL RIGHTS RESERVED.
 // See rttbCopyright.txt or
 // http://www.dkfz.de/en/sidt/projects/rttb/copyright.html
 //
 // This software is distributed WITHOUT ANY WARRANTY; without even
 // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 // PURPOSE.  See the above copyright notices for more information.
 //
 //------------------------------------------------------------------------
 /*!
 // @file
 // @version $Revision$ (last changed revision)
 // @date    $Date$ (last change date)
 // @author  $Author$ (last changed by)
 */
 
 #ifndef __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>
 
 namespace rttb
 {
 
 	const double errorConstant = 1e-5;
 	const double reducedErrorConstant = 0.0001;
 
 	using UnsignedIndex1D = unsigned short;
 
 	/*! @class UnsignedIndex3D
 		@brief 3D index.
 	*/
 	class UnsignedIndex3D: public boost::numeric::ublas::vector<UnsignedIndex1D>
 	{
 	public:
 		UnsignedIndex3D() : boost::numeric::ublas::vector<UnsignedIndex1D>(3,0) {}
 		UnsignedIndex3D(const UnsignedIndex1D value) : boost::numeric::ublas::vector<UnsignedIndex1D>(3,
 			        value) {}
 		UnsignedIndex3D(const UnsignedIndex1D  xValue, const UnsignedIndex1D  yValue,
 		                const UnsignedIndex1D  zValue)
 			: boost::numeric::ublas::vector<UnsignedIndex1D >(3, xValue)
 		{
 			(*this)(1) = yValue;
 			(*this)(2) = zValue;
 		}
 
 		const UnsignedIndex1D x() const
 		{
 			return (*this)(0);
 		}
 		const UnsignedIndex1D y() const
 		{
 			return (*this)(1);
 		}
 		const UnsignedIndex1D z() const
 		{
 			return (*this)(2);
 		}
 		friend bool operator==(const UnsignedIndex3D& gi1, const UnsignedIndex3D& 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 UnsignedIndex3D& aVector)
 		{
 			s << "[ " << aVector(0) << ", " << aVector(1) << ", " << aVector(2) << " ]";
 			return s;
 		}
 	};
 
 	using UnsignedIndexList = std::list<UnsignedIndex3D>;
 
 	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) {}
 		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 DoubleVoxelGridIndex3D = rttb::WorldCoordinate3D;
 
 	using ImageSize = rttb::UnsignedIndex3D;
 
 	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) {}
 		SpacingVectorType3D(const GridVolumeType value) : boost::numeric::ublas::vector<GridVolumeType>(3,
-			        value) {}
+			        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, xValue)
+			: 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): boost::numeric::ublas::vector<GridVolumeType>(3)
-		{
-			(*this)(0) = w.x();
-			(*this)(1) = w.y();
-			(*this)(2) = w.z();
-		}
+
+		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;
 			}
 		}
 		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) {}
 		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 UnsignedIndex3D& 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) {}
 		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
 
 #endif
diff --git a/testing/core/BaseTypeTest.cpp b/testing/core/BaseTypeTest.cpp
index 4c180ed..911b582 100644
--- a/testing/core/BaseTypeTest.cpp
+++ b/testing/core/BaseTypeTest.cpp
@@ -1,274 +1,277 @@
 // -----------------------------------------------------------------------
 // RTToolbox - DKFZ radiotherapy quantitative evaluation library
 //
 // Copyright (c) German Cancer Research Center (DKFZ),
 // Software development for Integrated Diagnostics and Therapy (SIDT).
 // ALL RIGHTS RESERVED.
 // See rttbCopyright.txt or
 // http://www.dkfz.de/en/sidt/projects/rttb/copyright.html
 //
 // This software is distributed WITHOUT ANY WARRANTY; without even
 // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 // PURPOSE.  See the above copyright notices for more information.
 //
 //------------------------------------------------------------------------
 /*!
 // @file
 // @version $Revision$ (last changed revision)
 // @date    $Date$ (last change date)
 // @author  $Author$ (last changed by)
 */
 
 #include "litCheckMacros.h"
 
 #include "rttbBaseType.h"
 
 namespace rttb
 {
 	namespace testing
 	{
 
 		/*! @brief BaseTypeTests - tests the API for the classes in baseType
 		1) UnsignedIndex3D
     2) WorldCoordinate3D
     3) SpacingVectorType3D
     4) OrientationMatrix 
     5) VoxelGridIndex3D
     6) VoxelGridIndex2D
 		*/
 		int BaseTypeTest(int argc, char* argv[])
 		{
 			PREPARE_DEFAULT_TEST_REPORTING;
 
       //1)  UnsignedIndex3D
       CHECK_NO_THROW(UnsignedIndex3D ui);
       UnsignedIndex3D emptyUnsignedIndex3D;
       CHECK_EQUAL(emptyUnsignedIndex3D.x(), 0);
       CHECK_EQUAL(emptyUnsignedIndex3D.y(), 0);
       CHECK_EQUAL(emptyUnsignedIndex3D.z(), 0);
 
       CHECK_NO_THROW(UnsignedIndex3D ui(5));
       UnsignedIndex3D sameValueUnsignedIndex(5);
       CHECK_EQUAL(sameValueUnsignedIndex.x(), 5);
       CHECK_EQUAL(sameValueUnsignedIndex.y(), 5);
       CHECK_EQUAL(sameValueUnsignedIndex.z(), 5);
 
       CHECK_NO_THROW(UnsignedIndex3D ui(5, 8, 42));
       UnsignedIndex3D differentValueUnsignedIndex(5, 8, 42);
       CHECK_EQUAL(differentValueUnsignedIndex.x(), 5);
       CHECK_EQUAL(differentValueUnsignedIndex.y(), 8);
       CHECK_EQUAL(differentValueUnsignedIndex.z(), 42);
 
       UnsignedIndex3D threeDimensionalUnsignedIndexSame(5, 8, 42);
       UnsignedIndex3D threeDimensionalUnsignedIndexDifferent(1, 2, 3);
 
       CHECK(differentValueUnsignedIndex == threeDimensionalUnsignedIndexSame);
       CHECK_EQUAL(differentValueUnsignedIndex == threeDimensionalUnsignedIndexDifferent, false);
       CHECK_EQUAL(differentValueUnsignedIndex == sameValueUnsignedIndex, false);
       CHECK_EQUAL(emptyUnsignedIndex3D == sameValueUnsignedIndex, false);
 
       //2) WorldCoordinate3D
       CHECK_NO_THROW(WorldCoordinate3D wc);
       WorldCoordinate3D emptyWC3D;
       CHECK_EQUAL(emptyWC3D.x(), 0);
       CHECK_EQUAL(emptyWC3D.y(), 0);
       CHECK_EQUAL(emptyWC3D.z(), 0);
 
       CHECK_NO_THROW(WorldCoordinate3D wc(6.5));
       WorldCoordinate3D sameValueWC3D(6.5);
       CHECK_EQUAL(sameValueWC3D.x(), 6.5);
       CHECK_EQUAL(sameValueWC3D.y(), 6.5);
       CHECK_EQUAL(sameValueWC3D.z(), 6.5);
 
       CHECK_NO_THROW(WorldCoordinate3D(5.8, 0.1, -2.7));
       WorldCoordinate3D differentValueWC3D(5.8, 0.1, -2.7);
       CHECK_EQUAL(differentValueWC3D.x(), 5.8);
       CHECK_EQUAL(differentValueWC3D.y(), 0.1);
       CHECK_EQUAL(differentValueWC3D.z(), -2.7);
 
       CHECK_EQUAL(differentValueWC3D.toString(), "5.800000 0.100000 -2.700000");
 
       WorldCoordinate3D differentValueWC3Dsecond(1.5, -3.9, 0.7);
       WorldCoordinate3D resultWC3DCrossTrue(-10.46, -8.11, -22.77);
       CHECK_NO_THROW(differentValueWC3D.cross(differentValueWC3Dsecond));
       auto resultWC3DCrossComputed = differentValueWC3D.cross(differentValueWC3Dsecond);
       CHECK_CLOSE(resultWC3DCrossComputed.x(), resultWC3DCrossTrue.x(), errorConstant);
       CHECK_CLOSE(resultWC3DCrossComputed.y(), resultWC3DCrossTrue.y(), errorConstant);
       CHECK_CLOSE(resultWC3DCrossComputed.z(), resultWC3DCrossTrue.z(), errorConstant);
       CHECK_NO_THROW(differentValueWC3Dsecond.cross(differentValueWC3D));
       auto resultWC3DCrossComputedOrder = differentValueWC3Dsecond.cross(differentValueWC3D);
       CHECK_CLOSE(resultWC3DCrossComputed.x(), resultWC3DCrossComputedOrder.x()*-1, errorConstant);
       CHECK_CLOSE(resultWC3DCrossComputed.y(), resultWC3DCrossComputedOrder.y()*-1, errorConstant);
       CHECK_CLOSE(resultWC3DCrossComputed.z(), resultWC3DCrossComputedOrder.z()*-1, errorConstant);
 
       differentValueWC3D = differentValueWC3Dsecond;
       CHECK_EQUAL(differentValueWC3D.x(), 1.5);
       CHECK_EQUAL(differentValueWC3D.y(), -3.9);
       CHECK_EQUAL(differentValueWC3D.z(), 0.7);
 
       boost::numeric::ublas::vector<WorldCoordinate> wcUblas(3, 4.5);
       differentValueWC3D = wcUblas;
       CHECK_EQUAL(differentValueWC3D.x(), 4.5);
       CHECK_EQUAL(differentValueWC3D.y(), 4.5);
       CHECK_EQUAL(differentValueWC3D.z(), 4.5);
 
       WorldCoordinate3D WCresultMinus;
       CHECK_NO_THROW(WCresultMinus = differentValueWC3D- differentValueWC3Dsecond);
       CHECK_EQUAL(WCresultMinus.x(), differentValueWC3D.x()- differentValueWC3Dsecond.x());
       CHECK_EQUAL(WCresultMinus.y(), differentValueWC3D.y() - differentValueWC3Dsecond.y());
       CHECK_EQUAL(WCresultMinus.z(), differentValueWC3D.z() - differentValueWC3Dsecond.z());
 
       WorldCoordinate3D WCresultPlus;
       CHECK_NO_THROW(WCresultPlus = differentValueWC3D + differentValueWC3Dsecond);
       CHECK_EQUAL(WCresultPlus.x(), differentValueWC3D.x() + differentValueWC3Dsecond.x());
       CHECK_EQUAL(WCresultPlus.y(), differentValueWC3D.y() + differentValueWC3Dsecond.y());
       CHECK_EQUAL(WCresultPlus.z(), differentValueWC3D.z() + differentValueWC3Dsecond.z());
 
       WorldCoordinate3D sameAsWcUblas(4.5);
       CHECK_EQUAL(resultWC3DCrossTrue== differentValueWC3Dsecond, false);
       CHECK_EQUAL(differentValueWC3D == sameAsWcUblas, true);
 
       WorldCoordinate3D sameAsWcUblasAlmost(4.5+1e-6, 4.5-1e-6, 4.5+2e-7);
       CHECK_EQUAL(sameAsWcUblas.equalsAlmost(sameAsWcUblasAlmost), true);
       CHECK_EQUAL(sameAsWcUblas.equalsAlmost(resultWC3DCrossComputedOrder), false);
 
       //3) SpacingVectorType
       CHECK_NO_THROW(SpacingVectorType3D svt);
       SpacingVectorType3D emptySvt;
       CHECK_EQUAL(emptySvt.x(), 0);
       CHECK_EQUAL(emptySvt.y(), 0);
       CHECK_EQUAL(emptySvt.z(), 0);
 
       CHECK_NO_THROW(SpacingVectorType3D svt(1.5));
+	  CHECK_THROW(SpacingVectorType3D svt(-1.5));
       SpacingVectorType3D sameValueSvt(1.5);
       CHECK_EQUAL(sameValueSvt.x(), 1.5);
       CHECK_EQUAL(sameValueSvt.y(), 1.5);
       CHECK_EQUAL(sameValueSvt.z(), 1.5);
 
       CHECK_NO_THROW(SpacingVectorType3D svt(1.5, 1.5, 0.5));
+      CHECK_THROW(SpacingVectorType3D svt(1.5, -1.5, 0.5));
+      CHECK_THROW(SpacingVectorType3D svt(-1.5, -1.5, -0.5));
       SpacingVectorType3D differentValuesSvt(1.5, 1.5, 0.5);
       CHECK_EQUAL(differentValuesSvt.x(), 1.5);
       CHECK_EQUAL(differentValuesSvt.y(), 1.5);
       CHECK_EQUAL(differentValuesSvt.z(), 0.5);
 
       SpacingVectorType3D differentValuesSvtChanged(0.5, 0.5, 1.5);
       CHECK_NO_THROW(SpacingVectorType3D svt(differentValuesSvtChanged));
       SpacingVectorType3D svtNew(differentValuesSvtChanged);
       CHECK_EQUAL(svtNew.x(), 0.5);
       CHECK_EQUAL(svtNew.y(), 0.5);
       CHECK_EQUAL(svtNew.z(), 1.5);
 
       CHECK_NO_THROW(svtNew = differentValuesSvt);
       CHECK_EQUAL(svtNew.x(), 1.5);
       CHECK_EQUAL(svtNew.y(), 1.5);
       CHECK_EQUAL(svtNew.z(), 0.5);
 
       CHECK_NO_THROW(svtNew = differentValueWC3D);
       CHECK_EQUAL(svtNew.x(), 4.5);
       CHECK_EQUAL(svtNew.y(), 4.5);
       CHECK_EQUAL(svtNew.z(), 4.5);
 
       boost::numeric::ublas::vector<GridVolumeType> ublasVector(3, 0.5);
       CHECK_NO_THROW(svtNew = ublasVector);
       CHECK_EQUAL(svtNew.x(), 0.5);
       CHECK_EQUAL(svtNew.y(), 0.5);
       CHECK_EQUAL(svtNew.z(), 0.5);
 
       SpacingVectorType3D sameAsUblasVector(0.5);
 
       CHECK_EQUAL(svtNew== differentValuesSvtChanged, false);
       CHECK_EQUAL(svtNew == sameAsUblasVector, true);
 
       SpacingVectorType3D almostSameAsUblasVector(0.5+1e-6, 0.5-1e-6,0.5+2e-7);
       CHECK(svtNew.equalsAlmost(almostSameAsUblasVector));
 
       CHECK_EQUAL(differentValuesSvtChanged.toString(), "0.500000 0.500000 1.500000");
 
       //4) OrientationMatrix
       CHECK_NO_THROW(OrientationMatrix om);
       OrientationMatrix om;
       CHECK_EQUAL(om(0, 0), 1.0);
       CHECK_EQUAL(om(1, 1), 1.0);
       CHECK_EQUAL(om(2, 2), 1.0);
       CHECK_EQUAL(om(0, 1), 0.0);
       CHECK_EQUAL(om(0, 2), 0.0);
       CHECK_EQUAL(om(1, 0), 0.0);
       CHECK_EQUAL(om(1, 2), 0.0);
       CHECK_EQUAL(om(2, 0), 0.0);
       CHECK_EQUAL(om(2, 1), 0.0);
 
       CHECK_NO_THROW(OrientationMatrix omValue(0.1));
       OrientationMatrix omValue(0.1);
       for (unsigned int i = 0; i < 3; i++) {
         for (unsigned int j = 0; j < 3; j++) {
           CHECK_EQUAL(omValue(i, j), 0.1);
         }
       }
 
       OrientationMatrix omValueAlmost(0.1+1e-6);
       CHECK_EQUAL(omValue.equalsAlmost(omValueAlmost), true);
       CHECK_EQUAL(omValue.equalsAlmost(om), false);
 
       OrientationMatrix omSame;
       CHECK_EQUAL(om == omSame, true);
       CHECK_EQUAL(omValue == omValueAlmost, false);
 
       //5) VoxelGridIndex3D
       CHECK_NO_THROW(VoxelGridIndex3D vgi);
       VoxelGridIndex3D vgi;
       CHECK_EQUAL(vgi.x(), 0);
       CHECK_EQUAL(vgi.y(), 0);
       CHECK_EQUAL(vgi.z(), 0);
 
       CHECK_NO_THROW(VoxelGridIndex3D vgiValue(2));
       VoxelGridIndex3D vgiValue(2);
       CHECK_EQUAL(vgiValue.x(), 2);
       CHECK_EQUAL(vgiValue.y(), 2);
       CHECK_EQUAL(vgiValue.z(), 2);
 
       CHECK_NO_THROW(VoxelGridIndex3D vgiValueDifferent(2,3,5));
       VoxelGridIndex3D vgiValueDifferent(2,3,5);
       CHECK_EQUAL(vgiValueDifferent.x(), 2);
       CHECK_EQUAL(vgiValueDifferent.y(), 3);
       CHECK_EQUAL(vgiValueDifferent.z(), 5);
 
       CHECK_EQUAL(vgiValueDifferent.toString(), "2 3 5");
 
       CHECK_NO_THROW(vgiValueDifferent = threeDimensionalUnsignedIndexSame);
       CHECK_EQUAL(vgiValueDifferent.x(), 5);
       CHECK_EQUAL(vgiValueDifferent.y(), 8);
       CHECK_EQUAL(vgiValueDifferent.z(), 42);
 
       VoxelGridIndex3D vgiValueDifferentSame(5, 8, 42);
 
       CHECK_EQUAL(vgi==vgiValue, false);
       CHECK_EQUAL(vgiValueDifferentSame == vgiValueDifferent, true);
 
       //6) VoxelGridIndex2D
       CHECK_NO_THROW(VoxelGridIndex2D vgi);
       VoxelGridIndex2D vgi2D;
       CHECK_EQUAL(vgi2D.x(), 0);
       CHECK_EQUAL(vgi2D.y(), 0);
 
       CHECK_NO_THROW(VoxelGridIndex2D vgi2DValue(2));
       VoxelGridIndex2D vgi2DValue(2);
       CHECK_EQUAL(vgi2DValue.x(), 2);
       CHECK_EQUAL(vgi2DValue.y(), 2);
 
       CHECK_NO_THROW(VoxelGridIndex2D vgi2DValueDifferent(2, 3));
       VoxelGridIndex2D vgi2DValueDifferent(2, 3);
       CHECK_EQUAL(vgi2DValueDifferent.x(), 2);
       CHECK_EQUAL(vgi2DValueDifferent.y(), 3);
 
       CHECK_EQUAL(vgi2DValueDifferent.toString(), "2 3");
 
       VoxelGridIndex2D vgi2DValueDifferentSame(2, 3);
 
       CHECK_EQUAL(vgi2D == vgi2DValueDifferent, false);
       CHECK_EQUAL(vgi2DValueDifferent == vgi2DValueDifferentSame, true);
 
 			RETURN_AND_REPORT_TEST_SUCCESS;
 		}
 
 	}//testing
 }//rttb
\ No newline at end of file