finish the work, update tests

Author: Licini

src/compas/scene/group.py

@@ -27,16 +27,3 @@ class Group(SceneObject):
             └── <GeometryObject: Point>
 
     """
-
-    def __new__(cls, *args, **kwargs):
-        # overwriting __new__ to revert to the default behavior of normal object, So an instance can be created directly without providing a registered item.
-        return object.__new__(cls)
-
-    @property
-    def __data__(self):
-        # type: () -> dict
-        data = {
-            "settings": self.settings,
-            "children": [child.__data__ for child in self.children],
-        }
-        return data

src/compas/scene/scene.py

@@ -9,7 +9,6 @@
 from .context import before_draw
 from .context import clear
 from .context import detect_current_context
-from .group import Group
 from .sceneobject import SceneObject
 from .sceneobject import SceneObjectFactory
 
@@ -47,32 +46,33 @@ def __data__(self):
         # type: () -> dict
         return {
             "name": self.name,
-            "items": list(self.items.values()),
-            "objects": list(self.objects.values()),
+            "attributes": self.attributes,
+            "datastore": self.datastore,
+            "objects": self.objects,
             "tree": self.tree,
         }
 
-    def __init__(self, name="Scene", context=None):
-        # type: (str, str | None) -> None
-        super(Scene, self).__init__(name=name)
+    def __init__(self, context=None, datastore=None, objects=None, tree=None, **kwargs):
+        # type: (str | None, dict | None, dict | None, Tree | None, **kwargs) -> None
+        super(Scene, self).__init__(**kwargs)
 
-        # TODO: deal with context
         self.context = context or detect_current_context()
-
-        self.tree = Tree()
-        self.tree.add(TreeNode(name="ROOT"))
-        self.items = {}
-        self.objects = {}
+        self.datastore = datastore or {}
+        self.objects = objects or {}
+        self.tree = tree or Tree()
+        if self.tree.root is None:
+            self.tree.add(TreeNode(name=self.name))
 
     def __repr__(self):
         # type: () -> str
 
         def node_repr(node):
-            if node.name == "ROOT":
-                return self.name
-
-            sceneobject = self.objects[node.name]
-            return str(sceneobject)
+            # type: (TreeNode) -> str
+            if node.is_root:
+                return node.name
+            else:
+                sceneobject = self.objects[node.name]
+                return str(sceneobject)
 
         return self.tree.get_hierarchy_string(node_repr=node_repr)
 
@@ -108,19 +108,39 @@ def add(self, item, parent=None, **kwargs):
 
         # Add the scene object and item to the data store
         self.objects[str(sceneobject.guid)] = sceneobject
-        self.items[str(item.guid)] = item
+        self.datastore[str(item.guid)] = item
 
         # Add the scene object to the hierarchical tree
         if parent is None:
             parent_node = self.tree.root
         else:
-            print(parent.guid)
+            if not isinstance(parent, SceneObject):
+                raise ValueError("Parent is not a SceneObject.", parent)
             parent_node = self.tree.get_node_by_name(parent.guid)
+            if parent_node is None:
+                raise ValueError("Parent is not part of the scene.", parent)
 
         self.tree.add(TreeNode(name=str(sceneobject.guid)), parent=parent_node)
 
         return sceneobject
 
+    def remove(self, sceneobject):
+        """Remove a scene object along with all its descendants from the scene.
+
+        Parameters
+        ----------
+        sceneobject : :class:`compas.scene.SceneObject`
+            The scene object to remove.
+        """
+        # type: (SceneObject) -> None
+        guid = str(sceneobject.guid)
+        self.objects.pop(guid, None)
+        node = self.tree.get_node_by_name(guid)
+        if node:
+            for descendant in node.descendants:
+                self.objects.pop(descendant.name, None)
+            self.tree.remove(node)
+
     def clear_context(self, guids=None):
         # type: (list | None) -> None
         """Clear the visualisation context.
@@ -173,7 +193,7 @@ def clear(self, clear_scene=True, clear_context=True):
         """
         guids = []
 
-        for sceneobject in self.objects:
+        for sceneobject in list(self.objects.values()):
             guids += sceneobject.guids
             sceneobject._guids = None
 
@@ -233,7 +253,7 @@ def find_by_name(self, name):
         return self.get_node_by_name(name=name)
 
     def find_by_itemtype(self, itemtype):
-        # type: (...) -> SceneObject | None
+        # type: (type) -> SceneObject | None
         """Find the first scene object with a data item of the given type.
 
         Parameters
@@ -246,12 +266,12 @@ def find_by_itemtype(self, itemtype):
         :class:`SceneObject` or None
 
         """
-        for obj in self.objects:
+        for obj in self.objects.values():
             if isinstance(obj.item, itemtype):
                 return obj
 
     def find_all_by_itemtype(self, itemtype):
-        # type: (...) -> list[SceneObject]
+        # type: (type) -> list[SceneObject]
         """Find all scene objects with a data item of the given type.
 
         Parameters
