vtkTransform.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkTransform.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
 
#ifndef vtkTransform_h
#define vtkTransform_h
 
#include "vtkCommonTransformsModule.h" // For export macro
#include "vtkLinearTransform.h"
 
#include "vtkMatrix4x4.h" // Needed for inline methods
 
class VTKCOMMONTRANSFORMS_EXPORT vtkTransform : public vtkLinearTransform
{
public:
  static vtkTransform* New();
  vtkTypeMacro(vtkTransform, vtkLinearTransform);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  void Identity();
 
  void Inverse() override;
 
 
  void Translate(double x, double y, double z) { this->Concatenation->Translate(x, y, z); }
  void Translate(const double x[3]) { this->Translate(x[0], x[1], x[2]); }
  void Translate(const float x[3]) { this->Translate(x[0], x[1], x[2]); }
 
 
  void RotateWXYZ(double angle, double x, double y, double z)
  {
    this->Concatenation->Rotate(angle, x, y, z);
  }
  void RotateWXYZ(double angle, const double axis[3])
  {
    this->RotateWXYZ(angle, axis[0], axis[1], axis[2]);
  }
  void RotateWXYZ(double angle, const float axis[3])
  {
    this->RotateWXYZ(angle, axis[0], axis[1], axis[2]);
  }
 
 
  void RotateX(double angle) { this->RotateWXYZ(angle, 1, 0, 0); }
  void RotateY(double angle) { this->RotateWXYZ(angle, 0, 1, 0); }
  void RotateZ(double angle) { this->RotateWXYZ(angle, 0, 0, 1); }
 
 
  void Scale(double x, double y, double z) { this->Concatenation->Scale(x, y, z); }
  void Scale(const double s[3]) { this->Scale(s[0], s[1], s[2]); }
  void Scale(const float s[3]) { this->Scale(s[0], s[1], s[2]); }
 
 
  void SetMatrix(vtkMatrix4x4* matrix) { this->SetMatrix(*matrix->Element); }
  void SetMatrix(const double elements[16])
  {
    this->Concatenation->Identity();
    this->Concatenate(elements);
  }
 
 
  void Concatenate(vtkMatrix4x4* matrix) { this->Concatenate(*matrix->Element); }
  void Concatenate(const double elements[16]) { this->Concatenation->Concatenate(elements); }
 
  void Concatenate(vtkLinearTransform* transform);
 
  void PreMultiply()
  {
    if (this->Concatenation->GetPreMultiplyFlag())
    {
      return;
    }
    this->Concatenation->SetPreMultiplyFlag(1);
    this->Modified();
  }
 
  void PostMultiply()
  {
    if (!this->Concatenation->GetPreMultiplyFlag())
    {
      return;
    }
    this->Concatenation->SetPreMultiplyFlag(0);
    this->Modified();
  }
 
  int GetNumberOfConcatenatedTransforms()
  {
    return this->Concatenation->GetNumberOfTransforms() + (this->Input == nullptr ? 0 : 1);
  }
 
 
  vtkLinearTransform* GetConcatenatedTransform(int i)
  {
    vtkAbstractTransform* t;
    if (this->Input == nullptr)
    {
      t = this->Concatenation->GetTransform(i);
    }
    else if (i < this->Concatenation->GetNumberOfPreTransforms())
    {
      t = this->Concatenation->GetTransform(i);
    }
    else if (i > this->Concatenation->GetNumberOfPreTransforms())
    {
      t = this->Concatenation->GetTransform(i - 1);
    }
    else if (this->GetInverseFlag())
    {
      t = this->Input->GetInverse();
    }
    else
    {
      t = this->Input;
    }
    return static_cast<vtkLinearTransform*>(t);
  }
 
 
  void GetOrientation(double orient[3]);
  void GetOrientation(float orient[3])
  {
    double temp[3];
    this->GetOrientation(temp);
    orient[0] = static_cast<float>(temp[0]);
    orient[1] = static_cast<float>(temp[1]);
    orient[2] = static_cast<float>(temp[2]);
  }
  double* GetOrientation() VTK_SIZEHINT(3)
  {
    this->GetOrientation(this->ReturnValue);
    return this->ReturnValue;
  }
 
