simgeometry 0.1.0__py3-none-any.whl

simgeometry/operations.py

@@ -0,0 +1,386 @@
+"""Boolean composition, affine transformations and queryable plane sections."""
+
+from __future__ import annotations
+
+import copy
+from itertools import product
+
+import cunumpy as xp
+import numpy as np
+
+from simgeometry.shapes import Shape, _component_major, _refine_loop, _signed_area
+
+
+def corners(shape):
+    return np.array(list(product(*zip(shape.lower_bound, shape.upper_bound))), float).T
+
+
+def mask(shape, points):
+    return np.asarray(xp.to_numpy(shape.contains_points(points)), dtype=bool)
+
+
+class BooleanShape(Shape):
+    """A snapshot of a union, intersection, or difference of two shapes.
+
+    Bounds conservatively enclose operands. ``inverted`` indicates the result
+    may be unbounded, so sampling requires explicit bounds in that case.
+    """
+
+    def __init__(self, left, right, operation):
+        if left.ndim != right.ndim:
+            raise ValueError("Boolean operands must have the same dimension")
+        if operation not in ("union", "intersection", "difference"):
+            raise ValueError("Unknown Boolean operation")
+        self.left, self.right = copy.deepcopy(left), copy.deepcopy(right)
+        self.operation = operation
+        self._inverted = bool(left.inverted or right.inverted)
+        super().__init__(
+            left.ndim,
+            np.minimum(left.lower_bound, right.lower_bound),
+            np.maximum(left.upper_bound, right.upper_bound),
+        )
+
+    def contains_points(self, points):
+        points = _component_major(points, self.ndim)
+        a, b = self.left.contains_points(points), self.right.contains_points(points)
+        if self.operation == "union":
+            return a | b
+        if self.operation == "intersection":
+            return a & b
+        return a & ~b
+
+    def contains(self, coords):
+        return bool(
+            xp.to_numpy(self.contains_points(np.asarray(coords).reshape(self.ndim, 1)))[
+                0
+            ]
+        )
+
+    def outlines(self, max_spacing=None):
+        """The boundary loops of a 2D Boolean shape, as ``(2, n)`` host arrays.
+
+        Loops keep the region on their left: outer boundaries are counter-clockwise
+        and holes clockwise (a plate minus a disc gives one of each). Each operand
+        enters as the polygon through its own ``outlines(max_spacing)``, so a curved
+        operand such as a ``Circle`` is approximated by its inscribed polygon; the
+        clipped loops are then refined to ``max_spacing`` (see ``Shape2D.outlines``).
+        Needs shapely (the ``clip`` extra). Inverted operands, non-2D shapes and
+        operands without outlines raise ``NotImplementedError``.
+        """
+        geometry = _shapely_geometry(self, max_spacing)
+        loops = []
+        for polygon in _polygons(geometry):
+            loops.append(_shapely_ring(polygon.exterior, counter_clockwise=True))
+            loops.extend(
+                _shapely_ring(ring, counter_clockwise=False)
+                for ring in polygon.interiors
+            )
+        loops = [loop for loop in loops if loop.shape[1] >= 3]
+        if max_spacing is None:
+            return loops
+        return [_refine_loop(loop, max_spacing) for loop in loops]
+
+    def boundary_panels(self, max_spacing=None):
+        """The edges of :meth:`outlines` as panels; see ``Shape2D.boundary_panels``."""
+        from simgeometry.panels import boundary_panels
+
+        return boundary_panels(self, max_spacing)
+
+
+def _shapely():
+    try:
+        import shapely
+    except ImportError as exc:  # pragma: no cover - depends on the environment
+        raise ImportError(
+            "Outlines of Boolean shapes need shapely: pip install 'simgeometry[clip]'"
+        ) from exc
+    return shapely
+
+
+def _shapely_geometry(shape, max_spacing):
+    """A shapely geometry of a 2D shape, built from its outline loops."""
+    shapely = _shapely()
+    if shape.ndim != 2:
+        raise NotImplementedError("outlines() is only defined for 2D shapes")
+    if shape.inverted:
+        raise NotImplementedError(
+            "outlines() of a Boolean shape needs bounded operands, not inverted ones"
+        )
+    if isinstance(shape, BooleanShape):
+        left = _shapely_geometry(shape.left, max_spacing)
+        right = _shapely_geometry(shape.right, max_spacing)
+        result = {
+            "union": shapely.union,
+            "intersection": shapely.intersection,
+            "difference": shapely.difference,
+        }[shape.operation](left, right)
+        return shapely.make_valid(result)
+    from simgeometry.objects.function_object import FunctionObject2D
+
+    if isinstance(shape, FunctionObject2D) or not hasattr(shape, "outlines"):
+        raise NotImplementedError(
+            f"{type(shape).__name__} has no outlines to combine in a Boolean shape"
+        )
+    if not getattr(shape, "closed", True):
+        raise NotImplementedError(
+            f"{type(shape).__name__} is an open curve and encloses no area"
+        )
+    outer, holes = [], []
+    for loop in shape.outlines(max_spacing):
+        loop = np.asarray(loop, dtype=float)
+        if loop.shape[1] < 3:
+            continue
+        (outer if _signed_area(loop) > 0 else holes).append(shapely.Polygon(loop.T))
+    geometry = shapely.union_all(outer) if outer else shapely.Polygon()
+    if holes:
+        geometry = shapely.difference(geometry, shapely.union_all(holes))
+    return shapely.make_valid(geometry)
+
+
+def _polygons(geometry):
+    """The nonempty polygons of a shapely geometry, in a deterministic order."""
+    shapely = _shapely()
+    polygons = []
+    for part in shapely.get_parts(geometry):
+        if isinstance(part, shapely.Polygon):
+            if part.area > 0:
+                polygons.append(part)
+        elif isinstance(part, (shapely.MultiPolygon, shapely.GeometryCollection)):
+            polygons.extend(_polygons(part))
+    return sorted(polygons, key=lambda p: (p.bounds[0], p.bounds[1], -p.area))
+
+
+def _shapely_ring(ring, *, counter_clockwise):
+    """A shapely ring as a ``(2, n)`` loop, without repeated vertices."""
+    coords = np.asarray(ring.coords, dtype=float)[:-1]
+    keep = np.any(coords != np.roll(coords, 1, axis=0), axis=1)
+    loop = np.ascontiguousarray(coords[keep].T)
+    if (_signed_area(loop) > 0) != counter_clockwise:
+        loop = np.ascontiguousarray(loop[:, ::-1])
+    return loop
+
+
+class TransformedShape(Shape):
+    """Independent affine image of a source, mapping p to matrix @ p + offset."""
+
+    def __init__(self, source, matrix, offset=None):
+        self.source = copy.deepcopy(source)
+        self.matrix = np.asarray(matrix, float)
+        self.offset = (
+            np.zeros(source.ndim) if offset is None else np.asarray(offset, float)
+        )
+        if self.matrix.shape != (source.ndim, source.ndim) or self.offset.shape != (
+            source.ndim,
+        ):
+            raise ValueError("Matrix and offset must match the shape dimension")
+        if not np.all(np.isfinite(self.matrix)) or not np.all(np.isfinite(self.offset)):
+            raise ValueError("Transform must be finite")
+        try:
+            self.inverse = np.linalg.inv(self.matrix)
+        except np.linalg.LinAlgError as exc:
+            raise ValueError("Transform must be invertible") from exc
+        vertices = self.matrix @ corners(source) + self.offset[:, None]
+        self._inverted = source.inverted
+        self._bc = getattr(source, "_bc", None)
+        self._bc_type = getattr(source, "_bc_type", "dirichlet")
+        super().__init__(source.ndim, vertices.min(axis=1), vertices.max(axis=1))
+
+    def contains_points(self, points):
+        points = _component_major(points, self.ndim)
+        local = xp.asarray(self.inverse) @ (points - xp.asarray(self.offset)[:, None])
+        return self.source.contains_points(local)
+
+    def contains(self, coords):
+        return self.source.contains(self.inverse @ (np.asarray(coords) - self.offset))
+
+    def outlines(self, max_spacing=None):
+        """The source's outline loops, transformed (2D only); see ``Shape2D.outlines``.
+
+        The source is refined to ``max_spacing`` divided by the transform's largest
+        stretch, so the transformed vertices are at most ``max_spacing`` apart.
+        """
+        if self.ndim != 2 or not hasattr(self.source, "outlines"):
+            raise NotImplementedError("outlines() needs a 2D source with outlines")
+        stretch = float(np.linalg.norm(self.matrix, 2))
+        if max_spacing is None:
+            local = None
+        elif callable(max_spacing):
+
+            def local(points):
+                world = self.matrix @ points + self.offset[:, None]
+                return np.asarray(max_spacing(world), dtype=float) / stretch
+
+        else:
+            local = max_spacing / stretch
+        # a reflection reverses the loops; an open curve keeps its vertex order
+        flip = np.linalg.det(self.matrix) < 0 and self.closed
+        loops = []
+        for loop in self.source.outlines(local):
+            loop = self.matrix @ loop + self.offset[:, None]
+            loops.append(loop[:, ::-1] if flip else loop)
+        return loops
+
+    @property
+    def closed(self):
+        """Whether the source encloses an area (False for an open curve)."""
+        return getattr(self.source, "closed", True)
+
+    @property
+    def exact_outline(self):
+        """Whether the outline is exact: an affine map keeps a polygon a polygon."""
+        return getattr(self.source, "exact_outline", False)
+
+    def boundary_panels(self, max_spacing=None):
+        """The edges of :meth:`outlines` as panels; see ``Shape2D.boundary_panels``."""
+        from simgeometry.panels import boundary_panels
+
+        return boundary_panels(self, max_spacing)
+
+    @property
+    def named_objects(self):
+        if not hasattr(self.source, "named_objects"):
+            raise AttributeError("This transformed shape has no named children")
+        return {
+            name: obj.transformed(self.matrix, self.offset)
+            for name, obj in self.source.named_objects.items()
+        }
+
+    @property
+    def names(self):
+        return getattr(self.source, "names", ("inside",))
+
+    @property
+    def styles(self):
+        return getattr(self.source, "styles", {})
+
+    def labels(self, points):
+        if not hasattr(self.source, "labels"):
+            return mask(self, points).astype(int)
+        local = self.inverse @ (np.asarray(xp.to_numpy(points)) - self.offset[:, None])
+        return self.source.labels(local)
+
+    def evaluate(self, *args, quantity=None, **kwargs):
+        if quantity is None:
+            quantity = "labels" if hasattr(self.source, "labels") else "occupancy"
+        return super().evaluate(*args, quantity=quantity, **kwargs)
+
+
+def rotation(shape, angle, *, axis=(0, 0, 1), origin=None):
+    angle = np.deg2rad(float(angle))
+    c, s = np.cos(angle), np.sin(angle)
+    if shape.ndim == 2:
+        matrix = np.array([[c, -s], [s, c]])
+    elif shape.ndim == 3:
+        axis = np.asarray(axis, float)
+        if (
+            axis.shape != (3,)
+            or not np.all(np.isfinite(axis))
+            or np.linalg.norm(axis) == 0
+        ):
+            raise ValueError("Rotation axis must be a finite nonzero 3-vector")
+        axis /= np.linalg.norm(axis)
+        x, y, z = axis
+        cross = np.array([[0, -z, y], [z, 0, -x], [-y, x, 0]])
+        matrix = c * np.eye(3) + (1 - c) * np.outer(axis, axis) + s * cross
+    else:
+        raise ValueError("Rotation requires 2D or 3D geometry")
+    origin = np.zeros(shape.ndim) if origin is None else np.asarray(origin, float)
+    return shape.transformed(matrix, origin - matrix @ origin)
+
+
+class Section(Shape):
+    """A membership-preserving section, including holes and disconnected pieces.
+
+    ``to_world`` and ``to_local`` use component-major arrays. ``to_local`` is
+    an orthogonal projection. For oblique planes, x/y denote plane coordinates.
+    """
+
+    def __init__(self, source, *, x=None, y=None, z=None, origin=None, normal=None):
+        if source.ndim < 2:
+            raise ValueError("Cannot slice one-dimensional geometry")
+        self.source = copy.deepcopy(source)
+        selection = {k: v for k, v in zip("xyz", (x, y, z)) if v is not None}
+        if origin is not None or normal is not None:
+            if selection or source.ndim != 3 or origin is None or normal is None:
+                raise ValueError(
+                    "An oblique section requires only a 3D origin and normal"
+                )
+            self.origin, n = np.asarray(origin, float), np.asarray(normal, float)
+            if (
+                self.origin.shape != (3,)
+                or n.shape != (3,)
+                or not np.all(np.isfinite(n))
+                or np.linalg.norm(n) == 0
+            ):
+                raise ValueError("Plane origin and nonzero normal must be 3-vectors")
+            n = n / np.linalg.norm(n)
+            u = np.eye(3)[np.argmin(np.abs(n))]
+            u -= n * np.dot(u, n)
+            u /= np.linalg.norm(u)
+            self.basis = np.column_stack((u, np.cross(n, u)))
+            self.axis_names = ("x", "y")
+        else:
+            if len(selection) != 1:
+                raise ValueError("Fix exactly one axis to form a section")
+            name, value = next(iter(selection.items()))
+            source_names = getattr(source, "axis_names", tuple("xyz"[: source.ndim]))
+            if name not in source_names or not np.isscalar(value):
+                raise ValueError(
+                    "Slice axis must exist and its position must be scalar"
+                )
+            axis = source_names.index(name)
+            self.origin = np.zeros(source.ndim)
+            self.origin[axis] = float(value)
+            remaining = [i for i in range(source.ndim) if i != axis]
+            self.basis = np.eye(source.ndim)[:, remaining]
+            self.axis_names = tuple(source_names[i] for i in remaining)
+        if not np.all(np.isfinite(self.origin)):
+            raise ValueError("Plane origin must be finite")
+        vertices = self.basis.T @ (corners(source) - self.origin[:, None])
+        self._inverted = source.inverted
+        super().__init__(source.ndim - 1, vertices.min(axis=1), vertices.max(axis=1))
+
+    def _to_parent(self, points):
+        points = np.asarray(points, float)
+        return (
+            self.origin + self.basis @ points
+            if points.ndim == 1
+            else self.origin[:, None] + self.basis @ points
+        )
+
+    def to_world(self, points):
+        """Map section coordinates back through any parent sections."""
+        parent = self._to_parent(points)
+        return (
+            self.source.to_world(parent) if isinstance(self.source, Section) else parent
+        )
+
+    def to_local(self, points):
+        """Orthogonally project world points through any parent sections."""
+        points = np.asarray(points, float)
+        if isinstance(self.source, Section):
+            points = self.source.to_local(points)
+        return self.basis.T @ (
+            points - self.origin if points.ndim == 1 else points - self.origin[:, None]
+        )
+
+    def contains_points(self, points):
+        points = np.asarray(xp.to_numpy(_component_major(points, self.ndim)), float)
+        return self.source.contains_points(self._to_parent(points))
+
+    def contains(self, coords):
+        return self.source.contains(self._to_parent(np.atleast_1d(coords)))
+
+    def labels(self, points):
+        if not hasattr(self.source, "labels"):
+            return mask(self, points).astype(int)
+        return self.source.labels(self._to_parent(points))
+
+    def evaluate(self, *args, quantity=None, **kwargs):
+        if quantity is None:
+            quantity = "labels" if hasattr(self.source, "labels") else "occupancy"
+        return super().evaluate(*args, quantity=quantity, **kwargs)
+
+    @property
+    def names(self):
+        return getattr(self.source, "names", ("inside",))

