fix(api): update listeners structure

Author: jourdain

examples/vtk/widgets_plane.py

@@ -32,10 +32,6 @@
 
 def create_vtk_pipeline(file_to_load):
     colors = vtkNamedColors()
-    sphere_source = vtkSphereSource()
-    sphere_source.SetRadius(10.0)
-    sphere_source.Update()
-    input_bounds = sphere_source.GetOutput().GetBounds()
 
     fp = None
     if file_to_load:
@@ -46,59 +42,49 @@ def create_vtk_pipeline(file_to_load):
             return
 
     # Setup a visualization pipeline.
-    plane = vtkPlane()
-    clipper = vtkClipPolyData()
-    clipper.SetClipFunction(plane)
-    clipper.InsideOutOn()
-    if file_to_load:
-        reader = vtkXMLPolyDataReader()
-        reader.SetFileName(fp)
-        reader.Update()
+    source = (
+        vtkXMLPolyDataReader(file_name=fp)
+        if file_to_load
+        else vtkSphereSource(radius=10.0)
+    )
+    source.Update()
+
+    input_bounds = source.output.bounds
+    plane = vtkPlane(
+        origin=(
+            0.5 * (input_bounds[0] + input_bounds[1]),
+            0.5 * (input_bounds[2] + input_bounds[3]),
+            0.5 * (input_bounds[4] + input_bounds[5]),
+        )
+    )
 
-        input_bounds = reader.GetOutput().GetBounds()
-        clipper.SetInputConnection(reader.GetOutputPort())
-    else:
-        clipper.SetInputConnection(sphere_source.GetOutputPort())
+    clipper = vtkClipPolyData(
+        clip_function=plane, inside_out=1, input_connection=source.output_port
+    )
 
     # Create a mapper and actor.
-    mapper = vtkPolyDataMapper()
-    mapper.SetInputConnection(clipper.GetOutputPort())
-    actor = vtkActor()
-    actor.SetMapper(mapper)
-
-    back_faces = vtkProperty()
-    back_faces.SetDiffuseColor(colors.GetColor3d("Gold"))
-
-    actor.SetBackfaceProperty(back_faces)
+    mapper = vtkPolyDataMapper(input_connection=clipper.output_port)
+    back_faces = vtkProperty(diffuse_color=colors.GetColor3d("Gold"))
+    actor = vtkActor(mapper=mapper, backface_property=back_faces)
 
     # A renderer and render window
-    renderer = vtkRenderer()
+    renderer = vtkRenderer(background=colors.GetColor3d("SlateGray"))
+    renderer.AddActor(actor)
     ren_win = vtkRenderWindow()
     ren_win.AddRenderer(renderer)
-    ren_win.SetWindowName("ImplicitPlaneWidget2")
-
-    renderer.AddActor(actor)
-    renderer.SetBackground(colors.GetColor3d("SlateGray"))
 
     # An interactor
-    iren = vtkRenderWindowInteractor()
+    iren = vtkRenderWindowInteractor(render_window=ren_win)
     iren.GetInteractorStyle().SetCurrentStyleToTrackballCamera()
-    iren.SetRenderWindow(ren_win)
 
