forked from Kitware/VTK
-
Notifications
You must be signed in to change notification settings - Fork 0
/
vtkStreamingDemandDrivenPipeline.h
324 lines (279 loc) · 10.8 KB
/
vtkStreamingDemandDrivenPipeline.h
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
/*=========================================================================
Program: Visualization Toolkit
Module: vtkStreamingDemandDrivenPipeline.h
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
/**
* @class vtkStreamingDemandDrivenPipeline
* @brief Executive supporting partial updates.
*
* vtkStreamingDemandDrivenPipeline is an executive that supports
* updating only a portion of the data set in the pipeline. This is
* the style of pipeline update that is provided by the old-style VTK
* 4.x pipeline. Instead of always updating an entire data set, this
* executive supports asking for pieces or sub-extents.
*/
#ifndef vtkStreamingDemandDrivenPipeline_h
#define vtkStreamingDemandDrivenPipeline_h
#include "vtkCommonExecutionModelModule.h" // For export macro
#include "vtkDemandDrivenPipeline.h"
#define VTK_UPDATE_EXTENT_COMBINE 1
#define VTK_UPDATE_EXTENT_REPLACE 2
class vtkInformationDoubleKey;
class vtkInformationDoubleVectorKey;
class vtkInformationIdTypeKey;
class vtkInformationIntegerKey;
class vtkInformationIntegerVectorKey;
class vtkInformationIterator;
class vtkInformationObjectBaseKey;
class vtkInformationStringKey;
class vtkInformationStringKey;
class vtkInformationUnsignedLongKey;
class VTKCOMMONEXECUTIONMODEL_EXPORT vtkStreamingDemandDrivenPipeline
: public vtkDemandDrivenPipeline
{
public:
static vtkStreamingDemandDrivenPipeline* New();
vtkTypeMacro(vtkStreamingDemandDrivenPipeline, vtkDemandDrivenPipeline);
void PrintSelf(ostream& os, vtkIndent indent) override;
/**
* Generalized interface for asking the executive to fulfill update
* requests.
*/
vtkTypeBool ProcessRequest(
vtkInformation* request, vtkInformationVector** inInfo, vtkInformationVector* outInfo) override;
///@{
/**
* Bring the outputs up-to-date.
*/
vtkTypeBool Update() override;
vtkTypeBool Update(int port) override;
virtual vtkTypeBool UpdateWholeExtent();
///@}
/**
* This method enables the passing of data requests to the algorithm
* to be used during execution (in addition to bringing a particular
* port up-to-date). The requests argument should contain an information
* object for each port that requests need to be passed. For each
* of those, the pipeline will copy all keys to the output information
* before execution. This is equivalent to:
* \verbatim
* executive->UpdateInformation();
* for (int i=0; i<executive->GetNumberOfOutputPorts(); i++)
* {
* vtkInformation* portRequests = requests->GetInformationObject(i);
* if (portRequests)
* {
* executive->GetOutputInformation(i)->Append(portRequests);
* }
* }
* executive->Update();
* \endverbatim
* Available requests include UPDATE_PIECE_NUMBER(), UPDATE_NUMBER_OF_PIECES()
* UPDATE_EXTENT() etc etc.
*/
virtual vtkTypeBool Update(int port, vtkInformationVector* requests);
/**
* Propagate the update request from the given output port back
* through the pipeline. Should be called only when information is
* up to date.
*/
int PropagateUpdateExtent(int outputPort);
///@{
/**
* Propagate time through the pipeline. this is a special pass
* only necessary if there is temporal meta data that must be updated
*/
int PropagateTime(int outputPort);
int UpdateTimeDependentInformation(int outputPort);
///@}
///@{
/**
* Set/Get the whole extent of an output port. The whole extent is
* meta data for structured data sets. It gets set by the algorithm
* during the update information pass.
*/
static int SetWholeExtent(vtkInformation*, int extent[6]);
static void GetWholeExtent(vtkInformation*, int extent[6]);
static int* GetWholeExtent(vtkInformation*) VTK_SIZEHINT(6);
///@}
///@{
/**
* This request flag indicates whether the requester can handle more
* data than requested for the given port. Right now it is used in
* vtkImageData. Image filters can return more data than requested.
* The consumer cannot handle this (i.e. DataSetToDataSetfilter)
* the image will crop itself. This functionality used to be in
* ImageToStructuredPoints.
*/
int SetRequestExactExtent(int port, int flag);
int GetRequestExactExtent(int port);
///@}
/**
* Key defining a request to propagate the update extent upstream.
* \ingroup InformationKeys
*/
static vtkInformationRequestKey* REQUEST_UPDATE_EXTENT();
/**
* Key defining a request to propagate the update extent upstream.
* \ingroup InformationKeys
*/
static vtkInformationRequestKey* REQUEST_UPDATE_TIME();
/**
* Key defining a request to make sure the meta information is up to date.
* \ingroup InformationKeys
*/
static vtkInformationRequestKey* REQUEST_TIME_DEPENDENT_INFORMATION();
/**
* Key for an algorithm to store in a request to tell this executive
* to keep executing it.
* \ingroup InformationKeys
*/
static vtkInformationIntegerKey* CONTINUE_EXECUTING();
/**
* Keys to store an update request in pipeline information.
* \ingroup InformationKeys
*/
static vtkInformationIntegerKey* UPDATE_EXTENT_INITIALIZED();
/**
* \ingroup InformationKeys
*/
static vtkInformationIntegerVectorKey* UPDATE_EXTENT();
/**
* \ingroup InformationKeys
*/
static vtkInformationIntegerKey* UPDATE_PIECE_NUMBER();
/**
* \ingroup InformationKeys
*/
static vtkInformationIntegerKey* UPDATE_NUMBER_OF_PIECES();
/**
* \ingroup InformationKeys
*/
static vtkInformationIntegerKey* UPDATE_NUMBER_OF_GHOST_LEVELS();
/**
* Key for combining the update extents requested by all consumers,
* so that the final extent that is produced satisfies all consumers.
* \ingroup InformationKeys
*/
static vtkInformationIntegerVectorKey* COMBINED_UPDATE_EXTENT();
/**
* Key to store the whole extent provided in pipeline information.
* \ingroup InformationKeys
*/
static vtkInformationIntegerVectorKey* WHOLE_EXTENT();
/**
* This is set if the update extent is not restricted to the
* whole extent, for sources that can generate an extent of
* any requested size.
* \ingroup InformationKeys
*/
static vtkInformationIntegerKey* UNRESTRICTED_UPDATE_EXTENT();
/**
* Key to specify the request for exact extent in pipeline information.
* \ingroup InformationKeys
*/
static vtkInformationIntegerKey* EXACT_EXTENT();
/**
* Key to store available time steps.
* \ingroup InformationKeys
*/
static vtkInformationDoubleVectorKey* TIME_STEPS();
/**
* Key to store available time range for continuous sources.
* \ingroup InformationKeys
*/
static vtkInformationDoubleVectorKey* TIME_RANGE();
/**
* Update time steps requested by the pipeline.
* \ingroup InformationKeys
*/
static vtkInformationDoubleKey* UPDATE_TIME_STEP();
/**
* Whether there are time dependent meta information
* if there is, the pipeline will perform two extra passes
* to gather the time dependent information
* \ingroup InformationKeys
*/
static vtkInformationIntegerKey* TIME_DEPENDENT_INFORMATION();
/**
* key to record the bounds of a dataset.
* \ingroup InformationKeys
*/
static vtkInformationDoubleVectorKey* BOUNDS();
///@{
/**
* Get/Set the update extent for output ports that use 3D extents.
*/
static void GetUpdateExtent(vtkInformation*, int extent[6]);
static int* GetUpdateExtent(vtkInformation*);
///@}
///@{
/**
* Set/Get the update piece, update number of pieces, and update
* number of ghost levels for an output port. Similar to update
* extent in 3D.
*/
static int GetUpdatePiece(vtkInformation*);
static int GetUpdateNumberOfPieces(vtkInformation*);
static int GetUpdateGhostLevel(vtkInformation*);
///@}
protected:
vtkStreamingDemandDrivenPipeline();
~vtkStreamingDemandDrivenPipeline() override;
/**
* Keep track of the update time request corresponding to the
* previous executing. If the previous update request did not
* correspond to an existing time step and the reader chose
* a time step with it's own logic, the data time step will
* be different than the request. If the same time step is
* requested again, there is no need to re-execute the algorithm.
* We know that it does not have this time step.
* \ingroup InformationKeys
*/
static vtkInformationDoubleKey* PREVIOUS_UPDATE_TIME_STEP();
// Does the time request correspond to what is in the data?
// Returns 0 if yes, 1 otherwise.
virtual int NeedToExecuteBasedOnTime(vtkInformation* outInfo, vtkDataObject* dataObject);
// Setup default information on the output after the algorithm
// executes information.
int ExecuteInformation(vtkInformation* request, vtkInformationVector** inInfoVec,
vtkInformationVector* outInfoVec) override;
// Copy information for the given request.
void CopyDefaultInformation(vtkInformation* request, int direction,
vtkInformationVector** inInfoVec, vtkInformationVector* outInfoVec) override;
// Helper to check output information before propagating it to inputs.
virtual int VerifyOutputInformation(
int outputPort, vtkInformationVector** inInfoVec, vtkInformationVector* outInfoVec);
// Override this check to account for update extent.
int NeedToExecuteData(
int outputPort, vtkInformationVector** inInfoVec, vtkInformationVector* outInfoVec) override;
// Override these to handle the continue-executing option.
void ExecuteDataStart(vtkInformation* request, vtkInformationVector** inInfoVec,
vtkInformationVector* outInfoVec) override;
void ExecuteDataEnd(vtkInformation* request, vtkInformationVector** inInfoVec,
vtkInformationVector* outInfoVec) override;
// Override this to handle cropping and ghost levels.
void MarkOutputsGenerated(vtkInformation* request, vtkInformationVector** inInfoVec,
vtkInformationVector* outInfoVec) override;
// Remove update/whole extent when resetting pipeline information.
void ResetPipelineInformation(int port, vtkInformation*) override;
// Flag for when an algorithm returns with CONTINUE_EXECUTING in the
// request.
int ContinueExecuting;
vtkInformation* UpdateExtentRequest;
vtkInformation* UpdateTimeRequest;
vtkInformation* TimeDependentInformationRequest;
vtkInformationIterator* InformationIterator;
// did the most recent PUE do anything ?
int LastPropogateUpdateExtentShortCircuited;
private:
vtkStreamingDemandDrivenPipeline(const vtkStreamingDemandDrivenPipeline&) = delete;
void operator=(const vtkStreamingDemandDrivenPipeline&) = delete;
};
#endif