vtkGeneralTransform.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    vtkGeneralTransform.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 vtkGeneralTransform_h
#define vtkGeneralTransform_h

#include "vtkCommonTransformsModule.h" // For export macro
#include "vtkAbstractTransform.h"

#include "vtkMatrix4x4.h" // Needed for inline methods

class VTKCOMMONTRANSFORMS_EXPORT vtkGeneralTransform : public vtkAbstractTransform
{
public:
  static vtkGeneralTransform *New();

  vtkTypeMacro(vtkGeneralTransform,vtkAbstractTransform);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  void Identity()
    { this->Concatenation->Identity(); this->Modified(); };

  void Inverse() override
    { this->Concatenation->Inverse(); this->Modified(); }


  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 Concatenate(vtkMatrix4x4 *matrix) {
    this->Concatenate(*matrix->Element); };
  void Concatenate(const double elements[16]) {
    this->Concatenation->Concatenate(elements); };

  void Concatenate(vtkAbstractTransform *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); };

  vtkAbstractTransform *GetConcatenatedTransform(int i) {
    if (this->Input == nullptr) {
      return this->Concatenation->GetTransform(i); }
    else if (i < this->Concatenation->GetNumberOfPreTransforms()) {
      return this->Concatenation->GetTransform(i); }
    else if (i > this->Concatenation->GetNumberOfPreTransforms()) {
      return this->Concatenation->GetTransform(i-1); }
    else if (this->GetInverseFlag()) {
      return this->Input->GetInverse(); }
    else {
      return this->Input; } };


  void SetInput(vtkAbstractTransform *input);
  vtkAbstractTransform *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(); };


  void InternalTransformPoint(const float in[3], float out[3]) override;
  void InternalTransformPoint(const double in[3], double out[3]) override;


  void InternalTransformDerivative(const float in[3], float out[3],
                                   float derivative[3][3]) override;
  void InternalTransformDerivative(const double in[3], double out[3],
                                   double derivative[3][3]) override;

  int CircuitCheck(vtkAbstractTransform *transform) override;

  vtkAbstractTransform *MakeTransform() override;

  vtkMTimeType GetMTime() override;

protected:
  vtkGeneralTransform();
  ~vtkGeneralTransform() override;

  void InternalDeepCopy(vtkAbstractTransform *t) override;
  void InternalUpdate() override;

  vtkAbstractTransform *Input;
  vtkTransformConcatenation *Concatenation;
  vtkTransformConcatenationStack *Stack;
private:
  vtkGeneralTransform(const vtkGeneralTransform&) = delete;
  void operator=(const vtkGeneralTransform&) = delete;
};


#endif