vtkCamera.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkCamera.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 vtkCamera_h
#define vtkCamera_h
 
#include "vtkObject.h"
#include "vtkRect.h"                // for ivar
#include "vtkRenderingCoreModule.h" // For export macro
 
class vtkHomogeneousTransform;
class vtkInformation;
class vtkMatrix4x4;
class vtkPerspectiveTransform;
class vtkRenderer;
class vtkTransform;
class vtkCallbackCommand;
class vtkCameraCallbackCommand;
 
class VTKRENDERINGCORE_EXPORT vtkCamera : public vtkObject
{
public:
  vtkTypeMacro(vtkCamera, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static vtkCamera* New();
 
 
  void SetPosition(double x, double y, double z);
  void SetPosition(const double a[3]) { this->SetPosition(a[0], a[1], a[2]); }
  vtkGetVector3Macro(Position, double);
 
 
  void SetFocalPoint(double x, double y, double z);
  void SetFocalPoint(const double a[3]) { this->SetFocalPoint(a[0], a[1], a[2]); }
  vtkGetVector3Macro(FocalPoint, double);
 
 
  void SetViewUp(double vx, double vy, double vz);
  void SetViewUp(const double a[3]) { this->SetViewUp(a[0], a[1], a[2]); }
  vtkGetVector3Macro(ViewUp, double);
 
  void OrthogonalizeViewUp();
 
  void SetDistance(double);
 
 
  vtkGetMacro(Distance, double);
 
 
  vtkGetVector3Macro(DirectionOfProjection, double);
 
  void Dolly(double value);
 
 
  void SetRoll(double angle);
  double GetRoll();
 
  void Roll(double angle);
 
  void Azimuth(double angle);
 
  void Yaw(double angle);
 
  void Elevation(double angle);
 
  void Pitch(double angle);
 
 
  void SetParallelProjection(vtkTypeBool flag);
  vtkGetMacro(ParallelProjection, vtkTypeBool);
  vtkBooleanMacro(ParallelProjection, vtkTypeBool);
 
 
  void SetUseHorizontalViewAngle(vtkTypeBool flag);
  vtkGetMacro(UseHorizontalViewAngle, vtkTypeBool);
  vtkBooleanMacro(UseHorizontalViewAngle, vtkTypeBool);
 
 
  void SetViewAngle(double angle);
  vtkGetMacro(ViewAngle, double);
 
 
  void SetParallelScale(double scale);
  vtkGetMacro(ParallelScale, double);
 
  void Zoom(double factor);
 
 
  void SetClippingRange(double dNear, double dFar);
  void SetClippingRange(const double a[2]) { this->SetClippingRange(a[0], a[1]); }
  vtkGetVector2Macro(ClippingRange, double);
 
 
  void SetThickness(double);
  vtkGetMacro(Thickness, double);
 
 
  void SetWindowCenter(double x, double y);
  vtkGetVector2Macro(WindowCenter, double);
 
  void SetObliqueAngles(double alpha, double beta);
 
  void ApplyTransform(vtkTransform* t);
 
 
  vtkGetVector3Macro(ViewPlaneNormal, double);
 
 
  void SetViewShear(double dxdz, double dydz, double center);
  void SetViewShear(double d[3]);
  vtkGetVector3Macro(ViewShear, double);
 
 
  vtkSetMacro(EyeAngle, double);
  vtkGetMacro(EyeAngle, double);
 
 
  vtkSetMacro(FocalDisk, double);
  vtkGetMacro(FocalDisk, double);
 
 
  vtkSetMacro(FocalDistance, double);
  vtkGetMacro(FocalDistance, double);
 
 
  vtkSetMacro(UseOffAxisProjection, vtkTypeBool);
  vtkGetMacro(UseOffAxisProjection, vtkTypeBool);
  vtkBooleanMacro(UseOffAxisProjection, vtkTypeBool);
 
 
  vtkSetVector3Macro(ScreenBottomLeft, double);
  vtkGetVector3Macro(ScreenBottomLeft, double);
 
 
  vtkSetVector3Macro(ScreenBottomRight, double);
  vtkGetVector3Macro(ScreenBottomRight, double);
 
 
  vtkSetVector3Macro(ScreenTopRight, double);
  vtkGetVector3Macro(ScreenTopRight, double);
 
 
  vtkSetMacro(EyeSeparation, double);
  vtkGetMacro(EyeSeparation, double);
 
 
  void SetEyePosition(double eyePosition[3]);
  void GetEyePosition(double eyePosition[3]);
 
  void GetEyePlaneNormal(double normal[3]);
 
 
  void SetEyeTransformMatrix(vtkMatrix4x4* matrix);
  vtkGetObjectMacro(EyeTransformMatrix, vtkMatrix4x4);
 
  void SetEyeTransformMatrix(const double elements[16]);
 
 
  void SetModelTransformMatrix(vtkMatrix4x4* matrix);
  vtkGetObjectMacro(ModelTransformMatrix, vtkMatrix4x4);
 
  void SetModelTransformMatrix(const double elements[16]);
 
  virtual vtkMatrix4x4* GetModelViewTransformMatrix();
 
  virtual vtkTransform* GetModelViewTransformObject();
 
  virtual vtkMatrix4x4* GetViewTransformMatrix();
 
  virtual vtkTransform* GetViewTransformObject();
 
  virtual void SetExplicitProjectionTransformMatrix(vtkMatrix4x4*);
  vtkGetObjectMacro(ExplicitProjectionTransformMatrix, vtkMatrix4x4);
  vtkSetMacro(UseExplicitProjectionTransformMatrix, bool);
  vtkGetMacro(UseExplicitProjectionTransformMatrix, bool);
  vtkBooleanMacro(UseExplicitProjectionTransformMatrix, bool);
  vtkSetMacro(ExplicitAspectRatio, double);
  vtkGetMacro(ExplicitAspectRatio, double);
  vtkSetMacro(UseExplicitAspectRatio, bool);
  vtkGetMacro(UseExplicitAspectRatio, bool);
  vtkBooleanMacro(UseExplicitAspectRatio, bool);
  virtual vtkMatrix4x4* GetProjectionTransformMatrix(double aspect, double nearz, double farz);
 
  virtual vtkPerspectiveTransform* GetProjectionTransformObject(
    double aspect, double nearz, double farz);
 
  virtual vtkMatrix4x4* GetCompositeProjectionTransformMatrix(
    double aspect, double nearz, double farz);
 
  virtual vtkMatrix4x4* GetProjectionTransformMatrix(vtkRenderer* ren);
 
 
  void SetUserViewTransform(vtkHomogeneousTransform* transform);
  vtkGetObjectMacro(UserViewTransform, vtkHomogeneousTransform);
 
 
  void SetUserTransform(vtkHomogeneousTransform* transform);
  vtkGetObjectMacro(UserTransform, vtkHomogeneousTransform);
 
  virtual void Render(vtkRenderer*) {}
 
  vtkMTimeType GetViewingRaysMTime();
 
  void ViewingRaysModified();
 
  virtual void GetFrustumPlanes(double aspect, double planes[24]);
 
 
  virtual void UpdateIdealShiftScale(double aspect);
  vtkGetVector3Macro(FocalPointShift, double);
  vtkGetMacro(FocalPointScale, double);
  vtkGetVector3Macro(NearPlaneShift, double);
  vtkGetMacro(NearPlaneScale, double);
  vtkSetMacro(ShiftScaleThreshold, double);
  vtkGetMacro(ShiftScaleThreshold, double);
 
 
  double* GetOrientation() VTK_SIZEHINT(3);
  double* GetOrientationWXYZ() VTK_SIZEHINT(4);
 
  void ComputeViewPlaneNormal();
 
  vtkMatrix4x4* GetCameraLightTransformMatrix();
 
  virtual void UpdateViewport(vtkRenderer* vtkNotUsed(ren)) {}
 
 
  vtkGetMacro(Stereo, int);
 
 
  vtkSetMacro(LeftEye, int);
  vtkGetMacro(LeftEye, int);
 
  void ShallowCopy(vtkCamera* source);
 
  void DeepCopy(vtkCamera* source);
 
 
  vtkSetMacro(FreezeFocalPoint, bool);
  vtkGetMacro(FreezeFocalPoint, bool);
 
 
  vtkSetMacro(UseScissor, bool);
  vtkGetMacro(UseScissor, bool);
 
 
  void SetScissorRect(vtkRecti scissorRect);
  void GetScissorRect(vtkRecti& scissorRect);
 
 
  vtkGetObjectMacro(Information, vtkInformation);
  virtual void SetInformation(vtkInformation*);
 
protected:
  vtkCamera();
  ~vtkCamera() override;
 
 
  void ComputeDistance();
  virtual void ComputeViewTransform();
 
  virtual void ComputeProjectionTransform(double aspect, double nearz, double farz);
 
  void ComputeCompositeProjectionTransform(double aspect, double nearz, double farz);
 
  void ComputeCameraLightTransform();
 
  void ComputeWorldToScreenMatrix();
 
  void ComputeOffAxisProjectionFrustum();
 
  void ComputeModelViewMatrix();
 
  void PartialCopy(vtkCamera* source);
 
  double WindowCenter[2];
  double ObliqueAngles[2];
  double FocalPoint[3];
  double Position[3];
  double ViewUp[3];
  double ViewAngle;
  double ClippingRange[2];
  double EyeAngle;
  vtkTypeBool ParallelProjection;
  double ParallelScale;
  int Stereo;
  int LeftEye;
  double Thickness;
  double Distance;
  double DirectionOfProjection[3];
  double ViewPlaneNormal[3];
  double ViewShear[3];
  vtkTypeBool UseHorizontalViewAngle;
 
  vtkTypeBool UseOffAxisProjection;
 
  double ScreenBottomLeft[3];
  double ScreenBottomRight[3];
  double ScreenTopRight[3];
 
  double EyeSeparation;
 
  vtkMatrix4x4* WorldToScreenMatrix;
  vtkTimeStamp WorldToScreenMatrixMTime;
 
  vtkMatrix4x4* EyeTransformMatrix;
 
  vtkMatrix4x4* ModelTransformMatrix;
 
  vtkHomogeneousTransform* UserTransform;
  vtkHomogeneousTransform* UserViewTransform;
 
  vtkMatrix4x4* ExplicitProjectionTransformMatrix;
  bool UseExplicitProjectionTransformMatrix;
 
  double ExplicitAspectRatio;
  bool UseExplicitAspectRatio;
 
  vtkTransform* ViewTransform;
  vtkPerspectiveTransform* ProjectionTransform;
  vtkPerspectiveTransform* Transform;
  vtkTransform* CameraLightTransform;
 
  vtkTransform* ModelViewTransform;
 
  double FocalDisk;
  double FocalDistance;
 
  double FocalPointShift[3];
  double FocalPointScale;
  double NearPlaneShift[3];
  double NearPlaneScale;
  double ShiftScaleThreshold;
 
  vtkCameraCallbackCommand* UserViewTransformCallbackCommand;
  friend class vtkCameraCallbackCommand;
 
  // ViewingRaysMtime keeps track of camera modifications which will
  // change the calculation of viewing rays for the camera before it is
  // transformed to the camera's location and orientation.
  vtkTimeStamp ViewingRaysMTime;
  bool FreezeFocalPoint;
  bool UseScissor;
 
  vtkRecti ScissorRect;
 
  // Arbitrary extra information associated with this camera.
  vtkInformation* Information;
 
private:
  vtkCamera(const vtkCamera&) = delete;
  void operator=(const vtkCamera&) = delete;
};
 
#endif