VTK
vtkGeneralTransform.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkGeneralTransform.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 =========================================================================*/
32 #ifndef vtkGeneralTransform_h
33 #define vtkGeneralTransform_h
34 
35 #include "vtkCommonTransformsModule.h" // For export macro
36 #include "vtkAbstractTransform.h"
37 
38 #include "vtkMatrix4x4.h" // Needed for inline methods
39 
40 class VTKCOMMONTRANSFORMS_EXPORT vtkGeneralTransform : public vtkAbstractTransform
41 {
42 public:
43  static vtkGeneralTransform *New();
44 
46  void PrintSelf(ostream& os, vtkIndent indent) override;
47 
53  void Identity()
54  { this->Concatenation->Identity(); this->Modified(); };
55 
61  void Inverse() override
62  { this->Concatenation->Inverse(); this->Modified(); }
63 
65 
69  void Translate(double x, double y, double z) {
70  this->Concatenation->Translate(x,y,z); };
71  void Translate(const double x[3]) { this->Translate(x[0], x[1], x[2]); };
72  void Translate(const float x[3]) { this->Translate(x[0], x[1], x[2]); };
74 
76 
82  void RotateWXYZ(double angle, double x, double y, double z) {
83  this->Concatenation->Rotate(angle,x,y,z); };
84  void RotateWXYZ(double angle, const double axis[3]) {
85  this->RotateWXYZ(angle, axis[0], axis[1], axis[2]); };
86  void RotateWXYZ(double angle, const float axis[3]) {
87  this->RotateWXYZ(angle, axis[0], axis[1], axis[2]); };
89 
91 
96  void RotateX(double angle) { this->RotateWXYZ(angle, 1, 0, 0); };
97  void RotateY(double angle) { this->RotateWXYZ(angle, 0, 1, 0); };
98  void RotateZ(double angle) { this->RotateWXYZ(angle, 0, 0, 1); };
100 
102 
107  void Scale(double x, double y, double z) {
108  this->Concatenation->Scale(x,y,z); };
109  void Scale(const double s[3]) { this->Scale(s[0], s[1], s[2]); };
110  void Scale(const float s[3]) { this->Scale(s[0], s[1], s[2]); };
112 
114 
118  void Concatenate(vtkMatrix4x4 *matrix) {
119  this->Concatenate(*matrix->Element); };
120  void Concatenate(const double elements[16]) {
121  this->Concatenation->Concatenate(elements); };
123 
131  void Concatenate(vtkAbstractTransform *transform);
132 
140  void PreMultiply() {
141  if (this->Concatenation->GetPreMultiplyFlag()) { return; }
142  this->Concatenation->SetPreMultiplyFlag(1); this->Modified(); };
143 
151  void PostMultiply() {
152  if (!this->Concatenation->GetPreMultiplyFlag()) { return; }
153  this->Concatenation->SetPreMultiplyFlag(0); this->Modified(); };
154 
160  return this->Concatenation->GetNumberOfTransforms() +
161  (this->Input == nullptr ? 0 : 1); };
162 
171  if (this->Input == nullptr) {
172  return this->Concatenation->GetTransform(i); }
173  else if (i < this->Concatenation->GetNumberOfPreTransforms()) {
174  return this->Concatenation->GetTransform(i); }
175  else if (i > this->Concatenation->GetNumberOfPreTransforms()) {
176  return this->Concatenation->GetTransform(i-1); }
177  else if (this->GetInverseFlag()) {
178  return this->Input->GetInverse(); }
179  else {
180  return this->Input; } };
181 
183 
191  void SetInput(vtkAbstractTransform *input);
192  vtkAbstractTransform *GetInput() { return this->Input; };
194 
203  return this->Concatenation->GetInverseFlag(); };
204 
206 
209  void Push() { if (this->Stack == nullptr) {
210  this->Stack = vtkTransformConcatenationStack::New(); }
211  this->Stack->Push(&this->Concatenation);
212  this->Modified(); };
214 
216 
220  void Pop() { if (this->Stack == nullptr) { return; }
221  this->Stack->Pop(&this->Concatenation);
222  this->Modified(); };
224 
226 
230  void InternalTransformPoint(const float in[3], float out[3]) override;
231  void InternalTransformPoint(const double in[3], double out[3]) override;
233 
235 
240  void InternalTransformDerivative(const float in[3], float out[3],
241  float derivative[3][3]) override;
242  void InternalTransformDerivative(const double in[3], double out[3],
243  double derivative[3][3]) override;
245 
254  int CircuitCheck(vtkAbstractTransform *transform) override;
255 
260 
264  vtkMTimeType GetMTime() override;
265 
266 protected:
268  ~vtkGeneralTransform() override;
269 
270  void InternalDeepCopy(vtkAbstractTransform *t) override;
271  void InternalUpdate() override;
272 
276 private:
277  vtkGeneralTransform(const vtkGeneralTransform&) = delete;
278  void operator=(const vtkGeneralTransform&) = delete;
279 };
280 
281 
282 #endif
283 
284 
285 
286 
287 
vtkGeneralTransform::Scale
void Scale(double x, double y, double z)
Create a scale matrix (i.e.
Definition: vtkGeneralTransform.h:107
vtkGeneralTransform::Inverse
void Inverse() override
Invert the transformation.
Definition: vtkGeneralTransform.h:61
vtkGeneralTransform::RotateWXYZ
void RotateWXYZ(double angle, double x, double y, double z)
Create a rotation matrix and concatenate it with the current transformation according to PreMultiply ...
Definition: vtkGeneralTransform.h:82
vtkAbstractTransform::CircuitCheck
virtual int CircuitCheck(vtkAbstractTransform *transform)
Check for self-reference.
vtkAbstractTransform
superclass for all geometric transformations
Definition: vtkAbstractTransform.h:50
vtkAbstractTransform::InternalTransformPoint
virtual void InternalTransformPoint(const float in[3], float out[3])=0
This will calculate the transformation without calling Update.
vtkMatrix4x4::Element
double Element[4][4]
The internal data is public for historical reasons. Do not use!
Definition: vtkMatrix4x4.h:45
vtkGeneralTransform::Identity
void Identity()
Set this transformation to the identity transformation.
Definition: vtkGeneralTransform.h:53
vtkTransformConcatenationStack
Definition: vtkAbstractTransform.h:503
vtkAbstractTransform.h
vtkObject::New
static vtkObject * New()
Create an object with Debug turned off, modified time initialized to zero, and reference counting on.
vtkAbstractTransform::InternalUpdate
virtual void InternalUpdate()
Perform any subclass-specific Update.
Definition: vtkAbstractTransform.h:337
vtkGeneralTransform::Translate
void Translate(const double x[3])
Definition: vtkGeneralTransform.h:71
vtkObject::Modified
virtual void Modified()
Update the modification time for this object.
vtkGeneralTransform::Translate
void Translate(const float x[3])
Definition: vtkGeneralTransform.h:72
vtkGeneralTransform::GetConcatenatedTransform
vtkAbstractTransform * GetConcatenatedTransform(int i)
Get one of the concatenated transformations as a vtkAbstractTransform.
Definition: vtkGeneralTransform.h:170
vtkGeneralTransform::Input
vtkAbstractTransform * Input
Definition: vtkGeneralTransform.h:273
vtkAbstractTransform::GetInverse
vtkAbstractTransform * GetInverse()
Get the inverse of this transform.
vtkAbstractTransform::PrintSelf
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkGeneralTransform::GetInput
vtkAbstractTransform * GetInput()
Definition: vtkGeneralTransform.h:192
vtkGeneralTransform::RotateX
void RotateX(double angle)
Create a rotation matrix about the X, Y, or Z axis and concatenate it with the current transformation...
Definition: vtkGeneralTransform.h:96
vtkGeneralTransform::PreMultiply
void PreMultiply()
Sets the internal state of the transform to PreMultiply.
Definition: vtkGeneralTransform.h:140
vtkGeneralTransform::Stack
vtkTransformConcatenationStack * Stack
Definition: vtkGeneralTransform.h:275
vtkGeneralTransform::Translate
void Translate(double x, double y, double z)
Create a translation matrix and concatenate it with the current transformation according to PreMultip...
Definition: vtkGeneralTransform.h:69
vtkMatrix4x4.h
vtkAbstractTransform::InternalTransformDerivative
virtual void InternalTransformDerivative(const float in[3], float out[3], float derivative[3][3])=0
This will transform a point and, at the same time, calculate a 3x3 Jacobian matrix that provides the ...
vtkIndent
a simple class to control print indentation
Definition: vtkIndent.h:39
vtkMatrix4x4
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:41
vtkGeneralTransform::Pop
void Pop()
Deletes the transformation on the top of the stack and sets the top to the next transformation on the...
Definition: vtkGeneralTransform.h:220
vtkAbstractTransform::GetMTime
vtkMTimeType GetMTime() override
Override GetMTime necessary because of inverse transforms.
vtkGeneralTransform
allows operations on any transforms
Definition: vtkGeneralTransform.h:40
vtkGeneralTransform::RotateY
void RotateY(double angle)
Definition: vtkGeneralTransform.h:97
vtkTransformConcatenationStack::New
static vtkTransformConcatenationStack * New()
Definition: vtkAbstractTransform.h:506
vtkGeneralTransform::RotateWXYZ
void RotateWXYZ(double angle, const double axis[3])
Definition: vtkGeneralTransform.h:84
vtkGeneralTransform::RotateZ
void RotateZ(double angle)
Definition: vtkGeneralTransform.h:98
vtkGeneralTransform::Concatenate
void Concatenate(const double elements[16])
Definition: vtkGeneralTransform.h:120
vtkGeneralTransform::Scale
void Scale(const double s[3])
Definition: vtkGeneralTransform.h:109
vtkGeneralTransform::GetInverseFlag
int GetInverseFlag()
Get the inverse flag of the transformation.
Definition: vtkGeneralTransform.h:202
vtkGeneralTransform::Concatenate
void Concatenate(vtkMatrix4x4 *matrix)
Concatenates the matrix with the current transformation according to PreMultiply or PostMultiply sema...
Definition: vtkGeneralTransform.h:118
vtkGeneralTransform::Scale
void Scale(const float s[3])
Definition: vtkGeneralTransform.h:110
vtkGeneralTransform::Concatenation
vtkTransformConcatenation * Concatenation
Definition: vtkGeneralTransform.h:274
vtkGeneralTransform::Push
void Push()
Pushes the current transformation onto the transformation stack.
Definition: vtkGeneralTransform.h:209
vtkGeneralTransform::PostMultiply
void PostMultiply()
Sets the internal state of the transform to PostMultiply.
Definition: vtkGeneralTransform.h:151
vtkTransformConcatenation
Definition: vtkAbstractTransform.h:394
vtkAbstractTransform::MakeTransform
virtual vtkAbstractTransform * MakeTransform()=0
Make another transform of the same type.
vtkGeneralTransform::GetNumberOfConcatenatedTransforms
int GetNumberOfConcatenatedTransforms()
Get the total number of transformations that are linked into this one via Concatenate() operations or...
Definition: vtkGeneralTransform.h:159
vtkMTimeType
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:302
vtkGeneralTransform::RotateWXYZ
void RotateWXYZ(double angle, const float axis[3])
Definition: vtkGeneralTransform.h:86
vtkAbstractTransform::InternalDeepCopy
virtual void InternalDeepCopy(vtkAbstractTransform *)
Perform any subclass-specific DeepCopy.
Definition: vtkAbstractTransform.h:342