---

Rendering/vtkCamera.h

Go to the documentation of this file.

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

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


Copyright (c) 1993-2001 Ken Martin, Will Schroeder, Bill Lorensen 
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

 * Redistributions of source code must retain the above copyright notice,
   this list of conditions and the following disclaimer.

 * Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.

 * Neither name of Ken Martin, Will Schroeder, or Bill Lorensen nor the names
   of any contributors may be used to endorse or promote products derived
   from this software without specific prior written permission.

 * Modified source versions must be plainly marked as such, and must not be
   misrepresented as being the original software.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

=========================================================================*/
#ifndef __vtkCamera_h
#define __vtkCamera_h

#include "vtkObject.h"
#include "vtkTransform.h"
#include "vtkPerspectiveTransform.h"

class vtkRenderer;

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]); };
  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] = tmp[0]; a[1] = tmp[1]; a[2] = 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] = tmp[0]; a[1] = tmp[1]; a[2] = 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] = tmp[0]; a[1] = tmp[1]; a[2] = 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] = tmp[0]; a[1] = tmp[1]; a[2] = 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 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] = tmp[0]; a[1] = tmp[1]; }; 


  void SetThickness(double);
  vtkGetMacro(Thickness,double);


  void SetWindowCenter(double x, double y);
  vtkGetVector2Macro(WindowCenter,double);

  void SetObliqueAngles(double alpha, double beta);


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


  vtkMatrix4x4 *GetViewTransformMatrix() { 
    return this->ViewTransform->GetMatrix(); };
  

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


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

  virtual void Render(vtkRenderer *) {};

  unsigned long GetViewingRaysMTime();

  void ViewingRaysModified();

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


  float *GetOrientation() { 
    return this->ViewTransform->GetOrientation(); };
  float *GetOrientationWXYZ() { 
    return this->ViewTransform->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)) {}
  
#ifndef VTK_REMOVE_LEGACY_CODE


  vtkMatrix4x4 &GetViewTransform()
    {VTK_LEGACY_METHOD(GetViewTransformMatrix,"3.2"); return *this->GetViewTransformMatrix();}
  vtkMatrix4x4 &GetPerspectiveTransform(double aspect,double nearz,double farz) 
    {VTK_LEGACY_METHOD(GetPerspectiveTransformMatrix,"3.2"); return *this->GetPerspectiveTransformMatrix(aspect, nearz, farz);}
  vtkMatrix4x4 &GetCompositePerspectiveTransform(double aspect, double nearz, double farz) 
    {VTK_LEGACY_METHOD(GetCompositePerspectiveTransformMatrix,"3.2"); return *this->GetCompositePerspectiveTransformMatrix(aspect,nearz,farz);}
#endif

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

  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

---