Skip to main content
`Ctrl`+`K`

# `scene`

This module provides a 3D graphics scene graph structure.

## `axes`: Bounding Box with axes ticks and labels

Primitive displaying a text field in the scene.

class LabelledAxes

  A group displaying a bounding box with axes labels around its children.

  property tickColor

    Color of ticks and text labels.

    This does NOT set bounding box color. Use `color` for the bounding box.

  property font

    Font of axes text labels (Font)

  property xlabel

    Text label of the X axis (str)

  property ylabel

    Text label of the Y axis (str)

  property zlabel

    Text label of the Z axis (str)

  property boxVisible

    Returns bounding box, axes labels and grid visibility.

  prepareGL2(context)

    Called before the rendering to prepare OpenGL resources.

    Override in subclass.

## `camera`: Projection management classes

This module provides classes to handle a perspective projection in 3D.

class CameraExtrinsic(position=(0.0, 0.0, 0.0), direction=(0.0, 0.0, -1.0), up=(0.0, 1.0, 0.0))

  Transform matrix to handle camera position and orientation.

  Parameters:

    - position (numpy.ndarray-like of 3 float32.) – Coordinates of the point of view.

    - direction (numpy.ndarray-like of 3 float32.) – Sight direction vector.

    - up (numpy.ndarray-like of 3 float32.) – Vector pointing upward in the image plane.

  copy()

    Return an independent copy

  setOrientation(direction=None, up=None)

    Set the rotation of the point of view.

    Parameters:

      - direction (numpy.ndarray-like of 3 float32 or None.) – Sight direction vector or None to keep the current one.

      - up (numpy.ndarray-like of 3 float32 or None.) – Vector pointing upward in the image plane or None to keep the current one.

    Raises:

      RuntimeError – if the direction and up are parallel.

  property position

    Coordinates of the point of view as a numpy.ndarray of 3 float32.

  property direction

    Sight direction (ndarray of 3 float32).

  property up

    Vector pointing upward in the image plane (ndarray of 3 float32).

  property side

    Vector pointing towards the side of the image plane.

    ndarray of 3 float32

  move(direction, step=1.0)

    Move the camera relative to the image plane.

    Parameters:

      - direction (str) – Direction relative to image plane. One of: ‘up’, ‘down’, ‘left’, ‘right’, ‘forward’, ‘backward’.

      - step (float) – The step of the pan to perform in the coordinate in which the camera position is defined.

  rotate(direction, angle=1.0)

    First-person rotation of the camera towards the direction.

    Parameters:

      - direction (str) – Direction of movement relative to image plane. In: ‘up’, ‘down’, ‘left’, ‘right’.

      - angle (float) – The angle in degrees of the rotation.

  orbit(direction, center=(0.0, 0.0, 0.0), angle=1.0)

    Rotate the camera around a point.

    Parameters:

      - direction (str) – Direction of movement relative to image plane. In: ‘up’, ‘down’, ‘left’, ‘right’.

      - center (numpy.ndarray-like of 3 float32.) – Position around which to rotate the point of view.

      - angle (float) – he angle in degrees of the rotation.

  reset(face=None)

    Reset the camera position to pre-defined orientations.

    Parameters:

      face (str) – The direction of the camera in: side, front, back, top, bottom, right, left.

class Camera(fovy=30.0, near=0.1, far=1.0, size=(1.0, 1.0), position=(0.0, 0.0, 0.0), direction=(0.0, 0.0, -1.0), up=(0.0, 1.0, 0.0))

  Combination of camera projection and position.

  See `Perspective` and `CameraExtrinsic`.

  Parameters:

    - fovy (float) – Vertical field-of-view in degrees.

    - near (float) – The near clipping plane Z coord (strictly positive).

    - far (float) – The far clipping plane Z coord (> near).

    - size (2-tuple of float) – Viewport’s size used to compute the aspect ratio (width, height).

    - position (numpy.ndarray-like of 3 float32.) – Coordinates of the point of view.

    - direction (numpy.ndarray-like of 3 float32.) – Sight direction vector.

    - up (numpy.ndarray-like of 3 float32.) – Vector pointing upward in the image plane.

  resetCamera(bounds)

    Change camera to have the bounds in the viewing frustum.

    It updates the camera position and depth extent. Camera sight direction and up are not affected.

    Parameters:

      bounds (numpy.ndarray: ((xMin, yMin, zMin), (xMax, yMax, zMax))) – The axes-aligned bounds to include.

  property intrinsic

    Intrinsic camera parameters, i.e., projection matrix.

  property extrinsic

    Extrinsic camera parameters, i.e., position and orientation.

  move(*args, **kwargs)

    See `CameraExtrinsic.move()`.

  rotate(*args, **kwargs)

    See `CameraExtrinsic.rotate()`.

  orbit(*args, **kwargs)

    See `CameraExtrinsic.orbit()`.

## `core`: Base class of the scene nodes

This module provides the base scene structure.

This module provides the classes for describing a tree structure with rendering and picking API. All nodes inherit from `Base`. Nodes with children are provided with `PrivateGroup` and `Group` classes. Leaf rendering nodes should inherit from `Elem`.

class Base

  A scene node with common features.

  property visible

    Visibility flag of the node

  property pickable

    True to make node pickable

  property parent

    Parent or None if no parent

  property path

    Tuple of scene nodes, from the tip of the tree down to this node.

    If this tree is attached to a `Viewport`, then the `Viewport` is the first element of path.

  property viewport

    The viewport this node is attached to or None.

  property root

    The root node of the scene.

    If attached to a `Viewport`, this is the item right under it

  property objectToNDCTransform

    Transform from object to normalized device coordinates.

    Do not forget perspective divide.

  property objectToSceneTransform

    Transform from object to scene.

    Combine transforms up to the Viewport (not including it).

  property transforms

    List of transforms defining the frame of this node relative to its parent.

  bounds(transformed=False, dataBounds=False)

    Returns the bounds of this node aligned with the axis, with or without transform applied.

    Parameters:

      - transformed (bool) – False to give bounds in object coordinates (the default), True to apply this object’s transforms.

      - dataBounds (bool) – False to give bounds of vertices (the default), True to give bounds of the represented data.

    Returns:

      The bounds: ((xMin, yMin, zMin), (xMax, yMax, zMax)) or None if no bounds.

    Return type:

      numpy.ndarray of float

  prepareGL2(ctx)

    Called before the rendering to prepare OpenGL resources.

    Override in subclass.

  renderGL2(ctx)

    Called to perform the OpenGL rendering.

    Override in subclass.

  render(ctx)

    Called internally to perform rendering.

  postRender(ctx)

    Hook called when parent’s node render is finished.

    Called in the reverse of rendering order (i.e., last child first).

    Meant for nodes that modify the `RenderContext` ctx to reset their modifications.

  pick(ctx, x, y, depth=None)

    True/False picking, should be fast

  pickRay(ctx, ray)

    Picking returning list of ray intersections.

class Elem

  A scene node that does some rendering.

class PrivateGroup(children=())

  A scene node that renders its (private) childern.

  Parameters:

    children (iterable) – `Base` nodes to add as children

  class ChildrenList(parent, children)

    List of children with notification and children’s parent update.

  prepareGL2(ctx)

    Called before the rendering to prepare OpenGL resources.

    Override in subclass.

  renderGL2(ctx)

    Render all children

