forked from Kitware/VTK
-
Notifications
You must be signed in to change notification settings - Fork 0
/
vtkCurveRepresentation.h
376 lines (325 loc) · 11.3 KB
/
vtkCurveRepresentation.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
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
/*=========================================================================
Program: Visualization Toolkit
Module: vtkCurveRepresentation
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 vtkCurveRepresentation
* @brief vtkWidgetRepresentation
* base class for a widget that represents an curve that connects control
* points.
*
* Base class for widgets used to define curves from points, such as
* vtkPolyLineRepresentation and vtkSplineRepresentation. This class
* uses handles, the number of which can be changed, to represent the
* points that define the curve. The handles can be picked can be
* picked on the curve itself to translate or rotate it in the scene.
*/
#ifndef vtkCurveRepresentation_h
#define vtkCurveRepresentation_h
#include "vtkInteractionWidgetsModule.h" // For export macro
#include "vtkPolyDataAlgorithm.h" // needed for vtkPolyDataAlgorithm
#include "vtkWidgetRepresentation.h"
class vtkActor;
class vtkCellPicker;
class vtkDoubleArray;
class vtkHandleSource;
class vtkPlaneSource;
class vtkPoints;
class vtkPolyData;
class vtkProp;
class vtkProperty;
class vtkTransform;
#define VTK_PROJECTION_YZ 0
#define VTK_PROJECTION_XZ 1
#define VTK_PROJECTION_XY 2
#define VTK_PROJECTION_OBLIQUE 3
class VTKINTERACTIONWIDGETS_EXPORT vtkCurveRepresentation : public vtkWidgetRepresentation
{
public:
vtkTypeMacro(vtkCurveRepresentation, vtkWidgetRepresentation);
void PrintSelf(ostream& os, vtkIndent indent) override;
// Used to manage the InteractionState of the widget
enum _InteractionState
{
Outside = 0,
OnHandle,
OnLine,
Moving,
Scaling,
Spinning,
Inserting,
Erasing,
Pushing
};
///@{
/**
* Set the interaction state
*/
vtkSetMacro(InteractionState, int);
///@}
///@{
/**
* Force the widget to be projected onto one of the orthogonal
* planes. Remember that when the InteractionState changes, a
* ModifiedEvent is invoked. This can be used to snap the curve to
* the plane if it is originally not aligned. The normal in
* SetProjectionNormal is 0,1,2 for YZ,XZ,XY planes respectively and
* 3 for arbitrary oblique planes when the widget is tied to a
* vtkPlaneSource.
*/
vtkSetMacro(ProjectToPlane, vtkTypeBool);
vtkGetMacro(ProjectToPlane, vtkTypeBool);
vtkBooleanMacro(ProjectToPlane, vtkTypeBool);
///@}
/**
* Set up a reference to a vtkPlaneSource that could be from another widget
* object, e.g. a vtkPolyDataSourceWidget.
*/
void SetPlaneSource(vtkPlaneSource* plane);
vtkSetClampMacro(ProjectionNormal, int, VTK_PROJECTION_YZ, VTK_PROJECTION_OBLIQUE);
vtkGetMacro(ProjectionNormal, int);
void SetProjectionNormalToXAxes() { this->SetProjectionNormal(0); }
void SetProjectionNormalToYAxes() { this->SetProjectionNormal(1); }
void SetProjectionNormalToZAxes() { this->SetProjectionNormal(2); }
void SetProjectionNormalToOblique() { this->SetProjectionNormal(3); }
///@{
/**
* Set the position of poly line handles and points in terms of a plane's
* position. i.e., if ProjectionNormal is 0, all of the x-coordinate
* values of the points are set to position. Any value can be passed (and is
* ignored) to update the poly line points when Projection normal is set to 3
* for arbitrary plane orientations.
*/
void SetProjectionPosition(double position);
vtkGetMacro(ProjectionPosition, double);
///@}
/**
* Grab the polydata (including points) that defines the
* interpolating curve. Points are guaranteed to be up-to-date when
* either the InteractionEvent or EndInteraction events are
* invoked. The user provides the vtkPolyData and the points and
* polyline are added to it.
*/
virtual void GetPolyData(vtkPolyData* pd) = 0;
///@{
/**
* Set/Get the handle properties (the spheres are the handles). The
* properties of the handles when selected and unselected can be manipulated.
*/
vtkGetObjectMacro(HandleProperty, vtkProperty);
vtkGetObjectMacro(SelectedHandleProperty, vtkProperty);
///@}
///@{
/**
* Set/Get the line properties. The properties of the line when selected
* and unselected can be manipulated.
*/
vtkGetObjectMacro(LineProperty, vtkProperty);
vtkGetObjectMacro(SelectedLineProperty, vtkProperty);
///@}
///@{
/**
* Set/Get the number of handles for this widget.
*/
virtual void SetNumberOfHandles(int npts) = 0;
vtkGetMacro(NumberOfHandles, int);
///@}
///@{
/**
* @deprecated VTK 9.1. Use `GetDirectional` and `SetDirectional` instead.
*/
VTK_DEPRECATED_IN_9_1_0("renamed to SetDirectional")
virtual void SetDirectionalLine(bool val);
VTK_DEPRECATED_IN_9_1_0("renamed to GetDirectional")
virtual bool GetDirectionalLine();
VTK_DEPRECATED_IN_9_1_0("renamed to DirectionalOn")
virtual void DirectionalLineOn();
VTK_DEPRECATED_IN_9_1_0("renamed to DirectionalOff")
virtual void DirectionalLineOff();
///@}
///@{
/**
* Set the representation to be directional or not.
* The meaning of being directional depends on the representation and
* its handles implementations in the subclasses.
*/
virtual void SetDirectional(bool val);
vtkGetMacro(Directional, bool);
vtkBooleanMacro(Directional, bool);
///@}
///@{
/**
* Set/Get the position of the handles. Call GetNumberOfHandles
* to determine the valid range of handle indices.
*/
virtual void SetHandlePosition(int handle, double x, double y, double z);
virtual void SetHandlePosition(int handle, double xyz[3]);
virtual void GetHandlePosition(int handle, double xyz[3]);
virtual double* GetHandlePosition(int handle);
virtual vtkDoubleArray* GetHandlePositions() = 0;
///@}
///@{
/**
* Control whether the curve is open or closed. A closed forms a
* continuous loop: the first and last points are the same. A
* minimum of 3 handles are required to form a closed loop.
*/
void SetClosed(vtkTypeBool closed);
vtkGetMacro(Closed, vtkTypeBool);
vtkBooleanMacro(Closed, vtkTypeBool);
///@}
/**
* Convenience method to determine whether the curve is
* closed in a geometric sense. The widget may be set "closed" but still
* be geometrically open (e.g., a straight line).
*/
vtkTypeBool IsClosed();
/**
* Get the approximate vs. the true arc length of the curve. Calculated as
* the summed lengths of the individual straight line segments. Use
* SetResolution to control the accuracy.
*/
virtual double GetSummedLength() = 0;
/**
* Convenience method to allocate and set the handles from a
* vtkPoints instance. If the first and last points are the same,
* the curve sets Closed to the on InteractionState and disregards
* the last point, otherwise Closed remains unchanged.
*/
virtual void InitializeHandles(vtkPoints* points) = 0;
///@{
/**
* These are methods that satisfy vtkWidgetRepresentation
* API. Note that a version of place widget is available where the
* center and handle position are specified.
*/
void BuildRepresentation() override = 0;
int ComputeInteractionState(int X, int Y, int modify = 0) override;
void StartWidgetInteraction(double e[2]) override;
void WidgetInteraction(double e[2]) override;
void EndWidgetInteraction(double e[2]) override;
double* GetBounds() override;
///@}
///@{
/**
* Methods supporting, and required by, the rendering process.
*/
void ReleaseGraphicsResources(vtkWindow*) override;
int RenderOpaqueGeometry(vtkViewport*) override;
int RenderTranslucentPolygonalGeometry(vtkViewport*) override;
int RenderOverlay(vtkViewport*) override;
vtkTypeBool HasTranslucentPolygonalGeometry() override;
///@}
/**
* Convenience method to set the line color.
* Ideally one should use GetLineProperty()->SetColor().
*/
void SetLineColor(double r, double g, double b);
/*
* Register internal Pickers within PickingManager
*/
void RegisterPickers() override;
///@{
/**
* Get/Set the current handle index. Setting the current handle index will
* also result in the handle being highlighted. Set to `-1` to remove the
* highlight.
*/
void SetCurrentHandleIndex(int index);
vtkGetMacro(CurrentHandleIndex, int);
///@}
///@{
/**
* Gets/Sets the constraint axis for translations. Returns Axis::NONE
* if none.
**/
vtkGetMacro(TranslationAxis, int);
vtkSetClampMacro(TranslationAxis, int, -1, 2);
///@}
///@{
/**
* Toggles constraint translation axis on/off.
*/
void SetXTranslationAxisOn() { this->TranslationAxis = Axis::XAxis; }
void SetYTranslationAxisOn() { this->TranslationAxis = Axis::YAxis; }
void SetZTranslationAxisOn() { this->TranslationAxis = Axis::ZAxis; }
void SetTranslationAxisOff() { this->TranslationAxis = Axis::NONE; }
///@}
///@{
/**
* Returns true if ContrainedAxis
**/
bool IsTranslationConstrained() { return this->TranslationAxis != Axis::NONE; }
///@}
protected:
vtkCurveRepresentation();
~vtkCurveRepresentation() override;
double LastEventPosition[3];
double Bounds[6];
// Controlling vars
int ProjectionNormal;
double ProjectionPosition;
vtkTypeBool ProjectToPlane;
vtkPlaneSource* PlaneSource;
// Projection capabilities
void ProjectPointsToPlane();
void ProjectPointsToOrthoPlane();
void ProjectPointsToObliquePlane();
int NumberOfHandles = 0;
vtkTypeBool Closed;
// The line segments
vtkActor* LineActor;
void HighlightLine(int highlight);
int HighlightHandle(vtkProp* prop); // returns handle index or -1 on fail
// accessors to glyphs representing hot spots (e.g., handles)
virtual vtkActor* GetHandleActor(int index) = 0;
virtual vtkHandleSource* GetHandleSource(int index) = 0;
/**
* returns handle index or -1 on fail
*/
virtual int GetHandleIndex(vtkProp* prop) = 0;
virtual void SizeHandles();
/**
* Returns the position of insertion or -1 on fail.
*/
virtual int InsertHandleOnLine(double* pos) = 0;
virtual void PushHandle(double* pos);
virtual void EraseHandle(const int&);
// Do the picking
vtkCellPicker* HandlePicker;
vtkCellPicker* LinePicker;
double LastPickPosition[3];
vtkActor* CurrentHandle;
int CurrentHandleIndex;
bool FirstSelected;
// Methods to manipulate the curve.
void MovePoint(double* p1, double* p2);
void Scale(double* p1, double* p2, int X, int Y);
void Translate(double* p1, double* p2);
void Spin(double* p1, double* p2, double* vpn);
// Transform the control points (used for spinning)
vtkTransform* Transform;
// Manage how the representation appears
bool Directional = false;
// Properties used to control the appearance of selected objects and
// the manipulator in general.
vtkProperty* HandleProperty;
vtkProperty* SelectedHandleProperty;
vtkProperty* LineProperty;
vtkProperty* SelectedLineProperty;
void CreateDefaultProperties();
// For efficient spinning
double Centroid[3];
void CalculateCentroid();
int TranslationAxis;
private:
vtkCurveRepresentation(const vtkCurveRepresentation&) = delete;
void operator=(const vtkCurveRepresentation&) = delete;
};
#endif