simgeometry/panels.py

@@ -0,0 +1,80 @@
+"""Boundary panels: the straight edges of a 2D outline, for boundary-element solvers."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+
+
+@dataclass(frozen=True)
+class Panels:
+    """Straight panels along the boundary of a 2D shape, as component-major host arrays.
+
+    ``start`` and ``end`` are ``(2, n)``; ``piece`` ``(n,)`` is the index of the
+    outline loop (see ``outlines()``) each panel belongs to, so the panels of one loop
+    are contiguous and in order. ``closed`` is False for an open curve.
+
+    :attr:`normal` is the unit normal to the right of each panel's direction. Loops
+    keep the shape on their left, so for a closed shape it points out of the
+    geometry, at outer boundaries and holes alike (inversion is ignored, as in
+    ``outlines()``). For an open curve it is the side to the right of the curve's
+    direction, from its first vertex to its last.
+    """
+
+    start: np.ndarray
+    end: np.ndarray
+    piece: np.ndarray
+    closed: bool = True
+
+    def __len__(self) -> int:
+        return int(self.start.shape[1])
+
+    @property
+    def midpoint(self) -> np.ndarray:
+        """Panel midpoints, ``(2, n)``."""
+        return 0.5 * (self.start + self.end)
+
+    @property
+    def length(self) -> np.ndarray:
+        """Panel lengths, ``(n,)``."""
+        return np.hypot(*(self.end - self.start))
+
+    @property
+    def tangent(self) -> np.ndarray:
+        """Unit tangents from start to end, ``(2, n)``."""
+        return (self.end - self.start) / self.length
+
+    @property
+    def normal(self) -> np.ndarray:
+        """Unit normals to the right of the tangents, ``(2, n)``."""
+        tx, ty = self.tangent
+        return np.stack((ty, -tx))
+
+
+def boundary_panels(shape, max_spacing=None) -> Panels:
+    """The edges of ``shape.outlines(max_spacing)`` as :class:`Panels`.
+
+    Each edge of a closed loop is a panel, including the one back to its first
+    vertex; an open curve has one panel fewer than vertices. Zero-length edges are
+    dropped.
+    """
+    closed = bool(getattr(shape, "closed", True))
+    starts, ends, pieces = [], [], []
+    for index, loop in enumerate(shape.outlines(max_spacing)):
+        loop = np.asarray(loop, dtype=float)
+        start = loop if closed else loop[:, :-1]
+        end = np.roll(loop, -1, axis=1) if closed else loop[:, 1:]
+        keep = np.hypot(*(end - start)) > 0
+        starts.append(start[:, keep])
+        ends.append(end[:, keep])
+        pieces.append(np.full(int(keep.sum()), index))
+    if not starts:
+        empty = np.zeros((2, 0))
+        return Panels(empty, empty.copy(), np.zeros(0, dtype=int), closed)
+    return Panels(
+        np.concatenate(starts, axis=1),
+        np.concatenate(ends, axis=1),
+        np.concatenate(pieces),
+        closed,
+    )

simgeometry/plotting.py

@@ -0,0 +1,179 @@
+"""Optional Matplotlib drawing for geometric shapes and domains."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+import numpy as np
+
+from simgeometry.shapes import Shape2D
+from simgeometry.simulation_domain import SimulationDomain
+
+# Draw order: grid lines, objects, then the domain outline.
+ZORDER_GRID = 1.5
+ZORDER_OBJECT = 3.0
+ZORDER_FRAME = 3.5
+
+
+def _axes(ax: Any | None) -> Any:
+    if ax is None:
+        import matplotlib.pyplot as plt
+
+        ax = plt.gca()
+    return ax
+
+
+def _region(
+    shape: Shape2D,
+    bounds: tuple[Sequence[float], Sequence[float]] | None,
+) -> tuple[float, float, float, float]:
+    """Return ``(x_min, y_min, x_max, y_max)`` of the region to draw ``shape`` in.
+
+    An inverted shape covers everything outside its geometry, so it is drawn
+    over ``bounds`` (the simulation domain) when given; otherwise, and for a
+    regular shape, over the shape's bounding box.
+    """
+    lower, upper = (
+        bounds
+        if bounds is not None and shape.inverted
+        else (shape.lower_bound, shape.upper_bound)
+    )
+    x_min, y_min = (float(v) for v in lower)
+    x_max, y_max = (float(v) for v in upper)
+    return x_min, y_min, x_max, y_max
+
+
+def _signed_area(vertices: np.ndarray) -> float:
+    x, y = vertices[:, 0], vertices[:, 1]
+    return 0.5 * float(np.sum(x * np.roll(y, -1) - np.roll(x, -1) * y))
+
+
+def _draw_function_object(
+    shape: Any,
+    ax: Any,
+    resolution: int = 128,
+    bounds: tuple[Sequence[float], Sequence[float]] | None = None,
+    **kwargs: Any,
+) -> Any:
+    x_min, y_min, x_max, y_max = _region(shape, bounds)
+    xs = np.linspace(x_min, x_max, resolution)
+    ys = np.linspace(y_min, y_max, resolution)
+    mask = np.asarray([[shape.contains((x, y)) for x in xs] for y in ys], dtype=bool)
+    if not mask.any():
+        return ax
+    style = {
+        "origin": "lower",
+        "extent": [x_min, x_max, y_min, y_max],
+        "cmap": "Greys",
+        "vmin": 0.0,
+        "vmax": 1.0,
+        "aspect": "auto",
+        "zorder": ZORDER_OBJECT,
+        **kwargs,
+    }
+    ax.imshow(np.ma.masked_where(~mask, mask.astype(float)), **style)
+    return ax
+
+
+def draw_shape(
+    shape: Shape2D,
+    ax: Any | None = None,
+    bounds: tuple[Sequence[float], Sequence[float]] | None = None,
+    **kwargs: Any,
+) -> Any:
+    """Draw a 2D shape as filled polygons (a mask for ``FunctionObject2D``).
+
+    An inverted shape is drawn as the region ``bounds = (lower, upper)`` (the
+    simulation domain; the shape's bounding box by default) with its geometry
+    cut out.
+    """
+    from matplotlib.patches import PathPatch, Polygon
+    from matplotlib.path import Path
+
+    from simgeometry.objects.function_object import FunctionObject2D
+
+    ax = _axes(ax)
+    if isinstance(shape, FunctionObject2D):
+        return _draw_function_object(shape, ax, bounds=bounds, **kwargs)
+
+    style = {
+        "facecolor": "gray",
+        "edgecolor": "black",
+        "zorder": ZORDER_OBJECT,
+        **kwargs,
+    }
+    if not getattr(shape, "closed", True):
+        # an open curve: draw its line, there is no area to fill
+        line_style = {"color": style["edgecolor"], "zorder": style["zorder"]}
+        for loop in shape.outlines():
+            ax.plot(*loop, **line_style)
+        ax.autoscale_view()
+        return ax
+    polygons = [loop.T for loop in shape.outlines()]
+    if not shape.inverted:
+        for vertices in polygons:
+            ax.add_patch(Polygon(vertices, closed=True, **style))
+        ax.autoscale_view()
+        return ax
+
+    # Fill the region counter-clockwise and the geometry clockwise, so that
+    # the geometry is a hole under matplotlib's nonzero winding rule.
+    x_min, y_min, x_max, y_max = _region(shape, bounds)
+    outer = np.array([[x_min, y_min], [x_max, y_min], [x_max, y_max], [x_min, y_max]])
+    holes = [v if _signed_area(v) < 0.0 else v[::-1] for v in polygons if len(v) >= 3]
+    path = Path.make_compound_path(
+        *(Path(np.vstack([ring, ring[:1]]), closed=True) for ring in (outer, *holes))
+    )
+    ax.add_patch(PathPatch(path, **style))
+    ax.autoscale_view()
+    return ax
+
+
+def draw_domain(
+    domain: SimulationDomain,
+    ax: Any | None = None,
+    show_grid: bool = False,
+    objects: bool = True,
+    **kwargs: Any,
+) -> Any:
+    """Draw the domain outline, optionally its grid lines, and its objects."""
+    from matplotlib.collections import LineCollection
+
+    ax = _axes(ax)
+    style = {"color": "black", "linewidth": 1.0, "zorder": ZORDER_FRAME, **kwargs}
+    lower = [float(bound) for bound in domain.lower_bound]
+    upper = [float(bound) for bound in domain.upper_bound]
+
+    if domain.ndim == 1:
+        ax.axvline(lower[0], **style)
+        ax.axvline(upper[0], **style)
+        return ax
+    if domain.ndim != 2:
+        raise ValueError(
+            f"draw_domain draws 1D and 2D domains, got ndim={domain.ndim}; "
+            "use Plotter3D for 3D geometry"
+        )
+
+    (x0, y0), (x1, y1) = lower, upper
+    ax.plot([x0, x1, x1, x0, x0], [y0, y0, y1, y1, y0], **style)
+
+    if show_grid:
+        xs, ys = (np.asarray(points) for points in domain.grid.get_grid_points())
+        segments = [[(x, y0), (x, y1)] for x in xs[1:-1]]
+        segments += [[(x0, y), (x1, y)] for y in ys[1:-1]]
+        ax.add_collection(
+            LineCollection(
+                segments,
+                colors="gray",
+                linewidths=0.5,
+                alpha=0.6,
+                zorder=ZORDER_GRID,
+            )
+        )
+
+    if objects:
+        for shape in domain.objects:
+            if isinstance(shape, Shape2D):
+                draw_shape(shape, ax=ax, bounds=(lower, upper))
+    return ax