use "data store" for Scene

Author: Licini

src/compas/scene/scene.py

@@ -1,6 +1,7 @@
 import compas.data  # noqa: F401
 import compas.datastructures  # noqa: F401
 import compas.geometry  # noqa: F401
+from compas.datastructures import Datastructure
 from compas.datastructures import Tree
 from compas.datastructures import TreeNode
 
@@ -13,7 +14,7 @@
 from .sceneobject import SceneObjectFactory
 
 
-class Scene(Tree):
+class Scene(Datastructure):
     """A scene is a container for hierarchical scene objects which are to be visualised in a given context.
 
     Parameters
@@ -44,49 +45,42 @@ class Scene(Tree):
     @property
     def __data__(self):
         # type: () -> dict
-        items = {str(object.item.guid): object.item for object in self.objects if object.item is not None}
         return {
             "name": self.name,
-            "root": self.root.__data__,  # type: ignore
-            "items": list(items.values()),
+            "items": list(self.items.values()),
+            "objects": list(self.objects.values()),
+            "tree": self.tree,
         }
 
-    @classmethod
-    def __from_data__(cls, data):
-        # type: (dict) -> Scene
-        scene = cls(data["name"])
-        items = {str(item.guid): item for item in data["items"]}
-
-        def add(node, parent, items):
-            for child_node in node.get("children", []):
-                settings = child_node["settings"]
-                if "item" in child_node:
-                    guid = child_node["item"]
-                    sceneobject = parent.add(items[guid], **settings)
-                else:
-                    sceneobject = parent.add(Group(**settings))
-                add(child_node, sceneobject, items)
-
-        add(data["root"], scene, items)
-
-        return scene
-
     def __init__(self, name="Scene", context=None):
         # type: (str, str | None) -> None
         super(Scene, self).__init__(name=name)
-        super(Scene, self).add(TreeNode(name="ROOT"))
+
+        # TODO: deal with context
         self.context = context or detect_current_context()
 
-    @property
-    def objects(self):
-        # type: () -> list[SceneObject]
-        return [node for node in self.nodes if not node.is_root]  # type: ignore
+        self.tree = Tree()
+        self.tree.add(TreeNode(name="ROOT"))
+        self.items = {}
+        self.objects = {}
+
+    def __repr__(self):
+        # type: () -> str
+
+        def node_repr(node):
+            if node.name == "ROOT":
+                return self.name
+
+            sceneobject = self.objects[node.name]
+            return str(sceneobject)
+
+        return self.tree.get_hierarchy_string(node_repr=node_repr)
 
     @property
     def context_objects(self):
         # type: () -> list
         guids = []
-        for obj in self.objects:
+        for obj in self.objects.values():
             guids += obj.guids
         return guids
 
@@ -109,20 +103,22 @@ def add(self, item, parent=None, **kwargs):
             The scene object associated with the item.
         """
 
-        parent = parent or self.root
+        # Create a corresponding new scene object
+        sceneobject = SceneObjectFactory.create(item=item, context=self.context, scene=self, **kwargs)
 
-        if isinstance(item, SceneObject):
-            sceneobject = item
+        # Add the scene object and item to the data store
+        self.objects[str(sceneobject.guid)] = sceneobject
+        self.items[str(item.guid)] = item
+
+        # Add the scene object to the hierarchical tree
+        if parent is None:
+            parent_node = self.tree.root
         else:
-            if "context" in kwargs:
-                if kwargs["context"] != self.context:
-                    raise Exception("Object context should be the same as scene context: {} != {}".format(kwargs["context"], self.context))
-                del kwargs["context"]  # otherwist the SceneObject receives "context" twice, which results in an error
-            
-            # Use the factory to create the scene object
-            sceneobject = SceneObjectFactory.create(item=item, context=self.context, **kwargs)
-            
-        super(Scene, self).add(sceneobject, parent=parent)
+            print(parent.guid)
+            parent_node = self.tree.get_node_by_name(parent.guid)
+
+        self.tree.add(TreeNode(name=str(sceneobject.guid)), parent=parent_node)
+
         return sceneobject
 
     def clear_context(self, guids=None):

src/compas/scene/sceneobject.py

@@ -24,27 +24,27 @@
 
 class SceneObjectFactory:
     """Factory class for creating appropriate SceneObject instances based on input item type.
-    
+
     This factory encapsulates the logic for selecting the right SceneObject subclass
     for a given data item, making the creation process more explicit and easier to understand.
     """
-    
+
     @staticmethod
