feat(listeners): initial support with static definition

Author: jourdain

examples/vtk/widgets_plane.py

@@ -3,15 +3,15 @@
 
 from trame.app import get_server
 from trame.ui.html import DivLayout
-from trame.widgets import html, client, vtk as vtk_widgets
+from trame.widgets import html, client
 from trame_vtklocal.widgets import vtklocal
+from trame.decorators import TrameApp, change
 
 # Required for vtk factory
 import vtkmodules.vtkRenderingOpenGL2  # noqa
 from vtkmodules.vtkInteractionStyle import vtkInteractorStyleSwitch  # noqa
 
 from vtkmodules.vtkCommonColor import vtkNamedColors
-from vtkmodules.vtkCommonCore import vtkCommand
 from vtkmodules.vtkCommonDataModel import vtkPlane
 from vtkmodules.vtkFiltersCore import vtkClipPolyData
 from vtkmodules.vtkFiltersSources import vtkSphereSource
@@ -29,8 +29,6 @@
     vtkRenderer,
 )
 
-WASM = True  # "USE_WASM" in os.environ
-
 
 def create_vtk_pipeline(file_to_load):
     colors = vtkNamedColors()
@@ -97,38 +95,25 @@ def create_vtk_pipeline(file_to_load):
     )
     rep.SetNormal(plane.GetNormal())
     rep.SetOrigin(plane.GetOrigin())
-    print(input_bounds)
 
     plane_widget = vtkImplicitPlaneWidget2()
     plane_widget.SetInteractor(iren)
     plane_widget.SetRepresentation(rep)
 
-    if not WASM:
-        my_callback = IPWCallback(plane)
-        plane_widget.AddObserver(vtkCommand.InteractionEvent, my_callback)
-
     renderer.ResetCamera(input_bounds)
     ren_win.Render()
 
     plane_widget.On()
 
-    return ren_win, plane_widget
-
-
-class IPWCallback:
-    def __init__(self, plane):
-        self.plane = plane
-
-    def __call__(self, caller, ev):
-        rep = caller.GetRepresentation()
-        rep.GetPlane(self.plane)
+    return ren_win, plane_widget, plane
 
 
 # -----------------------------------------------------------------------------
 # GUI
 # -----------------------------------------------------------------------------
 
 
+@TrameApp()
 class App:
     def __init__(self, server=None):
         self.server = get_server(server, client_type="vue3")
@@ -138,21 +123,59 @@ def __init__(self, server=None):
 
         self.server.cli.add_argument("--data")
         args, _ = self.server.cli.parse_known_args()
-        self.render_window, self.widget = create_vtk_pipeline(args.data)
+        self.render_window, self.widget, self.plane = create_vtk_pipeline(args.data)
+
         self.html_view = None
         self.ui = self._ui()
 
+    def register_widget_listeners(self):
+        self.html_view.register_widget(self.widget)
+
+        # extract wasm ids
+        widget_id = self.html_view.get_wasm_id(self.widget)
+        rep_id = self.html_view.get_wasm_id(self.widget.representation)
+
+        # init state vars and listener properties
+        self.server.state.plane_widget = None
+        self.html_view.listeners = (
+            "wasm_listeners",
+            {
+                widget_id: {
+                    "InteractionEvent": {
+                        "plane_widget": {
+                            rep_id: {
+                                "Normal": "normal",
+                                "Origin": "origin",
+                            }
+                        }
+                    }
+                }
+            },
+        )
+
+    @change("plane_widget")
+    def _on_widget_update(self, plane_widget, **_):
+        if plane_widget is None:
+            return
+
+        # update cutting plane
+        self.plane.SetNormal(plane_widget.get("normal"))
+        self.plane.SetOrigin(plane_widget.get("origin"))
+
+        # prevent requesting geometry too often
+        self.html_view.render_throttle()
+
     def _ui(self):
         with DivLayout(self.server) as layout:
             client.Style("body { margin: 0; }")
             with html.Div(
                 style="position: absolute; left: 0; top: 0; width: 100vw; height: 100vh;"
             ):
-                if WASM:
-                    self.html_view = vtklocal.LocalView(self.render_window)
-                    self.html_view.register_widget(self.widget)
-                else:
-                    self.html_view = vtk_widgets.VtkRemoteView(self.render_window)
+                self.html_view = vtklocal.LocalView(
+                    self.render_window,
+                    throttle_rate=20,
+                )
+                self.register_widget_listeners()
 
         return layout
 

trame_vtklocal/utils/__init__.py

@@ -0,0 +1,62 @@
+import asyncio
+
+
+class Throttle:
+    """
+    Helper class that wrap a function with a given max execution rate.
+    By default the rate is set to execute no more than once a second.
+
+    :param fn: the function to call.
+    :type fn: function
+
+    :param ts: Number of seconds to wait before the next execution.
+    :type ts: float
+    """
+
+    def __init__(self, fn, ts=1):
+        self._ts = ts
+        self._fn = fn
+        self._requests = 0
+        self._pending = False
+        self._last_args = []
+        self._last_kwargs = {}
+
+    @property
+    def rate(self):
+        """Number of maximum executions per second"""
+        return 1.0 / self._ts
+
+    @rate.setter
+    def rate(self, rate):
+        """Update the maximum number of executions per seconds"""
+        self._ts = 1.0 / rate
+
+    @property
+    def delta_t(self):
+        """Number of seconds to wait between execution"""
+        return self._ts
+
+    @delta_t.setter
+    def delta_t(self, seconds):
+        """Update the number of seconds to wait between execution"""
+        self._ts = seconds
+
+    async def _trottle(self):
+        self._pending = True
+        if self._requests:
+            self._fn(*self._last_args, **self._last_kwargs)
+            self._requests = 0
+
+        await asyncio.sleep(self._ts)
+        if self._requests > 0:
+            await self._trottle()
+        self._pending = False
+
+    def __call__(self, *args, **kwargs):
+        """Function call wrapper that will throttle the actual function provided at construction"""
+        self._requests += 1
+        self._last_args = args
+        self._last_kwargs = kwargs
+
+        if not self._pending:
+            asyncio.create_task(self._trottle())

