9.1/html/vtkCamera_8h_source.html

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


  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