dox/Rendering/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 "vtkObject.h"

class vtkHomogeneousTransform;
class vtkMatrix4x4;
class vtkPerspectiveTransform;
class vtkRenderer;
class vtkTransform;
class vtkCallbackCommand;
class vtkCameraCallbackCommand;

class VTK_RENDERING_EXPORT vtkCamera : public vtkObject
{
public:
  void PrintSelf(ostream& os, vtkIndent indent);
  vtkTypeMacro(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 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);

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


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

  void ComputeProjAndViewParams( );


  void SetConfigParams( double o2screen, double o2right, double o2left,
                        double o2top, double o2bottom , double interOccDist,
                        double scale, vtkMatrix4x4 * surfaceRot );
  // Description:
  // This function is a convinience function intended for the Paraview
  // ServerManager
  void SetHeadPose( double x00,  double x01,  double x02, double x03,
                    double x10,  double x11,  double x12, double x13,
                    double x20,  double x21,  double x22, double x23,
                    double x30,  double x31,  double x32, double x33 );


  vtkSetMacro(HeadTracked,int);
  vtkGetMacro(HeadTracked,int);

  void ShallowCopy(vtkCamera *source);

  void DeepCopy(vtkCamera *source);

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

  vtkMatrix4x4* SetTranslation( vtkMatrix4x4 mat );

  void ComputeCameraLightTransform();

  void SetSurface2Base( vtkMatrix4x4 *head );

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

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

  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;

  // Asymmetric Frustum
  int HeadTracked;
  vtkMatrix4x4 *HeadPose;
  vtkTransform *Surface2Base;
  vtkMatrix4x4 *HeadTrackedViewMat;

  double AsymLeft, AsymRight,  AsymBottom,  AsymTop;
  double EyePos[3];
  double O2Screen;
  double O2Right;
  double O2Left;
  double O2Top;
  double O2Bottom;
  double EyeOffset;
  double ScaleFactor;

  // temp
  vtkMatrix4x4 *eyePosMat;
  vtkMatrix4x4 *negEyePosMat;
  vtkMatrix4x4 *eyeOffsetMat;

private:
  vtkCamera(const vtkCamera&);  // Not implemented.
  void operator=(const vtkCamera&);  // Not implemented.
};

#endif

---