trame_vtklocal/utils/throttle.py

@@ -4,7 +4,8 @@
 import base64
 from pathlib import Path
 from trame_client.widgets.core import AbstractElement
-from .. import module
+from trame_vtklocal import module
+from trame_vtklocal.utils.throttle import Throttle
 
 try:
     import zlib  # noqa
@@ -46,7 +47,7 @@ def get_version():
 class LocalView(HtmlElement):
     _next_id = 0
 
-    def __init__(self, render_window, **kwargs):
+    def __init__(self, render_window, throttle_rate=10, **kwargs):
         super().__init__(
             "vtk-local",
             **kwargs,
@@ -70,6 +71,7 @@ def __init__(self, render_window, **kwargs):
         self._attr_names += [
             ("cache_size", "cacheSize"),
             ("eager_sync", "eagerSync"),
+            "listeners",  # only processed at mount time for now
         ]
         self._event_names += [
             "updated",
@@ -78,25 +80,34 @@ def __init__(self, render_window, **kwargs):
             ("camera", "camera"),
         ]
 
+        # Generate throttle update function
+        self.render_throttle = Throttle(self.update)
+        self.render_throttle.rate = throttle_rate
+
     @property
     def api(self):
+        """Return API from helper"""
         return module.get_helper(self.server).api
 
     @property
     def object_manager(self):
+        """Return object_manager"""
         return self.api.vtk_object_manager
 
     def update(self, push_camera=False):
+        """Sync view by pushing updates to client"""
         self.api.update(push_camera=push_camera)
         self.server.js_call(self.__ref, "update")
 
     def register_widget(self, w):
+        """Register external element (i.e. widget) into the scene so it can be managed"""
         if w not in self.__registered_obj:
             self.api.register_widget(self._render_window, w)
             self.__registered_obj.append(w)
             self.api.update()
 
     def uregister_widgets(self):
+        """Unregister external element (i.e. widget) from the scene so it can removed from tracking"""
         for w in self.__registered_obj:
             self.api.unregister(self._render_window, w)
 
@@ -136,6 +147,7 @@ def export(self, format="zip", **kwargs):
             return zip_buffer.getvalue()
 
     def reset_camera(self, renderer_or_render_window=None, **kwargs):
+        """Reset camera by making the call on the client side"""
         if renderer_or_render_window is None:
             renderer_or_render_window = self._render_window
 
@@ -150,7 +162,9 @@ def reset_camera(self, renderer_or_render_window=None, **kwargs):
 
     @property
     def ref_name(self):
+        """Return the assigned name as a vue.js ref"""
         return self.__ref
 
     def get_wasm_id(self, vtk_object):
+        """Return vtkObject id used within WASM scene manager"""
         return self.object_manager.GetId(vtk_object)

trame_vtklocal/widgets/vtklocal.py

@@ -1,6 +1,31 @@
 import { inject, ref, unref, onMounted, onBeforeUnmount } from "vue";
 import { createModule } from "../utils";
 
+function idToState(sceneManager, cid) {
+  sceneManager.updateStateFromObject(cid);
+  return sceneManager.getState(cid);
+}
+
+function createExtractCallback(trame, sceneManager, extractInfo) {
+  return function () {
+    for (const [name, objIds] of Object.entries(extractInfo)) {
+      const value = {};
+      for (const [objId, props] of Object.entries(objIds)) {
+        const state = idToState(sceneManager, objId);
+        if (typeof props === "string") {
+          value[props] = state;
+        } else {
+          // extract and remap
+          for (const [k, v] of Object.entries(props)) {
+            value[v] = state[k];
+          }
+        }
+      }
+      trame.state.set(name, value);
+    }
+  };
+}
+
 export default {
   emits: ["updated", "memory-vtk", "memory-arrays", "camera"],
   props: {
@@ -18,6 +43,22 @@ export default {
     wsClient: {
       type: Object,
     },
+    listeners: {
+      type: Object,
+      // {
+      //    cid: {
+      //       ModifiedEvent: {
+      //          varName: {
+      //             objId: {
+      //                "PropName": "keyInJS_varName",
+      //                "PropName2": "key2InJS_varName",
+      //             },
+      //             objId: "keyInJS_fullState",
+      //          },
+      //       },
+      //    }
+      // }
+    },
   },
   setup(props, { emit }) {
     const trame = inject("trame");
@@ -265,6 +306,20 @@ export default {
         ]);
       }
 
+      // Other listeners
+      for (const [cid, eventMap] of Object.entries(props.listeners || {})) {
+        for (const [eventName, extractInfo] of Object.entries(eventMap || {})) {
+          observerTags.push([
+            cid,
+            sceneManager.addObserver(
+              cid,
+              eventName,
+              createExtractCallback(trame, sceneManager, extractInfo)
+            ),
+          ]);
+        }
+      }
+
       sceneManager.startEventLoop(props.renderWindow);
       if (resizeObserver) {
         resizeObserver.observe(unref(container));