Update version to 1.3

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 */