simgeometry 0.1.0__py3-none-any.whl

simgeometry/kernels/contains_polygon_2d/contains_polygon_2d_cuda.cu

@@ -0,0 +1,35 @@
+// The CUDA version (GPU) of the contains_polygon_2d kernel;
+// contains_polygon_2d_pyccel.py next to this file is the Pyccel version (CPU),
+// with the same arguments.  Loaded by picnic.kernels.catalog: one thread per
+// marker (positions are (2, N)), even-odd ray casting over the (n, 2) vertices.
+
+#include "cunumpy/array_view.cuh"
+
+extern "C" __global__
+void contains_polygon_2d(
+    Array2D<double> positions,
+    Array1D<char> mask,
+    Array2D<double> vertices,
+    int inverted
+) {
+    const long long marker = blockDim.x * (long long)blockIdx.x + threadIdx.x;
+    if (marker >= positions.shape[1]) return;
+    const double x = positions(0, marker);
+    const double y = positions(1, marker);
+    const long long n = vertices.shape[0];
+    bool inside = false;
+    double xj = vertices(n - 1, 0);
+    double yj = vertices(n - 1, 1);
+    for (long long i = 0; i < n; ++i) {
+        const double xi = vertices(i, 0);
+        const double yi = vertices(i, 1);
+        if ((yi > y) != (yj > y)
+            && x < (xj - xi) * (y - yi) / ((yj - yi) + 1e-16) + xi) {
+            inside = !inside;
+        }
+        xj = xi;
+        yj = yi;
+    }
+    if (inverted == 1) inside = !inside;
+    mask(marker) = inside ? 1 : 0;
+}

simgeometry/kernels/contains_polygon_2d/contains_polygon_2d_metal.py

@@ -0,0 +1,58 @@
+"""The Metal version (Apple-silicon GPU, float32) of the ``contains_polygon_2d`` kernel.
+
+``contains_polygon_2d_pyccel.py`` next to this file is the CPU version with the same
+arguments. One thread per marker (``positions`` is ``(2, N)``); see :mod:`simgeometry.kernels._metal`. The test is
+done in float32, so a marker within about 1e-7 (relative) of the boundary may be
+classified differently from the CPU version.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from simgeometry._types import Array
+from simgeometry.kernels._metal import make_kernel
+
+_SOURCE = """
+    uint marker = thread_position_in_grid.x;
+    uint n_markers = positions_shape[1];
+    if (marker >= n_markers) return;
+    float x = positions[marker];
+    float y = positions[n_markers + marker];
+    int n = (int)vertices_shape[0];
+    bool inside = false;
+    float xj = vertices[2 * (n - 1)];
+    float yj = vertices[2 * (n - 1) + 1];
+    for (int i = 0; i < n; ++i) {
+        float xi = vertices[2 * i];
+        float yi = vertices[2 * i + 1];
+        if ((yi > y) != (yj > y) && x < (xj - xi) * (y - yi) / ((yj - yi) + 1e-16f) + xi) {
+            inside = !inside;
+        }
+        xj = xi;
+        yj = yi;
+    }
+    if (flags[0] == 1) inside = !inside;
+    inside_flag[marker] = inside ? 1 : 0;
+"""
+
+_KERNEL = make_kernel(
+    "simgeometry_contains_polygon_2d",
+    _SOURCE,
+    inputs=["positions", "vertices", "flags"],
+    outputs=["inside_flag"],
+)
+
+
+def contains_polygon_2d(
+    positions: Array,
+    mask: Array,
+    vertices: Array,
+    inverted: int,
+) -> None:
+    """Set ``mask[marker]`` to whether the marker lies inside the polygon."""
+    if not positions.shape[1]:
+        return
+    flags = np.zeros(positions.shape[1], dtype=np.uint8)
+    _KERNEL(positions, vertices, np.array([inverted], dtype=np.int32), out=flags)
+    mask[:] = flags.astype(bool)

simgeometry/kernels/contains_polygon_2d/contains_polygon_2d_numpy.py

@@ -0,0 +1,28 @@
+"""The NumPy version of the ``contains_polygon_2d`` kernel, run when Pyccel is unavailable.
+
+Same arguments and result as ``contains_polygon_2d_pyccel.py``, vectorized over
+the markers (a loop over the vertices).
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+
+def contains_polygon_2d(
+    positions: np.ndarray,
+    mask: np.ndarray,
+    vertices: np.ndarray,
+    inverted: int,
+) -> None:
+    """Set ``mask`` to whether each marker lies inside the polygon."""
+    x = positions[0]
+    y = positions[1]
+    inside = np.zeros(positions.shape[1], dtype=bool)
+    xj, yj = vertices[-1]
+    for xi, yi in vertices:
+        inside ^= ((yi > y) != (yj > y)) & (
+            x < (xj - xi) * (y - yi) / ((yj - yi) + 1e-16) + xi
+        )
+        xj, yj = xi, yi
+    mask[...] = ~inside if inverted == 1 else inside

