vtkAbstractTransform.h

Go to the documentation of this file.

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

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

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

class vtkDataArray;
class vtkMatrix4x4;
class vtkPoints;
class vtkSimpleCriticalSection;

class VTKCOMMONTRANSFORMS_EXPORT vtkAbstractTransform : public vtkObject
{
public:

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

  void TransformPoint(const float in[3], float out[3]) {
    this->Update(); this->InternalTransformPoint(in,out); }

  void TransformPoint(const double in[3], double out[3]) {
    this->Update(); this->InternalTransformPoint(in,out); }

  double *TransformPoint(double x, double y, double z)
    VTK_SIZEHINT(3)
  {
    return this->TransformDoublePoint(x,y,z);
  }
  double *TransformPoint(const double point[3])
    VTK_SIZEHINT(3)
  {
    return this->TransformPoint(point[0],point[1],point[2]);
  }


  float *TransformFloatPoint(float x, float y, float z)
    VTK_SIZEHINT(3)
  {
      this->InternalFloatPoint[0] = x;
      this->InternalFloatPoint[1] = y;
      this->InternalFloatPoint[2] = z;
      this->TransformPoint(this->InternalFloatPoint,this->InternalFloatPoint);
      return this->InternalFloatPoint;
  }
  float *TransformFloatPoint(const float point[3])
    VTK_SIZEHINT(3)
  {
    return this->TransformFloatPoint(point[0],point[1],point[2]);
  }


  double *TransformDoublePoint(double x, double y, double z)
    VTK_SIZEHINT(3)
  {
    this->InternalDoublePoint[0] = x;
    this->InternalDoublePoint[1] = y;
    this->InternalDoublePoint[2] = z;
    this->TransformPoint(this->InternalDoublePoint,this->InternalDoublePoint);
    return this->InternalDoublePoint;
  }
  double *TransformDoublePoint(const double point[3])
    VTK_SIZEHINT(3)
  {
    return this->TransformDoublePoint(point[0],point[1],point[2]);
  }


  void TransformNormalAtPoint(const float point[3], const float in[3],
                              float out[3]);
  void TransformNormalAtPoint(const double point[3], const double in[3],
                              double out[3]);

  double *TransformNormalAtPoint(const double point[3],
                                 const double normal[3])
    VTK_SIZEHINT(3)
  {
    this->TransformNormalAtPoint(point,normal,this->InternalDoublePoint);
    return this->InternalDoublePoint;
  }


  double *TransformDoubleNormalAtPoint(const double point[3],
                                       const double normal[3])
    VTK_SIZEHINT(3)
  {
    this->TransformNormalAtPoint(point,normal,this->InternalDoublePoint);
    return this->InternalDoublePoint;
  }


  float *TransformFloatNormalAtPoint(const float point[3],
                                     const float normal[3])
    VTK_SIZEHINT(3)
  {
    this->TransformNormalAtPoint(point,normal,this->InternalFloatPoint);
    return this->InternalFloatPoint;
  }


  void TransformVectorAtPoint(const float point[3], const float in[3],
                              float out[3]);
  void TransformVectorAtPoint(const double point[3], const double in[3],
                              double out[3]);

  double *TransformVectorAtPoint(const double point[3],
                                 const double vector[3])
    VTK_SIZEHINT(3)
  {
    this->TransformVectorAtPoint(point,vector,this->InternalDoublePoint);
    return this->InternalDoublePoint;
  }


  double *TransformDoubleVectorAtPoint(const double point[3],
                                       const double vector[3])
    VTK_SIZEHINT(3)
  {
    this->TransformVectorAtPoint(point,vector,this->InternalDoublePoint);
    return this->InternalDoublePoint;
  }


  float *TransformFloatVectorAtPoint(const float point[3],
                                     const float vector[3])
    VTK_SIZEHINT(3)
  {
    this->TransformVectorAtPoint(point,vector,this->InternalFloatPoint);
    return this->InternalFloatPoint;
  }

  virtual void TransformPoints(vtkPoints *inPts, vtkPoints *outPts);

  virtual void TransformPointsNormalsVectors(vtkPoints *inPts,
                                             vtkPoints *outPts,
                                             vtkDataArray *inNms,
                                             vtkDataArray *outNms,
                                             vtkDataArray *inVrs,
                                             vtkDataArray *outVrs,
                                             int nOptionalVectors = 0,
                                             vtkDataArray** inVrsArr = nullptr,
                                             vtkDataArray** outVrsArr = nullptr);

  vtkAbstractTransform *GetInverse();

  void SetInverse(vtkAbstractTransform *transform);

  virtual void Inverse() = 0;

  void DeepCopy(vtkAbstractTransform *);

  void Update();


  virtual void InternalTransformPoint(const float in[3], float out[3]) = 0;
  virtual void InternalTransformPoint(const double in[3], double out[3]) = 0;


  virtual void InternalTransformDerivative(const float in[3], float out[3],
                                           float derivative[3][3]) = 0;
  virtual void InternalTransformDerivative(const double in[3], double out[3],
                                           double derivative[3][3]) = 0;

