dox/Rendering/Core/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);



  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();
  void ComputeViewTransform();


  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