C++ (Cpp) CFloat32ProjectionData3DMemory::getDataConst示例

示例#1

文件： CudaBackProjectionAlgorithm3D.cpp 项目： 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
	}

}

示例#2

文件： CudaFDKAlgorithm3D.cpp 项目： PhysikerErlangen/astra-toolbox

//----------------------------------------------------------------------------------------
// Iterate
void CCudaFDKAlgorithm3D::run(int _iNrIterations)
{
	// check initialized
	ASTRA_ASSERT(m_bIsInitialized);

	const CProjectionGeometry3D* projgeom = m_pSinogram->getGeometry();
	const CConeProjectionGeometry3D* conegeom = dynamic_cast<const CConeProjectionGeometry3D*>(projgeom);
	const CVolumeGeometry3D& volgeom = *m_pReconstruction->getGeometry();

	ASTRA_ASSERT(conegeom);

	CFloat32ProjectionData3DMemory* pSinoMem = dynamic_cast<CFloat32ProjectionData3DMemory*>(m_pSinogram);
	ASTRA_ASSERT(pSinoMem);
	CFloat32VolumeData3DMemory* pReconMem = dynamic_cast<CFloat32VolumeData3DMemory*>(m_pReconstruction);
	ASTRA_ASSERT(pReconMem);


	bool ok = true;

	ok = astraCudaFDK(pReconMem->getData(), pSinoMem->getDataConst(),
	                  &volgeom, conegeom,
	                  m_bShortScan, m_iGPUIndex, m_iVoxelSuperSampling);

	ASTRA_ASSERT(ok);

}

示例#3

文件： CudaSirtAlgorithm3D.cpp 项目： iceseismic/astra-toolbox

//----------------------------------------------------------------------------------------
// Iterate
void CCudaSirtAlgorithm3D::run(int _iNrIterations)
{
	// check initialized
	ASTRA_ASSERT(m_bIsInitialized);

	const CProjectionGeometry3D* projgeom = m_pSinogram->getGeometry();
	const CVolumeGeometry3D& volgeom = *m_pReconstruction->getGeometry();

	bool ok = true;

	if (!m_bAstraSIRTInit) {

		ok &= m_pSirt->setGPUIndex(m_iGPUIndex);

		ok &= m_pSirt->setGeometry(&volgeom, projgeom);

		ok &= m_pSirt->enableSuperSampling(m_iVoxelSuperSampling, m_iDetectorSuperSampling);

		if (m_bUseReconstructionMask)
			ok &= m_pSirt->enableVolumeMask();
		if (m_bUseSinogramMask)
			ok &= m_pSirt->enableSinogramMask();

		ASTRA_ASSERT(ok);

		ok &= m_pSirt->init();

		ASTRA_ASSERT(ok);

		m_bAstraSIRTInit = true;

	}

	CFloat32ProjectionData3DMemory* pSinoMem = dynamic_cast<CFloat32ProjectionData3DMemory*>(m_pSinogram);
	ASTRA_ASSERT(pSinoMem);

	ok = m_pSirt->setSinogram(pSinoMem->getDataConst(), m_pSinogram->getGeometry()->getDetectorColCount());

	ASTRA_ASSERT(ok);

	if (m_bUseReconstructionMask) {
		CFloat32VolumeData3DMemory* pRMaskMem = dynamic_cast<CFloat32VolumeData3DMemory*>(m_pReconstructionMask);
		ASTRA_ASSERT(pRMaskMem);
		ok &= m_pSirt->setVolumeMask(pRMaskMem->getDataConst(), volgeom.getGridColCount());
	}
	if (m_bUseSinogramMask) {
		CFloat32ProjectionData3DMemory* pSMaskMem = dynamic_cast<CFloat32ProjectionData3DMemory*>(m_pSinogramMask);
		ASTRA_ASSERT(pSMaskMem);
		ok &= m_pSirt->setSinogramMask(pSMaskMem->getDataConst(), m_pSinogramMask->getGeometry()->getDetectorColCount());
	}

	CFloat32VolumeData3DMemory* pReconMem = dynamic_cast<CFloat32VolumeData3DMemory*>(m_pReconstruction);
	ASTRA_ASSERT(pReconMem);
	ok &= m_pSirt->setStartReconstruction(pReconMem->getDataConst(),
	                                      volgeom.getGridColCount());

	ASTRA_ASSERT(ok);

	if (m_bUseMinConstraint)
		ok &= m_pSirt->setMinConstraint(m_fMinValue);
	if (m_bUseMaxConstraint)
		ok &= m_pSirt->setMaxConstraint(m_fMaxValue);

	ok &= m_pSirt->iterate(_iNrIterations);
	ASTRA_ASSERT(ok);

	ok &= m_pSirt->getReconstruction(pReconMem->getData(),
	                                 volgeom.getGridColCount());
	ASTRA_ASSERT(ok);


}

示例#4

文件： CudaBackProjectionAlgorithm3D.cpp 项目： 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);
	}

}