class Group(children=())

  A scene node that renders its (public) children.

  property children

    List of children to be rendered.

## `cutplane`: Cutting plane primitive

A cut plane in a 3D texture: hackish implementation…

class ColormapMesh3D(position, normal, data, copy=True, mode='triangles', indices=None, colormap=None)

  A 3D mesh with color from a 3D texture.

  textureOffset

    Offset to add to texture coordinates

  property interpolation

    The texture interpolation mode: ‘linear’ or ‘nearest’

  property alpha

    Transparency of the plane, float in [0, 1]

  property colormap

    The colormap used by this primitive

  prepareGL2(ctx)

    Called before the rendering to prepare OpenGL resources.

    Override in subclass.

  renderGL2(ctx)

    Called to perform the OpenGL rendering.

    Override in subclass.

class CutPlane(point=(0.0, 0.0, 0.0), normal=(0.0, 0.0, 1.0))

  A cutting plane in a 3D texture

  property interpolation

    The texture interpolation mode: ‘linear’ (default) or ‘nearest’

  prepareGL2(ctx)

    Called before the rendering to prepare OpenGL resources.

    Override in subclass.

  renderGL2(ctx)

    Render all children

  property contourVertices

    The vertices of the contour of the plane/bounds intersection.

  property transforms

    List of transforms defining the frame of this node relative to its parent.

## `event`: Scene event system

This module provides a simple generic notification system.

class Notifier

  Base class for object with notification mechanism.

  addListener(listener)

    Register a listener.

    Adding an already registered listener has no effect.

    Parameters:

      listener (callable) – The function or method to register.

  removeListener(listener)

    Remove a previously registered listener.

    Parameters:

      listener (callable) – The function or method to unregister.

  notify(*args, **kwargs)

    Notify all registered listeners with the given parameters.

    Listeners are called directly in this method. Listeners are called in the order they were registered.

notifyProperty(attrName, copy=False, converter=None, doc=None)

  Create a property that adds notification to an attribute.

  Parameters:

    - attrName (str) – The name of the attribute to wrap.

    - copy (bool) – Whether to return a copy of the attribute or not (the default).

    - converter – Function converting input value to appropriate type This function takes a single argument and return the converted value. It can be used to perform some asserts.

    - doc (str) – The docstring of the property

  Returns:

    A property with getter and setter

class HookList(iterable)

  List with hooks before and after modification.

  append(*args, **kwargs)

    Append object to the end of the list.

  extend(*args, **kwargs)

    Extend list by appending elements from the iterable.

  insert(*args, **kwargs)

    Insert object before index.

  remove(*args, **kwargs)

    Remove first occurrence of value.

    Raises ValueError if the value is not present.

  pop(*args, **kwargs)

    Remove and return item at index (default last).

    Raises IndexError if list is empty or index is out of range.

  sort(*args, **kwargs)

    Sort the list in ascending order and return None.

    The sort is in-place (i.e. the list itself is modified) and stable (i.e. the order of two equal elements is maintained).

    If a key function is given, apply it once to each list item and sort them, ascending or descending, according to their function values.

    The reverse flag can be set to sort in descending order.

  reverse(*args, **kwargs)

    Reverse IN PLACE.

class NotifierList(iterable=())

  List of Notifiers with notification mechanism.

  This class registers itself as a listener of the list items.

  The default listener method forward notification from list items to the listeners of the list.

## `function`: OpenGL shader functions

This module provides functions to add to shaders.

class ProgramFunction

  Class providing a function to add to a GLProgram shaders.

  setupProgram(context, program)

    Sets-up uniforms of a program using this shader function.

    Parameters:

      - context (RenderContext) – The current rendering context

      - program (GLProgram) – The program to set-up. It MUST be in use and using this function.

class Fog

  Linear fog over the whole scene content.

  The background of the viewport is used as fog color, otherwise it defaults to white.

  property isOn

    True to enable fog, False to disable (bool)

  setupProgram(context, program)

    Sets-up uniforms of a program using this shader function.

    Parameters:

      - context (RenderContext) – The current rendering context

      - program (GLProgram) – The program to set-up. It MUST be in use and using this function.

class ClippingPlane(point=(0.0, 0.0, 0.0), normal=(0.0, 0.0, 0.0))

  Description of a clipping plane and rendering.

  Convention: Clipping is performed in camera/eye space.

  Parameters:

    - point (numpy.ndarray-like of 3 float32) – Local coordinates of a point on the plane.

    - normal (numpy.ndarray-like of 3 float32) – Local coordinates of the plane normal.

  property plane

    Plane parameters in camera space.

  setupProgram(context, program)

    Sets-up uniforms of a program using this shader function.

    Parameters:

      - context (RenderContext) – The current rendering context

      - program (GLProgram) – The program to set-up. It MUST be in use and using this function.

class DirectionalLight(direction=None, ambient=(1.0, 1.0, 1.0), diffuse=(0.0, 0.0, 0.0), specular=(1.0, 1.0, 1.0), shininess=0)

  Description of a directional Phong light.

  Parameters:

    - direction (ndarray of 3 floats or None) – The direction of the light or None to disable light

    - ambient (ndarray of 3 floats in [0, 1], default: (1., 1., 1.)) – RGB ambient light

    - diffuse (ndarray of 3 floats in [0, 1], default: (0., 0., 0.)) – RGB diffuse light parameter

    - specular (ndarray of 3 floats in [0, 1], default: (1., 1., 1.)) – RGB specular light parameter

    - shininess (int) – The shininess of the material for specular term, default: 0 which disables specular component.

  property isOn

    True if light is on, False otherwise.

  turnOff()

    Context manager to temporary turn off lighting during rendering.

        >>> with light.turnOff():
        ...     # Do some rendering without lighting

  property direction

    The direction of the light, or None if light is not on.

  property fragmentDef

    Definition to add to fragment shader

  property fragmentCall

    Function name to call in fragment shader

  setupProgram(context, program)

    Sets-up uniforms of a program using this shader function.

    Parameters:

      - context (RenderContext) – The current rendering context

      - program (GLProgram) – The program to set-up. It MUST be in use and using this function.

class Colormap(colormap=None, norm='linear', gamma=0.0, range_=(1.0, 10.0))
  NORMS = ('linear', 'log', 'sqrt', 'gamma', 'arcsinh')

    Tuple of supported normalizations.

  property decl

    Source code of the function declaration

  property colormap

    Color look-up table to use.

  property nancolor

    RGBA color to use for Not-A-Number values as 4 float in [0., 1.]

  property norm

    Normalization to use for colormap mapping.

    One of ‘linear’ (the default), ‘log’ for log10 mapping or ‘sqrt’. Invalid values (e.g., negative values with ‘log’ or ‘sqrt’) are mapped to 0.

  property gamma

    Gamma correction normalization parameter (float >= 0.)

  property range_

    Range of values to map to the colormap.

    2-tuple of floats: (begin, end). The begin value is mapped to the origin of the colormap and the end value is mapped to the other end of the colormap. The colormap is reversed if begin > end.

  property displayValuesBelowMin

    True to display values below colormap min, False to discard them.

  setupProgram(context, program)

    Sets-up uniforms of a program using this shader function.

    Parameters:

      - context (RenderContext) – The current rendering context

      - program (GLProgram) – The program to set-up. It MUST be in use and using this function.

