simgeometry 0.1.0__py3-none-any.whl

simgeometry/objects/function_object.py

@@ -0,0 +1,214 @@
+"""Function-based geometric object definitions."""
+
+from __future__ import annotations
+
+from typing import Any, Callable
+
+import cunumpy as xp
+
+from simgeometry._types import Array, BoundsLike, ConfigValue
+from simgeometry.shapes import Shape2D, Shape3D
+
+
+class FunctionObject2D(Shape2D):
+    """Represent an arbitrary 2D geometry object defined by a Boolean function.
+
+    The object interior is the set of all points for which ``func(coords)``
+    returns ``True``.  A bounding box must be supplied by the caller because
+    it cannot in general be derived from an arbitrary function.
+
+    Example
+    -------
+    Create a ring (annulus) with inner radius 1 and outer radius 2::
+
+        def ring(coords):
+            x, y = coords
+            r2 = x**2 + y**2
+            return 1.0**2 <= r2 <= 2.0**2
+
+        obj = FunctionObject2D(
+            func=ring,
+            lower_bound=(-2.0, -2.0),
+            upper_bound=(2.0, 2.0),
+        )
+    """
+
+    def __init__(
+        self,
+        func: Callable[[Array], bool],
+        lower_bound: BoundsLike,
+        upper_bound: BoundsLike,
+        bc: ConfigValue = None,
+        inverted: bool = False,
+    ) -> None:
+        """
+        Initialize a function-based 2D object.
+
+        Parameters
+        ----------
+        func:
+            A callable that accepts a coordinate array ``(x, y)`` and returns
+            ``True`` if the point lies inside the object.
+        lower_bound:
+            Lower corner ``(x_min, y_min)`` of the bounding box.
+        upper_bound:
+            Upper corner ``(x_max, y_max)`` of the bounding box.
+        bc:
+            Optional boundary condition information.
+        inverted:
+            If ``True``, the object covers every point where ``func`` is falsy.
+        """
+        assert callable(func), "func must be callable."
+        assert len(lower_bound) == 2, "lower_bound must have two coordinates."
+        assert len(upper_bound) == 2, "upper_bound must have two coordinates."
+
+        self._func = func
+        self._bc = bc
+        self._inverted = bool(inverted)
+
+        super().__init__(
+            lower_bound=tuple(lower_bound),
+            upper_bound=tuple(upper_bound),
+        )
+
+    @property
+    def func(self) -> Callable[[Array], bool]:
+        """Return the Boolean membership function."""
+        return self._func
+
+    def contains(self, coords: Array) -> bool:
+        """
+        Check if the given coordinates are inside the object.
+
+        Parameters
+        ----------
+        coords:
+            ``(x, y)`` coordinates to test.
+
+        Returns
+        -------
+        bool
+            ``True`` if ``func(coords)`` is truthy (falsy when inverted).
+        """
+        return self._apply_inversion(bool(self._func(xp.to_numpy(coords))))
+
+    def plot(self, ax: Any = None, **kwargs: Any) -> Any:
+        """Draw the object as a sampled mask into ``ax`` and return the axes.
+
+        ``resolution`` (samples per axis) and ``bounds`` set the sampling of the
+        mask, other keyword arguments style the image. With an inspection option
+        (``x``, ``y``, ``z``, ``grid``, ``nodes``, ``normals``) this is
+        :meth:`Shape2D.plot`.
+        """
+        if any(key in kwargs for key in ("x", "y", "z", "grid", "nodes", "normals")):
+            return super().plot(ax=ax, **kwargs)
+        from simgeometry.plotting import draw_shape
+
+        return draw_shape(self, ax=ax, **kwargs)
+
+
+class FunctionObject3D(Shape3D):
+    """Represent an arbitrary 3D geometry object defined by a Boolean function.
+
+    The object interior is the set of all points for which ``func(coords)``
+    returns ``True``.  A bounding box must be supplied by the caller because
+    it cannot in general be derived from an arbitrary function.
+
+    Example
+    -------
+    Create a solid torus with major radius 3 and tube radius 1::
+
+        def torus(coords):
+            x, y, z = coords
+            r = (x**2 + y**2)**0.5
+            return (r - 3.0)**2 + z**2 <= 1.0**2
+
+        obj = FunctionObject3D(
+            func=torus,
+            lower_bound=(-4.0, -4.0, -1.0),
+            upper_bound=(4.0, 4.0, 1.0),
+        )
+    """
+
+    def __init__(
+        self,
+        func: Callable[[Array], bool],
+        lower_bound: BoundsLike,
+        upper_bound: BoundsLike,
+        bc: ConfigValue = None,
+        inverted: bool = False,
+    ) -> None:
+        """
+        Initialize a function-based 3D object.
+
+        Parameters
+        ----------
+        func:
+            A callable that accepts a coordinate array ``(x, y, z)`` and
+            returns ``True`` if the point lies inside the object.
+        lower_bound:
+            Lower corner ``(x_min, y_min, z_min)`` of the bounding box.
+        upper_bound:
+            Upper corner ``(x_max, y_max, z_max)`` of the bounding box.
+        bc:
+            Optional boundary condition information.
+        inverted:
+            If ``True``, the object covers every point where ``func`` is falsy.
+        """
+        assert callable(func), "func must be callable."
+        assert len(lower_bound) == 3, "lower_bound must have three coordinates."
+        assert len(upper_bound) == 3, "upper_bound must have three coordinates."
+
+        self._func = func
+        self._bc = bc
+        self._inverted = bool(inverted)
+
+        super().__init__(
+            lower_bound=tuple(lower_bound),
+            upper_bound=tuple(upper_bound),
+        )
+
+    @property
+    def func(self) -> Callable[[Array], bool]:
+        """Return the Boolean membership function."""
+        return self._func
+
+    def contains(self, coords: Array) -> bool:
+        """
+        Check if the given coordinates are inside the object.
+
+        Parameters
+        ----------
+        coords:
+            ``(x, y, z)`` coordinates to test.
+
+        Returns
+        -------
+        bool
+            ``True`` if ``func(coords)`` is truthy (falsy when inverted).
+        """
+        return self._apply_inversion(bool(self._func(xp.to_numpy(coords))))
+
+    def get_vertices(
+        self,
+        slice_axis: int = 0,
+        slice_position: float | None = None,
+    ) -> tuple:
+        """Return an empty array; vertices cannot be derived from an arbitrary function."""
+        import cunumpy as xp
+
+        return xp.array([]), self.inverted
+
+    def volume(self) -> float:
+        """Volume cannot be analytically derived from an arbitrary function."""
+        raise NotImplementedError(
+            "volume() is not available for FunctionObject3D. "
+            "Use numerical integration if needed.",
+        )
+
+    def surface_area(self) -> float:
+        """Surface area cannot be analytically derived from an arbitrary function."""
+        raise NotImplementedError(
+            "surface_area() is not available for FunctionObject3D. "
+            "Use numerical methods if needed.",
+        )

