VTK
vtkAbstractTransform.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkAbstractTransform.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 =========================================================================*/
39 #ifndef vtkAbstractTransform_h
40 #define vtkAbstractTransform_h
41 
42 #include "vtkCommonTransformsModule.h" // For export macro
43 #include "vtkObject.h"
44 
45 class vtkDataArray;
46 class vtkMatrix4x4;
47 class vtkPoints;
49 
50 class VTKCOMMONTRANSFORMS_EXPORT vtkAbstractTransform : public vtkObject
51 {
52 public:
53 
55  void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;
56 
61  void TransformPoint(const float in[3], float out[3]) {
62  this->Update(); this->InternalTransformPoint(in,out); };
63 
68  void TransformPoint(const double in[3], double out[3]) {
69  this->Update(); this->InternalTransformPoint(in,out); };
70 
75  double *TransformPoint(double x, double y, double z) {
76  return this->TransformDoublePoint(x,y,z); }
77  double *TransformPoint(const double point[3]) {
78  return this->TransformPoint(point[0],point[1],point[2]); };
79 
81 
85  float *TransformFloatPoint(float x, float y, float z) {
86  this->InternalFloatPoint[0] = x;
87  this->InternalFloatPoint[1] = y;
88  this->InternalFloatPoint[2] = z;
89  this->TransformPoint(this->InternalFloatPoint,this->InternalFloatPoint);
90  return this->InternalFloatPoint; };
91  float *TransformFloatPoint(const float point[3]) {
92  return this->TransformFloatPoint(point[0],point[1],point[2]); };
94 
96 
100  double *TransformDoublePoint(double x, double y, double z) {
101  this->InternalDoublePoint[0] = x;
102  this->InternalDoublePoint[1] = y;
103  this->InternalDoublePoint[2] = z;
104  this->TransformPoint(this->InternalDoublePoint,this->InternalDoublePoint);
105  return this->InternalDoublePoint; };
106  double *TransformDoublePoint(const double point[3]) {
107  return this->TransformDoublePoint(point[0],point[1],point[2]); };
109 
111 
116  void TransformNormalAtPoint(const float point[3], const float in[3],
117  float out[3]);
118  void TransformNormalAtPoint(const double point[3], const double in[3],
119  double out[3]);
121 
122  double *TransformNormalAtPoint(const double point[3],
123  const double normal[3]) {
124  this->TransformNormalAtPoint(point,normal,this->InternalDoublePoint);
125  return this->InternalDoublePoint; };
126 
128 
133  double *TransformDoubleNormalAtPoint(const double point[3],
134  const double normal[3]) {
135  this->TransformNormalAtPoint(point,normal,this->InternalDoublePoint);
136  return this->InternalDoublePoint; };
138 
140 
145  float *TransformFloatNormalAtPoint(const float point[3],
146  const float normal[3]) {
147  this->TransformNormalAtPoint(point,normal,this->InternalFloatPoint);
148  return this->InternalFloatPoint; };
150 
152 
157  void TransformVectorAtPoint(const float point[3], const float in[3],
158  float out[3]);
159  void TransformVectorAtPoint(const double point[3], const double in[3],
160  double out[3]);
162 
163  double *TransformVectorAtPoint(const double point[3],
164  const double vector[3]) {
165  this->TransformVectorAtPoint(point,vector,this->InternalDoublePoint);
166  return this->InternalDoublePoint; };
167 
169 
174  double *TransformDoubleVectorAtPoint(const double point[3],
175  const double vector[3]) {
176  this->TransformVectorAtPoint(point,vector,this->InternalDoublePoint);
177  return this->InternalDoublePoint; };
179 
181 
186  float *TransformFloatVectorAtPoint(const float point[3],
187  const float vector[3]) {
188  this->TransformVectorAtPoint(point,vector,this->InternalFloatPoint);
189  return this->InternalFloatPoint; };
191 
196  virtual void TransformPoints(vtkPoints *inPts, vtkPoints *outPts);
197 
203  vtkPoints *outPts,
204  vtkDataArray *inNms,
205  vtkDataArray *outNms,
206  vtkDataArray *inVrs,
207  vtkDataArray *outVrs);
208 
217 
224 
228  virtual void Inverse() = 0;
229 
234 
241  void Update();
242 
244 
248  virtual void InternalTransformPoint(const float in[3], float out[3]) = 0;
249  virtual void InternalTransformPoint(const double in[3], double out[3]) = 0;
251 
253 
259  virtual void InternalTransformDerivative(const float in[3], float out[3],
260  float derivative[3][3]) = 0;
261  virtual void InternalTransformDerivative(const double in[3], double out[3],
262  double derivative[3][3]) = 0;
264 
269 
278  virtual int CircuitCheck(vtkAbstractTransform *transform);
279 
283  vtkMTimeType GetMTime() VTK_OVERRIDE;
284 
289  void UnRegister(vtkObjectBase *O) VTK_OVERRIDE;
290 
291 protected:
293  ~vtkAbstractTransform() VTK_OVERRIDE;
294 
298  virtual void InternalUpdate() {}
299 
304 
305  float InternalFloatPoint[3];
306  double InternalDoublePoint[3];
307 
308 private:
309 
310  // We need to record the time of the last update, and we also need
311  // to do mutex locking so updates don't collide. These are private
312  // because Update() is not virtual.
313  // If DependsOnInverse is set, then this transform object will
314  // check its inverse on every update, and update itself accordingly
315  // if necessary.
316 
317  vtkTimeStamp UpdateTime;
318  vtkSimpleCriticalSection *UpdateMutex;
319  vtkSimpleCriticalSection *InverseMutex;
320  int DependsOnInverse;
321 
322  // MyInverse is a transform which is the inverse of this one.
323 
324  vtkAbstractTransform *MyInverse;
325 
326  int InUnRegister;
327 
328 private:
329  vtkAbstractTransform(const vtkAbstractTransform&) VTK_DELETE_FUNCTION;
330  void operator=(const vtkAbstractTransform&) VTK_DELETE_FUNCTION;
331 };
332 
333 //-------------------------------------------------------------------------
334 // A simple data structure to hold both a transform and its inverse.
335 // One of ForwardTransform or InverseTransform might be NULL,
336 // and must be acquired by calling GetInverse() on the other.
338 {
339 public:
341 
344 
347  this->ForwardTransform = this->InverseTransform;
348  this->InverseTransform = tmp; };
349 };
350 
351 // .NAME vtkTransformConcatenation - store a series of transformations.
352 // .SECTION Description
353 // A helper class (not derived from vtkObject) to store a series of
354 // transformations in a pipelined concatenation.
355 class VTKCOMMONTRANSFORMS_EXPORT vtkTransformConcatenation
356 {
357 public:
359  return new vtkTransformConcatenation(); };
360  void Delete() { delete this; };
361 
366 
370  void Concatenate(const double elements[16]);
371 
373 
376  void SetPreMultiplyFlag(int flag) { this->PreMultiplyFlag = flag; };
377  int GetPreMultiplyFlag() { return this->PreMultiplyFlag; };
379 
381 
384  void Translate(double x, double y, double z);
385  void Rotate(double angle, double x, double y, double z);
386  void Scale(double x, double y, double z);
388 
392  void Inverse();
393 
397  int GetInverseFlag() { return this->InverseFlag; };
398 
402  void Identity();
403 
404  // copy the list
406 
410  int GetNumberOfTransforms() { return this->NumberOfTransforms; };
411 
417  int GetNumberOfPreTransforms() { return this->NumberOfPreTransforms; };
418 
423  return this->NumberOfTransforms-this->NumberOfPreTransforms; };
424 
429 
434 
435  void PrintSelf(ostream& os, vtkIndent indent);
436 
437 protected:
440 
443 
448 
453 };
454 
455 // .NAME vtkTransformConcatenationStack - Store a stack of concatenations.
456 // .SECTION Description
457 // A helper class (not derived from vtkObject) to store a stack of
458 // concatenations.
459 class VTKCOMMONTRANSFORMS_EXPORT vtkTransformConcatenationStack
460 {
461 public:
463  {
464  return new vtkTransformConcatenationStack();
465  }
466  void Delete()
467  {
468  delete this;
469  }
470 
476 
482 
484 
485 protected:
488 
492 };
493 
494 #endif
vtkPoints
represent and manipulate 3D points
Definition: vtkPoints.h:40
vtkTransformConcatenation::GetNumberOfPostTransforms
int GetNumberOfPostTransforms()
the number of transforms that were post-concatenated.
Definition: vtkAbstractTransform.h:422
vtkX3D::vector
@ vector
Definition: vtkX3D.h:237
vtkTransformConcatenation::Concatenate
void Concatenate(const double elements[16])
concatenate with a matrix according to Pre/PostMultiply semantics
vtkTransformConcatenation::Scale
void Scale(double x, double y, double z)
vtkTransformConcatenationStack::vtkTransformConcatenationStack
vtkTransformConcatenationStack()
vtkAbstractTransform::CircuitCheck
virtual int CircuitCheck(vtkAbstractTransform *transform)
Check for self-reference.
vtkTransformConcatenation::GetNumberOfTransforms
int GetNumberOfTransforms()
the number of stored transforms
Definition: vtkAbstractTransform.h:410
vtkAbstractTransform
superclass for all geometric transformations
Definition: vtkAbstractTransform.h:51
vtkAbstractTransform::InternalTransformPoint
virtual void InternalTransformPoint(const float in[3], float out[3])=0
This will calculate the transformation without calling Update.
vtkTransformConcatenationStack::StackSize
int StackSize
Definition: vtkAbstractTransform.h:489
vtkTransformConcatenationStack::DeepCopy
void DeepCopy(vtkTransformConcatenationStack *stack)
vtkTransformConcatenation::PreMatrixTransform
vtkAbstractTransform * PreMatrixTransform
Definition: vtkAbstractTransform.h:446
vtkTransformConcatenation::GetPreMultiplyFlag
int GetPreMultiplyFlag()
Definition: vtkAbstractTransform.h:377
vtkAbstractTransform::TransformNormalAtPoint
double * TransformNormalAtPoint(const double point[3], const double normal[3])
Definition: vtkAbstractTransform.h:122
vtkAbstractTransform::TransformNormalAtPoint
void TransformNormalAtPoint(const double point[3], const double in[3], double out[3])
vtkTransformConcatenation::SetPreMultiplyFlag
void SetPreMultiplyFlag(int flag)
set/get the PreMultiply flag
Definition: vtkAbstractTransform.h:376
vtkAbstractTransform::TransformVectorAtPoint
double * TransformVectorAtPoint(const double point[3], const double vector[3])
Definition: vtkAbstractTransform.h:163
vtkAbstractTransform::Inverse
virtual void Inverse()=0
Invert the transformation.
vtkTransformConcatenationStack
Definition: vtkAbstractTransform.h:460
vtkTransformConcatenation::PostMatrix
vtkMatrix4x4 * PostMatrix
Definition: vtkAbstractTransform.h:445
vtkTimeStamp
record modification and/or execution time
Definition: vtkTimeStamp.h:36
vtkTransformConcatenation::Delete
void Delete()
Definition: vtkAbstractTransform.h:360
vtkAbstractTransform::InternalTransformDerivative
virtual void InternalTransformDerivative(const double in[3], double out[3], double derivative[3][3])=0
vtkTransformPair::SwapForwardInverse
void SwapForwardInverse()
Definition: vtkAbstractTransform.h:345
vtkAbstractTransform::TransformFloatPoint
float * TransformFloatPoint(const float point[3])
Definition: vtkAbstractTransform.h:91
vtkObject
abstract base class for most VTK objects
Definition: vtkObject.h:60
vtkTransformConcatenation::GetTransform
vtkAbstractTransform * GetTransform(int i)
get one of the transforms
vtkTransformConcatenation::GetMaxMTime
vtkMTimeType GetMaxMTime()
get maximum MTime of all transforms
vtkTransformConcatenation::PrintSelf
void PrintSelf(ostream &os, vtkIndent indent)
vtkAbstractTransform::TransformFloatPoint
float * TransformFloatPoint(float x, float y, float z)
Apply the transformation to an (x,y,z) coordinate.
Definition: vtkAbstractTransform.h:85
vtkDataArray
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:55
vtkTransformConcatenation::PreMatrix
vtkMatrix4x4 * PreMatrix
Definition: vtkAbstractTransform.h:444
vtkAbstractTransform::SetInverse
void SetInverse(vtkAbstractTransform *transform)
Set a transformation that this transform will be the inverse of.
vtkAbstractTransform::TransformPoint
void TransformPoint(const double in[3], double out[3])
Apply the transformation to a double-precision coordinate.
Definition: vtkAbstractTransform.h:68
vtkAbstractTransform::Update
void Update()
Update the transform to account for any changes which have been made.
vtkAbstractTransform::GetInverse
vtkAbstractTransform * GetInverse()
Get the inverse of this transform.
vtkTransformConcatenationStack::Delete
void Delete()
Definition: vtkAbstractTransform.h:466
vtkAbstractTransform::TransformVectorAtPoint
void TransformVectorAtPoint(const float point[3], const float in[3], float out[3])
Apply the transformation to a vector at the specified vertex.
vtkAbstractTransform::InternalTransformPoint
virtual void InternalTransformPoint(const double in[3], double out[3])=0
vtkAbstractTransform::PrintSelf
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkAbstractTransform::TransformDoubleVectorAtPoint
double * TransformDoubleVectorAtPoint(const double point[3], const double vector[3])
Apply the transformation to a double-precision vector at the specified vertex.
Definition: vtkAbstractTransform.h:174
vtkTransformConcatenationStack::Pop
void Pop(vtkTransformConcatenation **concat)
pop will pop delete 'concat', then pop the top item on the stack onto 'concat'.
vtkTransformConcatenation::PostMatrixTransform
vtkAbstractTransform * PostMatrixTransform
Definition: vtkAbstractTransform.h:447
vtkTransformConcatenation::NumberOfPreTransforms
int NumberOfPreTransforms
Definition: vtkAbstractTransform.h:450
vtkMTimeType
vtkTypeUInt64 vtkMTimeType
Definition: vtkType.h:248
vtkAbstractTransform::TransformPoint
double * TransformPoint(const double point[3])
Definition: vtkAbstractTransform.h:77
vtkX3D::point
@ point
Definition: vtkX3D.h:236
vtkTransformConcatenation::~vtkTransformConcatenation
~vtkTransformConcatenation()
Update
virtual void Update()
Updates the extensions string.
vtkTransformConcatenation::GetNumberOfPreTransforms
int GetNumberOfPreTransforms()
the number of transforms that were pre-concatenated (note that whenever Iverse() is called,...
Definition: vtkAbstractTransform.h:417
vtkTransformConcatenationStack::Stack
vtkTransformConcatenation ** Stack
Definition: vtkAbstractTransform.h:490
vtkTransformPair::InverseTransform
vtkAbstractTransform * InverseTransform
Definition: vtkAbstractTransform.h:343
vtkAbstractTransform::TransformFloatNormalAtPoint
float * TransformFloatNormalAtPoint(const float point[3], const float normal[3])
Apply the transformation to a single-precision normal at the specified vertex.
Definition: vtkAbstractTransform.h:145
vtkTransformConcatenation::GetInverseFlag
int GetInverseFlag()
get the inverse flag
Definition: vtkAbstractTransform.h:397
vtkObjectBase
abstract base class for most VTK objects
Definition: vtkObjectBase.h:66
vtkAbstractTransform::TransformVectorAtPoint
void TransformVectorAtPoint(const double point[3], const double in[3], double out[3])
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:40
vtkAbstractTransform::TransformPoint
double * TransformPoint(double x, double y, double z)
Apply the transformation to a double-precision coordinate.
Definition: vtkAbstractTransform.h:75
vtkMatrix4x4
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:42
vtkTransformConcatenation::InverseFlag
int InverseFlag
Definition: vtkAbstractTransform.h:441
vtkAbstractTransform::GetMTime
vtkMTimeType GetMTime() override
Override GetMTime necessary because of inverse transforms.
vtkTransformConcatenation::Translate
void Translate(double x, double y, double z)
the three basic linear transformations
vtkTransformConcatenation::TransformList
vtkTransformPair * TransformList
Definition: vtkAbstractTransform.h:452
vtkTransformConcatenation::Concatenate
void Concatenate(vtkAbstractTransform *transform)
add a transform to the list according to Pre/PostMultiply semantics
vtkSimpleCriticalSection
Critical section locking class.
Definition: vtkSimpleCriticalSection.h:67
vtkTransformConcatenation::Identity
void Identity()
identity simply clears the transform list
vtkAbstractTransform::MakeTransform
virtual VTK_NEWINSTANCE vtkAbstractTransform * MakeTransform()=0
Make another transform of the same type.
vtkTransformConcatenationStack::New
static vtkTransformConcatenationStack * New()
Definition: vtkAbstractTransform.h:462
vtkTransformPair::ForwardTransform
vtkAbstractTransform * ForwardTransform
Definition: vtkAbstractTransform.h:342
vtkObject.h
vtkAbstractTransform::TransformFloatVectorAtPoint
float * TransformFloatVectorAtPoint(const float point[3], const float vector[3])
Apply the transformation to a single-precision vector at the specified vertex.
Definition: vtkAbstractTransform.h:186
vtkTransformPair
Definition: vtkAbstractTransform.h:338
vtkAbstractTransform::TransformDoubleNormalAtPoint
double * TransformDoubleNormalAtPoint(const double point[3], const double normal[3])
Apply the transformation to a double-precision normal at the specified vertex.
Definition: vtkAbstractTransform.h:133
vtkAbstractTransform::TransformNormalAtPoint
void TransformNormalAtPoint(const float point[3], const float in[3], float out[3])
Apply the transformation to a normal at the specified vertex.
vtkTransformConcatenation::Inverse
void Inverse()
invert the concatenation
vtkTransformConcatenation::vtkTransformConcatenation
vtkTransformConcatenation()
vtkTransformConcatenationStack::StackBottom
vtkTransformConcatenation ** StackBottom
Definition: vtkAbstractTransform.h:491
vtkAbstractTransform::DeepCopy
void DeepCopy(vtkAbstractTransform *)
Copy this transform from another of the same type.
vtkTransformConcatenation::NumberOfTransforms
int NumberOfTransforms
Definition: vtkAbstractTransform.h:449
vtkAbstractTransform::TransformPoint
void TransformPoint(const float in[3], float out[3])
Apply the transformation to a coordinate.
Definition: vtkAbstractTransform.h:61
vtkAbstractTransform::TransformPoints
virtual void TransformPoints(vtkPoints *inPts, vtkPoints *outPts)
Apply the transformation to a series of points, and append the results to outPts.
vtkTransformConcatenation::DeepCopy
void DeepCopy(vtkTransformConcatenation *transform)
vtkTransformConcatenation::Rotate
void Rotate(double angle, double x, double y, double z)
vtkAbstractTransform::TransformDoublePoint
double * TransformDoublePoint(const double point[3])
Definition: vtkAbstractTransform.h:106
vtkAbstractTransform::TransformPointsNormalsVectors
virtual void TransformPointsNormalsVectors(vtkPoints *inPts, vtkPoints *outPts, vtkDataArray *inNms, vtkDataArray *outNms, vtkDataArray *inVrs, vtkDataArray *outVrs)
Apply the transformation to a combination of points, normals and vectors.
vtkTransformConcatenation::PreMultiplyFlag
int PreMultiplyFlag
Definition: vtkAbstractTransform.h:442
VTK_NEWINSTANCE
#define VTK_NEWINSTANCE
Definition: vtkWrappingHints.h:30
vtkTransformConcatenation::MaxNumberOfTransforms
int MaxNumberOfTransforms
Definition: vtkAbstractTransform.h:451
vtkTransformPair::vtkTransformPair
vtkTransformPair()
Definition: vtkAbstractTransform.h:340
vtkTransformConcatenationStack::Push
void Push(vtkTransformConcatenation **concat)
push will move 'concat' onto the stack, and make 'concat' a copy of its previous self
vtkTransformConcatenation::New
static vtkTransformConcatenation * New()
Definition: vtkAbstractTransform.h:358
vtkTransformConcatenation
Definition: vtkAbstractTransform.h:356
vtkAbstractTransform::InternalDeepCopy
virtual void InternalDeepCopy(vtkAbstractTransform *)
Perform any subclass-specific DeepCopy.
Definition: vtkAbstractTransform.h:303
vtkTransformConcatenationStack::~vtkTransformConcatenationStack
~vtkTransformConcatenationStack()
vtkAbstractTransform::TransformDoublePoint
double * TransformDoublePoint(double x, double y, double z)
Apply the transformation to a double-precision (x,y,z) coordinate.
Definition: vtkAbstractTransform.h:100