vtkCamera.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef vtkCamera_h
#define vtkCamera_h
 
#include "vtkObject.h"
#include "vtkRect.h"                // for ivar
#include "vtkRenderingCoreModule.h" // For export macro
#include "vtkWrappingHints.h"       // For VTK_MARSHALAUTO
 
VTK_ABI_NAMESPACE_BEGIN
class vtkHomogeneousTransform;
class vtkInformation;
class vtkMatrix4x4;
class vtkPerspectiveTransform;
class vtkRenderer;
class vtkTransform;
class vtkCallbackCommand;
class vtkCameraCallbackCommand;
 
class VTKRENDERINGCORE_EXPORT VTK_MARSHALAUTO 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);


  double GetOffAxisClippingAdjustment();


  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 GetStereoEyePosition(double eyePosition[3]);

  void GetEyePlaneNormal(double normal[3]);


  void SetEyeTransformMatrix(vtkMatrix4x4* matrix);
  void SetEyeTransformMatrix(const double elements[16]);
  vtkGetObjectMacro(EyeTransformMatrix, vtkMatrix4x4);


  void SetModelTransformMatrix(vtkMatrix4x4* matrix);
  void SetModelTransformMatrix(const double elements[16]);
  vtkGetObjectMacro(ModelTransformMatrix, vtkMatrix4x4);

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


  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_NOT_SUPPORTED)
  vtkGetObjectMacro(Information, vtkInformation);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_NOT_SUPPORTED)
  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 ComputeScreenOrientationMatrix();

  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 ScreenCenter[3];
 
  double OffAxisClippingAdjustment;
  double EyeSeparation;
 
  vtkMatrix4x4* EyeTransformMatrix;
  vtkMatrix4x4* ProjectionPlaneOrientationMatrix;
 
  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;
};
 
VTK_ABI_NAMESPACE_END
#endif