WIP modifiers are working

Author: petrasvestartas

src/compas_model/elements/element.py

@@ -16,6 +16,7 @@
 from compas_model.algorithms import mesh_mesh_collision
 from compas_model.algorithms import mesh_mesh_contacts
 from compas_model.interactions import Contact
+from compas_model.interactions import Modifier
 from compas_model.materials import Material
 
 if TYPE_CHECKING:
@@ -322,16 +323,16 @@ def compute_modelgeometry(self) -> Union[Brep, Mesh]:
         xform = self.modeltransformation
         modelgeometry = self.elementgeometry.transformed(xform)
 
-        # this needs to be updated
+        # Modifiers updated
+        # TODO: contacts this needs to be updated
 
-        # graph = self.model.graph
-        # elements = list(self.model.elements())
-        # for neighbor in graph.neighbors_in(self.graphnode):
-        #     for interaction in graph.edge_interactions((neighbor, self.graphnode)):
-        #         if isinstance(interaction, Contact):
-        #             modelgeometry = interaction.apply(modelgeometry)
-        #         elif isinstance(interaction, BooleanModifier):
-        #             modelgeometry = interaction.apply(modelgeometry, elements[neighbor].modelgeometry)
+        graph = self.model.graph
+        for neighbor in graph.neighbors_in(self.graphnode):
+            modifiers: Union[list[Modifier], None] = graph.edge_attribute((neighbor, self.graphnode), "modifiers")
+
+            if modifiers:
+                for modifer in modifiers:
+                    modelgeometry = modifer.apply(modelgeometry)
 
         self.is_dirty = False
 

src/compas_model/interactions/__init__.py

@@ -1,7 +1,11 @@
 from .contact import Contact
 from .modifiers.modifier import Modifier
+from .modifiers.slicer_modifier import SlicerModifier
+from .modifiers.boolean_modifier import BooleanModifier
 
 __all__ = [
     "Contact",
     "Modifier",
+    "SlicerModifier",
+    "BooleanModifier",
 ]

src/compas_model/models/interactiongraph.py

@@ -89,10 +89,13 @@ def _build_interactions_str(self) -> str:
                 edge = node, nbr
                 if not self.has_edge(edge):
                     edge = nbr, node
+
                 lines.append(
-                    "- {}: {}".format(
+                    "- {}: {} {} {}".format(
                         nbr,
-                        self.edge_interactions(edge),  # type: ignore
+                        self.edge_attribute(edge, "modifiers"),
+                        self.edge_attribute(edge, "contacts"),
+                        self.edge_attribute(edge, "collisons"),
                     )  # type: ignore
                 )
         return "\n".join(lines) + "\n"

src/compas_model/models/model.py

@@ -7,6 +7,7 @@
 from compas.geometry import Transformation
 from compas_model.datastructures import KDTree
 from compas_model.elements import Element
+from compas_model.interactions import Modifier
 from compas_model.materials import Material
 
 from .bvh import ElementBVH
@@ -387,12 +388,13 @@ def add_interaction(self, a: Element, b: Element) -> tuple[int, int]:
             If one or both of the elements are not in the graph.
 
         """
-        if not self.has_element(a) or not self.has_element(b):
-            raise Exception("Please add both elements to the model first.")
 
         node_a = a.graphnode
         node_b = b.graphnode
 
+        if not self.has_element(a) or not self.has_element(b):
+            raise Exception("Please add both elements to the model first.")
+
         if not self.graph.has_node(node_a) or not self.graph.has_node(node_b):
             raise Exception("Something went wrong: the elements are not in the interaction graph.")
 
@@ -405,8 +407,41 @@ def add_interaction(self, a: Element, b: Element) -> tuple[int, int]:
     def identify_interactions(self):
         raise NotImplementedError
 
-    def add_modifier(self):
-        raise NotImplementedError
+    def add_modifier(self, a: Element, b: Element, type: str = "") -> tuple[int, int]:
+        """Add a modifier  between two elements.
+
+        Parameters
+        ----------
+        edge : tuple[int, int]
+            The edge of the interaction graph representing the interaction between the two elements.
+            Order matters: interaction is applied from node V0 to node V1.
+            The first element create and instance of the interaction.
+        type : str, optional
+            The type of modifier, if different contact are possible between the two elements.
+
+        Returns
+        -------
+        None
+
+        """
+        node_a = a.graphnode
+        node_b = b.graphnode
+
+        if not self.graph.has_node(node_a) or not self.graph.has_node(node_b):
+            raise Exception("Something went wrong: the elements are not in the interaction graph.")
+
+        if not self._graph.has_edge((node_a, node_b)):
+            raise Exception("Edge is not in the interaction graph. Add the edge first.")
+
+        modifier: Modifier = a.add_modifier(b, type)
+
+        if modifier:
+            if not self.graph.edge_attribute((node_a, node_b), "modifiers"):
+                self.graph.edge_attribute((node_a, node_b), "modifiers", [modifier])
+            else:
+                self.graph.edge_attribute((node_a, node_b), modifier).append(modifier)
+            self._guid_element[str(b.guid)].is_dirty = True
+            return node_a, node_b
 
     def compute_contacts(self):
         raise NotImplementedError