compas-masonry 0.2.1__py3-none-any.whl

compas_masonry/__init__.py

@@ -0,0 +1,3 @@
+__version__ = "0.2.1"
+
+__all_plugins__ = ["compas_masonry.scene"]

compas_masonry/__main__.py

@@ -0,0 +1,2 @@
+if __name__ == "__main__":
+    pass

compas_masonry/forms/settings.py

@@ -0,0 +1,203 @@
+#! python3
+# venv: brg-csd
+# r: compas_masonry
+
+from typing import Union
+
+import Eto.Drawing as drawing  # type: ignore
+import Eto.Forms as forms  # type: ignore
+import Rhino  # type: ignore
+import Rhino.UI  # type: ignore
+from pydantic import BaseModel
+from pydantic import Field
+
+from compas.colors import Color
+from compas_session.settings import Settings
+
+
+def field_ge(field):
+    """Get the 'greater than or equal to' constraint from a Pydantic field.
+
+    Parameters
+    ----------
+    field : ModelField
+        The Pydantic model field.
+
+    Returns
+    -------
+    float or int or None
+        The 'greater than or equal to' constraint if it exists, otherwise None.
+
+    """
+    ge = None
+    for m in field.metadata:
+        if hasattr(m, "ge"):
+            ge = m.ge
+            break
+    return ge
+
+
+def field_le(field):
+    """Get the 'less than or equal to' constraint from a Pydantic field.
+
+    Parameters
+    ----------
+    field : ModelField
+        The Pydantic model field.
+
+    Returns
+    -------
+    float or int or None
+        The 'less than or equal to' constraint if it exists, otherwise None.
+
+    """
+    le = None
+    for m in field.metadata:
+        if hasattr(m, "le"):
+            le = m.le
+            break
+    return le
+
+
+class SettingsForm(forms.Dialog[bool]):
+    """A dynamic form for editing Pydantic models.
+
+    Parameters
+    ----------
+    model_cls : Type[BaseModel]
+        The Pydantic model class to create the form for.
+    width : int, optional
+        The width of the form, by default 400.
+
+    """
+
+    def __init__(self, model: Union[Settings, BaseModel], title: str = "Settings", width: int = 400):
+        super().__init__()
+        self.ClientSize = drawing.Size(width, -1)
+        self.model = model
+        self.model_cls = type(model)
+        self.controls = {}
+        self.Title = title
+
+        self.Content = self._build_layout()
+
+        self.DefaultButton = self.ok_button
+        self.AbortButton = self.cancel_button
+
+    def _build_layout(self):
+        layout = forms.DynamicLayout()
+        layout.Padding = drawing.Padding(10)
+        layout.Spacing = drawing.Size(10, 10)
+
+        for name, field in self.model_cls.model_fields.items():
+            if issubclass(field.annotation, BaseModel):  # type: ignore
+                continue
+
+            text = field.title or name.replace("_", " ").capitalize()
+            label = forms.Label()
+            label.Text = text
+            control = self._create_control(name, field, field.default)
+            self.controls[name] = control
+            layout.AddRow(label, control)
+
+        layout.AddRow(None)
+
+        self.ok_button = forms.Button()
+        self.ok_button.Text = "OK"
+        self.ok_button.Click += self._on_ok
+
+        self.cancel_button = forms.Button()
+        self.cancel_button.Text = "Cancel"
+        self.cancel_button.Click += self._on_cancel
+
+        layout.AddRow(None, self.ok_button, self.cancel_button)
+        return layout
+
+    def _create_control(self, name, field, default):
+        if field.annotation is str:
+            value = getattr(self.model, name, default) or ""
+            control = forms.TextBox()
+            control.Text = value
+
+        elif field.annotation is int:
+            value = getattr(self.model, name, default) or 0
+            control = forms.NumericUpDown()
+            control.Value = value
+            control.MinValue = field_ge(field)
+            control.MaxValue = field_le(field)
+
+        elif field.annotation is float:
+            value = getattr(self.model, name, default) or 0.0
+            control = forms.NumericUpDown()
+            control.Value = value
+            control.DecimalPlaces = 3
+            control.MinValue = field_ge(field)
+            control.MaxValue = field_le(field)
+
+        elif field.annotation is bool:
+            value = getattr(self.model, name, default) or False
+            control = forms.CheckBox()
+            control.Checked = value
+
+        elif (
+            field.annotation is tuple
+            and hasattr(field, "default")
+            and isinstance(field.default, tuple)
+            and len(field.default) == 4
+            and all(isinstance(x, int) for x in field.default)
+        ):
+            value = getattr(self.model, name, default) or (255, 255, 255, 255)
+            color = drawing.Color.FromArgb(*value)
+            control = forms.ColorPicker()
+            control.Value = color
+
+        else:
+            value = getattr(self.model, name, default) or ""
+            control = forms.TextBox()
+            control.Text = str(value)
+
+        return control
+
+    def _on_ok(self, sender, e):
+        values = {}
+        for name, control in self.controls.items():
+            if isinstance(control, forms.TextBox):
+                values[name] = control.Text
+            elif isinstance(control, forms.NumericUpDown):
+                values[name] = control.Value
+            elif isinstance(control, forms.CheckBox):
+                values[name] = control.Checked
+            elif isinstance(control, forms.ColorPicker):
+                c = control.Value
+                values[name] = (c.R, c.G, c.B, c.A)
+        try:
+            for key, value in values.items():
+                setattr(self.model, key, value)
+            self.Close(True)
+        except Exception as ex:
+            forms.MessageBox.Show(str(ex), "Validation Error")
+
+    def _on_cancel(self, sender, e):
+        self.Close(False)
+
+    def show(self):
+        return self.ShowModal(Rhino.UI.RhinoEtoApp.MainWindow)
+
+
+# =============================================================================
+# Run as main
+# =============================================================================
+
+if __name__ == "__main__":
+
+    class TestSettings(BaseModel):
+        name: str = Field("Default", title="Name", description="Enter your name")
+        age: int = Field(30, title="Age", ge=0, le=120)
+        is_active: bool = Field(True, title="Active")
+        color: tuple = Field(Color.white().rgba255, title="Color", description="Pick a color")
+
+    settings = TestSettings(name="Alice", age=28, is_active=True, color=Color.red().rgba255)
+    dialog = SettingsForm(settings)  # type: ignore
+
+    if dialog.ShowModal(Rhino.UI.RhinoEtoApp.MainWindow):
+        print(dialog.model)

