CHANGE add_modifier takes type and **kwargs.

Author: petrasvestartas

data/frame.json

@@ -0,0 +1 @@
+{"Model::Line::Segments": [{"dtype": "compas.geometry/Line", "data": {"start": [-3000.0, -3000.0, 0.0], "end": [-3000.0, -3000.0, 3800.0]}, "guid": "2fc7fca3-cf83-44a8-9338-31917268590b"}, {"dtype": "compas.geometry/Line", "data": {"start": [-3000.0, 3000.0, 0.0], "end": [-3000.0, 3000.0, 3800.0]}, "guid": "aa520fb7-ff92-43da-b8c1-6a77754650f1"}, {"dtype": "compas.geometry/Line", "data": {"start": [3000.0, 3000.0, 0.0], "end": [3000.0, 3000.0, 3800.0]}, "guid": "29a4ef5b-edf0-4bd6-95f5-20b864c49908"}, {"dtype": "compas.geometry/Line", "data": {"start": [3000.0, -3000.0, 0.0], "end": [3000.0, -3000.0, 3800.0]}, "guid": "2263ec71-b010-499c-9614-3424307e6602"}, {"dtype": "compas.geometry/Line", "data": {"start": [-3000.0, -3000.0, 3800.0], "end": [-3000.0, 3000.0, 3800.0]}, "guid": "0ecd6ac6-1853-485b-8b50-3f07c7ec207d"}, {"dtype": "compas.geometry/Line", "data": {"start": [3000.0, 3000.0, 3800.0], "end": [3000.0, -3000.0, 3800.0]}, "guid": "008c3470-f42b-4184-a2d3-6c0c5416f901"}, {"dtype": "compas.geometry/Line", "data": {"start": [-3000.0, 3000.0, 3800.0], "end": [3000.0, 3000.0, 3800.0]}, "guid": "94af457f-3386-4fb7-9f8f-24d05eed86d2"}, {"dtype": "compas.geometry/Line", "data": {"start": [3000.0, -3000.0, 3800.0], "end": [-3000.0, -3000.0, 3800.0]}, "guid": "7c7014f7-d93c-4b17-a2d8-f8ff41f95a80"}], "Model::Mesh::Floor": [{"dtype": "compas.datastructures/Mesh", "data": {"attributes": {}, "default_vertex_attributes": {"x": 0.0, "y": 0.0, "z": 0.0}, "default_edge_attributes": {}, "default_face_attributes": {}, "vertex": {"0": {"x": -3000.0, "y": -3000.0, "z": 3800.0}, "1": {"x": -3000.0, "y": 3000.0, "z": 3800.0}, "2": {"x": 3000.0, "y": 3000.0, "z": 3800.0}, "3": {"x": 3000.0, "y": -3000.0, "z": 3800.0}}, "face": {"0": [0, 1, 2, 3]}, "facedata": {"0": {}}, "edgedata": {}, "max_vertex": 3, "max_face": 0}, "guid": "82f752d5-cf71-41e6-9aa0-742e41eddc14"}]}

docs/examples/elements/plate.py

@@ -12,7 +12,7 @@
 ]
 polygon : Polygon = Polygon(points)
 plate: PlateElement = PlateElement(polygon=polygon, thickness=0.2)
-
+plate.copy()
 
 # Vizualize.
 viewer = Viewer()

docs/examples/interactions/000_boolean_modifier.py

@@ -0,0 +1,29 @@
+from compas.geometry import Rotation
+from compas.geometry import Translation
+from compas_model.elements import BeamElement
+from compas_model.interactions import BooleanModifier
+from compas_model.models import Model
+from compas_viewer import Viewer
+
+# Create an element.
+beam0: BeamElement = BeamElement(0.2, 0.3, 3, name="beam0")
+beam1 : BeamElement = beam0.copy()
+beam1.name = "beam1"
+
+# Element transformation can be set or modified as an attribute.
+beam0.transformation = Rotation.from_axis_and_angle([0, 1, 0], 3.14/2, beam0.axis.midpoint)
+beam0.transformation = Translation.from_vector([0, 0, 1.5])* beam0.transformation # Rotate then translate
+
+# But the transformation is applied when beam.modelgeometry is computed.
+model = Model()
+model.add_element(beam0)
+model.add_element(beam1)
+
+model.add_interaction(beam1, beam0)
+model.add_modifier(beam1, beam0, BooleanModifier)
+
+# Vizualize.
+viewer = Viewer()
+for element in model.elements():
+    viewer.scene.add(element.modelgeometry, hide_coplanaredges=True)
+viewer.show()

