simgeometry 0.1.0__tar.gz → 0.2.0__tar.gz

{simgeometry-0.1.0/src/simgeometry.egg-info → simgeometry-0.2.0}/PKG-INFO

@@ -1,9 +1,8 @@
 Metadata-Version: 2.4
 Name: simgeometry
-Version: 0.1.0
+Version: 0.2.0
 Summary: Shapes, grids, and simulation domains for numerical simulations
 Author: Max
-License-Expression: MIT
 Project-URL: Source, https://github.com/max-models/simgeometry
 Keywords: geometry,grids,simulation,mpi
 Classifier: Development Status :: 3 - Alpha
@@ -15,11 +14,12 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-License-File: LICENSE.txt
-Requires-Dist: cunumpy>=0.6.2
+Requires-Dist: cunumpy>=0.7.1
 Requires-Dist: maybempi>=0.1
+Requires-Dist: methodcard
 Requires-Dist: mpiarray>=0.1.0
 Requires-Dist: numpy
+Requires-Dist: scope-profiler>=0.7.5
 Provides-Extra: dev
 Requires-Dist: jupyterlab; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
@@ -29,7 +29,8 @@ Requires-Dist: ruff; extra == "dev"
 Requires-Dist: simgeometry[docs,test]; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: griffe; extra == "docs"
-Requires-Dist: simgeometry[clip,plot]; extra == "docs"
+Requires-Dist: simgeometry[clip,interactive]; extra == "docs"
+Requires-Dist: plasma-plots[scene]>=0.2.5; extra == "docs"
 Requires-Dist: ipykernel; extra == "docs"
 Requires-Dist: matplotlib>=3.10.9; extra == "docs"
 Requires-Dist: nbclient>=0.11; extra == "docs"
@@ -44,6 +45,7 @@ Provides-Extra: plot
 Requires-Dist: matplotlib>=3.10; extra == "plot"
 Requires-Dist: simgeometry[evaluate,mesh]; extra == "plot"
 Provides-Extra: interactive
+Requires-Dist: plasma-plots>=0.2.5; extra == "interactive"
 Requires-Dist: pyvista>=0.44; extra == "interactive"
 Requires-Dist: simgeometry[plot]; extra == "interactive"
 Provides-Extra: mpi
@@ -55,11 +57,11 @@ Requires-Dist: cupy-cuda12x; extra == "gpu"
 Provides-Extra: metal
 Requires-Dist: mlx; (sys_platform == "darwin" and platform_machine == "arm64") and extra == "metal"
 Provides-Extra: test
+Requires-Dist: methodcard[symbolic]; extra == "test"
 Requires-Dist: mpi4py; extra == "test"
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
 Requires-Dist: simgeometry[clip]; extra == "test"
-Dynamic: license-file
 
 # simgeometry
 
