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 "vtkRenderingCoreModule.h" // For export macro
#include "vtkObject.h"
#include "vtkRect.h" // for ivar

class vtkHomogeneousTransform;
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(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)
   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]);


  double *GetOrientation() VTK_SIZEHINT(3);
  double *GetOrientationWXYZ() VTK_SIZEHINT(4);

  void ComputeViewPlaneNormal();

  vtkMatrix4x4 *GetCameraLightTransformMatrix();

  virtual void UpdateViewport(vtkRenderer *vtkNotUsed(ren)) {}


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

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;

  vtkTransform *ViewTransform;
  vtkPerspectiveTransform *ProjectionTransform;
  vtkPerspectiveTransform *Transform;
  vtkTransform *CameraLightTransform;

  vtkTransform *ModelViewTransform;

  double FocalDisk;

  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;


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

#endif