Common/Transforms/vtkTransform.h

/*=========================================================================

  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.

=========================================================================*/

/**
 * @class   vtkTransform
 * @brief   describes linear transformations via a 4x4 matrix
 *
 * A vtkTransform can be used to describe the full range of linear (also
 * known as affine) coordinate transformations in three dimensions,
 * which are internally represented as a 4x4 homogeneous transformation
 * matrix.  When you create a new vtkTransform, it is always initialized
 * to the identity transformation.
 * <P>The SetInput() method allows you to set another transform,
 * instead of the identity transform, to be the base transformation.
 * There is a pipeline mechanism to ensure that when the input is
 * modified, the current transformation will be updated accordingly.
 * This pipeline mechanism is also supported by the Concatenate() method.
 * <P>Most of the methods for manipulating this transformation,
 * e.g. Translate, Rotate, and Concatenate, can operate in either
 * PreMultiply (the default) or PostMultiply mode.  In PreMultiply
 * mode, the translation, concatenation, etc. will occur before any
 * transformations which are represented by the current matrix.  In
 * PostMultiply mode, the additional transformation will occur after
 * any transformations represented by the current matrix.
 * <P>This class performs all of its operations in a right handed
 * coordinate system with right handed rotations. Some other graphics
 * libraries use left handed coordinate systems and rotations.
 * @sa
 * vtkPerspectiveTransform vtkGeneralTransform vtkMatrix4x4
 * vtkTransformCollection vtkTransformFilter vtkTransformPolyDataFilter
 * vtkImageReslice
*/

