simgeometry 0.1.0__py3-none-any.whl

simgeometry/shapes.py

@@ -0,0 +1,402 @@
+"""Shapes helpers for geometry, grids, and simulation domains."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
+
+import cunumpy as xp
+import numpy as np
+
+from simgeometry._types import Array
+from simgeometry.api import GeometryAPI
+from simgeometry.boundingbox import BoundingBox
+from simgeometry.grid import Grid
+
+if TYPE_CHECKING:
+    from simgeometry.panels import Panels
+
+
+def _component_major(points: Array, ndim: int) -> Array:
+    """Return ``points`` as a ``(ndim, n)`` float array, checking its layout."""
+    points = xp.asarray(points, dtype=float)
+    if points.ndim != 2 or points.shape[0] != ndim:
+        raise ValueError(f"Expected points with shape ({ndim}, n), got {points.shape}")
+    return points
+
+
+def _signed_area(loop: np.ndarray) -> float:
+    """Shoelace area of a ``(2, n)`` loop: positive when counter-clockwise."""
+    x, y = loop
+    return 0.5 * float(np.sum(x * np.roll(y, -1) - np.roll(x, -1) * y))
+
+
+#: A spacing: a length, or a function of ``(2, m)`` points returning ``(m,)`` lengths.
+Spacing = float | Callable[[np.ndarray], np.ndarray]
+
+
+def _pieces(length: float, max_spacing: float) -> int:
+    """Number of equal pieces that keeps each one at most ``max_spacing`` long.
+
+    The tolerance keeps ``length / (length / n)`` from rounding up to ``n + 1``.
+    """
+    return max(1, int(np.ceil(length / max_spacing * (1 - 1e-12))))
+
+
+def _distribute(
+    curve: Callable[[np.ndarray], np.ndarray],
+    length: float,
+    max_spacing: Spacing,
+    *,
+    min_points: int = 1,
+    samples: int = 256,
+) -> np.ndarray:
+    """Parameters in ``[0, 1)`` of points along ``curve`` at about ``max_spacing`` apart.
+
+    ``curve`` maps parameters ``(m,)`` in ``[0, 1]`` to ``(2, m)`` points at uniform
+    arc length, ``length`` long in total. A constant spacing gives equal pieces of at most
+    that length; a callable one places points at equal steps of the integral of
+    ``1 / spacing`` along the curve, sampled at ``samples`` intervals.
+    """
+    if not callable(max_spacing):
+        n = max(min_points, _pieces(length, max_spacing))
+        return np.arange(n) / n
+    t = np.linspace(0.0, 1.0, samples + 1)
+    spacing = np.broadcast_to(np.asarray(max_spacing(curve(t)), dtype=float), t.shape)
+    if not np.all(spacing > 0):
+        raise ValueError("max_spacing must be positive")
+    density = length / spacing
+    cumulative = np.concatenate(
+        ([0.0], np.cumsum(0.5 * (density[1:] + density[:-1]) * np.diff(t)))
+    )
+    n = max(min_points, _pieces(cumulative[-1], 1.0))
+    return np.interp(np.arange(n) / n * cumulative[-1], cumulative, t)
+
+
+def _refine_loop(
+    loop: np.ndarray, max_spacing: Spacing, *, closed: bool = True
+) -> np.ndarray:
+    """Split each edge of a ``(2, n)`` loop into pieces of about ``max_spacing``.
+
+    A closed loop also has the edge from its last vertex back to its first; an open
+    one (a polyline) keeps its last vertex.
+    """
+    ends = np.roll(loop, -1, axis=1) if closed else loop[:, 1:]
+    pieces = []
+    for a, b in zip(loop.T, ends.T):
+        length = float(np.hypot(*(b - a)))
+        a, b = a[:, None], b[:, None]
+        t = _distribute(lambda t: a + t * (b - a), length, max_spacing)
+        pieces.append(a + t * (b - a))
+    if not closed:
+        pieces.append(loop[:, -1:])
+    return np.concatenate(pieces, axis=1)
+
+
+class Shape(GeometryAPI, ABC):
+    """Define the base interface for geometric shapes.
+
+    A shape created with ``inverted=True`` covers everything *except* its
+    geometry (e.g. a chamber wall around a circular cavity): ``contains`` is
+    negated and the shape extends over the whole simulation domain.  The
+    bounding box still describes the geometry itself, so consumers must not
+    use it to skip points for inverted shapes.
+    """
+
+    _inverted: bool = False
+
+    def __init__(
+        self,
+        ndim: int,
+        lower_bound: tuple[float, ...],
+        upper_bound: tuple[float, ...],
+    ) -> None:
+        """
+        Initialize a shape.
+
+        Parameters:
+        ndim (int): Number of dimensions.
+        bounds (list of tuples): List of tuples specifying min and max for each dimension.
+        """
+        assert isinstance(ndim, int) and ndim > 0, "ndim must be a positive integer."
+        assert ndim in [1, 2, 3]
+        self.ndim = ndim
+        self.set_bounding_box(lower_bound, upper_bound)
+
+    def set_bounding_box(
+        self,
+        lower_bound: tuple[float, ...],
+        upper_bound: tuple[float, ...],
+    ) -> None:
+        """Set the bounding box for the shape."""
+        self._bounding_box = BoundingBox(
+            lower_bound=lower_bound,
+            upper_bound=upper_bound,
+        )
+        assert self.ndim == self.bounding_box.ndim
+
+    @abstractmethod
+    def contains(self, coords: tuple[float, ...]) -> bool:
+        """
+        Check if the given coordinates are inside the shape.
+
+        Parameters:
+        coords (list or tuple): Coordinates for each dimension.
+
+        Returns:
+        bool: True if the coordinates are inside the shape, False otherwise.
+        """
+
+    def contains_points(self, points: Array) -> Array:
+        """Return a mask of the ``(ndim, n)`` points inside the shape.
+
+        The default calls :meth:`contains` point by point; shapes override it with a
+        vectorised test.
+        """
+        points = _component_major(points, self.ndim)
+        return xp.asarray([bool(self.contains(p)) for p in points.T], dtype=bool)
+
+    def node_mask(self, grid: Grid) -> np.ndarray:
+        """Return a host boolean array of the grid's shape, set at the nodes inside.
+
+        One vectorised :meth:`contains_points` over :meth:`Grid.node_points`, so
+        the cost is that of a few array passes over the grid.
+        """
+        inside = self.contains_points(grid.node_points())
+        shape = tuple(int(n) for n in grid.num_gridpoints)
+        return np.asarray(xp.to_numpy(inside), dtype=bool).reshape(shape)
+
+    def get_indices_in_object(self, grid: Grid) -> list[int] | list[tuple[int, ...]]:
+        """
+        Get the indices of grid points that are inside the shape.
+
+        Parameters:
+        grid (object): Grid object containing indices and cell sizes.
+
+        Returns:
+        list: The :attr:`Grid.indices` of the nodes inside, in their order.
+        """
+        if hasattr(grid, "indices_from_mask"):
+            return grid.indices_from_mask(self.node_mask(grid))
+        # any object with ``indices`` and ``node_coordinates`` (e.g. a few nodes)
+        indices = list(grid.indices)
+        if not indices:
+            return []
+        points = np.stack(
+            [np.atleast_1d(grid.node_coordinates(index)) for index in indices], axis=1
+        )
+        inside = np.asarray(xp.to_numpy(self.contains_points(points)), dtype=bool)
+        return [index for index, keep in zip(indices, inside) if keep]
+
+    def get_bound_vertices(self, slice_axis: int) -> xp.ndarray:
+        """Return vertices that bound the shape."""
+        b0 = self.lower_bound
+        b1 = self.upper_bound
+        # print(b0, b1)
+        axis1 = (slice_axis + 1) % 3
+        axis2 = (slice_axis + 2) % 3
+        bound_vertices = xp.array(
+            [
+                [b0[axis1], b0[axis2]],
+                [b1[axis1], b0[axis2]],
+                [b1[axis1], b1[axis2]],
+                [b0[axis1], b1[axis2]],
+            ],
+        )
+        return bound_vertices
+
+    @property
+    def inverted(self) -> bool:
+        """Return whether this object represents an inverted region."""
+        return self._inverted
+
+    def _apply_inversion(self, inside: bool) -> bool:
+        """Return ``inside`` for the geometry, negated for an inverted shape."""
+        return (not inside) if self.inverted else bool(inside)
+
+    @property
+    def bounding_box(self) -> BoundingBox:
+        """Return the bounding box."""
+        return self._bounding_box
+
+    @property
+    def lower_bound(self) -> tuple[float, ...]:
+        """Return the lower coordinate bounds."""
+        return self.bounding_box.lower_bound
+
+    @property
+    def upper_bound(self) -> tuple[float, ...]:
+        """Return the upper coordinate bounds."""
+        return self.bounding_box.upper_bound
+
+
+class Shape1D(Shape):
+    """Represent a one-dimensional shape."""
+
+    def __init__(
+        self,
+        lower_bound: tuple[float, float],
+        upper_bound: tuple[float, float],
+    ) -> None:
+        """
+        Initialize a 1D shape.
+
+        Parameters:
+        bounds (list of tuples): List of tuples specifying min and max for each dimension.
+        """
+        super().__init__(ndim=1, lower_bound=lower_bound, upper_bound=upper_bound)
+
+    @abstractmethod
+    def get_vertices(self) -> list[list[float]]:
+        """
+        Get the vertices of the 1D shape.
+
+        Returns:
+        list: List of vertices as [x] coordinates.
+        """
+
+    @abstractmethod
+    def contains(self, coords: float) -> bool:
+        """
+        Check if the given coordinates are inside the shape.
+
+        Parameters:
+        coords (float): Coordinates for each dimension.
+
+        Returns:
+        bool: True if the coordinates are inside the shape, False otherwise.
+        """
+
+
+class Shape2D(Shape):
+    """Represent a two-dimensional shape.
+
+    ``exact_outline`` is True for shapes whose :meth:`outlines` are their exact
+    boundary (polygons), False for curved ones. ``closed`` is False for open curves
+    (:class:`~simgeometry.Polyline`), which enclose no area.
+    """
+
+    exact_outline: bool = False
+    closed: bool = True
+
+    def __init__(
+        self,
+        lower_bound: tuple[float, float],
+        upper_bound: tuple[float, float],
+    ) -> None:
+        """
+        Initialize a 2D shape.
+
+        Parameters:
+        bounds (list of tuples): List of tuples specifying min and max for each dimension.
+        """
+        super().__init__(ndim=2, lower_bound=lower_bound, upper_bound=upper_bound)
+
+    @abstractmethod
+    def contains(self, coords: tuple[float, float]) -> bool:
+        """
+        Check if the given coordinates are inside the shape.
+
+        Parameters:
+        coords (tuple): Coordinates for each dimension.
+
+        Returns:
+        bool: True if the coordinates are inside the shape, False otherwise.
+        """
+
+    def outlines(self, max_spacing: Spacing | None = None) -> list[np.ndarray]:
+        """Return the boundary loops of the shape as ``(2, n)`` host arrays.
+
+        Each loop is counter-clockwise, without repeating its first vertex. A shape
+        made of several pieces (such as :class:`~simgeometry.Aperture2D`'s two
+        plates) has one loop per piece. An open curve (``closed`` is False) gives
+        its polyline instead, from its first vertex to its last. With
+        ``max_spacing``, edges longer than it are split evenly so that no two
+        consecutive vertices are further apart; curved shapes then place every
+        vertex on the curve. ``max_spacing`` may also be a function of ``(2, m)``
+        points returning ``(m,)`` spacings, to grade the vertices (finer near a
+        corner, say); the spacing then holds approximately. Inversion does not
+        change the outline.
+        """
+        if (
+            max_spacing is not None
+            and not callable(max_spacing)
+            and not max_spacing > 0
+        ):
+            raise ValueError("max_spacing must be positive")
+        loops = self._outline_loops(max_spacing)
+        if not self.closed:
+            return loops
+        return [loop[:, ::-1] if _signed_area(loop) < 0.0 else loop for loop in loops]
+
+    def boundary_panels(self, max_spacing: Spacing | None = None) -> Panels:
+        """The edges of :meth:`outlines` as panels, for boundary-element solvers.
+
+        See :class:`~simgeometry.panels.Panels` for the arrays and the normal
+        convention.
+        """
+        from simgeometry.panels import boundary_panels
+
+        return boundary_panels(self, max_spacing)
+
+    def _corner_loops(self) -> list[np.ndarray]:
+        """The unrefined ``(2, n)`` boundary loops; polygonal shapes define this."""
+        raise NotImplementedError(f"{type(self).__name__} has no outline")
+
+    def _outline_loops(self, max_spacing: Spacing | None) -> list[np.ndarray]:
+        """The loops of :meth:`_corner_loops`, refined; curved shapes override this."""
+        loops = self._corner_loops()
+        if max_spacing is None:
+            return loops
+        return [_refine_loop(loop, max_spacing, closed=self.closed) for loop in loops]
+
+    def plot(self, ax: Any = None, **kwargs: Any) -> Any:
+        """Draw the shape as filled polygons into ``ax`` and return the axes.
+
+        Keyword arguments style the polygons (``facecolor``, ``alpha``, ...).
+        """
+        if any(
+            key in kwargs
+            for key in ("x", "y", "z", "grid", "nodes", "normals", "resolution")
+        ):
+            return self.show(ax=ax, display=False, **kwargs)
+        from simgeometry.plotting import draw_shape
+
+        return draw_shape(self, ax=ax, **kwargs)
+
+
+class Shape3D(Shape):
+    """Represent a three-dimensional shape."""
+
+    def __init__(
+        self,
+        lower_bound: tuple[float, float, float],
+        upper_bound: tuple[float, float, float],
+    ) -> None:
+        """
+        Initialize a 3D shape.
+
+        Parameters:
+        bounds (list of tuples): List of tuples specifying min and max for each dimension.
+        """
+
+        super().__init__(ndim=3, lower_bound=lower_bound, upper_bound=upper_bound)
+
+    @abstractmethod
+    def volume(self) -> float:
+        """
+        Calculate the volume of the 3D shape.
+
+        Returns:
+        float: Volume of the shape.
+        """
+
+    @abstractmethod
+    def surface_area(self) -> float:
+        """
+        Calculate the surface area of the 3D shape.
+
+        Returns:
+        float: Surface area of the shape.
+        """

simgeometry/simulation_domain.py

@@ -0,0 +1,277 @@
+"""Simulation domain helpers for geometry, grids, and simulation domains."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import cunumpy as xp
+from maybempi import MPI
+
+from simgeometry._particle_boundaries import apply_particle_boundaries
+from simgeometry._types import Array, ConfigValue
+from simgeometry.boundingbox import BoundingBox
+from simgeometry.grid import Grid
+from simgeometry.shapes import Shape
+
+# The particle boundaries ``apply_bc_arrays`` knows.
+_PARTICLE_BC_TYPES = ("kill", "reflect", "periodic", "reinject")
+
+
+#: The ``apply_particle_boundaries`` kernel's code of each particle boundary type.
+PARTICLE_BOUNDARY_CODES = {"kill": 0, "reflect": 1, "periodic": 2, "reinject": 3}
+
+
+class SimulationDomain(BoundingBox):
+    """Class representing the simulation domain with boundary conditions."""
+
+    boundary_kernel = staticmethod(apply_particle_boundaries)
+
+    def __init__(
+        self,
+        ndim: int,
+        lower_bound: tuple,
+        upper_bound: tuple,
+        num_gridpoints: int | tuple[int, ...],
+        objects: list[Shape] | None = None,
+        bcs_field: Any | None = None,
+        bcs_particles: Any | None = None,
+        comm: MPI.Comm | None = None,
+        domain_decomposition: ConfigValue = None,
+    ) -> None:
+        """
+        Initialize the simulation domain with boundary conditions.
+
+        Parameters:
+        ndim (int): Number of dimensions (e.g., 1, 2, or 3).
+        bounds (list of tuples): List of tuples specifying min and max for each dimension.
+        bcs (dict): Dictionary specifying the boundary conditions for each dimension.
+        """
+        # A periodic field axis has ``n`` cells over the length (its last node
+        # neighbours its first); the grid, and everything deposited on or
+        # gathered from it, must use that node layout.
+        axis_names = ["x", "y", "z"][:ndim]
+        periodic = tuple(
+            bcs_field is not None
+            and bcs_field.get_bc(dir=axis, side="min").bc_type == "periodic"
+            for axis in axis_names
+        )
+        super().__init__(
+            lower_bound=lower_bound,
+            upper_bound=upper_bound,
+            comm=comm,
+            domain_decomposition=domain_decomposition,
+            periodic=periodic,
+        )
+        if objects is None:
+            objects = []
+        self._objects = objects
+        self._dimensions = ["x", "y", "z"][: self.ndim]
+        self._bcs_field = bcs_field
+        self._bcs_particles = bcs_particles
+
+        if self.bcs_particles is not None:
+            for dim in self._dimensions:
+                for side in ("min", "max"):
+                    bc_type = self.bcs_particles.get_bc(dir=dim, side=side).bc_type
+                    if bc_type not in _PARTICLE_BC_TYPES:
+                        raise ValueError(
+                            f"Unknown particle boundary {bc_type!r} on {dim} {side}; "
+                            f"expected one of {_PARTICLE_BC_TYPES}.",
+                        )
+
+        if ndim == 1:
+            bounds_injection_zone = ((1e-3,), (5e-3,))
+        elif ndim == 2:
+            bounds_injection_zone = ((1e-3, 0e-3), (5e-3, 20e-3))
+        elif ndim == 3:
+            bounds_injection_zone = ((1e-3, 0e-3, 0e-3), (5e-3, 20e-3, 20e-3))
+
+        self.injection_zone = BoundingBox(
+            lower_bound=bounds_injection_zone[0],
+            upper_bound=bounds_injection_zone[1],
+        )
+
+        self.grid = Grid(
+            ndim=ndim,
+            lower_bound=self.lower_bound,
+            upper_bound=upper_bound,
+            num_gridpoints=num_gridpoints,
+            comm=comm,
+            domain_decomposition=domain_decomposition,
+            periodic=periodic,
+        )
+
+    @property
+    def objects(self) -> list[Shape]:
+        """Return objects embedded in the domain."""
+        return self._objects
+
+    def plot(
+        self,
+        ax: Any = None,
+        show_grid: bool = False,
+        objects: bool = True,
+        **kwargs: Any,
+    ) -> Any:
+        """Draw the domain outline, its grid lines and its objects into ``ax``.
+
+        Keyword arguments style the outline (``color``, ``linewidth``, ...).
+        Returns the axes. Draw a field first with ``field.plot(ax=ax)``.
+        """
+        if self.ndim == 3 or any(axis in kwargs for axis in ("x", "y", "z")):
+            from simgeometry.collection import GeometryCollection
+
+            geometry = (
+                self.geometry
+                if objects
+                else GeometryCollection({}, bounds=(self.lower_bound, self.upper_bound))
+            )
+            return geometry.show(
+                ax=ax, grid=self.grid if show_grid else None, display=False, **kwargs
+            )
+        from simgeometry.plotting import draw_domain
+
+        return draw_domain(self, ax=ax, show_grid=show_grid, objects=objects, **kwargs)
+
+    @property
+    def geometry(self):
+        """Named geometry view using the domain bounds and current objects."""
+        from simgeometry.collection import GeometryCollection
+
+        return GeometryCollection(
+            self.objects, bounds=(self.lower_bound, self.upper_bound)
+        )
+
+    def evaluate(self, *args, **kwargs):
+        """Evaluate object labels on the domain grid or requested coordinates."""
+        if "grid" not in kwargs and "bounds" not in kwargs:
+            kwargs["grid"] = self.grid
+        return self.geometry.evaluate(*args, **kwargs)
+
+    def slice(self, **kwargs):
+        """Return a queryable section through the domain objects."""
+        return self.geometry.slice(**kwargs)
+
+    def show(self, **kwargs):
+        """Display objects, optionally with grid lines or a coordinate slice."""
+        if kwargs.get("grid") is True:
+            kwargs["grid"] = self.grid
+        return self.geometry.show(**kwargs)
+
+    def show_3d(self, **kwargs):
+        """Display the domain objects as 3D surfaces."""
+        if kwargs.get("grid") is True:
+            kwargs["grid"] = self.grid
+        return self.geometry.show_3d(**kwargs)
+
+    def cut_edges(self, grid=None, **kwargs):
+        """Geometry of object intersections with grid edges, without clamping."""
+        return self.geometry.cut_edges(self.grid if grid is None else grid, **kwargs)
+
+    def diagnose(self, grid=None, **kwargs):
+        """Inspect object overlaps and resolution on the domain grid."""
+        return self.geometry.diagnose(self.grid if grid is None else grid, **kwargs)
+
+    def cell_fractions(self, grid=None, **kwargs):
+        """Approximate solid volume and face-area fractions on the domain grid."""
+        return self.geometry.cell_fractions(
+            self.grid if grid is None else grid, **kwargs
+        )
+
+    @property
+    def bcs_field(self) -> Any | None:
+        """Return field boundary conditions."""
+        return self._bcs_field
+
+    @property
+    def bcs_particles(self) -> Any | None:
+        """Return particle boundary conditions."""
+        return self._bcs_particles
+
+    def particle_boundary_type(
+        self,
+        dir: int,
+        side: str,
+        particle_bcs: Any | None = None,
+    ) -> str:
+        """Return the particle boundary type for one axis side."""
+        particle_bcs = particle_bcs or self.bcs_particles
+        if particle_bcs is None:
+            raise ValueError("No particle boundary conditions are configured")
+        return particle_bcs.get_bc(
+            dir=self._dimensions[dir],
+            side=side,
+        ).bc_type
+
+    def particle_boundary_codes(
+        self, particle_bcs: Any | None = None
+    ) -> tuple[Array, Array]:
+        """The kernel codes of the lower and upper side of every axis (int64 arrays).
+
+        ``PARTICLE_BOUNDARY_CODES``: 0 kill, 1 reflect, 2 periodic, 3 reinject,
+        as ``apply_particle_boundaries`` and the fused pushes take them.
+        """
+        return tuple(
+            xp.asarray(
+                [
+                    PARTICLE_BOUNDARY_CODES[
+                        self.particle_boundary_type(axis, side, particle_bcs)
+                    ]
+                    for axis in range(self.ndim)
+                ],
+                dtype=xp.int64,
+            )
+            for side in ("min", "max")
+        )
+
+    @staticmethod
+    def _wrap_periodic(values: Array, lower: float, upper: float) -> Array:
+        """Wrap ``values`` into ``[lower, upper)``.
+
+        The domain holds ``lower <= x < upper``.  The modulo can round a
+        value just below ``lower`` up to exactly ``upper``, which would then
+        count as outside; such a value is the periodic image of ``lower``.
+        """
+        wrapped = lower + (values - lower) % (upper - lower)
+        return xp.where(wrapped >= upper, lower, wrapped)
+
+    def apply_bc_arrays(
+        self,
+        positions: Array,
+        velocities: Array,
+        alives: ConfigValue,
+        particle_bcs: Any | None = None,
+    ) -> Array:
+        """Apply particle boundaries and return markers reinjected this push.
+
+        ``positions`` is ``(ndim, N)`` and ``velocities`` ``(nvel, N)``. One
+        pass of the ``apply_particle_boundaries`` kernel reflects, wraps or
+        kills the markers in place; markers crossing a reinject side get a new
+        position from the injection zone here.
+        """
+        particle_bcs = particle_bcs or self.bcs_particles
+        assert positions.shape[0] == self.ndim, (
+            f"Expected positions with shape ({self.ndim}, N), got {positions.shape}"
+        )
+        num_markers = positions.shape[1]
+        if particle_bcs is None or num_markers == 0:
+            return xp.zeros(num_markers, dtype=bool)
+
+        lower_codes, upper_codes = self.particle_boundary_codes(particle_bcs)
+        reinjected = xp.zeros(num_markers, dtype=bool)
+        self.boundary_kernel(
+            positions,
+            velocities,
+            alives,
+            reinjected,
+            xp.asarray(self.lower_bound, dtype=float),
+            xp.asarray(self.upper_bound, dtype=float),
+            lower_codes,
+            upper_codes,
+        )
+        num_reinjected = int(xp.count_nonzero(reinjected))
+        if num_reinjected > 0:
+            positions[:, reinjected] = self.injection_zone.draw_random_positions(
+                num_reinjected,
+            )
+        return reinjected

simgeometry/utils.py

@@ -0,0 +1,24 @@
+"""Utils helpers for geometry, grids, and simulation domains."""
+
+from __future__ import annotations
+
+from numpy import ndarray
+
+
+def vertices_to_bounds(
+    vertices: ndarray,
+) -> tuple[tuple[float, float], tuple[float, float]]:
+    """
+    Convert a list of vertices to bounding box coordinates.
+
+    Parameters:
+    vertices (ndarray): Array of shape (N, 2) representing N vertices in 2D.
+
+    Returns:
+    Tuple[Tuple[float, float], Tuple[float, float]]: Lower and upper bounds as tuples.
+    """
+    xs = vertices[:, 0]
+    ys = vertices[:, 1]
+    lower_bound = (float(xs.min()), float(ys.min()))
+    upper_bound = (float(xs.max()), float(ys.max()))
+    return lower_bound, upper_bound