simgeometry/objects/line.py

@@ -0,0 +1,127 @@
+"""Line helpers for geometric object definitions."""
+
+from __future__ import annotations
+
+import cunumpy as xp
+
+from simgeometry._types import Array, BoundsLike, ConfigValue
+from simgeometry.shapes import Shape1D, _component_major
+
+
+class Line(Shape1D):
+    """Represent a line geometry object."""
+
+    def __init__(
+        self,
+        midpoint: BoundsLike,
+        side_lengths: BoundsLike,
+        bc: ConfigValue = None,
+        inverted: bool = False,
+    ) -> None:
+        """
+        Initialize a line in 1D space.
+
+        Parameters:
+        midpoint (list or tuple): Coordinates of the midpoint of the rectangle.
+        side_lengths (list or tuple): Lengths of the sides of the rectangle in each dimension.
+        bc (optional): Boundary condition information.
+        inverted (bool, optional): Cover everything except the line.
+        """
+        assert len(midpoint) == 1, (
+            f"Length of midpoint must match ndim (2). {len(midpoint) =}"
+        )
+        assert len(side_lengths) == 1, "Length of side_lengths must match ndim."
+
+        self.midpoint = xp.array(midpoint)
+        self.side_lengths = xp.array(side_lengths)
+        self._bc = bc
+        self._inverted = bool(inverted)
+
+        # Calculate bounds based on the midpoint and side lengths
+        half_lengths = self.side_lengths / 2
+        lower_bound = tuple(self.midpoint - half_lengths)
+        upper_bound = tuple(self.midpoint + half_lengths)
+
+        super().__init__(
+            lower_bound=lower_bound,
+            upper_bound=upper_bound,
+        )
+
+    def mirror(self, axis: int, position: float) -> None:
+        """
+        Mirror the line across a specified axis at a given position.
+
+        Parameters:
+            axis (int): Axis index (0 for x-axis).
+            position (float): Position along the axis to mirror.
+        """
+        if axis != 0:
+            raise ValueError("Axis must be 0 (x-axis).")
+
+        # Mirror the midpoint coordinate along the specified axis
+        self.midpoint[axis] = 2 * position - self.midpoint[axis]
+
+        half_lengths = self.side_lengths / 2
+        lower_bound = tuple(self.midpoint - half_lengths)
+        upper_bound = tuple(self.midpoint + half_lengths)
+
+        self.set_bounding_box(lower_bound, upper_bound)
+
+    def copy(self) -> Line:
+        """
+        Create a copy of the line.
+
+        Returns:
+            Line: A new instance of Line with the same midpoint, side lengths, and boundary conditions.
+        """
+        return Line(
+            midpoint=self.midpoint.copy(),
+            side_lengths=self.side_lengths.copy(),
+            bc=self._bc,
+            inverted=self._inverted,
+        )
+
+    def translate(self, offset: tuple[float]) -> None:
+        """
+        Translate the line by the given offset.
+
+        Parameters:
+            offset (tuple): (dx,) translation vector.
+        """
+        offset_vec = xp.asarray(offset)
+
+        # Apply translation
+        self.midpoint = self.midpoint + offset_vec
+
+        half_lengths = self.side_lengths / 2
+        lower_bound = tuple(self.midpoint - half_lengths)
+        upper_bound = tuple(self.midpoint + half_lengths)
+
+        self.set_bounding_box(lower_bound, upper_bound)
+
+    def get_vertices(self) -> ConfigValue:
+        """Return the vertices that define the object."""
+        return [(self.lower_bound[0], self.upper_bound[0])]
+
+    def contains(self, coords: Array) -> bool:
+        """
+        Check if the given coordinates are inside the line.
+
+        Parameters:
+        coords (list or tuple): Coordinates for each dimension.
+
+        Returns:
+        bool: True if the coordinates are inside the line, False otherwise.
+        """
+        assert len(coords) == 1, f"Expected 1 dimension, got {len(coords)}."
+
+        coords = xp.to_numpy(coords)
+        return self._apply_inversion(
+            bool(self.lower_bound[0] <= coords[0] <= self.upper_bound[0])
+        )
+
+    def contains_points(self, points: Array) -> Array:
+        """Vectorised :meth:`contains`: a mask of the ``(1, n)`` points inside."""
+        points = _component_major(points, 1)
+        inside = (self.lower_bound[0] <= points[0]) & (points[0] <= self.upper_bound[0])
+        return ~inside if self.inverted else inside

