simgeometry 0.1.0__py3-none-any.whl

simgeometry/objects/rectangle.py

@@ -0,0 +1,130 @@
+"""Rectangle helpers for geometric object definitions."""
+
+from __future__ import annotations
+
+from operator import add, sub
+
+import cunumpy as xp
+import numpy as np
+
+from simgeometry._types import Array, ConfigValue
+from simgeometry.shapes import Shape2D, _component_major
+
+
+class Rectangle(Shape2D):
+    """Represent a rectangular geometry object."""
+
+    exact_outline = True
+
+    def __init__(
+        self,
+        midpoint: tuple | list,
+        side_lengths: tuple,
+        bc: ConfigValue = None,
+        inverted: bool = False,
+    ) -> None:
+        """
+        Initialize a rectangle in 2D 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 rectangle.
+        """
+        assert len(midpoint) == 2, (
+            f"Length of midpoint must match ndim (2). {len(midpoint) =}"
+        )
+        assert len(side_lengths) == 2, "Length of side_lengths must match ndim."
+
+        self.midpoint = list(midpoint)
+        self.side_lengths = side_lengths
+        self._bc = bc
+        self._inverted = bool(inverted)
+
+        # Calculate bounds based on the midpoint and side lengths
+        half_lengths = tuple(len / 2 for len in self.side_lengths)
+        lower_bound = tuple(map(sub, self.midpoint, half_lengths))
+        upper_bound = tuple(map(add, self.midpoint, half_lengths))
+
+        super().__init__(
+            lower_bound=lower_bound,
+            upper_bound=upper_bound,
+        )
+
+    def mirror(self, axis: int, position: float) -> None:
+        """
+        Mirror the rectangle across a specified axis at a given position.
+
+        Parameters:
+            axis (int): Axis index (0 for x-axis, 1 for y-axis).
+            position (float): Position along the axis to mirror.
+        """
+        if axis < 0 or axis > 1:
+            raise ValueError("Axis must be 0 (x-axis) or 1 (y-axis).")
+
+        # Mirror the midpoint coordinate along the specified axis
+        self.midpoint[axis] = 2 * position - self.midpoint[axis]
+
+        half_lengths = tuple(len / 2 for len in self.side_lengths)
+        lower_bound = tuple(map(sub, self.midpoint, half_lengths))
+        upper_bound = tuple(map(add, self.midpoint, half_lengths))
+
+        self.set_bounding_box(lower_bound, upper_bound)
+
+    def copy(self) -> Rectangle:
+        """
+        Create a copy of the rectangle.
+
+        Returns:
+            Rectangle: A new instance of Rectangle with the same midpoint, side lengths, and boundary conditions.
+        """
+        return Rectangle(
+            midpoint=self.midpoint.copy(),
+            side_lengths=self.side_lengths,
+            bc=self._bc,
+            inverted=self._inverted,
+        )
+
+    def translate(self, offset: tuple[float, float]) -> None:
+        """
+        Translate the xyz by the given offset.
+
+        Parameters:
+            offset (tuple): (dx, dy) translation vector.
+        """
+        offset_vec = xp.asarray(offset)
+
+        # Apply translation
+        self.midpoint = list(xp.asarray(self.midpoint) + offset_vec)
+
+        half_lengths = tuple(len / 2 for len in self.side_lengths)
+        lower_bound = tuple(map(sub, self.midpoint, half_lengths))
+        upper_bound = tuple(map(add, self.midpoint, half_lengths))
+
+        self.set_bounding_box(lower_bound, upper_bound)
+
+    def _corner_loops(self) -> list[np.ndarray]:
+        """The four corners as one counter-clockwise ``(2, 4)`` loop."""
+        (xmin, ymin), (xmax, ymax) = self.lower_bound, self.upper_bound
+        return [np.array([[xmin, xmax, xmax, xmin], [ymin, ymin, ymax, ymax]], float)]
+
+    def contains(self, coords: Array) -> bool:
+        """
+        Check if the given coordinates are inside the rectangle.
+
+        Parameters:
+        coords (list or tuple): Coordinates for each dimension.
+
+        Returns:
+        bool: True if the coordinates are inside the rectangle, False otherwise.
+        """
+        return self._apply_inversion(self.bounding_box.contains(coords))
+
+    def contains_points(self, points: Array) -> Array:
+        """Vectorised :meth:`contains`: a mask of the ``(2, n)`` points inside."""
+        points = _component_major(points, 2)
+        lower = xp.asarray(self.bounding_box.lower_bound, dtype=float)[:, None]
+        upper = xp.asarray(self.bounding_box.upper_bound, dtype=float)[:, None]
+        inside = xp.all((points >= lower) & (points < upper), axis=0)
+        return ~inside if self.inverted else inside

