simgeometry 0.1.0__py3-none-any.whl

simgeometry/visualization.py

@@ -0,0 +1,381 @@
+"""Optional 1D/2D inspection and 3D surface viewers.
+
+Matplotlib is the default backend; PyVista adds interactive clipping widgets.
+Plots are sampled views. Increase resolution before interpreting small features.
+"""
+
+from __future__ import annotations
+
+from itertools import product
+
+import numpy as np
+
+
+def _finish(ax, display, save):
+    import matplotlib.pyplot as plt
+
+    if save:
+        ax.figure.savefig(save, bbox_inches="tight")
+    if display:
+        plt.show()
+    return ax
+
+
+def show(
+    shape,
+    *,
+    x=None,
+    y=None,
+    z=None,
+    ax=None,
+    resolution=None,
+    bounds=None,
+    grid=None,
+    nodes=False,
+    labels=True,
+    normals=False,
+    show_bounds=False,
+    color=None,
+    color_by="name",
+    opacity=0.65,
+    display=True,
+    save=None,
+    **kwargs,
+):
+    """Plot occupancy or a slice; dimensions and coordinates are labelled."""
+    import matplotlib.pyplot as plt
+    from matplotlib.colors import ListedColormap
+    from matplotlib.patches import Patch
+
+    selectors = {k: v for k, v in zip("xyz", (x, y, z)) if v is not None}
+    if resolution is None:
+        resolution = 48 if shape.ndim == 3 and not selectors else 128
+    if shape.ndim == 3 and not selectors:
+        return show_3d(
+            shape,
+            ax=ax,
+            resolution=resolution,
+            bounds=bounds,
+            grid=grid,
+            nodes=nodes,
+            labels=labels,
+            normals=normals,
+            show_bounds=show_bounds,
+            color=color,
+            color_by=color_by,
+            opacity=opacity,
+            display=display,
+            save=save,
+            **kwargs,
+        )
+    if color_by not in (None, "name"):
+        raise ValueError("color_by must be 'name' or None")
+    if grid is True:
+        raise ValueError("Pass a Grid object, or use domain.show(grid=True)")
+    if grid is not None and grid.ndim != shape.ndim:
+        raise ValueError("Grid and geometry dimensions must match")
+    grid_axes = list(grid.get_grid_points()) if grid is not None else None
+    if selectors:
+        if len(selectors) != 1:
+            raise ValueError("Select one coordinate for a geometry slice")
+        source_names = getattr(shape, "axis_names", tuple("xyz"[: shape.ndim]))
+        name = next(iter(selectors))
+        if name not in source_names:
+            raise ValueError(f"Available slice axes are {source_names}")
+        axis = source_names.index(name)
+        shape = shape.slice(**selectors)
+        if grid_axes is not None:
+            grid_axes.pop(axis)
+        if bounds is not None:
+            bounds = tuple(np.delete(v, axis) for v in bounds)
+    names = getattr(shape, "axis_names", tuple("xyz"[: shape.ndim]))
+    coordinates = dict(zip(names, grid_axes)) if grid_axes is not None else {}
+    quantity = "labels" if hasattr(shape, "labels") else "occupancy"
+    values = shape.evaluate(
+        **coordinates, resolution=resolution, bounds=bounds, quantity=quantity
+    )
+    ax = ax or plt.subplots()[1]
+    if shape.ndim == 1:
+        ax.step(
+            values.coords[names[0]], values.values, where="mid", color=color, **kwargs
+        )
+        ax.set_ylabel(quantity)
+    else:
+        xs, ys = (values.coords[n].values for n in names)
+        object_names = getattr(shape, "names", ("geometry",))
+        styles = getattr(
+            shape, "styles", getattr(getattr(shape, "source", None), "styles", {})
+        )
+        colors = [
+            styles.get(name, {}).get(
+                "color",
+                styles.get(name, {}).get(
+                    "facecolor", color or (f"C{i % 10}" if color_by == "name" else "C0")
+                ),
+            )
+            for i, name in enumerate(object_names)
+        ]
+        cmap = ListedColormap(colors or [color or "C0"])
+        data = np.ma.masked_where(values.values == 0, values.values.astype(float) - 1)
+        style = {
+            "cmap": cmap,
+            "vmin": -0.5,
+            "vmax": max(len(colors) - 0.5, 0.5),
+            "alpha": opacity,
+            **kwargs,
+        }
+        ax.pcolormesh(xs, ys, data.T, shading="nearest", **style)
+        if labels and len(object_names):
+            ax.legend(
+                handles=[Patch(color=c, label=n) for n, c in zip(object_names, colors)]
+            )
+        if grid_axes is not None:
+            for value in xs:
+                ax.axvline(value, color="gray", linewidth=0.4, alpha=0.5)
+            for value in ys:
+                ax.axhline(value, color="gray", linewidth=0.4, alpha=0.5)
+        if nodes:
+            xx, yy = np.meshgrid(xs, ys, indexing="ij")
+            ax.scatter(
+                xx.ravel(),
+                yy.ravel(),
+                c=(values.values != 0).ravel(),
+                cmap="coolwarm",
+                s=5,
+            )
+        if normals:
+            mesh = shape.to_mesh(resolution=resolution, bounds=bounds)
+            stride = max(1, len(mesh.cells) // 48)
+            ax.quiver(*mesh.centres[::stride].T, *mesh.normals[::stride].T, angles="xy")
+        if show_bounds:
+            lower, upper = bounds or (shape.lower_bound, shape.upper_bound)
+            ax.plot(
+                [lower[0], upper[0], upper[0], lower[0], lower[0]],
+                [lower[1], lower[1], upper[1], upper[1], lower[1]],
+                color="black",
+            )
+        ax.set_aspect("equal")
+        ax.set_ylabel(names[1])
+    ax.set_xlabel(names[0])
+    if selectors:
+        ax.set_title(", ".join(f"{k} = {v:g}" for k, v in selectors.items()))
+    return _finish(ax, display, save)
+
+
+def _clip_triangles(vertices, faces, origin, normal):
+    """Clip each triangle against a half-space, without adding artificial caps."""
+    origin, normal = np.asarray(origin, float), np.asarray(normal, float)
+    if (
+        origin.shape != (3,)
+        or normal.shape != (3,)
+        or not np.all(np.isfinite([origin, normal]))
+        or np.linalg.norm(normal) == 0
+    ):
+        raise ValueError("Clip plane needs finite 3D origin and nonzero normal")
+    triangles = []
+    for triangle in vertices[faces]:
+        polygon = []
+        for a, b in zip(triangle, np.roll(triangle, -1, axis=0)):
+            da, db = np.dot(a - origin, normal), np.dot(b - origin, normal)
+            if da >= 0:
+                polygon.append(a)
+            if (da >= 0) != (db >= 0):
+                polygon.append(a + da / (da - db) * (b - a))
+        for i in range(1, len(polygon) - 1):
+            triangles.append([polygon[0], polygon[i], polygon[i + 1]])
+    vertices = np.asarray(triangles).reshape(-1, 3)
+    return vertices, np.arange(len(vertices)).reshape(-1, 3)
+
+
+def _box_edges(lower, upper):
+    vertices = np.array(list(product(*zip(lower, upper))))
+    return np.array(
+        [
+            [a, b]
+            for i, a in enumerate(vertices)
+            for b in vertices[i + 1 :]
+            if np.count_nonzero(a != b) == 1
+        ]
+    )
+
+
+def show_3d(
+    shape,
+    *,
+    ax=None,
+    resolution=48,
+    bounds=None,
+    opacity=0.65,
+    wireframe=False,
+    normals=False,
+    labels=True,
+    color=None,
+    color_by="name",
+    grid=None,
+    nodes=False,
+    show_bounds=True,
+    clip=None,
+    backend="matplotlib",
+    display=True,
+    save=None,
+    **kwargs,
+):
+    """Render surfaces; return axes or an optional PyVista Plotter.
+
+    clip=(origin, normal) retains the positive half-space, without caps.
+    clip=True enables a PyVista clipping widget. PyVista callers own and should
+    close the returned plotter. No MPI operations are performed.
+    """
+    if shape.ndim != 3:
+        raise ValueError("show_3d requires three-dimensional geometry")
+    if backend not in ("matplotlib", "pyvista"):
+        raise ValueError("backend must be matplotlib or pyvista")
+    if color_by not in (None, "name"):
+        raise ValueError("color_by must be 'name' or None")
+    if grid is True:
+        raise ValueError("Pass a Grid object, or use domain.show_3d(grid=True)")
+    if grid is not None and grid.ndim != 3:
+        raise ValueError("A 3D view requires a 3D grid")
+    objects = getattr(shape, "named_objects", {"geometry": shape})
+    styles = getattr(shape, "styles", {})
+    lower, upper = bounds or (shape.lower_bound, shape.upper_bound)
+    if backend == "pyvista":
+        try:
+            from importlib import import_module
+
+            pv = import_module("pyvista")
+        except ImportError as exc:
+            raise ImportError("Interactive 3D needs simgeometry[interactive]") from exc
+        plotter = ax if ax is not None else pv.Plotter(off_screen=not display)
+    else:
+        import matplotlib.pyplot as plt
+        from matplotlib.colors import to_rgba
+        from matplotlib.patches import Patch
+        from mpl_toolkits.mplot3d.art3d import Line3DCollection, Poly3DCollection
+
+        if clip is True:
+            raise ValueError(
+                "Use backend='pyvista' for interactive clipping, or supply a plane"
+            )
+        ax = ax if ax is not None else plt.figure().add_subplot(projection="3d")
+        if not hasattr(ax, "set_zlabel"):
+            raise ValueError("Pass 3D axes to show_3d")
+        handles = []
+    for i, (name, obj) in enumerate(objects.items()):
+        mesh = obj.to_mesh(
+            resolution=resolution,
+            bounds=bounds
+            if bounds is not None
+            else ((lower, upper) if obj.inverted else None),
+        )
+        vertices, faces = mesh.vertices, mesh.cells
+        if clip is not None and clip is not False and clip is not True:
+            vertices, faces = _clip_triangles(vertices, faces, *clip)
+        if not len(faces):
+            continue
+        style = dict(styles.get(name, {}))
+        chosen = style.pop(
+            "color",
+            style.pop(
+                "facecolor", color or (f"C{i % 10}" if color_by == "name" else "C0")
+            ),
+        )
+        alpha = style.pop("opacity", style.pop("alpha", opacity))
+        if backend == "pyvista":
+            # Resolve Matplotlib cycle colors to RGB before passing to VTK.
+            from matplotlib.colors import to_rgb
+
+            data = pv.PolyData(
+                vertices, np.column_stack((np.full(len(faces), 3), faces)).ravel()
+            )
+            add = plotter.add_mesh_clip_plane if clip is True else plotter.add_mesh
+            add(
+                data,
+                color=to_rgb(chosen),
+                opacity=alpha,
+                style="wireframe" if wireframe else "surface",
+                label=name if labels else None,
+                **style,
+                **kwargs,
+            )
+            if normals:
+                stride = max(1, len(mesh.cells) // 64)
+                plotter.add_arrows(
+                    mesh.centres[::stride],
+                    mesh.normals[::stride],
+                    mag=float(np.max(np.asarray(upper) - lower)) * 0.05,
+                )
+        else:
+            artist = Poly3DCollection(
+                vertices[faces],
+                facecolors="none" if wireframe else to_rgba(chosen, alpha),
+                edgecolors=chosen if wireframe else "none",
+                **style,
+                **kwargs,
+            )
+            ax.add_collection3d(artist)
+            handles.append(Patch(color=chosen, label=name))
+            if normals:
+                triangles = vertices[faces][:: max(1, len(faces) // 64)]
+                points = triangles.mean(axis=1).T
+                normal = np.cross(
+                    triangles[:, 1] - triangles[:, 0], triangles[:, 2] - triangles[:, 0]
+                )
+                normal /= np.linalg.norm(normal, axis=1)[:, None]
+                ax.quiver(
+                    *points,
+                    *normal.T,
+                    length=float(np.max(np.asarray(upper) - lower)) * 0.05,
+                )
+    if backend == "pyvista":
+        if show_bounds:
+            plotter.show_bounds(bounds=np.array([lower, upper]).T.ravel())
+        if grid is not None:
+            edges = _grid_lines_3d(grid)
+            for segment in edges:
+                plotter.add_lines(segment, color="gray", width=1)
+            if nodes:
+                plotter.add_points(grid.node_points().T, point_size=4)
+        if labels and objects:
+            plotter.add_legend()
+        if display or save:
+            plotter.show(screenshot=str(save) if save else None, auto_close=False)
+        return plotter
+    if show_bounds:
+        ax.add_collection3d(
+            Line3DCollection(_box_edges(lower, upper), colors="black", linewidths=0.6)
+        )
+    if grid is not None:
+        ax.add_collection3d(
+            Line3DCollection(
+                _grid_lines_3d(grid), colors="gray", linewidths=0.3, alpha=0.4
+            )
+        )
+        if nodes:
+            ax.scatter(*grid.node_points(), s=2, alpha=0.25)
+    for setter, a, b in zip((ax.set_xlim, ax.set_ylim, ax.set_zlim), lower, upper):
+        setter(a, b)
+    from matplotlib.ticker import MaxNLocator
+
+    for axis in (ax.xaxis, ax.yaxis, ax.zaxis):
+        axis.set_major_locator(MaxNLocator(nbins=4))
+    ax.set_box_aspect(np.asarray(upper) - lower)
+    ax.set_xlabel("x")
+    ax.set_ylabel("y")
+    ax.set_zlabel("z")
+    if labels and handles:
+        ax.legend(handles=handles)
+    return _finish(ax, display, save)
+
+
+def _grid_lines_3d(grid):
+    axes = grid.get_grid_points()
+    segments = []
+    for axis in range(3):
+        other = [i for i in range(3) if i != axis]
+        for values in product(*(axes[i] for i in other)):
+            a, b = np.zeros(3), np.zeros(3)
+            a[other], b[other] = values, values
+            a[axis], b[axis] = grid.lower_bound[axis], grid.upper_bound[axis]
+            segments.append([a, b])
+    return np.asarray(segments)

simgeometry-0.1.0.dist-info/METADATA

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: simgeometry
+Version: 0.1.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
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.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: maybempi>=0.1
+Requires-Dist: mpiarray>=0.1.0
+Requires-Dist: numpy
+Provides-Extra: dev
+Requires-Dist: jupyterlab; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: pyproject-fmt; extra == "dev"
+Requires-Dist: pyright; extra == "dev"
+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: ipykernel; extra == "docs"
+Requires-Dist: matplotlib>=3.10.9; extra == "docs"
+Requires-Dist: nbclient>=0.11; extra == "docs"
+Requires-Dist: nbformat>=5.11.1; extra == "docs"
+Provides-Extra: clip
+Requires-Dist: shapely>=2; extra == "clip"
+Provides-Extra: evaluate
+Requires-Dist: xarray; extra == "evaluate"
+Provides-Extra: mesh
+Requires-Dist: scikit-image>=0.22; extra == "mesh"
+Provides-Extra: plot
+Requires-Dist: matplotlib>=3.10; extra == "plot"
+Requires-Dist: simgeometry[evaluate,mesh]; extra == "plot"
+Provides-Extra: interactive
+Requires-Dist: pyvista>=0.44; extra == "interactive"
+Requires-Dist: simgeometry[plot]; extra == "interactive"
+Provides-Extra: mpi
+Requires-Dist: mpi4py; extra == "mpi"
+Provides-Extra: pyccel
+Requires-Dist: pyccel>2.0; extra == "pyccel"
+Provides-Extra: gpu
+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: mpi4py; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: simgeometry[clip]; extra == "test"
+Dynamic: license-file
+
+# 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, 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.
+
+## 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
+tutorials](https://max-models.github.io/simgeometry/tutorials/) and [API
+guide](https://max-models.github.io/simgeometry/getting-started/geometry-api/)
+for examples and the accuracy limits of sampled operations.
+
+## Development
+
+``` bash
+pytest src/simgeometry/tests
+```
+
+Documentation: <https://max-models.github.io/simgeometry/>

simgeometry-0.1.0.dist-info/RECORD

@@ -0,0 +1,62 @@
+simgeometry/__init__.py,sha256=nf5mHb0bu5owT7LVv9sY85jzB8x0tw4q7sgFy0cHpAk,723
+simgeometry/_bounds.py,sha256=_x4gTpmbbWpaxcpnS82aeSap53GXfSPIB8eBnGY36uo,583
+simgeometry/_normalize.py,sha256=-l1arr_RSAyu8dOdX5EZDkHnNvKqo6SZ9EcXrm6nEN4,767
+simgeometry/_particle_boundaries.py,sha256=C-hrznsJlCQUNWVOA2Q4yRyxnfbzK6sYH3eWGDGlUMo,1314
+simgeometry/_types.py,sha256=Uq-RmwX9NzM5mZ7BV3kYbnb8hM7EJSBYvgYoWSo9tH8,615
+simgeometry/api.py,sha256=TvtLw24WGN3X2xWMrG_NTx9rLAI30wMxf6vPTllDtuE,9802
+simgeometry/boundingbox.py,sha256=LncuxkLbtYJLF-ZVmTGqfG672Qb5145Nsn0_n_fP8Co,7385
+simgeometry/collection.py,sha256=hDYf2fI3K7oRN_cSK1ZbPfPe9C6Eq_xBJGBs6KV8aIM,2720
+simgeometry/crossings.py,sha256=FgbhqrEkeMMmocpkhJVMWzUyYxHCrk2BT2VuLilUVKY,12712
+simgeometry/cut_edges.py,sha256=NGSYjSKn9BRJozZeSF0LO88jrAXGIrdAKoJwaz1y9SQ,12408
+simgeometry/cylindrical.py,sha256=V2zW4CiflW50-HPbczyfglcE_bwN1aZo7H6QgJD6_vo,1854
+simgeometry/domain_decomposition.py,sha256=csorErbtmyYMcCgMQgFH3a2qtDCtrHgZ6ykabEK5SAY,18629
+simgeometry/evaluation.py,sha256=A5auXqggAQHz1687HfpPF_9yetAIRZtHmtsy78RfgUg,3868
+simgeometry/fractions.py,sha256=EniF091r68CXbeKsm_qNQmQpglAhJjzYmtslyfpK2ms,2744
+simgeometry/grid.py,sha256=AXcOxZ0LAoHD3MskwHttVR8zedhefks3qH9TKPSgzo4,9237
+simgeometry/mesh.py,sha256=Cab_Q2JiOlLSV3zX8Z8lEVszypnw5hd_5cRBVHrMdN8,5821
+simgeometry/operations.py,sha256=QUgCpMZJhPzgKbPuvrQ5NqO-DG6srqEEsOVkmUJr3GY,15851
+simgeometry/panels.py,sha256=OKJkzD4V8rviYy6piJgUtyJ0axR83205UCxMO2Kjrjo,2796
+simgeometry/plotting.py,sha256=85i2RQWsbpL6y0kU-NZYZBlNHU6--zoLe0C-75IPgho,5695
+simgeometry/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+simgeometry/queries.py,sha256=Lmlc2kQViEI0PsE9F2s3TG5gq-R4yeUu0ENHXdxq0ZE,17058
+simgeometry/sampling.py,sha256=-n0RuV_nN7j5GxC4egjuIizQbNhMaeGde659dsF8O2k,2949
+simgeometry/shapes.py,sha256=Ifypi308KLTM1fpNdhYgv1pdQk7lqVwxSOwEVhqC1nQ,13935
+simgeometry/simulation_domain.py,sha256=jCS7e5OKhoW5BlIxGWuWdjGFh7LNE14WbQTOmlkv-S8,10257
+simgeometry/utils.py,sha256=OVXzau-hACj_uyp-9hzowAzL48cEQ3jokkwIWeXXqWM,692
+simgeometry/visualization.py,sha256=zxagBKYPTQyvJ9Z4nhHf6kwWGxzU7reIu9OG2O_b0zg,13726
+simgeometry/kernels/__init__.py,sha256=Dy_0n8PJdLTrOMhVae0PvE4qEjuJmJM7BBH893Kb7Gg,58
+simgeometry/kernels/_build.py,sha256=tu35VuhBI4MK3fr7qi19lCiLveakrhowh9EVVyTkNr8,1900
+simgeometry/kernels/_metal.py,sha256=47BVhlisjL-7HZfTPD2-F-MSmna8wN451fJIDUtkyXM,1307
+simgeometry/kernels/compile.py,sha256=urr_xmaw8tXOd6oud37bWZmq-UY0bQe5va55htV3mCQ,1117
+simgeometry/kernels/contains_ball/__init__.py,sha256=L3k3zxbP1V5YGZQ7Sa_in4S_vauRnK5q3IRBpVcN7Y0,455
+simgeometry/kernels/contains_ball/contains_ball_cuda.cu,sha256=1psPVSXIuCMXBGcC7G1tD8ODKyUUyUi0xCaavFdEqvg,998
+simgeometry/kernels/contains_ball/contains_ball_metal.py,sha256=DgQJc___uACqX7XcUWYZ0FB3UPEyuPRHjP_AfImzEnc,1665
+simgeometry/kernels/contains_ball/contains_ball_numpy.py,sha256=gcub-froE6hu2x2p_KaUmA9DmMhJZXEkAY7RYJiJKA4,639
+simgeometry/kernels/contains_ball/contains_ball_pyccel.py,sha256=JRoAH2boH5SD-BPYYF8nqNeILtBabdV3IPoh42yJ3dk,1193
+simgeometry/kernels/contains_box/__init__.py,sha256=Yq25a4PlIQRNGuvbSwEKJK6YfJ1nHCbBNGd_ov7bd1U,454
+simgeometry/kernels/contains_box/contains_box_cuda.cu,sha256=vhwnWR9EU_IDsjR0GhH4ti_1Sp5_qBLlx9cwv_lDt50,939
+simgeometry/kernels/contains_box/contains_box_metal.py,sha256=wbbuJjr92O4ADwkv6OLfZu8PNG4agRHp3CcbHwsj748,1559
+simgeometry/kernels/contains_box/contains_box_numpy.py,sha256=kg6t71Z0xre6ebTz58QNLkuS3se_IycqsrE9ieW6-5E,658
+simgeometry/kernels/contains_box/contains_box_pyccel.py,sha256=zyPOA0xLRobM1Gl1iknBMXmtZNsqS--o0Hm4LylpR-g,1159
+simgeometry/kernels/contains_polygon_2d/__init__.py,sha256=MnZZAjlgicPDq254YcHysf8AmfFF4JSes4xf9xohMfM,461
+simgeometry/kernels/contains_polygon_2d/contains_polygon_2d_cuda.cu,sha256=10g2bvtA5mPkTGZlPxkjDz_vbeKcQEN8b7N7-EY6cPk,1226
+simgeometry/kernels/contains_polygon_2d/contains_polygon_2d_metal.py,sha256=mUDrogUdYC1S4g_VMy9BsmV9fAax1FTBhnALr65obFY,1858
+simgeometry/kernels/contains_polygon_2d/contains_polygon_2d_numpy.py,sha256=YjAr8paCZyXQOrU5-14YvaSMJ1fHOJVkF6prDTu1_gg,822
+simgeometry/kernels/contains_polygon_2d/contains_polygon_2d_pyccel.py,sha256=4v28t9i6NYr9dotco8m82Gylq8jOE6_xjY6GbwVnPto,1455
+simgeometry/objects/__init__.py,sha256=hYrBck7eTU3A1eYyDSt81SnIaoKRIIw-RTZK5kOWCRY,936
+simgeometry/objects/aperture2d.py,sha256=0Sp7g6ZbZ6uaGFPBd030CemiZDbAsrhmd6EmqZ3UZ4I,6289
+simgeometry/objects/aperture3d.py,sha256=28RVcPaFn5WXXoGemOhTxWn4BBpMp3JZvwUkhvMtwA8,14561
+simgeometry/objects/circle.py,sha256=JQm0C1_eRldXquWtvtESdNS9fJg9kb2S6ldF2tOrBLc,4828
+simgeometry/objects/cuboid.py,sha256=rTj0IX-lHvUxDB-cXxbCZ4KDuZ-OjIDAFPZKHkUX32M,6308
+simgeometry/objects/function_object.py,sha256=thxzDKqijuWzoOGtj592a_O4F8skqtfM8xElKH7f-mA,6824
+simgeometry/objects/line.py,sha256=B7IryvfcHlci9J1zWlTloZK_dXoiTawGCEO9WI7raEo,4247
+simgeometry/objects/polygon.py,sha256=YU-FVjscOmLBpvrHQIIZ0gQS0Obix-iCkX2XtTFee60,6162
+simgeometry/objects/polyline.py,sha256=Cwb8nSVJoHZiGeNBxmraQykhY66OAWnMBxtcE3TtEGw,2596
+simgeometry/objects/rectangle.py,sha256=ZfuV-kqDrc7HTmFlJ5ptbwjuietKY8djLQv8yAZ3MYA,4637
+simgeometry/objects/sphere.py,sha256=VWEWWz6nWtQiyEZHEUnnFMfJwGsOIAoO9ZW6qgKsmU0,6431
+simgeometry/objects/triangle.py,sha256=xjEWv8y6wP9OrnyqiNBaWkk0pe2EQXDAIm9EqZ8GVS4,5499
+simgeometry-0.1.0.dist-info/licenses/LICENSE.txt,sha256=OUlDVbMHs0P7ZhgqM6Obmo2_ff1RSwNpzEJROYbma1w,1070
+simgeometry-0.1.0.dist-info/METADATA,sha256=WUWvXCJBXMCsH-WqArWY3s7fUbiSbtCudeclijNfwX8,4531
+simgeometry-0.1.0.dist-info/WHEEL,sha256=a-udL2m4V_6Yn8b-uKzWb12RjRxwwMo6ohYFM24tpaY,91
+simgeometry-0.1.0.dist-info/top_level.txt,sha256=VdQfEVxy9w8_S19sGhQZOSsKNuj3zhNyycDVmq4YYhM,12
+simgeometry-0.1.0.dist-info/RECORD,,

simgeometry-0.1.0.dist-info/WHEEL

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

simgeometry-0.1.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Max Lindqvist
+
+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.

simgeometry-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+simgeometry