docs/examples/interactions/001_slicer_modifier.py

@@ -0,0 +1,29 @@
+from compas.geometry import Rotation
+from compas.geometry import Translation
+from compas_model.elements import BeamElement
+from compas_model.interactions import SlicerModifier
+from compas_model.models import Model
+from compas_viewer import Viewer
+
+# Create an element.
+beam0: BeamElement = BeamElement(0.2, 0.3, 3, name="beam0")
+beam1 : BeamElement = beam0.copy()
+beam1.name = "beam1"
+
+# Element transformation can be set or modified as an attribute.
+beam0.transformation = Rotation.from_axis_and_angle([0, 1, 0], 3.14/2, beam0.axis.midpoint)
+beam0.transformation = Translation.from_vector([0, 0, 1.5])* beam0.transformation # Rotate then translate
+
+# But the transformation is applied when beam.modelgeometry is computed.
+model = Model()
+model.add_element(beam0)
+model.add_element(beam1)
+
+model.add_interaction(beam0, beam1)
+model.add_modifier(beam0, beam1, SlicerModifier)
+
+# Vizualize.
+viewer = Viewer()
+for element in model.elements():
+    viewer.scene.add(element.modelgeometry, hide_coplanaredges=True)
+viewer.show()

docs/examples/interactions/002_frame.py

@@ -0,0 +1,105 @@
+from pathlib import Path
+
+from compas import json_dump
+from compas import json_load
+from compas.datastructures import Mesh
+from compas.geometry import Frame
+from compas.geometry import Line
+from compas.geometry import Point
+from compas.geometry import Translation
+from compas.geometry import Vector
+from compas.geometry.transformation import Transformation
+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
+
+# =============================================================================
+# Create Geometry
+# =============================================================================
+points = [
+    Point(-3000, -3000, 0),
+    Point(-3000, 3000, 0),
+    Point(3000, 3000, 0),
+    Point(3000, -3000, 0),
+    Point(-3000, -3000, 3800),
+    Point(-3000, 3000, 3800),
+    Point(3000, 3000, 3800),
+    Point(3000, -3000, 3800),
+]
+
+lines = [
+    Line(points[0], points[4]),
+    Line(points[1], points[5]),
+    Line(points[2], points[6]),
+    Line(points[3], points[7]),
+    Line(points[4], points[5]),
+    Line(points[6], points[7]),
+    Line(points[5], points[6]),
+    Line(points[7], points[4]),
+]
+
+mesh = Mesh.from_vertices_and_faces(points[4:], [[0, 1, 2, 3]])
+
+# =============================================================================
+# Serialize Geometry into a JSON file
+# =============================================================================
+model_input = {"Model::Line::Segments": lines, "Model::Mesh::Floor": [mesh]}
+json_dump(model_input, Path("data/frame.json"))
+
+
+# =============================================================================
+# Load Geometry from JSON and Create Model
+# =============================================================================
+rhino_geometry = json_load(Path("data/frame.json"))
+lines = rhino_geometry["Model::Line::Segments"]
+
+model = Model()
+
+# Add columns
+columns = []
+for i in range(4):
+    column = ColumnElement(300, 300, lines[i].length)
+    column.transformation = Transformation.from_frame_to_frame(Frame.worldXY(), Frame(lines[i].start))
+    model.add_element(column)
+    columns.append(column)
+
+# Add beams
+beams = []
+for i in range(4, len(lines)):
+    beam = BeamElement(width=300, depth=700, length=lines[i].length)
+    target_frame = Frame(
+        lines[i].start, Vector.Zaxis().cross(lines[i].vector), Vector.Zaxis()
+    )
+    beam.transformation = (
+        Transformation.from_frame_to_frame(Frame.worldXY(), target_frame)
+        * Translation.from_vector([0, beam.depth * -0.5, 0])
+    )
+    beam.extend(150)
+    model.add_element(beam)
+    beams.append(beam)
+
+# Add interactions and modifiers
+for column in columns:
+    for beam in beams:
+        model.add_interaction(column, beam)
+        model.add_modifier(column, beam)  # column -> cuts -> beam
+
+# =============================================================================
+# Visualize Final Model
+# =============================================================================
+TOL.lineardeflection = 100
+
+config = Config()
+config.camera.target = [0, 0, 100]
+config.camera.position = [10000, -10000, 10000]
+config.camera.near = 10
+config.camera.far = 100000
+
+viewer = Viewer(config=config)
+for element in model.elements():
+    viewer.scene.add(element.modelgeometry, hide_coplanaredges=True)
+viewer.show()