  static void GetOrientation(double orient[3], vtkMatrix4x4* matrix);
 
 
  void GetOrientationWXYZ(double wxyz[4]);
  void GetOrientationWXYZ(float wxyz[4])
  {
    double temp[4];
    this->GetOrientationWXYZ(temp);
    wxyz[0] = static_cast<float>(temp[0]);
    wxyz[1] = static_cast<float>(temp[1]);
    wxyz[2] = static_cast<float>(temp[2]);
    wxyz[3] = static_cast<float>(temp[3]);
  }
  double* GetOrientationWXYZ() VTK_SIZEHINT(4)
  {
    this->GetOrientationWXYZ(this->ReturnValue);
    return this->ReturnValue;
  }
 
 
  void GetPosition(double pos[3]);
  void GetPosition(float pos[3])
  {
    double temp[3];
    this->GetPosition(temp);
    pos[0] = static_cast<float>(temp[0]);
    pos[1] = static_cast<float>(temp[1]);
    pos[2] = static_cast<float>(temp[2]);
  }
  double* GetPosition() VTK_SIZEHINT(3)
  {
    this->GetPosition(this->ReturnValue);
    return this->ReturnValue;
  }
 
 
  void GetScale(double scale[3]);
  void GetScale(float scale[3])
  {
    double temp[3];
    this->GetScale(temp);
    scale[0] = static_cast<float>(temp[0]);
    scale[1] = static_cast<float>(temp[1]);
    scale[2] = static_cast<float>(temp[2]);
  }
  double* GetScale() VTK_SIZEHINT(3)
  {
    this->GetScale(this->ReturnValue);
    return this->ReturnValue;
  }
 
  void GetInverse(vtkMatrix4x4* inverse);
 
  void GetTranspose(vtkMatrix4x4* transpose);
 
 
  void SetInput(vtkLinearTransform* input);
  vtkLinearTransform* GetInput() { return this->Input; }
 
  int GetInverseFlag() { return this->Concatenation->GetInverseFlag(); }
 
 
  void Push()
  {
    if (this->Stack == nullptr)
    {
      this->Stack = vtkTransformConcatenationStack::New();
    }
    this->Stack->Push(&this->Concatenation);
    this->Modified();
  }
 
 
  void Pop()
  {
    if (this->Stack == nullptr)
    {
      return;
    }
    this->Stack->Pop(&this->Concatenation);
    this->Modified();
  }
 
  int CircuitCheck(vtkAbstractTransform* transform) override;
 
  // Return an inverse transform which will always update itself
  // to match this transform.
  vtkAbstractTransform* GetInverse() { return vtkLinearTransform::GetInverse(); }
 
  vtkAbstractTransform* MakeTransform() override;
 
  vtkMTimeType GetMTime() override;
 
 
  void MultiplyPoint(const float in[4], float out[4]) { this->GetMatrix()->MultiplyPoint(in, out); }
  void MultiplyPoint(const double in[4], double out[4])
  {
    this->GetMatrix()->MultiplyPoint(in, out);
  }
 
protected:
  vtkTransform();
  ~vtkTransform() override;
 
  void InternalDeepCopy(vtkAbstractTransform* t) override;
 
  void InternalUpdate() override;
 
  vtkLinearTransform* Input;
  vtkTransformConcatenation* Concatenation;
  vtkTransformConcatenationStack* Stack;
 
  // this allows us to check whether people have been fooling
  // around with our matrix
  vtkMTimeType MatrixUpdateMTime;
 
  float Point[4];
  double DoublePoint[4];
  double ReturnValue[4];
 
private:
  vtkTransform(const vtkTransform&) = delete;
  void operator=(const vtkTransform&) = delete;
};
 
#endif