compas_masonry/scene/__init__.py

@@ -0,0 +1,13 @@
+from compas.plugins import plugin
+from compas.scene.context import register
+
+from compas_tna.diagrams import FormDiagram
+from .formobject import RhinoFormDiagramObject
+
+# this clashes with TNA and/or RV
+# we need a strategy for this
+
+
+@plugin(category="factories", pluggable_name="register_scene_objects", requires=["Rhino"])
+def register_scene_objects_rhino():
+    register(FormDiagram, RhinoFormDiagramObject, context="Rhino")

compas_masonry/scene/envelopeobject.py

@@ -0,0 +1,94 @@
+from typing import Optional
+
+import scriptcontext as sc  # type: ignore
+
+from compas.colors import Color
+from compas.datastructures import Mesh
+from compas.scene.descriptors.color import ColorAttribute
+from compas_masonry.session import MasonrySession as Session
+from compas_rhino.conversions import transformation_to_rhino
+from compas_rhino.conversions import vertices_and_faces_to_rhino
+from compas_rhino.scene import RhinoSceneObject
+from compas_tna.envelope import Envelope
+
+
+class RhinoEnvelopeObject(RhinoSceneObject):
+    session: Session = Session()
+
+    color = ColorAttribute(default=Color.black())
+
+    def __init__(
+        self,
+        color: Optional[Color] = None,
+        show_intrados=True,
+        show_middle=False,
+        show_extrados=True,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.color = color or self.color
+        self.show_intrados = show_intrados
+        self.show_middle = show_middle
+        self.show_extrados = show_extrados
+
+    @property
+    def settings(self) -> dict:
+        settings = super().settings
+        settings["color"] = self.color
+        settings["show_intrados"] = self.show_intrados
+        settings["show_middle"] = self.show_middle
+        settings["show_extrados"] = self.show_extrados
+        return settings
+
+    @property
+    def envelope(self) -> Envelope:
+        return self.item  # type: ignore
+
+    @envelope.setter
+    def envelope(self, envelope: Envelope) -> None:
+        self._item = envelope
+        self._transformation = None
+
+    def draw(self):
+        self._guids = []
+
+        if self.show_intrados:
+            self.draw_intrados()
+
+        if self.show_middle:
+            self.draw_middle()
+
+        if self.show_extrados:
+            self.draw_extrados()
+
+        return self._guids
+
+    def _draw_mesh(self, mesh: Mesh, name: str) -> None:
+        attr = self.compile_attributes(name=name, color=self.color)
+        vertex_index = mesh.vertex_index()
+        vertices = [mesh.vertex_attributes(vertex, "xyz") for vertex in mesh.vertices()]
+        faces = [[vertex_index[vertex] for vertex in mesh.face_vertices(face)] for face in mesh.faces()]
+        geometry = vertices_and_faces_to_rhino(vertices, faces, color=self.color, disjoint=True)
+        geometry.Transform(transformation_to_rhino(self.worldtransformation))
+        guid = sc.doc.Objects.AddMesh(geometry, attr)
+        if self.group:
+            self.add_to_group(self.group, [guid])
+        return guid
+
+    def draw_intrados(self):
+        if not self.envelope.intrados:  # type: ignore
+            return
+        guid = self._draw_mesh(self.envelope.intrados, name="Intrados")  # type: ignore
+        self._guids.append(guid)
+
+    def draw_middle(self):
+        if not self.envelope.middle:  # type: ignore
+            return
+        guid = self._draw_mesh(self.envelope.middle, name="Middle")  # type: ignore
+        self._guids.append(guid)
+
+    def draw_extrados(self):
+        if not self.envelope.extrados:  # type: ignore
+            return
+        guid = self._draw_mesh(self.envelope.extrados, name="Extrados")  # type: ignore
+        self._guids.append(guid)

compas_masonry/scene/formobject.py

@@ -0,0 +1,509 @@
+from math import sqrt
+from typing import Optional
+
+import rhinoscriptsyntax as rs  # type: ignore
+import scriptcontext as sc  # type: ignore
+
+import compas_rhino.conversions
+from compas.colors import Color
+from compas.geometry import Cylinder
+from compas.geometry import Line
+from compas.geometry import Sphere
+from compas.geometry import Vector
+from compas.scene.descriptors.color import ColorAttribute
+from compas.scene.descriptors.colordict import ColorDictAttribute
+from compas_masonry.session import MasonrySession as Session
+from compas_rui.scene import RUIMeshObject
+from compas_tna.diagrams import FormDiagram
+
+
+class RhinoFormDiagramObject(RUIMeshObject):
+    session: Session = Session()
+
+    vertexcolor = ColorDictAttribute(default=Color.white())
+    edgecolor = ColorDictAttribute(default=Color.black())
+    facecolor = ColorDictAttribute(default=Color.white())
+
+    freecolor = ColorAttribute(default=Color.white())
+    supportcolor = ColorAttribute(default=Color.red())
+    fixedcolor = ColorAttribute(default=Color.cyan())
+
+    residualcolor = ColorAttribute(default=Color.cyan())
+    reactioncolor = ColorAttribute(default=Color.green())
+
+    loadcolor = ColorAttribute(default=Color.green().darkened(50))
+    compressioncolor = ColorAttribute(default=Color.blue())
+    tensioncolor = ColorAttribute(default=Color.red())
+
+    ecrackcolor = ColorAttribute(default=Color.green())
+    icrackcolor = ColorAttribute(default=Color.blue())
+
+    boundscolor = ColorAttribute(default=Color.magenta())
+
+    def __init__(
+        self,
+        disjoint=True,
+        show_vertices=True,
+        show_edges=True,
+        show_faces=False,
+        vertexgroup="RhinoVAULT::FormDiagram::Vertices",
+        edgegroup="RhinoVAULT::FormDiagram::Edges",
+        facegroup="RhinoVAULT::FormDiagram::Faces",
+        layer="RhinoVAULT::FormDiagram",
+        show_supports=True,
+        show_fixed=True,
+        show_free=False,
+        loadgroup="RhinoVAULT::FormDiagram::Loads",
+        forcegroup="RhinoVAULT::FormDiagram::Forces",
+        reactiongroup="RhinoVAULT::FormDiagram::Reactions",
+        residualgroup="RhinoVAULT::FormDiagram::Residuals",
+        crackgroup="RhinoVAULT::FormDiagram::Cracks",
+        boundsgroup="RhinoVAULT::FormDiagram::Bounds",
+        **kwargs,
+    ):
+        super().__init__(
+            disjoint=disjoint,
+            show_vertices=show_vertices,
+            show_edges=show_edges,
+            show_faces=show_faces,
+            vertexgroup=vertexgroup,
+            edgegroup=edgegroup,
+            facegroup=facegroup,
+            layer=layer,
+            **kwargs,
+        )
+
+        self.show_supports = show_supports
+        self.show_fixed = show_fixed
+        self.show_free = show_free
+
+        self.loadgroup = loadgroup
+        self.forcegroup = forcegroup
+        self.reactiongroup = reactiongroup
+        self.residualgroup = residualgroup
+        self.crackgroup = crackgroup
+        self.boundsgroup = boundsgroup
+
+    # =============================================================================
+    # Properties
+    # =============================================================================
+
+    @property
+    def settings(self):
+        settings = super().settings
+        settings["show_supports"] = self.show_supports
+        settings["show_fixed"] = self.show_fixed
+        settings["show_free"] = self.show_free
+        return settings
+
+    @property
+    def diagram(self) -> FormDiagram:
+        return self.mesh  # type: ignore
+
+    @diagram.setter
+    def diagram(self, diagram: FormDiagram) -> None:
+        self.mesh = diagram
+
+    # =============================================================================
+    # Helpers
+    # =============================================================================
+
+    def vertices(self, **kwargs) -> list[int]:
+        return list(self.diagram.vertices())  # type: ignore
+
+    def edges(self, **kwargs) -> list[tuple[int, int]]:
+        return list(self.diagram.edges_where(_is_edge=True))  # type: ignore
+
+    def faces(self, **kwargs) -> list[int]:
+        return list(self.diagram.faces_where(_is_loaded=True))  # type: ignore
+
+    def supports(self) -> list[int]:
+        return list(self.diagram.vertices_where(is_support=True))  # type: ignore
+
+    def vertex_is_support(self, vertex) -> bool:
+        return bool(self.diagram.vertex_attribute(vertex, "is_support"))
+
+    def vertex_is_fixed(self, vertex) -> bool:
+        return bool(self.diagram.vertex_attribute(vertex, "is_fixed"))
+
+    def vertex_residual(self, vertex) -> Vector:
+        return Vector(*self.diagram.vertex_attributes(vertex, ["_rx", "_ry", "_rz"]))  # type: ignore
+
+    def vertex_weight(self, vertex) -> float:
+        weight = 0
+        thickness = self.diagram.vertex_attribute(vertex, "t")
+        if thickness:
+            area = self.diagram.vertex_area(vertex)
+            weight = area * thickness
+        return weight
+
+    def vertex_load(self, vertex) -> Vector:
+        return Vector(*self.diagram.vertex_attributes(vertex, ["px", "py", "pz"]))  # type: ignore
+
+    def vertex_bound(self, vertex) -> Optional[Line]:
+        ub = self.diagram.vertex_attribute(vertex, "ub")
+        lb = self.diagram.vertex_attribute(vertex, "lb")
+        if ub and lb:
+            point = self.diagram.vertex_point(vertex)
+            a = point.copy()
+            a.z = ub
+            b = point.copy()
+            b.z = lb
+            return Line(a, b)
+
+    def vertex_is_on_upper_bound(self, vertex, tol=1e-6) -> bool:
+        ub = self.diagram.vertex_attribute(vertex, "ub")
+        if ub is None:
+            return False
+        point = self.diagram.vertex_point(vertex)
+        return abs(point.z - ub) < tol
+
+    def vertex_is_on_lower_bound(self, vertex, tol=1e-6) -> bool:
+        lb = self.diagram.vertex_attribute(vertex, "lb")
+        if lb is None:
+            return False
+        point = self.diagram.vertex_point(vertex)
+        return abs(point.z - lb) < tol
+
+    def forces(self) -> list[float]:
+        Q = [self.diagram.edge_attribute(edge, "q") or 0.0 for edge in self.edges()]
+        L = [self.diagram.edge_length(edge) or 0.0 for edge in self.edges()]
+        return [q * l for q, l in zip(Q, L)]  # noqa: E741
+
+    def edge_force(self, edge) -> float:
+        q = self.diagram.edge_attribute(edge, "q") or 0.0
+        l = self.diagram.edge_length(edge) or 0.0  # noqa: E741
+        return q * l
+
+    def compute_vertex_color(self, vertex) -> Color:
+        if self.vertex_is_support(vertex):
+            color = self.supportcolor
+        elif self.vertex_is_fixed(vertex):
+            color = self.fixedcolor
+        else:
+            color = self.freecolor
+        return color  # type: ignore
+
+    def compute_visible_vertices(self) -> list[int]:
+        vertices = []
+        if self.show_free:
+            vertices += list(self.diagram.vertices_where(is_support=False, is_fixed=False))
+        if self.show_fixed:
+            vertices += list(self.diagram.vertices_where(is_fixed=True))
+        if self.show_supports:
+            vertices += list(self.diagram.vertices_where(is_support=True))
+        return vertices
+
+    def compute_edge_colors(self, tol=1e-3) -> list[Color]:
+        forces = self.forces()
+        magnitudes = [abs(f) for f in forces]
+        fmin = min(magnitudes)
+        fmax = max(magnitudes)
+
+        colors = []
+
+        if fmax - fmin >= tol:
+            for magnitude in magnitudes:
+                colors.append(Color.from_i((magnitude - fmin) / (fmax - fmin)))
+
+        return colors
+
+    def compute_pipe_colors(self, tol=1e-3) -> dict[tuple[int, int], Color]:
+        edges = self.edges()
+        forces = [self.edge_force(edge) for edge in edges]
+        magnitudes = [abs(f) for f in forces]
+        fmin = min(magnitudes)
+        fmax = max(magnitudes)
+
+        edge_color = {}
+
+        if fmax - fmin >= tol:
+            for edge, force, magnitude in zip(edges, forces, magnitudes):
+                edge_color[edge] = Color.from_i((magnitude - fmin) / (fmax - fmin))
+
+        return edge_color
+
+    # =============================================================================
+    # Names
+    # =============================================================================
+
+    def vertex_load_name(self, vertex) -> str:
+        return f"{self.diagram.name}.vertex.{vertex}.load"
+
+    def vertex_selfweight_name(self, vertex) -> str:
+        return f"{self.diagram.name}.vertex.{vertex}.selfweight"
+
+    def vertex_reaction_name(self, vertex) -> str:
+        return f"{self.diagram.name}.vertex.{vertex}.reaction"
+
+    def vertex_residual_name(self, vertex) -> str:
+        return f"{self.diagram.name}.vertex.{vertex}.residual"
+
+    def vertex_bound_name(self, vertex) -> str:
+        return f"{self.diagram.name}.vertex.{vertex}.bound"
+
+    def vertex_crack_name(self, vertex) -> str:
+        return f"{self.diagram.name}.vertex.{vertex}.crack"
+
+    def edge_pipe_name(self, edge) -> str:
+        return f"{self.diagram.name}.edge.{edge}.pipe"
+
+    # =============================================================================
+    # Clear
+    # =============================================================================
+
+    # =============================================================================
+    # Draw
+    # =============================================================================
+
+    def draw(self):
+        faces = []
+        if self.show_faces:
+            faces += list(self.faces())
+        if faces:
+            self.show_faces = faces
+
+        for vertex in self.vertices():
+            self.vertexcolor[vertex] = self.compute_vertex_color(vertex)
+
+        super().draw()
+
+        if self.session.settings.formdiagram.show_reactions:
+            self.draw_reactions()
+
+        if self.session.settings.formdiagram.show_residuals:
+            self.draw_residuals()
+
+        if self.session.settings.formdiagram.show_pipes:
+            self.draw_pipes()
+
+        if self.session.settings.formdiagram.show_loads:
+            self.draw_loads()
+
+        if self.session.settings.formdiagram.show_bounds:
+            self.draw_bounds()
+
+        if self.session.settings.formdiagram.show_cracks:
+            self.draw_cracks()
+
+        return self.guids
+
+    def draw_vertices(self):
+        if self.show_vertices is True:
+            self.show_vertices = self.compute_visible_vertices()
+
+        for vertex in self.vertices():
+            self.vertexcolor[vertex] = self.compute_vertex_color(vertex)
+
+        return super().draw_vertices()
+
+    def draw_edges(self):
+        if self.show_edges is True:
+            self.show_edges = self.edges()
+
+        return super().draw_edges()
+
+    def draw_faces(self):
+        if self.show_faces:
+            self.show_faces = self.faces()
+
+        return super().draw_faces()
+
+    # =============================================================================
+    # Redraw
+    # =============================================================================
+
+    def redraw_vertices(self):
+        rs.EnableRedraw(False)
+        self.clear_vertices()
+        self.draw_vertices()
+        rs.EnableRedraw(True)
+        rs.Redraw()
+
+    def redraw_edges(self):
+        rs.EnableRedraw(False)
+        self.clear_edges()
+        self.draw_edges()
+        rs.EnableRedraw(True)
+        rs.Redraw()
+
+    def redraw_faces(self):
+        rs.EnableRedraw(False)
+        self.clear_faces()
+        self.draw_faces()
+        rs.EnableRedraw(True)
+        rs.Redraw()
+
+    def redraw(self):
+        rs.EnableRedraw(False)
+        self.clear()
+        self.draw()
+        rs.EnableRedraw(True)
+        rs.Redraw()
+
+    # =============================================================================
+    # Structural
+    # =============================================================================
+
+    def draw_loads(self):
+        guids = []
+        color = self.loadcolor
+        scale = self.session.settings.formdiagram.scale_loads
+        tol = self.session.settings.formdiagram.tol_vectors
+
+        for vertex in self.diagram.vertices_where(is_support=False):
+            load = self.vertex_load(vertex)
+            if load is not None:
+                vector = load * scale
+                if vector.length > tol:
+                    name = self.vertex_load_name(vertex)
+                    attr = self.compile_attributes(name=name, color=color, arrow="end")
+                    point = self.diagram.vertex_point(vertex)
+                    line = Line.from_point_and_vector(point + vector, point)
+                    guid = sc.doc.Objects.AddLine(compas_rhino.conversions.line_to_rhino(line), attr)
+                    guids.append(guid)
+
+        if guids:
+            if self.loadgroup:
+                self.add_to_group(self.loadgroup, guids)
+            elif self.group:
+                self.add_to_group(self.group, guids)
+
+        self._guids += guids
+        return guids
+
+    def draw_pipes(self):
+        guids = []
+        scale = self.session.settings.formdiagram.scale_pipes
+        tol = self.session.settings.formdiagram.tol_pipes
+
+        for edge in self.edges():
+            force = self.edge_force(edge)
+            if force:
+                line = self.diagram.edge_line(edge)
+                radius = sqrt(abs(force)) * scale
+                color = self.compressioncolor
+                if radius > tol:
+                    pipe = Cylinder.from_line_and_radius(line, radius)
+                    name = self.edge_pipe_name(edge)
+                    attr = self.compile_attributes(name=name, color=color)
+                    guid = sc.doc.Objects.AddBrep(compas_rhino.conversions.cylinder_to_rhino_brep(pipe), attr)
+                    guids.append(guid)
+
+        if guids:
+            if self.forcegroup:
+                self.add_to_group(self.forcegroup, guids)
+            elif self.group:
+                self.add_to_group(self.group, guids)
+
+        self._guids += guids
+        return guids
+
+    def draw_reactions(self):
+        guids = []
+        scale = self.session.settings.formdiagram.scale_reactions
+        tol = self.session.settings.formdiagram.tol_vectors
+
+        for vertex in self.supports():
+            residual = self.vertex_residual(vertex)
+            vector = residual * -scale
+            if vector.length > tol:
+                name = self.vertex_reaction_name(vertex)
+                attr = self.compile_attributes(name=name, color=self.reactioncolor, arrow="end")
+                point = self.diagram.vertex_point(vertex)
+                line = Line.from_point_and_vector(point, vector)
+                guid = sc.doc.Objects.AddLine(compas_rhino.conversions.line_to_rhino(line), attr)
+                guids.append(guid)
+
+        if guids:
+            if self.reactiongroup:
+                self.add_to_group(self.reactiongroup, guids)
+            elif self.group:
+                self.add_to_group(self.group, guids)
+
+        self._guids += guids
+        return guids
+
+    def draw_residuals(self):
+        guids = []
+        scale = self.session.settings.formdiagram.scale_residuals
+        tol = self.session.settings.formdiagram.tol_vectors
+
+        for vertex in self.diagram.vertices_where(is_support=False):
+            residual = self.vertex_residual(vertex)
+            vector = residual * scale
+            if vector.length > tol:
+                name = self.vertex_residual_name(vertex)
+                attr = self.compile_attributes(name=name, color=self.residualcolor, arrow="end")
+                point = self.diagram.vertex_point(vertex)
+                line = Line.from_point_and_vector(point, vector)
+                guid = sc.doc.Objects.AddLine(compas_rhino.conversions.line_to_rhino(line), attr)
+                guids.append(guid)
+
+        if guids:
+            if self.residualgroup:
+                self.add_to_group(self.residualgroup, guids)
+            elif self.group:
+                self.add_to_group(self.group, guids)
+
+        self._guids += guids
+        return guids
+
+    # =============================================================================
+    # Envelope
+    # =============================================================================
+
+    def draw_bounds(self):
+        guids = []
+
+        for vertex in self.vertices():
+            bound = self.vertex_bound(vertex)
+            if bound:
+                name = self.vertex_bound_name(vertex)
+                attr = self.compile_attributes(name=name, color=self.boundscolor)
+
+                guid = sc.doc.Objects.AddLine(compas_rhino.conversions.line_to_rhino(bound), attr)
+                guids.append(guid)
+
+                guid = sc.doc.Objects.AddPoint(compas_rhino.conversions.point_to_rhino(bound.start), attr)
+                guids.append(guid)
+
+                guid = sc.doc.Objects.AddPoint(compas_rhino.conversions.point_to_rhino(bound.end), attr)
+                guids.append(guid)
+
+        if guids:
+            if self.boundsgroup:
+                self.add_to_group(self.boundsgroup, guids)
+            elif self.group:
+                self.add_to_group(self.group, guids)
+
+        self._guids += guids
+        return guids
+
+    def draw_cracks(self):
+        guids = []
+
+        for vertex in self.vertices():
+            if self.vertex_is_on_lower_bound(vertex):
+                name = self.vertex_crack_name(vertex)
+                attr = self.compile_attributes(name=name, color=self.icrackcolor)
+            elif self.vertex_is_on_upper_bound(vertex):
+                name = self.vertex_crack_name(vertex)
+                attr = self.compile_attributes(name=name, color=self.ecrackcolor)
+            else:
+                continue
+
+            point = self.diagram.vertex_point(vertex)
+            radius = self.session.settings.formdiagram.crack_radius
+            sphere = Sphere(radius, point=point)
+            guid = sc.doc.Objects.AddSphere(compas_rhino.conversions.sphere_to_rhino(sphere), attr)
+            guids.append(guid)
+
+        if guids:
+            if self.crackgroup:
+                self.add_to_group(self.crackgroup, guids)
+            elif self.group:
+                self.add_to_group(self.group, guids)
+
+        self._guids += guids
+        return guids

compas_masonry/session.py

@@ -0,0 +1,10 @@
+from compas_session.lazyload import LazyLoadSession
+
+from .settings import MasonrySettings
+
+
+class MasonrySession(LazyLoadSession):
+    settingsclass = MasonrySettings
+    settings: MasonrySettings  # type: ignore
+
+    # set a fail message

compas_masonry/settings.py

@@ -0,0 +1,53 @@
+from pydantic import BaseModel
+from pydantic import Field
+
+from compas_session.settings import Settings
+
+
+class FormDiagramSettings(BaseModel):
+    show_reactions: bool = Field(default=True, title="Show Reactions")
+    show_residuals: bool = Field(default=False, title="Show Residuals")
+    show_pipes: bool = Field(default=False, title="Show Pipes")
+    show_loads: bool = Field(default=False, title="Show Loads")
+    show_bounds: bool = Field(default=False, title="Show Bounds")
+    show_cracks: bool = Field(default=False, title="Show Cracks")
+
+    scale_reactions: float = Field(default=0.01, ge=1e-6, le=1e3, title="Scale Reactions")
+    scale_residuals: float = Field(default=1.0, ge=1e-6, le=1e3, title="Scale Residuals")
+    scale_pipes: float = Field(default=0.01, ge=1e-6, le=1e3, title="Scale Pipes")
+    scale_loads: float = Field(default=1.0, ge=1e-6, le=1e3, title="Scale Loads")
+
+    tol_vectors: float = Field(default=1e-3, ge=1e-6, le=1e3, title="Tolerance Vectors")
+    tol_pipes: float = Field(default=1e-2, ge=1e-6, le=1e3, title="Tolerance Pipes")
+
+    crack_radius: float = Field(default=0.1, ge=0.01, le=100, title="Crack Radius")
+
+
+class EnvelopeSettings(BaseModel):
+    show_intrados: bool = Field(default=True, title="Show Intrados")
+    show_middle: bool = Field(default=False, title="Show Middle")
+    show_extrados: bool = Field(default=True, title="Show Extrados")
+
+
+class BlockModelSettings(BaseModel):
+    tol_contacts: float = Field(default=1e-3, ge=1e-6, le=1e3, title="Tolerance Contacts")
+    amin_contacts: float = Field(default=1e-2, ge=1e-6, le=90, title="Minimum Angle Contacts")
+
+    show_blocks: bool = Field(default=True, title="Show Blocks")
+    show_supports: bool = Field(default=True, title="Show Supports")
+    show_contacts: bool = Field(default=False, title="Show Contacts")
+    show_interactions: bool = Field(default=False, title="Show Interactions")
+    show_selfweight: bool = Field(default=False, title="Show Selfweight")
+    show_reactions: bool = Field(default=False, title="Show Reactions")
+
+    scale_selfweight: float = Field(default=1.0, ge=1e-6, le=1e3, title="Scale Selfweight")
+    scale_reactions: float = Field(default=0.01, ge=1e-6, le=1e3, title="Scale Reactions")
+
+
+class MasonrySettings(Settings):
+    autoupdate: bool = Field(default=True, title="Auto Update")
+    autosave: bool = Field(default=False, title="Auto Save")
+
+    formdiagram: FormDiagramSettings = FormDiagramSettings()
+    envelope: EnvelopeSettings = EnvelopeSettings()
+    blockmodel: BlockModelSettings = BlockModelSettings()

compas_masonry/splash.py

@@ -0,0 +1,44 @@
+#! python3
+# venv: brg-csd
+# r: compas_masonry
+
+import pathlib
+
+import Eto.Drawing  # type: ignore
+import Eto.Forms  # type: ignore
+import Rhino  # type: ignore
+import Rhino.UI  # type: ignore
+import System  # type: ignore
+
+pluginfile = Rhino.PlugIns.PlugIn.PathFromId(System.Guid("4384e04f-2997-429b-b3fc-53e7fe78703e"))
+shared = pathlib.Path(str(pluginfile)).parent / "shared"
+
+
+class SplashForm(Eto.Forms.Dialog[bool]):
+    def __init__(self, title, url, width=800, height=450):
+        super().__init__()
+
+        self.Title = title
+        self.Padding = Eto.Drawing.Padding(0)
+        self.Resizable = False
+        self.ClientSize = Eto.Drawing.Size(width, height)
+        self.WindowStyle = Eto.Forms.WindowStyle.NONE  # type: ignore
+
+        webview = Eto.Forms.WebView()
+        webview.Size = Eto.Drawing.Size(width, height)
+        webview.Url = System.Uri(url)
+        webview.BrowserContextMenuEnabled = False
+        webview.DocumentLoading += self.action
+
+        layout = Eto.Forms.DynamicLayout()
+        layout.BeginVertical()
+        layout.AddRow(webview)
+        layout.EndVertical()
+        self.Content = layout
+
+    def action(self, sender, e):
+        if e.Uri.Scheme == "action" and e.Uri.Host == "close":
+            self.Close()
+
+    def show(self):
+        return self.ShowModal(Rhino.UI.RhinoEtoApp.MainWindow)

compas_masonry-0.2.1.dist-info/METADATA

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: compas_masonry
+Version: 0.2.1
+Summary: COMPAS Masonry is a masonry assessment toolbox for Rhino based on the COMPAS framework.
+Author-email: tom van mele <tom.v.mele@gmail.com>
+License: MIT License
+        
+        ETH Zurich - Block Research Group
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://blockresearchgroup.github.io/compas_masonry
+Project-URL: Documentation, https://blockresearchgroup.github.io/compas_masonry
+Project-URL: Repository, https://github.com/blockresearchgroup/compas_masonry
+Project-URL: Changelog, https://github.com/blockresearchgroup/compas_masonry/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/blockresearchgroup/compas_masonry/issues
+Project-URL: Forum, https://forum.compas-framework.org/
+Classifier: Development Status :: 4 - Beta
+Classifier: Topic :: Scientific/Engineering
+Classifier: Operating System :: Unix
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cvxpy
+Requires-Dist: compas>=2.14.1
+Requires-Dist: compas_cgal>=0.9.1
+Requires-Dist: compas_dem>=0.4
+Requires-Dist: compas_libigl>=0.7.6
+Requires-Dist: compas_rui>=0.6
+Requires-Dist: compas_session>=0.7
+Requires-Dist: compas_tna>=0.7
+Requires-Dist: compas_tno>=0.3
+Provides-Extra: dev
+Requires-Dist: bump-my-version; extra == "dev"
+Requires-Dist: compas_invocations2; extra == "dev"
+Requires-Dist: invoke>=0.14; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: sphinx_compas2_theme; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: wheel; extra == "dev"
+Dynamic: license-file
+
+# COMPAS Masonry
+
+> [!WARNING]
+> This plugin is under active development,
+> and its functionality will frequently change.
+
+![COMPAS Masonry](compas-Masonry.png)
+
+COMPAS Masonry is a plugin for Rhino for the assessment of masonry structures,
+and for the stability analsis of Discrete Element Models in general.
+
+The current version of this plugin is based on COMPAS 2 and is available for Rhino 8.
+
+## Installation
+
+To install COMPAS-Masonry, use Rhino's package manager Yak.
+To open Yak, type `PackageManager` on the Rhino command line.
+
+![COMPAS-Masonry installation with Yak](/gitbook/.gitbook/assets/COMPAS-Masonry_yak.png)
+
+## COMPAS Packages
+
+COMPAS-Masonry uses the following COMPAS packages:
+
+* [compas](https://github.com/compas-dev/compas)
+* [compas_assembly](https://github.com/blockresearchgroup/compas_assembly)
+* [compas_model](https://github.com/blockresearchgroup/compas_model)
+* [compas_rui](https://github.com/blockresearchgroup/compas_rui)
+* [compas_session](https://github.com/blockresearchgroup/compas_session)
+
+After installing RhinoVAULT with Yak, these requirements will be installed automatically if necessary.
+The tool might be unresponsive during this process, which might take up to 1 or 2 mins.
+The packages are installed in a separate virtual environment named `COMPAS-Masonry`.
+
+> [!NOTE]
+> Note that COMPAS-Masonry currently doesn't include any solvers
+> (such as [compas_cra](https://github.com/blockresearchgroup/compas_cra)) yet.
+> This is because they have dependencies that are still difficult to install in Rhino.
+
+## User Interface
+
+COMPAS-Masonry defines the following Rhino commands:
+
+* `Masonry`
+* `Masonry_session_undo`
+* `Masonry_session_redo`
+* `Masonry_session_open`
+* `Masonry_session_save`
+* `Masonry_scene_clear`
+* `Masonry_scene_redraw`
+* `Masonry_settings`
+
+These commands can be executed using the Rhino command line (simply start typing the command name),
+or with the corresponding buttons of the COMPAS-Masonry toolbar.
+
+![COMPAS-Masonry toolbar](/gitbook/.gitbook/assets/COMPAS-Masonry_toolbar.png)
+
+If the toolbar is not visible after installing COMPAS-Masonry,
+you can load it from the "Toolbars" page.
+To open the "Toolbars" page, type `Toolbar` on the Rhino command line...
+
+![Rhino Toolbars](/gitbook/.gitbook/assets/Rhino_toolbars.png)
+
+## Documentation
+
+For further "getting started" instructions, a tutorial, examples, and an detailed description of the individual commands and the user interface, please check out the online documentation here: [COMPAS-Masonry Gitbook](https://blockresearchgroup.gitbook.io/COMPAS-Masonry)
+
+## Issues
+
+Please report problems using the issue tracker of the github repo: <https://github.com/blockresearchgroup/compas-Masonry/issues>

compas_masonry-0.2.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+compas_masonry/__init__.py,sha256=6rlt9_Slk91nZSCwRLS2Fq-S-jeMbC69Mo8xhW-JG-A,66
+compas_masonry/__main__.py,sha256=-GqoftNECZBtC8F82KWJrdSD05BcKBrrL0ElHEEUHyk,36
+compas_masonry/session.py,sha256=qTzZTLZA2pnLPvYeLPxefwlCgp8dhn4JAiL9prF3Sbo,240
+compas_masonry/settings.py,sha256=RRVsZ4ZgV6Sinr2tHQ5FeV5IIqK7S1hwW7aDgsFWiFs,2565
+compas_masonry/splash.py,sha256=rQSOXMcHguoAT7eqRN_edO0ctN0i95tzYX7PgLKJWT4,1342
+compas_masonry/forms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+compas_masonry/forms/settings.py,sha256=m6tgvhYnOF-Nv-GvfDlCmThC7Yf0FMsXpBp2c6mRJPM,6288
+compas_masonry/scene/__init__.py,sha256=5mfXQp2zkLD45WN69RzDs0aHunMmTwbBQiz4cF9VvvM,429
+compas_masonry/scene/envelopeobject.py,sha256=bGsuB8NEm4KoMDtqneE5XcmjUX9BqaBNvISVow7qA8A,3146
+compas_masonry/scene/formobject.py,sha256=_Jf58QRI3liGv6T3fmTDEb_sp3cd1E3UrVu-B2BfgjI,18164
+compas_masonry-0.2.1.dist-info/licenses/LICENSE,sha256=wLowriMQkZN59QuARxuHKSyxeWroT2yQwAHRItCs2yM,1071
+compas_masonry-0.2.1.dist-info/METADATA,sha256=SrNN11LtEDWuOZe8ozd5gl7PDIqIqT7hRFzfOrWVHDU,5822
+compas_masonry-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+compas_masonry-0.2.1.dist-info/top_level.txt,sha256=iQC5Th2Uypnt4aDzfH4p37BbV1mL-okJfjoHZKz_3do,15
+compas_masonry-0.2.1.dist-info/RECORD,,

compas_masonry-0.2.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

compas_masonry-0.2.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+ETH Zurich - Block Research Group
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

compas_masonry-0.2.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+compas_masonry