src/compas_model/elements/beam.py

@@ -12,9 +12,13 @@
 from compas.geometry import bounding_box
 from compas.geometry import identity_matrix
 from compas.geometry import intersection_line_plane
+from compas.geometry import is_point_in_polygon_xy
 from compas.geometry import oriented_bounding_box
 from compas_model.elements.element import Element
 from compas_model.elements.element import Feature
+from compas_model.interactions import BooleanModifier
+from compas_model.interactions import Modifier
+from compas_model.interactions import SlicerModifier
 
 
 class BeamFeature(Feature):
@@ -99,7 +103,7 @@ def __init__(
         self.depth: float = depth
         self._length: float = length
 
-        self.points: list[list[float]] = [[-width * 1, -depth * 0.5, 0], [-width * 1, depth * 0.5, 0], [width * 0, depth * 0.5, 0], [width * 0, -depth * 0.5, 0]]
+        self.points: list[list[float]] = [[-width * 0.5, -depth * 0.5, 0], [-width * 0.5, depth * 0.5, 0], [width * 0.5, depth * 0.5, 0], [width * 0.5, -depth * 0.5, 0]]
 
         self.section: Polygon = Polygon(self.points)
         self.axis: Line = Line([0, 0, 0], [0, 0, length])
@@ -117,7 +121,7 @@ def compute_elementgeometry(self) -> Mesh:
         box: Box = Box.from_width_height_depth(self.width, self.length, self.depth)
         box.translate(
             [
-                self.width * -0.5,
+                0,
                 0,
                 self.length * 0.5,
             ]
@@ -239,3 +243,43 @@ def compute_top_and_bottom_polygons(self) -> tuple[Polygon, Polygon]:
             points0.append(result0)
             points1.append(result1)
         return Polygon(points0), Polygon(points1)
+
+    def _add_modifier_with_beam(self, target_element: "BeamElement", modifier_type: type[Modifier] = None, **kwargs) -> Modifier:
+        if not modifier_type:
+            raise ValueError("Modifier type is not defined, please define a modifier type e.g. SlicerModfier.")
+
+        if isinstance(modifier_type, type) and issubclass(modifier_type, BooleanModifier):
+            return BooleanModifier(self.elementgeometry.transformed(self.modeltransformation))
+
+        if isinstance(modifier_type, type) and issubclass(modifier_type, SlicerModifier):
+            return self._create_slicer_modifier(target_element)
+
+        raise ValueError(f"Unknown modifier type: {modifier_type}")
+
+    def _create_slicer_modifier(self, target_element: "BeamElement") -> Modifier:
+        mesh = self.elementgeometry.transformed(self.modeltransformation)
+        axis = target_element.axis.transformed(target_element.modeltransformation)
+
+        p0 = axis.start
+        p1 = axis.end
+
+        closest_distance_to_end_point = float("inf")
+        closest_face = 0
+        for face in self.elementgeometry.faces():
+            polygon = mesh.face_polygon(face)
+            frame = polygon.frame
+            result = intersection_line_plane(axis, Plane.from_frame(frame))
+            if result:
+                point = Point(*result)
+                xform = Transformation.from_frame_to_frame(frame, Frame.worldXY())
+                point = point.transformed(xform)
+                polygon = polygon.transformed(xform)
+                if is_point_in_polygon_xy(point, polygon):
+                    d = max(p0.distance_to_point(point), p1.distance_to_point(point))
+                    if d < closest_distance_to_end_point:
+                        closest_distance_to_end_point = d
+                        closest_face = face
+
+        plane = Plane.from_frame(mesh.face_polygon(closest_face).frame)
+        plane = Plane(plane.point, -plane.normal)
+        return SlicerModifier(plane)

src/compas_model/elements/column.py

@@ -13,8 +13,11 @@
 from compas.geometry import intersection_line_plane
 from compas.geometry import oriented_bounding_box
 from compas.itertools import pairwise
-from compas_model.elements.element import Element
+from compas_model.elements import BeamElement
+from compas_model.elements import Element
 from compas_model.elements.element import Feature
+from compas_model.interactions import BooleanModifier
+from compas_model.interactions import Modifier
 
 
 class ColumnFeature(Feature):
@@ -223,3 +226,6 @@ def compute_point(self) -> Point:
 
         xform: Transformation = identity_matrix if self.modeltransformation is None else self.modeltransformation
         return self.frame.point.transformed(xform)
+
+    def _add_modifier_with_beam(self, target_element: "BeamElement", modifier_type: type[Modifier] = None, **kwargs) -> Modifier:
+        return BooleanModifier(self.elementgeometry.transformed(self.modeltransformation))

src/compas_model/elements/element.py

@@ -20,6 +20,7 @@
 from compas_model.materials import Material
 
 if TYPE_CHECKING:
+    from compas_model.elements import Element
     from compas_model.models import ElementNode
     from compas_model.models import Model
 
@@ -477,3 +478,38 @@ def contacts(self, other: "Element", tolerance: float = 1e-6, minimum_area: floa
             tolerance=tolerance,
             minimum_area=minimum_area,
         )
+
+    def add_modifier(self, target_element: "Element", modifier_type: type[Modifier] = None, **kwargs) -> Modifier:
+        """Computes the contact interaction of the geometry of the elements that is used in the model's add_contact method.
+
+        Parameters
+        ----------
+        target_element : Element
+            The target element to compute the contact interaction.
+        modifier_type : type[Modifier] | None
+            The type of Modifier to be used. If not provided, the default modifier will be used.
+        kwargs : dict
+            The keyword arguments to be passed to the contact interaction.
+
+        Returns
+        -------
+        Modifier
+            The ContactInteraction that is applied to the neighboring element. One pair can have one or multiple variants.
+
+        Raises
+        ------
+        ValueError
+            If the target element type is not supported.
+        """
+        # Traverse up to the class one before the Element class
+        parent_class = target_element.__class__
+        while parent_class.__bases__[0].__name__ != "Element":
+            parent_class = parent_class.__bases__[0]
+
+        parent_class_name = parent_class.__name__.lower().replace("element", "")
+        method_name = f"_add_modifier_with_{parent_class_name}"
+        method = getattr(self, method_name, None)
+
+        if method is None:
+            raise ValueError(f"Unsupported target element type: {type(target_element)}")
+        return method(target_element, modifier_type, **kwargs)

src/compas_model/elements/plate.py

@@ -31,17 +31,32 @@ class PlateElement(Element):
         The base polygon of the plate.
     thickness : float
         The total offset thickness above and blow the polygon
+    is_support : bool
+        Flag indicating that the block is a support.
+    transformation : :class:`compas.geometry.Transformation`, optional
+        The transformation of the block.
+    features : list[:class:`PlateFeature`], optional
+        The features of the block.
     name : str, optional
-        The name of the element.
-    shape : :class:`compas.datastructures.Mesh`, optional
-        The base shape of the element.
+        The name of the block.
 
     Attributes
     ----------
-    shape : :class:`compas.datastructure.Mesh`
-        The base shape of the block.
+    bottom : :class:`compas.geometry.Polygon`
+        The base polygon of the plate.
+    top : :class:`compas.geometry.Polygon`
+        The top polygon of the plate.
+    thickness : float
+        The total offset thickness above and blow the polygon
     is_support : bool
         Flag indicating that the block is a support.
+    transformation : :class:`compas.geometry.Transformation`
+        The transformation of the block.
+    features : list[:class:`PlateFeature`]
+        The features of the Plate.
+    name : str
+        The name of the block.
+
 
     """
 

src/compas_model/interactions/modifiers/boolean_modifier.py

@@ -46,16 +46,16 @@ def apply(self, target: Union[Brep, Mesh]):
         if isinstance(target, Brep) and isinstance(self.source, Brep):
             try:
                 return Brep.from_boolean_difference(target, self.source)
-            except Exception:
+            except Exception as e:
                 print("Boolean difference is not successful.")
+                print(str(e))
                 return target
         else:
             from compas_cgal.booleans import boolean_difference_mesh_mesh
 
             mesh0: Mesh = target.copy() if not isinstance(target, Brep) else Mesh.from_polygons(target.to_polygons())
             mesh1: Mesh = self.source.copy() if not isinstance(self.source, Brep) else Mesh.from_polygons(self.source.to_polygons())
-            print(mesh0)
-            print(mesh1)
+
             A = mesh0.to_vertices_and_faces(triangulated=True)
             B = mesh1.to_vertices_and_faces(triangulated=True)