simgeometry/objects/polygon.py

@@ -0,0 +1,182 @@
+"""Polygon helpers for geometric object definitions."""
+
+from __future__ import annotations
+
+import cunumpy as xp
+import numpy as np
+from numpy import ndarray
+
+from simgeometry.kernels.contains_polygon_2d import kernel as contains_polygon_2d
+from simgeometry.shapes import Shape2D, _component_major
+from simgeometry.utils import vertices_to_bounds
+
+
+class Polygon(Shape2D):
+    """Represent a polygon geometry object."""
+
+    exact_outline = True
+
+    def __init__(
+        self,
+        vertices: ndarray,
+        bc: float | None = None,
+        inverted: bool = False,
+    ) -> None:
+        """
+        Initialize a polygon in 2D space.
+
+        Parameters:
+        vertices (list or tuple): List of tuples, each representing a vertex (x, y).
+        bc (optional): Boundary condition information.
+        inverted (bool, optional): Cover everything except the polygon.
+        """
+        assert len(vertices) >= 3, "Polygon must have at least three vertices."
+        assert all(len(vertex) == 2 for vertex in vertices), (
+            "Each vertex must have two coordinates."
+        )
+
+        self.vertices = xp.array(vertices)  # Use setter
+        self._bc = bc
+        self._inverted = bool(inverted)
+
+        # Calculate bounds tuple
+        lower_bound, upper_bound = vertices_to_bounds(self.vertices)
+
+        super().__init__(
+            lower_bound=lower_bound,
+            upper_bound=upper_bound,
+        )
+
+    @property
+    def vertices(self) -> ndarray:
+        """Return object vertices."""
+        return self._vertices
+
+    @vertices.setter
+    def vertices(self, vertices: ndarray) -> None:
+        """Set the vertices."""
+        self._vertices = vertices
+
+    def copy(self) -> Polygon:
+        """
+        Create a copy of the polygon.
+
+        Returns:
+            Polygon: A new instance of Polygon with the same vertices and boundary conditions.
+        """
+        return Polygon(
+            vertices=self.vertices.copy(),
+            bc=self._bc,
+            inverted=self._inverted,
+        )
+
+    def translate(self, offset: tuple[float, float]) -> None:
+        """
+        Translate the polygon by the given offset.
+
+        Parameters:
+            offset (tuple): (dx, dy) translation vector.
+        """
+        offset_vec = xp.asarray(offset)  # , dtype=self._vertices.dtype)
+
+        # Apply translation
+        self.vertices = self.vertices + offset_vec
+
+        lower_bound, upper_bound = vertices_to_bounds(self.vertices)
+
+        self.set_bounding_box(lower_bound, upper_bound)
+
+    # TODO: Enable mirroring along arbitrary axes
+    def mirror(self, axis: int, position: float) -> None:
+        """
+        Mirror the polygon across a specified axis at a given position.
+
+        Parameters:
+            axis (int): Axis to mirror across (0 for x-axis, 1 for y-axis).
+            position (float): Position along the axis to mirror.
+        """
+        assert axis in (0, 1), "Axis must be 0 (x-axis) or 1 (y-axis)."
+
+        # Create a copy of the vertices to avoid modifying during iteration
+        new_vertices = self.vertices.copy()
+
+        # Apply mirroring
+        for i in range(len(new_vertices)):
+            if axis == 0:  # Mirror across x-axis
+                new_vertices[i][1] = 2 * position - new_vertices[i][1]
+            else:  # Mirror across y-axis
+                new_vertices[i][0] = 2 * position - new_vertices[i][0]
+
+        self.vertices = new_vertices
+
+        lower_bound, upper_bound = vertices_to_bounds(self.vertices)
+
+        self.set_bounding_box(lower_bound, upper_bound)
+
+    def _corner_loops(self) -> list[np.ndarray]:
+        """The polygon's vertices as one ``(2, n)`` loop."""
+        return [np.asarray(xp.to_numpy(self._vertices), dtype=float).T.copy()]
+
+    def _contains_polygon(self, coords: ndarray) -> bool:
+        """
+        Check if the given coordinates are inside the polygon.
+
+        Parameters:
+        coords (list or tuple): Coordinates (x, y).
+
+        Returns:
+        bool: True if the point is inside the polygon, False otherwise.
+        """
+        coords = xp.to_numpy(coords)
+        vertices = xp.to_numpy(self._vertices)
+        x, y = coords
+
+        # First check if the point is inside the bounding box
+        if not self.bounding_box.contains(coords):
+            return False
+
+        # Ray casting algorithm for point-in-polygon
+        num_vertices = len(vertices)
+        inside = False
+        j = num_vertices - 1
+        for i in range(num_vertices):
+            xi, yi = vertices[i]
+            xj, yj = vertices[j]
+            if ((yi > y) != (yj > y)) and (
+                x < (xj - xi) * (y - yi) / ((yj - yi) + 1e-16) + xi
+            ):
+                inside = not inside
+            j = i
+        return inside
+        # return [self._vertices]
+
+    def contains(self, coords: ndarray) -> bool:
+        """
+        Check if the given coordinates are inside the (possibly inverted) polygon.
+
+        Parameters:
+        coords (list or tuple): Coordinates (x, y).
+
+        Returns:
+        bool: True if the point is inside the object, False otherwise.
+        """
+        return self._apply_inversion(self._contains_polygon(coords))
+
+    def contains_points(self, points: ndarray) -> ndarray:
+        """Vectorised :meth:`contains`: a mask of the ``(2, n)`` points inside."""
+        points = xp.asarray(_component_major(points, 2), dtype=float)
+        if points.shape[1] == 0:  # the compiled kernels reject empty arrays
+            return xp.zeros(0, dtype=bool)
+        vertices = xp.kernels.as_kernel_array(self._vertices, like=points, dtype=float)
+        lower = xp.asarray(self.bounding_box.lower_bound, dtype=float)[:, None]
+        upper = xp.asarray(self.bounding_box.upper_bound, dtype=float)[:, None]
+        inside = xp.empty(points.shape[1], dtype=bool)
+        contains_polygon_2d(
+            xp.kernels.as_kernel_array(points, like=points, dtype=float),
+            inside,
+            vertices,
+            0,
+        )
+        inside &= (points[0] >= lower[0]) & (points[0] < upper[0])
+        inside &= (points[1] >= lower[1]) & (points[1] < upper[1])
+        return ~inside if self.inverted else inside

