vtkViewport.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef vtkViewport_h
#define vtkViewport_h
 
#include "vtkObject.h"
#include "vtkRenderingCoreModule.h" // For export macro
#include "vtkWrappingHints.h"       // For VTK_MARSHALAUTO
 
#include "vtkSelection.h"    // Needed for selection
#include "vtkSmartPointer.h" // Needed for assigning default nullptr value
 
#include <array> // To store matrices
 
VTK_ABI_NAMESPACE_BEGIN
class vtkActor2DCollection;
class vtkAssemblyPath;
class vtkProp;
class vtkPropCollection;
class vtkWindow;
 
class VTKRENDERINGCORE_EXPORT VTK_MARSHALAUTO vtkViewport : public vtkObject
{
public:
  vtkTypeMacro(vtkViewport, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  void AddViewProp(vtkProp*);

  vtkPropCollection* GetViewProps() { return this->Props; }

  vtkTypeBool HasViewProp(vtkProp*);

  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  void RemoveViewProp(vtkProp*);

  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  void RemoveAllViewProps();


  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  void AddActor2D(vtkProp* p);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  void RemoveActor2D(vtkProp* p);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  vtkActor2DCollection* GetActors2D();


  vtkSetVector3Macro(Background, double);
  vtkGetVector3Macro(Background, double);


  vtkSetVector3Macro(Background2, double);
  vtkGetVector3Macro(Background2, double);
  //


  vtkSetClampMacro(BackgroundAlpha, double, 0.0, 1.0);
  vtkGetMacro(BackgroundAlpha, double);


  vtkSetMacro(GradientBackground, bool);
  vtkGetMacro(GradientBackground, bool);
  vtkBooleanMacro(GradientBackground, bool);


  vtkSetMacro(DitherGradient, bool);
  vtkGetMacro(DitherGradient, bool);
  vtkBooleanMacro(DitherGradient, bool);
 
  enum class GradientModes : int
  {
    // Background color is used at the bottom, Background2 color is used at the top.
    VTK_GRADIENT_VERTICAL,
    // Background color on the left, Background2 color on the right.
    VTK_GRADIENT_HORIZONTAL,
    // Background color in the center, Background2 color on and beyond the ellipse edge.
    // Ellipse touches all sides of the viewport. The ellipse is a circle for viewports with equal
    // width and height.
    VTK_GRADIENT_RADIAL_VIEWPORT_FARTHEST_SIDE,
    // Background color in the center, Background2 color on and beyond the ellipse edge.
    // Ellipse touches all corners of the viewport. The ellipse is a circle for viewports with equal
    // width and height.
    VTK_GRADIENT_RADIAL_VIEWPORT_FARTHEST_CORNER,
  };


  vtkSetEnumMacro(GradientMode, GradientModes);
  vtkGetEnumMacro(GradientMode, GradientModes);


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

  virtual vtkTypeBool 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();
  }

  inline void WorldToDisplay(double& x, double& y, double& z)
  {
    this->WorldToView(x, y, z);
    this->ViewToDisplay(x, y, z);
  }


  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 ViewToPose(double&, double&, double&) {}
  virtual void PoseToWorld(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 PoseToView(double&, double&, double&) {}
  virtual void WorldToPose(double&, double&, double&) {}
  virtual void ViewToWorld(double&, double&, double&) {}
  virtual void WorldToView(double&, double&, double&) {}
  virtual void ViewToDisplay(double& x, double& y, double& z);


  virtual int* GetSize() VTK_SIZEHINT(2);
  virtual int* GetOrigin() VTK_SIZEHINT(2);
  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 without/with setting fieldAssociation and selection.

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

  virtual vtkAssemblyPath* PickProp(double selectionX, double selectionY, int fieldAssociation,
    vtkSmartPointer<vtkSelection> selection) = 0;

  virtual vtkAssemblyPath* PickProp(double selectionX1, double selectionY1, double selectionX2,
    double selectionY2, int fieldAssociation, vtkSmartPointer<vtkSelection> selection) = 0;

  vtkAssemblyPath* PickPropFrom(double selectionX, double selectionY, vtkPropCollection*,
    int fieldAssociation, vtkSmartPointer<vtkSelection> selection);

  vtkAssemblyPath* PickPropFrom(double selectionX1, double selectionY1, double selectionX2,
    double selectionY2, vtkPropCollection*, int fieldAssociation,
    vtkSmartPointer<vtkSelection> selection);


  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; }
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_INTERNAL)
  vtkGetObjectMacro(PickResultProps, vtkPropCollection);

  virtual double GetPickedZ() { return this->PickedZ; }


  vtkSetVector3Macro(EnvironmentalBG, double);
  vtkGetVector3Macro(EnvironmentalBG, double);


  vtkSetVector3Macro(EnvironmentalBG2, double);
  vtkGetVector3Macro(EnvironmentalBG2, double);

  vtkSetMacro(GradientEnvironmentalBG, bool);
  vtkGetMacro(GradientEnvironmentalBG, bool);
  vtkBooleanMacro(GradientEnvironmentalBG, bool);
 
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() override;
 
  // Ivars for picking
  // Store a picked Prop (contained in an assembly path)
  vtkAssemblyPath* PickedProp;
  vtkPropCollection* PickFromProps;
  vtkPropCollection* PickResultProps;
  double PickX1;
  double PickY1;
  double PickX2;
  double PickY2;
  double PickedZ;
  // End Ivars for picking
 
  vtkPropCollection* Props;
  vtkActor2DCollection* Actors2D;
  vtkWindow* VTKWindow;
  double Background[3];
  double Background2[3];
  double BackgroundAlpha;
  double Viewport[4];
  double Aspect[2];
  double PixelAspect[2];
  double Center[2];
  bool GradientBackground;
  bool DitherGradient;
  GradientModes GradientMode = GradientModes::VTK_GRADIENT_VERTICAL;
 
  double EnvironmentalBG[3];
  double EnvironmentalBG2[3];
  bool GradientEnvironmentalBG;
 
  int Size[2];
  int Origin[2];
  double DisplayPoint[3];
  double ViewPoint[3];
  double WorldPoint[4];
 
private:
  std::array<int, 2> LastComputeAspectSize;
  std::array<double, 4> LastComputeAspectVPort;
  std::array<double, 2> LastComputeAspectPixelAspect;
 
  vtkViewport(const vtkViewport&) = delete;
  void operator=(const vtkViewport&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif