FIX conflicts from main.

Author: petrasvestartas

CHANGELOG.md

@@ -43,11 +43,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * Added `compas_model.elements.BeamElement`.
 * Added `compas_model.elements.ColumnElement`.
 * Added `compas_model.elements.PlateElement`.
+* Added `compas_model.models.Model.collisions` iterator.
+* Added `compas_model.models.graph.InteractionGraph.clear_edges`.
 
 ### Changed
 
 * Changed `Element.graph_node` to `Element.graphnode`.
 * Changed `Element.tree_node` to `Element.treenode`.
+* Fixed bug in deserialisation (`element.model` was not set properly).
 
 ### Removed
 

docs/examples/interactions/002_frame.py

@@ -12,7 +12,6 @@
 from compas.tolerance import TOL
 from compas_model.elements import BeamElement
 from compas_model.elements import ColumnElement
-from compas_model.interactions import BooleanModifier
 from compas_model.models import Model
 from compas_viewer import Viewer
 from compas_viewer.config import Config

src/compas_model/models/interactiongraph.py

@@ -100,6 +100,15 @@ def _build_interactions_str(self) -> str:
                 )
         return "\n".join(lines) + "\n"
 
+    def clear_edges(self):
+        """Clear all the edges and connectivity information of the graph."""
+        for u, v in list(self.edges()):
+            del self.edge[u][v]
+            if v in self.adjacency[u]:
+                del self.adjacency[u][v]
+            if u in self.adjacency[v]:
+                del self.adjacency[v][u]
+
     def node_element(self, node: int) -> Element:
         """Get the element associated with the node.
 
@@ -114,30 +123,3 @@ def node_element(self, node: int) -> Element:
 
         """
         return self.node_attribute(node, "element")  # type: ignore
-
-    # def edge_interactions(self, edge: tuple[int, int]) -> list[Interaction]:
-    #     """Get the element associated with the node.
-
-    #     Parameters
-    #     ----------
-    #     edge : tuple[int, int]
-    #         The identifier of the edge.
-
-    #     Returns
-    #     -------
-    #     :class:`compas_model.interactions.Interaction`
-
-    #     """
-    #     return self.edge_attribute(edge, "interactions")  # type: ignore
-
-    # def interactions(self) -> Generator[Interaction, None, None]:
-    #     """Get the interactions in the graph.
-
-    #     Yields
-    #     ------
-    #     :class:`compas_model.interactions.Interaction`
-
-    #     """
-    #     for edge in self.edges():
-    #         for interaction in self.edge_interactions(edge):
-    #             yield interaction

src/compas_model/models/model.py

@@ -78,6 +78,7 @@ def add(nodedata: dict, parentnode: ElementNode) -> None:
                 for childdata in nodedata["children"]:
                     guid = childdata["element"]
                     element = model._guid_element[guid]
+                    element.model = model
                     attr = childdata.get("attributes") or {}
                     childnode = ElementNode(element=element, name=childdata["name"], **attr)
                     parentnode.add(childnode)