## `interaction`: User interaction implementation

This module provides interaction to plug on the scene graph.

class ClickOrDrag(button='left')

  Click or drag interaction for a given button.

  class Idle(machine)
  class ClickOrDrag(machine)
    enterState(x, y)

      Called when the state machine enters this state.

      Arguments are those provided to the `goto()` method that triggered the transition to this state.

  class Drag(machine)
    enterState(initPos, curPos)

      Called when the state machine enters this state.

      Arguments are those provided to the `goto()` method that triggered the transition to this state.

  click(x, y)

    Called upon a left or right button click. To override in a subclass.

  beginDrag(x, y)

    Called at the beginning of a drag gesture with left button pressed. To override in a subclass.

  drag(x, y)

    Called on mouse moved during a drag gesture. To override in a subclass.

  endDrag(x, y)

    Called at the end of a drag gesture when the left button is released. To override in a subclass.

class CameraSelectRotate(viewport, orbitAroundCenter=True, button='right', selectCB=None)

  Camera rotation using an arcball-like interaction.

  click(x, y)

    Called upon a left or right button click. To override in a subclass.

  beginDrag(x, y)

    Called at the beginning of a drag gesture with left button pressed. To override in a subclass.

  drag(x, y)

    Called on mouse moved during a drag gesture. To override in a subclass.

  endDrag(x, y)

    Called at the end of a drag gesture when the left button is released. To override in a subclass.

class CameraSelectPan(viewport, button='left', selectCB=None)

  Picking on click and pan camera on drag.

  click(x, y)

    Called upon a left or right button click. To override in a subclass.

  beginDrag(x, y)

    Called at the beginning of a drag gesture with left button pressed. To override in a subclass.

  drag(x, y)

    Called on mouse moved during a drag gesture. To override in a subclass.

  endDrag(x, y)

    Called at the end of a drag gesture when the left button is released. To override in a subclass.

class CameraWheel(viewport, mode='center', scaleTransform=None)

  StateMachine like class, just handling wheel events.

class FocusManager(eventHandlers=(), ctrlEventHandlers=None)

  Manages focus across multiple event handlers

  On press an event handler can acquire focus. By default it looses focus when all buttons are released.

  class Idle(machine)
  class Focus(machine)
    enterState(eventHandler, btn)

      Called when the state machine enters this state.

      Arguments are those provided to the `goto()` method that triggered the transition to this state.

class RotateCameraControl(viewport, orbitAroundCenter=False, mode='center', scaleTransform=None, selectCB=None)

  Combine wheel and rotate state machine for left button and pan when ctrl is pressed

class PanCameraControl(viewport, orbitAroundCenter=False, mode='center', scaleTransform=None, selectCB=None)

  Combine wheel, selectPan and rotate state machine for left button and rotate when ctrl is pressed

class CameraControl(viewport, orbitAroundCenter=False, mode='center', scaleTransform=None, selectCB=None)

  Combine wheel, selectPan and rotate state machine.

class PlaneRotate(viewport, plane, button='right')

  Plane rotation using arcball interaction.

  Arcball ref.: Ken Shoemake. ARCBALL: A user interface for specifying three-dimensional orientation using a mouse. In Proc. GI ‘92. (1992). pp. 151-156.

  click(x, y)

    Called upon a left or right button click. To override in a subclass.

  beginDrag(x, y)

    Called at the beginning of a drag gesture with left button pressed. To override in a subclass.

  drag(x, y)

    Called on mouse moved during a drag gesture. To override in a subclass.

  endDrag(x, y)

    Called at the end of a drag gesture when the left button is released. To override in a subclass.

class PlanePan(viewport, plane, button='left')

  Pan a plane along its normal on drag.

  click(x, y)

    Called upon a left or right button click. To override in a subclass.

  beginDrag(x, y)

    Called at the beginning of a drag gesture with left button pressed. To override in a subclass.

  drag(x, y)

    Called on mouse moved during a drag gesture. To override in a subclass.

  endDrag(x, y)

    Called at the end of a drag gesture when the left button is released. To override in a subclass.

class PlaneControl(viewport, plane, mode='center', scaleTransform=None)

  Combine wheel, selectPan and rotate state machine for plane control.

class PanPlaneRotateCameraControl(viewport, plane, mode='center', scaleTransform=None)

  Combine wheel, pan plane and camera rotate state machine.

class PanPlaneZoomOnWheelControl(viewport, plane, mode='center', orbitAroundCenter=False, scaleTransform=None)

  Combine zoom on wheel and pan plane state machines.

## `primitives`: Base rendering primitives

class Geometry(mode, indices=None, copy=True, attrib0='position', **attributes)

  Set of vertices with normals and colors.

  Parameters:

    - mode (str) – OpenGL drawing mode: lines, line_strip, loop, triangles, triangle_strip, fan

    - indices – Array of vertex indices or None

    - copy (bool) – True (default) to copy the data, False to use as is.

    - attrib0 (str) – Name of the attribute that MUST be an array.

    - attributes – Provide list of attributes as extra parameters.

  property drawMode

    Kind of primitive to render, in `_MODES` (str)

  property nbVertices

    Returns the number of vertices of current attributes.

    It returns None if there is no attributes.

  property attrib0

    Attribute name that MUST be an array (str)

  setAttribute(name, array, copy=True)

    Set attribute with provided array.

    Parameters:

      - name (str) – The name of the attribute

      - array – Array-like attribute data or None to remove attribute

      - copy (bool) – True (default) to copy the data, False to use as is

  getAttribute(name, copy=True)

    Returns the numpy.ndarray corresponding to the name attribute.

    Parameters:

      - name (str) – The name of the attribute to get.

      - copy (bool) – True to get a copy (default), False to get internal array (DO NOT MODIFY)

    Returns:

      The corresponding array or None if no corresponding attribute.

    Return type:

      numpy.ndarray

  useAttribute(program, name=None)

    Enable and bind attribute(s) for a specific program.

    This MUST be called with OpenGL context active and after prepareGL2 has been called.

    Parameters:

      - program (GLProgram) – The program for which to set the attributes

      - name (str) – The attribute name to set or None to set then all

  setIndices(indices, copy=True)

    Set the primitive indices to use.

    Parameters:

      - indices – Array-like of uint primitive indices or None to unset

      - copy (bool) – True (default) to copy the data, False to use as is

  getIndices(copy=True)

    Returns the numpy.ndarray corresponding to the indices.

    Parameters:

      copy (bool) – True to get a copy (default), False to get internal array (DO NOT MODIFY)

    Returns:

      The primitive indices array or None if not set.

    Return type:

      numpy.ndarray or None

  property boundsAttributeNames

    Tuple of attribute names defining the bounds of the object.

    Attributes name are taken in the given order to compute the (x, y, z) the bounding box, e.g.:

        geometry.boundsAttributeNames = 'position'
        geometry.boundsAttributeNames = 'x', 'y', 'z'

  prepareGL2(ctx)

    Called before the rendering to prepare OpenGL resources.

    Override in subclass.

