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
|
/*=========================================================================
Program: Visualization Toolkit
Module: vtkHyperOctreeDualGridContourFilter.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 vtkHyperOctreeDualGridContourFilter
* @brief generate isosurfaces/isolines from scalar values
*
* use of unsigned short to hold level index limits tree depth to 16.
*
* To use this filter you must specify one or more contour values.
* You can either use the method SetValue() to specify each contour
* value, or use GenerateValues() to generate a series of evenly
* spaced contours. It is also possible to accelerate the operation of
* this filter (at the cost of extra memory) by using a
* vtkScalarTree. A scalar tree is used to quickly locate cells that
* contain a contour surface. This is especially effective if multiple
* contours are being extracted. If you want to use a scalar tree,
* invoke the method UseScalarTreeOn().
*
* @sa
* vtkMarchingContourFilter vtkKitwareContourFilter
* vtkMarchingCubes vtkSliceCubes vtkDividingCubes vtkMarchingSquares
* vtkImageMarchingCubes
*/
#ifndef vtkHyperOctreeDualGridContourFilter_h
#define vtkHyperOctreeDualGridContourFilter_h
#include "vtkFiltersHyperTreeModule.h" // For export macro
#include "vtkPolyDataAlgorithm.h"
#include "vtkContourValues.h" // Needed for inline methods
#include "vtkCutter.h" // for VTK_SORT_BY_VALUE
class vtkHyperOctree;
class vtkTetra;
class vtkHyperOctreeCursor;
class vtkHyperOctreeLightWeightCursor;
class vtkDataSetAttributes;
class vtkUnstructuredGrid;
class vtkUnsignedCharArray;
class vtkIdTypeArray;
class vtkBitArray;
class vtkIncrementalPointLocator;
class VTKFILTERSHYPERTREE_EXPORT vtkHyperOctreeDualGridContourFilter : public vtkPolyDataAlgorithm
{
public:
vtkTypeMacro(vtkHyperOctreeDualGridContourFilter,vtkPolyDataAlgorithm);
void PrintSelf(ostream& os, vtkIndent indent);
/**
* Construct object with initial range (0,1) and single contour value
* of 0.0.
*/
static vtkHyperOctreeDualGridContourFilter *New();
/**
* Methods to set / get contour values.
*/
/**
* Set a particular contour value at contour number i. The index i ranges
* between 0<=i<NumberOfContours.
*/
void SetValue(int i, double value)
{
this->ContourValues->SetValue(i,value);
}
/**
* Get the ith contour value.
*/
double GetValue(int i)
{
return this->ContourValues->GetValue(i);
}
/**
* Get a pointer to an array of contour values. There will be
* GetNumberOfContours() values in the list.
*/
double *GetValues()
{
return this->ContourValues->GetValues();
}
/**
* Fill a supplied list with contour values. There will be
* GetNumberOfContours() values in the list. Make sure you allocate
* enough memory to hold the list.
*/
void GetValues(double *contourValues)
{
this->ContourValues->GetValues(contourValues);
}
/**
* Set the number of contours to place into the list. You only really
* need to use this method to reduce list size. The method SetValue()
* will automatically increase list size as needed.
*/
void SetNumberOfContours(int number)
{
this->ContourValues->SetNumberOfContours(number);
}
/**
* Get the number of contours in the list of contour values.
*/
int GetNumberOfContours()
{
return this->ContourValues->GetNumberOfContours();
}
/**
* Generate numContours equally spaced contour values between specified
* range. Contour values will include min/max range values.
*/
void GenerateValues(int numContours, double range[2])
{
this->ContourValues->GenerateValues(numContours, range);
}
/**
* Generate numContours equally spaced contour values between specified
* range. Contour values will include min/max range values.
*/
void GenerateValues(int numContours, double
rangeStart, double rangeEnd)
{
this->ContourValues->GenerateValues(numContours, rangeStart, rangeEnd);
}
/**
* Modified GetMTime Because we delegate to vtkContourValues
*/
vtkMTimeType GetMTime();
//@{
/**
* Set / get a spatial locator for merging points. By default,
* an instance of vtkMergePoints is used.
*/
void SetLocator(vtkIncrementalPointLocator *locator);
vtkGetObjectMacro(Locator,vtkIncrementalPointLocator);
//@}
/**
* Create default locator. Used to create one when none is
* specified. The locator is used to merge coincident points.
*/
void CreateDefaultLocator();
protected:
vtkHyperOctreeDualGridContourFilter();
~vtkHyperOctreeDualGridContourFilter();
virtual int RequestData(vtkInformation* request,
vtkInformationVector** inputVector,
vtkInformationVector* outputVector);
virtual int RequestUpdateExtent(vtkInformation*,
vtkInformationVector**,
vtkInformationVector*);
virtual int FillInputPortInformation(int port, vtkInformation *info);
/**
* Do the recursive contour of the node pointed by Cursor.
*/
void ContourNode();
void TraverseNeighborhoodRecursively(
vtkHyperOctreeLightWeightCursor* neighborhood,
unsigned short* xyzIds);
void EvaluatePoint(vtkHyperOctreeLightWeightCursor* neighborhood,
unsigned short* xyzIds);
void ContourNode1D();
vtkContourValues *ContourValues;
vtkIncrementalPointLocator *Locator;
vtkHyperOctree *Input;
vtkPolyData *Output;
vtkCellArray *NewPolys;
vtkDataSetAttributes *InPD;
vtkDataSetAttributes *OutPD;
vtkDataArray *InScalars;
// To compute points on the fly.
// These are set to the input origin and size.
double Origin[3];
double Size[3];
// This is a table for traversing a neighborhood down an octree.
// 8 children x 8 cursors
// First three bits encode the child, rest encode the cursor id.
// 8xCursorId + childId.
unsigned char NeighborhoodTraversalTable[64];
void GenerateTraversalTable();
private:
vtkHyperOctreeDualGridContourFilter(const vtkHyperOctreeDualGridContourFilter&) VTK_DELETE_FUNCTION;
void operator=(const vtkHyperOctreeDualGridContourFilter&) VTK_DELETE_FUNCTION;
};
#endif
|
