VTK  9.2.6
vtkTransform.h
Go to the documentation of this file.
1/*=========================================================================
2
3 Program: Visualization Toolkit
4 Module: vtkTransform.h
5
6 Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7 All rights reserved.
8 See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9
10 This software is distributed WITHOUT ANY WARRANTY; without even
11 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12 PURPOSE. See the above copyright notice for more information.
13
14=========================================================================*/
15
51
52#ifndef vtkTransform_h
53#define vtkTransform_h
54
55#include "vtkCommonTransformsModule.h" // For export macro
56#include "vtkLinearTransform.h"
57
58#include "vtkMatrix4x4.h" // Needed for inline methods
59
60class VTKCOMMONTRANSFORMS_EXPORT vtkTransform : public vtkLinearTransform
61{
62public:
63 static vtkTransform* New();
65 void PrintSelf(ostream& os, vtkIndent indent) override;
66
72 void Identity();
73
79 void Inverse() override;
80
82
86 void Translate(double x, double y, double z) { this->Concatenation->Translate(x, y, z); }
87 void Translate(const double x[3]) { this->Translate(x[0], x[1], x[2]); }
88 void Translate(const float x[3]) { this->Translate(x[0], x[1], x[2]); }
90
92
98 void RotateWXYZ(double angle, double x, double y, double z)
99 {
100 this->Concatenation->Rotate(angle, x, y, z);
101 }
102 void RotateWXYZ(double angle, const double axis[3])
103 {
104 this->RotateWXYZ(angle, axis[0], axis[1], axis[2]);
105 }
106 void RotateWXYZ(double angle, const float axis[3])
107 {
108 this->RotateWXYZ(angle, axis[0], axis[1], axis[2]);
109 }
110
111
113
118 void RotateX(double angle) { this->RotateWXYZ(angle, 1, 0, 0); }
119 void RotateY(double angle) { this->RotateWXYZ(angle, 0, 1, 0); }
120 void RotateZ(double angle) { this->RotateWXYZ(angle, 0, 0, 1); }
122
124
129 void Scale(double x, double y, double z) { this->Concatenation->Scale(x, y, z); }
130 void Scale(const double s[3]) { this->Scale(s[0], s[1], s[2]); }
131 void Scale(const float s[3]) { this->Scale(s[0], s[1], s[2]); }
133
135
139 void SetMatrix(vtkMatrix4x4* matrix) { this->SetMatrix(*matrix->Element); }
140 void SetMatrix(const double elements[16])
141 {
142 this->Concatenation->Identity();
143 this->Concatenate(elements);
144 }
145
146
148
152 void Concatenate(vtkMatrix4x4* matrix) { this->Concatenate(*matrix->Element); }
153 void Concatenate(const double elements[16]) { this->Concatenation->Concatenate(elements); }
155
164
173 {
174 if (this->Concatenation->GetPreMultiplyFlag())
175 {
176 return;
177 }
178 this->Concatenation->SetPreMultiplyFlag(1);
179 this->Modified();
180 }
181
190 {
191 if (!this->Concatenation->GetPreMultiplyFlag())
192 {
193 return;
194 }
195 this->Concatenation->SetPreMultiplyFlag(0);
196 this->Modified();
197 }
198
204 {
205 return this->Concatenation->GetNumberOfTransforms() + (this->Input == nullptr ? 0 : 1);
206 }
207
209
217 {
219 if (this->Input == nullptr)
220 {
221 t = this->Concatenation->GetTransform(i);
222 }
223 else if (i < this->Concatenation->GetNumberOfPreTransforms())
224 {
225 t = this->Concatenation->GetTransform(i);
226 }
227 else if (i > this->Concatenation->GetNumberOfPreTransforms())
228 {
229 t = this->Concatenation->GetTransform(i - 1);
230 }
231 else if (this->GetInverseFlag())
232 {
233 t = this->Input->GetInverse();
234 }
235 else
236 {
237 t = this->Input;
238 }
239 return static_cast<vtkLinearTransform*>(t);
240 }
241
242
244
248 void GetOrientation(double orient[3]);
249 void GetOrientation(float orient[3])
250 {
251 double temp[3];
252 this->GetOrientation(temp);
253 orient[0] = static_cast<float>(temp[0]);
254 orient[1] = static_cast<float>(temp[1]);
255 orient[2] = static_cast<float>(temp[2]);
256 }
258 {
259 this->GetOrientation(this->ReturnValue);
260 return this->ReturnValue;
261 }
262
263
268 static void GetOrientation(double orient[3], vtkMatrix4x4* matrix);
269
271
275 void GetOrientationWXYZ(double wxyz[4]);
276 void GetOrientationWXYZ(float wxyz[4])
277 {
278 double temp[4];
279 this->GetOrientationWXYZ(temp);
280 wxyz[0] = static_cast<float>(temp[0]);
281 wxyz[1] = static_cast<float>(temp[1]);
282 wxyz[2] = static_cast<float>(temp[2]);
283 wxyz[3] = static_cast<float>(temp[3]);
284 }
286 {
287 this->GetOrientationWXYZ(this->ReturnValue);
288 return this->ReturnValue;
289 }
290
291
293
298 void GetPosition(double pos[3]);
299 void GetPosition(float pos[3])
300 {
301 double temp[3];
302 this->GetPosition(temp);
303 pos[0] = static_cast<float>(temp[0]);
304 pos[1] = static_cast<float>(temp[1]);
305 pos[2] = static_cast<float>(temp[2]);
306 }
308 {
309 this->GetPosition(this->ReturnValue);
310 return this->ReturnValue;
311 }
312
313
315
321 void GetScale(double scale[3]);
322 void GetScale(float scale[3])
323 {
324 double temp[3];
325 this->GetScale(temp);
326 scale[0] = static_cast<float>(temp[0]);
327 scale[1] = static_cast<float>(temp[1]);
328 scale[2] = static_cast<float>(temp[2]);
329 }
331 {
332 this->GetScale(this->ReturnValue);
333 return this->ReturnValue;
334 }
335
336
341 void GetInverse(vtkMatrix4x4* inverse);
342
348 void GetTranspose(vtkMatrix4x4* transpose);
349
351
360 vtkLinearTransform* GetInput() { return this->Input; }
362
370 int GetInverseFlag() { return this->Concatenation->GetInverseFlag(); }
371
373
376 void Push()
377 {
378 if (this->Stack == nullptr)
379 {
381 }
382 this->Stack->Push(&this->Concatenation);
383 this->Modified();
384 }
385
386
388
392 void Pop()
393 {
394 if (this->Stack == nullptr)
395 {
396 return;
397 }
398 this->Stack->Pop(&this->Concatenation);
399 this->Modified();
400 }
401
402
411 int CircuitCheck(vtkAbstractTransform* transform) override;
412
413 // Return an inverse transform which will always update itself
414 // to match this transform.
416
421
426
428
433 void MultiplyPoint(const float in[4], float out[4]) { this->GetMatrix()->MultiplyPoint(in, out); }
434 void MultiplyPoint(const double in[4], double out[4])
435 {
436 this->GetMatrix()->MultiplyPoint(in, out);
437 }
438
439
440protected:
442 ~vtkTransform() override;
443
445
446 void InternalUpdate() override;
447
451
452 // this allows us to check whether people have been fooling
453 // around with our matrix
455
456 float Point[4];
457 double DoublePoint[4];
458 double ReturnValue[4];
459
460private:
461 vtkTransform(const vtkTransform&) = delete;
462 void operator=(const vtkTransform&) = delete;
463};
464
465#endif
vtkAbstractTransform * GetInverse()
Get the inverse of this transform.
vtkMatrix4x4 * GetMatrix()
Get a pointer to an internal vtkMatrix4x4 that represents the transformation.
a simple class to control print indentation
Definition vtkIndent.h:40
vtkLinearTransform()=default
represent and manipulate 4x4 transformation matrices
void MultiplyPoint(const float in[4], float out[4])
Multiply a homogeneous coordinate by this matrix, i.e.
double Element[4][4]
The internal data is public for historical reasons. Do not use!
virtual void Modified()
Update the modification time for this object.
static vtkTransformConcatenationStack * New()
void Push()
Pushes the current transformation onto the transformation stack.
vtkTransformConcatenation * Concatenation
void RotateZ(double angle)
Create a rotation matrix about the X, Y, or Z axis and concatenate it with the current transformation...
vtkLinearTransform * Input
void GetScale(float scale[3])
Return the scale factors of the current transformation matrix as an array of three float numbers.
~vtkTransform() override
vtkMTimeType MatrixUpdateMTime
void MultiplyPoint(const float in[4], float out[4])
Use this method only if you wish to compute the transformation in homogeneous (x,y,...
void GetOrientation(float orient[3])
Get the x, y, z orientation angles from the transformation matrix as an array of three floating point...
void GetTranspose(vtkMatrix4x4 *transpose)
Return a matrix which is the transpose of the current transformation matrix.
int GetNumberOfConcatenatedTransforms()
Get the total number of transformations that are linked into this one via Concatenate() operations or...
void Concatenate(const double elements[16])
Concatenates the matrix with the current transformation according to PreMultiply or PostMultiply sema...
void PreMultiply()
Sets the internal state of the transform to PreMultiply.
void RotateWXYZ(double angle, const float axis[3])
Create a rotation matrix and concatenate it with the current transformation according to PreMultiply ...
void RotateY(double angle)
Create a rotation matrix about the X, Y, or Z axis and concatenate it with the current transformation...
vtkAbstractTransform * MakeTransform() override
Make a new transform of the same type.
int GetInverseFlag()
Get the inverse flag of the transformation.
double * GetScale()
Return the scale factors of the current transformation matrix as an array of three float numbers.
void GetInverse(vtkMatrix4x4 *inverse)
Return a matrix which is the inverse of the current transformation matrix.
double * GetOrientationWXYZ()
Return the wxyz angle+axis representing the current orientation.
void GetScale(double scale[3])
Return the scale factors of the current transformation matrix as an array of three float numbers.
void Scale(const double s[3])
Create a scale matrix (i.e.
vtkLinearTransform * GetConcatenatedTransform(int i)
Get one of the concatenated transformations as a vtkAbstractTransform.
vtkTransformConcatenationStack * Stack
vtkLinearTransform * GetInput()
Set the input for this transformation.
void GetPosition(float pos[3])
Return the position from the current transformation matrix as an array of three floating point number...
void Scale(const float s[3])
Create a scale matrix (i.e.
int CircuitCheck(vtkAbstractTransform *transform) override
Check for self-reference.
void Inverse() override
Invert the transformation.
void Concatenate(vtkLinearTransform *transform)
Concatenate the specified transform with the current transformation according to PreMultiply or PostM...
static void GetOrientation(double orient[3], vtkMatrix4x4 *matrix)
Convenience function to get the x, y, z orientation angles from a transformation matrix as an array o...
vtkMTimeType GetMTime() override
Override GetMTime to account for input and concatenation.
void Concatenate(vtkMatrix4x4 *matrix)
Concatenates the matrix with the current transformation according to PreMultiply or PostMultiply sema...
double ReturnValue[4]
vtkAbstractTransform * GetInverse()
void PostMultiply()
Sets the internal state of the transform to PostMultiply.
void Pop()
Deletes the transformation on the top of the stack and sets the top to the next transformation on the...
void RotateWXYZ(double angle, double x, double y, double z)
Create a rotation matrix and concatenate it with the current transformation according to PreMultiply ...
float Point[4]
void Scale(double x, double y, double z)
Create a scale matrix (i.e.
void GetOrientationWXYZ(double wxyz[4])
Return the wxyz angle+axis representing the current orientation.
double * GetPosition()
Return the position from the current transformation matrix as an array of three floating point number...
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
void Translate(const float x[3])
Create a translation matrix and concatenate it with the current transformation according to PreMultip...
double * GetOrientation()
Get the x, y, z orientation angles from the transformation matrix as an array of three floating point...
void GetPosition(double pos[3])
Return the position from the current transformation matrix as an array of three floating point number...
void Identity()
Set the transformation to the identity transformation.
void Translate(const double x[3])
Create a translation matrix and concatenate it with the current transformation according to PreMultip...
void RotateX(double angle)
Create a rotation matrix about the X, Y, or Z axis and concatenate it with the current transformation...
void SetMatrix(const double elements[16])
Set the current matrix directly.
void GetOrientationWXYZ(float wxyz[4])
Return the wxyz angle+axis representing the current orientation.
void Translate(double x, double y, double z)
Create a translation matrix and concatenate it with the current transformation according to PreMultip...
void RotateWXYZ(double angle, const double axis[3])
Create a rotation matrix and concatenate it with the current transformation according to PreMultiply ...
double DoublePoint[4]
void GetOrientation(double orient[3])
Get the x, y, z orientation angles from the transformation matrix as an array of three floating point...
void SetInput(vtkLinearTransform *input)
Set the input for this transformation.
void InternalUpdate() override
Perform any subclass-specific Update.
static vtkTransform * New()
void MultiplyPoint(const double in[4], double out[4])
Use this method only if you wish to compute the transformation in homogeneous (x,y,...
void InternalDeepCopy(vtkAbstractTransform *t) override
Perform any subclass-specific DeepCopy.
void SetMatrix(vtkMatrix4x4 *matrix)
Set the current matrix directly.
vtkTypeUInt32 vtkMTimeType
Definition vtkType.h:287
#define VTK_SIZEHINT(...)