diff options
Diffstat (limited to 'tests')
| -rw-r--r-- | tests/main.cpp | 38 | ||||
| -rw-r--r-- | tests/test_AstraObjectManager.cpp | 79 | ||||
| -rw-r--r-- | tests/test_FanFlatProjectionGeometry2D.cpp | 119 | ||||
| -rw-r--r-- | tests/test_Float32Data2D.cpp | 229 | ||||
| -rw-r--r-- | tests/test_Float32ProjectionData2D.cpp | 115 | ||||
| -rw-r--r-- | tests/test_Float32VolumeData2D.cpp | 110 | ||||
| -rw-r--r-- | tests/test_Fourier.cpp | 182 | ||||
| -rw-r--r-- | tests/test_ParallelBeamLineKernelProjector2D.cpp | 82 | ||||
| -rw-r--r-- | tests/test_ParallelBeamLinearKernelProjector2D.cpp | 172 | ||||
| -rw-r--r-- | tests/test_ParallelProjectionGeometry2D.cpp | 120 | ||||
| -rw-r--r-- | tests/test_VolumeGeometry2D.cpp | 150 | ||||
| -rw-r--r-- | tests/test_XMLDocument.cpp | 158 | ||||
| -rw-r--r-- | tests/tests_vc08.vcproj | 699 |
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> |