# vispy.scene.node module

class vispy.scene.node.Node(parent=None, name=None, transforms=None)

  Bases: `object`

  Base class representing an object in a scene.

  A group of nodes connected through parent-child relationships define a scenegraph. Nodes may have any number of children.

  Each Node defines a `transform` property, which describes the position, orientation, scale, etc. of the Node relative to its parent. The Node’s children inherit this property, and then further apply their own transformations on top of that.

  With the `transform` property, each Node implicitly defines a “local” coordinate system, and the Nodes and edges in the scenegraph can be thought of as coordinate systems connected by transformation functions.

  Parameters:
    parent Node

      The parent of the Node.

    name str

      The name used to identify the node.

    transforms instance of TransformSystem | None

      The associated transforms.

  property canvas

    The canvas in which this node’s scenegraph is being drawn.

  property children

    A copy of the list of children of this node. Do not add items to this list, but use `x.parent = y` instead.

  property clip_children

    Boolean indicating whether children of this node will inherit its clipper.

  property clipper

    A visual filter that can be used to clip visuals to the boundaries of this node.

  common_parent(node)

    Return the common parent of two entities

    If the entities have no common parent, return None.

    Parameters:
      node instance of Node

        The other node.

    Returns:
      parent instance of Node | None

        The parent.

  describe_tree(with_transform=False)

    Create tree diagram of children

    Parameters:
      with_transform bool

        If true, add information about node transform types.

    Returns:
      tree str

        The tree diagram.

  property document

    The document is an optional property that is an node representing the coordinate system from which this node should make physical measurements such as px, mm, pt, in, etc. This coordinate system should be used when determining line widths, font sizes, and any other lengths specified in physical units.

    The default is None; in this case, a default document is used during drawing (usually this is supplied by the SceneCanvas).

  property document_node

    The node to be used as the document coordinate system.

    By default, the document node is self.root_node.

  is_child(node)

    Check if a node is a child of the current node

    Parameters:
      node instance of Node

        The potential child.

    Returns:
      child bool

        Whether or not the node is a child.

  property name
  node_path(node)

    Return two lists describing the path from this node to another

    Parameters:
      node instance of Node

        The other node.

    Returns:
      p1 list

        First path (see below).

      p2 list

        Second path (see below).

    Notes

    The first list starts with this node and ends with the common parent between the endpoint nodes. The second list contains the remainder of the path from the common parent to the specified ending node.

    For example, consider the following scenegraph:

        A --- B --- C --- D
                                   --- E --- F

    Calling D.node_path(F) will return:

        ([D, C, B], [E, F])

  node_path_to_child(node)

    Return a list describing the path from this node to a child node

    If node is not a (grand)child of this node, then raise RuntimeError.

    Parameters:
      node instance of Node

        The child node.

    Returns:
      path list | None

        The path.

  node_path_transforms(node)

    Return the list of transforms along the path to another node.

    The transforms are listed in reverse order, such that the last transform should be applied first when mapping from this node to the other.

    Parameters:
      node instance of Node

        The other node.

    Returns:
      transforms list

        A list of Transform instances.

  node_transform(node)

    Return the transform that maps from the coordinate system of self to the local coordinate system of node.

    Note that there must be a _single_ path in the scenegraph that connects the two entities; otherwise an exception will be raised.

    Parameters:
      node instance of Node

        The other node.

    Returns:
      transform instance of ChainTransform

        The transform.

  on_parent_change(event)

    Parent change event handler

    Parameters:
      event instance of Event

        The event.

  property opacity
  property order

    A value used to determine the order in which nodes are drawn.

    Greater values are drawn later. Children are always drawn after their parent.

  property parent

    The parent of this node in the scenegraph.

    Nodes inherit coordinate transformations and some filters (opacity and clipping by default) from their parents. Setting this property assigns a new parent, changing the topology of the scenegraph.

    May be set to None to remove this node (and its children) from a scenegraph.

  parent_chain()

    Return the list of parents starting from this node. The chain ends at the first node with no parents.

  property picking

    Boolean that determines whether this node (and its children) are drawn in picking mode.

  property root_node
  property scene_node

    The first ancestor of this node that is a SubScene instance, or self if no such node exists.

  set_picking(*, picking=True)

    Context manager to temporarily set picking for this node and its children.

    Note that this function will not alter the picking mode unless/until the context manager is entered (using the with statement). Use `picking` for setting the picking mode directly.

  set_transform(type_, *args, **kwargs)

    Create a new transform of type and assign it to this node.

    All extra arguments are used in the construction of the transform.

    Parameters:
      type_str

        The transform type.

      *args tuple

        Arguments.

      **kwargs dict

        Keywoard arguments.

  property transform

    The transform that maps the local coordinate frame to the coordinate frame of the parent.

  update()

    Emit an event to inform listeners that properties of this Node have changed. Also request a canvas update.

  property visible

    Whether this node should be drawn or not. Only applicable to nodes that can be drawn.

previous

vispy.scene.events module

next

vispy.scene.subscene module