ScadPy 0.1.0__py3-none-any.whl

scadpy/d2/shape/transformations/mirror_shape.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import TYPE_CHECKING
+
+from typeguard import typechecked
+
+if TYPE_CHECKING:
+    from scadpy import Shape
+
+
+@typechecked
+def mirror_shape(
+    shape: Shape,
+    normal: float | Iterable[float],
+    pivot: float | Iterable[float] = 0,
+) -> Shape:
+    """Mirror a shape across a line defined by a normal vector and a pivot point.
+
+    Parameters
+    ----------
+    shape : Shape
+        The shape to mirror.
+    normal : float | Iterable[float]
+        The normal vector of the mirror line. Does not need to be normalized.
+        If a single float is provided, it is broadcast to all coordinate dimensions.
+    pivot : float | Iterable[float], default=0
+        The point through which the mirror line passes. If a single float is
+        provided, it is broadcast to all coordinate dimensions. Defaults to the origin.
+
+    Returns
+    -------
+    Shape
+        A new shape with all vertices mirrored across the specified line.
+
+    Examples
+    --------
+    >>> from scadpy import square, mirror_shape
+
+    >>> mirror_shape(  # doctest: +SKIP
+    ...     shape=square(4), normal=[1, 0], pivot=[2, 0]
+    ... )
+
+    .. render-example::
+        :name: mirror_shape
+        :example: mirror_shape(shape=square(4), normal=[1, 0], pivot=[2, 0])
+        :ghost: square(4)
+    """
+    from scadpy import mirror_vertex_coordinates
+
+    return shape.recoordinate(
+        mirror_vertex_coordinates(shape.vertex_coordinates, normal, pivot)
+    )

scadpy/d2/shape/transformations/pull_shape.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import TYPE_CHECKING
+
+from typeguard import typechecked
+
+
+if TYPE_CHECKING:
+    from scadpy import Shape, TopologyFilter
+
+
+@typechecked
+def pull_shape(
+    shape: Shape,
+    distance: float,
+    pivot: float | Iterable[float] = 0,
+    vertex_filter: TopologyFilter[Shape] | None = None,
+) -> Shape:
+    """Move a subset of shape vertices toward a pivot point by a given distance.
+
+    Each selected vertex is translated toward the pivot by at most ``distance`` units.
+    Vertices already closer than ``distance`` to the pivot are moved to the pivot.
+
+    Parameters
+    ----------
+    shape : Shape
+        The shape whose vertices will be pulled.
+    distance : float
+        The maximum distance each vertex is moved toward the pivot.
+    pivot : float | Iterable[float], default=0
+        The attraction point. If a single float is provided, it is broadcast
+        to all coordinate dimensions. Defaults to the origin.
+    vertex_filter : TopologyFilter[Shape] | None, default=None
+        A boolean array or callable selecting which vertices are affected. If ``None``,
+        all vertices are moved.
+
+    Returns
+    -------
+    Shape
+        A new shape with the selected vertices moved toward the pivot.
+
+    See Also
+    --------
+    push_shape : Move shape vertices away from a pivot point.
+
+    Examples
+    --------
+    >>> from scadpy import square, pull_shape
+
+    >>> shape = square(4)
+    >>> pull_shape(  # doctest: +SKIP
+    ...     shape=shape, distance=1.0, pivot=[2, 2],
+    ...     vertex_filter=shape.vertex_coordinates[:, 0] < 1,
+    ... )
+
+    .. render-example::
+        :name: pull_shape
+        :example: pull_shape(shape=square(4), distance=1.0, pivot=[2, 2], vertex_filter=square(4).vertex_coordinates[:, 0] < 1)
+        :ghost: square(4)
+    """
+    from scadpy import resolve_topology_filter, pull_vertex_coordinates
+
+    resolved_vertex_filter = resolve_topology_filter(shape, len(shape.vertex_coordinates), vertex_filter)
+    return shape.recoordinate(
+        pull_vertex_coordinates(shape.vertex_coordinates, distance, pivot, resolved_vertex_filter)
+    )

