//----------------------------------------------------------------------------------------
// Iterate
void CCudaBackProjectionAlgorithm3D::run(int _iNrIterations)
{
// check initialized
ASTRA_ASSERT(m_bIsInitialized);
CFloat32ProjectionData3DMemory* pSinoMem = dynamic_cast<CFloat32ProjectionData3DMemory*>(m_pSinogram);
ASTRA_ASSERT(pSinoMem);
CFloat32VolumeData3DMemory* pReconMem = dynamic_cast<CFloat32VolumeData3DMemory*>(m_pReconstruction);
ASTRA_ASSERT(pReconMem);
const CProjectionGeometry3D* projgeom = pSinoMem->getGeometry();
const CVolumeGeometry3D& volgeom = *pReconMem->getGeometry();
if (m_bSIRTWeighting) {
astraCudaBP_SIRTWeighted(pReconMem->getData(),
pSinoMem->getDataConst(),
&volgeom, projgeom,
m_iGPUIndex, m_iVoxelSuperSampling);
} else {
#if 1
CCompositeGeometryManager cgm;
cgm.doBP(m_pProjector, pReconMem, pSinoMem);
#else
astraCudaBP(pReconMem->getData(), pSinoMem->getDataConst(),
&volgeom, projgeom,
m_iGPUIndex, m_iVoxelSuperSampling);
#endif
}
}
//---------------------------------------------------------------------------------------
// Initialize - Config
bool CCudaBackProjectionAlgorithm3D::initialize(const Config& _cfg)
{
ASTRA_ASSERT(_cfg.self);
ConfigStackCheck<CAlgorithm> CC("CudaBackProjectionAlgorithm3D", this, _cfg);
// if already initialized, clear first
if (m_bIsInitialized) {
clear();
}
// initialization of parent class
if (!CReconstructionAlgorithm3D::initialize(_cfg)) {
return false;
}
CCudaProjector3D* pCudaProjector = 0;
pCudaProjector = dynamic_cast<CCudaProjector3D*>(m_pProjector);
if (!pCudaProjector) {
// TODO: Report
}
m_iGPUIndex = (int)_cfg.self.getOptionNumerical("GPUindex", -1);
CC.markOptionParsed("GPUindex");
m_iVoxelSuperSampling = 1;
if (pCudaProjector)
m_iVoxelSuperSampling = pCudaProjector->getVoxelSuperSampling();
m_iVoxelSuperSampling = (int)_cfg.self.getOptionNumerical("VoxelSuperSampling", m_iVoxelSuperSampling);
CC.markOptionParsed("VoxelSuperSampling");
CFloat32ProjectionData3DMemory* pSinoMem = dynamic_cast<CFloat32ProjectionData3DMemory*>(m_pSinogram);
ASTRA_ASSERT(pSinoMem);
const CProjectionGeometry3D* projgeom = pSinoMem->getGeometry();
const CParallelProjectionGeometry3D* par3dgeom = dynamic_cast<const CParallelProjectionGeometry3D*>(projgeom);
const CParallelVecProjectionGeometry3D* parvec3dgeom = dynamic_cast<const CParallelVecProjectionGeometry3D*>(projgeom);
if (parvec3dgeom || par3dgeom) {
// This option is only supported for Par3D currently
m_bSIRTWeighting = _cfg.self.getOptionBool("SIRTWeighting", false);
CC.markOptionParsed("SIRTWeighting");
}
// success
m_bIsInitialized = _check();
return m_bIsInitialized;
}
//----------------------------------------------------------------------------------------
// Iterate
void CCudaBackProjectionAlgorithm3D::run(int _iNrIterations)
{
// check initialized
ASTRA_ASSERT(m_bIsInitialized);
CFloat32ProjectionData3DMemory* pSinoMem = dynamic_cast<CFloat32ProjectionData3DMemory*>(m_pSinogram);
ASTRA_ASSERT(pSinoMem);
CFloat32VolumeData3DMemory* pReconMem = dynamic_cast<CFloat32VolumeData3DMemory*>(m_pReconstruction);
ASTRA_ASSERT(pReconMem);
const CProjectionGeometry3D* projgeom = pSinoMem->getGeometry();
const CConeProjectionGeometry3D* conegeom = dynamic_cast<const CConeProjectionGeometry3D*>(projgeom);
const CParallelProjectionGeometry3D* par3dgeom = dynamic_cast<const CParallelProjectionGeometry3D*>(projgeom);
const CConeVecProjectionGeometry3D* conevecgeom = dynamic_cast<const CConeVecProjectionGeometry3D*>(projgeom);
const CParallelVecProjectionGeometry3D* parvec3dgeom = dynamic_cast<const CParallelVecProjectionGeometry3D*>(projgeom);
const CVolumeGeometry3D& volgeom = *pReconMem->getGeometry();
if (conegeom) {
astraCudaConeBP(pReconMem->getData(), pSinoMem->getDataConst(),
volgeom.getGridColCount(),
volgeom.getGridRowCount(),
volgeom.getGridSliceCount(),
conegeom->getProjectionCount(),
conegeom->getDetectorColCount(),
conegeom->getDetectorRowCount(),
conegeom->getOriginSourceDistance(),
conegeom->getOriginDetectorDistance(),
conegeom->getDetectorSpacingX(),
conegeom->getDetectorSpacingY(),
conegeom->getProjectionAngles(),
m_iGPUIndex, m_iVoxelSuperSampling);
} else if (par3dgeom) {
if (!m_bSIRTWeighting) {
astraCudaPar3DBP(pReconMem->getData(), pSinoMem->getDataConst(),
volgeom.getGridColCount(),
volgeom.getGridRowCount(),
volgeom.getGridSliceCount(),
par3dgeom->getProjectionCount(),
par3dgeom->getDetectorColCount(),
par3dgeom->getDetectorRowCount(),
par3dgeom->getDetectorSpacingX(),
par3dgeom->getDetectorSpacingY(),
par3dgeom->getProjectionAngles(),
m_iGPUIndex, m_iVoxelSuperSampling);
} else {
astraCudaPar3DBP_SIRTWeighted(pReconMem->getData(),
pSinoMem->getDataConst(),
volgeom.getGridColCount(),
volgeom.getGridRowCount(),
volgeom.getGridSliceCount(),
par3dgeom->getProjectionCount(),
par3dgeom->getDetectorColCount(),
par3dgeom->getDetectorRowCount(),
par3dgeom->getDetectorSpacingX(),
par3dgeom->getDetectorSpacingY(),
par3dgeom->getProjectionAngles(),
m_iGPUIndex, m_iVoxelSuperSampling);
}
} else if (parvec3dgeom) {
if (!m_bSIRTWeighting) {
astraCudaPar3DBP(pReconMem->getData(), pSinoMem->getDataConst(),
volgeom.getGridColCount(),
volgeom.getGridRowCount(),
volgeom.getGridSliceCount(),
parvec3dgeom->getProjectionCount(),
parvec3dgeom->getDetectorColCount(),
parvec3dgeom->getDetectorRowCount(),
parvec3dgeom->getProjectionVectors(),
m_iGPUIndex, m_iVoxelSuperSampling);
} else {
astraCudaPar3DBP_SIRTWeighted(pReconMem->getData(),
pSinoMem->getDataConst(),
volgeom.getGridColCount(),
volgeom.getGridRowCount(),
volgeom.getGridSliceCount(),
parvec3dgeom->getProjectionCount(),
parvec3dgeom->getDetectorColCount(),
parvec3dgeom->getDetectorRowCount(),
parvec3dgeom->getProjectionVectors(),
m_iGPUIndex, m_iVoxelSuperSampling);
}
} else if (conevecgeom) {
astraCudaConeBP(pReconMem->getData(), pSinoMem->getDataConst(),
volgeom.getGridColCount(),
volgeom.getGridRowCount(),
volgeom.getGridSliceCount(),
conevecgeom->getProjectionCount(),
conevecgeom->getDetectorColCount(),
conevecgeom->getDetectorRowCount(),
conevecgeom->getProjectionVectors(),
m_iGPUIndex, m_iVoxelSuperSampling);
} else {
ASTRA_ASSERT(false);
}
}
