forked from Kitware/VTK
-
Notifications
You must be signed in to change notification settings - Fork 0
/
vtkAdaptiveDataSetSurfaceFilter.h
282 lines (232 loc) · 6.94 KB
/
vtkAdaptiveDataSetSurfaceFilter.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
/*=========================================================================
Program: Visualization Toolkit
Module: vtkAdaptiveDataSetSurfaceFilter.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 vtkAdaptiveDataSetSurfaceFilter
* @brief Adaptively extract dataset surface
*
* vtkAdaptiveDataSetSurfaceFilter uses view and dataset properties to
* create the outside surface mesh with the minimum minimorum of facets
* @warning
* Only implemented currently for 2-dimensional vtkHyperTreeGrid objects
* @sa
* vtkHyperTreeGrid vtkDataSetSurfaceFilter
* @par Thanks:
* This class was written by Guenole Harel and Jacques-Bernard Lekien, 2014
* This class was rewritten by Philippe Pebay, 2016
* This class was modified by Rogeli Grima, 2016
* This work was supported by Commissariat a l'Energie Atomique (CEA/DIF)
* CEA, DAM, DIF, F-91297 Arpajon, France.
*/
#ifndef vtkAdaptiveDataSetSurfaceFilter_h
#define vtkAdaptiveDataSetSurfaceFilter_h
#include "vtkFiltersHybridModule.h" // For export macro
#include "vtkGeometryFilter.h"
class vtkBitArray;
class vtkCamera;
class vtkHyperTreeGrid;
class vtkRenderer;
class vtkHyperTreeGridNonOrientedGeometryCursor;
class vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight;
class VTKFILTERSHYBRID_EXPORT vtkAdaptiveDataSetSurfaceFilter : public vtkGeometryFilter
{
public:
static vtkAdaptiveDataSetSurfaceFilter* New();
vtkTypeMacro(vtkAdaptiveDataSetSurfaceFilter, vtkGeometryFilter);
void PrintSelf(ostream& os, vtkIndent indent) override;
///@{
/**
* Set/Get the renderer attached to this adaptive surface extractor
*/
void SetRenderer(vtkRenderer* ren);
vtkGetObjectMacro(Renderer, vtkRenderer);
///@}
/**
* Get the mtime of this object.
*/
vtkMTimeType GetMTime() override;
///@{
/**
* Set/Get for active the circle selection viewport (defaut true)
*/
vtkSetMacro(CircleSelection, bool);
vtkGetMacro(CircleSelection, bool);
///@}
///@{
/**
* Set/Get for active the bounding box selection viewport (defaut false)
* JB C'est un facteur supplementaire d'acceleration possible
* JB uniquement si l'on ne peut faire de rotation dans la vue.
*/
vtkSetMacro(BBSelection, bool);
vtkGetMacro(BBSelection, bool);
///@}
///@{
/**
* JB Activation de la dependance au point de vue. Par defaut a True.
*/
vtkSetMacro(ViewPointDepend, bool);
vtkGetMacro(ViewPointDepend, bool);
///@}
///@{
/**
* Set/Get for forced a fixed the level max (lost dynamicity) (defaut -1)
*/
vtkSetMacro(FixedLevelMax, int);
vtkGetMacro(FixedLevelMax, int);
///@}
///@{
/**
* JB Set/Get the scale factor influence le calcul de l'adaptive view.
* JB Pour un raffinement de 2, donner Scale=2*X revient a faire un
* JB appel a DynamicDecimateLevelMax avec la valeur X. (defaut 1)
*/
vtkSetMacro(Scale, double);
vtkGetMacro(Scale, double);
///@}
///@{
/**
* JB Set/Get reduit de autant le niveau max de profondeur, calcule
* JB dynamiquement a parcourir dans la
* JB representation HTG. (defaut 0)
*/
vtkSetMacro(DynamicDecimateLevelMax, int);
vtkGetMacro(DynamicDecimateLevelMax, int);
///@}
protected:
vtkAdaptiveDataSetSurfaceFilter();
~vtkAdaptiveDataSetSurfaceFilter() override;
int RequestData(vtkInformation* vtkNotUsed(request), vtkInformationVector** inputVector,
vtkInformationVector* outputVector) override;
int DataObjectExecute(vtkDataObject* input, vtkPolyData* output);
int FillInputPortInformation(int port, vtkInformation* info) override;
/**
* Main routine to generate external boundary
*/
void ProcessTrees(vtkHyperTreeGrid* input, vtkPolyData* output);
/**
* Recursively descend into tree down to leaves
*/
void RecursivelyProcessTreeNot3D(vtkHyperTreeGridNonOrientedGeometryCursor*, int);
void RecursivelyProcessTree3D(vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight*, int);
/**
* Process 1D leaves and issue corresponding edges (lines)
*/
void ProcessLeaf1D(vtkHyperTreeGridNonOrientedGeometryCursor*);
/**
* Process 2D leaves and issue corresponding faces (quads)
*/
void ProcessLeaf2D(vtkHyperTreeGridNonOrientedGeometryCursor*);
/**
* Process 3D leaves and issue corresponding cells (voxels)
*/
void ProcessLeaf3D(vtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight*);
/**
* Helper method to generate a face based on its normal and offset from cursor origin
*/
void AddFace(vtkIdType, const double*, const double*, int, unsigned int);
vtkDataSetAttributes* InData;
vtkDataSetAttributes* OutData;
/**
* Dimension of input grid
*/
unsigned int Dimension;
/**
* Orientation of input grid when dimension < 3
*/
unsigned int Orientation;
/**
* Visibility Mask
*/
vtkBitArray* Mask;
/**
* Storage for points of output unstructured mesh
*/
vtkPoints* Points;
/**
* Storage for cells of output unstructured mesh
*/
vtkCellArray* Cells;
/**
* Pointer to the renderer in use
*/
vtkRenderer* Renderer;
/**
* First axis parameter for adaptive view
*/
unsigned int Axis1;
/**
* Second axis parameter for adaptive view
*/
unsigned int Axis2;
/**
* Maximum depth parameter for adaptive view
*/
int LevelMax;
/**
* Parallel projection parameter for adaptive view
*/
bool ParallelProjection;
/**
* Last renderer size parameters for adaptive view
*/
int LastRendererSize[2];
/**
* JB Activation de la dependance au point de vue
*/
bool ViewPointDepend;
/**
* Last camera focal point coordinates for adaptive view
*/
double LastCameraFocalPoint[3];
/**
* Last camera parallel scale for adaptive view
*/
double LastCameraParallelScale;
/**
* Bounds windows in the real coordinates
*/
double WindowBounds[4];
/**
* Product cell when in circle selection
*/
bool CircleSelection;
/**
* Radius parameter for adaptive view
*/
double Radius;
/**
* Product cell when in nounding box selection
*/
bool BBSelection;
#ifndef NDEBUG
/**
* Effect of options selection
*/
long int NbRejectByCircle;
long int NbRejectByBB;
#endif
/**
* JB Forced, fixed the level depth, ignored automatic determination
*/
int FixedLevelMax;
/**
* Scale factor for adaptive view
*/
double Scale;
/**
* JB Decimate level max after automatic determination
*/
int DynamicDecimateLevelMax;
private:
vtkAdaptiveDataSetSurfaceFilter(const vtkAdaptiveDataSetSurfaceFilter&) = delete;
void operator=(const vtkAdaptiveDataSetSurfaceFilter&) = delete;
};
#endif // vtkAdaptiveDataSetSurfaceFilter_h