Update version to 1.3

13 files changed, 2253 insertions, 0 deletions

diff --git a/tests/main.cpp b/tests/main.cpp
new file mode 100644
index 0000000..6fc963e
--- /dev/null
+++ b/tests/main.cpp
@@ -0,0 +1,38 @@
+/*
+-----------------------------------------------------------------------
+Copyright 2012 iMinds-Vision Lab, University of Antwerp
+
+Contact: astra@ua.ac.be
+Website: http://astra.ua.ac.be
+
+
+This file is part of the
+All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA Toolbox").
+
+The ASTRA Toolbox is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The ASTRA Toolbox is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
+
+-----------------------------------------------------------------------
+$Id$
+*/
+
+
+
+#define BOOST_TEST_DYN_LINK
+
+// Generate main()
+#define BOOST_AUTO_TEST_MAIN
+
+#include <boost/test/unit_test.hpp>
+#include <boost/test/auto_unit_test.hpp>
+#include <boost/test/floating_point_comparison.hpp>
diff --git a/tests/test_AstraObjectManager.cpp b/tests/test_AstraObjectManager.cpp
new file mode 100644
index 0000000..893efb9
--- /dev/null
+++ b/tests/test_AstraObjectManager.cpp
@@ -0,0 +1,79 @@
+/*
+-----------------------------------------------------------------------
+Copyright 2012 iMinds-Vision Lab, University of Antwerp
+
+Contact: astra@ua.ac.be
+Website: http://astra.ua.ac.be
+
+
+This file is part of the
+All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA Toolbox").
+
+The ASTRA Toolbox is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The ASTRA Toolbox is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
+
+-----------------------------------------------------------------------
+$Id$
+*/
+
+
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>
+#include <boost/test/auto_unit_test.hpp>
+
+#include "astra/AstraObjectManager.h"
+
+namespace astra {
+DEFINE_SINGLETON(CAstraObjectManager<int>);
+}
+
+BOOST_AUTO_TEST_CASE( testAstraObjectManager )
+{
+	astra::CAstraObjectManager<int> man;
+
+	int i1 = man.store(new int(1));
+	BOOST_REQUIRE(man.hasIndex(i1));
+	BOOST_CHECK(*(man.get(i1)) == 1);
+
+	int i2 = man.store(new int(2));
+	BOOST_REQUIRE(man.hasIndex(i2));
+	BOOST_CHECK(*(man.get(i1)) == 1);
+	BOOST_CHECK(*(man.get(i2)) == 2);
+
+	man.remove(i1);
+
+	BOOST_CHECK(!man.hasIndex(i1));
+	BOOST_REQUIRE(man.hasIndex(i2));
+
+	int i3 = man.store(new int(3));
+	BOOST_REQUIRE(man.hasIndex(i3));
+	BOOST_CHECK(*(man.get(i2)) == 2);
+	BOOST_CHECK(*(man.get(i3)) == 3);
+
+	int* pi4 = new int(4);
+	int i4 = man.store(pi4);
+	BOOST_REQUIRE(man.hasIndex(i4));
+	BOOST_CHECK(*(man.get(i2)) == 2);
+	BOOST_CHECK(*(man.get(i3)) == 3);
+	BOOST_CHECK(*(man.get(i4)) == 4);
+
+	BOOST_CHECK(man.getIndex(pi4) == i4);
+
+	man.clear();
+
+	BOOST_CHECK(!man.hasIndex(i1));
+	BOOST_CHECK(!man.hasIndex(i2));
+	BOOST_CHECK(!man.hasIndex(i3));
+	BOOST_CHECK(!man.hasIndex(i4));
+	BOOST_CHECK(!man.getIndex(pi4));
+}
diff --git a/tests/test_FanFlatProjectionGeometry2D.cpp b/tests/test_FanFlatProjectionGeometry2D.cpp
new file mode 100644
index 0000000..a07fbf8
--- /dev/null
+++ b/tests/test_FanFlatProjectionGeometry2D.cpp
@@ -0,0 +1,119 @@
+/*
+-----------------------------------------------------------------------
+Copyright 2012 iMinds-Vision Lab, University of Antwerp
+
+Contact: astra@ua.ac.be
+Website: http://astra.ua.ac.be
+
+
+This file is part of the
+All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA Toolbox").
+
+The ASTRA Toolbox is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The ASTRA Toolbox is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
+
+-----------------------------------------------------------------------
+$Id$
+*/
+
+
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>
+#include <boost/test/auto_unit_test.hpp>
+#include <boost/test/test_case_template.hpp>
+#include <boost/test/floating_point_comparison.hpp>
+
+#include <cmath>
+
+#include "astra/FanFlatProjectionGeometry2D.h"
+
+BOOST_AUTO_TEST_CASE( testFanFlatProjectionGeometry2D_Constructor )
+{
+	astra::float32 angles[] = { 0.0f, 1.0f, 2.0f, 3.0f };
+	astra::CFanFlatProjectionGeometry2D geom(4, 8, 0.5f, angles, 1.0f, 2.0f);
+
+	BOOST_REQUIRE( geom.isInitialized() );
+
+	BOOST_CHECK( geom.getProjectionAngleCount() == 4 );
+	BOOST_CHECK( geom.getDetectorCount() == 8 );
+	BOOST_CHECK( geom.getDetectorWidth() == 0.5f );
+	BOOST_CHECK( geom.getProjectionAngle(0) == 0.0f );
+	BOOST_CHECK( geom.getProjectionAngle(1) == 1.0f );
+	BOOST_CHECK( geom.getProjectionAngle(2) == 2.0f );
+	BOOST_CHECK( geom.getProjectionAngle(3) == 3.0f );
+	BOOST_CHECK( geom.getProjectionAngles()[0] == 0.0f );
+	BOOST_CHECK( geom.getProjectionAngles()[3] == 3.0f );
+	BOOST_CHECK( geom.getOriginSourceDistance() == 1.0f );
+	BOOST_CHECK( geom.getOriginDetectorDistance() == 2.0f );
+}
+
+BOOST_AUTO_TEST_CASE( testFanFlatProjectionGeometry2D_Offsets )
+{
+	astra::float32 angles[] = { 0.0f, 1.0f, 2.0f, 3.0f };
+	astra::CFanFlatProjectionGeometry2D geom(4, 8, 0.5f, angles, 1.0f, 2.0f);
+
+	BOOST_REQUIRE( geom.isInitialized() );
+
+	BOOST_CHECK( geom.getSourceDetectorDistance() == 3.0f );
+	BOOST_CHECK_SMALL( geom.getProjectionAngleDegrees(2) - 114.591559026165f, 1e-5f );
+
+	// CHECKME: where is the center of the detector array?
+	BOOST_CHECK( geom.detectorOffsetToIndexFloat(0.0f) == 3.5f );
+	BOOST_CHECK( geom.detectorOffsetToIndexFloat(0.625f) == 4.75f );
+	BOOST_CHECK( geom.detectorOffsetToIndex(-0.1f) == 3 );
+
+	BOOST_CHECK( geom.indexToDetectorOffset(0) == -1.75f );
+	BOOST_CHECK( geom.indexToDetectorOffset(1) == -1.25f );
+
+	int angle, detector;
+	geom.indexToAngleDetectorIndex(10, angle, detector);
+	BOOST_CHECK( angle == 1 );
+	BOOST_CHECK( detector == 2 );
+
+	float t, theta;
+	geom.getRayParams(0, 2, t, theta);
+	BOOST_CHECK_SMALL( tan(theta) + 0.25f, astra::eps );
+	BOOST_CHECK_SMALL( 17.0f*t*t - 1.0f, astra::eps );
+
+	// TODO: add test with large angle
+}
+
+
+BOOST_AUTO_TEST_CASE( testFanFlatProjectionGeometry2D_Clone )
+{
+	astra::float32 angles[] = { 0.0f, 1.0f, 2.0f, 3.0f };
+	astra::CFanFlatProjectionGeometry2D geom(4, 8, 0.5f, angles, 1.0f, 2.0f);
+
+	BOOST_REQUIRE( geom.isInitialized() );
+
+	astra::CFanFlatProjectionGeometry2D* geom2;
+	geom2 = dynamic_cast<astra::CFanFlatProjectionGeometry2D*>(geom.clone());
+
+	BOOST_REQUIRE( geom2 );
+	BOOST_REQUIRE( geom2->isInitialized() );
+
+	BOOST_CHECK( geom.isEqual(geom2) );
+	BOOST_CHECK( geom2->getProjectionAngleCount() == 4 );
+	BOOST_CHECK( geom2->getDetectorCount() == 8 );
+	BOOST_CHECK( geom2->getDetectorWidth() == 0.5f );
+	BOOST_CHECK( geom2->getProjectionAngle(0) == 0.0f );
+	BOOST_CHECK( geom2->getProjectionAngle(1) == 1.0f );
+	BOOST_CHECK( geom2->getProjectionAngle(2) == 2.0f );
+	BOOST_CHECK( geom2->getProjectionAngle(3) == 3.0f );
+	BOOST_CHECK( geom2->getProjectionAngles()[0] == 0.0f );
+	BOOST_CHECK( geom2->getProjectionAngles()[3] == 3.0f );
+	BOOST_CHECK( geom2->getOriginSourceDistance() == 1.0f );
+	BOOST_CHECK( geom2->getOriginDetectorDistance() == 2.0f );
+	delete geom2;
+}
+
diff --git a/tests/test_Float32Data2D.cpp b/tests/test_Float32Data2D.cpp
new file mode 100644
index 0000000..54d642b
--- /dev/null
+++ b/tests/test_Float32Data2D.cpp
@@ -0,0 +1,229 @@
+/*
+-----------------------------------------------------------------------
+Copyright 2012 iMinds-Vision Lab, University of Antwerp
+
+Contact: astra@ua.ac.be
+Website: http://astra.ua.ac.be
+
+
+This file is part of the
+All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA Toolbox").
+
+The ASTRA Toolbox is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The ASTRA Toolbox is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
+
+-----------------------------------------------------------------------
+$Id$
+*/
+
+
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>
+#include <boost/test/auto_unit_test.hpp>
+#include <boost/test/test_case_template.hpp>
+#include <boost/test/floating_point_comparison.hpp>
+
+#include "astra/Float32Data2D.h"
+
+
+// Utility class to test Float32Data2D
+class CTestFloat32Data2D : public astra::CFloat32Data2D {
+public:
+	CTestFloat32Data2D(int _iWidth, int _iHeight)
+	{
+		m_bInitialized = _initialize(_iWidth, _iHeight);
+	}
+	CTestFloat32Data2D(int _iWidth, int _iHeight, const astra::float32* _pfData)
+	{
+		m_bInitialized = _initialize(_iWidth, _iHeight, _pfData);
+	}
+
+	CTestFloat32Data2D(int _iWidth, int _iHeight, astra::float32 _fScalar)
+	{
+		m_bInitialized = _initialize(_iWidth, _iHeight, _fScalar);
+	}
+
+	CTestFloat32Data2D() { }
+
+};
+
+
+struct TestFloat32Data2D {
+	static astra::float32 d[];
+	TestFloat32Data2D() : data(2,2,d)
+	{
+	}
+
+	~TestFloat32Data2D()
+	{
+	}
+
+	CTestFloat32Data2D data;
+};
+
+astra::float32 TestFloat32Data2D::d[] = { 1.0f, 2.0f, 3.0f, 4.0f };
+
+BOOST_AUTO_TEST_CASE( testFloat32Data2D_Constructor1 )
+{
+	CTestFloat32Data2D data(2,2);
+
+	BOOST_REQUIRE( data.isInitialized() );
+
+	BOOST_CHECK( data.getWidth() == 2 );
+	BOOST_CHECK( data.getHeight() == 2 );
+	BOOST_CHECK( data.getSize() == 4 );
+	BOOST_CHECK( data.getDimensionCount() == 2 );
+
+	BOOST_REQUIRE( data.getDataConst() != 0 );
+	BOOST_REQUIRE( data.getData() != 0 );
+	BOOST_REQUIRE( data.getData2D() != 0 );
+	BOOST_REQUIRE( data.getData2DConst() != 0 );
+	BOOST_REQUIRE( data.getData2D()[0] != 0 );
+	BOOST_REQUIRE( data.getData2DConst()[0] != 0 );
+
+	data.setData(1.0f);
+
+	// CHECKME: should this be necessary?
+	data.updateStatistics();
+
+	BOOST_CHECK( data.getGlobalMin() == 1.0f );
+	BOOST_CHECK( data.getGlobalMax() == 1.0f );
+	BOOST_CHECK( data.getGlobalMean() == 1.0f );
+
+	BOOST_CHECK( data.getData()[0] == 1.0f );
+	BOOST_CHECK( data.getDataConst()[0] == 1.0f );
+	BOOST_CHECK( data.getData2D()[0][0] == 1.0f );
+	BOOST_CHECK( data.getData2DConst()[0][0] == 1.0f );
+}
+
+BOOST_AUTO_TEST_CASE( testFloat32Data2D_Constructor2 )
+{
+	CTestFloat32Data2D data(2,2,1.5f);
+
+	// CHECKME: should this be necessary?
+	data.updateStatistics();
+
+	BOOST_REQUIRE( data.isInitialized() );
+
+	BOOST_CHECK( data.getWidth() == 2 );
+	BOOST_CHECK( data.getHeight() == 2 );
+	BOOST_CHECK( data.getSize() == 4 );
+	BOOST_CHECK( data.getDimensionCount() == 2 );
+
+	BOOST_REQUIRE( data.getDataConst() != 0 );
+	BOOST_REQUIRE( data.getData() != 0 );
+	BOOST_REQUIRE( data.getData2D() != 0 );
+	BOOST_REQUIRE( data.getData2DConst() != 0 );
+	BOOST_REQUIRE( data.getData2D()[0] != 0 );
+	BOOST_REQUIRE( data.getData2DConst()[0] != 0 );
+
+	BOOST_CHECK( data.getGlobalMin() == 1.5f );
+	BOOST_CHECK( data.getGlobalMax() == 1.5f );
+	BOOST_CHECK( data.getGlobalMean() == 1.5f );
+
+	BOOST_CHECK( data.getData()[0] == 1.5f );
+	BOOST_CHECK( data.getDataConst()[0] == 1.5f );
+	BOOST_CHECK( data.getData2D()[0][0] == 1.5f );
+	BOOST_CHECK( data.getData2DConst()[0][0] == 1.5f );
+}
+
+BOOST_AUTO_TEST_CASE( testFloat32Data2D_Constructor3 )
+{
+	astra::float32 d[] = { 1.0f, 2.0f, 3.0f, 4.0f };
+	CTestFloat32Data2D data(2,2,d);
+
+	// CHECKME: should this be necessary?
+	data.updateStatistics();
+
+	BOOST_REQUIRE( data.isInitialized() );
+
+	BOOST_CHECK( data.getWidth() == 2 );
+	BOOST_CHECK( data.getHeight() == 2 );
+	BOOST_CHECK( data.getSize() == 4 );
+	BOOST_CHECK( data.getDimensionCount() == 2 );
+
+	BOOST_REQUIRE( data.getDataConst() != 0 );
+	BOOST_REQUIRE( data.getData() != 0 );
+	BOOST_REQUIRE( data.getData2D() != 0 );
+	BOOST_REQUIRE( data.getData2DConst() != 0 );
+	BOOST_REQUIRE( data.getData2D()[0] != 0 );
+	BOOST_REQUIRE( data.getData2DConst()[0] != 0 );
+
+	BOOST_CHECK( data.getGlobalMin() == 1.0f );
+	BOOST_CHECK( data.getGlobalMax() == 4.0f );
+
+	BOOST_CHECK( data.getData()[0] == 1.0f );
+	BOOST_CHECK( data.getDataConst()[0] == 1.0f );
+	BOOST_CHECK( data.getData2D()[0][0] == 1.0f );
+	BOOST_CHECK( data.getData2DConst()[0][0] == 1.0f );
+
+}
+
+BOOST_FIXTURE_TEST_CASE( testFloat32Data2D_Operators, TestFloat32Data2D )
+{
+	// Note: all operations below involve exactly representable floats,
+	// so there is no need to use epsilons in the checks
+
+	data.updateStatistics();
+
+	// FIXME: should those be correct here?
+	BOOST_CHECK( data.getGlobalMin() == 1.0f );
+	BOOST_CHECK( data.getGlobalMax() == 4.0f );
+	BOOST_CHECK( data.getGlobalMean() == 2.5f );
+
+	data *= 2.0f;
+
+	BOOST_CHECK( data.getDataConst()[0] == 2.0f );
+	BOOST_CHECK( data.getDataConst()[3] == 8.0f );
+
+	data /= 0.5f;
+
+	BOOST_CHECK( data.getDataConst()[0] == 4.0f );
+	BOOST_CHECK( data.getDataConst()[3] == 16.0f );
+
+	astra::float32 d[] = { 1.0f, 2.0f, 3.0f, 4.0f };
+	CTestFloat32Data2D data2(2,2,d);
+
+	data += data2;
+
+	BOOST_CHECK( data.getDataConst()[0] == 5.0f );
+	BOOST_CHECK( data.getDataConst()[3] == 20.0f );
+	
+	data *= data2;
+	
+	BOOST_CHECK( data.getDataConst()[0] == 5.0f );
+	BOOST_CHECK( data.getDataConst()[3] == 80.0f );
+
+	data -= data2;
+	BOOST_CHECK( data.getDataConst()[0] == 4.0f );
+	BOOST_CHECK( data.getDataConst()[3] == 76.0f );
+
+	data += 0.5f;
+	BOOST_CHECK( data.getDataConst()[0] == 4.5f );
+	BOOST_CHECK( data.getDataConst()[3] == 76.5f );
+
+	data -= 0.5f;
+	BOOST_CHECK( data.getDataConst()[0] == 4.0f );
+	BOOST_CHECK( data.getDataConst()[3] == 76.0f );
+}
+
+BOOST_FIXTURE_TEST_CASE( testFloat32Data2D_Update, TestFloat32Data2D )
+{
+	data.getData()[2] = 42.0f;
+	data.getData()[1] = -37.0f;
+	data.updateStatistics();
+
+	BOOST_CHECK( data.getGlobalMin() == -37.0f );
+	BOOST_CHECK( data.getGlobalMax() == 42.0f );
+	BOOST_CHECK( data.getGlobalMean() == 2.5f );
+}
diff --git a/tests/test_Float32ProjectionData2D.cpp b/tests/test_Float32ProjectionData2D.cpp
new file mode 100644
index 0000000..1fddeec
--- /dev/null
+++ b/tests/test_Float32ProjectionData2D.cpp
@@ -0,0 +1,115 @@
+/*
+-----------------------------------------------------------------------
+Copyright 2012 iMinds-Vision Lab, University of Antwerp
+
+Contact: astra@ua.ac.be
+Website: http://astra.ua.ac.be
+
+
+This file is part of the
+All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA Toolbox").
+
+The ASTRA Toolbox is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The ASTRA Toolbox is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
+
+-----------------------------------------------------------------------
+$Id$
+*/
+
+
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>
+#include <boost/test/auto_unit_test.hpp>
+#include <boost/test/test_case_template.hpp>
+#include <boost/test/floating_point_comparison.hpp>
+
+#include "astra/Float32ProjectionData2D.h"
+#include "astra/ParallelProjectionGeometry2D.h"
+
+// Note: most of the features of CFloat32ProjectionData2D are tested by
+// the CFloat32Data2D tests.
+
+BOOST_AUTO_TEST_CASE( testFloat32ProjectionData2D_Constructor1 )
+{
+	astra::float32 angles[] = { 0.0f, 1.0f };
+	astra::CParallelProjectionGeometry2D geom(2, 4, 0.5f, angles);
+	BOOST_REQUIRE( geom.isInitialized() );
+
+	astra::CFloat32ProjectionData2D data(&geom);
+	BOOST_REQUIRE( data.isInitialized() );
+
+	BOOST_CHECK( data.getType() == astra::CFloat32Data2D::PROJECTION );
+	BOOST_CHECK( data.getGeometry()->isEqual(&geom) );
+}
+
+BOOST_AUTO_TEST_CASE( testFloat32ProjectionData2D_Constructor2 )
+{
+	astra::float32 angles[] = { 0.0f, 1.0f };
+	astra::float32 d[] = { 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.f };
+	astra::CParallelProjectionGeometry2D geom(2, 4, 0.5f, angles);
+	BOOST_REQUIRE( geom.isInitialized() );
+
+	astra::CFloat32ProjectionData2D data(&geom, d);
+	BOOST_REQUIRE( data.isInitialized() );
+
+	BOOST_CHECK( data.getType() == astra::CFloat32Data2D::PROJECTION );
+	BOOST_CHECK( data.getGeometry()->isEqual(&geom) );
+
+	// CHECKME: should this be necessary?
+	data.updateStatistics();
+
+	BOOST_CHECK( data.getGlobalMax() == 10.0f );
+}
+
+BOOST_AUTO_TEST_CASE( testFloat32ProjectionData2D_Constructor3 )
+{
+	astra::float32 angles[] = { 0.0f, 1.0f };
+	astra::CParallelProjectionGeometry2D geom(2, 4, 0.5f, angles);
+	BOOST_REQUIRE( geom.isInitialized() );
+
+	astra::CFloat32ProjectionData2D data(&geom, 3.5f);
+	BOOST_REQUIRE( data.isInitialized() );
+
+	BOOST_CHECK( data.getType() == astra::CFloat32Data2D::PROJECTION );
+	BOOST_CHECK( data.getGeometry()->isEqual(&geom) );
+
+	// CHECKME: should this be necessary?
+	data.updateStatistics();
+
+	BOOST_CHECK( data.getGlobalMax() == 3.5f );
+}
+
+BOOST_AUTO_TEST_CASE( testFloat32ProjectionData2D_Clone )
+{
+	astra::float32 angles[] = { 0.0f, 1.0f };
+	astra::CParallelProjectionGeometry2D geom(2, 4, 0.5f, angles);
+	BOOST_REQUIRE( geom.isInitialized() );
+
+	astra::CFloat32ProjectionData2D data(&geom, 3.5f);
+	BOOST_REQUIRE( data.isInitialized() );
+
+	astra::CFloat32ProjectionData2D data2(data);
+	BOOST_REQUIRE( data2.isInitialized() );
+
+	BOOST_CHECK( data2.getGeometry()->isEqual(&geom) );
+	BOOST_CHECK( data2.getDataConst()[0] == 3.5f );
+	BOOST_CHECK( data2.getDataConst()[3] == 3.5f );
+
+	astra::CFloat32ProjectionData2D data3;
+	data3 = data;
+	BOOST_REQUIRE( data3.isInitialized() );
+
+	BOOST_CHECK( data3.getGeometry()->isEqual(&geom) );
+	BOOST_CHECK( data3.getDataConst()[0] == 3.5f );
+	BOOST_CHECK( data3.getDataConst()[3] == 3.5f );
+}
diff --git a/tests/test_Float32VolumeData2D.cpp b/tests/test_Float32VolumeData2D.cpp
new file mode 100644
index 0000000..29dde3a
--- /dev/null
+++ b/tests/test_Float32VolumeData2D.cpp
@@ -0,0 +1,110 @@
+/*
+-----------------------------------------------------------------------
+Copyright 2012 iMinds-Vision Lab, University of Antwerp
+
+Contact: astra@ua.ac.be
+Website: http://astra.ua.ac.be
+
+
+This file is part of the
+All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA Toolbox").
+
+The ASTRA Toolbox is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The ASTRA Toolbox is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
+
+-----------------------------------------------------------------------
+$Id$
+*/
+
+
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>
+#include <boost/test/auto_unit_test.hpp>
+#include <boost/test/test_case_template.hpp>
+#include <boost/test/floating_point_comparison.hpp>
+
+#include "astra/Float32VolumeData2D.h"
+
+// Note: most of the features of CFloat32VolumeData2D are tested by
+// the CFloat32Data2D tests.
+
+BOOST_AUTO_TEST_CASE( testFloat32VolumeData2D_Constructor1 )
+{
+	astra::CVolumeGeometry2D geom(16, 32);
+	BOOST_REQUIRE( geom.isInitialized() );
+
+	astra::CFloat32VolumeData2D data(&geom);
+	BOOST_REQUIRE( data.isInitialized() );
+
+	BOOST_CHECK( data.getType() == astra::CFloat32Data2D::VOLUME );
+	BOOST_CHECK( data.getGeometry()->isEqual(&geom) );
+}
+
+BOOST_AUTO_TEST_CASE( testFloat32VolumeData2D_Constructor1odd )
+{
+	astra::CVolumeGeometry2D geom(16, 32);
+	BOOST_REQUIRE( geom.isInitialized() );
+
+	astra::CFloat32VolumeData2D data(&geom, 1.0f);
+	BOOST_REQUIRE( data.isInitialized() );
+
+	BOOST_CHECK( data.getType() == astra::CFloat32Data2D::VOLUME );
+	BOOST_CHECK( data.getGeometry()->isEqual(&geom) );
+
+	// CHECKME: should this be necessary?
+	data.updateStatistics();
+	BOOST_CHECK( data.getGlobalMax() == 1.0f );
+}
+
+BOOST_AUTO_TEST_CASE( testFloat32VolumeData2D_Constructor2 )
+{
+	astra::float32 d[] = { 1.0f, 2.0f, 3.0f, 4.0f };
+	astra::CVolumeGeometry2D geom(2, 2);
+	BOOST_REQUIRE( geom.isInitialized() );
+
+	astra::CFloat32VolumeData2D data(&geom, d);
+	BOOST_REQUIRE( data.isInitialized() );
+
+	BOOST_CHECK( data.getType() == astra::CFloat32Data2D::VOLUME );
+
+	BOOST_CHECK( data.getGeometry()->isEqual(&geom) );
+
+	// CHECKME: should this be necessary?
+	data.updateStatistics();
+	BOOST_CHECK( data.getGlobalMax() == 4.0f );
+}
+
+BOOST_AUTO_TEST_CASE( testFloat32VolumeData2D_Clone )
+{
+	astra::float32 d[] = { 1.0f, 2.0f, 3.0f, 4.0f };
+	astra::CVolumeGeometry2D geom(2, 2);
+	BOOST_REQUIRE( geom.isInitialized() );
+
+	astra::CFloat32VolumeData2D data(&geom, d);
+	BOOST_REQUIRE( data.isInitialized() );
+
+	astra::CFloat32VolumeData2D data2(data);
+	BOOST_REQUIRE( data2.isInitialized() );
+
+	BOOST_CHECK( data2.getGeometry()->isEqual(&geom) );
+	BOOST_CHECK( data2.getDataConst()[0] == 1.0f );
+	BOOST_CHECK( data2.getDataConst()[3] == 4.0f );
+
+	astra::CFloat32VolumeData2D data3;
+	data3 = data;
+	BOOST_REQUIRE( data3.isInitialized() );
+
+	BOOST_CHECK( data3.getGeometry()->isEqual(&geom) );
+	BOOST_CHECK( data3.getDataConst()[0] == 1.0f );
+	BOOST_CHECK( data3.getDataConst()[3] == 4.0f );
+}
diff --git a/tests/test_Fourier.cpp b/tests/test_Fourier.cpp
new file mode 100644
index 0000000..2602edb
--- /dev/null
+++ b/tests/test_Fourier.cpp
@@ -0,0 +1,182 @@
+/*
+-----------------------------------------------------------------------
+Copyright 2012 iMinds-Vision Lab, University of Antwerp
+
+Contact: astra@ua.ac.be
+Website: http://astra.ua.ac.be
+
+
+This file is part of the
+All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA Toolbox").
+
+The ASTRA Toolbox is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The ASTRA Toolbox is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
+
+-----------------------------------------------------------------------
+$Id$
+*/
+
+
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>
+#include <boost/test/auto_unit_test.hpp>
+#include <boost/test/test_case_template.hpp>
+#include <boost/test/floating_point_comparison.hpp>
+
+#include "astra/Fourier.h"
+
+BOOST_AUTO_TEST_CASE( testFourier_DFT_1D_1 )
+{
+	astra::float32 inR[5] = { 1.0f, 1.0f, 0.0f, 0.0f, 1.0f };
+	astra::float32 inI[5] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
+	astra::float32 outR[5];
+	astra::float32 outI[5];
+
+	astra::discreteFourierTransform1D(5, inR, inI, outR, outI, 1, 1, false);
+
+	astra::float32 expected1R[5] = { 3.0f, 1.618034f, -0.618034f, -0.618034f, 1.618034f };
+	for (unsigned int i = 0; i < 5; ++i) {
+		BOOST_CHECK_SMALL(outR[i] - expected1R[i], 0.00001f);
+		BOOST_CHECK_SMALL(outI[i], 0.00001f);
+	}
+
+	astra::discreteFourierTransform1D(5, outR, outI, inR, inI, 1, 1, true);
+	astra::float32 expected2R[5] = { 1.0f, 1.0f, 0.0f, 0.0f, 1.0f };
+	for (unsigned int i = 0; i < 5; ++i) {
+		BOOST_CHECK_SMALL(inR[i] - expected2R[i], 0.00001f);
+		BOOST_CHECK_SMALL(inI[i], 0.00001f);
+	}
+}
+
+BOOST_AUTO_TEST_CASE( testFourier_DFT_2D_1 )
+{
+	astra::float32 inR[25] = { 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
+	                           1.0f, 1.0f, 0.0f, 0.0f, 1.0f,
+	                           1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+	                           1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+	                           1.0f, 1.0f, 0.0f, 0.0f, 1.0f };
+	astra::float32 inI[25] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+	                           0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+	                           0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+	                           0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+	                           0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
+	astra::float32 outR[25];
+	astra::float32 outI[25];
+
+	astra::discreteFourierTransform2D(5, 5, inR, inI, outR, outI, false);
+
+	astra::float32 expected1R[25] =
+	     { 13.0f    , 5.236068f, 0.763932f, 0.763932f, 5.236068f,
+	       5.236068f,-0.618034f,-2.0f     ,-2.0f     ,-0.618034f,
+	       0.763932f,-2.0f     , 1.618034f, 1.618034f,-2.0f     ,
+	       0.763932f,-2.0f     , 1.618034f, 1.618034f,-2.0f     ,
+	       5.236068f,-0.618034f,-2.0f     ,-2.0f     ,-0.618034f };
+	for (unsigned int i = 0; i < 25; ++i) {
+		BOOST_CHECK_SMALL(outR[i] - expected1R[i], 0.00001f);
+		BOOST_CHECK_SMALL(outI[i], 0.00001f);
+	}
+
+	astra::discreteFourierTransform2D(5, 5, outR, outI, inR, inI, true);
+	astra::float32 expected2R[25] = { 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
+	                                  1.0f, 1.0f, 0.0f, 0.0f, 1.0f,
+	                                  1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+	                                  1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+	                                  1.0f, 1.0f, 0.0f, 0.0f, 1.0f };
+	for (unsigned int i = 0; i < 25; ++i) {
+		BOOST_CHECK_SMALL(inR[i] - expected2R[i], 0.00001f);
+		BOOST_CHECK_SMALL(inI[i], 0.00001f);
+	}
+
+
+}
+
+
+BOOST_AUTO_TEST_CASE( testFourier_FFT_1D_1 )
+{
+	astra::float32 inR[8] = { 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f };
+	astra::float32 inI[8] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
+	astra::float32 outR[5];
+	astra::float32 outI[5];
+
+	astra::fastTwoPowerFourierTransform1D(8, inR, inI, outR, outI, 1, 1, false);
+
+	astra::float32 expected1R[8] = { 5.0f, 2.414214f, -1.0f, -0.414214f, 1.0f, -0.414214f, -1.0f, 2.414214f };
+	for (unsigned int i = 0; i < 8; ++i) {
+		BOOST_CHECK_SMALL(outR[i] - expected1R[i], 0.00001f);
+		BOOST_CHECK_SMALL(outI[i], 0.00001f);
+	}
+
+	astra::fastTwoPowerFourierTransform1D(8, outR, outI, inR, inI, 1, 1, true);
+	astra::float32 expected2R[8] = { 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f };
+	for (unsigned int i = 0; i < 8; ++i) {
+		BOOST_CHECK_SMALL(inR[i] - expected2R[i], 0.00001f);
+		BOOST_CHECK_SMALL(inI[i], 0.00001f);
+	}
+
+}
+
+BOOST_AUTO_TEST_CASE( testFourier_FFT_2D_1 )
+{
+	astra::float32 inR[64] = { 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f,
+	                           1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f,
+	                           1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f,
+	                           1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+	                           0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+	                           1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+	                           1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f,
+	                           1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f };
+	astra::float32 inI[64] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+	                           0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+	                           0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+	                           0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+	                           0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+	                           0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+	                           0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+	                           0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
+	astra::float32 outR[64];
+	astra::float32 outI[64];
+
+	astra::discreteFourierTransform2D(8, 8, inR, inI, outR, outI, false);
+
+	astra::float32 expected1R[64] =
+	     { 25.0f, 12.656854f, 1.0f, 1.343146f, 1.0f, 1.343146f, 1.0f, 12.656854f,
+	       12.656854f, 3.0f, -3.828427f, -1.0f, -1.0f, -1.0f, -3.828427f, 3.0f,
+	       1.0f, -3.828427f, -3.0f, 1.828427f, 1.0f, 1.828427f, -3.0f, -3.828427f,
+	       1.343146f, -1.0f, 1.828427f, 3.0f, -1.0f, 3.0f, 1.828427f, -1.0f,
+	       1.0f, -1.0f, 1.0f, -1.0f, -7.0f, -1.0f, 1.0f, -1.0f,
+	       1.343146f, -1.0f, 1.828427f, 3.0f, -1.0f, 3.0f, 1.828427f, -1.0f,
+	       1.0f, -3.828427f, -3.0f, 1.828427f, 1.0f, 1.828427f, -3.0f, -3.828427f,
+	       12.656854f, 3.0f, -3.828427f, -1.0f, -1.0f, -1.0f, -3.828427f, 3.0f };
+	for (unsigned int i = 0; i < 64; ++i) {
+		BOOST_CHECK_SMALL(outR[i] - expected1R[i], 0.00002f);
+		BOOST_CHECK_SMALL(outI[i], 0.00001f);
+	}
+
+
+	astra::discreteFourierTransform2D(8, 8, outR, outI, inR, inI, true);
+	astra::float32 expected2R[64] = { 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f,
+	                                  1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f,
+	                                  1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f,
+	                                  1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+	                                  0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+	                                  1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+	                                  1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f,
+	                                  1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f };
+	for (unsigned int i = 0; i < 64; ++i) {
+		BOOST_CHECK_SMALL(inR[i] - expected2R[i], 0.00001f);
+		BOOST_CHECK_SMALL(inI[i], 0.00001f);
+	}
+
+
+}
+
diff --git a/tests/test_ParallelBeamLineKernelProjector2D.cpp b/tests/test_ParallelBeamLineKernelProjector2D.cpp
new file mode 100644
index 0000000..86bc54f
--- /dev/null
+++ b/tests/test_ParallelBeamLineKernelProjector2D.cpp
@@ -0,0 +1,82 @@
+/*
+-----------------------------------------------------------------------
+Copyright 2012 iMinds-Vision Lab, University of Antwerp
+
+Contact: astra@ua.ac.be
+Website: http://astra.ua.ac.be
+
+
+This file is part of the
+All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA Toolbox").
+
+The ASTRA Toolbox is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The ASTRA Toolbox is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
+
+-----------------------------------------------------------------------
+$Id$
+*/
+
+
+
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>
+#include <boost/test/auto_unit_test.hpp>
+#include <boost/test/floating_point_comparison.hpp>
+
+#include "astra/ParallelBeamLineKernelProjector2D.h"
+#include "astra/ParallelProjectionGeometry2D.h"
+#include "astra/VolumeGeometry2D.h"
+
+struct TestParallelBeamLineKernelProjector2D {
+        TestParallelBeamLineKernelProjector2D()
+	{
+		astra::float32 angles[] = { 1.0f };
+		BOOST_REQUIRE( projGeom.initialize(1, 9, 1.0f, angles) );
+		BOOST_REQUIRE( volGeom.initialize(6, 4) );
+		BOOST_REQUIRE( proj.initialize(&projGeom, &volGeom) );
+	}
+        ~TestParallelBeamLineKernelProjector2D()
+	{
+
+	}
+
+	astra::CParallelBeamLineKernelProjector2D proj;
+	astra::CParallelProjectionGeometry2D projGeom;
+	astra::CVolumeGeometry2D volGeom;
+};
+
+BOOST_FIXTURE_TEST_CASE( testParallelBeamLineKernelProjector2D_General, TestParallelBeamLineKernelProjector2D )
+{
+
+}
+
+BOOST_FIXTURE_TEST_CASE( testParallelBeamLineKernelProjector2D_Rectangle, TestParallelBeamLineKernelProjector2D )
+{
+	int iMax = proj.getProjectionWeightsCount(0);
+	BOOST_REQUIRE(iMax > 0);
+
+	astra::SPixelWeight* pPix = new astra::SPixelWeight[iMax];
+	BOOST_REQUIRE(pPix);
+
+	int iCount;
+	proj.computeSingleRayWeights(0, 4, pPix, iMax, iCount); 
+	BOOST_REQUIRE(iCount <= iMax);
+
+	astra::float32 fWeight = 0;
+	for (int i = 0; i < iCount; ++i)
+		fWeight += pPix[i].m_fWeight;
+
+	BOOST_CHECK_SMALL(fWeight - 7.13037f, 0.00001f);
+}
+
+
diff --git a/tests/test_ParallelBeamLinearKernelProjector2D.cpp b/tests/test_ParallelBeamLinearKernelProjector2D.cpp
new file mode 100644
index 0000000..9100db4
--- /dev/null
+++ b/tests/test_ParallelBeamLinearKernelProjector2D.cpp
@@ -0,0 +1,172 @@
+/*
+-----------------------------------------------------------------------
+Copyright 2012 iMinds-Vision Lab, University of Antwerp
+
+Contact: astra@ua.ac.be
+Website: http://astra.ua.ac.be
+
+
+This file is part of the
+All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA Toolbox").
+
+The ASTRA Toolbox is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The ASTRA Toolbox is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
+
+-----------------------------------------------------------------------
+$Id$
+*/
+
+
+
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>
+#include <boost/test/auto_unit_test.hpp>
+#include <boost/test/floating_point_comparison.hpp>
+
+#include "astra/ParallelBeamLineKernelProjector2D.h"
+#include "astra/ParallelBeamLinearKernelProjector2D.h"
+#include "astra/ParallelBeamStripKernelProjector2D.h"
+#include "astra/ParallelProjectionGeometry2D.h"
+#include "astra/VolumeGeometry2D.h"
+#include "astra/ProjectionGeometry2D.h"
+
+#include <ctime>
+
+using astra::float32;
+
+struct TestParallelBeamLinearKernelProjector2D {
+        TestParallelBeamLinearKernelProjector2D()
+	{
+		astra::float32 angles[] = { 2.6f };
+		BOOST_REQUIRE( projGeom.initialize(1, 3, 1.0f, angles) );
+		BOOST_REQUIRE( volGeom.initialize(3, 2) );
+		BOOST_REQUIRE( proj.initialize(&projGeom, &volGeom) );
+	}
+        ~TestParallelBeamLinearKernelProjector2D()
+	{
+
+	}
+
+	astra::CParallelBeamLinearKernelProjector2D proj;
+	astra::CParallelProjectionGeometry2D projGeom;
+	astra::CVolumeGeometry2D volGeom;
+};
+
+BOOST_FIXTURE_TEST_CASE( testParallelBeamLinearKernelProjector2D_General, TestParallelBeamLinearKernelProjector2D )
+{
+
+}
+
+
+// Compute linear kernel for a single volume pixel/detector pixel combination
+float32 compute_linear_kernel(const astra::CProjectionGeometry2D& projgeom, const astra::CVolumeGeometry2D& volgeom,
+                  int iX, int iY, int iDet, float32 fAngle)
+{
+	// projection of center of volume pixel on detector array
+	float32 fDetProj = (iX - (volgeom.getGridColCount()-1.0f)/2.0f ) * volgeom.getPixelLengthX() * cos(fAngle) - (iY - (volgeom.getGridRowCount()-1.0f)/2.0f ) * volgeom.getPixelLengthY() * sin(fAngle);
+
+	// start of detector pixel on detector array
+	float32 fDetStart = projgeom.indexToDetectorOffset(iDet) - 0.5f;
+
+//	printf("(%d,%d,%d): %f in (%f,%f)\n", iX,iY,iDet,fDetProj, fDetStart, fDetStart+1.0f);
+
+	// projection of center of next volume pixel on detector array
+	float32 fDetStep;
+	// length of projection ray through volume pixel
+	float32 fWeight;
+
+	if (fabs(cos(fAngle)) > fabs(sin(fAngle))) {
+		fDetStep = volgeom.getPixelLengthY() * fabs(cos(fAngle));
+		fWeight = volgeom.getPixelLengthX() * 1.0f / fabs(cos(fAngle));
+	} else {
+		fDetStep = volgeom.getPixelLengthX() * fabs(sin(fAngle));
+		fWeight = volgeom.getPixelLengthY() * 1.0f / fabs(sin(fAngle));
+	}
+
+//	printf("step: %f\n   weight: %f\n", fDetStep, fWeight);
+
+	// center of detector pixel on detector array
+	float32 fDetCenter = fDetStart + 0.5f;
+
+	// unweighted contribution of this volume pixel:
+	// linear interpolation between
+	//  fDetCenter - fDetStep    |---> 0
+	//  fDetCenter               |---> 1
+	//  fDetCenter + fDetStep    |---> 0
+	float32 fBase;
+	if (fDetCenter <= fDetProj) {
+		fBase = (fDetCenter - (fDetProj - fDetStep))/fDetStep;
+	} else {
+		fBase = ((fDetProj + fDetStep) - fDetCenter)/fDetStep;
+	}
+//	printf("base: %f\n", fBase);
+	if (fBase < 0) fBase = 0;
+	return fBase * fWeight;
+}
+
+BOOST_AUTO_TEST_CASE( testParallelBeamLinearKernelProjector2D_Rectangles )
+{
+	astra::CParallelBeamLinearKernelProjector2D proj;
+	astra::CParallelProjectionGeometry2D projGeom;
+	astra::CVolumeGeometry2D volGeom;
+
+	const unsigned int iRandomTestCount = 100;
+
+	unsigned int iSeed = time(0);
+	srand(iSeed);
+
+	for (unsigned int iTest = 0; iTest < iRandomTestCount; ++iTest) {
+		int iDetectorCount = 1 + (rand() % 100);
+		int iRows = 1 + (rand() % 100);
+		int iCols = 1 + (rand() % 100);
+		
+		
+		astra::float32 angles[] = { rand() * 2.0f*astra::PI / RAND_MAX };
+		projGeom.initialize(1, iDetectorCount, 0.8f, angles);
+		volGeom.initialize(iCols, iRows);
+		proj.initialize(&projGeom, &volGeom);
+
+		int iMax = proj.getProjectionWeightsCount(0);
+		BOOST_REQUIRE(iMax > 0);
+
+		astra::SPixelWeight* pPix = new astra::SPixelWeight[iMax];
+		BOOST_REQUIRE(pPix);
+
+		astra::float32 fWeight = 0;
+		for (int iDet = 0; iDet < projGeom.getDetectorCount(); ++iDet) {
+			int iCount;
+			proj.computeSingleRayWeights(0, iDet, pPix, iMax, iCount); 
+			BOOST_REQUIRE(iCount <= iMax);
+
+			astra::float32 fW = 0;
+			for (int i = 0; i < iCount; ++i) {
+				float32 fTest = compute_linear_kernel(
+				            projGeom,
+				            volGeom,
+				            pPix[i].m_iIndex % volGeom.getGridColCount(),
+				            pPix[i].m_iIndex / volGeom.getGridColCount(),
+				            iDet,
+				            projGeom.getProjectionAngle(0));
+				BOOST_CHECK_SMALL( pPix[i].m_fWeight - fTest, 0.00037f);
+				fW += pPix[i].m_fWeight;
+			}
+
+			fWeight += fW;
+
+		}
+
+		delete[] pPix;
+	}
+}
+
+
diff --git a/tests/test_ParallelProjectionGeometry2D.cpp b/tests/test_ParallelProjectionGeometry2D.cpp
new file mode 100644
index 0000000..809c6fa
--- /dev/null
+++ b/tests/test_ParallelProjectionGeometry2D.cpp
@@ -0,0 +1,120 @@
+/*
+-----------------------------------------------------------------------
+Copyright 2012 iMinds-Vision Lab, University of Antwerp
+
+Contact: astra@ua.ac.be
+Website: http://astra.ua.ac.be
+
+
+This file is part of the
+All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA Toolbox").
+
+The ASTRA Toolbox is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The ASTRA Toolbox is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
+
+-----------------------------------------------------------------------
+$Id$
+*/
+
+
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>
+#include <boost/test/auto_unit_test.hpp>
+#include <boost/test/test_case_template.hpp>
+#include <boost/test/floating_point_comparison.hpp>
+
+#include "astra/ParallelProjectionGeometry2D.h"
+
+BOOST_AUTO_TEST_CASE( testParallelProjectionGeometry2D_Constructor )
+{
+	astra::float32 angles[] = { 0.0f, 1.0f, 2.0f, 3.0f };
+	astra::CParallelProjectionGeometry2D geom(4, 8, 0.5f, angles);
+
+	BOOST_REQUIRE( geom.isInitialized() );
+
+	BOOST_CHECK( geom.getProjectionAngleCount() == 4 );
+	BOOST_CHECK( geom.getDetectorCount() == 8 );
+	BOOST_CHECK( geom.getDetectorWidth() == 0.5f );
+	BOOST_CHECK( geom.getProjectionAngle(0) == 0.0f );
+	BOOST_CHECK( geom.getProjectionAngle(1) == 1.0f );
+	BOOST_CHECK( geom.getProjectionAngle(2) == 2.0f );
+	BOOST_CHECK( geom.getProjectionAngle(3) == 3.0f );
+	BOOST_CHECK( geom.getProjectionAngles()[0] == 0.0f );
+	BOOST_CHECK( geom.getProjectionAngles()[3] == 3.0f );
+}
+
+BOOST_AUTO_TEST_CASE( testParallelProjectionGeometry2D_Offsets )
+{
+	astra::float32 angles[] = { 0.0f, 1.0f, 2.0f, 3.0f };
+	astra::CParallelProjectionGeometry2D geom(4, 8, 0.5f, angles);
+
+	BOOST_REQUIRE( geom.isInitialized() );
+
+	BOOST_CHECK_SMALL( geom.getProjectionAngleDegrees(2) - 114.59155902f, 1e-5f );
+
+	BOOST_CHECK( geom.detectorOffsetToIndexFloat(0.0f) == 3.5f );
+	BOOST_CHECK( geom.detectorOffsetToIndexFloat(0.625f) == 4.75f );
+	BOOST_CHECK( geom.detectorOffsetToIndex(-0.1f) == 3 );
+
+	BOOST_CHECK( geom.indexToDetectorOffset(0) == -1.75f );
+	BOOST_CHECK( geom.indexToDetectorOffset(1) == -1.25f );
+
+	int angle, detector;
+	geom.indexToAngleDetectorIndex(10, angle, detector);
+	BOOST_CHECK( angle == 1 );
+	BOOST_CHECK( detector == 2 );
+
+	float t, theta;
+	geom.getRayParams(1, 2, t, theta);
+	BOOST_CHECK( theta == 1.0f );
+	BOOST_CHECK( t == -0.75f );
+
+	// TODO: add test with large angle
+}
+
+BOOST_AUTO_TEST_CASE( testParallelProjectionGeometry2D_Offsets_odd )
+{
+	astra::float32 angles[] = { 0.0f, 1.0f, 2.0f, 3.0f };
+	astra::CParallelProjectionGeometry2D geom(4, 7, 0.5f, angles);
+
+	BOOST_REQUIRE( geom.isInitialized() );
+
+	BOOST_CHECK( geom.detectorOffsetToIndexFloat(0.0f) == 3.0f );
+	BOOST_CHECK( geom.detectorOffsetToIndexFloat(0.625f) == 4.25f );
+}
+
+
+BOOST_AUTO_TEST_CASE( testParallelProjectionGeometry2D_Clone )
+{
+	astra::float32 angles[] = { 0.0f, 1.0f, 2.0f, 3.0f };
+	astra::CParallelProjectionGeometry2D geom(4, 8, 0.5f, angles);
+
+	BOOST_REQUIRE( geom.isInitialized() );
+
+	astra::CProjectionGeometry2D* geom2 = geom.clone();
+
+	BOOST_REQUIRE( geom2->isInitialized() );
+
+	BOOST_CHECK( geom.isEqual(geom2) );
+	BOOST_CHECK( geom2->getProjectionAngleCount() == 4 );
+	BOOST_CHECK( geom2->getDetectorCount() == 8 );
+	BOOST_CHECK( geom2->getDetectorWidth() == 0.5f );
+	BOOST_CHECK( geom2->getProjectionAngle(0) == 0.0f );
+	BOOST_CHECK( geom2->getProjectionAngle(1) == 1.0f );
+	BOOST_CHECK( geom2->getProjectionAngle(2) == 2.0f );
+	BOOST_CHECK( geom2->getProjectionAngle(3) == 3.0f );
+	BOOST_CHECK( geom2->getProjectionAngles()[0] == 0.0f );
+	BOOST_CHECK( geom2->getProjectionAngles()[3] == 3.0f );
+	delete geom2;
+}
+
diff --git a/tests/test_VolumeGeometry2D.cpp b/tests/test_VolumeGeometry2D.cpp
new file mode 100644
index 0000000..4ae88d3
--- /dev/null
+++ b/tests/test_VolumeGeometry2D.cpp
@@ -0,0 +1,150 @@
+/*
+-----------------------------------------------------------------------
+Copyright 2012 iMinds-Vision Lab, University of Antwerp
+
+Contact: astra@ua.ac.be
+Website: http://astra.ua.ac.be
+
+
+This file is part of the
+All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA Toolbox").
+
+The ASTRA Toolbox is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The ASTRA Toolbox is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
+
+-----------------------------------------------------------------------
+$Id$
+*/
+
+
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>
+#include <boost/test/auto_unit_test.hpp>
+#include <boost/test/test_case_template.hpp>
+#include <boost/test/floating_point_comparison.hpp>
+
+#include "astra/VolumeGeometry2D.h"
+
+BOOST_AUTO_TEST_CASE( testVolumeGeometry2D_Constructor1 )
+{
+	astra::CVolumeGeometry2D geom(16, 32);
+
+	BOOST_REQUIRE( geom.isInitialized() );
+
+	BOOST_CHECK( geom.getGridColCount() == 16 );
+	BOOST_CHECK( geom.getGridRowCount() == 32 );
+	BOOST_CHECK( geom.getGridTotCount() == 512 );
+	BOOST_CHECK( geom.getWindowLengthX() == 16.0f );
+	BOOST_CHECK( geom.getWindowLengthY() == 32.0f );
+	BOOST_CHECK( geom.getWindowArea() == 512.0f );
+	BOOST_CHECK( geom.getPixelLengthX() == 1.0f );
+	BOOST_CHECK( geom.getPixelLengthY() == 1.0f );
+	BOOST_CHECK( geom.getPixelArea() == 1.0f );
+	BOOST_CHECK( geom.getWindowMinX() == -8.0f );
+	BOOST_CHECK( geom.getWindowMaxX() == 8.0f );
+	BOOST_CHECK( geom.getWindowMinY() == -16.0f );
+	BOOST_CHECK( geom.getWindowMaxY() == 16.0f );
+}
+
+BOOST_AUTO_TEST_CASE( testVolumeGeometry2D_Constructor1odd )
+{
+	astra::CVolumeGeometry2D geom(5, 7);
+
+	BOOST_REQUIRE( geom.isInitialized() );
+
+	BOOST_CHECK( geom.getGridColCount() == 5 );
+	BOOST_CHECK( geom.getGridRowCount() == 7 );
+	BOOST_CHECK( geom.getGridTotCount() == 35 );
+	BOOST_CHECK( geom.getWindowLengthX() == 5.0f );
+	BOOST_CHECK( geom.getWindowLengthY() == 7.0f );
+	BOOST_CHECK( geom.getWindowArea() == 35.0f );
+	BOOST_CHECK( geom.getPixelLengthX() == 1.0f );
+	BOOST_CHECK( geom.getPixelLengthY() == 1.0f );
+	BOOST_CHECK( geom.getPixelArea() == 1.0f );
+	BOOST_CHECK( geom.getWindowMinX() == -2.5f );
+	BOOST_CHECK( geom.getWindowMaxX() == 2.5f );
+	BOOST_CHECK( geom.getWindowMinY() == -3.5f );
+	BOOST_CHECK( geom.getWindowMaxY() == 3.5f );
+}
+
+BOOST_AUTO_TEST_CASE( testVolumeGeometry2D_Constructor2 )
+{
+	astra::CVolumeGeometry2D geom(16, 32, -1.0f, -2.0f, 3.0f, 4.0f);
+
+	BOOST_REQUIRE( geom.isInitialized() );
+
+	BOOST_CHECK( geom.getGridColCount() == 16 );
+	BOOST_CHECK( geom.getGridRowCount() == 32 );
+	BOOST_CHECK( geom.getGridTotCount() == 512 );
+	BOOST_CHECK( geom.getWindowLengthX() == 4.0f );
+	BOOST_CHECK( geom.getWindowLengthY() == 6.0f );
+	BOOST_CHECK( geom.getWindowArea() == 24.0f );
+	BOOST_CHECK( geom.getPixelLengthX() == 0.25f );
+	BOOST_CHECK( geom.getPixelLengthY() == 0.1875f );
+	BOOST_CHECK( geom.getPixelArea() == 0.046875f );
+	BOOST_CHECK( geom.getWindowMinX() == -1.0f );
+	BOOST_CHECK( geom.getWindowMaxX() == 3.0f );
+	BOOST_CHECK( geom.getWindowMinY() == -2.0f );
+	BOOST_CHECK( geom.getWindowMaxY() == 4.0f );
+}
+
+BOOST_AUTO_TEST_CASE( testVolumeGeometry2D_Clone )
+{
+	astra::CVolumeGeometry2D geom(16, 32, -1.0f, -2.0f, 3.0f, 4.0f);
+
+	astra::CVolumeGeometry2D* geom2 = geom.clone();
+
+	BOOST_REQUIRE( geom2->isInitialized() );
+
+	BOOST_CHECK( geom.isEqual(geom2) );
+	BOOST_CHECK( geom2->getGridColCount() == 16 );
+	BOOST_CHECK( geom2->getGridRowCount() == 32 );
+	BOOST_CHECK( geom2->getGridTotCount() == 512 );
+	BOOST_CHECK( geom2->getWindowLengthX() == 4.0f );
+	BOOST_CHECK( geom2->getWindowLengthY() == 6.0f );
+	BOOST_CHECK( geom2->getWindowArea() == 24.0f );
+	BOOST_CHECK( geom2->getPixelLengthX() == 0.25f );
+	BOOST_CHECK( geom2->getPixelLengthY() == 0.1875f );
+	BOOST_CHECK( geom2->getPixelArea() == 0.046875f );
+	BOOST_CHECK( geom2->getWindowMinX() == -1.0f );
+	BOOST_CHECK( geom2->getWindowMaxX() == 3.0f );
+	BOOST_CHECK( geom2->getWindowMinY() == -2.0f );
+	BOOST_CHECK( geom2->getWindowMaxY() == 4.0f );
+
+	delete geom2;
+}
+
+BOOST_AUTO_TEST_CASE( testVolumeGeometry2D_Offsets )
+{
+	astra::CVolumeGeometry2D geom(16, 32, -1.0f, -2.0f, 3.0f, 4.0f);
+
+	BOOST_REQUIRE( geom.isInitialized() );
+
+	BOOST_CHECK( geom.pixelRowColToIndex(1,2) == 18 );
+
+	int r,c;
+	geom.pixelIndexToRowCol(66, r, c);
+	BOOST_CHECK( r == 4 );
+	BOOST_CHECK( c == 2 );
+
+	BOOST_CHECK( geom.pixelColToCenterX(2) == -0.375f );
+	BOOST_CHECK( geom.pixelColToMinX(2) == -0.5f );
+	BOOST_CHECK( geom.pixelColToMaxX(2) == -0.25f );
+
+	BOOST_CHECK( geom.pixelRowToCenterY(29) == -1.53125f );
+	BOOST_CHECK( geom.pixelRowToMinY(29) == -1.625f );
+	BOOST_CHECK( geom.pixelRowToMaxY(29) == -1.4375f );
+
+	BOOST_CHECK( geom.coordXToCol(0.1f) == 4 );
+	BOOST_CHECK( geom.coordYToRow(0.1f) == 20 );
+}
diff --git a/tests/test_XMLDocument.cpp b/tests/test_XMLDocument.cpp
new file mode 100644
index 0000000..adabdd6
--- /dev/null
+++ b/tests/test_XMLDocument.cpp
@@ -0,0 +1,158 @@
+/*
+-----------------------------------------------------------------------
+Copyright 2012 iMinds-Vision Lab, University of Antwerp
+
+Contact: astra@ua.ac.be
+Website: http://astra.ua.ac.be
+
+
+This file is part of the
+All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA Toolbox").
+
+The ASTRA Toolbox is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The ASTRA Toolbox is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
+
+-----------------------------------------------------------------------
+$Id$
+*/
+
+
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>
+#include <boost/test/auto_unit_test.hpp>
+
+#include "astra/XMLDocument.h"
+
+BOOST_AUTO_TEST_CASE( testXMLDocument_Constructor1 )
+{
+	astra::XMLDocument *doc = astra::XMLDocument::createDocument("test");
+	BOOST_REQUIRE(doc);
+
+	astra::XMLNode *root = doc->getRootNode();
+
+	BOOST_REQUIRE(root);
+
+	BOOST_CHECK(root->getName() == "test");
+	BOOST_CHECK(root->getContent().empty());
+}
+
+BOOST_AUTO_TEST_CASE( testXMLDocument_FileIO )
+{
+	astra::XMLDocument *doc = astra::XMLDocument::createDocument("test");
+
+	doc->saveToFile("test.xml");
+
+	astra::XMLDocument *doc2 = astra::XMLDocument::readFromFile("test.xml");
+	astra::XMLNode *root = doc2->getRootNode();
+
+	BOOST_REQUIRE(root);
+
+	BOOST_CHECK(root->getName() == "test");
+	BOOST_CHECK(root->getContent().empty());
+
+}
+
+BOOST_AUTO_TEST_CASE( testXMLDocument_CreateNodes )
+{
+	astra::XMLDocument *doc = astra::XMLDocument::createDocument("test");
+	BOOST_REQUIRE(doc);
+
+	astra::XMLNode *root = doc->getRootNode();
+	BOOST_REQUIRE(root);
+
+	astra::XMLNode *node = root->addChildNode("child");
+	BOOST_REQUIRE(node);
+
+	node->addAttribute("attr", "val");
+
+	doc->saveToFile("test2.xml");
+
+	delete node;
+	delete root;
+	delete doc;
+
+	doc = astra::XMLDocument::readFromFile("test2.xml");
+	BOOST_REQUIRE(doc);
+	root = doc->getRootNode();
+	BOOST_REQUIRE(node);
+	node = root->getSingleNode("child");
+	BOOST_REQUIRE(node);
+
+	BOOST_CHECK(node->hasAttribute("attr"));
+	BOOST_CHECK(node->getAttribute("attr") == "val");
+
+	delete node;
+	delete root;
+	delete doc;
+}
+
+BOOST_AUTO_TEST_CASE( testXMLDocument_Options )
+{
+	astra::XMLDocument *doc = astra::XMLDocument::createDocument("test");
+	BOOST_REQUIRE(doc);
+
+	astra::XMLNode *root = doc->getRootNode();
+	BOOST_REQUIRE(root);
+
+	BOOST_CHECK(!root->hasOption("opt"));
+
+	root->addOption("opt", "val");
+
+	BOOST_CHECK(root->hasOption("opt"));
+
+	BOOST_CHECK(root->getOption("opt") == "val");
+
+}
+
+BOOST_AUTO_TEST_CASE( testXMLDocument_List )
+{
+	astra::XMLDocument *doc = astra::XMLDocument::createDocument("test");
+	BOOST_REQUIRE(doc);
+
+	astra::XMLNode *root = doc->getRootNode();
+	BOOST_REQUIRE(root);
+
+	astra::XMLNode *node = root->addChildNode("child");
+	BOOST_REQUIRE(node);
+
+
+	float fl[] = { 1.0, 3.5, 2.0, 4.75 };
+
+	node->setContent(fl, sizeof(fl)/sizeof(fl[0]));
+
+	doc->saveToFile("test3.xml");
+
+	delete node;
+	delete root;
+	delete doc;
+
+	doc = astra::XMLDocument::readFromFile("test3.xml");
+	BOOST_REQUIRE(doc);
+	root = doc->getRootNode();
+	BOOST_REQUIRE(root);
+	node = root->getSingleNode("child");
+	BOOST_REQUIRE(node);
+
+	std::vector<astra::float32> f = node->getContentNumericalArray();
+
+	BOOST_CHECK(f[0] == fl[0]);
+	BOOST_CHECK(f[1] == fl[1]);
+	BOOST_CHECK(f[2] == fl[2]);
+	BOOST_CHECK(f[3] == fl[3]);
+
+	delete node;
+	delete root;
+	delete doc;
+
+}
+
diff --git a/tests/tests_vc08.vcproj b/tests/tests_vc08.vcproj
new file mode 100644
index 0000000..90c5d55
--- /dev/null
+++ b/tests/tests_vc08.vcproj
@@ -0,0 +1,699 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="tests"
+	ProjectGUID="{32C1BDD3-38C2-4C80-A03C-2129782F59B5}"
+	RootNamespace="tests"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="131072"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+		<Platform
+			Name="x64"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)\tests\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\"
+			ConfigurationType="1"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="..\lib\include\;..\include\"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="0"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra32D.lib"
+				LinkIncremental="2"
+				AdditionalLibraryDirectories="..\lib\win32\;..\bin\win32"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug|x64"
+			OutputDirectory="$(SolutionDir)\tests\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\"
+			ConfigurationType="1"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="..\lib\include\;..\include\"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="0"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra64D.lib"
+				LinkIncremental="2"
+				AdditionalLibraryDirectories="..\lib\x64\;..\bin\x64"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+				TargetMachine="17"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)\tests\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\"
+			ConfigurationType="1"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="..\lib\include\;..\include\"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra32.lib"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories="..\lib\win32\;..\bin\win32"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|x64"
+			OutputDirectory="$(SolutionDir)\tests\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\"
+			ConfigurationType="1"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="..\lib\include\;..\include\"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Astra64.lib"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories="..\lib\x64\;..\bin\x64"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+				TargetMachine="17"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug_CUDA|Win32"
+			OutputDirectory="$(SolutionDir)\tests\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\"
+			ConfigurationType="1"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="..\lib\include\;..\include\"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="0"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda32D.lib"
+				LinkIncremental="2"
+				AdditionalLibraryDirectories="..\lib\win32\;..\bin\win32"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug_CUDA|x64"
+			OutputDirectory="$(SolutionDir)\tests\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\"
+			ConfigurationType="1"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="..\lib\include\;..\include\"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="0"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda64D.lib"
+				LinkIncremental="2"
+				AdditionalLibraryDirectories="..\lib\x64\;..\bin\x64"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+				TargetMachine="17"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release_CUDA|Win32"
+			OutputDirectory="$(SolutionDir)\tests\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\"
+			ConfigurationType="1"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="..\lib\include\;..\include\"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda32.lib"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories="..\lib\win32\;..\bin\win32"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release_CUDA|x64"
+			OutputDirectory="$(SolutionDir)\tests\$(PlatformName)\$(ConfigurationName)"
+			IntermediateDirectory="$(OutDir)\obj\"
+			ConfigurationType="1"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="..\lib\include\;..\include\"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="AstraCuda64.lib"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories="..\lib\x64\;..\bin\x64"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				RandomizedBaseAddress="1"
+				DataExecutionPrevention="0"
+				TargetMachine="17"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Test Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath=".\test_FanFlatProjectionGeometry2D.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\test_Float32Data2D.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\test_Float32ProjectionData2D.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\test_Float32VolumeData2D.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\test_Fourier.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\test_ParallelBeamLinearKernelProjector2D.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\test_ParallelBeamLineKernelProjector2D.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\test_ParallelProjectionGeometry2D.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\test_VolumeGeometry2D.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Main"
+			>
+			<File
+				RelativePath=".\main.cpp"
+				>
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>