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
|
// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
/**
* @class vtkPlaneSource
* @brief create an array of quadrilaterals located in a plane
*
* vtkPlaneSource creates an m x n array of quadrilaterals arranged as
* a regular tiling in a plane. The plane is defined by specifying an
* origin point, and then two other points that, together with the
* origin, define two axes for the plane. These axes do not have to be
* orthogonal - so you can create a parallelogram. (The axes must not
* be parallel.) The resolution of the plane (i.e., number of subdivisions) is
* controlled by the ivars XResolution and YResolution.
*
* By default, the plane is centered at the origin and perpendicular to the
* z-axis, with width and height of length 1 and resolutions set to 1.
*
* There are three convenience methods that allow you to easily move the
* plane. The first, SetNormal(), allows you to specify the plane
* normal. The effect of this method is to rotate the plane around the center
* of the plane, aligning the plane normal with the specified normal. The
* rotation is about the axis defined by the cross product of the current
* normal with the new normal. The second, SetCenter(), translates the center
* of the plane to the specified center point. The third method, Push(),
* allows you to translate the plane along the plane normal by the distance
* specified. (Negative Push values translate the plane in the negative
* normal direction.) Note that the SetNormal(), SetCenter() and Push()
* methods modify the Origin, Point1, and/or Point2 instance variables.
*
* @warning
* The normal to the plane will point in the direction of the cross product
* of the first axis (Origin->Point1) with the second (Origin->Point2). This
* also affects the normals to the generated polygons.
*/
#ifndef vtkPlaneSource_h
#define vtkPlaneSource_h
#include "vtkFiltersSourcesModule.h" // For export macro
#include "vtkPolyDataAlgorithm.h"
VTK_ABI_NAMESPACE_BEGIN
class VTKFILTERSSOURCES_EXPORT vtkPlaneSource : public vtkPolyDataAlgorithm
{
public:
void PrintSelf(ostream& os, vtkIndent indent) override;
vtkTypeMacro(vtkPlaneSource, vtkPolyDataAlgorithm);
/**
* Construct plane perpendicular to z-axis, resolution 1x1, width
* and height 1.0, and centered at the origin.
*/
static vtkPlaneSource* New();
///@{
/**
* Specify the resolution of the plane along the first axes.
*/
vtkSetMacro(XResolution, int);
vtkGetMacro(XResolution, int);
///@}
///@{
/**
* Specify the resolution of the plane along the second axes.
*/
vtkSetMacro(YResolution, int);
vtkGetMacro(YResolution, int);
///@}
///@{
/**
* Set the number of x-y subdivisions in the plane.
*/
void SetResolution(int xR, int yR);
void GetResolution(int& xR, int& yR)
{
xR = this->XResolution;
yR = this->YResolution;
}
///@}
///@{
/**
* Specify a point defining the origin of the plane.
*/
vtkSetVector3Macro(Origin, double);
vtkGetVectorMacro(Origin, double, 3);
///@}
///@{
/**
* Specify a point defining the first axis of the plane.
*/
void SetPoint1(double x, double y, double z);
void SetPoint1(double pnt[3]);
vtkGetVectorMacro(Point1, double, 3);
///@}
///@{
/**
* Specify a point defining the second axis of the plane.
*/
void SetPoint2(double x, double y, double z);
void SetPoint2(double pnt[3]);
vtkGetVectorMacro(Point2, double, 3);
///@}
///@{
/**
* Convenience methods to retrieve the axes of the plane; that is
* axis a1 is the vector (Point1-Origin), and axis a2 is the vector
* (Point2-Origin).
*/
void GetAxis1(double a1[3]);
void GetAxis2(double a2[3]);
///@}
///@{
/**
* Set/Get the center of the plane. Works in conjunction with the plane
* normal to position the plane. Don't use this method to define the plane.
* Instead, use it to move the plane to a new center point.
*/
void SetCenter(double x, double y, double z);
void SetCenter(double center[3]);
vtkGetVectorMacro(Center, double, 3);
///@}
///@{
/**
* Set/Get the plane normal. Works in conjunction with the plane center to
* orient the plane. Don't use this method to define the plane. Instead, use
* it to rotate the plane around the current center point.
*/
void SetNormal(double nx, double ny, double nz);
void SetNormal(double n[3]);
vtkGetVectorMacro(Normal, double, 3);
///@}
/**
* Translate the plane in the direction of the normal by the
* distance specified. Negative values move the plane in the
* opposite direction.
*/
void Push(double distance);
/**
* Rotate plane at center around a given axis
* If the absolute value of the angle is inferior to the defined EPSILON, then don't
* rotate
*/
void Rotate(double angle, double rotationAxis[3]);
///@{
/**
* Set/get the desired precision for the output points.
* vtkAlgorithm::SINGLE_PRECISION - Output single-precision floating point.
* vtkAlgorithm::DOUBLE_PRECISION - Output double-precision floating point.
*/
vtkSetMacro(OutputPointsPrecision, int);
vtkGetMacro(OutputPointsPrecision, int);
///@}
protected:
vtkPlaneSource();
~vtkPlaneSource() override = default;
int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
int XResolution;
int YResolution;
double Origin[3];
double Point1[3];
double Point2[3];
double Normal[3];
double Center[3];
int OutputPointsPrecision;
int UpdatePlane(double v1[3], double v2[3]);
private:
vtkPlaneSource(const vtkPlaneSource&) = delete;
void operator=(const vtkPlaneSource&) = delete;
};
VTK_ABI_NAMESPACE_END
#endif
|