simgeometry/objects/sphere.py

@@ -0,0 +1,181 @@
+"""Sphere helpers for geometric object definitions."""
+
+from __future__ import annotations
+
+import cunumpy as xp
+
+from simgeometry._types import Array, ConfigValue
+from simgeometry.shapes import Shape3D, _component_major
+
+
+class Sphere(Shape3D):
+    """Represent a spherical geometry object."""
+
+    def __init__(
+        self,
+        midpoint: list | tuple,
+        radius: float,
+        bc: ConfigValue = None,
+        inverted: bool = False,
+    ) -> None:
+        """
+        Initialize a sphere in 3D.
+
+        Parameters:
+        midpoint (list or tuple): Coordinates of the midpoint of the sphere.
+        radius (float): Radius of the sphere.
+        bc (optional): Boundary condition information.
+        """
+        assert len(midpoint) == 3, "Length of midpoint must be 3 for 3D Sphere."
+        assert isinstance(radius, (int, float)) and radius > 0, (
+            "Radius must be a positive number."
+        )
+
+        self.midpoint = list(midpoint)
+        self.radius = radius
+        self._bc = bc
+        self._inverted = bool(inverted)
+
+        # Calculate bounds based on the midpoint and radius
+        lower_bound = tuple(m - self.radius for m in self.midpoint)
+        upper_bound = tuple(m + self.radius for m in self.midpoint)
+
+        super().__init__(
+            lower_bound=lower_bound,
+            upper_bound=upper_bound,
+        )
+
+    def mirror(self, axis: int, position: float) -> None:
+        """
+        Mirror the sphere across a specified axis at a given position.
+
+        Parameters:
+            axis (int): Axis index (0 for x-axis, 1 for y-axis, 2 for z-axis).
+            position (float): Position along the axis to mirror.
+        """
+        if axis < 0 or axis > 2:
+            raise ValueError("Axis must be 0 (x-axis), 1 (y-axis), or 2 (z-axis).")
+
+        # Mirror the midpoint coordinate along the specified axis
+        self.midpoint[axis] = 2 * position - self.midpoint[axis]
+
+        lower_bound = tuple(m - self.radius for m in self.midpoint)
+        upper_bound = tuple(m + self.radius for m in self.midpoint)
+
+        self.set_bounding_box(lower_bound, upper_bound)
+
+    def copy(self) -> Sphere:
+        """
+        Create a copy of the sphere.
+
+        Returns:
+            Sphere: A new instance of Sphere with the same midpoint, radius, and boundary conditions.
+        """
+        return Sphere(
+            midpoint=self.midpoint.copy(),
+            radius=self.radius,
+            bc=self._bc,
+            inverted=self._inverted,
+        )
+
+    def translate(self, offset: tuple[float, float]) -> None:
+        """
+        Translate the xyz by the given offset.
+
+        Parameters:
+            offset (tuple): (dx, dy) translation vector.
+        """
+        offset_vec = xp.asarray(offset)
+
+        # Apply translation
+        self.midpoint = list(xp.asarray(self.midpoint) + offset_vec)
+
+        lower_bound = tuple(m - self.radius for m in self.midpoint)
+        upper_bound = tuple(m + self.radius for m in self.midpoint)
+
+        self.set_bounding_box(lower_bound, upper_bound)
+
+    def get_vertices(self, slice_axis: int, slice_position: float) -> ConfigValue:
+        """
+        Get the vertices of a slice of the sphere along a given axis.
+
+        Parameters:
+        slice_axis (int): Axis along which to slice (0 for x, 1 for y, 2 for z).
+        slice_position (float): Position along the slice_axis where the slice is taken.
+
+        Returns:
+        vertices (ndarray): Array of vertices defining the slice circle.
+                            If the slice does not intersect the sphere, returns an empty array.
+        """
+        assert 0 <= slice_axis < 3, "slice_axis must be 0, 1, or 2."
+
+        inverted = self.inverted
+
+        # Calculate the distance from the sphere center to the slicing plane
+        distance = abs(slice_position - self.midpoint[slice_axis])
+
+        # Check if the plane intersects the sphere
+        if distance > self.radius:
+            # The plane does not intersect the sphere
+            return xp.array([]), inverted
+
+        elif distance == self.radius:
+            # The plane touches the sphere at a single point
+            axis1 = (slice_axis + 1) % 3
+            axis2 = (slice_axis + 2) % 3
+            point = xp.array([self.midpoint[axis1], self.midpoint[axis2]])
+            return xp.array([point]), inverted
+
+        else:
+            # The plane intersects the sphere in a circle
+            # Compute the radius of the circle
+            r = xp.sqrt(self.radius**2 - distance**2)
+
+            # Get the center of the circle in the plane
+            axis1 = (slice_axis + 1) % 3
+            axis2 = (slice_axis + 2) % 3
+            center1 = self.midpoint[axis1]
+            center2 = self.midpoint[axis2]
+
+            # Generate points along the circle
+            N = 100  # Number of points to approximate the circle
+            theta = xp.linspace(0, 2 * xp.pi, N)
+            x = center1 + r * xp.cos(theta)
+            y = center2 + r * xp.sin(theta)
+
+            # Combine x and y into an array of vertices
+            vertices = xp.column_stack((x, y))
+
+            return xp.array(vertices), inverted
+
+    def contains(self, coords: Array) -> bool:
+        """
+        Check if the given coordinates are inside the sphere.
+
+        Parameters:
+        coords (list or tuple): Coordinates for each dimension.
+
+        Returns:
+        bool: True if the coordinates are inside the sphere, False otherwise.
+        """
+        coords = xp.asarray(coords, dtype=float)
+        midpoint = xp.asarray(self.midpoint, dtype=float)
+        distance_squared = xp.sum((coords - midpoint) ** 2)
+        inside = bool(distance_squared <= self.radius**2)
+        return (not inside) if self.inverted else inside
+
+    def contains_points(self, points: Array) -> Array:
+        """Vectorised :meth:`contains`: a mask of the ``(3, n)`` points inside."""
+        points = _component_major(points, 3)
+        midpoint = xp.asarray(self.midpoint, dtype=float)[:, None]
+        distance_squared = xp.sum((points - midpoint) ** 2, axis=0)
+        inside = distance_squared <= self.radius**2
+        return ~inside if self.inverted else inside
+
+    def volume(self) -> float:
+        """Calculate the volume of the sphere."""
+        return (4 / 3) * xp.pi * self.radius**3
+
+    def surface_area(self) -> float:
+        """Calculate the surface area of the sphere."""
+        return 4 * xp.pi * self.radius**2

