Permit filtering identifiers for UpdateStatesFromObjects

- Extend the vtkObjectManager with a new method that allows one to replicate behavior of `UpdateStatesFromObjects` only for a given list of identifiers.

Author: jspanchu

Documentation/release/dev/add-filtered-update-states-from-objects.md

@@ -0,0 +1,5 @@
+## Add method that allows updating states of specific objects.
+
+You can now call the `void UpdateStatesFromObjects(const std::vector<vtkTypeUInt32>& identifiers)` method on the `vtkObjectManager`
+to only update states of objects corresponding to the vector of identifiers. This method allows you to efficiently update a specific
+object and it's dependencies without touching other unrelated objects.

Serialization/Manager/Testing/Python/TestFilteredUpdateStatesFromObjects.py

@@ -0,0 +1,62 @@
+from vtkmodules.test import Testing as vtkTesting
+
+class TestFilteredUpdateStatesFromObjects(vtkTesting.vtkTest):
+    def test(self):
+        from vtkmodules.vtkSerializationManager import vtkObjectManager
+        from vtkmodules.vtkRenderingCore import vtkRenderWindow, vtkRenderer, vtkRenderWindowInteractor, vtkPolyDataMapper, vtkActor
+        from vtkmodules.vtkFiltersSources import vtkSphereSource, vtkConeSource
+        # from vtkmodules.vtkCommonCore import vtkLogger
+        import json
+
+        sphereActor = vtkActor(mapper = (vtkSphereSource() >> vtkPolyDataMapper()).last)
+        coneActor = vtkActor(mapper = (vtkConeSource() >> vtkPolyDataMapper()).last)
+
+        sphereRenderWindow = vtkRenderWindow()
+        sphereRenderer = vtkRenderer()
+        sphereRenderWindow.AddRenderer(sphereRenderer)
+        sphereRenderer.AddActor(sphereActor)
+
+        coneRenderWindow = vtkRenderWindow()
+        coneRenderer = vtkRenderer()
+        coneRenderWindow.AddRenderer(coneRenderer)
+        coneRenderer.AddActor(coneActor)
+
+        sphereInteractor = vtkRenderWindowInteractor(render_window = sphereRenderWindow)
+        coneInteractor = vtkRenderWindowInteractor(render_window = coneRenderWindow)
+
+        sphereInteractor.Render()
+        coneInteractor.Render()
+
+        manager = vtkObjectManager()
+        manager.Initialize()
+
+        # manager.SetObjectManagerLogVerbosity(vtkLogger.VERBOSITY_WARNING)
+        # manager.serializer.SetSerializerLogVerbosity(vtkLogger.VERBOSITY_WARNING)
+
+        sphereRenderWindowId = manager.RegisterObject(sphereRenderWindow)
+        coneRenderWindowId = manager.RegisterObject(coneRenderWindow)
+
+        manager.UpdateStatesFromObjects()
+
+        # Keep track of the property IDs for verification later
+        spherePropertyId = manager.GetId(sphereActor.property)
+        conePropertyId = manager.GetId(coneActor.property)
+
+        sphereActor.property.opacity = 0.5  # Change sphere opacity to see if it gets updated correctly
+        manager.UpdateStatesFromObjects([sphereRenderWindowId])
+        self.assertIn("vtk-object-manager-kept-alive", json.loads(manager.GetState(sphereRenderWindowId)), "vtk-object-manager-kept-alive key not found in sphere render window state")
+        # verify that the sphere opacity change is reflected in the state
+        self.assertEqual(json.loads(manager.GetState(spherePropertyId))['Opacity'], 0.5)
+        sphereActor.property.opacity = 1.0  # Change sphere opacity back to original value
+
+        coneActor.property.opacity = 0.3  # Change cone opacity to see if it gets updated correctly
+        manager.UpdateStatesFromObjects([coneRenderWindowId])
+        self.assertIn("vtk-object-manager-kept-alive", json.loads(manager.GetState(coneRenderWindowId)), "vtk-object-manager-kept-alive key not found in cone render window state")
+        # verify that the cone opacity change is reflected in the state
+        self.assertEqual(json.loads(manager.GetState(conePropertyId))['Opacity'], 0.3)
+
+        # Since we only updated the cone render window, the sphere's opacity should not have changed
+        self.assertEqual(json.loads(manager.GetState(spherePropertyId))['Opacity'], 0.5)
+
+if __name__ == "__main__":
+    vtkTesting.main([(TestFilteredUpdateStatesFromObjects, 'test')])

Serialization/Manager/vtkObjectManager.cxx

