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) VTK_OVERRIDE;

  void Identity();

  void Inverse() VTK_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 == NULL ? 0 : 1); };


  vtkLinearTransform *GetConcatenatedTransform(int i)
  {
      vtkAbstractTransform *t;
      if (this->Input == NULL)
      {
        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() {
    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() {
    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() {
    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() {
    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 == NULL) {
                    this->Stack = vtkTransformConcatenationStack::New(); }
                this->Stack->Push(&this->Concatenation);
                this->Modified(); };


  void Pop() { if (this->Stack == NULL) { return; }
               this->Stack->Pop(&this->Concatenation);
               this->Modified(); };

  int CircuitCheck(vtkAbstractTransform *transform) VTK_OVERRIDE;

  // Return an inverse transform which will always update itself
  // to match this transform.
  vtkAbstractTransform *GetInverse() {
    return vtkLinearTransform::GetInverse(); }

  vtkAbstractTransform *MakeTransform() VTK_OVERRIDE;

  vtkMTimeType GetMTime() VTK_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 () VTK_OVERRIDE;

  void InternalDeepCopy(vtkAbstractTransform *t) VTK_OVERRIDE;

  void InternalUpdate() VTK_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&) VTK_DELETE_FUNCTION;
  void operator=(const vtkTransform&) VTK_DELETE_FUNCTION;
};

#endif