class Lines(positions, normals=None, colors=(1.0, 1.0, 1.0, 1.0), indices=None, mode='lines', width=1.0)

  A set of segments

  property width

    Width of the line in pixels.

  property smooth

    Smooth line rendering enabled (bool, default: True)

  renderGL2(ctx)

    Called to perform the OpenGL rendering.

    Override in subclass.

class DashedLines(positions, colors=(1.0, 1.0, 1.0, 1.0), indices=None, width=1.0)

  Set of dashed lines

  This MUST be defined as a set of lines (no strip or loop).

  property dash

    Dash of the line as a 2-tuple of lengths in pixels: (on, off)

  getPositions(copy=True)

    Get coordinates of lines.

    Parameters:

      copy (bool) – True to get a copy, False otherwise

    Returns:

      Coordinates of lines

    Return type:

      numpy.ndarray of float32 of shape (N, 2, Ndim)

  setPositions(positions, copy=True)

    Set line coordinates.

    Parameters:

      - positions – Array of line coordinates

      - copy (bool) – True to copy input array, False to use as is

  renderGL2(context)

    Called to perform the OpenGL rendering.

    Override in subclass.

class Box(stroke=(1.0, 1.0, 1.0, 1.0), fill=(1.0, 1.0, 1.0, 0.0))

  Rectangular box

  classmethod getLineIndices(copy=True)

    Returns 2D array of Box lines indices

    Parameters:

      copy – True (default) to get a copy, False to get internal array (Do not modify!)

    Return type:

      numpy.ndarray

  classmethod getVertices(copy=True)

    Returns 2D array of Box corner coordinates.

    Parameters:

      copy – True (default) to get a copy, False to get internal array (Do not modify!)

    Return type:

      numpy.ndarray

  property size

    Size of the box (sx, sy, sz)

  property strokeSmooth

    True to draw smooth stroke, False otherwise

  property strokeWidth

    Width of the stroke (float)

  property strokeColor

    RGBA color of the box lines (4-tuple of float in [0, 1])

  property fillColor

    RGBA color of the box faces (4-tuple of float in [0, 1])

class Axes

  3D RGB orthogonal axes

  property size

    Size of the axes (sx, sy, sz)

class BoxWithAxes(color=(1.0, 1.0, 1.0, 1.0))

  Rectangular box with RGB OX, OY, OZ axes

  Parameters:

    color – RGBA color of the box

  property color

    The RGBA color to use for the box: 4 float in [0, 1]

  property size

    Size of the axes (sx, sy, sz)

class PlaneInGroup(point=(0.0, 0.0, 0.0), normal=(0.0, 0.0, 1.0))

  A plane using its parent bounds to display a contour.

  If plane is outside the bounds of its parent, it is not visible.

  Cannot set the transform attribute of this primitive. This primitive never has any bounds.

  moveToCenter()

    Place the plane at the center of the data, not changing orientation.

  property color

    Plane outline color (array of 4 float in [0, 1]).

  property width

    Width of the plane stroke in pixels

  property strokeVisible

    Whether surrounding stroke is visible or not (bool).

  property plane

    The plane parameters in the frame of the object.

  property transforms

    List of transforms defining the frame of this node relative to its parent.

  property contourVertices

    The vertices of the contour of the plane/bounds intersection.

  property center

    The center of the plane/bounds intersection points.

  property isValid

    True if a contour is defined, False otherwise.

  prepareGL2(ctx)

    Called before the rendering to prepare OpenGL resources.

    Override in subclass.

  renderGL2(ctx)

    Render all children

class BoundedGroup(children=())

  Group with data bounds

  property shape

    Data shape (depth, height, width) of this group or None

  property size

    Data size (width, height, depth) of this group or None

class Points(x, y, z, value=0.0, size=1.0, indices=None, colormap=None)

  A set of data points with an associated value and size.

  property colormap

    The colormap used to render the image

class ColorPoints(x, y, z, color=(1.0, 1.0, 1.0, 1.0), size=1.0, indices=None)

  A set of points with an associated color and size.

  setColor(color, copy=True)

    Set colors

    Parameters:

      - color – Single RGBA color or 2D array of color of length number of points

      - copy (bool) – True to copy colors (default), False to use provided array (Do not modify!)

  getColor(copy=True)

    Returns the color or array of colors of the points.

    Parameters:

      copy – True to get a copy (default), False to return internal array (Do not modify!)

    Returns:

      Color or array of colors

    Return type:

      numpy.ndarray

class GridPoints(values=0.0, shape=None, sizes=1.0, indices=None, minValue=None, maxValue=None)

  Data points on a regular grid with an associated value and size.

  renderGL2(ctx)

    Called to perform the OpenGL rendering.

    Override in subclass.

class Spheres(positions, radius=1.0, colors=(1.0, 1.0, 1.0, 1.0))

  A set of spheres.

  Spheres are rendered as circles using points. This brings some limitations: - Do not support non-uniform scaling. - Assume the projection keeps ratio. - Do not render distorion by perspective projection. - If the sphere center is clipped, the whole sphere is not displayed.

  renderGL2(ctx)

    Called to perform the OpenGL rendering.

    Override in subclass.

class Mesh3D(positions, colors, normals=None, mode='triangles', indices=None, copy=True)

  A conventional 3D mesh

  property culling

    Face culling (str)

    One of ‘back’, ‘front’ or None.

  renderGL2(ctx)

    Called to perform the OpenGL rendering.

    Override in subclass.

class ColormapMesh3D(position, value, colormap=None, normal=None, mode='triangles', indices=None, copy=True)

  A 3D mesh with color computed from a colormap

  property lineWidth

    Width of the line in pixels.

  property lineSmooth

    Smooth line rendering enabled (bool, default: True)

  property alpha

    Transparency of the mesh, float in [0, 1]

  property culling

    Face culling (str)

    One of ‘back’, ‘front’ or None.

  property colormap

    The colormap used to render the image

  renderGL2(ctx)

    Called to perform the OpenGL rendering.

    Override in subclass.

class ImageData(data, copy=True, colormap=None)

  Display a 2x2 data array with a texture.

  property colormap

    The colormap used to render the image

class ImageRgba(data, copy=True)

  Display a 2x2 RGBA image with a texture.

  Supports images of float in [0, 1] and uint8.

class GroupDepthOffset(children=(), epsilon=None)

  A group using 2-pass rendering and glDepthRange to avoid Z-fighting

  prepareGL2(ctx)

    Called before the rendering to prepare OpenGL resources.

    Override in subclass.

  renderGL2(ctx)

    Render all children

class GroupNoDepth(children=(), mask=True, notest=True)

  A group rendering its children without writing to the depth buffer

  Parameters:

    - mask (bool) – True (default) to disable writing in the depth buffer

    - notest (bool) – True (default) to disable depth test

  renderGL2(ctx)

    Render all children

class GroupBBox(children=(), color=(1.0, 1.0, 1.0, 1.0))

  A group displaying a bounding box around the children.

  prepareGL2(ctx)

    Called before the rendering to prepare OpenGL resources.

    Override in subclass.

  property color

    The RGBA color to use for the box: 4 float in [0, 1]

  property strokeWidth

    The width of the stroke lines in pixels (float)

  property axesVisible

    Whether axes are displayed or not (bool)

  property boxVisible

    Whether bounding box is displayed or not (bool)

