Common/vtkGeneralTransform.h Source File

Main Page Class Hierarchy Alphabetical List Compound List File List Compound Members File Members Related Pages

# Common/vtkGeneralTransform.h

Go to the documentation of this file.

    00001 /*=========================================================================
    00002
    00003   Program:   Visualization Toolkit
    00004   Module:    $RCSfile: vtkGeneralTransform.h,v $
    00005   Language:  C++
    00006
    00007   Copyright (c) 1993-2002 Ken Martin, Will Schroeder, Bill Lorensen
    00008   All rights reserved.
    00009   See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
    00010
    00011      This software is distributed WITHOUT ANY WARRANTY; without even
    00012      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
    00013      PURPOSE.  See the above copyright notice for more information.
    00014
    00015 =========================================================================*/
    00045 #ifndef __vtkGeneralTransform_h
    00046 #define __vtkGeneralTransform_h
    00047
    00048 #include "vtkAbstractTransform.h"
    00049
    00050 #include "vtkMatrix4x4.h" // Needed for inline methods
    00051
    00052 class VTK_COMMON_EXPORT vtkGeneralTransform : public vtkAbstractTransform
    00053 {
    00054 public:
    00055   static vtkGeneralTransform *New();
    00056
    00057   vtkTypeRevisionMacro(vtkGeneralTransform,vtkAbstractTransform);
    00058   void PrintSelf(ostream& os, vtkIndent indent);
    00059
    00063   void Identity() { this->Concatenation->Identity(); this->Modified(); };
    00064
    00068   void Inverse() { this->Concatenation->Inverse(); this->Modified(); };
    00069
    00071
    00073   void Translate(double x, double y, double z) {
    00074     this->Concatenation->Translate(x,y,z); };
    00075   void Translate(const double x[3]) { this->Translate(x[0], x[1], x[2]); };
    00076   void Translate(const float x[3]) { this->Translate(x[0], x[1], x[2]); };
    00078
    00080
    00084   void RotateWXYZ(double angle, double x, double y, double z) {
    00085     this->Concatenation->Rotate(angle,x,y,z); };
    00086   void RotateWXYZ(double angle, const double axis[3]) {
    00087     this->RotateWXYZ(angle, axis[0], axis[1], axis[2]); };
    00088   void RotateWXYZ(double angle, const float axis[3]) {
    00089     this->RotateWXYZ(angle, axis[0], axis[1], axis[2]); };
    00091
    00093
    00096   void RotateX(double angle) { this->RotateWXYZ(angle, 1, 0, 0); };
    00097   void RotateY(double angle) { this->RotateWXYZ(angle, 0, 1, 0); };
    00098   void RotateZ(double angle) { this->RotateWXYZ(angle, 0, 0, 1); };
    00100
    00102
    00105   void Scale(double x, double y, double z) {
    00106     this->Concatenation->Scale(x,y,z); };
    00107   void Scale(const double s[3]) { this->Scale(s[0], s[1], s[2]); };
    00108   void Scale(const float s[3]) { this->Scale(s[0], s[1], s[2]); };
    00110
    00112
    00114   void Concatenate(vtkMatrix4x4 *matrix) {
    00115     this->Concatenate(*matrix->Element); };
    00116   void Concatenate(const double elements[16]) {
    00117     this->Concatenation->Concatenate(elements); };
    00119
    00125   void Concatenate(vtkAbstractTransform *transform);
    00126
    00128
    00133   void PreMultiply() {
    00134     if (this->Concatenation->GetPreMultiplyFlag()) { return; }
    00135     this->Concatenation->SetPreMultiplyFlag(1); this->Modified(); };
    00137
    00139
    00144   void PostMultiply()  {
    00145     if (!this->Concatenation->GetPreMultiplyFlag()) { return; }
    00146     this->Concatenation->SetPreMultiplyFlag(0); this->Modified(); };
    00148
    00150
    00152   int GetNumberOfConcatenatedTransforms() {
    00153     return this->Concatenation->GetNumberOfTransforms() +
    00154       (this->Input == NULL ? 0 : 1); };
    00156
    00158
    00163   vtkAbstractTransform *GetConcatenatedTransform(int i) {
    00164     if (this->Input == NULL) {
    00165       return this->Concatenation->GetTransform(i); }
    00166     else if (i < this->Concatenation->GetNumberOfPreTransforms()) {
    00167       return this->Concatenation->GetTransform(i); }
    00168     else if (i > this->Concatenation->GetNumberOfPreTransforms()) {
    00169       return this->Concatenation->GetTransform(i-1); }
    00170     else if (this->GetInverseFlag()) {
    00171       return this->Input->GetInverse(); }
    00172     else {
    00173       return this->Input; } };
    00175
    00177
    00183   void SetInput(vtkAbstractTransform *input);
    00184   vtkAbstractTransform *GetInput() { return this->Input; };
    00186
    00188
    00192   int GetInverseFlag() {
    00193     return this->Concatenation->GetInverseFlag(); };
    00195
    00197
    00198   void Push() { if (this->Stack == NULL) {
    00199                     this->Stack = vtkTransformConcatenationStack::New(); }
    00200                 this->Stack->Push(&this->Concatenation);
    00201                 this->Modified(); };
    00203
    00205
    00207   void Pop() { if (this->Stack == NULL) { return; }
    00208                this->Stack->Pop(&this->Concatenation);
    00209                this->Modified(); };
    00211
    00213
    00215   void InternalTransformPoint(const float in[3], float out[3]);
    00216   void InternalTransformPoint(const double in[3], double out[3]);
    00218
    00220
    00222   void InternalTransformDerivative(const float in[3], float out[3],
    00223                                    float derivative[3][3]);
    00224   void InternalTransformDerivative(const double in[3], double out[3],
    00225                                    double derivative[3][3]);
    00227
    00234   int CircuitCheck(vtkAbstractTransform *transform);
    00235
    00237   vtkAbstractTransform *MakeTransform();
    00238
    00240   unsigned long GetMTime();
    00241
    00242 protected:
    00243   vtkGeneralTransform();
    00244   ~vtkGeneralTransform();
    00245
    00246   void InternalDeepCopy(vtkAbstractTransform *t);
    00247   void InternalUpdate();
    00248
    00249   vtkAbstractTransform *Input;
    00250   vtkTransformConcatenation *Concatenation;
    00251   vtkTransformConcatenationStack *Stack;
    00252 private:
    00253   vtkGeneralTransform(const vtkGeneralTransform&);  // Not implemented.
    00254   void operator=(const vtkGeneralTransform&);  // Not implemented.
    00255 };
    00256
    00257
    00258 #endif
    00259
    00260
    00261
    00262
    00263