/* ----------------------------------------------------------------------- Copyright: 2010-2016, iMinds-Vision Lab, University of Antwerp 2014-2016, 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 . ----------------------------------------------------------------------- */ #ifndef INC_ASTRA_PROJECTOR3D #define INC_ASTRA_PROJECTOR3D #include #include #include "Globals.h" #include "Config.h" namespace astra { class CSparseMatrix; class CProjectionGeometry3D; class CVolumeGeometry3D; /** This is a base interface class for a three-dimensional projector. Each subclass should at least * implement the core projection functions computeProjectionRayWeights and projectPoint. * * \par XML Configuration * \astra_xml_item{ProjectionGeometry, xml node, The geometry of the projection.} * \astra_xml_item{VolumeGeometry, xml node, The geometry of the volume.} */ class _AstraExport CProjector3D { protected: CProjectionGeometry3D* m_pProjectionGeometry; ///< Used projection geometry CVolumeGeometry3D* m_pVolumeGeometry; ///< Used volume geometry bool m_bIsInitialized; ///< Has this class been initialized? /** 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(); public: /** * Default Constructor. */ CProjector3D(); /** Destructor, is virtual to show that we are aware subclass destructor is called. */ virtual ~CProjector3D(); /** Clear all member variables, setting all numeric variables to 0 and all pointers to NULL. */ void clear(); /** Initialize the projector with a config object. * This function does not set m_bInitialized to true. * * @param _cfg Configuration Object * @return initialization successful? */ virtual bool initialize(const Config& _cfg); /** Fetch the Projection Geometry of this projector. * * @return Projection Geometry class. */ CProjectionGeometry3D* getProjectionGeometry(); /** Fetch the Volume Geometry of this projector. * * @return Volume Geometry class. */ CVolumeGeometry3D* getVolumeGeometry(); /** Compute the pixel weights for a single ray, from the source to a detector pixel. * * @param _iProjectionIndex Index of the projection. * @param _iSliceIndex Index of the detector pixel (1-d index). * @param _iDetectorIndex Index of the detector pixel (1-d index). * @param _pWeightedPixels Pointer to a pre-allocated array, consisting of _iMaxPixelCount elements * of type SPixelWeight. On return, this array contains a list of the index * and weight for all pixels on the ray. * @param _iMaxPixelCount Maximum number of pixels (and corresponding weights) that can be stored in _pWeightedPixels. * This number MUST be greater than the total number of pixels on the ray. * @param _iStoredPixelCount On return, this variable contains the total number of pixels on the * ray (that have been stored in the list _pWeightedPixels). */ virtual void computeSingleRayWeights(int _iProjectionIndex, int _iSliceIndex, int _iDetectorIndex, SPixelWeight* _pWeightedPixels, int _iMaxPixelCount, int& _iStoredPixelCount) = 0; /** Compute the pixel weights for all rays in a single projection, from the source to a each of the * detector pixels. All pixels and their weights are stored consecutively in the array _pWeightedPixels. * The array starts with all pixels on the first ray, followed by all pixels on the second ray, the third * ray, etc. Note that a pixel may occur in the list more than once, as it can be on several rays. * * @param _iProjectionIndex Index of the projection (zero-based). * @param _pfWeightedPixels Pointer to a pre-allocated array, consisting of getProjectionWeightsCount() * elements of type SPixelWeight. On return, this array contains a list of * the index and weight for all pixels on each of the rays. The elements for * every ray start at equal offsets (ray_index * _pWeightedPixels / ray_count). * @param _piRayStoredPixelCount Pointer to a pre-allocated array, containing a single integer for each * ray in the projection. On return, this array contains the number of * pixels on the ray, for each ray in the given projection. */ virtual void computeProjectionRayWeights(int _iProjectionIndex, SPixelWeight* _pfWeightedPixels, int* _piRayStoredPixelCount); /** Create a list of detectors that are influenced by point [_iRow, _iCol]. * * @param _iRow row of the point * @param _iCol column of the point * @return list of SDetector2D structs */ //virtual std::vector projectPoint(int _iRow, int _iCol) = 0; /** Returns the number of weights required for storage of all weights of one projection. * * @param _iProjectionIndex Index of the projection (zero-based). * @return Size of buffer (given in SWeightedPixel3D elements) needed to store weighted pixels. */ virtual int getProjectionWeightsCount(int _iProjectionIndex) = 0; /** Has the projector been initialized? * * @return initialized successfully */ bool isInitialized() const; /** get a description of the class * * @return description string */ virtual std::string description() const = 0; /** * Returns a string describing the projector type */ virtual std::string getType() = 0; private: //< For Config unused argument checking ConfigCheckData* configCheckData; friend class ConfigStackCheck; }; // inline functions inline bool CProjector3D::isInitialized() const { return m_bIsInitialized; } inline CProjectionGeometry3D* CProjector3D::getProjectionGeometry() { return m_pProjectionGeometry; } inline CVolumeGeometry3D* CProjector3D::getVolumeGeometry() { return m_pVolumeGeometry; } } // namespace astra #endif /* INC_ASTRA_PROJECTOR3D */