@@ -605,7 +606,29 @@ def materials(self) -> Generator[Material, None, None]:
         """
         return iter(self._guid_material.values())
 
-    def collisions(self):
+    def collisions(self) -> Generator[tuple[Element, Element], None, None]:
+        """Yield all collision pairs in the model.
+
+        Yields
+        ------
+        tuple[:class:`Element`, :class:`Element`]
+            The collision pairs.
+
+        Notes
+        -----
+        Collisions are not identified automatically.
+        To identify collision, run :meth:`identify_interactions` or :meth:`compute_collisions` first.
+
+        """
+        for edge in self.graph.edges():
+            collision = self.graph.edge_attribute(edge, name="collision")
+            if collision:
+                u, v = edge
+                a = self.graph.node_element(u)
+                b = self.graph.node_element(v)
+                yield a, b
+
+    def contacts(self):
         raise NotImplementedError
 
     # def elements_connected_by(self, interaction_type: Type[Interaction]) -> list[list[Element]]:
@@ -653,11 +676,34 @@ def collisions(self):
     # Compute
     # =============================================================================
 
-    def compute_bvh(self, nodetype=ElementOBBNode, max_depth=None, leafsize=1) -> ElementBVH:
+    def compute_bvh(self, nodetype=ElementOBBNode, max_depth: Optional[int] = None, leafsize: Optional[int] = 1) -> ElementBVH:
+        """Compute the Bounding Volume Hierarchy (BVH) of the elements for fast collision checks.
+
+        Parameters
+        ----------
+        nodetype : :class:`ElementOBBNode`
+            The type of bounding volume node used in the tree.
+        max_depth : int, optional
+            The maximum depth used for constructing the BVH.
+        leafsize : int, optional
+            The number of elements contained in a BVH leaf node.
+
+        Returns
+        -------
+        :class:`ElementBVH`
+
+        """
         self._bvh = ElementBVH.from_elements(self.elements(), nodetype=nodetype, max_depth=max_depth, leafsize=leafsize)
         return self._bvh
 
     def compute_kdtree(self) -> KDTree:
+        """Compute the KD tree of the elements for fast nearest neighbour queries.
+
+        Returns
+        -------
+        :class:`KDTree`
+
+        """
         self._kdtree = KDTree(list(self.elements()))
         return self._kdtree
 
@@ -666,9 +712,30 @@ def compute_kdtree(self) -> KDTree:
     # =============================================================================
 
     def element_nnbrs(self, element: Element, k=1) -> list[tuple[Element, float]]:
+        """"""
         return [nbr for nbr in self.point_nnbrs(element.point, k=k + 1) if nbr[0] is not element]
 
     def point_nnbrs(self, point, k=1) -> list[tuple[Element, float]]:
         if k == 1:
             return [self.kdtree.nearest_neighbor(point)]
         return self.kdtree.nearest_neighbors(point, number=k)
+
+    # def identify_interactions(self, reset_graph=True, k=None) -> None:
+    #     """Identify element interactions by computing element collision pairs and adding an interaction edge per pair.
+
+    #     Returns
+    #     -------
+    #     None
+
+    #     """
+    #     if reset_graph:
+    #         self.graph.clear_edges()
+
+    #     k = k or 1
+    #     for element in self.elements():
+    #         for nbr, distance in self.element_nnbrs(element, k=k):
+    #             if self.has_interaction():
+    #                 continue
+    #             # dos something with the distance?
+    #             if element.is_collision(nbr, precise=True):
+    #                 pass

src/compas_model/scene/elementobject.py

@@ -1,8 +1,10 @@
-import compas.geometry  # noqa: F401
-import compas_model.elements  # noqa: F401
+from typing import Optional
+
 from compas.colors import Color
+from compas.geometry import Transformation
 from compas.scene import SceneObject
 from compas.scene.descriptors.colordict import ColorDictAttribute
+from compas_model.elements import Element
 
 
 class ElementObject(SceneObject):
@@ -50,37 +52,49 @@ class ElementObject(SceneObject):
     edgecolor = ColorDictAttribute()
     facecolor = ColorDictAttribute()
 
-    def __init__(self, element, **kwargs):
-        # type: (compas_model.elements.Element, dict) -> None
-        super(ElementObject, self).__init__(item=element, **kwargs)
+    def __init__(
+        self,
+        element: Element,
+        vertexcolor: Optional[Color] = Color.black(),
+        edgecolor: Optional[Color] = Color.black(),
+        facecolor: Optional[Color] = Color.white(),
+        vertexsize: Optional[float] = 1.0,
+        edgewidth: Optional[float] = 1.0,
+        show_vertices: Optional[bool] = False,
+        show_edges: Optional[bool] = True,
+        show_faces: Optional[bool] = True,
+        **kwargs,
+    ) -> None:
+        super().__init__(item=element, **kwargs)
 
         self._element = element
