C++ (Cpp) CFloat32VolumeData3DMemory::getGeometry Examples

Example #1

File: CudaBackProjectionAlgorithm3D.cpp Project: PhysikerErlangen/astra-toolbox

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

}

Example #2

File: CudaBackProjectionAlgorithm3D.cpp Project: malenie/astra-toolbox

//----------------------------------------------------------------------------------------
// 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);
	}

}