void CCudaFilteredBackProjectionAlgorithm::initializeFromProjector()
{
m_iPixelSuperSampling = 1;
m_iGPUIndex = -1;
// Projector
CCudaProjector2D* pCudaProjector = dynamic_cast<CCudaProjector2D*>(m_pProjector);
if (!pCudaProjector) {
if (m_pProjector) {
ASTRA_WARN("non-CUDA Projector2D passed to FBP_CUDA");
}
} else {
m_iPixelSuperSampling = pCudaProjector->getVoxelSuperSampling();
m_iGPUIndex = pCudaProjector->getGPUIndex();
}
}
//---------------------------------------------------------------------------------------
// Initialize - Config
bool CCudaReconstructionAlgorithm2D::initialize(const Config& _cfg)
{
ASTRA_ASSERT(_cfg.self);
ConfigStackCheck<CAlgorithm> CC("CudaReconstructionAlgorithm2D", this, _cfg);
// if already initialized, clear first
if (m_bIsInitialized) {
clear();
}
// Projector
XMLNode node = _cfg.self.getSingleNode("ProjectorId");
CCudaProjector2D* pCudaProjector = 0;
if (node) {
int id = boost::lexical_cast<int>(node.getContent());
CProjector2D *projector = CProjector2DManager::getSingleton().get(id);
pCudaProjector = dynamic_cast<CCudaProjector2D*>(projector);
if (!pCudaProjector) {
ASTRA_WARN("non-CUDA Projector2D passed");
}
}
CC.markNodeParsed("ProjectorId");
// sinogram data
node = _cfg.self.getSingleNode("ProjectionDataId");
ASTRA_CONFIG_CHECK(node, "CudaSirt2", "No ProjectionDataId tag specified.");
int id = boost::lexical_cast<int>(node.getContent());
m_pSinogram = dynamic_cast<CFloat32ProjectionData2D*>(CData2DManager::getSingleton().get(id));
CC.markNodeParsed("ProjectionDataId");
// reconstruction data
node = _cfg.self.getSingleNode("ReconstructionDataId");
ASTRA_CONFIG_CHECK(node, "CudaSirt2", "No ReconstructionDataId tag specified.");
id = boost::lexical_cast<int>(node.getContent());
m_pReconstruction = dynamic_cast<CFloat32VolumeData2D*>(CData2DManager::getSingleton().get(id));
CC.markNodeParsed("ReconstructionDataId");
// fixed mask
if (_cfg.self.hasOption("ReconstructionMaskId")) {
m_bUseReconstructionMask = true;
id = boost::lexical_cast<int>(_cfg.self.getOption("ReconstructionMaskId"));
m_pReconstructionMask = dynamic_cast<CFloat32VolumeData2D*>(CData2DManager::getSingleton().get(id));
ASTRA_CONFIG_CHECK(m_pReconstructionMask, "CudaReconstruction2D", "Invalid ReconstructionMaskId.");
}
CC.markOptionParsed("ReconstructionMaskId");
// fixed mask
if (_cfg.self.hasOption("SinogramMaskId")) {
m_bUseSinogramMask = true;
id = boost::lexical_cast<int>(_cfg.self.getOption("SinogramMaskId"));
m_pSinogramMask = dynamic_cast<CFloat32ProjectionData2D*>(CData2DManager::getSingleton().get(id));
ASTRA_CONFIG_CHECK(m_pSinogramMask, "CudaReconstruction2D", "Invalid SinogramMaskId.");
}
CC.markOptionParsed("SinogramMaskId");
// Constraints - NEW
if (_cfg.self.hasOption("MinConstraint")) {
m_bUseMinConstraint = true;
m_fMinValue = _cfg.self.getOptionNumerical("MinConstraint", 0.0f);
CC.markOptionParsed("MinConstraint");
} else {
// Constraint - OLD
m_bUseMinConstraint = _cfg.self.getOptionBool("UseMinConstraint", false);
CC.markOptionParsed("UseMinConstraint");
if (m_bUseMinConstraint) {
m_fMinValue = _cfg.self.getOptionNumerical("MinConstraintValue", 0.0f);
CC.markOptionParsed("MinConstraintValue");
}
}
if (_cfg.self.hasOption("MaxConstraint")) {
m_bUseMaxConstraint = true;
m_fMaxValue = _cfg.self.getOptionNumerical("MaxConstraint", 255.0f);
CC.markOptionParsed("MaxConstraint");
} else {
// Constraint - OLD
m_bUseMaxConstraint = _cfg.self.getOptionBool("UseMaxConstraint", false);
CC.markOptionParsed("UseMaxConstraint");
if (m_bUseMaxConstraint) {
m_fMaxValue = _cfg.self.getOptionNumerical("MaxConstraintValue", 0.0f);
CC.markOptionParsed("MaxConstraintValue");
}
}
// GPU number
m_iGPUIndex = (int)_cfg.self.getOptionNumerical("GPUindex", -1);
m_iGPUIndex = (int)_cfg.self.getOptionNumerical("GPUIndex", m_iGPUIndex);
CC.markOptionParsed("GPUindex");
if (!_cfg.self.hasOption("GPUindex"))
CC.markOptionParsed("GPUIndex");
// Supersampling factors
m_iDetectorSuperSampling = 1;
m_iPixelSuperSampling = 1;
if (pCudaProjector) {
// New interface
m_iDetectorSuperSampling = pCudaProjector->getDetectorSuperSampling();
m_iPixelSuperSampling = pCudaProjector->getVoxelSuperSampling();
}
// Deprecated options
m_iDetectorSuperSampling = (int)_cfg.self.getOptionNumerical("DetectorSuperSampling", m_iDetectorSuperSampling);
m_iPixelSuperSampling = (int)_cfg.self.getOptionNumerical("PixelSuperSampling", m_iPixelSuperSampling);
CC.markOptionParsed("DetectorSuperSampling");
CC.markOptionParsed("PixelSuperSampling");
return _check();
}
bool CCudaFilteredBackProjectionAlgorithm::initialize(const Config& _cfg)
{
ASTRA_ASSERT(_cfg.self);
ConfigStackCheck<CAlgorithm> CC("CudaFilteredBackProjectionAlgorithm", this, _cfg);
// if already initialized, clear first
if (m_bIsInitialized)
{
clear();
}
// Projector
XMLNode node = _cfg.self.getSingleNode("ProjectorId");
CCudaProjector2D* pCudaProjector = 0;
if (node) {
int id = boost::lexical_cast<int>(node.getContent());
CProjector2D *projector = CProjector2DManager::getSingleton().get(id);
pCudaProjector = dynamic_cast<CCudaProjector2D*>(projector);
if (!pCudaProjector) {
ASTRA_WARN("non-CUDA Projector2D passed");
}
}
CC.markNodeParsed("ProjectorId");
// sinogram data
node = _cfg.self.getSingleNode("ProjectionDataId");
ASTRA_CONFIG_CHECK(node, "CudaFBP", "No ProjectionDataId tag specified.");
int id = boost::lexical_cast<int>(node.getContent());
m_pSinogram = dynamic_cast<CFloat32ProjectionData2D*>(CData2DManager::getSingleton().get(id));
CC.markNodeParsed("ProjectionDataId");
// reconstruction data
node = _cfg.self.getSingleNode("ReconstructionDataId");
ASTRA_CONFIG_CHECK(node, "CudaFBP", "No ReconstructionDataId tag specified.");
id = boost::lexical_cast<int>(node.getContent());
m_pReconstruction = dynamic_cast<CFloat32VolumeData2D*>(CData2DManager::getSingleton().get(id));
CC.markNodeParsed("ReconstructionDataId");
// filter type
node = _cfg.self.getSingleNode("FilterType");
if (node)
{
m_eFilter = _convertStringToFilter(node.getContent().c_str());
}
else
{
m_eFilter = FILTER_RAMLAK;
}
CC.markNodeParsed("FilterType");
// filter
node = _cfg.self.getSingleNode("FilterSinogramId");
if (node)
{
id = boost::lexical_cast<int>(node.getContent());
const CFloat32ProjectionData2D * pFilterData = dynamic_cast<CFloat32ProjectionData2D*>(CData2DManager::getSingleton().get(id));
m_iFilterWidth = pFilterData->getGeometry()->getDetectorCount();
int iFilterProjectionCount = pFilterData->getGeometry()->getProjectionAngleCount();
m_pfFilter = new float[m_iFilterWidth * iFilterProjectionCount];
memcpy(m_pfFilter, pFilterData->getDataConst(), sizeof(float) * m_iFilterWidth * iFilterProjectionCount);
}
else
{
m_iFilterWidth = 0;
m_pfFilter = NULL;
}
CC.markNodeParsed("FilterSinogramId"); // TODO: Only for some types!
// filter parameter
node = _cfg.self.getSingleNode("FilterParameter");
if (node)
{
float fParameter = boost::lexical_cast<float>(node.getContent());
m_fFilterParameter = fParameter;
}
else
{
m_fFilterParameter = -1.0f;
}
CC.markNodeParsed("FilterParameter"); // TODO: Only for some types!
// D value
node = _cfg.self.getSingleNode("FilterD");
if (node)
{
float fD = boost::lexical_cast<float>(node.getContent());
m_fFilterD = fD;
}
else
{
m_fFilterD = 1.0f;
}
CC.markNodeParsed("FilterD"); // TODO: Only for some types!
// GPU number
m_iGPUIndex = (int)_cfg.self.getOptionNumerical("GPUindex", -1);
CC.markOptionParsed("GPUindex");
m_iPixelSuperSampling = 1;
if (pCudaProjector) {
// New interface
m_iPixelSuperSampling = pCudaProjector->getVoxelSuperSampling();
}
// Deprecated options
m_iPixelSuperSampling = (int)_cfg.self.getOptionNumerical("PixelSuperSampling", m_iPixelSuperSampling);
CC.markOptionParsed("PixelSuperSampling");
// Fan beam short scan mode
if (m_pSinogram && dynamic_cast<CFanFlatProjectionGeometry2D*>(m_pSinogram->getGeometry())) {
m_bShortScan = (int)_cfg.self.getOptionBool("ShortScan", false);
CC.markOptionParsed("ShortScan");
}
m_pFBP = new AstraFBP;
m_bAstraFBPInit = false;
// success
m_bIsInitialized = true;
return m_bIsInitialized;
}