forked from Kitware/VTK
-
Notifications
You must be signed in to change notification settings - Fork 0
/
vtkFlyingEdges2D.h
172 lines (147 loc) · 5.93 KB
/
vtkFlyingEdges2D.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
/*=========================================================================
Program: Visualization Toolkit
Module: vtkFlyingEdges2D.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 vtkFlyingEdges2D
* @brief generate isoline(s) from a structured points set
*
* vtkFlyingEdges2D is a reference implementation of the 2D version of the
* flying edges algorithm. It is designed to be highly scalable (i.e.,
* parallelizable) for large data. It implements certain performance
* optimizations including computational trimming to rapidly eliminate
* processing of data regions, packed bit representation of case table
* values, single edge intersection, elimination of point merging, and
* elimination of any reallocs (due to dynamic data insertion). Note that
* computational trimming is a method to reduce total computational cost in
* which partial computational results can be used to eliminate future
* computations.
*
* This is a four-pass algorithm. The first pass processes all x-edges and
* builds x-edge case values (which, when the two x-edges defining a pixel
* are combined, are equivalent to vertex-based case table except edge-based
* approaches are separable to parallel computing). Next x-pixel rows are
* processed to gather information from y-edges (basically to count the
* number of edge intersections and lines generated). In the third pass a
* prefix sum is used to count and allocate memory for the output
* primitives. Finally in the fourth pass output primitives are generated into
* pre-allocated arrays. This implementation uses pixel cell axes (a x-y dyad
* located at the pixel origin) to ensure that each edge is intersected at
* most one time.
*
* See the paper "Flying Edges: A High-Performance Scalable Isocontouring
* Algorithm" by Schroeder, Maynard, Geveci. Proc. of LDAV 2015. Chicago, IL.
*
* @warning
* This filter is specialized to 2D images. This implementation can produce
* degenerate line segments (i.e., zero-length line segments).
*
* @warning
* This class has been threaded with vtkSMPTools. Using TBB or other
* non-sequential type (set in the CMake variable
* VTK_SMP_IMPLEMENTATION_TYPE) may improve performance significantly.
*
* @sa
* vtkContourFilter vtkFlyingEdges3D vtkSynchronizedTemplates2D
* vtkMarchingSquares
*/
#ifndef vtkFlyingEdges2D_h
#define vtkFlyingEdges2D_h
#include "vtkFiltersCoreModule.h" // For export macro
#include "vtkPolyDataAlgorithm.h"
#include "vtkContourValues.h" // Needed for direct access to ContourValues
class vtkImageData;
class VTKFILTERSCORE_EXPORT vtkFlyingEdges2D : public vtkPolyDataAlgorithm
{
public:
static vtkFlyingEdges2D *New();
vtkTypeMacro(vtkFlyingEdges2D,vtkPolyDataAlgorithm);
void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;
/**
* Because we delegate to vtkContourValues.
*/
vtkMTimeType GetMTime() VTK_OVERRIDE;
/**
* 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);}
//@{
/**
* Option to set the point scalars of the output. The scalars will be the
* iso value of course. By default this flag is on.
*/
vtkSetMacro(ComputeScalars,int);
vtkGetMacro(ComputeScalars,int);
vtkBooleanMacro(ComputeScalars,int);
//@}
//@{
/**
* Set/get which component of the scalar array to contour on; defaults to 0.
*/
vtkSetMacro(ArrayComponent, int);
vtkGetMacro(ArrayComponent, int);
//@}
protected:
vtkFlyingEdges2D();
~vtkFlyingEdges2D() VTK_OVERRIDE;
int RequestData(vtkInformation *, vtkInformationVector **,
vtkInformationVector *) VTK_OVERRIDE;
int FillInputPortInformation(int port, vtkInformation *info) VTK_OVERRIDE;
vtkContourValues *ContourValues;
int ComputeScalars;
int ArrayComponent;
private:
vtkFlyingEdges2D(const vtkFlyingEdges2D&) VTK_DELETE_FUNCTION;
void operator=(const vtkFlyingEdges2D&) VTK_DELETE_FUNCTION;
};
#endif