diff options
Diffstat (limited to 'include')
| -rw-r--r-- | include/astra/FanFlatBeamLineKernelProjector2D.h | 8 | ||||
| -rw-r--r-- | include/astra/FanFlatBeamStripKernelProjector2D.h | 8 | ||||
| -rw-r--r-- | include/astra/ParallelBeamBlobKernelProjector2D.h | 8 | ||||
| -rw-r--r-- | include/astra/ParallelBeamDistanceDrivenProjector2D.h | 197 | ||||
| -rw-r--r-- | include/astra/ParallelBeamDistanceDrivenProjector2D.inl | 220 | ||||
| -rw-r--r-- | include/astra/ParallelBeamLineKernelProjector2D.h | 8 | ||||
| -rw-r--r-- | include/astra/ParallelBeamLinearKernelProjector2D.h | 8 | ||||
| -rw-r--r-- | include/astra/ParallelBeamLinearKernelProjector2D.inl | 2 | ||||
| -rw-r--r-- | include/astra/ParallelBeamStripKernelProjector2D.h | 8 | ||||
| -rw-r--r-- | include/astra/Projector2D.h | 8 | ||||
| -rw-r--r-- | include/astra/Projector2DImpl.inl | 1 | ||||
| -rw-r--r-- | include/astra/ProjectorTypelist.h | 7 | ||||
| -rw-r--r-- | include/astra/SparseMatrixProjector2D.h | 8 |
13 files changed, 424 insertions, 67 deletions
diff --git a/include/astra/FanFlatBeamLineKernelProjector2D.h b/include/astra/FanFlatBeamLineKernelProjector2D.h index 1bfaf07..4492bdf 100644 --- a/include/astra/FanFlatBeamLineKernelProjector2D.h +++ b/include/astra/FanFlatBeamLineKernelProjector2D.h @@ -134,14 +134,6 @@ public: int _iMaxPixelCount, int& _iStoredPixelCount); - /** 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<SDetector2D> projectPoint(int _iRow, int _iCol); - /** Policy-based projection of all rays. This function will calculate each non-zero projection * weight and use this value for a task provided by the policy object. * diff --git a/include/astra/FanFlatBeamStripKernelProjector2D.h b/include/astra/FanFlatBeamStripKernelProjector2D.h index a6a303c..4942f6c 100644 --- a/include/astra/FanFlatBeamStripKernelProjector2D.h +++ b/include/astra/FanFlatBeamStripKernelProjector2D.h @@ -132,14 +132,6 @@ public: int _iMaxPixelCount, int& _iStoredPixelCount); - /** 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<SDetector2D> projectPoint(int _iRow, int _iCol); - /** Policy-based projection of all rays. This function will calculate each non-zero projection * weight and use this value for a task provided by the policy object. * diff --git a/include/astra/ParallelBeamBlobKernelProjector2D.h b/include/astra/ParallelBeamBlobKernelProjector2D.h index 46b0b52..ffae707 100644 --- a/include/astra/ParallelBeamBlobKernelProjector2D.h +++ b/include/astra/ParallelBeamBlobKernelProjector2D.h @@ -160,14 +160,6 @@ public: int _iMaxPixelCount, int& _iStoredPixelCount); - /** 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<SDetector2D> projectPoint(int _iRow, int _iCol); - /** Policy-based projection of all rays. This function will calculate each non-zero projection * weight and use this value for a task provided by the policy object. * diff --git a/include/astra/ParallelBeamDistanceDrivenProjector2D.h b/include/astra/ParallelBeamDistanceDrivenProjector2D.h new file mode 100644 index 0000000..6d1d633 --- /dev/null +++ b/include/astra/ParallelBeamDistanceDrivenProjector2D.h @@ -0,0 +1,197 @@ +/* +----------------------------------------------------------------------- +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 _INC_ASTRA_PARALLELDISTANCEDRIVENPROJECTOR +#define _INC_ASTRA_PARALLELDISTANCEDRIVENPROJECTOR + +#include "ParallelProjectionGeometry2D.h" +#include "ParallelVecProjectionGeometry2D.h" +#include "Float32Data2D.h" +#include "Projector2D.h" + +#include "Float32ProjectionData2D.h" +#include "Float32VolumeData2D.h" + +namespace astra +{ + +/** This class implements a "distance driven" two-dimensional projector. + * + * Reference: + * De Man, Bruno, and Samit Basu. “Distance-Driven Projection and Backprojection in Three Dimensions.” Physics in Medicine and Biology 49, no. 11 (2004): 2463. + * + * \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.} + * + * \par MATLAB example + * \astra_code{ + * cfg = astra_struct('distance_driven');\n + * cfg.ProjectionGeometry = proj_geom;\n + * cfg.VolumeGeometry = vol_geom;\n + * proj_id = astra_mex_projector('create'\, cfg);\n + * } + */ +class _AstraExport CParallelBeamDistanceDrivenProjector2D : public CProjector2D { + +protected: + + /** Initial clearing. Only to be used by constructors. + */ + virtual void _clear(); + + /** Check the values of this object. If everything is ok, the object can be set to the initialized state. + * The following statements are then guaranteed to hold: + * - no NULL pointers + * - all sub-objects are initialized properly + * - blobvalues are ok + */ + virtual bool _check(); + +public: + + // type of the projector, needed to register with CProjectorFactory + static std::string type; + + /** Default constructor. + */ + CParallelBeamDistanceDrivenProjector2D(); + + /** Constructor. + * + * @param _pProjectionGeometry Information class about the geometry of the projection. Will be HARDCOPIED. + * @param _pReconstructionGeometry Information class about the geometry of the reconstruction volume. Will be HARDCOPIED. + */ + CParallelBeamDistanceDrivenProjector2D(CParallelProjectionGeometry2D* _pProjectionGeometry, + CVolumeGeometry2D* _pReconstructionGeometry); + + /** Destructor, is virtual to show that we are aware subclass destructor are called. + */ + ~CParallelBeamDistanceDrivenProjector2D(); + + /** Initialize the projector with a config object. + * + * @param _cfg Configuration Object + * @return initialization successful? + */ + virtual bool initialize(const Config& _cfg); + + /** Initialize the projector. + * + * @param _pProjectionGeometry Information class about the geometry of the projection. Will be HARDCOPIED. + * @param _pReconstructionGeometry Information class about the geometry of the reconstruction volume. Will be HARDCOPIED. + * @return initialization successful? + */ + virtual bool initialize(CParallelProjectionGeometry2D* _pProjectionGeometry, + CVolumeGeometry2D* _pVolumeGeometry); + + /** Clear this class. + */ + virtual void clear(); + + /** 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 SPixelWeight elements) needed to store weighted pixels. + */ + virtual int getProjectionWeightsCount(int _iProjectionIndex); + + /** Compute the pixel weights for a single ray, from the source to a detector pixel. + * + * @param _iProjectionIndex Index of the projection + * @param _iDetectorIndex Index of the detector pixel + * @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 _iDetectorIndex, + SPixelWeight* _pWeightedPixels, + int _iMaxPixelCount, + int& _iStoredPixelCount); + + + /** Policy-based projection of all rays. This function will calculate each non-zero projection + * weight and use this value for a task provided by the policy object. + * + * @param _policy Policy object. Should contain prior, addWeight and posterior function. + */ + template <typename Policy> + void project(Policy& _policy); + + /** Policy-based projection of all rays of a single projection. This function will calculate + * each non-zero projection weight and use this value for a task provided by the policy object. + * + * @param _iProjection Which projection should be projected? + * @param _policy Policy object. Should contain prior, addWeight and posterior function. + */ + template <typename Policy> + void projectSingleProjection(int _iProjection, Policy& _policy); + + /** Policy-based projection of a single ray. This function will calculate each non-zero + * projection weight and use this value for a task provided by the policy object. + * + * @param _iProjection Which projection should be projected? + * @param _iDetector Which detector should be projected? + * @param _policy Policy object. Should contain prior, addWeight and posterior function. + */ + template <typename Policy> + void projectSingleRay(int _iProjection, int _iDetector, Policy& _policy); + + /** Return the type of this projector. + * + * @return identification type of this projector + */ + virtual std::string getType(); + + +protected: + /** Internal policy-based projection of a range of angles and range. + * (_i*From is inclusive, _i*To exclusive) */ + template <typename Policy> + void projectBlock_internal(int _iProjFrom, int _iProjTo, + int _iDetFrom, int _iDetTo, Policy& _policy); + +}; + +//---------------------------------------------------------------------------------------- + +inline std::string CParallelBeamDistanceDrivenProjector2D::getType() +{ + return type; +} + + +} // namespace astra + + +#endif + diff --git a/include/astra/ParallelBeamDistanceDrivenProjector2D.inl b/include/astra/ParallelBeamDistanceDrivenProjector2D.inl new file mode 100644 index 0000000..aedcee9 --- /dev/null +++ b/include/astra/ParallelBeamDistanceDrivenProjector2D.inl @@ -0,0 +1,220 @@ +/* +----------------------------------------------------------------------- +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/>. + +----------------------------------------------------------------------- +*/ + +#define policy_weight(p,rayindex,volindex,weight) do { if (p.pixelPrior(volindex)) { p.addWeight(rayindex, volindex, weight); p.pixelPosterior(volindex); } } while (false) + +template <typename Policy> +void CParallelBeamDistanceDrivenProjector2D::project(Policy& p) +{ + projectBlock_internal(0, m_pProjectionGeometry->getProjectionAngleCount(), + 0, m_pProjectionGeometry->getDetectorCount(), p); +} + +template <typename Policy> +void CParallelBeamDistanceDrivenProjector2D::projectSingleProjection(int _iProjection, Policy& p) +{ + projectBlock_internal(_iProjection, _iProjection + 1, + 0, m_pProjectionGeometry->getDetectorCount(), p); +} + +template <typename Policy> +void CParallelBeamDistanceDrivenProjector2D::projectSingleRay(int _iProjection, int _iDetector, Policy& p) +{ + projectBlock_internal(_iProjection, _iProjection + 1, + _iDetector, _iDetector + 1, p); +} + + + + + +template <typename Policy> +void CParallelBeamDistanceDrivenProjector2D::projectBlock_internal(int _iProjFrom, int _iProjTo, int _iDetFrom, int _iDetTo, Policy& p) +{ + // get vector geometry + const CParallelVecProjectionGeometry2D* pVecProjectionGeometry; + if (dynamic_cast<CParallelProjectionGeometry2D*>(m_pProjectionGeometry)) { + pVecProjectionGeometry = dynamic_cast<CParallelProjectionGeometry2D*>(m_pProjectionGeometry)->toVectorGeometry(); + } else { + pVecProjectionGeometry = dynamic_cast<CParallelVecProjectionGeometry2D*>(m_pProjectionGeometry); + } + + // precomputations + const float32 pixelLengthX = m_pVolumeGeometry->getPixelLengthX(); + const float32 pixelLengthY = m_pVolumeGeometry->getPixelLengthY(); + const float32 inv_pixelLengthX = 1.0f / pixelLengthX; + const float32 inv_pixelLengthY = 1.0f / pixelLengthY; + const int colCount = m_pVolumeGeometry->getGridColCount(); + const int rowCount = m_pVolumeGeometry->getGridRowCount(); + + // Performance note: + // This is not a very well optimizated version of the distance driven + // projector. The CPU projector model in ASTRA requires ray-driven iteration, + // which limits re-use of intermediate computations. + + // loop angles + for (int iAngle = _iProjFrom; iAngle < _iProjTo; ++iAngle) { + + const SParProjection * proj = &pVecProjectionGeometry->getProjectionVectors()[iAngle]; + + const bool vertical = fabs(proj->fRayX) < fabs(proj->fRayY); + + const float32 Ex = m_pVolumeGeometry->getWindowMinX() + pixelLengthX*0.5f; + const float32 Ey = m_pVolumeGeometry->getWindowMaxY() - pixelLengthY*0.5f; + + // loop detectors + for (int iDetector = _iDetFrom; iDetector < _iDetTo; ++iDetector) { + + const int iRayIndex = iAngle * m_pProjectionGeometry->getDetectorCount() + iDetector; + + // POLICY: RAY PRIOR + if (!p.rayPrior(iRayIndex)) continue; + + const float32 Dx = proj->fDetSX + (iDetector+0.5f) * proj->fDetUX; + const float32 Dy = proj->fDetSY + (iDetector+0.5f) * proj->fDetUY; + + if (vertical) { + + const float32 RxOverRy = proj->fRayX/proj->fRayY; + const float32 lengthPerRow = m_pVolumeGeometry->getPixelLengthX() * m_pVolumeGeometry->getPixelLengthY(); + const float32 deltac = -pixelLengthY * RxOverRy * inv_pixelLengthX; + const float32 deltad = 0.5f * fabs((proj->fDetUX - proj->fDetUY * RxOverRy) * inv_pixelLengthX); + + // calculate c for row 0 + float32 c = (Dx + (Ey - Dy)*RxOverRy - Ex) * inv_pixelLengthX + 0.5f; + + // loop rows + for (int row = 0; row < rowCount; ++row, c+= deltac) { + + // horizontal extent of ray in center of this row: + // [ c - deltad , c + deltad ] + + // |-gapBegin-*---|------|----*-gapEnd-| + // * = ray extent intercepts; c - deltad and c + deltad + // | = pixel column edges + + const int colBegin = (int)floor(c - deltad); + const int colEnd = (int)ceil(c + deltad); + + if (colBegin >= colCount || colEnd <= 0) + continue; + + int iVolumeIndex = row * colCount + colBegin; + if (colBegin + 1 == colEnd) { + + if (colBegin >= 0 && colBegin < colCount) + policy_weight(p, iRayIndex, iVolumeIndex, + 2.0f * deltad * lengthPerRow); + } else { + + if (colBegin >= 0) { + const float gapBegin = (c - deltad) - (float32)colBegin; + policy_weight(p, iRayIndex, iVolumeIndex, + (1.0f - gapBegin) * lengthPerRow); + } + + const int clippedMColBegin = std::max(colBegin + 1, 0); + const int clippedMColEnd = std::min(colEnd - 1, colCount); + iVolumeIndex = row * colCount + clippedMColBegin; + for (int col = clippedMColBegin; col < clippedMColEnd; ++col, ++iVolumeIndex) { + policy_weight(p, iRayIndex, iVolumeIndex, lengthPerRow); + } + + iVolumeIndex = row * colCount + colEnd - 1; + if (colEnd <= colCount) { + const float gapEnd = (float32)colEnd - (c + deltad); + policy_weight(p, iRayIndex, iVolumeIndex, + (1.0f - gapEnd) * lengthPerRow); + } + } + + } + + } else { + + const float32 RyOverRx = proj->fRayY/proj->fRayX; + const float32 lengthPerCol = m_pVolumeGeometry->getPixelLengthX() * m_pVolumeGeometry->getPixelLengthY(); + const float32 deltar = -pixelLengthX * RyOverRx * inv_pixelLengthY; + const float32 deltad = 0.5f * fabs((proj->fDetUY - proj->fDetUX * RyOverRx) * inv_pixelLengthY); + + // calculate r for col 0 + float32 r = -(Dy + (Ex - Dx)*RyOverRx - Ey) * inv_pixelLengthY + 0.5f; + + // loop columns + for (int col = 0; col < colCount; ++col, r+= deltar) { + + // vertical extent of ray in center of this column: + // [ r - deltad , r + deltad ] + + const int rowBegin = (int)floor(r - deltad); + const int rowEnd = (int)ceil(r + deltad); + + if (rowBegin >= rowCount || rowEnd <= 0) + continue; + + int iVolumeIndex = rowBegin * colCount + col; + if (rowBegin + 1 == rowEnd) { + + if (rowBegin >= 0 && rowBegin < rowCount) + policy_weight(p, iRayIndex, iVolumeIndex, + 2.0f * deltad * lengthPerCol); + } else { + if (rowBegin >= 0) { + const float gapBegin = (r - deltad) - (float32)rowBegin; + policy_weight(p, iRayIndex, iVolumeIndex, + (1.0f - gapBegin) * lengthPerCol); + } + + const int clippedMRowBegin = std::max(rowBegin + 1, 0); + const int clippedMRowEnd = std::min(rowEnd - 1, rowCount); + iVolumeIndex = clippedMRowBegin * colCount + col; + + for (int row = clippedMRowBegin; row < clippedMRowEnd; ++row, iVolumeIndex += colCount) { + policy_weight(p, iRayIndex, iVolumeIndex, lengthPerCol); + } + + iVolumeIndex = (rowEnd - 1) * colCount + col; + if (rowEnd <= rowCount) { + const float gapEnd = (float32)rowEnd - (r + deltad); + policy_weight(p, iRayIndex, iVolumeIndex, + (1.0f - gapEnd) * lengthPerCol); + } + } + + } + + } + + // POLICY: RAY POSTERIOR + p.rayPosterior(iRayIndex); + + } + } + + if (dynamic_cast<CParallelProjectionGeometry2D*>(m_pProjectionGeometry)) + delete pVecProjectionGeometry; +} diff --git a/include/astra/ParallelBeamLineKernelProjector2D.h b/include/astra/ParallelBeamLineKernelProjector2D.h index f709e1d..4238919 100644 --- a/include/astra/ParallelBeamLineKernelProjector2D.h +++ b/include/astra/ParallelBeamLineKernelProjector2D.h @@ -132,14 +132,6 @@ public: int _iMaxPixelCount, int& _iStoredPixelCount); - /** 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<SDetector2D> projectPoint(int _iRow, int _iCol); - /** Policy-based projection of all rays. This function will calculate each non-zero projection * weight and use this value for a task provided by the policy object. * diff --git a/include/astra/ParallelBeamLinearKernelProjector2D.h b/include/astra/ParallelBeamLinearKernelProjector2D.h index a09dcd1..67d940e 100644 --- a/include/astra/ParallelBeamLinearKernelProjector2D.h +++ b/include/astra/ParallelBeamLinearKernelProjector2D.h @@ -135,14 +135,6 @@ public: int _iMaxPixelCount, int& _iStoredPixelCount); - /** 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<SDetector2D> projectPoint(int _iRow, int _iCol); - /** Policy-based projection of all rays. This function will calculate each non-zero projection * weight and use this value for a task provided by the policy object. diff --git a/include/astra/ParallelBeamLinearKernelProjector2D.inl b/include/astra/ParallelBeamLinearKernelProjector2D.inl index 485eef6..10d4892 100644 --- a/include/astra/ParallelBeamLinearKernelProjector2D.inl +++ b/include/astra/ParallelBeamLinearKernelProjector2D.inl @@ -156,7 +156,7 @@ void CParallelBeamLinearKernelProjector2D::projectBlock_internal(int _iProjFrom, float32 detSize = sqrt(proj->fDetUX * proj->fDetUX + proj->fDetUY * proj->fDetUY); - bool vertical = fabs(proj->fRayX) < fabs(proj->fRayY); + const bool vertical = fabs(proj->fRayX) < fabs(proj->fRayY); if (vertical) { RxOverRy = proj->fRayX/proj->fRayY; lengthPerRow = detSize * m_pVolumeGeometry->getPixelLengthX() * sqrt(proj->fRayY*proj->fRayY + proj->fRayX*proj->fRayX) / abs(proj->fRayY); diff --git a/include/astra/ParallelBeamStripKernelProjector2D.h b/include/astra/ParallelBeamStripKernelProjector2D.h index 153a454..597f8dc 100644 --- a/include/astra/ParallelBeamStripKernelProjector2D.h +++ b/include/astra/ParallelBeamStripKernelProjector2D.h @@ -133,14 +133,6 @@ public: int _iMaxPixelCount, int& _iStoredPixelCount); - /** 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<SDetector2D> projectPoint(int _iRow, int _iCol); - /** Policy-based projection of all rays. This function will calculate each non-zero projection * weight and use this value for a task provided by the policy object. * diff --git a/include/astra/Projector2D.h b/include/astra/Projector2D.h index 8e0b7a8..9d9130f 100644 --- a/include/astra/Projector2D.h +++ b/include/astra/Projector2D.h @@ -149,14 +149,6 @@ public: 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<SDetector2D> projectPoint(int _iRow, int _iCol) = 0; - /** Returns the number of weights required for storage of all weights of one projection ray. * * @param _iProjectionIndex Index of the projection (zero-based). diff --git a/include/astra/Projector2DImpl.inl b/include/astra/Projector2DImpl.inl index b7edb1f..1308141 100644 --- a/include/astra/Projector2DImpl.inl +++ b/include/astra/Projector2DImpl.inl @@ -26,6 +26,7 @@ along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>. */ +#include "ParallelBeamDistanceDrivenProjector2D.inl" #include "ParallelBeamLinearKernelProjector2D.inl" #include "ParallelBeamLineKernelProjector2D.inl" #include "ParallelBeamStripKernelProjector2D.inl" diff --git a/include/astra/ProjectorTypelist.h b/include/astra/ProjectorTypelist.h index 1a65aad..063693d 100644 --- a/include/astra/ProjectorTypelist.h +++ b/include/astra/ProjectorTypelist.h @@ -35,6 +35,7 @@ along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>. #include "Projector2D.h" #include "ParallelBeamLineKernelProjector2D.h" #include "ParallelBeamLinearKernelProjector2D.h" +#include "ParallelBeamDistanceDrivenProjector2D.h" #include "ParallelBeamBlobKernelProjector2D.h" #include "ParallelBeamStripKernelProjector2D.h" #include "SparseMatrixProjector2D.h" @@ -46,9 +47,10 @@ namespace astra{ #ifdef ASTRA_CUDA - typedef TYPELIST_8( + typedef TYPELIST_9( CFanFlatBeamLineKernelProjector2D, CFanFlatBeamStripKernelProjector2D, + CParallelBeamDistanceDrivenProjector2D, CParallelBeamLinearKernelProjector2D, CParallelBeamLineKernelProjector2D, CParallelBeamBlobKernelProjector2D, @@ -59,9 +61,10 @@ namespace astra{ #else - typedef TYPELIST_7( + typedef TYPELIST_8( CFanFlatBeamLineKernelProjector2D, CFanFlatBeamStripKernelProjector2D, + CParallelBeamDistanceDrivenProjector2D, CParallelBeamLinearKernelProjector2D, CParallelBeamLineKernelProjector2D, CParallelBeamBlobKernelProjector2D, diff --git a/include/astra/SparseMatrixProjector2D.h b/include/astra/SparseMatrixProjector2D.h index db8c4e2..1fc44c5 100644 --- a/include/astra/SparseMatrixProjector2D.h +++ b/include/astra/SparseMatrixProjector2D.h @@ -133,14 +133,6 @@ public: int _iMaxPixelCount, int& _iStoredPixelCount); - /** 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<SDetector2D> projectPoint(int _iRow, int _iCol); - /** Policy-based projection of all rays. This function will calculate each non-zero projection * weight and use this value for a task provided by the policy object. * |