-        self.vertexcolor = kwargs.get("vertexcolor", Color.black())
-        self.edgecolor = kwargs.get("edgecolor", Color.black())
-        self.facecolor = kwargs.get("facecolor", Color.white())
-        self.vertexsize = kwargs.get("vertexsize", 1.0)
-        self.edgewidth = kwargs.get("edgewidth", 1.0)
-        self.show_vertices = kwargs.get("show_vertices", False)
-        self.show_edges = kwargs.get("show_edges", True)
-        self.show_faces = kwargs.get("show_faces", True)
+
+        self.vertexcolor = vertexcolor
+        self.edgecolor = edgecolor
+        self.facecolor = facecolor
+
+        self.vertexsize = vertexsize
+        self.edgewidth = edgewidth
+
+        self.show_vertices = show_vertices
+        self.show_edges = show_edges
+        self.show_faces = show_faces
 
     @property
-    def element(self):
-        # type: () -> compas_model.elements.Element
+    def element(self) -> Element:
         return self._element
 
     @element.setter
-    def element(self, element):
+    def element(self, element: Element) -> None:
         self._element = element
         self._transformation = None
 
     @property
-    def transformation(self):
-        # type: () -> compas.geometry.Transformation | None
+    def transformation(self) -> Transformation:
         return self._transformation
 
     @transformation.setter
-    def transformation(self, transformation):
+    def transformation(self, transformation: Transformation) -> None:
         self._transformation = transformation
 
     def draw(self):

src/compas_model/scene/modelobject.py

@@ -1,59 +1,49 @@
-import compas.geometry  # noqa: F401
-import compas_model.models  # noqa: F401
+from typing import Optional
+
+from compas.geometry import Transformation
 from compas.scene import SceneObject
+from compas_model.models import Model
 
 
 class ModelObject(SceneObject):
     def __init__(
         self,
-        model,  # type: compas_model.models.Model
-        show_tree=False,  # type: bool
-        show_graph=False,  # type: bool
-        show_elements=True,  # type: bool
-        show_interactions=True,  # type: bool
-        show_element_faces=True,  # type: bool
-        **kwargs,  # type: dict
-    ):  # type: (...) -> None
-        super(ModelObject, self).__init__(item=model, **kwargs)
+        model: Model,
+        show_elements: Optional[bool] = True,
+        show_contacts: Optional[bool] = True,
+        **kwargs,
+    ) -> None:
+        super().__init__(item=model, **kwargs)
 
         self._model = model
 
-        self.show_tree = show_tree
-        self.show_graph = show_graph
         self.show_elements = show_elements
-        self.show_interactions = show_interactions
-
-        elementkwargs = kwargs.copy()
-        if "show_faces" in elementkwargs:
-            del elementkwargs["show_faces"]
+        self.show_contacts = show_contacts
 
         for element in model.elements():
-            self.add(element, show_faces=show_element_faces, **elementkwargs)
+            self.add(element, **kwargs)
 
-        # for edge in model.graph.edges():
-        #     interaction = model.graph.edge_attribute(edge, name="interaction")
-        #     self.add(interaction, show_faces=show_interaction_faces,  **kwargs)
+        for contact in model.contacts():
+            self.add(contact, **kwargs)
 
     @property
-    def model(self):
-        # type: () -> compas_model.models.Model
+    def model(self) -> Model:
         return self._model
 
     @model.setter
-    def model(self, model):
+    def model(self, model: Model) -> None:
         self._model = model
         self._transformation = None
 
     @property
-    def transformation(self):
-        # type: () -> compas.geometry.Transformation | None
+    def transformation(self) -> Transformation:
         return self._transformation
 
     @transformation.setter
-    def transformation(self, transformation):
+    def transformation(self, transformation: Transformation) -> None:
         self._transformation = transformation
 
-    def draw(self):
+    def draw(self) -> None:
         """draw the model.
 
         Returns
@@ -63,7 +53,7 @@ def draw(self):
         """
         raise NotImplementedError
 
-    def clear(self):
+    def clear(self) -> None:
         """Clear all components of the model.
 
         Returns