vtkViewport.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkViewport.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 vtkViewport_h
#define vtkViewport_h
 
#include "vtkRenderingCoreModule.h" // For export macro
#include "vtkObject.h"
 
class vtkActor2DCollection;
class vtkAssemblyPath;
class vtkProp;
class vtkPropCollection;
class vtkWindow;
 
class VTKRENDERINGCORE_EXPORT vtkViewport : public vtkObject
{
public:
  vtkTypeMacro(vtkViewport,vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent);
 
  void AddViewProp(vtkProp *);
 
  vtkPropCollection *GetViewProps() {return this->Props;};
 
  int HasViewProp(vtkProp *);
 
  void RemoveViewProp(vtkProp *);
 
  void RemoveAllViewProps(void);
 
 
  void AddActor2D(vtkProp* p);
  void RemoveActor2D(vtkProp* p);
  vtkActor2DCollection *GetActors2D();
 
 
  vtkSetVector3Macro(Background,double);
  vtkGetVector3Macro(Background,double);
 
 
  vtkSetVector3Macro(Background2,double);
  vtkGetVector3Macro(Background2,double);
 
 
  vtkSetMacro(GradientBackground,bool);
  vtkGetMacro(GradientBackground,bool);
  vtkBooleanMacro(GradientBackground,bool);
 
 
  vtkSetVector2Macro(Aspect,double);
  vtkGetVectorMacro(Aspect,double,2);
  virtual void ComputeAspect();
 
 
  vtkSetVector2Macro(PixelAspect,double);
  vtkGetVectorMacro(PixelAspect,double,2);
 
 
  vtkSetVector4Macro(Viewport,double);
  vtkGetVectorMacro(Viewport,double,4);
 
 
  vtkSetVector3Macro(DisplayPoint,double);
  vtkGetVectorMacro(DisplayPoint,double,3);
 
 
  vtkSetVector3Macro(ViewPoint,double);
  vtkGetVectorMacro(ViewPoint,double,3);
 
 
  vtkSetVector4Macro(WorldPoint,double);
  vtkGetVectorMacro(WorldPoint,double,4);
 
  virtual double *GetCenter();
 
  virtual int IsInViewport(int x,int y);
 
  virtual vtkWindow *GetVTKWindow() = 0;
 
  virtual void DisplayToView(); // these get modified in subclasses
 
  virtual void ViewToDisplay(); // to handle stereo rendering
 
  virtual void WorldToView();
 
  virtual void ViewToWorld();
 
  void DisplayToWorld() {this->DisplayToView(); this->ViewToWorld();};
 
  void WorldToDisplay() {this->WorldToView(); this->ViewToDisplay();};
 
 
  virtual void LocalDisplayToDisplay(double &x, double &y);
  virtual void DisplayToNormalizedDisplay(double &u, double &v);
  virtual void NormalizedDisplayToViewport(double &x, double &y);
  virtual void ViewportToNormalizedViewport(double &u, double &v);
  virtual void NormalizedViewportToView(double &x, double &y, double &z);
  virtual void ViewToWorld(double &, double &, double &) {}
  virtual void DisplayToLocalDisplay(double &x, double &y);
  virtual void NormalizedDisplayToDisplay(double &u, double &v);
  virtual void ViewportToNormalizedDisplay(double &x, double &y);
  virtual void NormalizedViewportToViewport(double &u, double &v);
  virtual void ViewToNormalizedViewport(double &x, double &y, double &z);
  virtual void WorldToView(double &, double &, double &) {}
 
 
  virtual int *GetSize();
  virtual int *GetOrigin();
  void GetTiledSize(int *width, int *height);
  virtual void GetTiledSizeAndOrigin(int *width, int *height,
                                     int *lowerLeftX, int *lowerLeftY);
 
  // The following methods describe the public pick interface for picking
  // Props in a viewport.
 
  virtual vtkAssemblyPath* PickProp(double selectionX, double selectionY) = 0;
 
 
  virtual vtkAssemblyPath* PickProp(double selectionX1, double selectionY1,
                                    double selectionX2, double selectionY2) = 0;
 
 
  vtkAssemblyPath* PickPropFrom(double selectionX, double selectionY,
                                vtkPropCollection*);
 
 
  vtkAssemblyPath* PickPropFrom(double selectionX1, double selectionY1,
                                double selectionX2, double selectionY2,
                                vtkPropCollection*);
 
 
  double GetPickX() const {return (this->PickX1 + this->PickX2)*0.5;}
  double GetPickY() const {return (this->PickY1 + this->PickY2)*0.5;}
  double GetPickWidth() const {return this->PickX2 - this->PickX1 + 1;};
  double GetPickHeight() const {return this->PickY2 - this->PickY1 + 1;};
  double GetPickX1() const {return this->PickX1;}
  double GetPickY1() const {return this->PickY1;}
  double GetPickX2() const {return this->PickX2;}
  double GetPickY2() const {return this->PickY2;}
  vtkGetMacro(IsPicking, int);
  vtkGetMacro(CurrentPickId, unsigned int);
  void SetCurrentPickId(unsigned int a) {this->CurrentPickId = a;};
  vtkGetObjectMacro(PickResultProps, vtkPropCollection);
 
  virtual double GetPickedZ() = 0;
 
protected:
  // Create a vtkViewport with a black background, a white ambient light,
  // two-sided lighting turned on, a viewport of (0,0,1,1), and back face
  // culling turned off.
  vtkViewport();
  ~vtkViewport();
 
  //BTX
  // Picking functions to be implemented by sub-classes
  // Perform the main picking loop
  virtual void DevicePickRender() = 0;
  // Enter a pick mode
  virtual void StartPick(unsigned int pickFromSize) = 0;
  // Set the pick id to the next id before drawing an object
  virtual void UpdatePickId() = 0;
  // Exit Pick mode
  virtual void DonePick() = 0;
  // Return the id of the picked object, only valid after a call to DonePick
  virtual unsigned int GetPickedId() = 0;
  // Return the number of objects picked, only valid after a call to DonePick
  virtual unsigned int GetNumPickedIds() = 0;
  // Put no more than atMost picked object ids into the callerBuffer and
  // return the number of picked objects returned.
  virtual int GetPickedIds(unsigned int atMost, unsigned int *callerBuffer) = 0;
  //ETX
 
  // Ivars for picking
  // Store a picked Prop (contained in an assembly path)
  vtkAssemblyPath* PickedProp;
  vtkPropCollection* PickFromProps;
  vtkPropCollection* PickResultProps;
  // Boolean flag to determine if picking is enabled for this render
  int IsPicking;
  unsigned int CurrentPickId;
  double PickX1;
  double PickY1;
  double PickX2;
  double PickY2;
  // End Ivars for picking
 
  vtkPropCollection *Props;
  vtkActor2DCollection *Actors2D;
  vtkWindow *VTKWindow;
  double Background[3];
  double Background2[3];
  double Viewport[4];
  double Aspect[2];
  double PixelAspect[2];
  double Center[2];
  bool GradientBackground;
 
  int Size[2];
  int Origin[2];
  double DisplayPoint[3];
  double ViewPoint[3];
  double WorldPoint[4];
 
 
private:
  vtkViewport(const vtkViewport&);  // Not implemented.
  void operator=(const vtkViewport&);  // Not implemented.
};
 
 
 
#endif