---

Rendering/vtkCamera.h

Go to the documentation of this file.

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

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

  Copyright (c) 1993-2002 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 vtkLinearTransform;

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]); };
  void SetPosition(const float a[3]) {
    this->SetPosition(a[0], a[1], a[2]); };
  vtkGetVector3Macro(Position,double);
  void GetPosition(float a[3]) {
    double tmp[3]; this->GetPosition(tmp); 
    a[0] = static_cast<float>(tmp[0]); 
    a[1] = static_cast<float>(tmp[1]); 
    a[2] = static_cast<float>(tmp[2]); };     


  void SetFocalPoint(double x, double y, double z);
  void SetFocalPoint(const double a[3]) {
    this->SetFocalPoint(a[0], a[1], a[2]);};
  void SetFocalPoint(const float a[3]) {
    this->SetFocalPoint(a[0], a[1], a[2]);};
  vtkGetVector3Macro(FocalPoint,double);
  void GetFocalPoint(float a[3]) {
    double tmp[3]; this->GetFocalPoint(tmp); 
    a[0] = static_cast<float>(tmp[0]); 
    a[1] = static_cast<float>(tmp[1]); 
    a[2] = static_cast<float>(tmp[2]); }; 
  

  void SetViewUp(double vx, double vy, double vz);
  void SetViewUp(const double a[3]) {
    this->SetViewUp(a[0], a[1], a[2]); }
  void SetViewUp(const float a[3]) {
    this->SetViewUp(a[0], a[1], a[2]); }
  vtkGetVector3Macro(ViewUp,double);
  void GetViewUp(float a[3]) {
    double tmp[3]; this->GetViewUp(tmp); 
    a[0] = static_cast<float>(tmp[0]); 
    a[1] = static_cast<float>(tmp[1]); 
    a[2] = static_cast<float>(tmp[2]); }; 

  void OrthogonalizeViewUp();


  void SetDistance(double);
  vtkGetMacro(Distance,double);


  vtkGetVector3Macro(DirectionOfProjection,double);
  void GetDirectionOfProjection(float a[3]) {
    double tmp[3]; this->GetDirectionOfProjection(tmp); 
    a[0] = static_cast<float>(tmp[0]); 
    a[1] = static_cast<float>(tmp[1]); 
    a[2] = static_cast<float>(tmp[2]); }; 

  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 near, double far);
  void SetClippingRange(const double a[2]) {
    this->SetClippingRange(a[0], a[1]); };
  void SetClippingRange(const float a[2]) {
    this->SetClippingRange(a[0], a[1]); };
  vtkGetVector2Macro(ClippingRange,double);
  void GetClippingRange(float a[2]) {
    double tmp[2]; this->GetClippingRange(tmp); 
    a[0] = static_cast<float>(tmp[0]); 
    a[1] = static_cast<float>(tmp[1]); }; 


  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 GetViewPlaneNormal(float a[3]) {
    double tmp[3]; this->GetViewPlaneNormal(tmp); 
    a[0] = static_cast<float>(tmp[0]); 
    a[1] = static_cast<float>(tmp[1]); 
    a[2] = static_cast<float>(tmp[2]); }; 



  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 vtkMatrix4x4 *GetPerspectiveTransformMatrix(double aspect,
                                              double nearz, 
                                              double farz);


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


  void SetUserTransform(vtkLinearTransform *transform);
  vtkGetObjectMacro(UserTransform,vtkLinearTransform);

  virtual void Render(vtkRenderer *) {};

  unsigned long GetViewingRaysMTime();

  void ViewingRaysModified();

  virtual void GetFrustumPlanes(float aspect, float planes[24]);


  float *GetOrientation();
  float *GetOrientationWXYZ();


  void SetViewPlaneNormal(double x, double y, double z);
  void SetViewPlaneNormal(const double a[3]) {
    this->SetViewPlaneNormal(a[0], a[1], a[2]); };
  void SetViewPlaneNormal(const float a[3]) {
    this->SetViewPlaneNormal(a[0], a[1], a[2]); };

  void ComputeViewPlaneNormal();

  vtkMatrix4x4 *GetCameraLightTransformMatrix();
  
  virtual void UpdateViewport(vtkRenderer *vtkNotUsed(ren)) {}
  
  virtual vtkTransform *GetViewTransformObject() {return this->ViewTransform;};
  
protected:
  vtkCamera();
  ~vtkCamera();


  void ComputeDistance();
  void ComputeViewTransform();
  void ComputePerspectiveTransform(double aspect, double nearz, double farz);
  void ComputeCompositePerspectiveTransform(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;
  vtkLinearTransform *UserTransform;

  vtkTransform *ViewTransform;
  vtkPerspectiveTransform *PerspectiveTransform;
  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

Generated on Fri Mar 7 15:40:30 2003 for VTK by Doxygen 1.2.18