summaryrefslogtreecommitdiffstats
path: root/include
diff options
context:
space:
mode:
Diffstat (limited to 'include')
-rw-r--r--include/astra/CudaFilteredBackProjectionAlgorithm.h8
-rw-r--r--include/astra/CudaProjector2D.h2
-rw-r--r--include/astra/CudaProjector3D.h2
-rw-r--r--include/astra/Float32Data3D.h2
-rw-r--r--include/astra/Float32Data3DGPU.h2
-rw-r--r--include/astra/cuda/2d/algo.h173
-rw-r--r--include/astra/cuda/2d/arith.h85
-rw-r--r--include/astra/cuda/2d/astra.h127
-rw-r--r--include/astra/cuda/2d/cgls.h90
-rw-r--r--include/astra/cuda/2d/darthelper.h41
-rw-r--r--include/astra/cuda/2d/dims.h68
-rw-r--r--include/astra/cuda/2d/em.h75
-rw-r--r--include/astra/cuda/2d/fan_bp.h52
-rw-r--r--include/astra/cuda/2d/fan_fp.h40
-rw-r--r--include/astra/cuda/2d/fbp.h97
-rw-r--r--include/astra/cuda/2d/fbp_filters.h61
-rw-r--r--include/astra/cuda/2d/fft.h72
-rw-r--r--include/astra/cuda/2d/par_bp.h47
-rw-r--r--include/astra/cuda/2d/par_fp.h40
-rw-r--r--include/astra/cuda/2d/sart.h87
-rw-r--r--include/astra/cuda/2d/sirt.h96
-rw-r--r--include/astra/cuda/2d/util.h84
-rw-r--r--include/astra/cuda/3d/algo3d.h71
-rw-r--r--include/astra/cuda/3d/arith3d.h79
-rw-r--r--include/astra/cuda/3d/astra3d.h314
-rw-r--r--include/astra/cuda/3d/cgls3d.h112
-rw-r--r--include/astra/cuda/3d/cone_bp.h45
-rw-r--r--include/astra/cuda/3d/cone_fp.h45
-rw-r--r--include/astra/cuda/3d/darthelper3d.h42
-rw-r--r--include/astra/cuda/3d/dims3d.h77
-rw-r--r--include/astra/cuda/3d/fdk.h50
-rw-r--r--include/astra/cuda/3d/mem3d.h105
-rw-r--r--include/astra/cuda/3d/par3d_bp.h46
-rw-r--r--include/astra/cuda/3d/par3d_fp.h50
-rw-r--r--include/astra/cuda/3d/sirt3d.h121
-rw-r--r--include/astra/cuda/3d/util3d.h68
36 files changed, 2568 insertions, 8 deletions
diff --git a/include/astra/CudaFilteredBackProjectionAlgorithm.h b/include/astra/CudaFilteredBackProjectionAlgorithm.h
index 5ff9f02..1280e9a 100644
--- a/include/astra/CudaFilteredBackProjectionAlgorithm.h
+++ b/include/astra/CudaFilteredBackProjectionAlgorithm.h
@@ -30,11 +30,11 @@ along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
#ifdef ASTRA_CUDA
-#include <astra/Float32ProjectionData2D.h>
-#include <astra/Float32VolumeData2D.h>
-#include <astra/CudaReconstructionAlgorithm2D.h>
+#include "Float32ProjectionData2D.h"
+#include "Float32VolumeData2D.h"
+#include "CudaReconstructionAlgorithm2D.h"
-#include "../../cuda/2d/astra.h"
+#include "cuda/2d/astra.h"
namespace astra
{
diff --git a/include/astra/CudaProjector2D.h b/include/astra/CudaProjector2D.h
index db6972e..8f61064 100644
--- a/include/astra/CudaProjector2D.h
+++ b/include/astra/CudaProjector2D.h
@@ -33,7 +33,7 @@ along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
#include "ParallelProjectionGeometry2D.h"
#include "Float32Data2D.h"
#include "Projector2D.h"
-#include "../../cuda/2d/astra.h"
+#include "cuda/2d/astra.h"
namespace astra
{
diff --git a/include/astra/CudaProjector3D.h b/include/astra/CudaProjector3D.h
index 83ce93e..60df7bb 100644
--- a/include/astra/CudaProjector3D.h
+++ b/include/astra/CudaProjector3D.h
@@ -36,7 +36,7 @@ along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
#include "Globals.h"
#include "Config.h"
#include "Projector3D.h"
-#include "../../cuda/3d/astra3d.h"
+#include "cuda/3d/astra3d.h"
namespace astra
{
diff --git a/include/astra/Float32Data3D.h b/include/astra/Float32Data3D.h
index 12ad685..1bdddc6 100644
--- a/include/astra/Float32Data3D.h
+++ b/include/astra/Float32Data3D.h
@@ -32,7 +32,7 @@ along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
#include "Float32Data.h"
#include "Float32Data2D.h"
-#include "../../cuda/3d/mem3d.h"
+#include "cuda/3d/mem3d.h"
namespace astra {
diff --git a/include/astra/Float32Data3DGPU.h b/include/astra/Float32Data3DGPU.h
index 9ebb341..cac38f6 100644
--- a/include/astra/Float32Data3DGPU.h
+++ b/include/astra/Float32Data3DGPU.h
@@ -33,7 +33,7 @@ along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
#include "Globals.h"
#include "Float32Data3D.h"
-#include "../../cuda/3d/mem3d.h"
+#include "cuda/3d/mem3d.h"
namespace astra {
diff --git a/include/astra/cuda/2d/algo.h b/include/astra/cuda/2d/algo.h
new file mode 100644
index 0000000..2ce929c
--- /dev/null
+++ b/include/astra/cuda/2d/algo.h
@@ -0,0 +1,173 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_ALGO_H
+#define _CUDA_ALGO_H
+
+#include "astra/Globals.h"
+#include "dims.h"
+
+namespace astra {
+
+class CParallelProjectionGeometry2D;
+class CParallelVecProjectionGeometry2D;
+class CFanFlatProjectionGeometry2D;
+class CFanFlatVecProjectionGeometry2D;
+class CVolumeGeometry2D;
+class CProjectionGeometry2D;
+
+}
+
+namespace astraCUDA {
+
+class _AstraExport ReconAlgo {
+public:
+ ReconAlgo();
+ virtual ~ReconAlgo();
+
+ bool setGPUIndex(int iGPUIndex);
+
+ bool setGeometry(const astra::CVolumeGeometry2D* pVolGeom,
+ const astra::CProjectionGeometry2D* pProjGeom);
+
+ bool setSuperSampling(int raysPerDet, int raysPerPixelDim);
+
+ void signalAbort() { shouldAbort = true; }
+
+ virtual bool enableVolumeMask();
+ virtual bool enableSinogramMask();
+
+ // init should be called after setting all geometry
+ virtual bool init() = 0;
+
+ // setVolumeMask should be called after init and before iterate,
+ // but only if enableVolumeMask was called before init.
+ // It may be called again after iterate.
+ bool setVolumeMask(float* D_maskData, unsigned int maskPitch);
+
+ // setSinogramMask should be called after init and before iterate,
+ // but only if enableSinogramMask was called before init.
+ // It may be called again after iterate.
+ bool setSinogramMask(float* D_smaskData, unsigned int smaskPitch);
+
+
+ // setBuffers should be called after init and before iterate.
+ // It may be called again after iterate.
+ virtual bool setBuffers(float* D_volumeData, unsigned int volumePitch,
+ float* D_projData, unsigned int projPitch);
+
+
+ // instead of calling setBuffers, you can also call allocateBuffers
+ // to let ReconAlgo manage its own GPU memory
+ virtual bool allocateBuffers();
+
+ // copy data to GPU. This must be called after allocateBuffers.
+ // pfSinogram, pfReconstruction, pfVolMask, pfSinoMask are the
+ // sinogram, reconstruction, volume mask and sinogram mask in system RAM,
+ // respectively. The corresponding pitch variables give the pitches
+ // of these buffers, measured in floats.
+ // The sinogram is multiplied by fSinogramScale after uploading it.
+ virtual bool copyDataToGPU(const float* pfSinogram, unsigned int iSinogramPitch, float fSinogramScale,
+ const float* pfReconstruction, unsigned int iReconstructionPitch,
+ const float* pfVolMask, unsigned int iVolMaskPitch,
+ const float* pfSinoMask, unsigned int iSinoMaskPitch);
+
+
+
+ // set Min/Max constraints. They may be called at any time, and will affect
+ // any iterate() calls afterwards.
+ virtual bool setMinConstraint(float fMin);
+ virtual bool setMaxConstraint(float fMax);
+
+
+ // iterate should be called after init and setBuffers.
+ // It may be called multiple times.
+ virtual bool iterate(unsigned int iterations) = 0;
+
+ // Compute the norm of the difference of the FP of the current
+ // reconstruction and the sinogram. (This performs one FP.)
+ // It can be called after iterate.
+ virtual float computeDiffNorm() = 0;
+ // TODO: computeDiffNorm shouldn't be virtual, but for it to be
+ // implemented in ReconAlgo, it needs a way to get a suitable
+ // temporary sinogram buffer.
+
+ bool getReconstruction(float* pfReconstruction,
+ unsigned int iReconstructionPitch) const;
+
+
+
+protected:
+ void reset();
+
+ bool callFP(float* D_volumeData, unsigned int volumePitch,
+ float* D_projData, unsigned int projPitch,
+ float outputScale);
+ bool callBP(float* D_volumeData, unsigned int volumePitch,
+ float* D_projData, unsigned int projPitch,
+ float outputScale);
+
+
+ SDimensions dims;
+ SParProjection* parProjs;
+ SFanProjection* fanProjs;
+ float fOutputScale;
+
+ volatile bool shouldAbort;
+
+ bool freeGPUMemory;
+
+ // Input/output
+ float* D_sinoData;
+ unsigned int sinoPitch;
+
+ float* D_volumeData;
+ unsigned int volumePitch;
+
+ // Masks
+ bool useVolumeMask;
+ bool useSinogramMask;
+
+ float* D_maskData;
+ unsigned int maskPitch;
+ float* D_smaskData;
+ unsigned int smaskPitch;
+
+ // Min/max
+ bool useMinConstraint;
+ bool useMaxConstraint;
+ float fMinConstraint;
+ float fMaxConstraint;
+
+
+};
+
+
+}
+
+#endif
+
diff --git a/include/astra/cuda/2d/arith.h b/include/astra/cuda/2d/arith.h
new file mode 100644
index 0000000..e18bb1b
--- /dev/null
+++ b/include/astra/cuda/2d/arith.h
@@ -0,0 +1,85 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_ARITH_H
+#define _CUDA_ARITH_H
+
+#include <cuda.h>
+
+namespace astraCUDA {
+
+
+struct opAddScaled;
+struct opScaleAndAdd;
+struct opAddMulScaled;
+struct opAddMul;
+struct opAdd;
+struct opAdd2;
+struct opMul;
+struct opDiv;
+struct opMul2;
+struct opDividedBy;
+struct opInvert;
+struct opSet;
+struct opClampMin;
+struct opClampMax;
+struct opClampMinMask;
+struct opClampMaxMask;
+struct opSegmentAndMask;
+struct opSetMaskedValues;
+
+struct opMulMask;
+
+
+template<typename op> void processVolCopy(float* out, const SDimensions& dims);
+template<typename op> void processVolCopy(float* out, float param, const SDimensions& dims);
+template<typename op> void processVolCopy(float* out1, float* out2, float param1, float param2, const SDimensions& dims);
+template<typename op> void processVolCopy(float* out, const float* in, const SDimensions& dims);
+template<typename op> void processVolCopy(float* out, const float* in, float param, const SDimensions& dims);
+template<typename op> void processVolCopy(float* out, const float* in1, const float* in2, const SDimensions& dims);
+template<typename op> void processVolCopy(float* out, const float* in1, const float* in2, float param, const SDimensions& dims);
+
+template<typename op> void processVol(float* out, unsigned int pitch, const SDimensions& dims);
+template<typename op> void processVol(float* out, float fParam, unsigned int pitch, const SDimensions& dims);
+template<typename op> void processVol(float* out1, float* out2, float fParam1, float fParam2, unsigned int pitch, const SDimensions& dims);
+template<typename op> void processVol(float* out, const float* in, unsigned int pitch, const SDimensions& dims);
+template<typename op> void processVol(float* out, const float* in, float fParam, unsigned int pitch, const SDimensions& dims);
+template<typename op> void processVol(float* out, const float* in1, const float* in2, float fParam, unsigned int pitch, const SDimensions& dims);
+template<typename op> void processVol(float* out, const float* in1, const float* in2, unsigned int pitch, const SDimensions& dims);
+
+template<typename op> void processSino(float* out, unsigned int pitch, const SDimensions& dims);
+template<typename op> void processSino(float* out, float fParam, unsigned int pitch, const SDimensions& dims);
+template<typename op> void processSino(float* out1, float* out2, float fParam1, float fParam2, unsigned int pitch, const SDimensions& dims);
+template<typename op> void processSino(float* out, const float* in, unsigned int pitch, const SDimensions& dims);
+template<typename op> void processSino(float* out, const float* in, float fParam, unsigned int pitch, const SDimensions& dims);
+template<typename op> void processSino(float* out, const float* in1, const float* in2, float fParam, unsigned int pitch, const SDimensions& dims);
+template<typename op> void processSino(float* out, const float* in1, const float* in2, unsigned int pitch, const SDimensions& dims);
+
+
+}
+
+#endif
diff --git a/include/astra/cuda/2d/astra.h b/include/astra/cuda/2d/astra.h
new file mode 100644
index 0000000..6f0e2f0
--- /dev/null
+++ b/include/astra/cuda/2d/astra.h
@@ -0,0 +1,127 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_ASTRA_H
+#define _CUDA_ASTRA_H
+
+#include "fbp_filters.h"
+#include "dims.h"
+#include "algo.h"
+
+using astraCUDA::SFanProjection;
+
+namespace astra {
+
+enum Cuda2DProjectionKernel {
+ ker2d_default = 0
+};
+
+class CParallelProjectionGeometry2D;
+class CParallelVecProjectionGeometry2D;
+class CFanFlatProjectionGeometry2D;
+class CFanFlatVecProjectionGeometry2D;
+class CVolumeGeometry2D;
+class CProjectionGeometry2D;
+
+
+class _AstraExport BPalgo : public astraCUDA::ReconAlgo {
+public:
+ BPalgo();
+ ~BPalgo();
+
+ virtual bool init();
+
+ virtual bool iterate(unsigned int iterations);
+
+ virtual float computeDiffNorm();
+};
+
+
+
+
+// TODO: Clean up this interface to FP
+
+// Do a single forward projection
+_AstraExport bool astraCudaFP(const float* pfVolume, float* pfSinogram,
+ unsigned int iVolWidth, unsigned int iVolHeight,
+ unsigned int iProjAngles, unsigned int iProjDets,
+ const SParProjection *pAngles,
+ unsigned int iDetSuperSampling = 1,
+ float fOutputScale = 1.0f, int iGPUIndex = 0);
+
+_AstraExport bool astraCudaFanFP(const float* pfVolume, float* pfSinogram,
+ unsigned int iVolWidth, unsigned int iVolHeight,
+ unsigned int iProjAngles, unsigned int iProjDets,
+ const SFanProjection *pAngles,
+ unsigned int iDetSuperSampling = 1,
+ float fOutputScale = 1.0f, int iGPUIndex = 0);
+
+
+_AstraExport bool convertAstraGeometry(const CVolumeGeometry2D* pVolGeom,
+ const CParallelProjectionGeometry2D* pProjGeom,
+ astraCUDA::SParProjection*& pProjs,
+ float& fOutputScale);
+
+_AstraExport bool convertAstraGeometry(const CVolumeGeometry2D* pVolGeom,
+ const CParallelVecProjectionGeometry2D* pProjGeom,
+ astraCUDA::SParProjection*& pProjs,
+ float& fOutputScale);
+
+
+_AstraExport bool convertAstraGeometry(const CVolumeGeometry2D* pVolGeom,
+ const CFanFlatProjectionGeometry2D* pProjGeom,
+ astraCUDA::SFanProjection*& pProjs,
+ float& outputScale);
+
+_AstraExport bool convertAstraGeometry(const CVolumeGeometry2D* pVolGeom,
+ const CFanFlatVecProjectionGeometry2D* pProjGeom,
+ astraCUDA::SFanProjection*& pProjs,
+ float& outputScale);
+
+_AstraExport bool convertAstraGeometry_dims(const CVolumeGeometry2D* pVolGeom,
+ const CProjectionGeometry2D* pProjGeom,
+ astraCUDA::SDimensions& dims);
+
+_AstraExport bool convertAstraGeometry(const CVolumeGeometry2D* pVolGeom,
+ const CProjectionGeometry2D* pProjGeom,
+ astraCUDA::SParProjection*& pParProjs,
+ astraCUDA::SFanProjection*& pFanProjs,
+ float& outputScale);
+}
+
+namespace astraCUDA {
+
+// Return string with CUDA device number, name and memory size.
+// Use device == -1 to get info for the current device.
+_AstraExport std::string getCudaDeviceString(int device);
+
+_AstraExport bool setGPUIndex(int index);
+
+_AstraExport size_t availableGPUMemory();
+
+}
+#endif
diff --git a/include/astra/cuda/2d/cgls.h b/include/astra/cuda/2d/cgls.h
new file mode 100644
index 0000000..375a425
--- /dev/null
+++ b/include/astra/cuda/2d/cgls.h
@@ -0,0 +1,90 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_CGLS_H
+#define _CUDA_CGLS_H
+
+#include "algo.h"
+
+namespace astraCUDA {
+
+class _AstraExport CGLS : public ReconAlgo {
+public:
+ CGLS();
+ virtual ~CGLS();
+
+ // disable some features
+ virtual bool enableSinogramMask() { return false; }
+ virtual bool setMinConstraint(float) { return false; }
+ virtual bool setMaxConstraint(float) { return false; }
+
+ virtual bool init();
+
+ virtual bool setBuffers(float* D_volumeData, unsigned int volumePitch,
+ float* D_projData, unsigned int projPitch);
+
+ virtual bool copyDataToGPU(const float* pfSinogram, unsigned int iSinogramPitch, float fSinogramScale,
+ const float* pfReconstruction, unsigned int iReconstructionPitch,
+ const float* pfVolMask, unsigned int iVolMaskPitch,
+ const float* pfSinoMask, unsigned int iSinoMaskPitch);
+
+
+ virtual bool iterate(unsigned int iterations);
+
+ virtual float computeDiffNorm();
+
+protected:
+ void reset();
+
+ bool sliceInitialized;
+
+ // Buffers
+ float* D_r;
+ unsigned int rPitch;
+
+ float* D_w;
+ unsigned int wPitch;
+
+ float* D_z;
+ unsigned int zPitch;
+
+ float* D_p;
+ unsigned int pPitch;
+
+
+ float gamma;
+};
+
+
+_AstraExport bool doCGLS(float* D_volumeData, unsigned int volumePitch,
+ float* D_projData, unsigned int projPitch,
+ const SDimensions& dims, const float* angles,
+ const float* TOffsets, unsigned int iterations);
+
+}
+
+#endif
diff --git a/include/astra/cuda/2d/darthelper.h b/include/astra/cuda/2d/darthelper.h
new file mode 100644
index 0000000..3c2f83c
--- /dev/null
+++ b/include/astra/cuda/2d/darthelper.h
@@ -0,0 +1,41 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_ARITH2_H
+#define _CUDA_ARITH2_H
+
+#include "astra/Globals.h"
+
+namespace astraCUDA {
+
+ void roiSelect(float* out, float radius, unsigned int width, unsigned int height);
+ void dartMask(float* out, const float* in, unsigned int conn, unsigned int radius, unsigned int threshold, unsigned int width, unsigned int height);
+ void dartSmoothing(float* out, const float* in, float b, unsigned int radius, unsigned int width, unsigned int height);
+
+}
+
+#endif
diff --git a/include/astra/cuda/2d/dims.h b/include/astra/cuda/2d/dims.h
new file mode 100644
index 0000000..0bdefa9
--- /dev/null
+++ b/include/astra/cuda/2d/dims.h
@@ -0,0 +1,68 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_DIMS_H
+#define _CUDA_DIMS_H
+
+#include "astra/GeometryUtil2D.h"
+
+
+namespace astraCUDA {
+
+using astra::SParProjection;
+using astra::SFanProjection;
+
+
+
+struct SDimensions {
+ // Width, height of reconstruction volume
+ unsigned int iVolWidth;
+ unsigned int iVolHeight;
+
+ // Number of projection angles
+ unsigned int iProjAngles;
+
+ // Number of detector pixels
+ unsigned int iProjDets;
+
+ // in FP, number of rays to trace per detector pixel.
+ // This should usually be set to 1.
+ // If fDetScale > 1, this should be set to an integer of roughly
+ // the same size as fDetScale.
+ unsigned int iRaysPerDet;
+
+ // in BP, square root of number of rays to trace per volume pixel
+ // This should usually be set to 1.
+ // If fDetScale < 1, this should be set to an integer of roughly
+ // the same size as 1 / fDetScale.
+ unsigned int iRaysPerPixelDim;
+};
+
+}
+
+#endif
+
diff --git a/include/astra/cuda/2d/em.h b/include/astra/cuda/2d/em.h
new file mode 100644
index 0000000..3ffe01b
--- /dev/null
+++ b/include/astra/cuda/2d/em.h
@@ -0,0 +1,75 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_EM_H
+#define _CUDA_EM_H
+
+#include "algo.h"
+
+namespace astraCUDA {
+
+class _AstraExport EM : public ReconAlgo {
+public:
+ EM();
+ virtual ~EM();
+
+ // disable some features
+ virtual bool enableSinogramMask() { return false; }
+ virtual bool enableVolumeMask() { return false; }
+ virtual bool setMinConstraint(float) { return false; }
+ virtual bool setMaxConstraint(float) { return false; }
+
+ virtual bool init();
+
+ virtual bool iterate(unsigned int iterations);
+
+ virtual float computeDiffNorm();
+
+protected:
+ void reset();
+ bool precomputeWeights();
+
+ // Temporary buffers
+ float* D_projData;
+ unsigned int projPitch;
+
+ float* D_tmpData;
+ unsigned int tmpPitch;
+
+ // Geometry-specific precomputed data
+ float* D_pixelWeight;
+ unsigned int pixelPitch;
+};
+
+_AstraExport bool doEM(float* D_volumeData, unsigned int volumePitch,
+ float* D_projData, unsigned int projPitch,
+ const SDimensions& dims, const float* angles,
+ const float* TOffsets, unsigned int iterations);
+
+}
+
+#endif
diff --git a/include/astra/cuda/2d/fan_bp.h b/include/astra/cuda/2d/fan_bp.h
new file mode 100644
index 0000000..22349b0
--- /dev/null
+++ b/include/astra/cuda/2d/fan_bp.h
@@ -0,0 +1,52 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_FAN_BP_H
+#define _CUDA_FAN_BP_H
+
+namespace astraCUDA {
+
+_AstraExport bool FanBP(float* D_volumeData, unsigned int volumePitch,
+ float* D_projData, unsigned int projPitch,
+ const SDimensions& dims, const SFanProjection* angles,
+ float fOutputScale);
+
+_AstraExport bool FanBP_SART(float* D_volumeData, unsigned int volumePitch,
+ float* D_projData, unsigned int projPitch,
+ unsigned int angle,
+ const SDimensions& dims, const SFanProjection* angles,
+ float fOutputScale);
+
+_AstraExport bool FanBP_FBPWeighted(float* D_volumeData, unsigned int volumePitch,
+ float* D_projData, unsigned int projPitch,
+ const SDimensions& dims, const SFanProjection* angles,
+ float fOutputScale);
+
+
+}
+
+#endif
diff --git a/include/astra/cuda/2d/fan_fp.h b/include/astra/cuda/2d/fan_fp.h
new file mode 100644
index 0000000..3e8f1e4
--- /dev/null
+++ b/include/astra/cuda/2d/fan_fp.h
@@ -0,0 +1,40 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_FAN_FP_H
+#define _CUDA_FAN_FP_H
+
+namespace astraCUDA {
+
+_AstraExport bool FanFP(float* D_volumeData, unsigned int volumePitch,
+ float* D_projData, unsigned int projPitch,
+ const SDimensions& dims, const SFanProjection* angles,
+ float outputScale);
+
+}
+
+#endif
diff --git a/include/astra/cuda/2d/fbp.h b/include/astra/cuda/2d/fbp.h
new file mode 100644
index 0000000..8666646
--- /dev/null
+++ b/include/astra/cuda/2d/fbp.h
@@ -0,0 +1,97 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#include "algo.h"
+#include "fbp_filters.h"
+
+namespace astraCUDA {
+
+class _AstraExport FBP : public ReconAlgo {
+public:
+ FBP();
+ ~FBP();
+
+ virtual bool useSinogramMask() { return false; }
+ virtual bool useVolumeMask() { return false; }
+
+ // Returns the required size of a filter in the fourier domain
+ // when multiplying it with the fft of the projection data.
+ // Its value is equal to the smallest power of two larger than
+ // or equal to twice the number of detectors in the spatial domain.
+ //
+ // _iDetectorCount is the number of detectors in the spatial domain.
+ static int calcFourierFilterSize(int _iDetectorCount);
+
+ // Sets the filter type. Some filter types require the user to supply an
+ // array containing the filter.
+ // The number of elements in a filter in the fourier domain should be equal
+ // to the value returned by calcFourierFilterSize().
+ // The following types require a filter:
+ //
+ // - FILTER_PROJECTION:
+ // The filter size should be equal to the output of
+ // calcFourierFilterSize(). The filtered sinogram is
+ // multiplied with the supplied filter.
+ //
+ // - FILTER_SINOGRAM:
+ // Same as FILTER_PROJECTION, but now the filter should contain a row for
+ // every projection direction.
+ //
+ // - FILTER_RPROJECTION:
+ // The filter should now contain one kernel (= ifft of filter), with the
+ // peak in the center. The filter width
+ // can be any value. If odd, the peak is assumed to be in the center, if
+ // even, it is assumed to be at floor(filter-width/2).
+ //
+ // - FILTER_RSINOGRAM
+ // Same as FILTER_RPROJECTION, but now the supplied filter should contain a
+ // row for every projection direction.
+ //
+ // A large number of other filters (FILTER_RAMLAK, FILTER_SHEPPLOGAN,
+ // FILTER_COSINE, FILTER_HAMMING, and FILTER_HANN)
+ // have a D variable, which gives the cutoff point in the frequency domain.
+ // Setting this value to 1.0 will include the whole filter
+ bool setFilter(astra::E_FBPFILTER _eFilter,
+ const float * _pfHostFilter = NULL,
+ int _iFilterWidth = 0, float _fD = 1.0f, float _fFilterParameter = -1.0f);
+
+ bool setShortScan(bool ss) { m_bShortScan = ss; return true; }
+
+ virtual bool init();
+
+ virtual bool iterate(unsigned int iterations);
+
+ virtual float computeDiffNorm() { return 0.0f; } // TODO
+
+protected:
+ void reset();
+
+ void* D_filter; // cufftComplex*
+ bool m_bShortScan;
+};
+
+}
diff --git a/include/astra/cuda/2d/fbp_filters.h b/include/astra/cuda/2d/fbp_filters.h
new file mode 100644
index 0000000..7c1121a
--- /dev/null
+++ b/include/astra/cuda/2d/fbp_filters.h
@@ -0,0 +1,61 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef FBP_FILTERS_H
+#define FBP_FILTERS_H
+
+namespace astra {
+
+enum E_FBPFILTER
+{
+ FILTER_NONE, //< no filter (regular BP)
+ FILTER_RAMLAK, //< default FBP filter
+ FILTER_SHEPPLOGAN, //< Shepp-Logan
+ FILTER_COSINE, //< Cosine
+ FILTER_HAMMING, //< Hamming filter
+ FILTER_HANN, //< Hann filter
+ FILTER_TUKEY, //< Tukey filter
+ FILTER_LANCZOS, //< Lanczos filter
+ FILTER_TRIANGULAR, //< Triangular filter
+ FILTER_GAUSSIAN, //< Gaussian filter
+ FILTER_BARTLETTHANN, //< Bartlett-Hann filter
+ FILTER_BLACKMAN, //< Blackman filter
+ FILTER_NUTTALL, //< Nuttall filter, continuous first derivative
+ FILTER_BLACKMANHARRIS, //< Blackman-Harris filter
+ FILTER_BLACKMANNUTTALL, //< Blackman-Nuttall filter
+ FILTER_FLATTOP, //< Flat top filter
+ FILTER_KAISER, //< Kaiser filter
+ FILTER_PARZEN, //< Parzen filter
+ FILTER_PROJECTION, //< all projection directions share one filter
+ FILTER_SINOGRAM, //< every projection direction has its own filter
+ FILTER_RPROJECTION, //< projection filter in real space (as opposed to fourier space)
+ FILTER_RSINOGRAM, //< sinogram filter in real space
+};
+
+}
+
+#endif /* FBP_FILTERS_H */
diff --git a/include/astra/cuda/2d/fft.h b/include/astra/cuda/2d/fft.h
new file mode 100644
index 0000000..d36cae2
--- /dev/null
+++ b/include/astra/cuda/2d/fft.h
@@ -0,0 +1,72 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef FFT_H
+#define FFT_H
+
+#include <cufft.h>
+#include <cuda.h>
+
+#include "fbp_filters.h"
+
+namespace astraCUDA {
+
+bool allocateComplexOnDevice(int _iProjectionCount,
+ int _iDetectorCount,
+ cufftComplex ** _ppDevComplex);
+
+bool freeComplexOnDevice(cufftComplex * _pDevComplex);
+
+bool uploadComplexArrayToDevice(int _iProjectionCount, int _iDetectorCount,
+ cufftComplex * _pHostComplexSource,
+ cufftComplex * _pDevComplexTarget);
+
+bool runCudaFFT(int _iProjectionCount, const float * _pfDevRealSource,
+ int _iSourcePitch, int _iProjDets,
+ int _iFFTRealDetectorCount, int _iFFTFourierDetectorCount,
+ cufftComplex * _pDevTargetComplex);
+
+bool runCudaIFFT(int _iProjectionCount, const cufftComplex* _pDevSourceComplex,
+ float * _pfRealTarget,
+ int _iTargetPitch, int _iProjDets,
+ int _iFFTRealDetectorCount, int _iFFTFourierDetectorCount);
+
+void applyFilter(int _iProjectionCount, int _iFreqBinCount,
+ cufftComplex * _pSinogram, cufftComplex * _pFilter);
+
+int calcFFTFourierSize(int _iFFTRealSize);
+
+void genFilter(astra::E_FBPFILTER _eFilter, float _fD, int _iProjectionCount,
+ cufftComplex * _pFilter, int _iFFTRealDetectorCount,
+ int _iFFTFourierDetectorCount, float _fParameter = -1.0f);
+
+void genIdenFilter(int _iProjectionCount, cufftComplex * _pFilter,
+ int _iFFTRealDetectorCount, int _iFFTFourierDetectorCount);
+
+}
+
+#endif /* FFT_H */
diff --git a/include/astra/cuda/2d/par_bp.h b/include/astra/cuda/2d/par_bp.h
new file mode 100644
index 0000000..c8dfab8
--- /dev/null
+++ b/include/astra/cuda/2d/par_bp.h
@@ -0,0 +1,47 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_PAR_BP_H
+#define _CUDA_PAR_BP_H
+
+#include "dims.h"
+
+namespace astraCUDA {
+
+_AstraExport bool BP(float* D_volumeData, unsigned int volumePitch,
+ float* D_projData, unsigned int projPitch,
+ const SDimensions& dims, const SParProjection* angles,
+ float fOutputScale);
+
+_AstraExport bool BP_SART(float* D_volumeData, unsigned int volumePitch,
+ float* D_projData, unsigned int projPitch,
+ unsigned int angle, const SDimensions& dims,
+ const SParProjection* angles, float fOutputScale);
+
+}
+
+#endif
diff --git a/include/astra/cuda/2d/par_fp.h b/include/astra/cuda/2d/par_fp.h
new file mode 100644
index 0000000..62277a1
--- /dev/null
+++ b/include/astra/cuda/2d/par_fp.h
@@ -0,0 +1,40 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_PAR_FP_H
+#define _CUDA_PAR_FP_H
+
+namespace astraCUDA {
+
+_AstraExport bool FP(float* D_volumeData, unsigned int volumePitch,
+ float* D_projData, unsigned int projPitch,
+ const SDimensions& dims, const SParProjection* angles,
+ float fOutputScale);
+
+}
+
+#endif
diff --git a/include/astra/cuda/2d/sart.h b/include/astra/cuda/2d/sart.h
new file mode 100644
index 0000000..6c0e547
--- /dev/null
+++ b/include/astra/cuda/2d/sart.h
@@ -0,0 +1,87 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_SART_H
+#define _CUDA_SART_H
+
+#include "algo.h"
+
+namespace astraCUDA {
+
+class _AstraExport SART : public ReconAlgo {
+public:
+ SART();
+ ~SART();
+
+ // disable some features
+ virtual bool enableSinogramMask() { return false; }
+
+ virtual bool init();
+
+ virtual bool setProjectionOrder(int* projectionOrder, int projectionCount);
+
+ virtual bool iterate(unsigned int iterations);
+
+ virtual float computeDiffNorm();
+
+ void setRelaxation(float r) { fRelaxation = r; }
+
+protected:
+ void reset();
+ bool precomputeWeights();
+
+ bool callFP_SART(float* D_volumeData, unsigned int volumePitch,
+ float* D_projData, unsigned int projPitch,
+ unsigned int angle, float outputScale);
+ bool callBP_SART(float* D_volumeData, unsigned int volumePitch,
+ float* D_projData, unsigned int projPitch,
+ unsigned int angle, float outputScale);
+
+
+ // projection angle variables
+ bool customOrder;
+ int* projectionOrder;
+ int projectionCount;
+ int iteration;
+
+ // Temporary buffers
+ float* D_projData;
+ unsigned int projPitch;
+
+ float* D_tmpData; // Only used when there's a volume mask
+ unsigned int tmpPitch;
+
+ // Geometry-specific precomputed data
+ float* D_lineWeight;
+ unsigned int linePitch;
+
+ float fRelaxation;
+};
+
+}
+
+#endif
diff --git a/include/astra/cuda/2d/sirt.h b/include/astra/cuda/2d/sirt.h
new file mode 100644
index 0000000..434a07c
--- /dev/null
+++ b/include/astra/cuda/2d/sirt.h
@@ -0,0 +1,96 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_SIRT_H
+#define _CUDA_SIRT_H
+
+#include "algo.h"
+
+namespace astraCUDA {
+
+class _AstraExport SIRT : public ReconAlgo {
+public:
+ SIRT();
+ ~SIRT();
+
+ virtual bool init();
+
+ // Do optional long-object compensation. See the comments in sirt.cu.
+ // Call this after init(). It can not be used in combination with masks.
+ bool doSlabCorrections();
+
+ // Set min/max masks to existing GPU memory buffers
+ bool setMinMaxMasks(float* D_minMaskData, float* D_maxMaskData,
+ unsigned int pitch);
+
+ // Set min/max masks from RAM buffers
+ bool uploadMinMaxMasks(const float* minMaskData, const float* maxMaskData,
+ unsigned int pitch);
+
+ void setRelaxation(float r) { fRelaxation = r; }
+
+ virtual bool iterate(unsigned int iterations);
+
+ virtual float computeDiffNorm();
+
+protected:
+ void reset();
+ bool precomputeWeights();
+
+ // Temporary buffers
+ float* D_projData;
+ unsigned int projPitch;
+
+ float* D_tmpData;
+ unsigned int tmpPitch;
+
+ // Geometry-specific precomputed data
+ float* D_lineWeight;
+ unsigned int linePitch;
+
+ float* D_pixelWeight;
+ unsigned int pixelPitch;
+
+ // Masks
+ bool freeMinMaxMasks;
+ float* D_minMaskData;
+ unsigned int minMaskPitch;
+ float* D_maxMaskData;
+ unsigned int maxMaskPitch;
+
+ float fRelaxation;
+};
+
+bool doSIRT(float* D_volumeData, unsigned int volumePitch,
+ float* D_projData, unsigned int projPitch,
+ float* D_maskData, unsigned int maskPitch,
+ const SDimensions& dims, const float* angles,
+ const float* TOffsets, unsigned int iterations);
+
+}
+
+#endif
diff --git a/include/astra/cuda/2d/util.h b/include/astra/cuda/2d/util.h
new file mode 100644
index 0000000..70e7c86
--- /dev/null
+++ b/include/astra/cuda/2d/util.h
@@ -0,0 +1,84 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_UTIL_H
+#define _CUDA_UTIL_H
+
+#include <cuda.h>
+#include <driver_types.h>
+#include <string>
+
+#include "astra/Globals.h"
+
+#include "dims.h"
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+#define ASTRA_CUDA_ASSERT(err) do { if (err != cudaSuccess) { astraCUDA::reportCudaError(err); assert(err == cudaSuccess); } } while(0)
+
+
+namespace astraCUDA {
+
+bool copyVolumeToDevice(const float* in_data, unsigned int in_pitch,
+ const SDimensions& dims,
+ float* outD_data, unsigned int out_pitch);
+bool copyVolumeFromDevice(float* out_data, unsigned int out_pitch,
+ const SDimensions& dims,
+ float* inD_data, unsigned int in_pitch);
+bool copySinogramFromDevice(float* out_data, unsigned int out_pitch,
+ const SDimensions& dims,
+ float* inD_data, unsigned int in_pitch);
+bool copySinogramToDevice(const float* in_data, unsigned int in_pitch,
+ const SDimensions& dims,
+ float* outD_data, unsigned int out_pitch);
+
+bool allocateVolume(float*& D_ptr, unsigned int width, unsigned int height, unsigned int& pitch);
+void zeroVolume(float* D_data, unsigned int pitch, unsigned int width, unsigned int height);
+
+bool allocateVolumeData(float*& D_ptr, unsigned int& pitch, const SDimensions& dims);
+bool allocateProjectionData(float*& D_ptr, unsigned int& pitch, const SDimensions& dims);
+void zeroVolumeData(float* D_ptr, unsigned int pitch, const SDimensions& dims);
+void zeroProjectionData(float* D_ptr, unsigned int pitch, const SDimensions& dims);
+
+void duplicateVolumeData(float* D_dst, float* D_src, unsigned int pitch, const SDimensions& dims);
+void duplicateProjectionData(float* D_dst, float* D_src, unsigned int pitch, const SDimensions& dims);
+
+
+
+bool cudaTextForceKernelsCompletion();
+void reportCudaError(cudaError_t err);
+
+
+
+float dotProduct2D(float* D_data, unsigned int pitch,
+ unsigned int width, unsigned int height);
+
+}
+
+#endif
diff --git a/include/astra/cuda/3d/algo3d.h b/include/astra/cuda/3d/algo3d.h
new file mode 100644
index 0000000..f5fd207
--- /dev/null
+++ b/include/astra/cuda/3d/algo3d.h
@@ -0,0 +1,71 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_ALGO_H
+#define _CUDA_ALGO_H
+
+#include "dims3d.h"
+#include "util3d.h"
+
+namespace astraCUDA3d {
+
+class _AstraExport ReconAlgo3D {
+public:
+ ReconAlgo3D();
+ ~ReconAlgo3D();
+
+ bool setConeGeometry(const SDimensions3D& dims, const SConeProjection* projs, const SProjectorParams3D& params);
+ bool setPar3DGeometry(const SDimensions3D& dims, const SPar3DProjection* projs, const SProjectorParams3D& params);
+
+ void signalAbort() { shouldAbort = true; }
+
+protected:
+ void reset();
+
+ bool callFP(cudaPitchedPtr& D_volumeData,
+ cudaPitchedPtr& D_projData,
+ float outputScale);
+ bool callBP(cudaPitchedPtr& D_volumeData,
+ cudaPitchedPtr& D_projData,
+ float outputScale);
+
+ SDimensions3D dims;
+ SProjectorParams3D params;
+ SConeProjection* coneProjs;
+ SPar3DProjection* par3DProjs;
+
+ float fOutputScale;
+
+ volatile bool shouldAbort;
+
+};
+
+
+}
+
+#endif
+
diff --git a/include/astra/cuda/3d/arith3d.h b/include/astra/cuda/3d/arith3d.h
new file mode 100644
index 0000000..fa9f3a1
--- /dev/null
+++ b/include/astra/cuda/3d/arith3d.h
@@ -0,0 +1,79 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_ARITH3D_H
+#define _CUDA_ARITH3D_H
+
+#include <cuda.h>
+
+namespace astraCUDA3d {
+
+struct opAddScaled;
+struct opScaleAndAdd;
+struct opAddMulScaled;
+struct opAddMul;
+struct opAdd;
+struct opMul;
+struct opMul2;
+struct opDividedBy;
+struct opInvert;
+struct opSet;
+struct opClampMin;
+struct opClampMax;
+
+enum VolType {
+ SINO = 0,
+ VOL = 1
+};
+
+
+template<typename op, VolType t> void processVol(CUdeviceptr* out, unsigned int pitch, unsigned int width, unsigned int height);
+template<typename op, VolType t> void processVol(CUdeviceptr* out, float fParam, unsigned int pitch, unsigned int width, unsigned int height);
+template<typename op, VolType t> void processVol(CUdeviceptr* out, const CUdeviceptr* in, unsigned int pitch, unsigned int width, unsigned int height);
+template<typename op, VolType t> void processVol(CUdeviceptr* out, const CUdeviceptr* in, float fParam, unsigned int pitch, unsigned int width, unsigned int height);
+template<typename op, VolType t> void processVol(CUdeviceptr* out, const CUdeviceptr* in1, const CUdeviceptr* in2, float fParam, unsigned int pitch, unsigned int width, unsigned int height);
+template<typename op, VolType t> void processVol(CUdeviceptr* out, const CUdeviceptr* in1, const CUdeviceptr* in2, unsigned int pitch, unsigned int width, unsigned int height);
+
+template<typename op> void processVol3D(cudaPitchedPtr& out, const SDimensions3D& dims);
+template<typename op> void processVol3D(cudaPitchedPtr& out, float fParam, const SDimensions3D& dims);
+template<typename op> void processVol3D(cudaPitchedPtr& out, const cudaPitchedPtr& in, const SDimensions3D& dims);
+template<typename op> void processVol3D(cudaPitchedPtr& out, const cudaPitchedPtr& in, float fParam, const SDimensions3D& dims);
+template<typename op> void processVol3D(cudaPitchedPtr& out, const cudaPitchedPtr& in1, const cudaPitchedPtr& in2, float fParam, const SDimensions3D& dims);
+template<typename op> void processVol3D(cudaPitchedPtr& out, const cudaPitchedPtr& in1, const cudaPitchedPtr& in2, const SDimensions3D& dims);
+
+template<typename op> void processSino3D(cudaPitchedPtr& out, const SDimensions3D& dims);
+template<typename op> void processSino3D(cudaPitchedPtr& out, float fParam, const SDimensions3D& dims);
+template<typename op> void processSino3D(cudaPitchedPtr& out, const cudaPitchedPtr& in, const SDimensions3D& dims);
+template<typename op> void processSino3D(cudaPitchedPtr& out, const cudaPitchedPtr& in, float fParam, const SDimensions3D& dims);
+template<typename op> void processSino3D(cudaPitchedPtr& out, const cudaPitchedPtr& in1, const cudaPitchedPtr& in2, float fParam, const SDimensions3D& dims);
+template<typename op> void processSino3D(cudaPitchedPtr& out, const cudaPitchedPtr& in1, const cudaPitchedPtr& in2, const SDimensions3D& dims);
+
+
+
+}
+
+#endif
diff --git a/include/astra/cuda/3d/astra3d.h b/include/astra/cuda/3d/astra3d.h
new file mode 100644
index 0000000..0ea752d
--- /dev/null
+++ b/include/astra/cuda/3d/astra3d.h
@@ -0,0 +1,314 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_ASTRA3D_H
+#define _CUDA_ASTRA3D_H
+
+#include "dims3d.h"
+
+namespace astra {
+
+
+// TODO: Switch to a class hierarchy as with the 2D algorithms
+
+
+class CProjectionGeometry3D;
+class CParallelProjectionGeometry3D;
+class CParallelVecProjectionGeometry3D;
+class CConeProjectionGeometry3D;
+class CConeVecProjectionGeometry3D;
+class CVolumeGeometry3D;
+class AstraSIRT3d_internal;
+
+using astraCUDA3d::Cuda3DProjectionKernel;
+using astraCUDA3d::ker3d_default;
+using astraCUDA3d::ker3d_sum_square_weights;
+
+
+class _AstraExport AstraSIRT3d {
+public:
+
+ AstraSIRT3d();
+ ~AstraSIRT3d();
+
+ // Set the volume and projection geometry
+ bool setGeometry(const CVolumeGeometry3D* pVolGeom,
+ const CProjectionGeometry3D* pProjGeom);
+
+ // Enable supersampling.
+ //
+ // The number of rays used in FP is the square of iDetectorSuperSampling.
+ // The number of rays used in BP is the cube of iVoxelSuperSampling.
+ bool enableSuperSampling(unsigned int iVoxelSuperSampling,
+ unsigned int iDetectorSuperSampling);
+
+ void setRelaxation(float r);
+
+ // Enable volume/sinogram masks
+ //
+ // This may optionally be called before init().
+ // If it is called, setVolumeMask()/setSinogramMask() must be called between
+ // setSinogram() and iterate().
+ bool enableVolumeMask();
+ bool enableSinogramMask();
+
+ // Set GPU index
+ //
+ // This should be called before init(). Note that setting the GPU index
+ // in a thread which has already used the GPU may not work.
+ bool setGPUIndex(int index);
+
+ // Allocate GPU buffers and
+ // precompute geometry-specific data.
+ //
+ // This must be called after calling setReconstructionGeometry() and
+ // setProjectionGeometry() or setFanProjectionGeometry().
+ bool init();
+
+ // Setup input sinogram for a slice.
+ // pfSinogram must be a float array of size XXX
+ // NB: iSinogramPitch is measured in floats, not in bytes.
+ //
+ // This must be called after init(), and before iterate(). It may be
+ // called again after iterate()/getReconstruction() to start a new slice.
+ //
+ // pfSinogram will only be read from during this call.
+ bool setSinogram(const float* pfSinogram, unsigned int iSinogramPitch);
+
+ // Setup volume mask for a slice.
+ // pfMask must be a float array of size XXX
+ // NB: iMaskPitch is measured in floats, not in bytes.
+ //
+ // It may only contain the exact values 0.0f and 1.0f. Only volume pixels
+ // for which pfMask[z] is 1.0f are processed.
+ bool setVolumeMask(const float* pfMask, unsigned int iMaskPitch);
+
+ // Setup sinogram mask for a slice.
+ // pfMask must be a float array of size XXX
+ // NB: iMaskPitch is measured in floats, not in bytes.
+ //
+ // It may only contain the exact values 0.0f and 1.0f. Only sinogram pixels
+ // for which pfMask[z] is 1.0f are processed.
+ bool setSinogramMask(const float* pfMask, unsigned int iMaskPitch);
+
+ // Set the starting reconstruction for SIRT.
+ // pfReconstruction must be a float array of size XXX
+ // NB: iReconstructionPitch is measured in floats, not in bytes.
+ //
+ // This may be called between setSinogram() and iterate().
+ // If this function is not called before iterate(), SIRT will start
+ // from a zero reconstruction.
+ //
+ // pfReconstruction will only be read from during this call.
+ bool setStartReconstruction(const float* pfReconstruction,
+ unsigned int iReconstructionPitch);
+
+ // Enable min/max constraint.
+ //
+ // These may optionally be called between init() and iterate()
+ bool setMinConstraint(float fMin);
+ bool setMaxConstraint(float fMax);
+
+ // Perform a number of (additive) SIRT iterations.
+ // This must be called after setSinogram().
+ //
+ // If called multiple times, without calls to setSinogram() or
+ // setStartReconstruction() in between, iterate() will continue from
+ // the result of the previous call.
+ // Calls to getReconstruction() are allowed between calls to iterate() and
+ // do not change the state.
+ bool iterate(unsigned int iIterations);
+
+ // Get the reconstructed slice.
+ // pfReconstruction must be a float array of size XXX
+ // NB: iReconstructionPitch is measured in floats, not in bytes.
+ //
+ // This may be called after iterate().
+ bool getReconstruction(float* pfReconstruction,
+ unsigned int iReconstructionPitch) const;
+
+ // Compute the norm of the difference of the FP of the current
+ // reconstruction and the sinogram. (This performs one FP.)
+ // It can be called after iterate().
+ float computeDiffNorm();
+
+ // Signal the algorithm that it should abort after the current iteration.
+ // This is intended to be called from another thread.
+ void signalAbort();
+
+protected:
+ AstraSIRT3d_internal *pData;
+};
+
+
+class AstraCGLS3d_internal;
+
+
+class _AstraExport AstraCGLS3d {
+public:
+
+ AstraCGLS3d();
+ ~AstraCGLS3d();
+
+ // Set the volume and projection geometry
+ bool setGeometry(const CVolumeGeometry3D* pVolGeom,
+ const CProjectionGeometry3D* pProjGeom);
+
+ // Enable supersampling.
+ //
+ // The number of rays used in FP is the square of iDetectorSuperSampling.
+ // The number of rays used in BP is the cube of iVoxelSuperSampling.
+ bool enableSuperSampling(unsigned int iVoxelSuperSampling,
+ unsigned int iDetectorSuperSampling);
+
+ // Enable volume/sinogram masks
+ //
+ // This may optionally be called before init().
+ // If it is called, setVolumeMask()/setSinogramMask() must be called between
+ // setSinogram() and iterate().
+ bool enableVolumeMask();
+ //bool enableSinogramMask();
+
+ // Set GPU index
+ //
+ // This should be called before init(). Note that setting the GPU index
+ // in a thread which has already used the GPU may not work.
+ bool setGPUIndex(int index);
+
+ // Allocate GPU buffers and
+ // precompute geometry-specific data.
+ //
+ // This must be called after calling setReconstructionGeometry() and
+ // setProjectionGeometry() or setFanProjectionGeometry().
+ bool init();
+
+ // Setup input sinogram for a slice.
+ // pfSinogram must be a float array of size XXX
+ // NB: iSinogramPitch is measured in floats, not in bytes.
+ //
+ // This must be called after init(), and before iterate(). It may be
+ // called again after iterate()/getReconstruction() to start a new slice.
+ //
+ // pfSinogram will only be read from during this call.
+ bool setSinogram(const float* pfSinogram, unsigned int iSinogramPitch);
+
+ // Setup volume mask for a slice.
+ // pfMask must be a float array of size XXX
+ // NB: iMaskPitch is measured in floats, not in bytes.
+ //
+ // It may only contain the exact values 0.0f and 1.0f. Only volume pixels
+ // for which pfMask[z] is 1.0f are processed.
+ bool setVolumeMask(const float* pfMask, unsigned int iMaskPitch);
+
+ // Setup sinogram mask for a slice.
+ // pfMask must be a float array of size XXX
+ // NB: iMaskPitch is measured in floats, not in bytes.
+ //
+ // It may only contain the exact values 0.0f and 1.0f. Only sinogram pixels
+ // for which pfMask[z] is 1.0f are processed.
+ //bool setSinogramMask(const float* pfMask, unsigned int iMaskPitch);
+
+ // Set the starting reconstruction for SIRT.
+ // pfReconstruction must be a float array of size XXX
+ // NB: iReconstructionPitch is measured in floats, not in bytes.
+ //
+ // This may be called between setSinogram() and iterate().
+ // If this function is not called before iterate(), SIRT will start
+ // from a zero reconstruction.
+ //
+ // pfReconstruction will only be read from during this call.
+ bool setStartReconstruction(const float* pfReconstruction,
+ unsigned int iReconstructionPitch);
+
+ // Enable min/max constraint.
+ //
+ // These may optionally be called between init() and iterate()
+ //bool setMinConstraint(float fMin);
+ //bool setMaxConstraint(float fMax);
+
+ // Perform a number of (additive) SIRT iterations.
+ // This must be called after setSinogram().
+ //
+ // If called multiple times, without calls to setSinogram() or
+ // setStartReconstruction() in between, iterate() will continue from
+ // the result of the previous call.
+ // Calls to getReconstruction() are allowed between calls to iterate() and
+ // do not change the state.
+ bool iterate(unsigned int iIterations);
+
+ // Get the reconstructed slice.
+ // pfReconstruction must be a float array of size XXX
+ // NB: iReconstructionPitch is measured in floats, not in bytes.
+ //
+ // This may be called after iterate().
+ bool getReconstruction(float* pfReconstruction,
+ unsigned int iReconstructionPitch) const;
+
+ // Compute the norm of the difference of the FP of the current
+ // reconstruction and the sinogram. (This performs one FP.)
+ // It can be called after iterate().
+ float computeDiffNorm();
+
+ // Signal the algorithm that it should abort after the current iteration.
+ // This is intended to be called from another thread.
+ void signalAbort();
+
+protected:
+ AstraCGLS3d_internal *pData;
+};
+
+bool convertAstraGeometry_dims(const CVolumeGeometry3D* pVolGeom,
+ const CProjectionGeometry3D* pProjGeom,
+ astraCUDA3d::SDimensions3D& dims);
+
+bool convertAstraGeometry(const CVolumeGeometry3D* pVolGeom,
+ const CProjectionGeometry3D* pProjGeom,
+ SPar3DProjection*& pParProjs,
+ SConeProjection*& pConeProjs,
+ astraCUDA3d::SProjectorParams3D& params);
+
+_AstraExport bool astraCudaFP(const float* pfVolume, float* pfProjections,
+ const CVolumeGeometry3D* pVolGeom,
+ const CProjectionGeometry3D* pProjGeom,
+ int iGPUIndex, int iDetectorSuperSampling,
+ Cuda3DProjectionKernel projKernel);
+
+
+_AstraExport bool astraCudaBP(float* pfVolume, const float* pfProjections,
+ const CVolumeGeometry3D* pVolGeom,
+ const CProjectionGeometry3D* pProjGeom,
+ int iGPUIndex, int iVoxelSuperSampling);
+
+_AstraExport bool astraCudaBP_SIRTWeighted(float* pfVolume, const float* pfProjections,
+ const CVolumeGeometry3D* pVolGeom,
+ const CProjectionGeometry3D* pProjGeom,
+ int iGPUIndex, int iVoxelSuperSampling);
+
+}
+
+
+#endif
diff --git a/include/astra/cuda/3d/cgls3d.h b/include/astra/cuda/3d/cgls3d.h
new file mode 100644
index 0000000..b9b9e3a
--- /dev/null
+++ b/include/astra/cuda/3d/cgls3d.h
@@ -0,0 +1,112 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_CGLS3D_H
+#define _CUDA_CGLS3D_H
+
+#include "algo3d.h"
+
+namespace astraCUDA3d {
+
+class _AstraExport CGLS : public ReconAlgo3D {
+public:
+ CGLS();
+ ~CGLS();
+
+// bool setConeGeometry(const SDimensions3D& dims, const SConeProjection* projs);
+
+
+ bool enableVolumeMask();
+ bool enableSinogramMask();
+
+ // init should be called after setting all geometry
+ bool init();
+
+ // setVolumeMask should be called after init and before iterate,
+ // but only if enableVolumeMask was called before init.
+ // It may be called again after iterate.
+ bool setVolumeMask(cudaPitchedPtr& D_maskData);
+
+ // setSinogramMask should be called after init and before iterate,
+ // but only if enableSinogramMask was called before init.
+ // It may be called again after iterate.
+ bool setSinogramMask(cudaPitchedPtr& D_smaskData);
+
+
+ // setBuffers should be called after init and before iterate.
+ // It may be called again after iterate.
+ bool setBuffers(cudaPitchedPtr& D_volumeData,
+ cudaPitchedPtr& D_projData);
+
+
+ // set Min/Max constraints. They may be called at any time, and will affect
+ // any iterate() calls afterwards.
+ bool setMinConstraint(float fMin) { return false; }
+ bool setMaxConstraint(float fMax) { return false; }
+
+ // iterate should be called after init and setBuffers.
+ // It may be called multiple times.
+ bool iterate(unsigned int iterations);
+
+ // Compute the norm of the difference of the FP of the current reconstruction
+ // and the sinogram. (This performs one FP.)
+ // It can be called after iterate.
+ float computeDiffNorm();
+
+protected:
+ void reset();
+
+ bool useVolumeMask;
+ bool useSinogramMask;
+
+ cudaPitchedPtr D_maskData;
+ cudaPitchedPtr D_smaskData;
+
+ // Input/output
+ cudaPitchedPtr D_sinoData;
+ cudaPitchedPtr D_volumeData;
+
+ // Temporary buffers
+ cudaPitchedPtr D_r;
+ cudaPitchedPtr D_w;
+ cudaPitchedPtr D_z;
+ cudaPitchedPtr D_p;
+
+ float gamma;
+
+ bool sliceInitialized;
+};
+
+_AstraExport bool doCGLS(cudaPitchedPtr D_volumeData, unsigned int volumePitch,
+ cudaPitchedPtr D_projData, unsigned int projPitch,
+ cudaPitchedPtr D_maskData, unsigned int maskPitch,
+ const SDimensions3D& dims, const SConeProjection* projs,
+ unsigned int iterations);
+
+}
+
+#endif
diff --git a/include/astra/cuda/3d/cone_bp.h b/include/astra/cuda/3d/cone_bp.h
new file mode 100644
index 0000000..6dcadb1
--- /dev/null
+++ b/include/astra/cuda/3d/cone_bp.h
@@ -0,0 +1,45 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_CONE_BP_H
+#define _CUDA_CONE_BP_H
+
+namespace astraCUDA3d {
+
+_AstraExport bool ConeBP_Array(cudaPitchedPtr D_volumeData,
+ cudaArray *D_projArray,
+ const SDimensions3D& dims, const SConeProjection* angles,
+ const SProjectorParams3D& params);
+
+_AstraExport bool ConeBP(cudaPitchedPtr D_volumeData,
+ cudaPitchedPtr D_projData,
+ const SDimensions3D& dims, const SConeProjection* angles,
+ const SProjectorParams3D& params);
+
+}
+
+#endif
diff --git a/include/astra/cuda/3d/cone_fp.h b/include/astra/cuda/3d/cone_fp.h
new file mode 100644
index 0000000..4da72d4
--- /dev/null
+++ b/include/astra/cuda/3d/cone_fp.h
@@ -0,0 +1,45 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_CONE_FP_H
+#define _CUDA_CONE_FP_H
+
+namespace astraCUDA3d {
+
+_AstraExport bool ConeFP_Array(cudaArray *D_volArray,
+ cudaPitchedPtr D_projData,
+ const SDimensions3D& dims, const SConeProjection* angles,
+ const SProjectorParams3D& params);
+
+_AstraExport bool ConeFP(cudaPitchedPtr D_volumeData,
+ cudaPitchedPtr D_projData,
+ const SDimensions3D& dims, const SConeProjection* angles,
+ const SProjectorParams3D& params);
+
+}
+
+#endif
diff --git a/include/astra/cuda/3d/darthelper3d.h b/include/astra/cuda/3d/darthelper3d.h
new file mode 100644
index 0000000..385e48e
--- /dev/null
+++ b/include/astra/cuda/3d/darthelper3d.h
@@ -0,0 +1,42 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_DARTHELPER3_H
+#define _CUDA_DARTHELPER3_H
+
+#include "dims3d.h"
+
+namespace astraCUDA3d {
+
+ void dartSmoothing(float* out, const float* in, float b, unsigned int radius, SDimensions3D dims);
+ void dartMasking(float* out, const float* in, unsigned int conn, unsigned int radius, unsigned int threshold, SDimensions3D dims);
+
+ bool setGPUIndex(int index);
+
+}
+
+#endif
diff --git a/include/astra/cuda/3d/dims3d.h b/include/astra/cuda/3d/dims3d.h
new file mode 100644
index 0000000..ef4ea78
--- /dev/null
+++ b/include/astra/cuda/3d/dims3d.h
@@ -0,0 +1,77 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_CONE_DIMS_H
+#define _CUDA_CONE_DIMS_H
+
+#include "astra/GeometryUtil3D.h"
+
+
+namespace astraCUDA3d {
+
+using astra::SConeProjection;
+using astra::SPar3DProjection;
+
+
+enum Cuda3DProjectionKernel {
+ ker3d_default = 0,
+ ker3d_sum_square_weights
+};
+
+
+struct SDimensions3D {
+ unsigned int iVolX;
+ unsigned int iVolY;
+ unsigned int iVolZ;
+ unsigned int iProjAngles;
+ unsigned int iProjU; // number of detectors in the U direction
+ unsigned int iProjV; // number of detectors in the V direction
+};
+
+struct SProjectorParams3D {
+ SProjectorParams3D() :
+ iRaysPerDetDim(1), iRaysPerVoxelDim(1),
+ fOutputScale(1.0f),
+ fVolScaleX(1.0f), fVolScaleY(1.0f), fVolScaleZ(1.0f),
+ ker(ker3d_default),
+ bFDKWeighting(false)
+ { }
+
+ unsigned int iRaysPerDetDim;
+ unsigned int iRaysPerVoxelDim;
+ float fOutputScale;
+ float fVolScaleX;
+ float fVolScaleY;
+ float fVolScaleZ;
+ Cuda3DProjectionKernel ker;
+ bool bFDKWeighting;
+};
+
+}
+
+#endif
+
diff --git a/include/astra/cuda/3d/fdk.h b/include/astra/cuda/3d/fdk.h
new file mode 100644
index 0000000..6f6e73b
--- /dev/null
+++ b/include/astra/cuda/3d/fdk.h
@@ -0,0 +1,50 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_FDK_H
+#define _CUDA_FDK_H
+
+#include "dims3d.h"
+
+namespace astraCUDA3d {
+
+bool FDK_PreWeight(cudaPitchedPtr D_projData,
+ float fSrcOrigin, float fDetOrigin,
+ float fZShift,
+ float fDetUSize, float fDetVSize, float fVoxSize,
+ bool bShortScan,
+ const SDimensions3D& dims, const float* angles);
+
+bool FDK(cudaPitchedPtr D_volumeData,
+ cudaPitchedPtr D_projData,
+ const SConeProjection* angles,
+ const SDimensions3D& dims, SProjectorParams3D params, bool bShortScan,
+ const float* filter);
+
+}
+
+#endif
diff --git a/include/astra/cuda/3d/mem3d.h b/include/astra/cuda/3d/mem3d.h
new file mode 100644
index 0000000..78e1294
--- /dev/null
+++ b/include/astra/cuda/3d/mem3d.h
@@ -0,0 +1,105 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_MEM3D_H
+#define _CUDA_MEM3D_H
+
+#include <boost/shared_ptr.hpp>
+
+#include "astra3d.h"
+
+namespace astra {
+class CVolumeGeometry3D;
+class CProjectionGeometry3D;
+}
+
+namespace astraCUDA3d {
+
+// TODO: Make it possible to delete these handles when they're no longer
+// necessary inside the FP/BP
+//
+// TODO: Add functions for querying capacity
+
+struct SMemHandle3D_internal;
+
+struct MemHandle3D {
+ boost::shared_ptr<SMemHandle3D_internal> d;
+ operator bool() const { return (bool)d; }
+};
+
+struct SSubDimensions3D {
+ unsigned int nx;
+ unsigned int ny;
+ unsigned int nz;
+ unsigned int pitch;
+ unsigned int subnx;
+ unsigned int subny;
+ unsigned int subnz;
+ unsigned int subx;
+ unsigned int suby;
+ unsigned int subz;
+};
+
+/*
+// Useful or not?
+enum Mem3DCopyMode {
+ MODE_SET,
+ MODE_ADD
+};
+*/
+
+enum Mem3DZeroMode {
+ INIT_NO,
+ INIT_ZERO
+};
+
+int maxBlockDimension();
+
+_AstraExport MemHandle3D wrapHandle(float *D_ptr, unsigned int x, unsigned int y, unsigned int z, unsigned int pitch);
+
+MemHandle3D allocateGPUMemory(unsigned int x, unsigned int y, unsigned int z, Mem3DZeroMode zero);
+
+bool copyToGPUMemory(const float *src, MemHandle3D dst, const SSubDimensions3D &pos);
+
+bool copyFromGPUMemory(float *dst, MemHandle3D src, const SSubDimensions3D &pos);
+
+bool freeGPUMemory(MemHandle3D handle);
+
+bool zeroGPUMemory(MemHandle3D handle, unsigned int x, unsigned int y, unsigned int z);
+
+bool setGPUIndex(int index);
+
+
+bool FP(const astra::CProjectionGeometry3D* pProjGeom, MemHandle3D projData, const astra::CVolumeGeometry3D* pVolGeom, MemHandle3D volData, int iDetectorSuperSampling, astra::Cuda3DProjectionKernel projKernel);
+
+bool BP(const astra::CProjectionGeometry3D* pProjGeom, MemHandle3D projData, const astra::CVolumeGeometry3D* pVolGeom, MemHandle3D volData, int iVoxelSuperSampling, bool bFDKWeighting);
+
+bool FDK(const astra::CProjectionGeometry3D* pProjGeom, MemHandle3D projData, const astra::CVolumeGeometry3D* pVolGeom, MemHandle3D volData, bool bShortScan, const float *pfFilter = 0);
+
+}
+
+#endif
diff --git a/include/astra/cuda/3d/par3d_bp.h b/include/astra/cuda/3d/par3d_bp.h
new file mode 100644
index 0000000..b4ec6a3
--- /dev/null
+++ b/include/astra/cuda/3d/par3d_bp.h
@@ -0,0 +1,46 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_PAR3D_BP_H
+#define _CUDA_PAR3D_BP_H
+
+namespace astraCUDA3d {
+
+_AstraExport bool Par3DBP_Array(cudaPitchedPtr D_volumeData,
+ cudaArray *D_projArray,
+ const SDimensions3D& dims, const SPar3DProjection* angles,
+ const SProjectorParams3D& params);
+
+_AstraExport bool Par3DBP(cudaPitchedPtr D_volumeData,
+ cudaPitchedPtr D_projData,
+ const SDimensions3D& dims, const SPar3DProjection* angles,
+ const SProjectorParams3D& params);
+
+
+}
+
+#endif
diff --git a/include/astra/cuda/3d/par3d_fp.h b/include/astra/cuda/3d/par3d_fp.h
new file mode 100644
index 0000000..18f5f2e
--- /dev/null
+++ b/include/astra/cuda/3d/par3d_fp.h
@@ -0,0 +1,50 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_PAR3D_FP_H
+#define _CUDA_PAR3D_FP_H
+
+namespace astraCUDA3d {
+
+_AstraExport bool Par3DFP_Array(cudaArray *D_volArray,
+ cudaPitchedPtr D_projData,
+ const SDimensions3D& dims, const SPar3DProjection* angles,
+ const SProjectorParams3D& params);
+
+_AstraExport bool Par3DFP(cudaPitchedPtr D_volumeData,
+ cudaPitchedPtr D_projData,
+ const SDimensions3D& dims, const SPar3DProjection* angles,
+ const SProjectorParams3D& params);
+
+_AstraExport bool Par3DFP_SumSqW(cudaPitchedPtr D_volumeData,
+ cudaPitchedPtr D_projData,
+ const SDimensions3D& dims, const SPar3DProjection* angles,
+ const SProjectorParams3D& params);
+
+}
+
+#endif
diff --git a/include/astra/cuda/3d/sirt3d.h b/include/astra/cuda/3d/sirt3d.h
new file mode 100644
index 0000000..7c9a7c0
--- /dev/null
+++ b/include/astra/cuda/3d/sirt3d.h
@@ -0,0 +1,121 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_SIRT3D_H
+#define _CUDA_SIRT3D_H
+
+#include "algo3d.h"
+
+namespace astraCUDA3d {
+
+class _AstraExport SIRT : public ReconAlgo3D {
+public:
+ SIRT();
+ ~SIRT();
+
+// bool setConeGeometry(const SDimensions3D& dims, const SConeProjection* projs);
+
+
+ bool enableVolumeMask();
+ bool enableSinogramMask();
+
+ // init should be called after setting all geometry
+ bool init();
+
+ // Set relaxation factor. This may be called after init and before iterate.
+ void setRelaxation(float r) { fRelaxation = r; }
+
+ // setVolumeMask should be called after init and before iterate,
+ // but only if enableVolumeMask was called before init.
+ // It may be called again after iterate.
+ bool setVolumeMask(cudaPitchedPtr& D_maskData);
+
+ // setSinogramMask should be called after init and before iterate,
+ // but only if enableSinogramMask was called before init.
+ // It may be called again after iterate.
+ bool setSinogramMask(cudaPitchedPtr& D_smaskData);
+
+
+ // setBuffers should be called after init and before iterate.
+ // It may be called again after iterate.
+ bool setBuffers(cudaPitchedPtr& D_volumeData,
+ cudaPitchedPtr& D_projData);
+
+
+ // set Min/Max constraints. They may be called at any time, and will affect
+ // any iterate() calls afterwards.
+ bool setMinConstraint(float fMin);
+ bool setMaxConstraint(float fMax);
+
+ // iterate should be called after init and setBuffers.
+ // It may be called multiple times.
+ bool iterate(unsigned int iterations);
+
+ // Compute the norm of the difference of the FP of the current reconstruction
+ // and the sinogram. (This performs one FP.)
+ // It can be called after iterate.
+ float computeDiffNorm();
+
+protected:
+ void reset();
+ bool precomputeWeights();
+
+ bool useVolumeMask;
+ bool useSinogramMask;
+
+ bool useMinConstraint;
+ bool useMaxConstraint;
+ float fMinConstraint;
+ float fMaxConstraint;
+
+ float fRelaxation;
+
+ cudaPitchedPtr D_maskData;
+ cudaPitchedPtr D_smaskData;
+
+ // Input/output
+ cudaPitchedPtr D_sinoData;
+ cudaPitchedPtr D_volumeData;
+
+ // Temporary buffers
+ cudaPitchedPtr D_projData;
+ cudaPitchedPtr D_tmpData;
+
+ // Geometry-specific precomputed data
+ cudaPitchedPtr D_lineWeight;
+ cudaPitchedPtr D_pixelWeight;
+};
+
+bool doSIRT(cudaPitchedPtr D_volumeData, unsigned int volumePitch,
+ cudaPitchedPtr D_projData, unsigned int projPitch,
+ cudaPitchedPtr D_maskData, unsigned int maskPitch,
+ const SDimensions3D& dims, const SConeProjection* projs,
+ unsigned int iterations);
+
+}
+
+#endif
diff --git a/include/astra/cuda/3d/util3d.h b/include/astra/cuda/3d/util3d.h
new file mode 100644
index 0000000..17eb31e
--- /dev/null
+++ b/include/astra/cuda/3d/util3d.h
@@ -0,0 +1,68 @@
+/*
+-----------------------------------------------------------------------
+Copyright: 2010-2018, imec Vision Lab, University of Antwerp
+ 2014-2018, CWI, Amsterdam
+
+Contact: astra@astra-toolbox.com
+Website: http://www.astra-toolbox.com/
+
+This file is part of the 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/>.
+
+-----------------------------------------------------------------------
+*/
+
+#ifndef _CUDA_UTIL3D_H
+#define _CUDA_UTIL3D_H
+
+#include <cuda.h>
+#include "dims3d.h"
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+#include "../2d/util.h"
+
+namespace astraCUDA3d {
+
+cudaPitchedPtr allocateVolumeData(const SDimensions3D& dims);
+cudaPitchedPtr allocateProjectionData(const SDimensions3D& dims);
+bool zeroVolumeData(cudaPitchedPtr& D_data, const SDimensions3D& dims);
+bool zeroProjectionData(cudaPitchedPtr& D_data, const SDimensions3D& dims);
+bool copyVolumeToDevice(const float* data, cudaPitchedPtr& D_data, const SDimensions3D& dims, unsigned int pitch = 0);
+bool copyProjectionsToDevice(const float* data, cudaPitchedPtr& D_data, const SDimensions3D& dims, unsigned int pitch = 0);
+bool copyVolumeFromDevice(float* data, const cudaPitchedPtr& D_data, const SDimensions3D& dims, unsigned int pitch = 0);
+bool copyProjectionsFromDevice(float* data, const cudaPitchedPtr& D_data, const SDimensions3D& dims, unsigned int pitch = 0);
+bool duplicateVolumeData(cudaPitchedPtr& D_dest, const cudaPitchedPtr& D_src, const SDimensions3D& dims);
+bool duplicateProjectionData(cudaPitchedPtr& D_dest, const cudaPitchedPtr& D_src, const SDimensions3D& dims);
+
+
+bool transferProjectionsToArray(cudaPitchedPtr D_projData, cudaArray* array, const SDimensions3D& dims);
+bool transferVolumeToArray(cudaPitchedPtr D_volumeData, cudaArray* array, const SDimensions3D& dims);
+bool zeroProjectionArray(cudaArray* array, const SDimensions3D& dims);
+bool zeroVolumeArray(cudaArray* array, const SDimensions3D& dims);
+cudaArray* allocateProjectionArray(const SDimensions3D& dims);
+cudaArray* allocateVolumeArray(const SDimensions3D& dims);
+
+bool cudaTextForceKernelsCompletion();
+
+float dotProduct3D(cudaPitchedPtr data, unsigned int x, unsigned int y, unsigned int z);
+
+int calcNextPowerOfTwo(int _iValue);
+
+}
+
+#endif