scadpy/d2/shape/transformations/push_shape.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import TYPE_CHECKING
+
+from typeguard import typechecked
+
+
+if TYPE_CHECKING:
+    from scadpy import Shape, TopologyFilter
+
+
+@typechecked
+def push_shape(
+    shape: Shape,
+    distance: float,
+    pivot: float | Iterable[float] = 0,
+    vertex_filter: TopologyFilter[Shape] | None = None,
+) -> Shape:
+    """Move a subset of shape vertices away from a pivot point by a given distance.
+
+    Each selected vertex is translated away from the pivot by exactly ``distance`` units.
+    Vertices located exactly at the pivot are not moved (undefined direction).
+
+    Parameters
+    ----------
+    shape : Shape
+        The shape whose vertices will be pushed.
+    distance : float
+        The distance each vertex is moved away from the pivot.
+    pivot : float | Iterable[float], default=0
+        The repulsion point. If a single float is provided, it is broadcast
+        to all coordinate dimensions. Defaults to the origin.
+    vertex_filter : TopologyFilter[Shape] | None, default=None
+        A boolean array or callable selecting which vertices are affected. If ``None``,
+        all vertices are moved.
+
+    Returns
+    -------
+    Shape
+        A new shape with the selected vertices moved away from the pivot.
+
+    See Also
+    --------
+    pull_shape : Move shape vertices toward a pivot point.
+
+    Examples
+    --------
+    >>> from scadpy import square, push_shape
+
+    >>> shape = square(4)
+    >>> push_shape(  # doctest: +SKIP
+    ...     shape=shape, distance=1.0, pivot=[2, 2],
+    ...     vertex_filter=shape.vertex_coordinates[:, 0] < 1,
+    ... )
+
+    .. render-example::
+        :name: push_shape
+        :example: push_shape(shape=square(4), distance=1.0, pivot=[2, 2], vertex_filter=square(4).vertex_coordinates[:, 0] < 1)
+        :ghost: square(4)
+    """
+    from scadpy import resolve_topology_filter, push_vertex_coordinates
+
+    resolved_vertex_filter = resolve_topology_filter(shape, len(shape.vertex_coordinates), vertex_filter)
+    return shape.recoordinate(
+        push_vertex_coordinates(shape.vertex_coordinates, distance, pivot, resolved_vertex_filter)
+    )

scadpy/d2/shape/transformations/radial_extrude_shape.py