  virtual VTK_NEWINSTANCE vtkAbstractTransform *MakeTransform() = 0;

  virtual int CircuitCheck(vtkAbstractTransform *transform);

  vtkMTimeType GetMTime() override;

  void UnRegister(vtkObjectBase *O) override;

protected:
  vtkAbstractTransform();
  ~vtkAbstractTransform() override;

  virtual void InternalUpdate() {}

  virtual void InternalDeepCopy(vtkAbstractTransform *) {}

  float InternalFloatPoint[3];
  double InternalDoublePoint[3];

private:

  // We need to record the time of the last update, and we also need
  // to do mutex locking so updates don't collide.  These are private
  // because Update() is not virtual.
  // If DependsOnInverse is set, then this transform object will
  // check its inverse on every update, and update itself accordingly
  // if necessary.

  vtkTimeStamp UpdateTime;
  vtkSimpleCriticalSection *UpdateMutex;
  vtkSimpleCriticalSection *InverseMutex;
  int DependsOnInverse;

  // MyInverse is a transform which is the inverse of this one.

  vtkAbstractTransform *MyInverse;

  int InUnRegister;

private:
  vtkAbstractTransform(const vtkAbstractTransform&) = delete;
  void operator=(const vtkAbstractTransform&) = delete;
};

//-------------------------------------------------------------------------
// A simple data structure to hold both a transform and its inverse.
// One of ForwardTransform or InverseTransform might be nullptr,
// and must be acquired by calling GetInverse() on the other.
class vtkTransformPair
{
public:
  vtkTransformPair() {}

  vtkAbstractTransform *ForwardTransform;
  vtkAbstractTransform *InverseTransform;

  void SwapForwardInverse() {
    vtkAbstractTransform *tmp = this->ForwardTransform;
    this->ForwardTransform = this->InverseTransform;
    this->InverseTransform = tmp; }
};

// .NAME vtkTransformConcatenation - store a series of transformations.
// .SECTION Description
// A helper class (not derived from vtkObject) to store a series of
// transformations in a pipelined concatenation.
class VTKCOMMONTRANSFORMS_EXPORT vtkTransformConcatenation
{
public:
  static vtkTransformConcatenation *New() {
    return new vtkTransformConcatenation(); }
  void Delete() { delete this; }

  void Concatenate(vtkAbstractTransform *transform);

  void Concatenate(const double elements[16]);


  void SetPreMultiplyFlag(int flag) { this->PreMultiplyFlag = flag; }
  int GetPreMultiplyFlag() { return this->PreMultiplyFlag; }


  void Translate(double x, double y, double z);
  void Rotate(double angle, double x, double y, double z);
  void Scale(double x, double y, double z);

  void Inverse();

  int GetInverseFlag() { return this->InverseFlag; }

  void Identity();

  // copy the list
  void DeepCopy(vtkTransformConcatenation *transform);

  int GetNumberOfTransforms() { return this->NumberOfTransforms; }

  int GetNumberOfPreTransforms() { return this->NumberOfPreTransforms; }

  int GetNumberOfPostTransforms() {
    return this->NumberOfTransforms-this->NumberOfPreTransforms; }

  vtkAbstractTransform *GetTransform(int i);

  vtkMTimeType GetMaxMTime();

  void PrintSelf(ostream& os, vtkIndent indent);

protected:
  vtkTransformConcatenation();
  ~vtkTransformConcatenation();

  int InverseFlag;
  int PreMultiplyFlag;

  vtkMatrix4x4 *PreMatrix;
  vtkMatrix4x4 *PostMatrix;
  vtkAbstractTransform *PreMatrixTransform;
  vtkAbstractTransform *PostMatrixTransform;

  int NumberOfTransforms;
  int NumberOfPreTransforms;
  int MaxNumberOfTransforms;
  vtkTransformPair *TransformList;

private:
  vtkTransformConcatenation(const vtkTransformConcatenation&)
    = delete;
  void operator=(const vtkTransformConcatenation&) = delete;
};

// .NAME vtkTransformConcatenationStack - Store a stack of concatenations.
// .SECTION Description
// A helper class (not derived from vtkObject) to store a stack of
// concatenations.
class VTKCOMMONTRANSFORMS_EXPORT vtkTransformConcatenationStack
{
public:
  static vtkTransformConcatenationStack *New()
  {
      return new vtkTransformConcatenationStack();
  }
  void Delete()
  {
      delete this;
  }

  void Pop(vtkTransformConcatenation **concat);

  void Push(vtkTransformConcatenation **concat);

  void DeepCopy(vtkTransformConcatenationStack *stack);

protected:
  vtkTransformConcatenationStack();
  ~vtkTransformConcatenationStack();

  int StackSize;
  vtkTransformConcatenation **Stack;
  vtkTransformConcatenation **StackBottom;

private:
  vtkTransformConcatenationStack(const vtkTransformConcatenationStack&)
    = delete;
  void operator=(const vtkTransformConcatenationStack&) = delete;
};

#endif