class_docstr: A Canvas that automatically draws the contents of a scene
  
  Parameters
  ----------
  title : str
      The widget title
  size : (width, height)
      The size of the window.
  position : (x, y)
      The position of the window in screen coordinates.
  show : bool
      Whether to show the widget immediately. Default False.
  autoswap : bool
      Whether to swap the buffers automatically after a draw event.
      Default True. If True, the ``swap_buffers`` Canvas method will
      be called last (by default) by the ``canvas.draw`` event handler.
  app : Application | str
      Give vispy Application instance to use as a backend.
      (vispy.app is used by default.) If str, then an application
      using the chosen backend (e.g., 'pyglet') will be created.
      Note the canvas application can be accessed at ``canvas.app``.
  create_native : bool
      Whether to create the widget immediately. Default True.
  vsync : bool
      Enable vertical synchronization.
  resizable : bool
      Allow the window to be resized.
  decorate : bool
      Decorate the window. Default True.
  fullscreen : bool | int
      If False, windowed mode is used (default). If True, the default
      monitor is used. If int, the given monitor number is used.
  config : dict
      A dict with OpenGL configuration options, which is combined
      with the default configuration options and used to initialize
      the context. See ``canvas.context.config`` for possible
      options.
  shared : Canvas | GLContext | None
      An existing canvas or context to share OpenGL objects with.
  keys : str | dict | None
      Default key mapping to use. If 'interactive', escape and F11 will
      close the canvas and toggle full-screen mode, respectively.
      If dict, maps keys to functions. If dict values are strings,
      they are assumed to be ``Canvas`` methods, otherwise they should
      be callable.
  parent : widget-object
      The parent widget if this makes sense for the used backend.
  dpi : float | None
      Resolution in dots-per-inch to use for the canvas. If dpi is None,
      then the value will be determined by querying the global config first,
      and then the operating system.
  always_on_top : bool
      If True, try to create the window in always-on-top mode.
  px_scale : int > 0
      A scale factor to apply between logical and physical pixels in addition
      to the actual scale factor determined by the backend. This option
      allows the scale factor to be adjusted for testing.
  bgcolor : Color
      The background color to use.
  
  See also
  --------
  vispy.app.Canvas
  
  Notes
  -----
  Receives the following events:
  
      * initialize
      * resize
      * draw
      * mouse_press
      * mouse_release
      * mouse_double_click
      * mouse_move
      * mouse_wheel
      * key_press
      * key_release
      * stylus
      * touch
      * close
  
  The ordering of the mouse_double_click, mouse_press, and mouse_release
  events are not guaranteed to be consistent between backends. Only certain
  backends natively support double-clicking (currently Qt and WX); on other
  backends, they are detected manually with a fixed time delay.
  This can cause problems with accessibility, as increasing the OS detection
  time or using a dedicated double-click button will not be respected.
docstr: The SubScene object that represents the root node of the
  scene graph to be displayed.
docstr_tok: ["The","SubScene","object","that","represents","the","root","node","of","the","scene","graph","to","be","displayed","."]
code: def scene(self):
      """The SubScene object that represents the root node of the
      scene graph to be displayed.
      """
      return self._scene
  
imports: from __future__ import division
  import weakref
  import numpy
  from ..None import gloo
  from ..None import app
  from .visuals import VisualNode
  from ..visuals.transforms import TransformSystem
  from ..color import Color
  from ..util import logger, Frozen
  from ..util.profiler import Profiler
  from .subscene import SubScene
  from .events import SceneMouseEvent
  from .widgets import Widget
label_desc: Use image node_id 2 for calling the SceneCanvas obj's underlying member method code with example usage: obj.scene() and returns: self