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
|
/*=========================================================================
Program: Visualization Toolkit
Module: $RCSfile: vtkCompositeDataPipeline.h,v $
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.
=========================================================================*/
// .NAME vtkCompositeDataPipeline - Executive supporting composite datasets.
// .SECTION Description
// vtkCompositeDataPipeline is an executive that supports the processing of
// composite dataset. It supports algorithms that are aware of composite
// dataset as well as those that are not. Type checking is performed at run
// time. Algorithms that are not composite dataset-aware have to support
// all dataset types contained in the composite dataset. The pipeline
// execution can be summarized as follows:
//
// * REQUEST_INFORMATION: The producers have to provide information about
// the contents of the composite dataset in this pass.
// Sources that can produce more than one piece (note that a piece is
// different than a block; each piece consistes of 0 or more blocks) should
// set MAXIMUM_NUMBER_OF_PIECES to -1.
//
// * REQUEST_UPDATE_EXTENT: This pass is identical to the one implemented
// in vtkStreamingDemandDrivenPipeline
//
// * REQUEST_DATA: This is where the algorithms execute. If the
// vtkCompositeDataPipeline is assigned to a simple filter,
// it will invoke the vtkStreamingDemandDrivenPipeline passes in a loop,
// passing a different block each time and will collect the results in a
// composite dataset.
// .SECTION See also
// vtkCompositeDataSet
#ifndef __vtkCompositeDataPipeline_h
#define __vtkCompositeDataPipeline_h
#include "vtkStreamingDemandDrivenPipeline.h"
class vtkCompositeDataSet;
class vtkInformationDoubleKey;
class vtkInformationIntegerVectorKey;
class vtkInformationObjectBaseKey;
class vtkInformationStringKey;
class vtkInformationDataObjectKey;
class vtkInformationIntegerKey;
class VTK_FILTERING_EXPORT vtkCompositeDataPipeline : public vtkStreamingDemandDrivenPipeline
{
public:
static vtkCompositeDataPipeline* New();
vtkTypeRevisionMacro(vtkCompositeDataPipeline,vtkStreamingDemandDrivenPipeline);
void PrintSelf(ostream& os, vtkIndent indent);
// Description:
// Generalized interface for asking the executive to fullfill update
// requests.
virtual int ProcessRequest(vtkInformation* request,
vtkInformationVector** inInfo,
vtkInformationVector* outInfo);
// Description:
// Returns the data object stored with the DATA_OBJECT() in the
// output port
vtkDataObject* GetCompositeOutputData(int port);
// Description:
// Returns the data object stored with the DATA_OBJECT() in the
// input port
vtkDataObject* GetCompositeInputData(
int port, int index, vtkInformationVector **inInfoVec);
// Description:
// vtkCompositeDataPipeline specific keys
static vtkInformationIntegerKey* REQUIRES_TIME_DOWNSTREAM();
protected:
vtkCompositeDataPipeline();
~vtkCompositeDataPipeline();
virtual int ForwardUpstream(vtkInformation* request);
virtual int ForwardUpstream(int i, int j, vtkInformation* request);
// Copy information for the given request.
virtual void CopyDefaultInformation(vtkInformation* request, int direction,
vtkInformationVector** inInfoVec,
vtkInformationVector* outInfoVec);
virtual void CopyFromDataToInformation(
vtkDataObject* dobj, vtkInformation* inInfo);
virtual void PushInformation(vtkInformation*);
virtual void PopInformation (vtkInformation*);
virtual int ExecuteDataObject(vtkInformation* request,
vtkInformationVector** inInfo,
vtkInformationVector* outInfo);
virtual int ExecuteData(vtkInformation* request,
vtkInformationVector** inInfoVec,
vtkInformationVector* outInfoVec);
virtual void ExecuteDataStart(vtkInformation* request,
vtkInformationVector** inInfoVec,
vtkInformationVector* outInfoVec);
// Override this check to account for update extent.
virtual int NeedToExecuteData(int outputPort,
vtkInformationVector** inInfoVec,
vtkInformationVector* outInfoVec);
// Override this check to account for iterating over temporal data.
virtual int NeedToExecuteBasedOnTime(vtkInformation *outInfo,
vtkDataObject *dataObject);
// Check whether the data object in the pipeline information for an
// output port exists and has a valid type.
virtual int CheckCompositeData(vtkInformation *request,
int port,
vtkInformationVector** inInfoVec,
vtkInformationVector* outInfoVec);
// True when the pipeline is iterating over the current (simple) filter
// to produce composite output. In this case, ExecuteDataStart() should
// NOT Initialize() the composite output.
int InLocalLoop;
virtual void ExecuteSimpleAlgorithm(vtkInformation* request,
vtkInformationVector** inInfoVec,
vtkInformationVector* outInfoVec,
int compositePort);
virtual void ExecuteSimpleAlgorithmTime(vtkInformation* request,
vtkInformationVector** inInfoVec,
vtkInformationVector* outInfoVec);
vtkDataObject* ExecuteSimpleAlgorithmForBlock(
vtkInformationVector** inInfoVec,
vtkInformationVector* outInfoVec,
vtkInformation* inInfo,
vtkInformation* outInfo,
vtkInformation* request,
vtkDataObject* dobj);
bool ShouldIterateOverInput(int& compositePort);
bool ShouldIterateTemporalData(vtkInformation *request,
vtkInformationVector** inInfoVec,
vtkInformationVector *outInfoVec);
virtual int InputTypeIsValid(int port, int index,
vtkInformationVector **inInfoVec);
vtkInformation* InformationCache;
vtkInformation* GenericRequest;
vtkInformation* DataObjectRequest;
vtkInformation* InformationRequest;
vtkInformation* UpdateExtentRequest;
vtkInformation* DataRequest;
// Because we sometimes have to swap between "simple" data types and composite
// data types, we sometimes want to skip resetting the pipeline information.
int SuppressResetPipelineInformation;
virtual void ResetPipelineInformation(int port, vtkInformation*);
// Description:
// Tries to create the best possible composite data output for the given input
// and non-composite algorithm output. Returns a new instance on success.
// Don't use this method for creating vtkTemporalDataSet. It's main purpose is
// to determine if vtkHierarchicalBoxDataSet can be propagated as
// vtkHierarchicalBoxDataSet in the output (if the algorithm can produce
// vtkUniformGrid given vtkUniformGrid inputs) or if it should be downgraded
// to a vtkMultiBlockDataSet.
vtkCompositeDataSet* CreateOutputCompositeDataSet(
vtkCompositeDataSet* input, int compositePort);
private:
vtkCompositeDataPipeline(const vtkCompositeDataPipeline&); // Not implemented.
void operator=(const vtkCompositeDataPipeline&); // Not implemented.
};
#endif
|