class ClipPlane(point=(0.0, 0.0, 0.0), normal=(0.0, 0.0, 1.0))

  A clipping plane attached to a box

  renderGL2(ctx)

    Render all children

  postRender(ctx)

    Hook called when parent’s node render is finished.

    Called in the reverse of rendering order (i.e., last child first).

    Meant for nodes that modify the `RenderContext` ctx to reset their modifications.

## `text`: Text field rendering primitives

Primitive displaying a text field in the scene.

class Font(name=None, size=-1, weight=-1, italic=False)

  Description of a font.

  Parameters:

    - name (str) – Family of the font

    - size (int) – Size of the font in points

    - weight (int) – Font weight

    - italic (bool) – True for italic font, False (default) otherwise

  property name

    Name of the font (str)

  property size

    Font size in points (int)

  property weight

    Font weight (int)

  property italic

    True for italic (bool)

class Text2D(text='', font=None)

  Text field as a 2D texture displayed with bill-boarding

  Parameters:

    - text (str) – Text to display

    - font (Font) – The font to use

  property text

    Text displayed by this primitive (str)

  property font

    Font to use to raster text (Font)

  property foreground

    RGBA color of the text: 4 float in [0, 1]

  property background

    RGBA background color of the text field: 4 float in [0, 1]

  property overlay

    True to always display text on top of the scene (default: False)

  property align

    Horizontal anchor position of the text field (str).

    Either ‘left’ (default), ‘center’ or ‘right’.

  property valign

    Vertical anchor position of the text field (str).

    Either ‘top’, ‘baseline’ (default), ‘center’ or ‘bottom’

  prepareGL2(context)

    Called before the rendering to prepare OpenGL resources.

    Override in subclass.

  renderGL2(context)

    Called to perform the OpenGL rendering.

    Override in subclass.

class LabelledAxes

  A group displaying a bounding box with axes labels around its children.

  property font

    Font of axes text labels (Font)

  property xlabel

    Text label of the X axis (str)

  property ylabel

    Text label of the Y axis (str)

  property zlabel

    Text label of the Z axis (str)

  prepareGL2(context)

    Called before the rendering to prepare OpenGL resources.

    Override in subclass.

## `transform`: Transformation matrix system

This module provides 4x4 matrix operation and classes to handle them.

mat4LookAtDir(position, direction, up)

  Creates matrix to look in direction from position.

  Parameters:

    - position – Array-like 3 coordinates of the point of view position.

    - direction – Array-like 3 coordinates of the sight direction vector.

    - up – Array-like 3 coordinates of the upward direction in the image plane.

  Returns:

    Corresponding matrix.

  Return type:

    numpy.ndarray of shape (4, 4)

mat4LookAt(position, center, up)

  Creates matrix to look at center from position.

  See gluLookAt.

  Parameters:

    - position – Array-like 3 coordinates of the point of view position.

    - center – Array-like 3 coordinates of the center of the scene.

    - up – Array-like 3 coordinates of the upward direction in the image plane.

  Returns:

    Corresponding matrix.

  Return type:

    numpy.ndarray of shape (4, 4)

mat4Frustum(left, right, bottom, top, near, far)

  Creates a frustum projection matrix.

  See glFrustum.

mat4Perspective(fovy, width, height, near, far)

  Creates a perspective projection matrix.

  Similar to gluPerspective.

  Parameters:

    - fovy (float) – Field of view angle in degrees in the y direction.

    - width (float) – Width of the viewport.

    - height (float) – Height of the viewport.

    - near (float) – Distance to the near plane (strictly positive).

    - far (float) – Distance to the far plane (strictly positive).

  Returns:

    Corresponding matrix.

  Return type:

    numpy.ndarray of shape (4, 4)

mat4Orthographic(left, right, bottom, top, near, far)

  Creates an orthographic (i.e., parallel) projection matrix.

  See glOrtho.

mat4Translate(tx, ty, tz)

  4x4 translation matrix.

mat4Scale(sx, sy, sz)

  4x4 scale matrix.

mat4RotateFromAngleAxis(angle, x=0.0, y=0.0, z=1.0)

  4x4 rotation matrix from angle and axis.

  Parameters:

    - angle (float) – The rotation angle in radians.

    - x (float) – The rotation vector x coordinate.

    - y (float) – The rotation vector y coordinate.

    - z (float) – The rotation vector z coordinate.

mat4RotateFromQuaternion(quaternion)

  4x4 rotation matrix from quaternion.

  Parameters:

    quaternion – Array-like unit quaternion stored as (x, y, z, w)

mat4Shear(axis, sx=0.0, sy=0.0, sz=0.0)

  4x4 shear matrix: Skew two axes relative to a third fixed one.

  shearFactor = tan(shearAngle)

  Parameters:

    - axis (str) – The axis to keep constant and shear against. In ‘x’, ‘y’, ‘z’.

    - sx (float) – The shear factor for the X axis relative to axis.

    - sy (float) – The shear factor for the Y axis relative to axis.

    - sz (float) – The shear factor for the Z axis relative to axis.

class Transform(static=False)
  inverse()

    Return the Transform of the inverse.

    The returned Transform is static, it is not updated when this Transform is modified.

    Returns:

      A Transform which is the inverse of this Transform.

  getMatrix(copy=True)

    The 4x4 matrix of this transform.

    Parameters:

      copy (bool) – True (the default) to get a copy of the matrix, False to get the internal matrix, do not modify!

    Returns:

      4x4 matrix of this transform.

  property matrix

    The 4x4 matrix of this transform.

  getInverseMatrix(copy=False)

    The 4x4 matrix of the inverse of this transform.

    Parameters:

      copy (bool) – True (the default) to get a copy of the matrix, False to get the internal matrix, do not modify!

    Returns:

      4x4 matrix of the inverse of this transform.

  property inverseMatrix

    The 4x4 matrix of the inverse of this transform.

  transformPoints(points, direct=True, perspectiveDivide=False)

    Apply the transform to an array of points.

    Parameters:

      - points – 2D array of N vectors of 3 or 4 coordinates

      - direct (bool) – Whether to apply the direct (True, the default) or inverse (False) transform.

      - perspectiveDivide (bool) – Whether to apply the perspective divide (True) or not (False, the default).

    Returns:

      The transformed points.

    Return type:

      numpy.ndarray of same shape as points.

  transformPoint(point, direct=True, perspectiveDivide=False)

    Apply the transform to a point.

    Parameters:

      - point – Array-like vector of 3 or 4 coordinates.

      - direct (bool) – Whether to apply the direct (True, the default) or inverse (False) transform.

      - perspectiveDivide (bool) – Whether to apply the perspective divide (True) or not (False, the default).

    Returns:

      The transformed point.

    Return type:

      numpy.ndarray of same length as point.

  transformDir(direction, direct=True)

    Apply the transform to a direction.

    Parameters:

      - direction – Array-like vector of 3 coordinates.

      - direct (bool) – Whether to apply the direct (True, the default) or inverse (False) transform.

    Returns:

      The transformed direction.

    Return type:

      numpy.ndarray of length 3.

  transformNormal(normal, direct=True)

    Apply the transform to a normal: R = (M-1)t * V.

    Parameters:

      - normal – Array-like vector of 3 coordinates.

      - direct (bool) – Whether to apply the direct (True, the default) or inverse (False) transform.

    Returns:

      The transformed normal.

    Return type:

      numpy.ndarray of length 3.

  transformBounds(bounds, direct=True)

    Apply the transform to an axes-aligned rectangular box.

    Parameters:

      - bounds (2x3 numpy.ndarray) – Min and max coords of the box for each axes.

      - direct (bool) – Whether to apply the direct (True, the default) or inverse (False) transform.

    Returns:

      Axes-aligned rectangular box including the transformed box.

    Return type:

      2x3 numpy.ndarray of float32