#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;

  /**
   * Set the transformation to the identity transformation.  If
   * the transform has an Input, then the transformation will be
   * reset so that it is the same as the Input.
   */
  void Identity();

  /**
   * Invert the transformation.  This will also set a flag so that
   * the transformation will use the inverse of its Input, if an Input
   * has been set.
   */
  void Inverse() override;

  //@{
  /**
   * Create a translation matrix and concatenate it with the current
   * transformation according to PreMultiply or PostMultiply semantics.
   */
  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]); };
  //@}

  //@{
  /**
   * Create a rotation matrix and concatenate it with the current
   * transformation according to PreMultiply or PostMultiply semantics.
   * The angle is in degrees, and (x,y,z) specifies the axis that the
   * rotation will be performed around.
   */
  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]); };
  //@}

  //@{
  /**
   * Create a rotation matrix about the X, Y, or Z axis and concatenate
   * it with the current transformation according to PreMultiply or
   * PostMultiply semantics.  The angle is expressed in degrees.
   */
  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); };
  //@}

  //@{
  /**
   * Create a scale matrix (i.e. set the diagonal elements to x, y, z)
   * and concatenate it with the current transformation according to
   * PreMultiply or PostMultiply semantics.
   */
  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]); };
  //@}

  //@{
  /**
   * Set the current matrix directly. Note: First, the current
   * matrix is set to the identity, then the input matrix is concatenated.
   */
  void SetMatrix(vtkMatrix4x4 *matrix) {
    this->SetMatrix(*matrix->Element); };
  void SetMatrix(const double elements[16]) {
    this->Concatenation->Identity(); this->Concatenate(elements); };
  //@}

  //@{
  /**
   * Concatenates the matrix with the current transformation according
   * to PreMultiply or PostMultiply semantics.
   */
  void Concatenate(vtkMatrix4x4 *matrix) {
    this->Concatenate(*matrix->Element); };
  void Concatenate(const double elements[16]) {
    this->Concatenation->Concatenate(elements); };
  //@}

  /**
   * Concatenate the specified transform with the current transformation
   * according to PreMultiply or PostMultiply semantics.
   * The concatenation is pipelined, meaning that if any of the
   * transformations are changed, even after Concatenate() is called,
   * those changes will be reflected when you call TransformPoint().
   */
  void Concatenate(vtkLinearTransform *transform);

  /**
   * Sets the internal state of the transform to PreMultiply. All subsequent
   * operations will occur before those already represented in the
   * current transformation.  In homogeneous matrix notation, M = M*A where
   * M is the current transformation matrix and A is the applied matrix.
   * The default is PreMultiply.
   */
  void PreMultiply() {
    if (this->Concatenation->GetPreMultiplyFlag()) { return; }
    this->Concatenation->SetPreMultiplyFlag(1); this->Modified(); };

  /**
   * Sets the internal state of the transform to PostMultiply. All subsequent
   * operations will occur after those already represented in the
   * current transformation.  In homogeneous matrix notation, M = A*M where
   * M is the current transformation matrix and A is the applied matrix.
   * The default is PreMultiply.
   */
  void PostMultiply()  {
    if (!this->Concatenation->GetPreMultiplyFlag()) { return; }
    this->Concatenation->SetPreMultiplyFlag(0); this->Modified(); };

  /**
   * Get the total number of transformations that are linked into this
   * one via Concatenate() operations or via SetInput().
   */
  int GetNumberOfConcatenatedTransforms() {
    return this->Concatenation->GetNumberOfTransforms() +
      (this->Input == nullptr ? 0 : 1); };

  //@{
  /**
   * Get one of the concatenated transformations as a vtkAbstractTransform.
   * These transformations are applied, in series, every time the
   * transformation of a coordinate occurs.  This method is provided
   * to make it possible to decompose a transformation into its
   * constituents, for example to save a transformation to a file.
   */
  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);
  }
  //@}

  //@{
  /**
   * Get the x, y, z orientation angles from the transformation matrix as an
   * array of three floating point values.
   */
  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; };
  //@}

  /**
   * Convenience function to get the x, y, z orientation angles from
   * a transformation matrix as an array of three floating point values.
   */
  static void GetOrientation(double orient[3], vtkMatrix4x4 *matrix);

  //@{
  /**
   * Return the wxyz angle+axis representing the current orientation.
   * The angle is in degrees and the axis is a unit vector.
   */
  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; };
  //@}

  //@{
  /**
   * Return the position from the current transformation matrix as an array
   * of three floating point numbers. This is simply returning the translation
   * component of the 4x4 matrix.
   */
  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; };
  //@}

  //@{
  /**
   * Return the scale factors of the current transformation matrix as
   * an array of three float numbers.  These scale factors are not necessarily
   * about the x, y, and z axes unless unless the scale transformation was
   * applied before any rotations.
   */
  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; };
  //@}

  /**
   * Return a matrix which is the inverse of the current transformation
   * matrix.
   */
  void GetInverse(vtkMatrix4x4 *inverse);

  /**
   * Return a matrix which is the transpose of the current transformation
   * matrix.  This is equivalent to the inverse if and only if the
   * transformation is a pure rotation with no translation or scale.
   */
  void GetTranspose(vtkMatrix4x4 *transpose);

  //@{
  /**
   * Set the input for this transformation.  This will be used as the
   * base transformation if it is set.  This method allows you to build
   * a transform pipeline: if the input is modified, then this transformation
   * will automatically update accordingly.  Note that the InverseFlag,
   * controlled via Inverse(), determines whether this transformation
   * will use the Input or the inverse of the Input.
   */
  void SetInput(vtkLinearTransform *input);
  vtkLinearTransform *GetInput() { return this->Input; };
  //@}

  /**
   * Get the inverse flag of the transformation.  This controls
   * whether it is the Input or the inverse of the Input that
   * is used as the base transformation.  The InverseFlag is
   * flipped every time Inverse() is called.  The InverseFlag
   * is off when a transform is first created.
   */
  int GetInverseFlag() {
    return this->Concatenation->GetInverseFlag(); };

  //@{
  /**
   * Pushes the current transformation onto the transformation stack.
   */
  void Push() { if (this->Stack == nullptr) {
                    this->Stack = vtkTransformConcatenationStack::New(); }
                this->Stack->Push(&this->Concatenation);
                this->Modified(); };
  //@}

  //@{
  /**
   * Deletes the transformation on the top of the stack and sets the top
   * to the next transformation on the stack.
   */
  void Pop() { if (this->Stack == nullptr) { return; }
               this->Stack->Pop(&this->Concatenation);
               this->Modified(); };
  //@}

  /**
   * Check for self-reference.  Will return true if concatenating
   * with the specified transform, setting it to be our inverse,
   * or setting it to be our input will create a circular reference.
   * CircuitCheck is automatically called by SetInput(), SetInverse(),
   * and Concatenate(vtkXTransform *).  Avoid using this function,
   * it is experimental.
   */
  int CircuitCheck(vtkAbstractTransform *transform) override;

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

  /**
   * Make a new transform of the same type.
   */
  vtkAbstractTransform *MakeTransform() override;

  /**
   * Override GetMTime to account for input and concatenation.
   */
  vtkMTimeType GetMTime() override;

  //@{
  /**
   * Use this method only if you wish to compute the transformation in
   * homogeneous (x,y,z,w) coordinates, otherwise use TransformPoint().
   * This method calls this->GetMatrix()->MultiplyPoint().
   */
  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