@@ -0,0 +1,285 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import TYPE_CHECKING
+
+import numpy as np
+from numpy.typing import NDArray
+from shapely.geometry.polygon import Polygon
+from trimesh import Trimesh
+from trimesh.creation import triangulate_polygon
+from trimesh.geometry import faces_to_edges
+from trimesh.grouping import group_rows
+from typeguard import typechecked
+
+if TYPE_CHECKING:
+    from scadpy.d2.shape import Shape
+    from scadpy.d3.solid import Solid
+
+
+def _rotate_3d(points, axis, angle, pivot):
+    points = points - pivot
+
+    axis = axis / np.linalg.norm(axis)
+    cos_a = np.cos(angle)
+    sin_a = np.sin(angle)
+    one_minus_cos = 1 - cos_a
+    x, y, z = axis
+
+    R = np.array(
+        [
+            [
+                cos_a + x * x * one_minus_cos,
+                x * y * one_minus_cos - z * sin_a,
+                x * z * one_minus_cos + y * sin_a,
+            ],
+            [
+                y * x * one_minus_cos + z * sin_a,
+                cos_a + y * y * one_minus_cos,
+                y * z * one_minus_cos - x * sin_a,
+            ],
+            [
+                z * x * one_minus_cos - y * sin_a,
+                z * y * one_minus_cos + x * sin_a,
+                cos_a + z * z * one_minus_cos,
+            ],
+        ]
+    )
+
+    rotated = points @ R.T
+
+    return rotated + pivot
+
+
+
+def _radial_extrude_shapely_polygon_into_trimesh(
+    polygon: Polygon,
+    axis: float | Iterable[float],
+    start: float = 0,
+    end: float = 360,
+    pivot: float | Iterable[float] = 0,
+    segment_count: int = 64,
+) -> Trimesh:
+    from scadpy import resolve_vector_2d, resolve_vector_3d
+
+    slice_count = segment_count + 1
+
+    start = start % 360
+    end = end % 360
+    is_ring = False
+    if start == end:
+        slice_count -= 1
+        is_ring = True
+    if end <= start:
+        end += 360
+
+    angles = np.linspace(np.radians(start), np.radians(end), segment_count + 1)
+    axis = resolve_vector_2d(axis, 0)
+    pivot = resolve_vector_2d(pivot, 0)
+
+    triangulated_vertex_coordinates, triangulated_face_to_vertex = triangulate_polygon(
+        polygon, engine="triangle"
+    )
+    triangulated_edge_to_vertex = faces_to_edges(triangulated_face_to_vertex)
+
+    slice_border_vertex_coordinates = _create_slice_border_vertex_coordinates(
+        triangulated_vertex_coordinates, slice_count
+    )
+
+    triangulated_border_vertex_count = len(triangulated_vertex_coordinates)
+    triangulated_edge_to_vertex_sorted = np.sort(triangulated_edge_to_vertex, axis=1)
+    triangulated_edge_unique = group_rows(
+        triangulated_edge_to_vertex_sorted, require_count=1
+    )
+    slice_border_faces = _create_slice_border_faces(
+        triangulated_edge_to_vertex[triangulated_edge_unique],
+        triangulated_border_vertex_count,
+        slice_count - 1,
+        is_ring,
+    )
+
+    # make slices
+    final_vertex_coordinate_slices = [
+        slice_border_vertex_coordinates[
+            i * triangulated_border_vertex_count : i * triangulated_border_vertex_count
+            + triangulated_border_vertex_count
+        ]
+        for i in range(0, slice_count)
+    ]
+    for i, slice in enumerate(final_vertex_coordinate_slices):
+        slice[:] = _rotate_3d(
+            slice, resolve_vector_3d(axis, 0), angles[i], resolve_vector_3d(pivot, 0)
+        )
+
+    centroid_x = polygon.centroid.x - float(pivot[0])
+    centroid_y = polygon.centroid.y - float(pivot[1])
+    chirality = float(axis[0]) * centroid_y - float(axis[1]) * centroid_x
+
+    if chirality < 0:
+        slice_border_faces = slice_border_faces[:, ::-1]
+
+    last_slice_border_faces = (
+        triangulated_face_to_vertex + triangulated_border_vertex_count * (slice_count - 1)
+    )
+    if not is_ring:
+        start_cap_faces = triangulated_face_to_vertex
+        end_cap_faces = last_slice_border_faces
+        if chirality < 0:
+            end_cap_faces = end_cap_faces[:, ::-1]
+        else:
+            start_cap_faces = start_cap_faces[:, ::-1]
+
+        slice_border_faces = np.concatenate(
+            [start_cap_faces, slice_border_faces, end_cap_faces]
+        )
+
+    mesh = Trimesh(vertices=slice_border_vertex_coordinates, faces=slice_border_faces)
+    return mesh
+
+
+def _create_slice_border_vertex_coordinates(
+    triangulated_border_vertex_coordinates: NDArray[np.float64],
+    triangulated_slice_count: int,
+) -> NDArray[np.float64]:
+    border_vertex_count = len(triangulated_border_vertex_coordinates)
+    vertex_coordinates = np.zeros(
+        (
+            border_vertex_count * triangulated_slice_count,
+            3,
+        ),
+        dtype=np.float64,
+    )
+    vertex_coordinates[:, :2] = np.tile(
+        triangulated_border_vertex_coordinates, (triangulated_slice_count, 1)
+    )
+    return vertex_coordinates
+
+
+def _create_slice_border_faces(
+    triangulated_border_edge_to_vertex: NDArray[np.int64],
+    triangulated_border_vertex_count: int,
+    slice_count: int,
+    is_ring: bool,
+) -> NDArray[np.int64]:
+    all_edges = np.tile(triangulated_border_edge_to_vertex, (slice_count, 1))
+    layer_offsets = (
+        np.repeat(np.arange(slice_count), len(triangulated_border_edge_to_vertex))
+        * triangulated_border_vertex_count
+    )
+    all_edges += layer_offsets.reshape(-1, 1)
+
+    v0 = all_edges[:, 0]
+    v1 = all_edges[:, 1]
+    v2 = v0 + triangulated_border_vertex_count
+    v3 = v1 + triangulated_border_vertex_count
+
+    triangle1 = np.column_stack([v0, v1, v2])
+    triangle2 = np.column_stack([v1, v3, v2])
+
+    faces = np.vstack([triangle1, triangle2])
+
+    if is_ring:
+        last_edges = (
+            triangulated_border_edge_to_vertex
+            + triangulated_border_vertex_count * slice_count
+        )
+        first_edges = triangulated_border_edge_to_vertex
+        v0 = last_edges[:, 0]
+        v1 = last_edges[:, 1]
+        v2 = first_edges[:, 0]
+        v3 = first_edges[:, 1]
+
+        triangle1 = np.column_stack([v0, v1, v2])
+        triangle2 = np.column_stack([v1, v3, v2])
+
+        ring_faces = np.vstack([triangle1, triangle2])
+        faces = np.vstack([faces, ring_faces])
+
+    return faces
+
+
+@typechecked
+def radial_extrude_shape(
+    shape: Shape,
+    axis: float | Iterable[float],
+    start: float = 0,
+    end: float = 360,
+    pivot: float | Iterable[float] = 0,
+    segment_count: int = 64,
+) -> Solid:
+    """Revolve a 2D shape around an axis to produce a 3D solid.
+
+    Each part of the shape is independently revolved around the given axis.
+    The axis is defined in 2D (the Z component is always 0). The revolution
+    spans from ``start`` to ``end`` degrees. A full 360° revolution produces
+    a closed solid; a partial revolution leaves the ends open. If ``start``
+    equals ``end``, an empty solid is returned.
+
+    Parameters
+    ----------
+    shape : Shape
+        The 2D shape to revolve.
+    axis : float or Iterable[float]
+        The 2D axis of revolution (e.g. ``[0, 1]`` for the Y-axis).
+    start : float, optional
+        Starting angle in degrees. Default is ``0``.
+    end : float, optional
+        Ending angle in degrees. Default is ``360`` (full revolution). If
+        equal to ``start``, an empty solid is returned.
+    pivot : float or Iterable[float], optional
+        2D pivot point for the revolution. Default is ``0`` (origin).
+    segment_count : int, optional
+        Number of angular segments used to approximate the revolution.
+        Higher values produce smoother results. Default is ``64``.
+
+    Returns
+    -------
+    Solid
+        The resulting 3D solid.
+
+    Examples
+    --------
+    >>> from scadpy import radial_extrude_shape, circle
+
+    >>> # torus: circle profile offset from the Y-axis, revolved 360°
+    >>> radial_extrude_shape(  # doctest: +SKIP
+    ...     shape=circle(radius=0.5).translate([2, 0]),
+    ...     axis=[0, 1],
+    ... )
+
+    .. render-example::
+        :name: radial_extrude_shape
+        :example: radial_extrude_shape(shape=circle(radius=0.5).translate([2, 0]), axis=[0, 1])
+
+    >>> # partial torus (270°)
+    >>> radial_extrude_shape(  # doctest: +SKIP
+    ...     shape=circle(radius=0.5).translate([2, 0]),
+    ...     axis=[0, 1], end=270,
+    ... )
+
+    .. render-example::
+        :name: radial_extrude_shape_partial
+        :example: radial_extrude_shape(shape=circle(radius=0.5).translate([2, 0]), axis=[0, 1], end=270)
+    """
+    from scadpy import Part, Solid, linear_cut_shape, unify_solid
+
+    if start == end:
+        return Solid.from_parts([])
+
+    cut_shape = linear_cut_shape(shape=shape, axis=axis, pivot=pivot)
+    parts = [
+        Part[Trimesh].from_geometry(
+            _radial_extrude_shapely_polygon_into_trimesh(
+                p.geometry, axis, start, end, pivot, segment_count
+            ),
+            p.color,
+        )
+        for p in cut_shape._parts
+    ]
+
+    if not parts:
+        return Solid.from_parts([])
+    solids = [Solid.from_parts([p]) for p in parts]
+    if len(solids) == 1:
+        return solids[0]
+    return unify_solid(solids=solids)