@@ -77,12 +79,12 @@ pip install simgeometry
 ```
 
 For development, install this checkout with `pip install -e '.[test]'`.
-NumPy, cunumpy, maybempi, and mpiarray are runtime dependencies.
-Matplotlib is optional. Install `simgeometry[plot]` for plotting,
-labelled evaluation and surface meshing, or `simgeometry[interactive]`
-for interactive 3D clipping with PyVista. Install `simgeometry[mpi]` for
-MPI, `simgeometry[pyccel]` for compiled CPU containment kernels, or
-`simgeometry[gpu]` for CUDA.
+NumPy, cunumpy, maybempi, mpiarray and scope-profiler are runtime
+dependencies. Matplotlib is optional. Install `simgeometry[plot]` for
+plotting, labelled evaluation and surface meshing, or
+`simgeometry[interactive]` for interactive 3D clipping with PyVista.
+Install `simgeometry[mpi]` for MPI, `simgeometry[pyccel]` for compiled
+CPU containment kernels, or `simgeometry[gpu]` for CUDA.
 
 ## Example
 
@@ -115,10 +117,71 @@ inside = shell.evaluate(x=[0, 0.8], y=0, z=0)
 Shapes support named collections, Boolean operations, affine transforms,
 surface queries, point sampling, mesh export, cut-edge geometry and
 approximate cell/face fractions. See the [executed
-tutorials](https://max-models.github.io/simgeometry/tutorials/) and [API
+examples](https://max-models.github.io/simgeometry/examples/) and [API
 guide](https://max-models.github.io/simgeometry/getting-started/geometry-api/)
 for examples and the accuracy limits of sampled operations.
 
+## Level sets, solids of revolution and conductors
+
+``` python
+from simgeometry import GeometryCollection, Tube
+
+ring = lambda z: Tube((0, 0, z - 0.4), (0, 0, z + 0.4), 1.0, 1.6, fillet=0.1)
+lens = GeometryCollection(
+    {"entrance": ring(-1.2), "focus": ring(0.0), "exit": ring(1.2)},
+    voltages={"entrance": 0.0, "focus": 10e3, "exit": 0.0},
+)
+scan = lens.with_voltages(focus=lambda t: 10e3 * min(t / 1e-6, 1.0))
+values = scan.dirichlet_values(grid, t=0.5e-6)  # labels and voltages per node
+distance = lens["focus"].level_set(points)  # exact signed distance
+```
+
+`Cylinder`, `Tube`, `Cone` and `Torus` take any axis. Analytic shapes
+have a `level_set(points)`, negative inside, with `level_set_exact`
+where it is the Euclidean signed distance; Booleans and transforms
+propagate it. Edge crossings refine it with a few secant steps instead
+of bisecting `contains`, and `signed_distance` returns an exact one
+directly. The [conductors
+example](https://max-models.github.io/simgeometry/examples/conductors-and-level-sets/)
+builds an Einzel lens.
+
+## Preview a domain decomposition
+
+``` python
+from simgeometry import Sphere
+from simgeometry.domain_decomposition import DomainDecomposition
+
+preview = DomainDecomposition.preview(8, decompose=[True, True, True])
+preview.proc_sizes  # [2, 2, 2], as on 8 MPI ranks
+boxes = preview.subdomain_boxes((0, 0, 0), (2, 1, 1), (33, 17, 17))
+preview.show_3d((0, 0, 0), (2, 1, 1), (33, 17, 17), shape=Sphere((1, 0.5, 0.5), 0.35))
+```
+
+`DomainDecomposition.preview(size)` computes the split a `size`-rank run
+would use without a communicator, for inspection and planning: index
+ranges, subdomains and owner ranks for every rank. `show_3d` draws one
+box per rank (with `simgeometry[interactive]`) and `show` one rectangle
+per rank of a 2D decomposition. See the [parallel grids
+example](https://max-models.github.io/simgeometry/examples/parallel-grids/).
+
+## Profiling
+
+simgeometry ships
+[scope-profiler](https://github.com/max-models/scope-profiler) regions
+for its expensive operations (`simgeometry.node_mask`,
+`simgeometry.crossings`, `simgeometry.to_mesh`, …). They are off by
+default and cost almost nothing. Turn them on in an application that
+profiles itself with the `simgeometry` tag:
+
+``` python
+import scope_profiler as sp
+
+sp.setup(enable_tags=["simgeometry"])
+```
+
+or `SCOPE_PROFILER_ENABLE_TAGS=simgeometry`, or
+`scope-profiler run --enable-tag simgeometry`.
+
 ## Development
 
 ``` bash

simgeometry-0.2.0/README.md