simgeometry/kernels/contains_polygon_2d/contains_polygon_2d_pyccel.py

@@ -0,0 +1,40 @@
+"""Mask of the markers inside a 2D polygon, by even-odd ray casting.
+
+The Pyccel version (CPU) of the ``contains_polygon_2d`` kernel;
+``contains_polygon_2d_cuda.cu`` next to this file is the CUDA version (GPU), with
+the same arguments.  ``positions`` is ``(2, N)`` (component-major), ``vertices`` is (n, 2), the closing edge implied.  The same
+crossing rule as ``Markers._polygon_contains_points``.  With ``inverted == 1``
+the mask is negated.
+"""
+
+
+def contains_polygon_2d(
+    positions: "float[:,:]",
+    mask: "bool[:]",
+    vertices: "float[:,:]",
+    inverted: int,
+) -> None:
+    """Set ``mask[marker]`` to whether the marker lies inside the polygon."""
+    num_markers = positions.shape[1]
+    num_vertices = vertices.shape[0]
+    # fmt: off
+    #$ omp parallel for private(x, y, inside, xj, yj, i, xi, yi) schedule(dynamic, 2048)
+    # fmt: on
+    for marker in range(num_markers):
+        x = positions[0, marker]
+        y = positions[1, marker]
+        inside = False
+        xj = vertices[num_vertices - 1, 0]
+        yj = vertices[num_vertices - 1, 1]
+        for i in range(num_vertices):
+            xi = vertices[i, 0]
+            yi = vertices[i, 1]
+            if (yi > y) != (yj > y) and x < (xj - xi) * (y - yi) / (
+                (yj - yi) + 1e-16
+            ) + xi:
+                inside = not inside
+            xj = xi
+            yj = yi
+        if inverted == 1:
+            inside = not inside
+        mask[marker] = inside

simgeometry/mesh.py

