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 =========================================================================*/
24 #ifndef __vtkLinearTransform_h
25 #define __vtkLinearTransform_h
26 
28 
30 {
31 public:
32 
34  void PrintSelf(ostream& os, vtkIndent indent);
35 
37 
39  void TransformNormal(const float in[3], float out[3]) {
40  this->Update(); this->InternalTransformNormal(in,out); };
42 
44 
46  void TransformNormal(const double in[3], double out[3]) {
47  this->Update(); this->InternalTransformNormal(in,out); };
49 
51 
53  double *TransformNormal(double x, double y, double z) {
54  return this->TransformDoubleNormal(x,y,z); }
55  double *TransformNormal(const double normal[3]) {
56  return this->TransformDoubleNormal(normal[0],normal[1],normal[2]); };
58 
60 
62  float *TransformFloatNormal(float x, float y, float z) {
63  this->InternalFloatPoint[0] = x;
64  this->InternalFloatPoint[1] = y;
65  this->InternalFloatPoint[2] = z;
66  this->TransformNormal(this->InternalFloatPoint,this->InternalFloatPoint);
67  return this->InternalFloatPoint; };
68  float *TransformFloatNormal(const float normal[3]) {
69  return this->TransformFloatNormal(normal[0],normal[1],normal[2]); };
71 
73 
75  double *TransformDoubleNormal(double x, double y, double z) {
76  this->InternalDoublePoint[0] = x;
77  this->InternalDoublePoint[1] = y;
78  this->InternalDoublePoint[2] = z;
79  this->TransformNormal(this->InternalDoublePoint,this->InternalDoublePoint);
80  return this->InternalDoublePoint; };
81  double *TransformDoubleNormal(const double normal[3]) {
82  return this->TransformDoubleNormal(normal[0],normal[1],normal[2]); };
84 
86 
88  double *TransformVector(double x, double y, double z) {
89  return this->TransformDoubleVector(x,y,z); }
90  double *TransformVector(const double normal[3]) {
91  return this->TransformDoubleVector(normal[0],normal[1],normal[2]); };
93 
95 
97  void TransformVector(const float in[3], float out[3]) {
98  this->Update(); this->InternalTransformVector(in,out); };
100 
102 
104  void TransformVector(const double in[3], double out[3]) {
105  this->Update(); this->InternalTransformVector(in,out); };
107 
109 
111  float *TransformFloatVector(float x, float y, float z) {
112  this->InternalFloatPoint[0] = x;
113  this->InternalFloatPoint[1] = y;
114  this->InternalFloatPoint[2] = z;
115  this->TransformVector(this->InternalFloatPoint,this->InternalFloatPoint);
116  return this->InternalFloatPoint; };
117  float *TransformFloatVector(const float vec[3]) {
118  return this->TransformFloatVector(vec[0],vec[1],vec[2]); };
120 
122 
124  double *TransformDoubleVector(double x, double y, double z) {
125  this->InternalDoublePoint[0] = x;
126  this->InternalDoublePoint[1] = y;
127  this->InternalDoublePoint[2] = z;
128  this->TransformVector(this->InternalDoublePoint,this->InternalDoublePoint);
129  return this->InternalDoublePoint; };
130  double *TransformDoubleVector(const double vec[3]) {
131  return this->TransformDoubleVector(vec[0],vec[1],vec[2]); };
133 
136  void TransformPoints(vtkPoints *inPts, vtkPoints *outPts);
137 
140  virtual void TransformNormals(vtkDataArray *inNms, vtkDataArray *outNms);
141 
144  virtual void TransformVectors(vtkDataArray *inVrs, vtkDataArray *outVrs);
145 
147 
150  vtkPoints *outPts,
151  vtkDataArray *inNms,
152  vtkDataArray *outNms,
153  vtkDataArray *inVrs,
154  vtkDataArray *outVrs);
156 
158 
161  {
162  return static_cast<vtkLinearTransform *>(this->GetInverse());
163  }
165 
167 
169  void InternalTransformPoint(const float in[3], float out[3]);
170  void InternalTransformPoint(const double in[3], double out[3]);
172 
174 
176  virtual void InternalTransformNormal(const float in[3], float out[3]);
177  virtual void InternalTransformNormal(const double in[3], double out[3]);
179 
181 
183  virtual void InternalTransformVector(const float in[3], float out[3]);
184  virtual void InternalTransformVector(const double in[3], double out[3]);
186 
188 
190  void InternalTransformDerivative(const float in[3], float out[3],
191  float derivative[3][3]);
192  void InternalTransformDerivative(const double in[3], double out[3],
193  double derivative[3][3]);
195 
196 protected:
199 private:
200  vtkLinearTransform(const vtkLinearTransform&); // Not implemented.
201  void operator=(const vtkLinearTransform&); // Not implemented.
202 };
203 
204 #endif
205 
206 
207 
208 
209 
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:37
double * TransformNormal(const double normal[3])
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:53
#define VTK_COMMON_EXPORT
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:38
abstract superclass for linear transformations