@@ -265,7 +285,7 @@ def find_all_by_itemtype(self, itemtype):
 
         """
         sceneobjects = []
-        for obj in self.objects:
+        for obj in self.objects.values():
             if isinstance(obj.item, itemtype):
                 sceneobjects.append(obj)
         return sceneobjects

src/compas/scene/sceneobject.py

@@ -12,7 +12,6 @@
 import compas.scene  # noqa: F401
 from compas.colors import Color
 from compas.data import Data
-from compas.datastructures import TreeNode
 from compas.geometry import Frame
 from compas.geometry import Transformation
 
@@ -55,8 +54,9 @@ def create(item=None, scene=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.")
+        if isinstance(item, SceneObject):
+            item._scene = scene
+            return item
 
         sceneobject_cls = get_sceneobject_cls(item, **kwargs)
 
@@ -139,17 +139,24 @@ def __init__(
         **kwargs  # type: dict
     ):  # fmt: skip
         # type: (...) -> None
-        if item and not isinstance(item, Data):
-            raise ValueError("The item assigned to this scene object should be a data object: {}".format(type(item)))
 
         name = name or getattr(item, "name", None)
         super(SceneObject, self).__init__(name=name, **kwargs)
         # the scene object needs to store the context
         # 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"
+
+        if isinstance(item, Data):
+            self._item = str(item.guid)
+        elif isinstance(item, str):
+            self._item = item
+        elif item is None:
+            self._item = None
+        else:
+            raise ValueError("The item assigned to this scene object should be a data object or a str guid: {}".format(item))
+
         self.context = context
         self._scene = scene
-        self._item = item.guid
         self._guids = []
         self._node = None
         self._transformation = transformation
@@ -162,7 +169,7 @@ def __init__(
     def __data__(self):
         # type: () -> dict
         return {
-            "item": str(self._item),
+            "item": self._item,
             "name": self.name,
             "color": self.color,
             "opacity": self.opacity,
@@ -187,7 +194,44 @@ def item(self):
     @property
     def node(self):
         # type: () -> compas.datastructures.TreeNode
-        return self.scene.tree.get_object_node(self.guid)
+        return self.scene.tree.get_node_by_name(self.guid)
+
+    @property
+    def is_root(self):
+        # type: () -> bool
+        return self.node.is_root
+
+    @property
+    def is_leaf(self):
+        # type: () -> bool
+        return self.node.is_leaf
+
+    @property
+    def is_branch(self):
+        # type: () -> bool
+        return self.node.is_branch
+
+    @property
+    def parentnode(self):
+        # type: () -> compas.datastructures.Node | None
+        return self.node.parent
+
+    @property
+    def childnodes(self):
+        # type: () -> list[compas.datastructures.Node]
+        return self.node.children
+
+    @property
+    def parent(self):
+        # type: () -> compas.scene.SceneObject | None
+        if self.parentnode and not self.parentnode.is_root:
+            return self.scene.objects[self.parentnode.name]
+        return None
+
+    @property
+    def children(self):
+        # type: () -> list[compas.scene.SceneObject]
+        return [self.scene.objects[child.name] for child in self.childnodes]
 
     @property
     def guids(self):
@@ -236,6 +280,28 @@ def contrastcolor(self):
                     self._contrastcolor = self.color.lightened(50)
         return self._contrastcolor
 
+    def add(self, item, **kwargs):
+        """Add a scene object to the scene.
+
+        Parameters
+        ----------
+        item : :class:`compas.data.Data`
+            The item to add to the scene.
+        **kwargs : dict
+            Additional keyword arguments to pass to the SceneObject constructor.
+
+        Returns
+        -------
+        :class:`compas.scene.SceneObject`
+            The added scene object.
+        """
+        # type: (compas.data.Data, dict) -> compas.scene.SceneObject
+        return self.scene.add(item, parent=self, **kwargs)
+
+    def remove(self):
+        """Remove this scene object along with all its descendants from the scene."""
+        self.scene.remove(self)
+
     @contrastcolor.setter
     def contrastcolor(self, color):
         # type: (compas.colors.Color) -> None

tests/compas/scene/test_scene.py

@@ -6,6 +6,7 @@
     from compas.scene import register
     from compas.scene import Scene
     from compas.scene import SceneObject
+    from compas.scene import SceneObjectFactory
     from compas.scene import SceneObjectNotRegisteredError
     from compas.data import Data
     from compas.geometry import Box
@@ -46,29 +47,29 @@ def test_get_sceneobject_cls_with_orderly_registration():
         register(FakeItem, FakeSceneObject, context="fake")
         register(FakeSubItem, FakeSubSceneObject, context="fake")
         item = FakeItem()
-        sceneobject = SceneObject(item, context="fake")
+        sceneobject = SceneObjectFactory.create(item, context="fake")
         assert isinstance(sceneobject, FakeSceneObject)
 
         item = FakeSubItem()
-        sceneobject = SceneObject(item, context="fake")
+        sceneobject = SceneObjectFactory.create(item, context="fake")
         assert isinstance(sceneobject, FakeSubSceneObject)
 
     def test_get_sceneobject_cls_with_out_of_order_registration():
         register(FakeSubItem, FakeSubSceneObject, context="fake")
         register(FakeItem, FakeSceneObject, context="fake")
         item = FakeItem()
-        sceneobject = SceneObject(item, context="fake")
+        sceneobject = SceneObjectFactory.create(item, context="fake")
         assert isinstance(sceneobject, FakeSceneObject)
 
         item = FakeSubItem()
-        sceneobject = SceneObject(item, context="fake")
+        sceneobject = SceneObjectFactory.create(item, context="fake")
         assert isinstance(sceneobject, FakeSubSceneObject)
 
         def test_sceneobject_auto_context_discovery(mocker):
             register_fake_context()
 
             item = FakeItem()
-            sceneobject = SceneObject(item)
+            sceneobject = SceneObjectFactory.create(item)
 
             assert isinstance(sceneobject, FakeSceneObject)
 
@@ -78,7 +79,7 @@ def test_sceneobject_auto_context_discovery_no_context(mocker):
 
             with pytest.raises(SceneObjectNotRegisteredError):
                 item = FakeSubItem()
-                _ = SceneObject(item)
+                _ = SceneObjectFactory.create(item)
 
     def test_sceneobject_transform():
         scene = Scene()