VTK
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=========================================================================*/
28#ifndef vtkLinearTransform_h
29#define vtkLinearTransform_h
30
31#include "vtkCommonTransformsModule.h" // For export macro
33
34class VTKCOMMONTRANSFORMS_EXPORT vtkLinearTransform : public vtkHomogeneousTransform
35{
36public:
37
39 void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;
40
45 void TransformNormal(const float in[3], float out[3]) {
46 this->Update(); this->InternalTransformNormal(in,out); };
47
52 void TransformNormal(const double in[3], double out[3]) {
53 this->Update(); this->InternalTransformNormal(in,out); };
54
59 double *TransformNormal(double x, double y, double z) {
60 return this->TransformDoubleNormal(x,y,z); }
61 double *TransformNormal(const double normal[3]) {
62 return this->TransformDoubleNormal(normal[0],normal[1],normal[2]); };
63
65
69 float *TransformFloatNormal(float x, float y, float z) {
70 this->InternalFloatPoint[0] = x;
71 this->InternalFloatPoint[1] = y;
72 this->InternalFloatPoint[2] = z;
73 this->TransformNormal(this->InternalFloatPoint,this->InternalFloatPoint);
74 return this->InternalFloatPoint; };
75 float *TransformFloatNormal(const float normal[3]) {
76 return this->TransformFloatNormal(normal[0],normal[1],normal[2]); };
78
80
84 double *TransformDoubleNormal(double x, double y, double z) {
85 this->InternalDoublePoint[0] = x;
86 this->InternalDoublePoint[1] = y;
87 this->InternalDoublePoint[2] = z;
88 this->TransformNormal(this->InternalDoublePoint,this->InternalDoublePoint);
89 return this->InternalDoublePoint; };
90 double *TransformDoubleNormal(const double normal[3]) {
91 return this->TransformDoubleNormal(normal[0],normal[1],normal[2]); };
93
98 double *TransformVector(double x, double y, double z) {
99 return this->TransformDoubleVector(x,y,z); }
100 double *TransformVector(const double normal[3]) {
101 return this->TransformDoubleVector(normal[0],normal[1],normal[2]); };
102
107 void TransformVector(const float in[3], float out[3]) {
108 this->Update(); this->InternalTransformVector(in,out); };
109
114 void TransformVector(const double in[3], double out[3]) {
115 this->Update(); this->InternalTransformVector(in,out); };
116
118
122 float *TransformFloatVector(float x, float y, float z) {
123 this->InternalFloatPoint[0] = x;
124 this->InternalFloatPoint[1] = y;
125 this->InternalFloatPoint[2] = z;
126 this->TransformVector(this->InternalFloatPoint,this->InternalFloatPoint);
127 return this->InternalFloatPoint; };
128 float *TransformFloatVector(const float vec[3]) {
129 return this->TransformFloatVector(vec[0],vec[1],vec[2]); };
131
133
137 double *TransformDoubleVector(double x, double y, double z) {
138 this->InternalDoublePoint[0] = x;
139 this->InternalDoublePoint[1] = y;
140 this->InternalDoublePoint[2] = z;
141 this->TransformVector(this->InternalDoublePoint,this->InternalDoublePoint);
142 return this->InternalDoublePoint; };
143 double *TransformDoubleVector(const double vec[3]) {
144 return this->TransformDoubleVector(vec[0],vec[1],vec[2]); };
146
151 void TransformPoints(vtkPoints *inPts, vtkPoints *outPts) VTK_OVERRIDE;
152
157 virtual void TransformNormals(vtkDataArray *inNms, vtkDataArray *outNms);
158
163 virtual void TransformVectors(vtkDataArray *inVrs, vtkDataArray *outVrs);
164
170 vtkPoints *outPts,
171 vtkDataArray *inNms,
172 vtkDataArray *outNms,
173 vtkDataArray *inVrs,
174 vtkDataArray *outVrs) VTK_OVERRIDE;
175
181 {
182 return static_cast<vtkLinearTransform *>(this->GetInverse());
183 }
184
186
190 void InternalTransformPoint(const float in[3], float out[3]) VTK_OVERRIDE;
191 void InternalTransformPoint(const double in[3], double out[3]) VTK_OVERRIDE;
193
195
199 virtual void InternalTransformNormal(const float in[3], float out[3]);
200 virtual void InternalTransformNormal(const double in[3], double out[3]);
202
204
208 virtual void InternalTransformVector(const float in[3], float out[3]);
209 virtual void InternalTransformVector(const double in[3], double out[3]);
211
213
218 void InternalTransformDerivative(const float in[3], float out[3],
219 float derivative[3][3]) VTK_OVERRIDE;
220 void InternalTransformDerivative(const double in[3], double out[3],
221 double derivative[3][3]) VTK_OVERRIDE;
223
224protected:
226 ~vtkLinearTransform() VTK_OVERRIDE {}
227private:
228 vtkLinearTransform(const vtkLinearTransform&) VTK_DELETE_FUNCTION;
229 void operator=(const vtkLinearTransform&) VTK_DELETE_FUNCTION;
230};
231
232#endif
233
234
235
236
237
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:55
superclass for homogeneous transformations
a simple class to control print indentation
Definition: vtkIndent.h:40
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.
void TransformPointsNormalsVectors(vtkPoints *inPts, vtkPoints *outPts, vtkDataArray *inNms, vtkDataArray *outNms, vtkDataArray *inVrs, vtkDataArray *outVrs) override
Apply the transformation to a combination of points, normals and vectors.
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
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])
virtual void InternalTransformNormal(const double in[3], double out[3])
double * TransformDoubleNormal(const double normal[3])
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])
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])
void InternalTransformDerivative(const double in[3], double out[3], double derivative[3][3]) override
~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 * TransformDoubleVector(const double vec[3])
represent and manipulate 3D points
Definition: vtkPoints.h:40