-    rep = vtkImplicitPlaneRepresentation()
-    rep.SetPlaceFactor(1.25)  # This must be set prior to placing the widget
-    rep.PlaceWidget(input_bounds)
-    plane.SetOrigin(
-        0.5 * (input_bounds[0] + input_bounds[1]),
-        0.5 * (input_bounds[2] + input_bounds[3]),
-        0.5 * (input_bounds[4] + input_bounds[5]),
+    rep = vtkImplicitPlaneRepresentation(
+        place_factor=1.25,
     )
-    rep.SetNormal(plane.GetNormal())
-    rep.SetOrigin(plane.GetOrigin())
+    rep.PlaceWidget(input_bounds)
+    rep.normal = plane.normal
+    rep.origin = plane.origin
 
-    plane_widget = vtkImplicitPlaneWidget2()
-    plane_widget.SetInteractor(iren)
-    plane_widget.SetRepresentation(rep)
+    plane_widget = vtkImplicitPlaneWidget2(interactor=iren, representation=rep)
 
     renderer.ResetCamera(input_bounds)
     ren_win.Render()
@@ -142,8 +128,8 @@ def _on_widget_update(self, plane_widget, **_):
             return
 
         # update cutting plane
-        self.plane.SetNormal(plane_widget.get("normal"))
-        self.plane.SetOrigin(plane_widget.get("origin"))
+        self.plane.normal = plane_widget.get("normal")
+        self.plane.origin = plane_widget.get("origin")
 
         # prevent requesting geometry too often
         self.html_view.render_throttle()
@@ -152,30 +138,31 @@ def toggle_listeners(self):
         if self.state.wasm_listeners is not None and len(self.state.wasm_listeners):
             self.state.wasm_listeners = {}
         else:
-            widget_id = self.html_view.get_wasm_id(self.widget)
-            rep_id = self.html_view.get_wasm_id(self.widget.representation)
             self.state.wasm_listeners = {
-                widget_id: {
+                self.widget_id: {
                     "InteractionEvent": {
                         "plane_widget": {
-                            rep_id: {
-                                "Normal": "normal",
-                                "Origin": "origin",
-                            }
+                            "normal": (
+                                self.widget_id,
+                                "WidgetRepresentation",
+                                "Normal",
+                            ),
+                            "origin": (
+                                self.widget_id,
+                                "WidgetRepresentation",
+                                "Origin",
+                            ),
                         }
                     }
                 }
             }
 
     def one_time_update(self):
-        rep_id = self.html_view.get_wasm_id(self.widget.representation)
         self.html_view.eval(
             {
                 "plane_widget": {
-                    rep_id: {
-                        "Normal": "normal",
-                        "Origin": "origin",
-                    }
+                    "origin": (self.widget_id, "WidgetRepresentation", "Origin"),
+                    "normal": (self.widget_id, "WidgetRepresentation", "Normal"),
                 }
             }
         )
@@ -201,7 +188,7 @@ def _ui(self):
                     throttle_rate=20,
                     listeners=("wasm_listeners", {}),
                 )
-                self.html_view.register_widget(self.widget)
+                self.widget_id = self.html_view.register_widget(self.widget)
 
         return layout
 

trame_vtklocal/widgets/vtklocal.py

@@ -45,6 +45,34 @@ def get_version():
 
 
 class LocalView(HtmlElement):
+    """
+    LocalView allow to mirror a server side vtkRenderWindow on the client side using VTK.wasm.
+
+    Parameters
+
+    :param render_window: Specify the VTK window to mirror
+    :type vtkRenderWindow:
+    :param throttle_rate: Number of update per second the render_throttle() method will actually perform.
+    :type number:
+
+    Properties
+
+    :param cache_size: Size of client side cache for geometry and arrays in Bytes.
+    :type number:
+    :param eager_sync: If enabled, the server will push states rather than waiting for the client to request them. Usually improve fast update behavior.
+    :type bool:
+    :param listeners: Dynamic structure describing what to observe and how to map internal WASM state to trame state variable.
+    :type dict:
+
+    Events
+
+    :param updated: Emitted after each completed client side update.
+    :param memory_vtk: Event which provides the current memory used by vtk object structures.
+    :param memory_arrays: Event which provides the current memory used by vtk arrays.
+    :param camera: Event emitted when any camera is changed. The actual state of the camera is passed as arg.
+
+    """
+
     _next_id = 0
 
     def __init__(self, render_window, throttle_rate=10, **kwargs):
@@ -75,9 +103,9 @@ def __init__(self, render_window, throttle_rate=10, **kwargs):
         ]
         self._event_names += [
             "updated",
+            "camera",
             ("memory_vtk", "memory-vtk"),
             ("memory_arrays", "memory-arrays"),
-            ("camera", "camera"),
         ]
 
         # Generate throttle update function
@@ -99,14 +127,9 @@ def eval(self, state_mapping):
 
         state_mapping = {
             trame_state_name: {
-                wasm_id1: {
-                    wasm_state_prop_name: js_name_in_trame_state_name_obj1
-                    wasm_state_prop_name2: js_name2_in_trame_state_name_obj1
-                },
-                wasm_id2: {
-                    wasm_state_prop_name: js_name_in_trame_state_name_obj2
-                    wasm_state_prop_name2: js_name2_in_trame_state_name_obj2
-                },
+                prop_name1: (wasm_id, "PropName"),
+                origin: (wasm_id, "WidgetRepresentation", "origin"),
+                widget_state: widget_id,
             }
         }
         """
@@ -118,12 +141,14 @@ def update(self, push_camera=False):
         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"""
+        """Register external element (i.e. widget) into the scene so it can be managed and return its wasm_id"""
         if w not in self.__registered_obj:
             self.api.register_widget(self._render_window, w)
             self.__registered_obj.append(w)
             self.api.update()
 
+        return self.get_wasm_id(w)
+
     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:

vue-components/src/components/VtkLocal.js

@@ -15,20 +15,41 @@ function idToState(sceneManager, cid) {
   return sceneManager.getState(wasmId);
 }
 
+function createStateHelper(sceneManager) {
+  const cache = {};
+
+  return function getState(wasm_id) {
+    if (!cache[wasm_id]) {
+      cache[wasm_id] = idToState(sceneManager, wasm_id);
+    }
+    return cache[wasm_id];
+  };
+}
+
+function getStatePathToValue(getStateFn, statePath) {
+  const expression = Array.isArray(statePath) ? statePath : [statePath];
+  let value = null;
+  for (let i = 0; i < expression.length; i++) {
+    const token = expression[i];
+    if (i === 0) {
+      value = getStateFn(token);
+    } else {
+      value = value[token];
+      if (value.Id) {
+        value = getStateFn(value.Id);
+      }
+    }
+  }
+  return value;
+}
+
 function createExtractCallback(trame, sceneManager, extractInfo) {
   return function () {
-    for (const [name, objIds] of Object.entries(extractInfo)) {
+    const getState = createStateHelper(sceneManager);
+    for (const [name, props] 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];
-          }
-        }
+      for (const [propName, statePath] of Object.entries(props)) {
+        value[propName] = getStatePathToValue(getState, statePath);
       }
       trame.state.set(name, value);
     }
@@ -369,7 +390,6 @@ export default {
     // Public -----------------------------------------------------------------
 
     function evalStateExtract(definition) {
-      console.log("definition", definition);
       createExtractCallback(trame, sceneManager, definition)();
     }