From b2fc6c70434674d74551c3a6c01ffb3233499312 Mon Sep 17 00:00:00 2001 From: Willem Jan Palenstijn Date: Mon, 1 Jul 2013 22:34:11 +0000 Subject: Update version to 1.3 --- src/ReconstructionAlgorithm2D.cpp | 275 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 275 insertions(+) create mode 100644 src/ReconstructionAlgorithm2D.cpp (limited to 'src/ReconstructionAlgorithm2D.cpp') diff --git a/src/ReconstructionAlgorithm2D.cpp b/src/ReconstructionAlgorithm2D.cpp new file mode 100644 index 0000000..ea693e3 --- /dev/null +++ b/src/ReconstructionAlgorithm2D.cpp @@ -0,0 +1,275 @@ +/* +----------------------------------------------------------------------- +Copyright 2012 iMinds-Vision Lab, University of Antwerp + +Contact: astra@ua.ac.be +Website: http://astra.ua.ac.be + + +This file is part of the +All Scale Tomographic Reconstruction Antwerp Toolbox ("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 . + +----------------------------------------------------------------------- +$Id$ +*/ + +#include "astra/ReconstructionAlgorithm2D.h" + +#include + +#include "astra/AstraObjectManager.h" + +using namespace std; + +namespace astra { + +//---------------------------------------------------------------------------------------- +// Constructor +CReconstructionAlgorithm2D::CReconstructionAlgorithm2D() +{ + _clear(); +} + +//---------------------------------------------------------------------------------------- +// Destructor +CReconstructionAlgorithm2D::~CReconstructionAlgorithm2D() +{ + clear(); +} + +//--------------------------------------------------------------------------------------- +// Clear - Constructors +void CReconstructionAlgorithm2D::_clear() +{ + m_pProjector = NULL; + m_pSinogram = NULL; + m_pReconstruction = NULL; + m_bUseMinConstraint = false; + m_fMinValue = 0.0f; + m_bUseMaxConstraint = false; + m_fMaxValue = 0.0f; + m_bUseReconstructionMask = false; + m_pReconstructionMask = NULL; + m_bUseSinogramMask = false; + m_pSinogramMask = NULL; + m_bIsInitialized = false; +} + +//--------------------------------------------------------------------------------------- +// Clear - Public +void CReconstructionAlgorithm2D::clear() +{ + // Nothing to delete, so just _clear() + _clear(); +} + +//--------------------------------------------------------------------------------------- +// Initialize - Config +bool CReconstructionAlgorithm2D::initialize(const Config& _cfg) +{ + ASTRA_ASSERT(_cfg.self); + ConfigStackCheck CC("ReconstructionAlgorithm2D", this, _cfg); + + // projector + XMLNode* node = _cfg.self->getSingleNode("ProjectorId"); + ASTRA_CONFIG_CHECK(node, "Reconstruction2D", "No ProjectorId tag specified."); + int id = boost::lexical_cast(node->getContent()); + m_pProjector = CProjector2DManager::getSingleton().get(id); + ASTRA_DELETE(node); + CC.markNodeParsed("ProjectorId"); + + // sinogram data + node = _cfg.self->getSingleNode("ProjectionDataId"); + ASTRA_CONFIG_CHECK(node, "Reconstruction2D", "No ProjectionDataId tag specified."); + id = boost::lexical_cast(node->getContent()); + m_pSinogram = dynamic_cast(CData2DManager::getSingleton().get(id)); + ASTRA_DELETE(node); + CC.markNodeParsed("ProjectionDataId"); + + // reconstruction data + node = _cfg.self->getSingleNode("ReconstructionDataId"); + ASTRA_CONFIG_CHECK(node, "Reconstruction2D", "No ReconstructionDataId tag specified."); + id = boost::lexical_cast(node->getContent()); + m_pReconstruction = dynamic_cast(CData2DManager::getSingleton().get(id)); + ASTRA_DELETE(node); + CC.markNodeParsed("ReconstructionDataId"); + + // fixed mask + if (_cfg.self->hasOption("ReconstructionMaskId")) { + m_bUseReconstructionMask = true; + id = boost::lexical_cast(_cfg.self->getOption("ReconstructionMaskId")); + m_pReconstructionMask = dynamic_cast(CData2DManager::getSingleton().get(id)); + } + CC.markOptionParsed("ReconstructionMaskId"); + + // fixed mask + if (_cfg.self->hasOption("SinogramMaskId")) { + m_bUseSinogramMask = true; + id = boost::lexical_cast(_cfg.self->getOption("SinogramMaskId")); + m_pSinogramMask = dynamic_cast(CData2DManager::getSingleton().get(id)); + } + 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"); + } + } + + // return success + return _check(); +} + +//---------------------------------------------------------------------------------------- +// Initialize - C++ +bool CReconstructionAlgorithm2D::initialize(CProjector2D* _pProjector, + CFloat32ProjectionData2D* _pSinogram, + CFloat32VolumeData2D* _pReconstruction) +{ + m_pProjector = _pProjector; + m_pSinogram = _pSinogram; + m_pReconstruction = _pReconstruction; + + // return success + return _check(); +} + +//--------------------------------------------------------------------------------------- +// Set Constraints +void CReconstructionAlgorithm2D::setConstraints(bool _bUseMin, float32 _fMinValue, bool _bUseMax, float32 _fMaxValue) +{ + m_bUseMinConstraint = _bUseMin; + m_fMinValue = _fMinValue; + m_bUseMaxConstraint = _bUseMax; + m_fMaxValue = _fMaxValue; +} + +//---------------------------------------------------------------------------------------- +// Set Fixed Reconstruction Mask +void CReconstructionAlgorithm2D::setReconstructionMask(CFloat32VolumeData2D* _pMask, bool _bEnable) +{ + // TODO: check geometry matches volume + m_bUseReconstructionMask = _bEnable; + m_pReconstructionMask = _pMask; + if (m_pReconstructionMask == NULL) { + m_bUseReconstructionMask = false; + } +} + +//---------------------------------------------------------------------------------------- +// Set Fixed Sinogram Mask +void CReconstructionAlgorithm2D::setSinogramMask(CFloat32ProjectionData2D* _pMask, bool _bEnable) +{ + // TODO: check geometry matches sinogram + m_bUseSinogramMask = _bEnable; + m_pSinogramMask = _pMask; + if (m_pSinogramMask == NULL) { + m_bUseSinogramMask = false; + } +}//---------------------------------------------------------------------------------------- +// Check +bool CReconstructionAlgorithm2D::_check() +{ + // check pointers + ASTRA_CONFIG_CHECK(m_pProjector, "Reconstruction2D", "Invalid Projector Object."); + ASTRA_CONFIG_CHECK(m_pSinogram, "Reconstruction2D", "Invalid Projection Data Object."); + ASTRA_CONFIG_CHECK(m_pReconstruction, "Reconstruction2D", "Invalid Reconstruction Data Object."); + + // check initializations + ASTRA_CONFIG_CHECK(m_pProjector->isInitialized(), "Reconstruction2D", "Projector Object Not Initialized."); + ASTRA_CONFIG_CHECK(m_pSinogram->isInitialized(), "Reconstruction2D", "Projection Data Object Not Initialized."); + ASTRA_CONFIG_CHECK(m_pReconstruction->isInitialized(), "Reconstruction2D", "Reconstruction Data Object Not Initialized."); + + // check compatibility between projector and data classes + ASTRA_CONFIG_CHECK(m_pSinogram->getGeometry()->isEqual(m_pProjector->getProjectionGeometry()), "Reconstruction2D", "Projection Data not compatible with the specified Projector."); + ASTRA_CONFIG_CHECK(m_pReconstruction->getGeometry()->isEqual(m_pProjector->getVolumeGeometry()), "Reconstruction2D", "Reconstruction Data not compatible with the specified Projector."); + + // success + return true; +} + +//--------------------------------------------------------------------------------------- +// Information - All +map CReconstructionAlgorithm2D::getInformation() +{ + map res; + res["ProjectorId"] = getInformation("ProjectorId"); + res["ProjectionDataId"] = getInformation("ProjectionDataId"); + res["ReconstructionDataId"] = getInformation("ReconstructionDataId"); + res["UseMinConstraint"] = getInformation("UseMinConstraint"); + res["MinConstraintValue"] = getInformation("MinConstraintValue"); + res["UseMaxConstraint"] = getInformation("UseMaxConstraint"); + res["MaxConstraintValue"] = getInformation("MaxConstraintValue"); + res["ReconstructionMaskId"] = getInformation("ReconstructionMaskId"); + return mergeMap(CAlgorithm::getInformation(), res); +}; + +//--------------------------------------------------------------------------------------- +// Information - Specific +boost::any CReconstructionAlgorithm2D::getInformation(std::string _sIdentifier) +{ + if (_sIdentifier == "UseMinConstraint") { return m_bUseMinConstraint ? string("yes") : string("no"); } + if (_sIdentifier == "MinConstraintValue") { return m_fMinValue; } + if (_sIdentifier == "UseMaxConstraint") { return m_bUseMaxConstraint ? string("yes") : string("no"); } + if (_sIdentifier == "MaxConstraintValue") { return m_fMaxValue; } + if (_sIdentifier == "ProjectorId") { + int iIndex = CProjector2DManager::getSingleton().getIndex(m_pProjector); + if (iIndex != 0) return iIndex; + return std::string("not in manager"); + } + if (_sIdentifier == "ProjectionDataId") { + int iIndex = CData2DManager::getSingleton().getIndex(m_pSinogram); + if (iIndex != 0) return iIndex; + return std::string("not in manager"); + } + if (_sIdentifier == "ReconstructionDataId") { + int iIndex = CData2DManager::getSingleton().getIndex(m_pReconstruction); + if (iIndex != 0) return iIndex; + return std::string("not in manager"); + } + if (_sIdentifier == "ReconstructionMaskId") { + if (!m_bUseReconstructionMask) return string("not used"); + int iIndex = CData2DManager::getSingleton().getIndex(m_pReconstructionMask); + if (iIndex != 0) return iIndex; + return std::string("not in manager"); + } + return CAlgorithm::getInformation(_sIdentifier); +}; +//---------------------------------------------------------------------------------------- + +} // namespace astra -- cgit v1.2.3