@@ -566,6 +566,76 @@ void vtkObjectManager::UpdateStatesFromObjects()
   this->PruneUnusedObjects();
 }
 
+//------------------------------------------------------------------------------
+void vtkObjectManager::UpdateStatesFromObjects(const std::vector<vtkTypeUInt32>& identifiers)
+{
+  // get objects with strong references held by the manager.
+  const auto managerOwnershipKey = this->OWNERSHIP_KEY();
+  const auto managerStrongObjectsIter = this->Context->StrongObjects().find(managerOwnershipKey);
+  // get objects with strong references held by the deserializer.
+  const auto deserializerOwnershipKey = this->Deserializer->GetObjectDescription();
+  const auto deserStrongObjectsIter = this->Context->StrongObjects().find(deserializerOwnershipKey);
+  // get objects with strong references held by the invoker.
+  const auto invokerOwnershipKey = this->Invoker->GetObjectDescription();
+  const auto invokerStrongObjectsIter = this->Context->StrongObjects().find(invokerOwnershipKey);
+
+  // for each identifier, serialize the object and mark it as kept alive where necessary.
+  for (const auto& identifier : identifiers)
+  {
+    const auto dependencies = this->GetAllDependencies(identifier);
+    for (const auto& depId : dependencies)
+    {
+      // Reset dependency cache as it will be rebuilt.
+      this->Context->ResetDirectDependenciesForNode(depId);
+    }
+    // The concered strong objects go under the top level root node
+    vtkMarshalContext::ScopedParentTracker rootNodeTracker(this->Context, vtkObjectManager::ROOT());
+    if (managerStrongObjectsIter != this->Context->StrongObjects().end())
+    {
+      for (const auto& object : managerStrongObjectsIter->second)
+      {
+        // The object must have already been registered in the context and have a valid identifier.
+        if (this->Context->GetId(object) == identifier)
+        {
+          const auto stateId = this->Serializer->SerializeJSON(object);
+          if (const auto idIter = stateId.find("Id"); idIter != stateId.end())
+          {
+            if (idIter->is_number_unsigned() && idIter->get<vtkTypeUInt32>() == identifier)
+            {
+              auto& state = this->Context->GetState(idIter->get<vtkTypeUInt32>());
+              state["vtk-object-manager-kept-alive"] = true;
+            }
+          }
+        }
+      }
+    }
+    if (deserStrongObjectsIter != this->Context->StrongObjects().end())
+    {
+      for (const auto& object : deserStrongObjectsIter->second)
+      {
+        if (this->Context->GetId(object) == identifier)
+        {
+          this->Serializer->SerializeJSON(object);
+        }
+      }
+    }
+    if (invokerStrongObjectsIter != this->Context->StrongObjects().end())
+    {
+      for (const auto& object : invokerStrongObjectsIter->second)
+      {
+        if (this->Context->GetId(object) == identifier)
+        {
+          this->Serializer->SerializeJSON(object);
+        }
+      }
+    }
+  }
+  // Remove unused states
+  this->PruneUnusedStates();
+  // Remove unused objects
+  this->PruneUnusedObjects();
+}
+
 //------------------------------------------------------------------------------
 void vtkObjectManager::UpdateObjectFromState(const std::string& state)
 {

Serialization/Manager/vtkObjectManager.h

@@ -145,10 +145,21 @@ class VTKSERIALIZATIONMANAGER_EXPORT vtkObjectManager : public vtkObject
   void UpdateObjectsFromStates();
 
   /**
-   * Serialize registered objects into vtk states.
+   * Serialize registered objects into states.
    */
   void UpdateStatesFromObjects();
 
+  /**
+   * This method is similar to `void UpdateStatesFromObjects()`. The only difference is that this
+   * method is far more efficient when updating a specific object and it's dependencies. The
+   * identifiers must be valid and correspond to registered objects.
+   *
+   * @warning This method prunes all unused states and objects after serialization. Ensure that
+   * `void UpdateStatesFromObjects()` is called atleast once before this method if you want to
+   * preserve objects that were registered but not specified in `identifiers`.
+   */
+  void UpdateStatesFromObjects(const std::vector<vtkTypeUInt32>& identifiers);
+
   ///@{
   /**
    * Deserialize the state into vtk object.
@@ -192,7 +203,7 @@ class VTKSERIALIZATIONMANAGER_EXPORT vtkObjectManager : public vtkObject
   void Import(const std::string& stateFileName, const std::string& blobFileName);
 
   /**
-   * Removes all objects that are neither referenced by this manager or any other object.
+   * Removes all states whose corresponding objects no longer exist.
    */
   void PruneUnusedStates();