vtkPerspectiveTransform.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkPerspectiveTransform.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 vtkPerspectiveTransform_h
#define vtkPerspectiveTransform_h
 
#include "vtkCommonTransformsModule.h" // For export macro
#include "vtkHomogeneousTransform.h"
 
#include "vtkMatrix4x4.h" // Needed for inline methods
 
class VTKCOMMONTRANSFORMS_EXPORT vtkPerspectiveTransform : public vtkHomogeneousTransform
{
 public:
  static vtkPerspectiveTransform *New();
  vtkTypeMacro(vtkPerspectiveTransform,vtkHomogeneousTransform);
  void PrintSelf(ostream& os, vtkIndent indent);
 
  void Identity() { this->Concatenation->Identity(); this->Modified(); };
 
  void Inverse() { this->Concatenation->Inverse(); this->Modified(); };
 
 
  void AdjustViewport(double oldXMin, double oldXMax,
                      double oldYMin, double oldYMax,
                      double newXMin, double newXMax,
                      double newYMin, double newYMax);
 
 
  void AdjustZBuffer(double oldNearZ, double oldFarZ,
                     double newNearZ, double newFarZ);
 
 
  void Ortho(double xmin, double xmax, double ymin, double ymax,
             double znear, double zfar);
 
 
  void Frustum(double xmin, double xmax, double ymin, double ymax,
               double znear, double zfar);
 
  void Perspective(double angle, double aspect, double znear, double zfar);
 
  void Shear(double dxdz, double dydz, double zplane);
 
  void Stereo(double angle, double focaldistance);
 
 
  void SetupCamera(const double position[3], const double focalpoint[3],
                   const double viewup[3]);
 
  void SetupCamera(double p0, double p1, double p2,
                   double fp0, double fp1, double fp2,
                   double vup0, double vup1, double vup2);
 
 
  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->Identity(); this->Concatenate(elements); };
 
 
  void Concatenate(vtkMatrix4x4 *matrix) {
    this->Concatenate(*matrix->Element); };
  void Concatenate(const double elements[16]) {
    this->Concatenation->Concatenate(elements); };
 
  void Concatenate(vtkHomogeneousTransform *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); };
 
 
  vtkHomogeneousTransform *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<vtkHomogeneousTransform *>(t);
    }
 
 
  void SetInput(vtkHomogeneousTransform *input);
  vtkHomogeneousTransform *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(); };
 
  vtkAbstractTransform *MakeTransform();
 
  int CircuitCheck(vtkAbstractTransform *transform);
 
  unsigned long GetMTime();
 
protected:
  vtkPerspectiveTransform();
  ~vtkPerspectiveTransform();
 
  void InternalDeepCopy(vtkAbstractTransform *t);
  void InternalUpdate();
 
  vtkHomogeneousTransform *Input;
  vtkTransformConcatenation *Concatenation;
  vtkTransformConcatenationStack *Stack;
 
private:
  vtkPerspectiveTransform(const vtkPerspectiveTransform&);  // Not implemented
  void operator=(const vtkPerspectiveTransform&);  // Not implemented
};
 
 
#endif