VTK  9.2.6
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=========================================================================*/
33#ifndef vtkLinearTransform_h
34#define vtkLinearTransform_h
35
36#include "vtkCommonTransformsModule.h" // For export macro
38
39class VTKCOMMONTRANSFORMS_EXPORT vtkLinearTransform : public vtkHomogeneousTransform
40{
41public:
43 void PrintSelf(ostream& os, vtkIndent indent) override;
44
49 void TransformNormal(const float in[3], float out[3])
50 {
51 this->Update();
52 this->InternalTransformNormal(in, out);
53 }
54
59 void TransformNormal(const double in[3], double out[3])
60 {
61 this->Update();
62 this->InternalTransformNormal(in, out);
63 }
64
69 double* TransformNormal(double x, double y, double z) VTK_SIZEHINT(3)
70 {
71 return this->TransformDoubleNormal(x, y, z);
72 }
73 double* TransformNormal(const double normal[3]) VTK_SIZEHINT(3)
74 {
75 return this->TransformDoubleNormal(normal[0], normal[1], normal[2]);
76 }
77
79
83 float* TransformFloatNormal(float x, float y, float z) VTK_SIZEHINT(3)
84 {
85 this->InternalFloatPoint[0] = x;
86 this->InternalFloatPoint[1] = y;
87 this->InternalFloatPoint[2] = z;
88 this->TransformNormal(this->InternalFloatPoint, this->InternalFloatPoint);
89 return this->InternalFloatPoint;
90 }
91 float* TransformFloatNormal(const float normal[3]) VTK_SIZEHINT(3)
92 {
93 return this->TransformFloatNormal(normal[0], normal[1], normal[2]);
94 }
96
98
102 double* TransformDoubleNormal(double x, double y, double z) VTK_SIZEHINT(3)
103 {
104 this->InternalDoublePoint[0] = x;
105 this->InternalDoublePoint[1] = y;
106 this->InternalDoublePoint[2] = z;
107 this->TransformNormal(this->InternalDoublePoint, this->InternalDoublePoint);
108 return this->InternalDoublePoint;
109 }
110 double* TransformDoubleNormal(const double normal[3]) VTK_SIZEHINT(3)
111 {
112 return this->TransformDoubleNormal(normal[0], normal[1], normal[2]);
113 }
115
120 double* TransformVector(double x, double y, double z) VTK_SIZEHINT(3)
121 {
122 return this->TransformDoubleVector(x, y, z);
123 }
124 double* TransformVector(const double normal[3]) VTK_SIZEHINT(3)
125 {
126 return this->TransformDoubleVector(normal[0], normal[1], normal[2]);
127 }
128
133 void TransformVector(const float in[3], float out[3])
134 {
135 this->Update();
136 this->InternalTransformVector(in, out);
137 }
138
143 void TransformVector(const double in[3], double out[3])
144 {
145 this->Update();
146 this->InternalTransformVector(in, out);
147 }
148
150
154 float* TransformFloatVector(float x, float y, float z) VTK_SIZEHINT(3)
155 {
156 this->InternalFloatPoint[0] = x;
157 this->InternalFloatPoint[1] = y;
158 this->InternalFloatPoint[2] = z;
159 this->TransformVector(this->InternalFloatPoint, this->InternalFloatPoint);
160 return this->InternalFloatPoint;
161 }
162 float* TransformFloatVector(const float vec[3]) VTK_SIZEHINT(3)
163 {
164 return this->TransformFloatVector(vec[0], vec[1], vec[2]);
165 }
167
169
173 double* TransformDoubleVector(double x, double y, double z) VTK_SIZEHINT(3)
174 {
175 this->InternalDoublePoint[0] = x;
176 this->InternalDoublePoint[1] = y;
177 this->InternalDoublePoint[2] = z;
178 this->TransformVector(this->InternalDoublePoint, this->InternalDoublePoint);
179 return this->InternalDoublePoint;
180 }
181 double* TransformDoubleVector(const double vec[3]) VTK_SIZEHINT(3)
182 {
183 return this->TransformDoubleVector(vec[0], vec[1], vec[2]);
184 }
186
191 void TransformPoints(vtkPoints* inPts, vtkPoints* outPts) override;
192
197 virtual void TransformNormals(vtkDataArray* inNms, vtkDataArray* outNms);
198
203 virtual void TransformVectors(vtkDataArray* inVrs, vtkDataArray* outVrs);
204
210 vtkDataArray* outNms, vtkDataArray* inVrs, vtkDataArray* outVrs, int nOptionalVectors = 0,
211 vtkDataArray** inVrsArr = nullptr, vtkDataArray** outVrsArr = nullptr) override;
212
218 {
219 return static_cast<vtkLinearTransform*>(this->GetInverse());
220 }
221
223
227 void InternalTransformPoint(const float in[3], float out[3]) override;
228 void InternalTransformPoint(const double in[3], double out[3]) override;
230
232
236 virtual void InternalTransformNormal(const float in[3], float out[3]);
237 virtual void InternalTransformNormal(const double in[3], double out[3]);
239
241
245 virtual void InternalTransformVector(const float in[3], float out[3]);
246 virtual void InternalTransformVector(const double in[3], double out[3]);
248
250
256 const float in[3], float out[3], float derivative[3][3]) override;
258 const double in[3], double out[3], double derivative[3][3]) override;
260
261protected:
263 ~vtkLinearTransform() override = default;
264
265private:
266 vtkLinearTransform(const vtkLinearTransform&) = delete;
267 void operator=(const vtkLinearTransform&) = delete;
268};
269
270#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
superclass for homogeneous transformations
a simple class to control print indentation
Definition vtkIndent.h:34
abstract superclass for linear transformations
double * TransformNormal(const double normal[3])
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.
float * TransformFloatVector(float x, float y, float z)
Apply the transformation to an (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.
double * TransformVector(const double normal[3])
void TransformPoints(vtkPoints *inPts, vtkPoints *outPts) override
Apply the transformation to a series of points, and append the results to outPts.
double * TransformDoubleNormal(double x, double y, double z)
Apply the transformation to a double-precision (x,y,z) normal.
void InternalTransformPoint(const double in[3], double out[3]) override
This will calculate the transformation without calling Update.
virtual void InternalTransformNormal(const float in[3], float out[3])
This will calculate the transformation without calling Update.
double * TransformDoubleVector(double x, double y, double z)
Apply the transformation to a double-precision (x,y,z) vector.
virtual void InternalTransformVector(const double in[3], double out[3])
This will calculate the transformation without calling Update.
vtkLinearTransform()=default
virtual void InternalTransformNormal(const double in[3], double out[3])
This will calculate the transformation without calling Update.
double * TransformDoubleNormal(const double normal[3])
Apply the transformation to a double-precision (x,y,z) normal.
~vtkLinearTransform() override=default
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.
float * TransformFloatNormal(float x, float y, float z)
Apply the transformation to an (x,y,z) normal.
double * TransformNormal(double x, double y, double z)
Synonymous with TransformDoubleNormal(x,y,z).
void TransformVector(const float in[3], float out[3])
Apply the transformation to a vector.
vtkLinearTransform * GetLinearInverse()
Just like GetInverse, but it includes a typecast to vtkLinearTransform.
void TransformNormal(const float in[3], float out[3])
Apply the transformation to a normal.
float * TransformFloatVector(const float vec[3])
Apply the transformation to an (x,y,z) vector.
void TransformVector(const double in[3], double out[3])
Apply the transformation to a double-precision vector.
double * TransformVector(double x, double y, double z)
Synonymous with TransformDoubleVector(x,y,z).
float * TransformFloatNormal(const float normal[3])
Apply the transformation to an (x,y,z) normal.
void InternalTransformDerivative(const double in[3], double out[3], double derivative[3][3]) override
This will calculate the transformation as well as its derivative without calling Update.
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 * TransformDoubleVector(const double vec[3])
Apply the transformation to a double-precision (x,y,z) vector.
represent and manipulate 3D points
Definition vtkPoints.h:34
#define VTK_SIZEHINT(...)