VTK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
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 =========================================================================*/
24 #ifndef __vtkLinearTransform_h
25 #define __vtkLinearTransform_h
26 
27 #include "vtkCommonTransformsModule.h" // For export macro
29 
30 class VTKCOMMONTRANSFORMS_EXPORT vtkLinearTransform : public vtkHomogeneousTransform
31 {
32 public:
33 
35  void PrintSelf(ostream& os, vtkIndent indent);
36 
38 
40  void TransformNormal(const float in[3], float out[3]) {
41  this->Update(); this->InternalTransformNormal(in,out); };
43 
45 
47  void TransformNormal(const double in[3], double out[3]) {
48  this->Update(); this->InternalTransformNormal(in,out); };
50 
52 
54  double *TransformNormal(double x, double y, double z) {
55  return this->TransformDoubleNormal(x,y,z); }
56  double *TransformNormal(const double normal[3]) {
57  return this->TransformDoubleNormal(normal[0],normal[1],normal[2]); };
59 
61 
63  float *TransformFloatNormal(float x, float y, float z) {
64  this->InternalFloatPoint[0] = x;
65  this->InternalFloatPoint[1] = y;
66  this->InternalFloatPoint[2] = z;
67  this->TransformNormal(this->InternalFloatPoint,this->InternalFloatPoint);
68  return this->InternalFloatPoint; };
69  float *TransformFloatNormal(const float normal[3]) {
70  return this->TransformFloatNormal(normal[0],normal[1],normal[2]); };
72 
74 
76  double *TransformDoubleNormal(double x, double y, double z) {
77  this->InternalDoublePoint[0] = x;
78  this->InternalDoublePoint[1] = y;
79  this->InternalDoublePoint[2] = z;
80  this->TransformNormal(this->InternalDoublePoint,this->InternalDoublePoint);
81  return this->InternalDoublePoint; };
82  double *TransformDoubleNormal(const double normal[3]) {
83  return this->TransformDoubleNormal(normal[0],normal[1],normal[2]); };
85 
87 
89  double *TransformVector(double x, double y, double z) {
90  return this->TransformDoubleVector(x,y,z); }
91  double *TransformVector(const double normal[3]) {
92  return this->TransformDoubleVector(normal[0],normal[1],normal[2]); };
94 
96 
98  void TransformVector(const float in[3], float out[3]) {
99  this->Update(); this->InternalTransformVector(in,out); };
101 
103 
105  void TransformVector(const double in[3], double out[3]) {
106  this->Update(); this->InternalTransformVector(in,out); };
108 
110 
112  float *TransformFloatVector(float x, float y, float z) {
113  this->InternalFloatPoint[0] = x;
114  this->InternalFloatPoint[1] = y;
115  this->InternalFloatPoint[2] = z;
116  this->TransformVector(this->InternalFloatPoint,this->InternalFloatPoint);
117  return this->InternalFloatPoint; };
118  float *TransformFloatVector(const float vec[3]) {
119  return this->TransformFloatVector(vec[0],vec[1],vec[2]); };
121 
123 
125  double *TransformDoubleVector(double x, double y, double z) {
126  this->InternalDoublePoint[0] = x;
127  this->InternalDoublePoint[1] = y;
128  this->InternalDoublePoint[2] = z;
129  this->TransformVector(this->InternalDoublePoint,this->InternalDoublePoint);
130  return this->InternalDoublePoint; };
131  double *TransformDoubleVector(const double vec[3]) {
132  return this->TransformDoubleVector(vec[0],vec[1],vec[2]); };
134 
137  void TransformPoints(vtkPoints *inPts, vtkPoints *outPts);
138 
141  virtual void TransformNormals(vtkDataArray *inNms, vtkDataArray *outNms);
142 
145  virtual void TransformVectors(vtkDataArray *inVrs, vtkDataArray *outVrs);
146 
148 
151  vtkPoints *outPts,
152  vtkDataArray *inNms,
153  vtkDataArray *outNms,
154  vtkDataArray *inVrs,
155  vtkDataArray *outVrs);
157 
159 
162  {
163  return static_cast<vtkLinearTransform *>(this->GetInverse());
164  }
166 
168 
170  void InternalTransformPoint(const float in[3], float out[3]);
171  void InternalTransformPoint(const double in[3], double out[3]);
173 
175 
177  virtual void InternalTransformNormal(const float in[3], float out[3]);
178  virtual void InternalTransformNormal(const double in[3], double out[3]);
180 
182 
184  virtual void InternalTransformVector(const float in[3], float out[3]);
185  virtual void InternalTransformVector(const double in[3], double out[3]);
187 
189 
191  void InternalTransformDerivative(const float in[3], float out[3],
192  float derivative[3][3]);
193  void InternalTransformDerivative(const double in[3], double out[3],
194  double derivative[3][3]);
196 
197 protected:
200 private:
201  vtkLinearTransform(const vtkLinearTransform&); // Not implemented.
202  void operator=(const vtkLinearTransform&); // Not implemented.
203 };
204 
205 #endif
206 
207 
208 
209 
210 
void TransformNormal(const double in[3], double out[3])
double * TransformDoubleNormal(double x, double y, double z)
void TransformVector(const float in[3], float out[3])
float * TransformFloatNormal(float x, float y, float z)
superclass for homogeneous transformations
double * TransformDoubleNormal(const double normal[3])
float * TransformFloatNormal(const float normal[3])
vtkAbstractTransform * GetInverse()
double * TransformVector(double x, double y, double z)
void TransformVector(const double in[3], double out[3])
void InternalTransformPoint(const float in[3], float out[3])
double * TransformVector(const double normal[3])
vtkLinearTransform * GetLinearInverse()
float * TransformFloatVector(const float vec[3])
a simple class to control print indentation
Definition: vtkIndent.h:38
double * TransformNormal(const double normal[3])
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:53
void InternalTransformDerivative(const float in[3], float out[3], float derivative[3][3])
double * TransformNormal(double x, double y, double z)
void TransformPoints(vtkPoints *inPts, vtkPoints *outPts)
void TransformNormal(const float in[3], float out[3])
float * TransformFloatVector(float x, float y, float z)
double * TransformDoubleVector(const double vec[3])
void PrintSelf(ostream &os, vtkIndent indent)
double * TransformDoubleVector(double x, double y, double z)
virtual void TransformPointsNormalsVectors(vtkPoints *inPts, vtkPoints *outPts, vtkDataArray *inNms, vtkDataArray *outNms, vtkDataArray *inVrs, vtkDataArray *outVrs)
represent and manipulate 3D points
Definition: vtkPoints.h:39
abstract superclass for linear transformations