@@ -0,0 +1,126 @@
+# simgeometry
+
+
+Geometry primitives for numerical simulations: bounded domains,
+structured grids, MPI domain decomposition, and 1D, 2D, and 3D shapes.
+Box, ball, and polygon containment have NumPy, Pyccel, CUDA, and Metal
+implementations. Originally developed for
+[Picnic](https://github.com/max-models/picnic).
+
+## Install
+
+``` bash
+pip install simgeometry
+```
+
+For development, install this checkout with `pip install -e '.[test]'`.
+NumPy, cunumpy, maybempi, mpiarray and scope-profiler are runtime
+dependencies. Matplotlib is optional. Install `simgeometry[plot]` for
+plotting, labelled evaluation and surface meshing, or
+`simgeometry[interactive]` for interactive 3D clipping with PyVista.
+Install `simgeometry[mpi]` for MPI, `simgeometry[pyccel]` for compiled
+CPU containment kernels, or `simgeometry[gpu]` for CUDA.
+
+## Example
+
+``` python
+from simgeometry.grid import Grid
+from simgeometry.objects import Circle
+
+boundary = Circle(midpoint=(0.5, 0.5), radius=0.25)
+grid = Grid(ndim=2, lower_bound=(0, 0), upper_bound=(1, 1), num_gridpoints=(32, 32))
+mask = boundary.node_mask(grid)
+```
+
+`SimulationDomain` accepts field and particle boundary objects through
+their `get_bc(dir=..., side=...).bc_type` interface. Applications may
+supply a seeded random function with `BoundingBox.random` and an
+accelerated particle boundary implementation with
+`SimulationDomain.boundary_kernel`.
+
+## Inspect, slice, and compose
+
+``` python
+from simgeometry import Sphere
+
+shell = Sphere((0, 0, 0), 1) - Sphere((0, 0, 0), 0.4)
+shell.show_3d(opacity=0.6)
+shell.slice(z=0.2).show()
+inside = shell.evaluate(x=[0, 0.8], y=0, z=0)
+```
+
+Shapes support named collections, Boolean operations, affine transforms,
+surface queries, point sampling, mesh export, cut-edge geometry and
+approximate cell/face fractions. See the [executed
+examples](https://max-models.github.io/simgeometry/examples/) and [API
+guide](https://max-models.github.io/simgeometry/getting-started/geometry-api/)
+for examples and the accuracy limits of sampled operations.
+
+## Level sets, solids of revolution and conductors
+
+``` python
+from simgeometry import GeometryCollection, Tube
+
+ring = lambda z: Tube((0, 0, z - 0.4), (0, 0, z + 0.4), 1.0, 1.6, fillet=0.1)
+lens = GeometryCollection(
+    {"entrance": ring(-1.2), "focus": ring(0.0), "exit": ring(1.2)},
+    voltages={"entrance": 0.0, "focus": 10e3, "exit": 0.0},
+)
+scan = lens.with_voltages(focus=lambda t: 10e3 * min(t / 1e-6, 1.0))
+values = scan.dirichlet_values(grid, t=0.5e-6)  # labels and voltages per node
+distance = lens["focus"].level_set(points)  # exact signed distance
+```
+
+`Cylinder`, `Tube`, `Cone` and `Torus` take any axis. Analytic shapes
+have a `level_set(points)`, negative inside, with `level_set_exact`
+where it is the Euclidean signed distance; Booleans and transforms
+propagate it. Edge crossings refine it with a few secant steps instead
+of bisecting `contains`, and `signed_distance` returns an exact one
+directly. The [conductors
+example](https://max-models.github.io/simgeometry/examples/conductors-and-level-sets/)
+builds an Einzel lens.
+
+## Preview a domain decomposition
+
+``` python
+from simgeometry import Sphere
+from simgeometry.domain_decomposition import DomainDecomposition
+
+preview = DomainDecomposition.preview(8, decompose=[True, True, True])
+preview.proc_sizes  # [2, 2, 2], as on 8 MPI ranks
+boxes = preview.subdomain_boxes((0, 0, 0), (2, 1, 1), (33, 17, 17))
+preview.show_3d((0, 0, 0), (2, 1, 1), (33, 17, 17), shape=Sphere((1, 0.5, 0.5), 0.35))
+```
+
+`DomainDecomposition.preview(size)` computes the split a `size`-rank run
+would use without a communicator, for inspection and planning: index
+ranges, subdomains and owner ranks for every rank. `show_3d` draws one
+box per rank (with `simgeometry[interactive]`) and `show` one rectangle
+per rank of a 2D decomposition. See the [parallel grids
+example](https://max-models.github.io/simgeometry/examples/parallel-grids/).
+
+## Profiling
+
+simgeometry ships
+[scope-profiler](https://github.com/max-models/scope-profiler) regions
+for its expensive operations (`simgeometry.node_mask`,
+`simgeometry.crossings`, `simgeometry.to_mesh`, …). They are off by
+default and cost almost nothing. Turn them on in an application that
+profiles itself with the `simgeometry` tag:
+
+``` python
+import scope_profiler as sp
+
+sp.setup(enable_tags=["simgeometry"])
+```
+
+or `SCOPE_PROFILER_ENABLE_TAGS=simgeometry`, or
+`scope-profiler run --enable-tag simgeometry`.
+
+## Development
+
+``` bash
+pytest src/simgeometry/tests
+```
+
+Documentation: <https://max-models.github.io/simgeometry/>

{simgeometry-0.1.0 → simgeometry-0.2.0}/pyproject.toml

@@ -4,12 +4,10 @@ requires = [ "setuptools", "wheel" ]
 
 [project]
 name = "simgeometry"
-version = "0.1.0"
+version = "0.2.0"
 description = "Shapes, grids, and simulation domains for numerical simulations"
 readme = "README.md"
 keywords = [ "geometry", "grids", "simulation", "mpi" ]
-license = "MIT"
-license-files = [ "LICENSE.txt" ]
 authors = [ { name = "Max" } ]
 requires-python = ">=3.10"
 classifiers = [
@@ -22,10 +20,12 @@ classifiers = [
   "Programming Language :: Python :: 3.14",
 ]
 dependencies = [
-  "cunumpy>=0.6.2",
+  "cunumpy>=0.7.1",
   "maybempi>=0.1",
+  "methodcard",
   "mpiarray>=0.1.0",
   "numpy",
+  "scope-profiler>=0.7.5",
 ]
 optional-dependencies.dev = [
   "jupyterlab",
@@ -37,7 +37,9 @@ optional-dependencies.dev = [
 ]
 optional-dependencies.docs = [
   "griffe",
-  "simgeometry[clip,plot]",
+  "simgeometry[clip,interactive]",
+  # interactive 3-D scenes in the notebooks (plasma_plots.scene)
+  "plasma-plots[scene]>=0.2.5",
   "ipykernel",
   "matplotlib>=3.10.9",
   "nbclient>=0.11",
@@ -47,17 +49,20 @@ optional-dependencies.clip = [ "shapely>=2" ]
 optional-dependencies.evaluate = [ "xarray" ]
 optional-dependencies.mesh = [ "scikit-image>=0.22" ]
 optional-dependencies.plot = [ "matplotlib>=3.10", "simgeometry[evaluate,mesh]" ]
-optional-dependencies.interactive = [ "pyvista>=0.44", "simgeometry[plot]" ]
+optional-dependencies.interactive = [ "plasma-plots>=0.2.5", "pyvista>=0.44", "simgeometry[plot]" ]
 optional-dependencies.mpi = [ "mpi4py" ]
 optional-dependencies.pyccel = [ "pyccel>2.0" ]
 optional-dependencies.gpu = [ "cupy-cuda12x" ]
 optional-dependencies.metal = [ "mlx; sys_platform == 'darwin' and platform_machine == 'arm64'" ]
-optional-dependencies.test = [ "mpi4py", "pytest", "pytest-cov", "simgeometry[clip]" ]
+optional-dependencies.test = [ "methodcard[symbolic]", "mpi4py", "pytest", "pytest-cov", "simgeometry[clip]" ]
 urls.Source = "https://github.com/max-models/simgeometry"
 
+[project.entry-points."scope_profiler.opt_in_tags"]
+simgeometry = "simgeometry"
+
 [tool.setuptools]
 package-data."*" = [ "py.typed" ]
-package-data.simgeometry = [ "kernels/*/*.cu" ]
+package-data.simgeometry = [ "kernels/*.cuh", "kernels/*/*.cu" ]
 packages.find.where = [ "src" ]
 packages.find.exclude = [ "simgeometry.tests*" ]
 
@@ -83,8 +88,19 @@ reportMissingImports = "error"
 ini_options.pythonpath = [ "src" ]
 ini_options.testpaths = [ "src" ]
 ini_options.addopts = "-ra"
+ini_options.markers = [ "convergence: an order-of-accuracy test of a method card" ]
 
 [tool.coverage]
 run.omit = [ "*/tests/*" ]
 run.source = [ "simgeometry" ]
 report.show_missing = true
+
+# PRs to devel test against the devel branches of the max-models packages (pinned in
+# uv.lock); PRs to main and the release use PyPI only (CI sets UV_NO_SOURCES).
+[tool.uv.sources]
+cunumpy = { git = "https://github.com/max-models/cunumpy", branch = "devel" }
+maybempi = { git = "https://github.com/max-models/maybempi", branch = "devel" }
+methodcard = { git = "https://github.com/max-models/methodcard", branch = "devel" }
+mpiarray = { git = "https://github.com/max-models/mpiarray", branch = "devel" }
+plasma-plots = { git = "https://github.com/max-models/plasma-plots", branch = "devel" }
+scope-profiler = { git = "https://github.com/max-models/scope-profiler", branch = "devel" }

{simgeometry-0.1.0 → simgeometry-0.2.0}/src/simgeometry/__init__.py

@@ -1,38 +1,63 @@
 """Shapes, grids, and domains for numerical simulations."""
 
+from importlib.metadata import PackageNotFoundError, version
+
+import scope_profiler as sp
+
+from simgeometry._profiling import _PROFILE_TAGS
 from simgeometry.collection import GeometryCollection
 from simgeometry.grid import Grid
 from simgeometry.objects import (
     Aperture2D,
     Aperture3D,
     Circle,
+    Cone,
     Cuboid,
+    Cylinder,
     FunctionObject2D,
     FunctionObject3D,
+    Helix,
     Line,
     Polygon,
     Polyline,
     Rectangle,
+    SlantedTube,
     Sphere,
+    Torus,
     Triangle,
+    Tube,
 )
+from simgeometry.operations import PolarRepeat
 from simgeometry.simulation_domain import SimulationDomain
 
-__version__ = "0.1.0"
+# simgeometry's regions stay off unless the application enables the "simgeometry" tag.
+sp.register_opt_in_tag(*_PROFILE_TAGS)
+
+try:
+    __version__ = version("simgeometry")
+except PackageNotFoundError:  # not installed, e.g. run from a source tree
+    __version__ = "0.0.0+unknown"
 __all__ = [
     "GeometryCollection",
     "Grid",
+    "PolarRepeat",
     "SimulationDomain",
     "Aperture2D",
     "Aperture3D",
     "Circle",
+    "Cone",
     "Cuboid",
+    "Cylinder",
     "FunctionObject2D",
     "FunctionObject3D",
+    "Helix",
     "Line",
     "Polygon",
     "Polyline",
     "Rectangle",
+    "SlantedTube",
     "Sphere",
+    "Torus",
     "Triangle",
+    "Tube",
 ]

simgeometry-0.2.0/src/simgeometry/_decomposition_views.py

@@ -0,0 +1,181 @@
+"""Views of a domain decomposition: one box (3D) or rectangle (2D) per rank.
+
+Used by `DomainDecomposition.show_3d` and `DomainDecomposition.show`.
+Nothing here communicates; the boxes come from ``subdomain_boxes``.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+_MAX_LEGEND_RANKS = 16
+
+
+def _rank_colors(size: int) -> list[tuple[float, float, float]]:
+    """Return one distinct colour per rank: tab10 up to 10 ranks, else tab20/turbo."""
+    from matplotlib import colormaps
+
+    if size <= 10:
+        cmap = colormaps["tab10"]
+        return [tuple(cmap(i)[:3]) for i in range(size)]
+    if size <= 20:
+        cmap = colormaps["tab20"]
+        return [tuple(cmap(i)[:3]) for i in range(size)]
+    cmap = colormaps["turbo"]
+    return [tuple(cmap(i / (size - 1))[:3]) for i in range(size)]
+
+
+def _objects(shape: Any) -> dict[str, Any]:
+    """Return the named objects of a collection, or the shape itself."""
+    return dict(getattr(shape, "named_objects", None) or {"shape": shape})
+
+
+def show_decomposition_3d(
+    decomposition: Any,
+    lower_bound: Any,
+    upper_bound: Any,
+    num_gridpoints: Any,
+    *,
+    shape: Any = None,
+    opacity: float = 0.25,
+    shape_opacity: float = 1.0,
+    resolution: int = 48,
+    legend: bool | None = None,
+    plotter: Any = None,
+    display: bool = True,
+    save: Any = None,
+) -> Any:
+    """Draw the subdomains of a 3D decomposition with plasma-plots; return the plotter."""
+    if decomposition.ndim != 3:
+        raise ValueError("show_3d needs a three-dimensional decomposition")
+    try:
+        import pyvista as pv
+        from plasma_plots.pyvista_plots import pyvista_surfaces
+    except ImportError as exc:
+        raise ImportError("Interactive 3D needs simgeometry[interactive]") from exc
+
+    boxes = decomposition.subdomain_boxes(lower_bound, upper_bound, num_gridpoints)
+    if legend is None:
+        legend = len(boxes) <= _MAX_LEGEND_RANKS
+    meshes = {}
+    for rank, (lower, upper) in enumerate(boxes):
+        box = pv.Box(
+            bounds=(lower[0], upper[0], lower[1], upper[1], lower[2], upper[2]),
+            quads=True,
+        )
+        box.point_data["rank"] = np.full(box.n_points, rank)
+        meshes[f"rank {rank}"] = box
+    if plotter is None:
+        plotter = pv.Plotter(off_screen=not display)
+    pyvista_surfaces(
+        meshes,
+        colors=None if not legend else _rank_colors(len(boxes)),
+        scalars=None if legend else "rank",
+        cmap="turbo",
+        opacity=opacity,
+        show_edges=True,
+        legend=legend,
+        plotter=plotter,
+    )
+    if shape is not None:
+        if shape.ndim != 3:
+            raise ValueError("shape must be three-dimensional")
+        bounds = (np.asarray(lower_bound, float), np.asarray(upper_bound, float))
+        shapes = {
+            name: obj.to_mesh(
+                resolution=resolution,
+                bounds=bounds if getattr(obj, "inverted", False) else None,
+            )
+            for name, obj in _objects(shape).items()
+        }
+        pyvista_surfaces(
+            shapes,
+            colors=["0.55"] * len(shapes),
+            opacity=shape_opacity,
+            legend=False,
+            plotter=plotter,
+        )
+    plotter.show_bounds(
+        bounds=np.array([lower_bound, upper_bound], dtype=float).T.ravel(),
+        location="outer",
+        xtitle="x",
+        ytitle="y",
+        ztitle="z",
+        n_xlabels=3,
+        n_ylabels=3,
+        n_zlabels=3,
+        fmt="%.2g",
+    )
+    # x to the right, y into the picture and z up, so rank 0 is in front.
+    plotter.view_vector((1.0, -1.0, 1.0))
+    plotter.reset_camera()
+    plotter.camera.zoom(0.9)
+    if legend and plotter.legend is not None:
+        plotter.legend.SetPosition(0.82, 0.70)  # clear of the boxes
+    if display or save:
+        plotter.show(screenshot=str(save) if save else None, auto_close=False)
+    return plotter
+
+
+def show_decomposition_2d(
+    decomposition: Any,
+    lower_bound: Any,
+    upper_bound: Any,
+    num_gridpoints: Any,
+    *,
+    shape: Any = None,
+    ax: Any = None,
+    opacity: float = 0.35,
+    labels: bool = True,
+    display: bool = True,
+    save: Any = None,
+) -> Any:
+    """Draw the subdomains of a 2D decomposition with Matplotlib; return the axes."""
+    if decomposition.ndim != 2:
+        raise ValueError("show needs a two-dimensional decomposition")
+    import matplotlib.pyplot as plt
+    from matplotlib.patches import Rectangle
+
+    from simgeometry.visualization import _finish
+
+    if ax is None:
+        ax = plt.figure(layout="constrained").add_subplot()
+    boxes = decomposition.subdomain_boxes(lower_bound, upper_bound, num_gridpoints)
+    colors = _rank_colors(len(boxes))
+    for rank, ((x0, y0), (x1, y1)) in enumerate(boxes):
+        ax.add_patch(
+            Rectangle(
+                (x0, y0),
+                x1 - x0,
+                y1 - y0,
+                facecolor=(*colors[rank], opacity),
+                edgecolor=colors[rank],
+                linewidth=1.5,
+            )
+        )
+        if labels:
+            ax.text(
+                (x0 + x1) / 2,
+                (y0 + y1) / 2,
+                f"rank {rank}",
+                ha="center",
+                va="center",
+                fontsize="small",
+            )
+    if shape is not None:
+        if shape.ndim != 2:
+            raise ValueError("shape must be two-dimensional")
+        for obj in _objects(shape).values():
+            closed = getattr(obj, "closed", True)
+            for loop in obj.outlines():
+                if closed:
+                    loop = np.concatenate([loop, loop[:, :1]], axis=1)
+                ax.plot(*loop, color="black", linewidth=1.2, solid_capstyle="round")
+    ax.set_xlim(lower_bound[0], upper_bound[0])
+    ax.set_ylim(lower_bound[1], upper_bound[1])
+    ax.set_aspect("equal")
+    ax.set_xlabel("x")
+    ax.set_ylabel("y")
+    return _finish(ax, display, save)