simgeometry/objects/polyline.py

@@ -0,0 +1,67 @@
+"""Open polylines: curves of zero thickness, such as thin plates and wires."""
+
+from __future__ import annotations
+
+import cunumpy as xp
+import numpy as np
+from numpy import ndarray
+
+from simgeometry._types import ConfigValue
+from simgeometry.shapes import Shape2D, _component_major
+from simgeometry.utils import vertices_to_bounds
+
+
+class Polyline(Shape2D):
+    """An open curve through ``vertices``: a thin plate, wire or grid of zero thickness.
+
+    It encloses no area, so :meth:`contains` is always False and it cannot be
+    inverted or combined in Boolean shapes. Its geometry is its outline, an open
+    polyline from the first vertex to the last (``closed`` is False), which
+    :meth:`~simgeometry.shapes.Shape2D.boundary_panels` and ``crossings()`` use
+    directly.
+    """
+
+    exact_outline = True
+    closed = False
+
+    def __init__(self, vertices: ndarray, bc: ConfigValue = None) -> None:
+        """
+        Initialize a polyline in 2D space.
+
+        Parameters:
+        vertices (list or tuple): At least two ``(x, y)`` vertices, in order along the
+            curve; consecutive vertices must differ.
+        bc (optional): Boundary condition information.
+        """
+        points = np.asarray(xp.to_numpy(xp.asarray(vertices, dtype=float)), dtype=float)
+        if points.ndim != 2 or points.shape[1] != 2 or points.shape[0] < 2:
+            raise ValueError("A polyline needs at least two (x, y) vertices")
+        if np.any(np.hypot(*np.diff(points, axis=0).T) == 0):
+            raise ValueError("Consecutive polyline vertices must differ")
+        self._vertices = points
+        self._bc = bc
+        lower_bound, upper_bound = vertices_to_bounds(points)
+        super().__init__(lower_bound=lower_bound, upper_bound=upper_bound)
+
+    @property
+    def vertices(self) -> ndarray:
+        """The ``(n, 2)`` vertices, one row per point, as given."""
+        return self._vertices
+
+    @property
+    def length(self) -> float:
+        """The length of the curve."""
+        return float(np.hypot(*np.diff(self._vertices, axis=0).T).sum())
+
+    def _corner_loops(self) -> list[np.ndarray]:
+        """The vertices as one open ``(2, n)`` polyline."""
+        return [self._vertices.T.copy()]
+
+    def contains(self, coords: tuple[float, float]) -> bool:
+        """Always False: a curve encloses no area."""
+        return False
+
+    def contains_points(self, points: ndarray) -> ndarray:
+        """An all-False mask of the ``(2, n)`` points: a curve encloses no area."""
+        points = _component_major(points, 2)
+        return xp.zeros(points.shape[1], dtype=bool)