class Inverse(transform)

  Transform which is the inverse of another one.

  Static: It never gets updated.

class TransformList(iterable=())

  List of transforms.

class StaticTransformList(iterable=())

  Transform that is a snapshot of a list of Transforms

  It does not keep reference to the list of Transforms.

  Parameters:

    iterable – Iterable of Transform used for initialization

class Matrix(matrix=None)
  setMatrix(matrix=None)

    Update the 4x4 Matrix.

    Parameters:

      matrix – 4x4 array-like matrix or None for identity matrix.

  property matrix

    The 4x4 matrix of this transform.

class Translate(tx=0.0, ty=0.0, tz=0.0)

  4x4 translation matrix.

class Scale(sx=1.0, sy=1.0, sz=1.0)

  4x4 scale matrix.

class Rotate(angle=0.0, ax=0.0, ay=0.0, az=1.0)
  property angle

    The rotation angle in degrees.

  property axis

    The normalized rotation axis as a numpy.ndarray.

  setAngleAxis(angle=None, axis=None)

    Update the angle and/or axis of the rotation.

    Parameters:

      - angle (float) – The rotation angle in degrees.

      - axis – Array-like axis vector (3 coordinates).

  property quaternion

    Rotation unit quaternion as (x, y, z, w).

    Where: ||(x, y, z)|| = sin(angle/2), w = cos(angle/2).

class Shear(axis, sx=0.0, sy=0.0, sz=0.0)
  property axis

    The axis against which other axes are skewed.

  property factors

    The shear factors: shearFactor = tan(shearAngle)

class Orthographic(left=0.0, right=1.0, bottom=1.0, top=0.0, near=-1.0, far=1.0, size=(1.0, 1.0), keepaspect=True)

  Orthographic (i.e., parallel) projection which can keep aspect ratio.

  Clipping planes are adjusted to match the aspect ratio of the `size` attribute if `keepaspect` is True.

  In this case, the left, right, bottom and top parameters defines the area which must always remain visible. Effective clipping planes are adjusted to keep the aspect ratio.

  Parameters:

    - left (float) – Coord of the left clipping plane.

    - right (float) – Coord of the right clipping plane.

    - bottom (float) – Coord of the bottom clipping plane.

    - top (float) – Coord of the top clipping plane.

    - near (float) – Distance to the near plane.

    - far (float) – Distance to the far plane.

    - size (2-tuple of float) – Viewport’s size used to compute the aspect ratio (width, height).

    - keepaspect (bool) – True (default) to keep aspect ratio, False otherwise.

  setClipping(left=None, right=None, bottom=None, top=None)

    Set the clipping planes of the projection.

    Parameters are adjusted to keep aspect ratio. If a clipping plane coord is not provided, it uses its current value

    Parameters:

      - left (float) – Coord of the left clipping plane.

      - right (float) – Coord of the right clipping plane.

      - bottom (float) – Coord of the bottom clipping plane.

      - top (float) – Coord of the top clipping plane.

  property left

    Coord of the left clipping plane.

  property right

    Coord of the right clipping plane.

  property bottom

    Coord of the bottom clipping plane.

  property top

    Coord of the top clipping plane.

  property size

    Viewport size as a 2-tuple of float (width, height)

  property keepaspect

    True to keep aspect ratio, False otherwise.

class Ortho2DWidget(near=-1.0, far=1.0, size=(1.0, 1.0))

  Orthographic projection with pixel as unit.

  Provides same coordinates as widgets: origin: top left, X axis goes left, Y axis goes down.

  Parameters:

    - near (float) – Z coordinate of the near clipping plane.

    - far (float) – Z coordinante of the far clipping plane.

    - size (2-tuple of float) – Viewport’s size used to compute the aspect ratio (width, height).

class Perspective(fovy=90.0, near=0.1, far=1.0, size=(1.0, 1.0))

  Perspective projection matrix defined by FOV and aspect ratio.

  Parameters:

    - fovy (float) – Vertical field-of-view in degrees.

    - near (float) – The near clipping plane Z coord (stricly positive).

    - far (float) – The far clipping plane Z coord (> near).

    - size (2-tuple of float) – Viewport’s size used to compute the aspect ratio (width, height).

  property fovy

    Vertical field-of-view in degrees.

## `utils`: Miscellaneous

This module provides functions to generate indices, to check intersection and to handle planes.

triangleToLineIndices(triangleIndices, unicity=False)

  Generates lines indices from triangle indices.

  This is generating lines indices for the edges of the triangles.

  Parameters:

    - triangleIndices (numpy.ndarray) – The indices to draw a set of vertices as triangles.

    - unicity (bool) – If True remove duplicated lines, else (the default) returns all lines.

  Returns:

    The indices to draw the edges of the triangles as lines.

  Return type:

    1D numpy.ndarray of uint16 or uint32.

verticesNormalsToLines(vertices, normals, scale=1.0)

  Return vertices of lines representing normals at given positions.

  Parameters:

    - vertices (numpy.ndarray with shape: (nbPoints, 3)) – Positions of the points.

    - normals (numpy.ndarray with shape: (nbPoints, 3)) – Corresponding normals at the points.

    - scale (float) – The scale factor to apply to normals.

  Returns:

    Array of vertices to draw corresponding lines.

  Return type:

    numpy.ndarray with shape: (nbPoints * 2, 3)

unindexArrays(mode, indices, *arrays)

  Convert indexed GL primitives to unindexed ones.

  Given indices in arrays and the OpenGL primitive they represent, return the unindexed equivalent.

  Parameters:

    - mode (str) – Kind of primitive represented by indices. In: points, lines, line_strip, loop, triangles, triangle_strip, fan.

    - indices (numpy.ndarray of dimension 1.) – Indices in other arrays

    - arrays – Remaining arguments are arrays to convert

  Returns:

    Converted arrays

  Return type:

    tuple of numpy.ndarray

triangleStripToTriangles(strip)

  Convert a triangle strip to a set of triangles.

  The order of the corners is inverted for odd triangles.

  Parameters:

    strip (numpy.ndarray) – Array of triangle corners of shape (N, 3). N must be at least 3.

  Returns:

    Equivalent triangles corner as an array of shape (N, 3, 3)

  Return type:

    numpy.ndarray

trianglesNormal(positions)

  Return normal for each triangle.

  Parameters:

    positions (numpy.ndarray of shape (NbTriangles*3, 3)) – Serie of triangle’s corners

  Returns:

    Normals corresponding to each position.

  Return type:

    numpy.ndarray of shape (NbTriangles, 3)

gridVertices(dim0Array, dim1Array, dtype)

  Generate an array of 2D positions from 2 arrays of 1D coordinates.

  Parameters:

    - dim0Array – 1D array-like of coordinates along the first dimension.

    - dim1Array – 1D array-like of coordinates along the second dimension.

    - dtype (numpy.dtype) – Data type of the output array.

  Returns:

    Array of grid coordinates.

  Return type:

    numpy.ndarray with shape: (len(dim0Array), len(dim1Array), 2)

