dox/Rendering/vtkCamera.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    $RCSfile: vtkCamera.h,v $

  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"

class vtkMatrix4x4;
class vtkPerspectiveTransform;
class vtkRenderer;
class vtkTransform;
class vtkHomogeneousTransform;

class VTK_RENDERING_EXPORT vtkCamera : public vtkObject
{
 public:
  void PrintSelf(ostream& os, vtkIndent indent);
  vtkTypeRevisionMacro(vtkCamera,vtkObject);

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


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

  virtual vtkMatrix4x4 *GetViewTransformMatrix();


  virtual vtkTransform *GetViewTransformObject()
    {
      return this->ViewTransform;
    }
  

  VTK_LEGACY(virtual vtkMatrix4x4 *GetPerspectiveTransformMatrix(double aspect,
                                                                 double nearz,
                                                                 double farz));
  

   virtual vtkMatrix4x4 *GetProjectionTransformMatrix(double aspect,
                                                      double nearz,
                                                      double farz);
  

  virtual vtkPerspectiveTransform *GetProjectionTransformObject(double aspect,
                                                                double nearz,
                                                                double farz);
  


  VTK_LEGACY(virtual vtkMatrix4x4 *GetCompositePerspectiveTransformMatrix(
               double aspect,
               double nearz,
               double farz));
  

  virtual vtkMatrix4x4 *GetCompositeProjectionTransformMatrix(double aspect,
                                                              double nearz,
                                                              double farz);

  

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


  VTK_LEGACY(void SetViewPlaneNormal(double x, double y, double z));
  VTK_LEGACY(void SetViewPlaneNormal(const double a[3]));

  void ComputeViewPlaneNormal();

  vtkMatrix4x4 *GetCameraLightTransformMatrix();

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


  vtkSetMacro(LeftEye,int);
  vtkGetMacro(LeftEye,int);

protected:
  vtkCamera();
  ~vtkCamera();


  void ComputeDistance();
  void ComputeViewTransform();
  
#ifndef VTK_LEGACY_REMOVE


  void ComputePerspectiveTransform(double aspect,
                                   double nearz,
                                   double farz);
  

  void ComputeCompositePerspectiveTransform(double aspect,
                                            double nearz,
                                            double farz);
#endif
  

  void ComputeProjectionTransform(double aspect,
                                  double nearz,
                                  double farz);
  

  void ComputeCompositeProjectionTransform(double aspect,
                                           double nearz,
                                           double farz);
  
  
  void ComputeCameraLightTransform();

  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;
  vtkHomogeneousTransform *UserTransform;

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

  double FocalDisk;

  // 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;
private:
  vtkCamera(const vtkCamera&);  // Not implemented.
  void operator=(const vtkCamera&);  // Not implemented.
};

#endif

---