Merge remote-tracking branch 'origin/main'

Author: tomvanmele

CHANGELOG.md

@@ -9,8 +9,46 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+* Added comprehensive form diagram creation methods to `FormDiagram` class:
+  * `create_cross()` - Creates cross discretisation with orthogonal arrangement and quad diagonals
+  * `create_fan()` - Creates fan discretisation with straight lines to corners
+  * `create_parametric_fan()` - Creates parametric fan diagrams with lambda parameter control
+  * `create_cross_with_diagonal()` - Creates cross discretisation with diagonal lines
+  * `create_ortho()` - Creates orthogonal discretisation
+  * `create_circular_radial()` - Creates circular radial form diagrams with equally spaced hoops
+  * `create_circular_radial_spaced()` - Creates circular radial form diagrams with hemispheric spacing
+  * `create_circular_spiral()` - Creates circular spiral form diagrams
+  * `create_arch()` - Creates arch form diagrams with semicircular projection
+  * `create_arch_equally_spaced()` - Creates arch form diagrams with equally spaced nodes
+* Added support assignment methods:
+  * `assign_support_type()` - Assigns supports based on type ("corners" or "all")
+* Added corner detection functionality:
+  * `corner_vertices()` - Identifies corner vertices on boundary with configurable angle threshold
+* Added comprehensive mesh creation functions in `diagram_rectangular.py`:
+  * `create_cross_mesh()` - Creates cross pattern meshes
+  * `create_fan_mesh()` - Creates fan pattern meshes
+  * `create_parametric_fan_mesh()` - Creates parametric fan meshes with lambda interpolation
+  * `create_cross_with_diagonal_mesh()` - Creates cross meshes with diagonals
+  * `create_ortho_mesh()` - Creates orthogonal grid meshes
+* Added circular mesh creation functions in `diagram_circular.py`:
+  * `create_circular_radial_mesh()` - Creates circular radial meshes
+  * `create_circular_radial_spaced_mesh()` - Creates hemispherically spaced circular meshes
+  * `create_circular_spiral_mesh()` - Creates circular spiral meshes
+* Added arch mesh creation functions in `diagram_arch.py`:
+  * `create_arch_linear_mesh()` - Creates arch meshes with semicircular projection
+  * `create_arch_linear_equally_spaced_mesh()` - Creates arch meshes with equally spaced nodes
+
 ### Changed
 
+* Refactored parameter passing from `xy_span=[[x0, x1], [y0, y1]]` to `x_span=(x0, x1), y_span=(y0, y1)` for better API consistency
+* Changed `center` parameter from list to tuple in circular diagram functions for immutability and consistency
+* Updated function signatures to use single-line format for Black compatibility
+* Improved code formatting and linting across all diagram generation files
+* Fixed various spelling errors and documentation formatting issues
+* Renamed `create_delta_form()` to `create_cross_with_diagonal()` for better clarity
+* Updated support assignment to use `is_support` attribute instead of deprecated `is_fixed`
+* Removed deprecated `form.parameters` usage from all form creation methods
+
 ### Removed
 
 

src/compas_tna/diagrams/diagram.py

@@ -1,5 +1,37 @@
 from compas.datastructures import Mesh
+from compas.geometry import angle_vectors
 
 
 class Diagram(Mesh):
     """Base diagram implementing attributes shared between the form and force diagram."""
+
+    def corner_vertices(self, tol=160):
+        """Identify the corner vertices on the boundary.
+
+        Parameters
+        ----------
+        tol : float, optional
+            The threshold value for the angle in degrees formed between two edges
+            at a vertex on the boundary for it to be considered a corner.
+            Vertices with smaller angles than the threshold are considered a corner.
+
+        Returns
+        -------
+        vertices : list[int]
+            The list of vertices filtered as corners.
+
+        """
+        vertices = []
+        for vertex in self.vertices_on_boundary():
+            if self.vertex_degree(vertex) == 2:
+                vertices.append(vertex)
+            else:
+                nbrs = []
+                for nbr in self.vertex_neighbors(vertex):
+                    if self.is_edge_on_boundary((vertex, nbr)):
+                        nbrs.append(nbr)
+                u = self.edge_vector((vertex, nbrs[0]))
+                v = self.edge_vector((vertex, nbrs[1]))
+                if angle_vectors(u, v, deg=True) < tol:
+                    vertices.append(vertex)
+        return vertices

src/compas_tna/diagrams/diagram_arch.py

@@ -0,0 +1,91 @@
+import math
+
+from compas.datastructures import Mesh
+
+
+def create_arch_linear_mesh(H: float = 1.0, L: float = 2.0, x0: float = 0.0, n: int = 100) -> Mesh:
+    """Construct a Mesh based on an arch linear discretisation.
+    Note: The nodes of the mesh are spaced following a projection in a semicircular arch.
+
+    Parameters
+    ----------
+    H : float, optional
+        Height of the arch, by default 1.0
+    L : float, optional
+        Span of the arch, by default 2.0
+    x0 : float, optional
+        Initial coordinate of the arch, by default 0.0
+    n : int, optional
+        Numbers of nodes to be considered in the mesh, by default 100
+
+    Returns
+    -------
+    mesh : Mesh
+        The Mesh created.
+
+    """
+    if n < 2:
+        raise ValueError("n must be at least 2 to create a valid mesh")
+    if H <= 0 or L <= 0:
+        raise ValueError("Height (H) and length (L) must be positive values")
+    if L < 2 * H:
+        raise ValueError("Length (L) must be greater than 2 * Height (H)")
+
+    # Add option for starting from Hi and Li for a given thk.
+    radius = H / 2 + (L**2 / (8 * H))
+    spr = math.atan2((L / 2), (radius - H))
+    tot_angle = 2 * spr
+    angle_init = (math.pi - tot_angle) / 2
+    an = tot_angle / (n - 1)
+
+    lines = []
+
+    for i in range(n - 1):
+        angle_i = angle_init + i * an
+        angle_f = angle_init + (i + 1) * an
+        xi = L / 2 - radius * math.cos(angle_i) + x0
+        xf = L / 2 - radius * math.cos(angle_f) + x0
+
+        lines.append([[xi, 0.0, 0.0], [xf, 0.0, 0.0]])
+
+    mesh = Mesh.from_lines(lines)
+
+    return mesh
+
+
+def create_arch_linear_equally_spaced_mesh(L: float = 2.0, x0: float = 0.0, n: int = 100) -> Mesh:
+    """Construct a Mesh based on an arch linear discretisation with equally spaced nodes.
+
+    Parameters
+    ----------
+    L : float, optional
+        Span of the arch, by default 2.0
+    x0 : float, optional
+        Initial coordinate of the arch, by default 0.0
+    n : int, optional
+        Numbers of nodes to be considered in the mesh, by default 100
+
+    Returns
+    -------
+    mesh : Mesh
+        The Mesh created.
+
+    """
+    if n < 2:
+        raise ValueError("n must be at least 2 to create a valid mesh")
+    if L <= 0:
+        raise ValueError("Length (L) must be a positive value")
+
+    # Equally spaced coordinates
+    x = [x0 + i * L / (n - 1) for i in range(n)]
+    lines = []
+
+    for i in range(n - 1):
+        xi = x[i]
+        xf = x[i + 1]
+
+        lines.append([[xi, 0.0, 0.0], [xf, 0.0, 0.0]])
+
+    mesh = Mesh.from_lines(lines)
+
+    return mesh