triangleStripGridIndices(dim0, dim1)

  Generate indices to draw a grid of vertices as a triangle strip.

  Vertices are expected to be stored as row-major (i.e., C contiguous).

  Parameters:

    - dim0 (int) – The number of rows of vertices.

    - dim1 (int) – The number of columns of vertices.

  Returns:

    The vertex indices

  Return type:

    1D numpy.ndarray of uint32

linesGridIndices(dim0, dim1)

  Generate indices to draw a grid of vertices as lines.

  Vertices are expected to be stored as row-major (i.e., C contiguous).

  Parameters:

    - dim0 (int) – The number of rows of vertices.

    - dim1 (int) – The number of columns of vertices.

  Returns:

    The vertex indices.

  Return type:

    1D numpy.ndarray of uint32

angleBetweenVectors(refVector, vectors, norm=None)

  Return the angle between 2 vectors.

  Parameters:

    - refVector (numpy.ndarray of shape: (NCoords,)) – Coordinates of the reference vector.

    - vectors (numpy.ndarray of shape: (NCoords,) or (NbVector, NCoords)) – Coordinates of the vector(s) to get angle from reference.

    - norm – A direction vector giving an orientation to the angles or None.

  Returns:

    The angles in radians in [0, pi] if norm is None else in [0, 2pi].

  Return type:

    float or numpy.ndarray of shape (NbVectors,)

segmentPlaneIntersect(s0, s1, planeNorm, planePt)

  Compute the intersection of a segment with a plane.

  Parameters:

    - s0 (1D numpy.ndarray-like of length 3) – First end of the segment

    - s1 (1D numpy.ndarray-like of length 3) – Second end of the segment

    - planeNorm (numpy.ndarray of shape: (3,)) – Normal vector of the plane.

    - planePt (numpy.ndarray of shape: (3,)) – A point of the plane.

  Returns:

    The intersection points. The number of points goes from 0 (no intersection) to 2 (segment in the plane)

  Return type:

    list of numpy.ndarray

boxPlaneIntersect(boxVertices, boxLineIndices, planeNorm, planePt)

  Return intersection points between a box and a plane.

  Parameters:

    - boxVertices (numpy.ndarray with shape: (8, 3)) – Position of the corners of the box.

    - boxLineIndices (numpy.ndarray-like with shape: (12, 2)) – Indices of the box edges.

    - planeNorm (numpy.ndarray of shape: (3,)) – Normal vector of the plane.

    - planePt (numpy.ndarray of shape: (3,)) – A point of the plane.

  Returns:

    The found intersection points

  Return type:

    numpy.ndarray with 2 dimensions

clipSegmentToBounds(segment, bounds)

  Clip segment to volume aligned with axes.

  Parameters:

    - segment (numpy.ndarray) – (p0, p1)

    - bounds (numpy.ndarray) – (lower corner, upper corner)

  Returns:

    Either clipped (p0, p1) or None if outside volume

  Return type:

    Union[None,List[numpy.ndarray]]

segmentVolumeIntersect(segment, nbins)

  Get bin indices intersecting with segment

  It should work with N dimensions. Coordinate convention (z, y, x) or (x, y, z) should not matter as long as segment and nbins are consistent.

  Parameters:

    - segment (numpy.ndarray) – Segment end points as a 2xN array of coordinates

    - nbins (numpy.ndarray) – Shape of the volume with same coordinates order as segment

  Returns:

    List of bins indices as a 2D array or None if no bins

  Return type:

    Union[None,numpy.ndarray]

class Plane(point=(0.0, 0.0, 0.0), normal=(0.0, 0.0, 1.0))

  Object handling a plane and notifying plane changes.

  Parameters:

    - point (3-tuple of float.) – A point on the plane.

    - normal (3-tuple of float.) – Normal of the plane.

  setPlane(point=None, normal=None)

    Set plane point and normal and notify.

    Parameters:

      - point (3-tuple of float or None.) – A point on the plane.

      - normal (3-tuple of float or None.) – Normal of the plane.

  property point

    A point on the plane.

  property normal

    The (normalized) normal of the plane.

  property parameters

    Plane equation parameters: a*x + b*y + c*z + d = 0.

  property isPlane

    True if a plane is defined (i.e., ||normal|| != 0).

  move(step)

    Move the plane of step along the normal.

  segmentIntersection(s0, s1)

    Compute the plane intersection with segment [s0, s1].

    Parameters:

      - s0 (1D numpy.ndarray-like of length 3) – First end of the segment

      - s1 (1D numpy.ndarray-like of length 3) – Second end of the segment

    Returns:

      The intersection points. The number of points goes from 0 (no intersection) to 2 (segment in the plane)

    Return type:

      list of 1D numpy.ndarray

## `viewport`: Root of a scene tree

This module provides a class to control a viewport on the rendering window.

The `Viewport` describes a Viewport rendering a scene. The attribute `scene` is the root group of the scene tree. `RenderContext` handles the current state during rendering.

class RenderContext(viewport, glContext)

  Handle a current rendering context.

  An instance of this class is passed to rendering method through the scene during render.

  User should NEVER use an instance of this class beyond the method it is passed to as an argument (i.e., do not keep a reference to it).

  Parameters:

    - viewport (Viewport) – The viewport doing the rendering.

    - glContext (Context) – The operating system OpenGL context in use.

  cache(key, factory, *args, **kwargs)

    Lazy-loading cache to store values in the context for rendering

    Parameters:

      - key – The key to retrieve

      - factory – A callback taking args and kwargs as arguments and returning the value to store.

    Returns:

      The stored or newly allocated value

  property viewport

    Viewport doing the current rendering

  property glCtx

    The OpenGL context in use

  property objectToCamera

    The current transform from object to camera coords.

    Do not modify.

  property projection

    Projection transform.

    Do not modify.

  property objectToNDC

    The transform from object to NDC (this includes projection).

    Do not modify.

  pushTransform(transform_, multiply=True)

    Push a `Transform` on the transform stack.

    Parameters:

      - transform (Transform) – The transform to add to the stack.

      - multiply (bool) – True (the default) to multiply with the top of the stack, False to push the transform as is without multiplication.

  popTransform()

    Pop the transform on top of the stack.

    Returns:

      The Transform that is popped from the stack.

  property clipper

    The current clipping plane (ClippingPlane)

  setClipPlane(point=(0.0, 0.0, 0.0), normal=(0.0, 0.0, 0.0))

    Set the clipping plane to use

    For now only handles a single clipping plane.

    Parameters:

      - point (3-tuple of float) – A point of the plane

      - normal (3-tuple of float) – Normal vector of the plane or (0, 0, 0) for no clipping

  setupProgram(program)

    Sets-up uniforms of a program using the context shader functions.

    Parameters:

      program (GLProgram) – The program to set-up. It MUST be in use and using the context function.

  property fragDecl

    Fragment shader declaration for scene shader functions

  property fragCallPre

    Fragment shader call for scene shader functions (to do first)

    It takes the camera position (vec4) as argument.

  property fragCallPost

    Fragment shader call for scene shader functions (to do last)

    It takes the camera position (vec4) as argument.

