VTK  9.0.1
vtkLinearTransform.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkLinearTransform.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 =========================================================================*/
25 #ifndef vtkLinearTransform_h
26 #define vtkLinearTransform_h
27 
28 #include "vtkCommonTransformsModule.h" // For export macro
30 
31 class VTKCOMMONTRANSFORMS_EXPORT vtkLinearTransform : public vtkHomogeneousTransform
32 {
33 public:
35  void PrintSelf(ostream& os, vtkIndent indent) override;
36 
41  void TransformNormal(const float in[3], float out[3])
42  {
43  this->Update();
44  this->InternalTransformNormal(in, out);
45  }
46 
51  void TransformNormal(const double in[3], double out[3])
52  {
53  this->Update();
54  this->InternalTransformNormal(in, out);
55  }
56 
61  double* TransformNormal(double x, double y, double z) VTK_SIZEHINT(3)
62  {
63  return this->TransformDoubleNormal(x, y, z);
64  }
65  double* TransformNormal(const double normal[3]) VTK_SIZEHINT(3)
66  {
67  return this->TransformDoubleNormal(normal[0], normal[1], normal[2]);
68  }
69 
71 
75  float* TransformFloatNormal(float x, float y, float z) VTK_SIZEHINT(3)
76  {
77  this->InternalFloatPoint[0] = x;
78  this->InternalFloatPoint[1] = y;
79  this->InternalFloatPoint[2] = z;
80  this->TransformNormal(this->InternalFloatPoint, this->InternalFloatPoint);
81  return this->InternalFloatPoint;
82  }
83  float* TransformFloatNormal(const float normal[3]) VTK_SIZEHINT(3)
84  {
85  return this->TransformFloatNormal(normal[0], normal[1], normal[2]);
86  }
88 
90 
94  double* TransformDoubleNormal(double x, double y, double z) VTK_SIZEHINT(3)
95  {
96  this->InternalDoublePoint[0] = x;
97  this->InternalDoublePoint[1] = y;
98  this->InternalDoublePoint[2] = z;
99  this->TransformNormal(this->InternalDoublePoint, this->InternalDoublePoint);
100  return this->InternalDoublePoint;
101  }
102  double* TransformDoubleNormal(const double normal[3]) VTK_SIZEHINT(3)
103  {
104  return this->TransformDoubleNormal(normal[0], normal[1], normal[2]);
105  }
107 
112  double* TransformVector(double x, double y, double z) VTK_SIZEHINT(3)
113  {
114  return this->TransformDoubleVector(x, y, z);
115  }
116  double* TransformVector(const double normal[3]) VTK_SIZEHINT(3)
117  {
118  return this->TransformDoubleVector(normal[0], normal[1], normal[2]);
119  }
120 
125  void TransformVector(const float in[3], float out[3])
126  {
127  this->Update();
128  this->InternalTransformVector(in, out);
129  }
130 
135  void TransformVector(const double in[3], double out[3])
136  {
137  this->Update();
138  this->InternalTransformVector(in, out);
139  }
140 
142 
146  float* TransformFloatVector(float x, float y, float z) VTK_SIZEHINT(3)
147  {
148  this->InternalFloatPoint[0] = x;
149  this->InternalFloatPoint[1] = y;
150  this->InternalFloatPoint[2] = z;
151  this->TransformVector(this->InternalFloatPoint, this->InternalFloatPoint);
152  return this->InternalFloatPoint;
153  }
154  float* TransformFloatVector(const float vec[3]) VTK_SIZEHINT(3)
155  {
156  return this->TransformFloatVector(vec[0], vec[1], vec[2]);
157  }
159 
161 
165  double* TransformDoubleVector(double x, double y, double z) VTK_SIZEHINT(3)
166  {
167  this->InternalDoublePoint[0] = x;
168  this->InternalDoublePoint[1] = y;
169  this->InternalDoublePoint[2] = z;
170  this->TransformVector(this->InternalDoublePoint, this->InternalDoublePoint);
171  return this->InternalDoublePoint;
172  }
173  double* TransformDoubleVector(const double vec[3]) VTK_SIZEHINT(3)
174  {
175  return this->TransformDoubleVector(vec[0], vec[1], vec[2]);
176  }
178 
183  void TransformPoints(vtkPoints* inPts, vtkPoints* outPts) override;
184 
189  virtual void TransformNormals(vtkDataArray* inNms, vtkDataArray* outNms);
190 
195  virtual void TransformVectors(vtkDataArray* inVrs, vtkDataArray* outVrs);
196 
202  vtkDataArray* outNms, vtkDataArray* inVrs, vtkDataArray* outVrs, int nOptionalVectors = 0,
203  vtkDataArray** inVrsArr = nullptr, vtkDataArray** outVrsArr = nullptr) override;
204 
210  {
211  return static_cast<vtkLinearTransform*>(this->GetInverse());
212  }
213 
215 
219  void InternalTransformPoint(const float in[3], float out[3]) override;
220  void InternalTransformPoint(const double in[3], double out[3]) override;
222 
224 
228  virtual void InternalTransformNormal(const float in[3], float out[3]);
229  virtual void InternalTransformNormal(const double in[3], double out[3]);
231 
233 
237  virtual void InternalTransformVector(const float in[3], float out[3]);
238  virtual void InternalTransformVector(const double in[3], double out[3]);
240 
242 
248  const float in[3], float out[3], float derivative[3][3]) override;
250  const double in[3], double out[3], double derivative[3][3]) override;
252 
253 protected:
255  ~vtkLinearTransform() override {}
256 
257 private:
258  vtkLinearTransform(const vtkLinearTransform&) = delete;
259  void operator=(const vtkLinearTransform&) = delete;
260 };
261 
262 #endif
void Update()
Update the transform to account for any changes which have been made.
vtkAbstractTransform * GetInverse()
Get the inverse of this transform.
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:50
superclass for homogeneous transformations
a simple class to control print indentation
Definition: vtkIndent.h:34
abstract superclass for linear transformations
virtual void TransformVectors(vtkDataArray *inVrs, vtkDataArray *outVrs)
Apply the transformation to a series of vectors, and append the results to outVrs.
virtual void TransformNormals(vtkDataArray *inNms, vtkDataArray *outNms)
Apply the transformation to a series of normals, and append the results to outNms.
virtual void InternalTransformVector(const float in[3], float out[3])
This will calculate the transformation without calling Update.
void InternalTransformPoint(const float in[3], float out[3]) override
This will calculate the transformation without calling Update.
double * TransformNormal(double x, double y, double z)
Synonymous with TransformDoubleNormal(x,y,z).
double * TransformDoubleVector(double x, double y, double z)
Apply the transformation to a double-precision (x,y,z) vector.
void InternalTransformDerivative(const float in[3], float out[3], float derivative[3][3]) override
This will calculate the transformation as well as its derivative without calling Update.
void TransformPoints(vtkPoints *inPts, vtkPoints *outPts) override
Apply the transformation to a series of points, and append the results to outPts.
float * TransformFloatNormal(float x, float y, float z)
Apply the transformation to an (x,y,z) normal.
void InternalTransformPoint(const double in[3], double out[3]) override
double * TransformDoubleVector(const double vec[3])
virtual void InternalTransformNormal(const float in[3], float out[3])
This will calculate the transformation without calling Update.
virtual void InternalTransformVector(const double in[3], double out[3])
virtual void InternalTransformNormal(const double in[3], double out[3])
double * TransformVector(double x, double y, double z)
Synonymous with TransformDoubleVector(x,y,z).
float * TransformFloatNormal(const float normal[3])
void TransformPointsNormalsVectors(vtkPoints *inPts, vtkPoints *outPts, vtkDataArray *inNms, vtkDataArray *outNms, vtkDataArray *inVrs, vtkDataArray *outVrs, int nOptionalVectors=0, vtkDataArray **inVrsArr=nullptr, vtkDataArray **outVrsArr=nullptr) override
Apply the transformation to a combination of points, normals and vectors.
vtkLinearTransform * GetLinearInverse()
Just like GetInverse, but it includes a typecast to vtkLinearTransform.
float * TransformFloatVector(const float vec[3])
void TransformVector(const float in[3], float out[3])
Apply the transformation to a vector.
void TransformNormal(const float in[3], float out[3])
Apply the transformation to a normal.
void TransformVector(const double in[3], double out[3])
Apply the transformation to a double-precision vector.
float * TransformFloatVector(float x, float y, float z)
Apply the transformation to an (x,y,z) vector.
double * TransformDoubleNormal(const double normal[3])
double * TransformNormal(const double normal[3])
void InternalTransformDerivative(const double in[3], double out[3], double derivative[3][3]) override
double * TransformVector(const double normal[3])
~vtkLinearTransform() override
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
void TransformNormal(const double in[3], double out[3])
Apply the transformation to a double-precision normal.
double * TransformDoubleNormal(double x, double y, double z)
Apply the transformation to a double-precision (x,y,z) normal.
represent and manipulate 3D points
Definition: vtkPoints.h:34
#define VTK_SIZEHINT(...)