update modifier system

Author: tomvanmele

CHANGELOG.md

@@ -15,8 +15,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * Added `compas_model.models.Model.contacts` iterator.
 * Added `brep_brep_contacts` for calculation of contacts between elements with brep geometry.
 * Added `compas_model.datastructures.BVHNode.add` to take care of `depth` value.
-* Added `compas_model.elements.Element.modifiers`.
-* Added `compas_model.elements.Element.add_modifier`.
 * Added `compas_model.elements.Element.apply_modifiers`.
 * Added `compas_model.elements.Element.material` setter.
 * Added lazy-computed `compas_model.elements.Element.femesh2` property.
@@ -25,7 +23,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * Added `compas_model.elements.Element.compute_femesh3` property.
 * Added `compas_model.modifiers`.
 * Added `compas_model.modifiers.Modifier`.
-* Added `compas_model.modifiers.TrimModifier`.
+* Added `compas_model.models.Model.add_modifier`.
 
 ### Changed
 
@@ -50,6 +48,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * Changed `compas_model.model.Model.elements` to property.
 * Changed `compas_model.model.Model.materials` to property.
 * Changed `compas_model.model.Model.contacts` to property.
+* Changed `compas_model.model.Element.compute_modelgeometry` to use new modifier implementation.
 
 ### Removed
 

docs/api/compas_model.modifiers.rst

@@ -12,4 +12,3 @@ Classes
     :nosignatures:
 
     Modifier
-    TrimModifier

src/compas_model/elements/element.py

@@ -4,6 +4,7 @@
 from typing import TYPE_CHECKING
 from typing import Optional
 from typing import Sequence
+from typing import Type
 from typing import TypeVar
 from typing import Union
 
@@ -117,7 +118,7 @@ def __data__(self) -> dict:
         return {
             "transformation": self.transformation,
             "features": self.features,
-            "modifiers": self.modifiers,
+            # "modifiers": self.modifiers,
             "name": self.name,
         }
 
@@ -126,7 +127,6 @@ def __init__(
         geometry: Optional[Union[Brep, Mesh]] = None,
         transformation: Optional[Transformation] = None,
         features: Optional[Sequence[Feature | FeatureType]] = None,
-        modifiers: Optional[Sequence[Modifier]] = None,
         name: Optional[str] = None,
     ) -> None:
         super().__init__(name=name)