simgeometry/objects/triangle.py

@@ -0,0 +1,148 @@
+"""Triangle helpers for geometric object definitions."""
+
+from __future__ import annotations
+
+import cunumpy as xp
+import numpy as np
+
+from simgeometry._types import Array, ConfigValue, Vertices2DLike
+from simgeometry.shapes import Shape2D, _component_major
+from simgeometry.utils import vertices_to_bounds
+
+
+class Triangle(Shape2D):
+    """Represent a triangular geometry object."""
+
+    exact_outline = True
+
+    def __init__(
+        self,
+        vertices: Vertices2DLike,
+        bc: ConfigValue = None,
+        inverted: bool = False,
+    ) -> None:
+        """
+        Initialize a triangle in 2D space.
+
+        Parameters:
+        vertices (list or tuple): List of three tuples, each representing a vertex (x, y).
+        bc (optional): Boundary condition information.
+        inverted (bool, optional): Cover everything except the triangle.
+        """
+        assert len(vertices) == 3, "Triangle must have exactly three vertices."
+        assert all(len(vertex) == 2 for vertex in vertices), (
+            "Each vertex must have two coordinates."
+        )
+
+        self._vertices = [xp.array(vertex) for vertex in vertices]
+        self._bc = bc
+        self._inverted = bool(inverted)
+
+        # Calculate bounds
+        xs = [vertex[0] for vertex in self._vertices]
+        ys = [vertex[1] for vertex in self._vertices]
+
+        lower_bound = (min(xs), min(ys))
+        upper_bound = (max(xs), max(ys))
+
+        super().__init__(
+            lower_bound=lower_bound,
+            upper_bound=upper_bound,
+        )
+
+    def mirror(self, axis: int, position: float) -> None:
+        """
+        Mirror the triangle across a specified axis at a given position.
+
+        Parameters:
+            axis (int): Axis index (0 for x-axis, 1 for y-axis).
+            position (float): Position along the axis to mirror.
+        """
+        for i in range(3):
+            if axis == 0:  # Mirror across vertical line x = position
+                self._vertices[i][0] = 2 * position - self._vertices[i][0]
+            elif axis == 1:  # Mirror across horizontal line y = position
+                self._vertices[i][1] = 2 * position - self._vertices[i][1]
+            else:
+                raise ValueError("Axis must be 0 (x-axis) or 1 (y-axis).")
+
+        lower_bound, upper_bound = vertices_to_bounds(xp.array(self._vertices))
+
+        self.set_bounding_box(lower_bound, upper_bound)
+
+    def copy(self) -> Triangle:
+        """
+        Create a copy of the triangle.
+
+        Returns:
+            Triangle: A new instance of Triangle with the same vertices and boundary conditions.
+        """
+        vertices_copy = [vertex.copy() for vertex in self._vertices]
+        return Triangle(vertices=vertices_copy, bc=self._bc, inverted=self._inverted)
+
+    def translate(self, offset: tuple[float, float]) -> None:
+        """
+        Translate the xyz by the given offset.
+
+        Parameters:
+            offset (tuple): (dx, dy) translation vector.
+        """
+        offset_vec = xp.asarray(offset)
+
+        # Apply translation to each vertex
+        for i in range(3):
+            self._vertices[i] += offset_vec
+
+        lower_bound, upper_bound = vertices_to_bounds(xp.array(self._vertices))
+
+        self.set_bounding_box(lower_bound, upper_bound)
+
+    def contains(self, coords: Array) -> bool:
+        """
+        Check if the given coordinates are inside the (possibly inverted) triangle.
+
+        Parameters:
+        coords (list or tuple): Coordinates (x, y).
+
+        Returns:
+        bool: True if the point is inside the object, False otherwise.
+        """
+        # Use the same arithmetic as the batch path. Separate scalar dot
+        # products can round differently at an edge and disagree with node_mask.
+        point = xp.asarray(coords, dtype=float).reshape(2, 1)
+        return bool(xp.to_numpy(self.contains_points(point))[0])
+
+    def contains_points(self, points: Array) -> Array:
+        """Vectorised :meth:`contains`: a mask of the ``(2, n)`` points inside."""
+        points = _component_major(points, 2)
+        vertices = [xp.asarray(vertex, dtype=float) for vertex in self._vertices]
+        lower = xp.asarray(self.bounding_box.lower_bound, dtype=float)[:, None]
+        upper = xp.asarray(self.bounding_box.upper_bound, dtype=float)[:, None]
+        in_box = xp.all((points >= lower) & (points < upper), axis=0)
+        # Barycentric coordinates for every point, including the edges.
+        v0 = vertices[2] - vertices[0]
+        v1 = vertices[1] - vertices[0]
+        v2x = points[0] - vertices[0][0]
+        v2y = points[1] - vertices[0][1]
+        dot00 = v0[0] * v0[0] + v0[1] * v0[1]
+        dot01 = v0[0] * v1[0] + v0[1] * v1[1]
+        dot02 = v0[0] * v2x + v0[1] * v2y
+        dot11 = v1[0] * v1[0] + v1[1] * v1[1]
+        dot12 = v1[0] * v2x + v1[1] * v2y
+        denom = dot00 * dot11 - dot01 * dot01
+        if denom == 0:
+            inside = xp.zeros(points.shape[1], dtype=bool)  # degenerate triangle
+        else:
+            inv_denom = 1 / denom
+            u = (dot11 * dot02 - dot01 * dot12) * inv_denom
+            v = (dot00 * dot12 - dot01 * dot02) * inv_denom
+            inside = in_box & (u >= 0) & (v >= 0) & (u + v <= 1)
+        return ~inside if self.inverted else inside
+
+    def _corner_loops(self) -> list[np.ndarray]:
+        """The three vertices as one ``(2, 3)`` loop."""
+        return [
+            np.array(
+                [[float(xp.to_numpy(v)[i]) for v in self._vertices] for i in (0, 1)]
+            )
+        ]