scadpy/d2/shape/transformations/radial_slice_shape.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from math import cos, radians, sin
+from typing import TYPE_CHECKING
+
+import numpy as np
+from shapely.geometry.polygon import Polygon
+from typeguard import typechecked
+
+if TYPE_CHECKING:
+    from scadpy import Shape, TopologyFilter
+
+
+@typechecked
+def radial_slice_shape(
+    shape: Shape,
+    start: float = 0,
+    end: float = 360,
+    pivot: float | Iterable[float] = 0,
+    part_filter: TopologyFilter[Shape] | None = None,
+) -> Shape:
+    """
+    Slice a shape by keeping only the angular sector between two angles.
+
+    Constructs a pie-shaped wedge from the pivot point spanning the angular range
+    from start to end, and intersects it with the selected parts. Only the portion
+    of the shape within the wedge remains.
+
+    Parameters
+    ----------
+    shape : Shape
+        The input shape to slice.
+    start : float, optional
+        The start angle of the sector in degrees. Defaults to 0.
+    end : float, optional
+        The end angle of the sector in degrees. Defaults to 360.
+    pivot : float | Iterable[float], optional
+        The center point of the angular sector. Defaults to the origin.
+    part_filter : TopologyFilter[Shape] | None, optional
+        A boolean mask selecting which parts to slice. If None, all parts are sliced.
+
+    Returns
+    -------
+    Shape
+        A new shape containing only the angular sector of the selected parts,
+        plus the unselected parts unchanged. If start equals end, the shape
+        is returned unchanged.
+
+    Examples
+    --------
+    >>> from scadpy import radial_slice_shape, square, circle
+    >>> import numpy as np
+
+    >>> shape = square(10) - circle(3)
+
+    >>> # quarter slice
+    >>> radial_slice_shape(shape, start=0, end=90) # doctest: +SKIP
+
+    .. render-example::
+        :name: radial_slice_shape_quarter
+        :example: radial_slice_shape(shape, start=0, end=90)
+        :ghost: shape
+
+    >>> # three quarter slice
+    >>> radial_slice_shape(shape, start=45, end=315) # doctest: +SKIP
+
+    .. render-example::
+        :name: radial_slice_shape_three_quarter
+        :example: radial_slice_shape(shape, start=45, end=315)
+        :ghost: shape
+
+    >>> # off-center pivot
+    >>> radial_slice_shape(  # doctest: +SKIP
+    ...     shape, start=0, end=180, pivot=[3, 3]
+    ... )
+
+    .. render-example::
+        :name: radial_slice_shape_pivot
+        :example: radial_slice_shape(shape, start=0, end=180, pivot=[3, 3])
+        :ghost: shape
+
+    >>> # partial slice on a composite shape
+    >>> a = square(6) - circle(2)
+    >>> b = circle(3).translate(10)
+
+    >>> radial_slice_shape(  # doctest: +SKIP
+    ...     a + b, start=0, end=120,
+    ...     part_filter=np.array([True, False]),
+    ... )
+
+    .. render-example::
+        :name: radial_slice_shape_partial
+        :example: radial_slice_shape(a + b, start=0, end=120, part_filter=np.array([True, False]))
+        :ghost: a + b
+    """
+    from scadpy import resolve_vector_2d, transform_filtered_parts, Shape
+
+    pivot = resolve_vector_2d(pivot, 0)
+
+    start = start % 360
+    end = end % 360
+    if start == end:
+        return shape
+    if end <= start:
+        end += 360
+
+    bounds = shape.bounds
+    radius = max(bounds[2] - bounds[0], bounds[3] - bounds[1]) * 2
+
+    n = max(2, int((end - start) / 5))
+    if n == 2:
+        theta = [radians(start), radians(end)]
+    else:
+        theta = np.linspace(radians(start), radians(end), n + 1)
+
+    px, py = pivot
+    points = (
+        [(px, py)]
+        + [(px + radius * cos(t), py + radius * sin(t)) for t in theta]
+        + [(px, py)]
+    )
+
+    slice_mask = Shape.from_geometries([Polygon(points)])
+
+    return transform_filtered_parts(
+        assembly=shape,
+        parts=shape._parts,
+        part_filter=part_filter,
+        transform=lambda parts: (Shape.from_parts(parts) & slice_mask)._parts,
+        concat_parts=Shape.from_parts,
+    )

