serialize only the camera

Author: LKasianAnsys

src/ansys/visor/viewer/renderer/local_renderer.py

@@ -318,25 +318,25 @@ def serialize_camera_state(self) -> None:
         """See :meth:`IRenderer.serialize_camera_state`.
 
         ``vtklocal`` advertises each object's modification time off the live
-        VTK object but serves state out of a serialization cache that only
-        ``UpdateStatesFromObjects`` refreshes.  Writing the pipeline camera
-        without this call publishes a new version number against the old
-        content, and the client fetches the pre-write camera and applies it
-        over the one just installed.
-
-        The render window's id is passed, not the camera's own.  It is the
-        form the framework itself reproduces -- ``LocalView.update`` resolves
-        ``[self._render_window, *registered]`` to ids and hands those to
-        ``UpdateStatesFromObjects`` -- and the camera sits inside the render
-        window's dependency closure, which is why ``get_status`` can name the
-        camera's id at all when building ``ignore_ids``.
-
-        No ``js_call``: that lives in ``LocalView.update``, not in the object
-        manager, so this serialises without pushing and without re-opening
-        the rebuild race ``_apply_runtime_state_to_render`` refuses.
+        VTK object but serves state out of a serialization cache, so a write
+        to the pipeline camera without this call publishes a new
+        version number against the old content: the client fetches the
+        pre-write camera and applies it over the one just installed.
+
+        ``UpdateStateFromObject`` resets the camera's dependency edges
+        and re-serializes it, and does nothing else.  It is not
+        interchangeable with ``UpdateStatesFromObjects``, which prunes
+        the whole store whichever ids are passed.  The interactor,
+        picker and widget objects are named in no other object's state
+        and survive a prune only by being re-serialized as roots in the
+        same pass, which nothing else on the load path does.
+
+        No ``js_call``: that lives in ``LocalView.update``, so this
+        serialises without re-opening the rebuild race
+        ``_apply_runtime_state_to_render`` refuses.
         """
