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"
 
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);
 
  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(int flag);
  vtkGetMacro(ParallelProjection, int);
  vtkBooleanMacro(ParallelProjection, int);
 
 
  void SetUseHorizontalViewAngle(int flag);
  vtkGetMacro(UseHorizontalViewAngle, int);
  vtkBooleanMacro(UseHorizontalViewAngle, int);
 
 
  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, int);
  vtkGetMacro(UseOffAxisProjection, int);
  vtkBooleanMacro(UseOffAxisProjection, int);
 
 
  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 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 *) {}
 
  unsigned long GetViewingRaysMTime();
 
  void ViewingRaysModified();
 
  virtual void GetFrustumPlanes(double aspect, double planes[24]);
 
 
  double *GetOrientation();
  double *GetOrientationWXYZ();
 
  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);
 
protected:
  vtkCamera();
  ~vtkCamera();
 
 
  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;
  int    ParallelProjection;
  double ParallelScale;
  int    Stereo;
  int    LeftEye;
  double Thickness;
  double Distance;
  double DirectionOfProjection[3];
  double ViewPlaneNormal[3];
  double ViewShear[3];
  int    UseHorizontalViewAngle;
 
  int    UseOffAxisProjection;
 
  double ScreenBottomLeft[3];
  double ScreenBottomRight[3];
  double ScreenTopRight[3];
 
  double EyeSeparation;
 
  vtkMatrix4x4 *WorldToScreenMatrix;
  vtkTimeStamp  WorldToScreenMatrixMTime;
 
  vtkMatrix4x4 *EyeTransformMatrix;
 
  vtkMatrix4x4 *ModelTransformMatrix;
 
  vtkHomogeneousTransform *UserTransform;
  vtkHomogeneousTransform *UserViewTransform;
 
  vtkTransform *ViewTransform;
  vtkPerspectiveTransform *ProjectionTransform;
  vtkPerspectiveTransform *Transform;
  vtkTransform *CameraLightTransform;
 
  vtkTransform *ModelViewTransform;
 
  double FocalDisk;
  //BTX
  vtkCameraCallbackCommand *UserViewTransformCallbackCommand;
  friend class vtkCameraCallbackCommand;
  //ETX
 
  // 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;
 
private:
  vtkCamera(const vtkCamera&);  // Not implemented.
  void operator=(const vtkCamera&);  // Not implemented.
};
 
#endif