VTK  9.3.0
vtkLinearTransform.h
Go to the documentation of this file.
1// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
2// SPDX-License-Identifier: BSD-3-Clause
24#ifndef vtkLinearTransform_h
25#define vtkLinearTransform_h
26
27#include "vtkCommonTransformsModule.h" // For export macro
29
30VTK_ABI_NAMESPACE_BEGIN
31class VTKCOMMONTRANSFORMS_EXPORT vtkLinearTransform : public vtkHomogeneousTransform
32{
33public:
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
253protected:
255 ~vtkLinearTransform() override = default;
256
257private:
258 vtkLinearTransform(const vtkLinearTransform&) = delete;
259 void operator=(const vtkLinearTransform&) = delete;
260};
261
262VTK_ABI_NAMESPACE_END
263#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:29
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:29
#define VTK_SIZEHINT(...)