@@ -138,7 +138,7 @@ def __init__(
         self._transformation = transformation
         self._geometry = geometry
         self._features = list(features or [])
-        self._modifiers = list(modifiers or [])
+        # self._modifiers = []
         self._material = None
 
         self._aabb = None
@@ -201,9 +201,9 @@ def children(self) -> list["Element"]:
     def features(self) -> list[Feature]:
         return self._features
 
-    @property
-    def modifiers(self) -> list[Modifier]:
-        return self._modifiers
+    # @property
+    # def modifiers(self) -> list[Type[Modifier]]:
+    #     return self._modifiers
 
     @property
     def femesh2(self) -> Mesh:
@@ -217,20 +217,22 @@ def femesh3(self) -> Polyhedron:
             self._femesh3 = self.compute_femesh3()
         return self._femesh3
 
-    @property
-    def is_dirty(self) -> bool:
-        return self._is_dirty
+    # @property
+    # def is_dirty(self) -> bool:
+    #     return self._is_dirty
 
-    @is_dirty.setter
-    def is_dirty(self, value: bool):
-        self._is_dirty = value
+    # @is_dirty.setter
+    # def is_dirty(self, value: bool):
+    #     self._is_dirty = value
 
-        if value:
-            # this is potentially expensive and wasteful
-            # perhaps this mapping needs to be managed on the model level
-            elements: dict[int, Element] = {element.graphnode: element for element in self.model.elements}
-            for neighbor in self.model.graph.neighbors_out(self.graphnode):
-                elements[neighbor].is_dirty = value
+    #     if value:
+    #         # this is potentially expensive and wasteful
+    #         # perhaps this mapping needs to be managed on the model level
+    #         elements: dict[int, Element] = {
+    #             element.graphnode: element for element in self.model.elements
+    #         }
+    #         for neighbor in self.model.graph.neighbors_out(self.graphnode):
+    #             elements[neighbor].is_dirty = value
 
     # ==========================================================================
     # Computed attributes
@@ -343,11 +345,13 @@ def compute_modelgeometry(self) -> Union[Brep, Mesh]:
         xform = self.modeltransformation
         modelgeometry = self.elementgeometry.transformed(xform)
 
-        if self.modifiers:
-            for modifier in self.modifiers:
-                modelgeometry = modifier.apply(modelgeometry)
+        for nbr in self.model.graph.neighbors_in(self.graphnode):
+            modifiers: list[Modifier] = self.model.graph.edge_attribute((nbr, self.graphnode), name="modifiers")  # type: ignore
+            if modifiers:
+                for modifier in modifiers:
+                    modelgeometry = modifier.apply(modelgeometry)
 
-        self.is_dirty = False
+        # self.is_dirty = False
 
         return modelgeometry
 
@@ -456,16 +460,6 @@ def apply_features(self) -> Union[Mesh, Brep]:
         """
         raise NotImplementedError
 
-    def apply_modifiers(self) -> Union[Mesh, Brep]:
-        """Apply the modifiers to the (base) geometry.
-
-        Returns
-        -------
-        Mesh | Brep
-
-        """
-        raise NotImplementedError
-
     # ==========================================================================
     # Transformations
     # ==========================================================================
@@ -507,7 +501,7 @@ def transformed(self, transformation: Transformation) -> "Element":
     # ==========================================================================
 
     def add_feature(self, feature: Feature) -> None:
-        """Add a feature to the list of features of the lement.
+        """Add a feature to the list of features of the element.
 
         Parameters
         ----------
@@ -521,25 +515,29 @@ def add_feature(self, feature: Feature) -> None:
         """
         self.features.append(feature)
 
-    def add_modifier(self, modifier: Modifier) -> None:
-        """Computes the modifier to be applied to the target element.
+    # def add_modifier(self, modifiertype: Type[Modifier]) -> None:
+    #     """Add a modifier type to the registered modifiers of the element.
 
-        Parameters
-        ----------
-        modifier : :class:`Modifier`
-            The modifier instance.
+    #     These modifiers can be applied automatically to connected target elements
+    #     that are compatible with the type of modification,
+    #     if such compatibility requirement is specified.
 
-        Returns
-        -------
-        None
+    #     Parameters
+    #     ----------
+    #     modifiertype : Type[:class:`Modifier`]
+    #         The modifier type.
 
-        Raises
-        ------
-        ValueError
-            If the target element type is not supported.
+    #     Returns
+    #     -------
+    #     None
 
-        """
-        self.modifiers.append(modifier)
+    #     Raises
+    #     ------
+    #     ValueError
+    #         If the target element type is not supported.
+
+    #     """
+    #     self.modifiers.append(modifiertype)
 
     def contacts(self, other: "Element", tolerance: float = 1e-6, minimum_area: float = 1e-2) -> list[Contact]:
         """Compute the contacts between this element and another element.

src/compas_model/models/model.py

@@ -2,6 +2,7 @@
 from typing import Generator
 from typing import Iterator
 from typing import Optional
+from typing import Type
 from typing import TypeVar
 from typing import Union
 
@@ -12,6 +13,7 @@
 from compas_model.elements import Group
 from compas_model.interactions import Contact
 from compas_model.materials import Material
+from compas_model.modifiers import Modifier
 
 from .bvh import ElementBVH
 from .bvh import ElementOBBNode
@@ -120,9 +122,9 @@ def __init__(self, name=None):
         self._tree = ElementTree()
         self._graph = InteractionGraph()
         self._graph.update_default_node_attributes(element=None)
-        # type of contacts is list[Contacts]
+        self._graph.update_default_edge_attributes(modifiers=None)
         self._graph.update_default_edge_attributes(contacts=None)
-        # computed
+
         self._bvh = None
         self._kdtree = None
 
@@ -297,7 +299,7 @@ def remove_element(self, element: Element) -> None:
         if guid not in self._elements:
             raise Exception("Element not in the model.")
 
-        self._elements[guid].is_dirty = True
+        # self._elements[guid].is_dirty = True
 
         del self._elements[guid]
 
@@ -457,6 +459,15 @@ def add_interaction(self, a: Element, b: Element) -> tuple[int, int]:
         Exception
             If one or both of the elements are not in the graph.
 
+        Notes
+        -----
+        In future implementations, adding an interaction should implicitly take care of adding modifiers
+        onto the interaction edges, based on the registered modifiers of the source nodes.
+
+        In the current implementation, modifiers have to be added explicitly using :meth:`add_modifiers`.
+        This method will add an interaction edge from the source of the modifier to its target if needed
+        and store the modifier object on it.
+
         """
         node_a = a.graphnode
         node_b = b.graphnode
@@ -467,9 +478,17 @@ def add_interaction(self, a: Element, b: Element) -> tuple[int, int]:
         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.")
 
-        edge = self._graph.add_edge(node_a, node_b)
+        edge = self.graph.add_edge(node_a, node_b)
 
-        self._elements[str(b.guid)].is_dirty = True
+        # modifiers = []
+        # if a.modifiers:
+        #     for modifiertype in a.modifiers:
+        #         # modifiertype.applies_to
+        #         # modifiers.append()
+        #         pass
+
+        # if modifiers:
+        #     self.graph.edge_attribute(edge, name="modifiers", value=modifiers)
 
         return edge
 
@@ -486,8 +505,8 @@ def remove_interaction(self, a: Element, b: Element) -> None:
         None
 
         """
-        elements = list(self.elements)
-        elements[b.graphnode].is_dirty = True
+        # elements = list(self.elements)
+        # elements[b.graphnode].is_dirty = True
 
         edge = a.graphnode, b.graphnode
         if self.graph.has_edge(edge):
@@ -521,6 +540,50 @@ def has_interaction(self, a: Element, b: Element) -> bool:
             result = self.graph.has_edge(edge)
         return result
 
+    # =============================================================================
+    # Modifiers (temp)
+    # =============================================================================
+
+    def add_modifier(
+        self,
+        source: Element,
+        target: Element,
+        modifiertype: Type[Modifier],
+    ) -> list[Modifier]:
+        """Add a modifier between two elements, with one the source of the modifier and the other the target.
+
+        Parameters
+        ----------
+        source : :class:`compas_model.elements.Element`
+            The source element.
+        target : :class:`compas_model.elements.Element`
+            The target element.
+        modifiertype : Type[:class:`compas_model.modifiers.Modifier`]
+            The type of modifier.
+
+        Returns
+        -------
+        list[Modifier]
+            All modifiers stored on the interaction edge between source and target.
+
+        Notes
+        -----
+        This element should implement the protocol specified by the modifier.
+        The methods of the source element defined by the protocol are used to compute the tools involved in the modification.
+        The tools are used by the modifier to apply the modification to the model geometry of the target element.
+
+        The modifier defines the protocol for the modification.
+        The protocol should be implemented by the source element.
+        The protocol methods of the source element are used to compute the modification tool.
+        The modifier applies the modification to the target using this tool.
+
+        """
+        edge = self.add_interaction(source, target)
+        modifiers = self.graph.edge_attribute(edge, name="modifiers") or []
+        modifiers.append(modifiertype(source))
+        self.graph.edge_attribute(edge, name="modifiers", value=modifiers)
+        return modifiers
+
     # =============================================================================
     # Compute
     # =============================================================================
@@ -571,6 +634,14 @@ def compute_kdtree(self) -> KDTree:
     def compute_contacts(self, tolerance=1e-6, minimum_area=1e-2) -> None:
         """Compute the contacts between the block elements of this model.
 
+        Computing contacts is done independently of the edges of the interaction graph.
+        If contacts are found between two elements with an existing edge, the contacts attribute of the edge will be replaced.
+        If there is no pre-existing edge, one will be added.
+        No element pairs are excluded in the search based on the existence of an edge between their nodes in the interaction graph.
+
+        The search is conducted entirely based on the BVH of the elements contained in the model.
+        It is a spatial search that creates topological connections between elements based on their geometrical interaction.
+
         Parameters
         ----------
         tolerance : float, optional
@@ -592,6 +663,7 @@ def compute_contacts(self, tolerance=1e-6, minimum_area=1e-2) -> None:
                     contacts = element.contacts(nbr, tolerance=tolerance, minimum_area=minimum_area)
                     if contacts:
                         self.graph.add_edge(u, v, contacts=contacts)
+
                 else:
                     edge = (u, v) if self.graph.has_edge((u, v)) else (v, u)
                     contacts = self.graph.edge_attribute(edge, name="contacts")

src/compas_model/modifiers/__init__.py

@@ -1,7 +1,5 @@
 from .modifier import Modifier
-from .trim import TrimModifier
 
 __all__ = [
     "Modifier",
-    "TrimModifier",
 ]

src/compas_model/modifiers/modifier.py

@@ -20,13 +20,22 @@ class Modifier(Data):
     def __data__(self) -> dict:
         return {"name": self.name}
 
-    def __init__(self, name: Optional[str] = None) -> None:
+    def __init__(
+        self,
+        source,
+        name: Optional[str] = None,
+    ) -> None:
         super().__init__(name=name)
 
+        self.source = source
+
     def __repr__(self):
         return f'{self.__class__.__name__}(name="{self.name}")'
 
-    def apply(self, target: Union[Brep, Mesh]) -> Union[Brep, Mesh]:
+    def apply(
+        self,
+        targetgeometry: Union[Brep, Mesh],
+    ) -> Union[Brep, Mesh]:
         """Apply the interaction to the target geometry.
 
         Parameters