summaryrefslogtreecommitdiffstats
path: root/include/astra/ProjectionGeometry2D.h
diff options
context:
space:
mode:
authorWillem Jan Palenstijn <WillemJan.Palenstijn@uantwerpen.be>2013-07-01 22:34:11 +0000
committerwpalenst <WillemJan.Palenstijn@uantwerpen.be>2013-07-01 22:34:11 +0000
commitb2fc6c70434674d74551c3a6c01ffb3233499312 (patch)
treeb17f080ebc504ab85ebb7c3d89f917fd87ce9e00 /include/astra/ProjectionGeometry2D.h
downloadastra-b2fc6c70434674d74551c3a6c01ffb3233499312.tar.gz
astra-b2fc6c70434674d74551c3a6c01ffb3233499312.tar.bz2
astra-b2fc6c70434674d74551c3a6c01ffb3233499312.tar.xz
astra-b2fc6c70434674d74551c3a6c01ffb3233499312.zip
Update version to 1.3
Diffstat (limited to 'include/astra/ProjectionGeometry2D.h')
-rw-r--r--include/astra/ProjectionGeometry2D.h373
1 files changed, 373 insertions, 0 deletions
diff --git a/include/astra/ProjectionGeometry2D.h b/include/astra/ProjectionGeometry2D.h
new file mode 100644
index 0000000..bcaee7a
--- /dev/null
+++ b/include/astra/ProjectionGeometry2D.h
@@ -0,0 +1,373 @@
+/*
+-----------------------------------------------------------------------
+Copyright 2012 iMinds-Vision Lab, University of Antwerp
+
+Contact: astra@ua.ac.be
+Website: http://astra.ua.ac.be
+
+
+This file is part of the
+All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA Toolbox").
+
+The ASTRA Toolbox is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The ASTRA Toolbox is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
+
+-----------------------------------------------------------------------
+$Id$
+*/
+
+#ifndef _INC_ASTRA_PROJECTIONGEOMETRY2D
+#define _INC_ASTRA_PROJECTIONGEOMETRY2D
+
+#include "Globals.h"
+#include "Config.h"
+#include "Vector3D.h"
+
+#include <string>
+#include <cmath>
+#include <vector>
+
+namespace astra
+{
+
+/**
+ * This abstract base class defines the projection geometry.
+ * It has a number of data fields, such as width of detector
+ * pixels, projection angles, number of detector pixels and object offsets
+ * for every projection angle.
+ */
+class _AstraExport CProjectionGeometry2D
+{
+
+protected:
+
+ bool m_bInitialized; ///< Has the object been intialized?
+
+ /** Number of projection angles
+ */
+ int m_iProjectionAngleCount;
+
+ /** Number of detectors, i.e., the number of detector measurements for each projection angle.
+ */
+ int m_iDetectorCount;
+
+ /** Width of a detector pixel, i.e., the distance between projected rays (or width of projected strips).
+ */
+ float32 m_fDetectorWidth;
+
+ /** An array of m_iProjectionAngleCount elements containing an extra detector offset for each projection.
+ */
+ float32* m_pfExtraDetectorOffset;
+
+ /** Dynamically allocated array of projection angles. All angles are represented in radians and lie in
+ * the [0,2pi[ interval.
+ */
+ float32* m_pfProjectionAngles;
+
+ /** Default constructor. Sets all numeric member variables to 0 and all pointer member variables to NULL.
+ *
+ * If an object is constructed using this default constructor, it must always be followed by a call
+ * to one of the init() methods before the object can be used. Any use before calling init() is not
+ * allowed, except calling the member function isInitialized().
+ *
+ */
+ CProjectionGeometry2D();
+
+ /** Constructor. Create an instance of the CProjectionGeometry2D class.
+ *
+ * @param _iProjectionAngleCount Number of projection angles.
+ * @param _iDetectorCount Number of detectors, i.e., the number of detector measurements for each projection angle.
+ * @param _fDetectorWidth Width of a detector cell, in unit lengths. All detector cells are assumed to have equal width.
+ * @param _pfProjectionAngles Pointer to an array of projection angles. The angles will be copied from this array.
+ * All angles are represented in radians.
+ */
+ CProjectionGeometry2D(int _iProjectionAngleCount,
+ int _iDetectorCount,
+ float32 _fDetectorWidth,
+ const float32* _pfProjectionAngles,
+ const float32* _pfExtraDetectorOffsets = 0);
+
+ /** Copy constructor.
+ */
+ CProjectionGeometry2D(const CProjectionGeometry2D& _projGeom);
+
+ /** Check variable values.
+ */
+ bool _check();
+
+ /** Clear all member variables, setting all numeric variables to 0 and all pointers to NULL.
+ * Should only be used by constructors. Otherwise use the clear() function.
+ */
+ void _clear();
+
+ /** Initialization. Initializes an instance of the CProjectionGeometry2D class. If the object has been
+ * initialized before, the object is reinitialized and memory is freed and reallocated if necessary.
+ *
+ * @param _iProjectionAngleCount Number of projection angles.
+ * @param _iDetectorCount Number of detectors, i.e., the number of detector measurements for each projection angle.
+ * @param _fDetectorWidth Width of a detector cell, in unit lengths. All detector cells are assumed to have equal width.
+ * @param _pfProjectionAngles Pointer to an array of projection angles. The angles will be copied from this array.
+ */
+ bool _initialize(int _iProjectionAngleCount,
+ int _iDetectorCount,
+ float32 _fDetectorWidth,
+ const float32* _pfProjectionAngles,
+ const float32* _pfExtraDetectorOffsets = 0);
+
+public:
+
+ /** Destructor
+ */
+ virtual ~CProjectionGeometry2D();
+
+ /** Clear all member variables, setting all numeric variables to 0 and all pointers to NULL.
+ */
+ virtual void clear();
+
+ /** Create a hard copy.
+ */
+ virtual CProjectionGeometry2D* clone() = 0;
+
+ /** Initialize the geometry with a config object.
+ *
+ * @param _cfg Configuration Object
+ * @return initialization successful?
+ */
+ virtual bool initialize(const Config& _cfg);
+
+ /** Get the initialization state of the object.
+ *
+ * @return true iff the object has been initialized
+ */
+ bool isInitialized() const;
+
+ /** Return true if this geometry instance is the same as the one specified.
+ *
+ * @return true if this geometry instance is the same as the one specified.
+ */
+ virtual bool isEqual(CProjectionGeometry2D*) const = 0;
+
+ /** Get the number of projection angles.
+ *
+ * @return Number of projection angles
+ */
+ int getProjectionAngleCount() const;
+
+ /** Get the number of detectors.
+ *
+ * @return Number of detectors, i.e., the number of detector measurements for each projection angle.
+ */
+ int getDetectorCount() const;
+
+ /** Get the width of a detector.
+ *
+ * @return Width of a detector, in unit lengths
+ */
+ float32 getDetectorWidth() const;
+
+ /** Get a projection angle, given by its index. The angle is represented in Radians.
+ *
+ * @return Projection angle with index _iProjectionIndex
+ */
+ float32 getProjectionAngle(int _iProjectionIndex) const;
+
+ /** Returns a buffer containing all projection angles. The element count of the buffer is equal
+ * to the number given by getProjectionAngleCount.
+ *
+ * The angles are in radians.
+ *
+ * @return Pointer to buffer containing the angles.
+ */
+ const float32* getProjectionAngles() const;
+
+ /** Get a projection angle, given by its index. The angle is represented in degrees.
+ *
+ * @return Projection angle with index _iProjectionIndex
+ */
+ float32 getProjectionAngleDegrees(int _iProjectionIndex) const;
+
+ float32 getExtraDetectorOffset(int iAngle) const;
+ const float32* getExtraDetectorOffset() const { return m_pfExtraDetectorOffset; }
+
+ /** Get the index coordinate of a point on a detector array.
+ *
+ * @param _fOffset distance between the center of the detector array and a certain point
+ * @return the location of the point in index coordinates (still float, not rounded)
+ */
+ virtual float32 detectorOffsetToIndexFloat(float32 _fOffset) const;
+
+ /** Get the index coordinate of a point on a detector array.
+ *
+ * @param _fOffset distance between the center of the detector array and a certain point
+ * @return the index of the detector that is hit, -1 if detector array isn't hit.
+ */
+ virtual int detectorOffsetToIndex(float32 _fOffset) const;
+
+ /** Get the offset of a detector based on its index coordinate.
+ *
+ * @param _iIndex the index of the detector.
+ * @return the offset from the center of the detector array.
+ */
+ virtual float32 indexToDetectorOffset(int _iIndex) const;
+
+ /** Get the angle and detector index of a sinogram pixel
+ *
+ * @param _iIndex the index of the detector pixel in the sinogram.
+ * @param _iAngleIndex output: index of angle
+ * @param _iDetectorIndex output: index of detector
+ */
+ virtual void indexToAngleDetectorIndex(int _iIndex, int& _iAngleIndex, int& _iDetectorIndex) const;
+
+ /** Get the value for t and theta, based upon the row and column index.
+ *
+ * @param _iRow row index
+ * @param _iColumn column index
+ * @param _fT output: value of t
+ * @param _fTheta output: value of theta, always lies within the [0,pi[ interval.
+ */
+ virtual void getRayParams(int _iRow, int _iColumn, float32& _fT, float32& _fTheta) const;
+
+ /** Returns true if the type of geometry defined in this class is the one specified in _sType.
+ *
+ * @param _sType geometry type to compare to.
+ * @return true if the type of geometry defined in this class is the one specified in _sType.
+ */
+ virtual bool isOfType(const std::string& _sType) = 0;
+
+ /**
+ * Returns a vector describing the direction of a ray belonging to a certain detector
+ *
+ * @param _iProjectionIndex index of projection
+ * @param _iProjectionIndex index of detector
+ *
+ * @return a unit vector describing the direction
+ */
+ virtual CVector3D getProjectionDirection(int _iProjectionIndex, int _iDetectorIndex) = 0;
+
+
+ //< For Config unused argument checking
+ ConfigCheckData* configCheckData;
+ friend class ConfigStackCheck<CProjectionGeometry2D>;
+};
+
+
+
+//----------------------------------------------------------------------------------------
+// Inline member functions
+//----------------------------------------------------------------------------------------
+
+
+inline float32 CProjectionGeometry2D::getExtraDetectorOffset(int _iAngle) const
+{
+ return m_pfExtraDetectorOffset ? m_pfExtraDetectorOffset[_iAngle] : 0.0f;
+}
+
+
+// Get the initialization state.
+inline bool CProjectionGeometry2D::isInitialized() const
+{
+ return m_bInitialized;
+}
+
+
+// Get the number of detectors.
+inline int CProjectionGeometry2D::getDetectorCount() const
+{
+ ASTRA_ASSERT(m_bInitialized);
+ return m_iDetectorCount;
+}
+
+// Get the width of a single detector (in unit lengths).
+inline float32 CProjectionGeometry2D::getDetectorWidth() const
+{
+ ASTRA_ASSERT(m_bInitialized);
+ return m_fDetectorWidth;
+}
+
+// Get the number of projection angles.
+inline int CProjectionGeometry2D::getProjectionAngleCount() const
+{
+ ASTRA_ASSERT(m_bInitialized);
+ return m_iProjectionAngleCount;
+}
+
+// Get pointer to buffer used to store projection angles.
+inline const float32* CProjectionGeometry2D::getProjectionAngles() const
+{
+ ASTRA_ASSERT(m_bInitialized);
+ return m_pfProjectionAngles;
+}
+
+// Get a projection angle, represented in Radians.
+inline float32 CProjectionGeometry2D::getProjectionAngle(int _iProjectionIndex) const
+{
+ // basic checks
+ ASTRA_ASSERT(m_bInitialized);
+ ASTRA_ASSERT(_iProjectionIndex >= 0);
+ ASTRA_ASSERT(_iProjectionIndex < m_iProjectionAngleCount);
+
+ return m_pfProjectionAngles[_iProjectionIndex];
+}
+
+// Get a projection angle, represented in degrees.
+inline float32 CProjectionGeometry2D::getProjectionAngleDegrees(int _iProjectionIndex) const
+{
+ // basic checks
+ ASTRA_ASSERT(m_bInitialized);
+ ASTRA_ASSERT(_iProjectionIndex >= 0);
+ ASTRA_ASSERT(_iProjectionIndex < m_iProjectionAngleCount);
+
+ return (m_pfProjectionAngles[_iProjectionIndex] * 180.0f / PI32);
+}
+
+// Get T and Theta
+inline void CProjectionGeometry2D::getRayParams(int _iRow, int _iColumn, float32& _fT, float32& _fTheta) const
+{
+ ASTRA_ASSERT(m_bInitialized);
+ _fT = indexToDetectorOffset(_iColumn);
+ _fTheta = getProjectionAngle(_iRow);
+ if (PI <= _fTheta) {
+ _fTheta -= PI;
+ _fT = -_fT;
+ }
+}
+
+// detector offset -> detector index
+inline int CProjectionGeometry2D::detectorOffsetToIndex(float32 _fOffset) const
+{
+ int res = (int)(detectorOffsetToIndexFloat(_fOffset) + 0.5f);
+ return (res > 0 && res <= m_iDetectorCount) ? res : -1;
+}
+
+// detector offset -> detector index (float)
+inline float32 CProjectionGeometry2D::detectorOffsetToIndexFloat(float32 _fOffset) const
+{
+ return (_fOffset / m_fDetectorWidth) + ((m_iDetectorCount-1.0f) * 0.5f);
+}
+
+// detector index -> detector offset
+inline float32 CProjectionGeometry2D::indexToDetectorOffset(int _iIndex) const
+{
+ return (_iIndex - (m_iDetectorCount-1.0f) * 0.5f) * m_fDetectorWidth;
+}
+
+// sinogram index -> angle and detecor index
+inline void CProjectionGeometry2D::indexToAngleDetectorIndex(int _iIndex, int& _iAngleIndex, int& _iDetectorIndex) const
+{
+ _iAngleIndex = _iIndex / m_iDetectorCount;
+ _iDetectorIndex = _iIndex % m_iDetectorCount;
+}
+
+} // end namespace astra
+
+#endif /* _INC_ASTRA_PROJECTIONGEOMETRY2D */