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 --- include/astra/AstraObjectManager.h | 290 +++++++++++++++++++++++++++++++++++++ 1 file changed, 290 insertions(+) create mode 100644 include/astra/AstraObjectManager.h (limited to 'include/astra/AstraObjectManager.h') diff --git a/include/astra/AstraObjectManager.h b/include/astra/AstraObjectManager.h new file mode 100644 index 0000000..afb6312 --- /dev/null +++ b/include/astra/AstraObjectManager.h @@ -0,0 +1,290 @@ +/* +----------------------------------------------------------------------- +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$ +*/ + +#ifndef _INC_ASTRA_ASTRAOBJECTMANAGER +#define _INC_ASTRA_ASTRAOBJECTMANAGER + +#include +#include + +#include "Globals.h" +#include "Singleton.h" +#include "Projector2D.h" +#include "Projector3D.h" +#include "Float32Data2D.h" +#include "Float32Data3D.h" +#include "SparseMatrix.h" +#include "Algorithm.h" + +namespace astra { + +/** + * This class contains functionality to store objects. A unique index handle + * will be assigned to each data object by which it can be accessed in the + * future. Indices are always >= 1. + * + * We store them in a special common base class to make indices unique + * among all ObjectManagers. + */ + + +class CAstraIndexManager { +protected: + /** The index of the previously stored data object. + */ + static int m_iPreviousIndex; +}; + + +template +class CAstraObjectManager : public Singleton >, CAstraIndexManager { + +public: + + /** Default constructor. + */ + CAstraObjectManager(); + + /** Destructor. + */ + ~CAstraObjectManager(); + + /** Store the object in the manager and assign a unique index handle to it. + * + * @param _pObject A pointer to the object that should be stored. + * @return The index of the stored data object. If the index in negative, an error occurred + * and the object was NOT stored. + */ + int store(T* _pObject); + + /** Does the manager contain an object with the index _iIndex? + * + * @param _iIndex Index handle to the data object in question. + * @return True if the manager contains an object with the index handle _iIndex. + */ + bool hasIndex(int _iIndex) const; + + /** Fetch the object to which _iIndex refers to. + * + * @param _iIndex Index handle to the data object in question. + * @return Pointer to the stored data object. A null pointer is returned if no object with index _iIndex is found. + */ + T* get(int _iIndex) const; + + /** Delete an object that was previously stored. This actually DELETES the objecy. Therefore, after this + * function call, the object in question will have passed on. It will be no more. It will have ceased + * to be. It will be expired and will go to meet its maker. Bereft of life, it will rest in peace. + * It will be an EX-OBJECT. + * + * @param _iIndex Index handle to the object in question. + * @return Error code. 0 for success. + */ + void remove(int _iIndex); + + /** Get the index of the object, zero if it doesn't exist. + * + * @param _pObject The data object. + * @return Index of the stored object, 0 if not found. + */ + int getIndex(const T* _pObject) const; + + /** Clear all data. This will also delete all the content of each object. + */ + void clear(); + + /** Get info. + */ + std::string info(); + +protected: + + /** Map each data object to a unique index. + */ + std::map m_mIndexToObject; + +}; + +//---------------------------------------------------------------------------------------- +// Constructor +template +CAstraObjectManager::CAstraObjectManager() +{ +} + +//---------------------------------------------------------------------------------------- +// Destructor +template +CAstraObjectManager::~CAstraObjectManager() +{ + +} + +//---------------------------------------------------------------------------------------- +// store data +template +int CAstraObjectManager::store(T* _pDataObject) +{ + m_iPreviousIndex++; + m_mIndexToObject[m_iPreviousIndex] = _pDataObject; + return m_iPreviousIndex; +} + +//---------------------------------------------------------------------------------------- +// has data? +template +bool CAstraObjectManager::hasIndex(int _iIndex) const +{ + typename map::const_iterator it = m_mIndexToObject.find(_iIndex); + return it != m_mIndexToObject.end(); +} + +//---------------------------------------------------------------------------------------- +// get data +template +T* CAstraObjectManager::get(int _iIndex) const +{ + typename map::const_iterator it = m_mIndexToObject.find(_iIndex); + if (it != m_mIndexToObject.end()) + return it->second; + else + return 0; +} + +//---------------------------------------------------------------------------------------- +// delete data +template +void CAstraObjectManager::remove(int _iIndex) +{ + if (!hasIndex(_iIndex)) { + return; + } + // find data + typename map::iterator it = m_mIndexToObject.find(_iIndex); + // delete data + delete (*it).second; + // delete from map + m_mIndexToObject.erase(it); +} + +//---------------------------------------------------------------------------------------- +// Get Index +template +int CAstraObjectManager::getIndex(const T* _pObject) const +{ + for (typename map::const_iterator it = m_mIndexToObject.begin(); it != m_mIndexToObject.end(); it++) { + if ((*it).second == _pObject) return (*it).first; + } + return 0; +} + + +//---------------------------------------------------------------------------------------- +// clear +template +void CAstraObjectManager::clear() +{ + for (typename map::iterator it = m_mIndexToObject.begin(); it != m_mIndexToObject.end(); it++) { + // delete data + delete (*it).second; + (*it).second = 0; + } + + m_mIndexToObject.clear(); +} + +//---------------------------------------------------------------------------------------- +// Print info to string +template +std::string CAstraObjectManager::info() { + std::stringstream res; + res << "id init description" << std::endl; + res << "-----------------------------------------" << std::endl; + for (typename map::iterator it = m_mIndexToObject.begin(); it != m_mIndexToObject.end(); it++) { + res << (*it).first << " \t"; + T* pObject = m_mIndexToObject[(*it).first]; + if (pObject->isInitialized()) { + res << "v "; + } else { + res << "x "; + } + res << pObject->description() << endl; + } + res << "-----------------------------------------" << std::endl; + return res.str(); +} + + + +//---------------------------------------------------------------------------------------- +// Create the necessary Object Managers +/** + * This class contains functionality to store 2D projector objects. A unique index handle will be + * assigned to each data object by which it can be accessed in the future. + * Indices are always >= 1. + */ +class _AstraExport CProjector2DManager : public CAstraObjectManager{}; + +/** + * This class contains functionality to store 3D projector objects. A unique index handle will be + * assigned to each data object by which it can be accessed in the future. + * Indices are always >= 1. + */ +class _AstraExport CProjector3DManager : public CAstraObjectManager{}; + +/** + * This class contains functionality to store 2D data objects. A unique index handle will be + * assigned to each data object by which it can be accessed in the future. + * Indices are always >= 1. + */ +class _AstraExport CData2DManager : public CAstraObjectManager{}; + +/** + * This class contains functionality to store 3D data objects. A unique index handle will be + * assigned to each data object by which it can be accessed in the future. + * Indices are always >= 1. + */ +class _AstraExport CData3DManager : public CAstraObjectManager{}; + +/** + * This class contains functionality to store algorithm objects. A unique index handle will be + * assigned to each data object by which it can be accessed in the future. + * Indices are always >= 1. + */ +class _AstraExport CAlgorithmManager : public CAstraObjectManager{}; + +/** + * This class contains functionality to store matrix objects. A unique index handle will be + * assigned to each data object by which it can be accessed in the future. + * Indices are always >= 1. + */ +class _AstraExport CMatrixManager : public CAstraObjectManager{}; + + +} // end namespace + +#endif -- cgit v1.2.3