@@ -0,0 +1,147 @@
+"""Sampled surface meshes and portable export formats."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+import numpy as np
+
+from simgeometry.evaluation import sampling_axes
+from simgeometry.operations import mask
+
+
+@dataclass(frozen=True)
+class SurfaceMesh:
+    """Vertices (n, ndim), segments/triangles, and sampling spacing.
+
+    Empty cells mean no boundary was resolved in the requested region.
+    ``spacing`` describes the sampling, not a guaranteed error bound. Surfaces
+    touching the sampling bounds can be open. Coordinates are physical.
+    """
+
+    vertices: np.ndarray
+    cells: np.ndarray
+    spacing: tuple[float, ...]
+
+    @property
+    def centres(self):
+        """Segment/triangle centres, shape (ncells, ndim)."""
+        return self.vertices[self.cells].mean(axis=1)
+
+    @property
+    def normals(self):
+        """Outward unit normals of mesh segments/triangles (faceted approximation)."""
+        cells = self.vertices[self.cells]
+        edge = cells[:, 1] - cells[:, 0]
+        normal = (
+            np.column_stack((edge[:, 1], -edge[:, 0]))
+            if self.vertices.shape[1] == 2
+            else np.cross(edge, cells[:, 2] - cells[:, 0])
+        )
+        length = np.linalg.norm(normal, axis=1)
+        return normal / np.where(length > 0, length, np.nan)[:, None]
+
+    def save(self, path):
+        """Write .npz, .obj (segments or triangles), or ASCII .stl (3D)."""
+        path = Path(path)
+        suffix = path.suffix.lower()
+        if suffix == ".npz":
+            np.savez(
+                path, vertices=self.vertices, cells=self.cells, spacing=self.spacing
+            )
+        elif suffix == ".obj":
+            vertices = np.pad(self.vertices, ((0, 0), (0, 3 - self.vertices.shape[1])))
+            lines = ["# simgeometry sampled surface\n"]
+            lines += ["v " + " ".join(f"{v:.17g}" for v in p) + "\n" for p in vertices]
+            prefix = "f" if self.cells.shape[1] == 3 else "l"
+            lines += [
+                prefix + " " + " ".join(str(int(i) + 1) for i in cell) + "\n"
+                for cell in self.cells
+            ]
+            path.write_text("".join(lines))
+        elif suffix == ".stl" and self.vertices.shape[1] == 3:
+            lines = ["solid simgeometry\n"]
+            for triangle in self.vertices[self.cells]:
+                normal = np.cross(triangle[1] - triangle[0], triangle[2] - triangle[0])
+                length = np.linalg.norm(normal)
+                normal = normal / length if length else normal
+                lines.append(
+                    "facet normal "
+                    + " ".join(f"{v:.17g}" for v in normal)
+                    + "\nouter loop\n"
+                )
+                lines += [
+                    "vertex " + " ".join(f"{v:.17g}" for v in p) + "\n"
+                    for p in triangle
+                ]
+                lines.append("endloop\nendfacet\n")
+            lines.append("endsolid simgeometry\n")
+            path.write_text("".join(lines))
+        else:
+            raise ValueError("Use .npz, .obj, or .stl for 3D triangles")
+        return path
+
+
+def to_mesh(shape, *, resolution=64, bounds=None):
+    if shape.ndim not in (2, 3):
+        raise ValueError("Surface meshing requires 2D or 3D geometry")
+    try:
+        from skimage.measure import find_contours, marching_cubes
+    except ImportError as exc:
+        raise ImportError("Surface meshing requires simgeometry[mesh]") from exc
+    from simgeometry.queries import BALLS, BOXES
+
+    if bounds is None:
+        lower, upper = np.asarray(shape.lower_bound), np.asarray(shape.upper_bound)
+        pad = (upper - lower) * 0.05
+        bounds = (lower - pad, upper + pad)
+    axes = sampling_axes(shape, resolution, bounds)
+    dimensions = tuple(len(a) for a in axes)
+    spacing = tuple(float(a[1] - a[0]) for a in axes)
+    points = np.stack([a.ravel() for a in np.meshgrid(*axes, indexing="ij")])
+    # Continuous implicit functions improve primitive surface placement; generic
+    # membership masks have an uncertainty of roughly a sampling cell.
+    if isinstance(shape, BALLS):
+        values = shape.radius - np.linalg.norm(
+            points - np.asarray(shape.midpoint)[:, None], axis=0
+        )
+    elif isinstance(shape, BOXES):
+        centre = (np.asarray(shape.lower_bound) + shape.upper_bound) / 2
+        half = (np.asarray(shape.upper_bound) - shape.lower_bound) / 2
+        q = abs(points - centre[:, None]) - half[:, None]
+        values = -(
+            np.linalg.norm(np.maximum(q, 0), axis=0) + np.minimum(np.max(q, axis=0), 0)
+        )
+    else:
+        values = mask(shape, points).astype(float) - 0.5
+    if isinstance(shape, (*BALLS, *BOXES)) and shape.inverted:
+        values = -values
+    values = values.reshape(dimensions)
+    if not (values.min() < 0 < values.max()):
+        return SurfaceMesh(
+            np.empty((0, shape.ndim)), np.empty((0, shape.ndim), dtype=int), spacing
+        )
+    if shape.ndim == 2:
+        vertices, cells = [], []
+        offset = 0
+        for contour in find_contours(values, 0, positive_orientation="high"):
+            vertices.extend(
+                contour * np.asarray(spacing) + np.array([a[0] for a in axes])
+            )
+            cells.extend((offset + i, offset + i + 1) for i in range(len(contour) - 1))
+            offset += len(contour)
+        return SurfaceMesh(
+            np.asarray(vertices).reshape(-1, 2),
+            np.asarray(cells, dtype=int).reshape(-1, 2),
+            spacing,
+        )
+    vertices, faces, _, _ = marching_cubes(
+        values,
+        level=0,
+        spacing=spacing,
+        allow_degenerate=False,
+        gradient_direction="ascent",
+    )
+    vertices += np.array([a[0] for a in axes])
+    return SurfaceMesh(vertices, faces, spacing)

simgeometry/objects/__init__.py

@@ -0,0 +1,35 @@
+"""Package exports for geometric object definitions."""
+
+# 1D objects
+# 2D objects
+from simgeometry.objects.aperture2d import Aperture2D
+from simgeometry.objects.aperture3d import Aperture3D
+from simgeometry.objects.circle import Circle
+from simgeometry.objects.cuboid import Cuboid
+from simgeometry.objects.function_object import FunctionObject2D, FunctionObject3D
+from simgeometry.objects.line import Line
+from simgeometry.objects.polygon import Polygon
+from simgeometry.objects.polyline import Polyline
+from simgeometry.objects.rectangle import Rectangle
+
+# 3D objects
+from simgeometry.objects.sphere import Sphere
+from simgeometry.objects.triangle import Triangle
+
+__all__ = [
+    # 2D objects
+    "Aperture2D",
+    "Aperture3D",
+    "Circle",
+    "Cuboid",
+    "FunctionObject2D",
+    "FunctionObject3D",
+    # 1D objects
+    "Line",
+    "Polygon",
+    "Polyline",
+    "Rectangle",
+    # 3D objects
+    "Sphere",
+    "Triangle",
+]

simgeometry/objects/aperture2d.py

@@ -0,0 +1,183 @@
+"""Two-dimensional aperture helpers for geometric object definitions."""
+
+from __future__ import annotations
+
+import numpy as np
+from numpy import ndarray
+
+from simgeometry._types import ConfigValue
+from simgeometry.objects.polygon import Polygon
+from simgeometry.shapes import Shape2D
+
+
+class Aperture2D(Shape2D):
+    """Two plates mirrored about a beam axis: a slit, or the 2D cut of a round aperture.
+
+    The beam runs along coordinate ``axis`` (0 for x, 1 for y), on the centre line
+    where the other coordinate equals ``position``. ``vertices`` are the plate profile
+    as ``(axial, radial)`` pairs: the coordinate along the beam and the distance from
+    the centre line. One plate is the polygon at ``position + radial``, the other its
+    mirror image at ``position - radial``. :meth:`slit` builds the common rectangular
+    plates.
+    """
+
+    exact_outline = True
+
+    def __init__(
+        self,
+        axis: int,
+        position: float,
+        vertices: tuple[tuple[float, float], ...],
+        bc: ConfigValue = None,
+        inverted: bool = False,
+    ) -> None:
+        """
+        Initialize a 2D aperture object.
+
+        Parameters:
+            axis (int): The beam axis, 0 (along x) or 1 (along y).
+            position (float): The centre line: the coordinate across the beam,
+                ``y`` for ``axis=0`` and ``x`` for ``axis=1``.
+            vertices (list or tuple): The plate profile as ``(axial, radial)``
+                vertices.
+            bc (optional): Boundary condition information.
+            inverted (bool, optional): Cover everything except the two plates.
+        """
+
+        self.axis = axis
+        self._position = position
+        self.vertices = vertices
+        self._bc = bc
+        self._inverted = bool(inverted)
+
+        lower, upper = self._plate_vertices()
+        self._lower_polygon = Polygon(vertices=lower, bc=bc)
+        self._upper_polygon = Polygon(vertices=upper, bc=bc)
+
+        super().__init__(
+            lower_bound=tuple(
+                min(lower, upper)
+                for lower, upper in zip(
+                    self._lower_polygon.lower_bound,
+                    self._upper_polygon.lower_bound,
+                )
+            ),
+            upper_bound=tuple(
+                max(lower, upper)
+                for lower, upper in zip(
+                    self._lower_polygon.upper_bound,
+                    self._upper_polygon.upper_bound,
+                )
+            ),
+        )
+
+    @classmethod
+    def slit(
+        cls,
+        axial_position: float,
+        half_width: float,
+        thickness: float,
+        length: float,
+        *,
+        axis: int = 0,
+        position: float = 0.0,
+        bc: ConfigValue = None,
+        inverted: bool = False,
+    ) -> Aperture2D:
+        """A slit: two rectangular plates with a gap of ``2 * half_width`` between them.
+
+        The plates are ``thickness`` thick along the beam, centred on
+        ``axial_position``, and extend ``length`` outward from the gap.
+        """
+        if not (half_width >= 0 and thickness > 0 and length > 0):
+            raise ValueError(
+                "A slit needs half_width >= 0 and positive thickness and length"
+            )
+        front, back = axial_position - thickness / 2, axial_position + thickness / 2
+        tip, outer = half_width, half_width + length
+        return cls(
+            axis=axis,
+            position=position,
+            vertices=((front, tip), (back, tip), (back, outer), (front, outer)),
+            bc=bc,
+            inverted=inverted,
+        )
+
+    @property
+    def axis(self) -> int:
+        """Return the beam axis."""
+        return self._axis
+
+    @axis.setter
+    def axis(self, value: int) -> None:
+        """Set the beam axis."""
+        assert value in [0, 1], "Axis must be one of 0 or 1."
+        self._axis = value
+
+    def _plate_vertices(self) -> tuple[ndarray, ndarray]:
+        """The ``(n, 2)`` vertices of the plate below and the plate above the centre line."""
+        profile = np.asarray(self.vertices, dtype=float)
+        axial, radial = profile[:, 0], profile[:, 1]
+        plates = []
+        for across in (self.position - radial, self.position + radial):
+            points = (axial, across) if self.axis == 0 else (across, axial)
+            plates.append(np.stack(points, axis=1))
+        return plates[0], plates[1]
+
+    def _corner_loops(self) -> list[np.ndarray]:
+        """One loop per plate: the lower plate, then the upper one."""
+        return [
+            loop
+            for plate in (self._lower_polygon, self._upper_polygon)
+            for loop in plate._corner_loops()
+        ]
+
+    def contains(self, coords: ndarray) -> bool:
+        """
+        Check if the given coordinates are inside one of the plates.
+
+        Parameters:
+        coords (list or tuple): Coordinates (x, y).
+
+        Returns:
+        bool: True if the point is inside a plate, False otherwise.
+        """
+
+        inside = self._lower_polygon.contains(coords) or self._upper_polygon.contains(
+            coords
+        )
+        return self._apply_inversion(inside)
+
+    def contains_points(self, points: ndarray) -> ndarray:
+        """Vectorised :meth:`contains`: a mask of the ``(2, n)`` points inside."""
+        inside = self._lower_polygon.contains_points(
+            points
+        ) | self._upper_polygon.contains_points(points)
+        return ~inside if self.inverted else inside
+
+    @property
+    def vertices(self) -> tuple[tuple[float, float], ...]:
+        """Return the plate profile as ``(axial, radial)`` vertices."""
+        return self._vertices
+
+    @vertices.setter
+    def vertices(self, value: tuple) -> None:
+        """Set the vertices."""
+        for vertex in value:
+            assert len(vertex) == 2, "vertices must be a tuple of length 2."
+        self._vertices = value
+
+    @property
+    def rvec(self) -> list:
+        """Return the radial aperture coordinate vector."""
+        return [v[1] for v in self.vertices]
+
+    @property
+    def zvec(self) -> list:
+        """Return the axial aperture coordinate vector."""
+        return [v[0] for v in self.vertices]
+
+    @property
+    def position(self) -> float:
+        """Return the centre line's coordinate across the beam."""
+        return self._position