-        self._object_manager.UpdateStatesFromObjects(
-            [self._object_manager.GetId(self._render_window)]
+        self._object_manager.UpdateStateFromObject(
+            self._object_manager.GetId(self._vtk_renderer.GetActiveCamera())
         )
 
     # ------------------------------------------------------------------

tests/unit/renderer/test_local_renderer.py

@@ -185,18 +185,17 @@ def SetParallelScale(self, value): # noqa: N802
 # ---------------------------------------------------------------------------
 # Object-manager id literals
 #
-# Hand-written, and distinctive on purpose.  The id source in the fixture is
-# keyed on object *identity*: the render window resolves to the first literal
-# and every other object to the second.  A test that asserts the first literal
-# therefore fails if production names the renderer, the interactor, the picker
-# or the active camera, instead of coinciding with whatever it named.
-#
-# Both are far outside the small-integer range a real object manager hands out
-# in a freshly initialised scene, so a literal arriving from anywhere other
-# than here is visible on sight.
+# Hand-written, and distinctive on purpose.  The id source is keyed on object
+# *identity*: the active camera resolves to its own literal, the render window
+# to a second, and every other object to the third. A test that asserts
+# ACTIVE_CAMERA_WASM_ID therefore fails if production names the render window,
+# the renderer, the interactor or the picker, instead of coinciding with
+# whatever it named. The render window keeps a literal of its own so that a
+# revert to the previous call shape fails by name rather than as the catch-all.
 # ---------------------------------------------------------------------------
 
 RENDER_WINDOW_WASM_ID = 8150001
+ACTIVE_CAMERA_WASM_ID = 8150002
 WRONG_OBJECT_WASM_ID = 8150999
 
 
@@ -738,32 +737,37 @@ def test_sync_camera_stores_the_object_without_copying(self, renderer):
 
         assert renderer.get_camera_state() is cam
 
-    def test_serialize_camera_state_updates_states_from_the_render_window_id(
+    def test_serialize_camera_state_updates_the_states_from_the_active_camera_id(
         self, renderer
     ):
-        """The re-serialise names the render window, and nothing else.
+        """The re-serialise names the active camera, and nothing else.
 
         The id source is keyed on object identity, so every object other than
-        the render window resolves to a different, equally distinctive
-        literal.  Asserting ``RENDER_WINDOW_WASM_ID`` therefore fails if the
-        implementation names ``_vtk_renderer``, the interactor, or the active
-        camera, rather than coinciding with them.  Asserting against
-        ``GetId(renderer._render_window)`` -- the attribute production reads
-        -- would pass in all of those cases and pin nothing.
-
-        The expected value is the list production passes, not a repacking of
-        it: ``UpdateStatesFromObjects`` takes a sequence of ids.
+        the active camera resolves to a different, equally distinctive
+        literal.  Asserting ``ACTIVE_CAMERA_WASM_ID`` therefore fails if the
+        implementation names ``_render_window``, ``_vtk_renderer``, the
+        interactor or the picker, rather than coinciding with them.  The
+        render window has a literal of its own, so the previous call shape
+        fails by name.  Asserting against
+        ``GetId(renderer._vtk_renderer.GetActiveCamera())`` -- the expression
+        production reads -- would pass in all of those cases and pin nothing.
+
+        The expected value is the bare id production passes:
+        ``UpdateStateFromObject`` takes a single id, not a sequence.
         """
+        camera = renderer._vtk_renderer.GetActiveCamera()
         renderer._object_manager.GetId.side_effect = (
-            lambda obj: RENDER_WINDOW_WASM_ID
+            lambda obj: ACTIVE_CAMERA_WASM_ID
+            if obj is camera
+            else RENDER_WINDOW_WASM_ID
             if obj is renderer._render_window
             else WRONG_OBJECT_WASM_ID
         )
 
         renderer.serialize_camera_state()
 
-        renderer._object_manager.UpdateStatesFromObjects.assert_called_with(
-            [RENDER_WINDOW_WASM_ID]
+        renderer._object_manager.UpdateStateFromObject.assert_called_with(
+            ACTIVE_CAMERA_WASM_ID
         )
 
     def test_serialize_camera_state_does_not_notify_the_client(self, renderer):

tests/unit/vtk/scene/test_base.py

@@ -42,6 +42,7 @@
 from ansys.visor.viewer.vtk.scene.base import VisorSceneBase
 from ansys.visor.viewer.vtk.variables.visor_part_variables import VisorPartVariables
 from ansys.visor.viewer.vtk.variables.visor_variables import VisorVariable
+from tests.unit.renderer.test_local_renderer import ACTIVE_CAMERA_WASM_ID
 
 NODE_ID = 7
 SECOND_NODE_ID = 8
@@ -158,15 +159,18 @@ def array_dataset() -> vtkPolyData:
 # Object-manager id literals
 #
 # Hand-written and distinctive.  Seeded into the renderer fixture's id source
-# keyed on object identity, so that asserting RENDER_WINDOW_WASM_ID fails --
-# rather than coincides -- if the re-serialisation names the renderer, the
-# interactor, the picker or the active camera instead of the render window.
+# keyed on object identity, so that asserting ACTIVE_CAMERA_WASM_ID fails --
+# rather than coincides -- if the re-serialization names the render window,
+# the renderer, the interactor or the picker instead of the active camera.
+# The render window keeps a literal of its own so that a revert to the
+# previous call shape fails by name rather than as the catch-all.
 #
 # Asserting against the id source's own answer for the attribute production
 # reads would pin nothing: it would pass whichever object production named.
 # ---------------------------------------------------------------------------
 
 RENDER_WINDOW_WASM_ID = 8150001
+ACTIVE_CAMERA_WASM_ID = 8150002
 WRONG_OBJECT_WASM_ID = 8150999
 
 
@@ -180,9 +184,10 @@ def renderer():
 
     The object manager that arrives with the patched LocalView is a MagicMock,
     so its ``GetId`` is seeded here rather than in a test: keyed on object
-    identity, the render window resolves to RENDER_WINDOW_WASM_ID and every
-    other object to WRONG_OBJECT_WASM_ID.  That is what lets the ordering test
-    below assert which object the re-serialisation named.
+    identity, the active camera resolves to ACTIVE_CAMERA_WASM_ID, the render
+    window to RENDER_WINDOW_WASM_ID and every other object to
+    WRONG_OBJECT_WASM_ID.  This is what lets the ordering test below assert
+    which object the re-serialization named.
     """
     mock_server = MagicMock()
     mock_server.state = {}
@@ -204,8 +209,11 @@ def renderer():
     ):
         r = VisorLocalRenderer(mock_server)
 
+    camera = r._vtk_renderer.GetActiveCamera.return_value
     r._object_manager.GetId.side_effect = (
-        lambda obj: RENDER_WINDOW_WASM_ID
+        lambda obj: ACTIVE_CAMERA_WASM_ID
+        if obj is camera
+        else RENDER_WINDOW_WASM_ID
         if obj is r._render_window
         else WRONG_OBJECT_WASM_ID
     )
@@ -1131,10 +1139,10 @@ def test_apply_state_syncs_the_camera_under_the_lock_before_the_render_step(scen
     server correct; it does not make the state the client is served correct,
     and the two are separate steps that can each silently do nothing.  The
     spy appends the literal string ``"camera"`` for the write, the two-tuple
-    ``("serialize", <ids>)`` for the re-serialisation -- the tuple is the
+    ``("serialize", <id>)`` for the re-serialisation -- the tuple is the
     recording format, not the argument -- and ``"bridge"`` for the delegated
-    render step.  ``<ids>`` is asserted as the list production passes, since
-    ``UpdateStatesFromObjects`` takes a sequence.
+    render step.  ``<id>`` is asserted as the bare id production passes, since
+    ``UpdateStateFromObject`` takes a single id.
 
     Ordered between the two: after the write, because re-serialising before
     it would publish the pre-load camera; before the render step, because the
@@ -1152,16 +1160,16 @@ def _sync(camera_state):
         return real_sync(camera_state)
 
     scene._renderer.sync_camera = _sync
-    scene._renderer._object_manager.UpdateStatesFromObjects = (
-        lambda ids: order.append(("serialize", ids))
+    scene._renderer._object_manager.UpdateStateFromObject = (
+        lambda object_id: order.append(("serialize", object_id))
     )
     scene._apply_runtime_state_to_render = lambda state: order.append("bridge")
 
     scene.apply_state(_persisted_state(_persisted_camera()))
 
     assert order == [
         "camera",
-        ("serialize", [RENDER_WINDOW_WASM_ID]),
+        ("serialize", ACTIVE_CAMERA_WASM_ID),
         "bridge",
     ]
     assert observed["depth"] >= 1
@@ -1184,8 +1192,8 @@ def test_apply_state_serializes_the_camera_under_the_lock(scene):
     scene._vtk_lock = _LockSpy()
     observed = {}
 
-    scene._renderer._object_manager.UpdateStatesFromObjects = (
-        lambda ids: observed.update(depth=scene._vtk_lock.depth)
+    scene._renderer._object_manager.UpdateStateFromObject = (
+        lambda object_id: observed.update(depth=scene._vtk_lock.depth)
     )
 
     scene.apply_state(_persisted_state(_persisted_camera()))
@@ -1202,15 +1210,15 @@ def test_apply_state_serializes_the_camera_under_the_lock(scene):
 # then ``self._renderer.serialize_camera_state()``, both inside
 # ``_vtk_lock``.  Same shape as the ``sync_camera`` trigger section above: the
 # re-serialisation runs after the reset, is spied on
-# ``_object_manager.UpdateStatesFromObjects`` with the render-window id, and
+# ``_object_manager.UpdateStateFromObject`` with the active-camera id, and
 # the lock is held (depth >= 1) at both points.
 #
 # Own literals are unnecessary here -- reset_camera takes no camera argument,
 # only the scene-graph bounds -- so what is pinned is order and lock depth,
 # not a value.
 # ===========================================================================
 
-def test_reset_camera_serializes_after_the_reset_with_the_render_window_id(scene):
+def test_reset_camera_serializes_after_the_reset_with_the_active_camera_id(scene):
     """The re-serialisation follows the reset, and carries production's id.
 
     Reverted -- the reset kept and the re-serialisation dropped -- the
@@ -1219,9 +1227,9 @@ def test_reset_camera_serializes_after_the_reset_with_the_render_window_id(scene
     fetch.
 
     The spy appends ``"reset"`` for the reset call and the two-tuple
-    ``("serialize", <ids>)`` for the re-serialisation; the tuple is the
-    recording format, not the argument.  ``<ids>`` is asserted as the list
-    production passes, since ``UpdateStatesFromObjects`` takes a sequence.
+    ``("serialize", <id>)`` for the re-serialisation; the tuple is the
+    recording format, not the argument.  ``<id>`` is asserted as the bare id
+    production passes, since ``UpdateStateFromObject`` takes a single id.
     """
     order = []
     real_reset = scene._renderer.reset_camera
@@ -1231,13 +1239,13 @@ def _reset(bounds):
         return real_reset(bounds)
 
     scene._renderer.reset_camera = _reset
-    scene._renderer._object_manager.UpdateStatesFromObjects = (
-        lambda ids: order.append(("serialize", ids))
+    scene._renderer._object_manager.UpdateStateFromObject = (
+        lambda object_id: order.append(("serialize", object_id))
     )
 
     scene.reset_camera()
 
-    assert order == ["reset", ("serialize", [RENDER_WINDOW_WASM_ID])]
+    assert order == ["reset", ("serialize", ACTIVE_CAMERA_WASM_ID)]
 
 
 def test_reset_camera_holds_the_lock_across_both_halves(scene):
@@ -1261,8 +1269,8 @@ def _reset(bounds):
         return real_reset(bounds)
 
     scene._renderer.reset_camera = _reset
-    scene._renderer._object_manager.UpdateStatesFromObjects = (
-        lambda ids: observed.update(serialize_depth=scene._vtk_lock.depth)
+    scene._renderer._object_manager.UpdateStateFromObject = (
+        lambda object_id: observed.update(serialize_depth=scene._vtk_lock.depth)
     )
 
     scene.reset_camera()