class Viewport(framebuffer=0)

  Rendering a single scene through a camera in part of a framebuffer.

  Parameters:

    framebuffer (int) – The framebuffer ID this viewport is rendering into

  property transforms

    Proxy of camera transforms.

    Do not modify the list.

  property dirty

    True if scene is dirty and needs redisplay.

  resetDirty()

    Mark the scene as not being dirty.

    To call after rendering.

  property background

    Viewport’s background color (4-tuple of float in [0, 1] or None)

    The background color is used to clear to viewport. If None, the viewport is not cleared

  property camera

    The camera used to render the scene.

  property light

    The light used to render the scene.

  property fog

    The fog function used to render the scene

  property origin

    Origin (ox, oy) of the viewport in pixels

  property size

    Size (width, height) of the viewport in pixels

  property shape

    Shape (height, width) of the viewport in pixels.

    This is a convenient wrapper to the inverse of size.

  property framebuffer

    The framebuffer ID this viewport is rendering into (int)

  render(glContext)

    Perform the rendering of the viewport

    Parameters:

      glContext (Context) – The context used for rendering

  adjustCameraDepthExtent()

    Update camera depth extent to fit the scene bounds.

    Only near and far planes are updated. The scene might still not be fully visible (e.g., if spanning behind the viewpoint with perspective projection).

  resetCamera()

    Change camera to have the whole scene in the viewing frustum.

    It updates the camera position and depth extent. Camera sight direction and up are not affected.

  orbitCamera(direction, angle=1.0)

    Rotate the camera around center of the scene.

    Parameters:

      - direction (str) – Direction of movement relative to image plane. In: ‘up’, ‘down’, ‘left’, ‘right’.

      - angle (float) – he angle in degrees of the rotation.

  moveCamera(direction, step=0.1)

    Move the camera relative to the image plane.

    Parameters:

      - direction (str) – Direction relative to image plane. One of: ‘up’, ‘down’, ‘left’, ‘right’, ‘forward’, ‘backward’.

      - step (float) – The ratio of data to step for each pan.

  windowToNdc(winX, winY, checkInside=True)

    Convert position from window to normalized device coordinates.

    If window coordinates are int, they are moved half a pixel to be positioned at the center of pixel.

    Parameters:

      - winX – X window coord, origin left.

      - winY – Y window coord, origin top.

      - checkInside (bool) – If True, returns None if position is outside viewport.

    Returns:

      (x, y) Normalize device coordinates in [-1, 1] or None. Origin center, x to the right, y goes upward.

  ndcToWindow(ndcX, ndcY, checkInside=True)

    Convert position from normalized device coordinates (NDC) to window.

    Parameters:

      - ndcX (float) – X NDC coord.

      - ndcY (float) – Y NDC coord.

      - checkInside (bool) – If True, returns None if position is outside viewport.

    Returns:

      (x, y) window coordinates or None. Origin top-left, x to the right, y goes downward.

## `window`: On-screen window

This module provides a class for Viewports rendering on the screen.

The `Window` renders a list of Viewports in the current framebuffer. The rendering can be performed in an off-screen framebuffer that is only updated when the scene has changed and not each time Qt is requiring a repaint.

The `Context` and `ContextGL2` represent the operating system OpenGL context and handle OpenGL resources.

class Context(glContextHandle)

  Correspond to an operating system OpenGL context.

  User should NEVER use an instance of this class beyond the method it is passed to as an argument (i.e., do not keep a reference to it).

  Parameters:

    glContextHandle – System specific OpenGL context handle.

  property isCurrent

    Whether this OpenGL context is the current one or not.

  setCurrent(isCurrent=True)

    Set the state of the OpenGL context to reflect OpenGL state.

    This should not be called from the scene graph, only in the wrapper that handle the OpenGL context to reflect its state.

    Parameters:

      isCurrent (bool) – The state of the system OpenGL context.

  property dotsPerInch: float

    Number of physical dots per inch on the screen

  property devicePixelRatio

    Ratio between device and device independent pixels (float)

    This is useful for font rendering.

  property glContext

    The handle to the OpenGL context provided by the system.

  cleanGLGarbage()

    This is releasing OpenGL resource that are no longer used.

class ContextGL2(glContextHandle)

  Handle a system GL2 context.

  User should NEVER use an instance of this class beyond the method it is passed to as an argument (i.e., do not keep a reference to it).

  Parameters:

    glContextHandle – System specific OpenGL context handle.

  prog(vertexShaderSrc, fragmentShaderSrc, attrib0='position')

    Cache program within context.

    WARNING: No clean-up.

    Parameters:

      - vertexShaderSrc (str) – Vertex shader source code

      - fragmentShaderSrc (str) – Fragment shader source code

      - attrib0 (str) – Attribute’s name to bind to position 0 (default: ‘position’). On some platform, this attribute MUST be active and with an array attached to it in order for the rendering to occur….

  makeVbo(data=None, sizeInBytes=None, usage=None, target=None)

    Create a VBO in this context with the data.

    Current limitations:

    - One array per VBO

    - Do not support sharing VertexBuffer across VboAttrib

    Automatically discards the VBO when the returned `VertexBuffer` istance is deleted.

    Parameters:

      - data (numpy.ndarray) – 2D array of data to store in VBO or None.

      - sizeInBytes (int) – Size of the VBO or None. It should be <= data.nbytes if both are given.

      - usage – OpenGL usage define in VertexBuffer._USAGES.

      - target – OpenGL target in VertexBuffer._TARGETS.

    Returns:

      The VertexBuffer created in this context.

  makeVboAttrib(data, usage=None, target=None)

    Create a VBO from data and returns the associated VBOAttrib.

    Automatically discards the VBO when the returned `VBOAttrib` istance is deleted.

    Parameters:

      - data (numpy.ndarray) – 2D array of data to store in VBO or None.

      - usage – OpenGL usage define in VertexBuffer._USAGES.

      - target – OpenGL target in VertexBuffer._TARGETS.

    Returns:

      A VBOAttrib instance created in this context.

  cleanGLGarbage()

    Delete OpenGL resources that are pending for destruction.

    This requires the associated OpenGL context to be active. This is meant to be called before rendering.

class Window(mode='framebuffer')

  OpenGL Framebuffer where to render viewports

  Parameters:

    mode (str) –

    Rendering mode to use:

    - ’direct’ to render everything for each render call

    - ’framebuffer’ to cache viewport rendering in a texture and update the texture only when needed.

  property dirty

    True if this object or any attached viewports is dirty.

  property size

    Size (width, height) of the window in pixels

  property shape

    Shape (height, width) of the window in pixels.

    This is a convenient wrapper to the reverse of size.

  property viewports

    List of viewports to render in the corresponding framebuffer

  property framebufferid

    Framebuffer ID used to perform rendering

  grab(glcontext)

    Returns the raster of the scene as an RGB numpy array

    Returns:

      OpenGL scene RGB bitmap as an array of dimension (height, width, 3)

    Return type:

      numpy.ndarray of uint8

  render(glcontext, dotsPerInch, devicePixelRatio)

    Perform the rendering of attached viewports

    Parameters:

      - glcontext – System identifier of the OpenGL context

      - dotsPerInch (`float`) – Screen physical resolution in pixels per inch

      - devicePixelRatio (`float`) – Ratio between device and device-independent pixels