scadpy/d2/shape/transformations/recoordinate_shape.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+from numpy.typing import NDArray
+from shapely.geometry import Polygon
+from typeguard import typechecked
+
+if TYPE_CHECKING:
+    from scadpy.d2.shape import Shape
+
+
+@typechecked
+def recoordinate_shape(
+    shape: Shape, vertex_coordinates: NDArray[np.float64]
+) -> Shape:
+    """Rebuild a shape with new vertex coordinates, preserving topology and colors.
+
+    Parameters
+    ----------
+    shape : Shape
+        The source shape providing topology (part/ring structure) and colors.
+    vertex_coordinates : NDArray[np.float64]
+        New vertex coordinates of shape ``(n_vertices, 2)``, in the same order
+        as :func:`get_shape_vertex_coordinates`.
+
+    Returns
+    -------
+    Shape
+        A new shape with the same topology as *shape* but at the new positions.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from shapely.geometry import Polygon
+    >>> from scadpy import recoordinate_shape, Shape, square
+
+    >>> recoordinate_shape(  # doctest: +SKIP
+    ...     shape=square(4),
+    ...     vertex_coordinates=(
+    ...         square(4).vertex_coordinates + [2.0, 1.0]
+    ...     ),
+    ... )
+
+    .. render-example::
+        :name: recoordinate_shape
+        :example: recoordinate_shape(shape=square(4), vertex_coordinates=square(4).vertex_coordinates + [2.0, 1.0])
+        :ghost: square(4)
+    """
+    from scadpy.core.part import Part
+
+    vertex_to_part = shape.vertex_to_part
+    vertex_to_ring = shape.vertex_to_ring
+    part_colors = shape.part_colors
+    ring_types = shape.ring_types
+
+    parts = []
+    for part_index in np.unique(vertex_to_part):
+        part_mask = vertex_to_part == part_index
+        part_coords = vertex_coordinates[part_mask]
+        part_ring_indices = vertex_to_ring[part_mask]
+        color = list(part_colors[part_index])
+
+        exterior = None
+        interiors = []
+        for ring_index in np.unique(part_ring_indices):
+            ring_mask = part_ring_indices == ring_index
+            coordinates = part_coords[ring_mask]
+            if ring_types[ring_index] == "exterior":
+                exterior = coordinates
+            else:
+                interiors.append(coordinates)
+
+        parts.append(
+            Part[Polygon].from_geometry(
+                Polygon(shell=exterior, holes=interiors),
+                color,
+            )
+        )
+
+    return shape.from_parts(parts)