blob: 21632ebcfa79c5a7c71d3bda31f5830ca5c1ea57 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
/*
-----------------------------------------------------------------------
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 <http://www.gnu.org/licenses/>.
-----------------------------------------------------------------------
$Id$
*/
#ifndef _INC_ASTRA_ALGORITHM
#define _INC_ASTRA_ALGORITHM
#include <boost/any.hpp>
#include "Globals.h"
#include "Config.h"
namespace astra {
/**
* This class contains the interface for an algorithm implementation.
*/
class _AstraExport CAlgorithm {
public:
/** Default constructor, containing no code.
*/
CAlgorithm();
/** Destructor.
*/
virtual ~CAlgorithm();
/** Initialize the algorithm with a config object.
*
* @param _cfg Configuration Object
* @return initialization successful?
*/
virtual bool initialize(const Config& _cfg) = 0;
/** Get all information parameters
*
* @return map with all boost::any object
*/
virtual map<string,boost::any> getInformation();
/** Get a single piece of information represented as a boost::any
*
* @param _sIdentifier identifier string to specify which piece of information you want
* @return boost::any object
*/
virtual boost::any getInformation(std::string _sIdentifier);
/** Perform a number of iterations.
*
* @param _iNrIterations amount of iterations to perform.
*/
virtual void run(int _iNrIterations = 0) = 0;
/** Has this class been initialized?
*
* @return initialized
*/
bool isInitialized();
/** get a description of the class
*
* @return description string
*/
virtual std::string description() const;
/** Set the GPU Index to run on.
* TODO: Move this from CAlgorithm to a Context-like class
*/
virtual void setGPUIndex(int /*_iGPUIndex*/) { };
/** Signal the algorithm it should abort soon.
* This is intended to be called from a different thread
* while the algorithm is running. There are no guarantees
* on how soon the algorithm will abort. The state of the
* algorithm object will be consistent (so it is safe to delete it
* normally afterwards), but the algorithm's output is undefined.
*
* Note that specific algorithms may give guarantees on their
* state after an abort. Check their documentation for details.
*/
virtual void signalAbort() { m_bShouldAbort = true; }
protected:
//< Has this class been initialized?
bool m_bIsInitialized;
//< If this is set, the algorithm should try to abort as soon as possible.
volatile bool m_bShouldAbort;
private:
/**
* Private copy constructor to prevent CAlgorithms from being copied.
*/
CAlgorithm(const CAlgorithm&);
/**
* Private assignment operator to prevent CAlgorithms from being copied.
*/
CAlgorithm& operator=(const CAlgorithm&);
//< For Config unused argument checking
ConfigCheckData* configCheckData;
friend class ConfigStackCheck<CAlgorithm>;
};
// inline functions
inline std::string CAlgorithm::description() const { return "Algorithm"; };
inline bool CAlgorithm::isInitialized() { return m_bIsInitialized; }
} // end namespace
#endif
|