-    def create(item=None, **kwargs):
+    def create(item=None, scene=None, **kwargs):
         """Create appropriate SceneObject instance based on item type.
-        
+
         Parameters
         ----------
         item : :class:`compas.data.Data`
             The data item to create a scene object for.
         **kwargs : dict
             Additional keyword arguments to pass to the SceneObject constructor.
-            
+
         Returns
         -------
         :class:`compas.scene.SceneObject`
             A SceneObject instance of the appropriate subclass for the given item.
-            
+
         Raises
         ------
         ValueError
@@ -55,13 +55,16 @@ def create(item=None, **kwargs):
         if item is None:
             raise ValueError("Cannot create a scene object for None. Please ensure you pass an instance of a supported class.")
 
+        if scene is None:
+            raise ValueError("Cannot create a scene object without a scene.")
+
         sceneobject_cls = get_sceneobject_cls(item, **kwargs)
-        
+
         # Create and return an instance of the appropriate scene object class
-        return sceneobject_cls(item=item, **kwargs)
+        return sceneobject_cls(item=item, scene=scene, **kwargs)
 
 
-class SceneObject(TreeNode):
+class SceneObject(Data):
     """Base class for all scene objects.
 
     Parameters
@@ -130,9 +133,9 @@ def __init__(
         color=None,  # type: compas.colors.Color | None
         opacity=1.0,  # type: float
         show=True,  # type: bool
-        frame=None,  # type: compas.geometry.Frame | None
         transformation=None,  # type: compas.geometry.Transformation | None
         context=None,  # type: str | None
+        scene=None,  # type: compas.scene.Scene | None
         **kwargs  # type: dict
     ):  # fmt: skip
         # type: (...) -> None
@@ -145,7 +148,8 @@ def __init__(
         # because it has no access to the tree and/or the scene before it is added
         # which means that adding child objects will be added in context "None"
         self.context = context
-        self._item = item
+        self._scene = scene
+        self._item = item.guid
         self._guids = []
         self._node = None
         self._transformation = transformation
@@ -158,29 +162,32 @@ def __init__(
     def __data__(self):
         # type: () -> dict
         return {
-            "item": str(self.item.guid),
-            "settings": self.settings,
-            "children": [child.__data__ for child in self.children],
+            "item": str(self._item),
+            "name": self.name,
+            "color": self.color,
+            "opacity": self.opacity,
+            "show": self.show,
+            "transformation": self.transformation,
         }
 
-    @classmethod
-    def __from_data__(cls, data):
-        # type: (dict) -> None
-        raise TypeError("Serialisation outside Scene not allowed.")
-
     def __repr__(self):
         # type: () -> str
         return "<{}: {}>".format(self.__class__.__name__, self.name)
 
     @property
     def scene(self):
         # type: () -> compas.scene.Scene | None
-        return self.tree
+        return self._scene
 
     @property
     def item(self):
         # type: () -> compas.data.Data
-        return self._item
+        return self.scene.items[self._item]
+
+    @property
+    def node(self):
+        # type: () -> compas.datastructures.TreeNode
+        return self.scene.tree.get_object_node(self.guid)
 
     @property
     def guids(self):
@@ -234,58 +241,6 @@ def contrastcolor(self, color):
         # type: (compas.colors.Color) -> None
         self._contrastcolor = Color.coerce(color)
 
-    @property
-    def settings(self):
-        # type: () -> dict
-        settings = {
-            "name": self.name,
-            "color": self.color,
-            "opacity": self.opacity,
-            "show": self.show,
-        }
-
-        if self.frame:
-            settings["frame"] = self.frame
-        if self.transformation:
-            settings["transformation"] = self.transformation
-
-        return settings
-
-    def add(self, item, **kwargs):
-        # type: (compas.data.Data, dict) -> SceneObject
-        """Add a child item to the scene object.
-
-        Parameters
-        ----------
-        item : :class:`compas.data.Data`
-            The item to add.
-        **kwargs : dict
-            Additional keyword arguments to create the scene object for the item.
-
-        Returns
-        -------
-        :class:`compas.scene.SceneObject`
-            The scene object associated with the added item.
-
-        Raises
-        ------
-        ValueError
-            If the scene object does not have an associated scene node.
-        """
-        if isinstance(item, SceneObject):
-            sceneobject = item
-        else:
-            if "context" in kwargs:
-                if kwargs["context"] != self.context:
-                    raise Exception("Child context should be the same as parent context: {} != {}".format(kwargs["context"], self.context))
-                del kwargs["context"]  # otherwist the SceneObject receives "context" twice, which results in an error
-            
-            # Use the factory to create the scene object
-            sceneobject = SceneObjectFactory.create(item=item, context=self.context, **kwargs)
-
-        super(SceneObject, self).add(sceneobject)
-        return sceneobject
-
     def draw(self):
         """The main drawing method."""
         raise NotImplementedError