ScadPy 0.1.0__py3-none-any.whl

scadpy/d2/shape/topologies/edge/get_shape_edge_normals.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+from numpy.typing import NDArray
+from typeguard import typechecked
+
+if TYPE_CHECKING:
+    from scadpy.d2.shape import Shape
+
+
+@typechecked
+def get_shape_edge_normals(
+    shape: Shape,
+) -> NDArray[np.float64]:
+    """
+    For each edge in the shape, return its outward unit normal.
+
+    See :func:`get_assembly_edge_normals` for full documentation.
+
+    Examples
+    --------
+    >>> from scadpy import get_shape_edge_normals, square
+
+    >>> # square(2) centered at origin: 4 edges,
+    >>> # each normal points outward
+    >>> square_shape = square(2)
+    >>> get_shape_edge_normals(square_shape).round(4)
+    array([[ 0., -1.],
+           [ 1., -0.],
+           [ 0.,  1.],
+           [-1., -0.]])
+    """
+    from scadpy.core.assembly import get_assembly_edge_normals
+
+    return get_assembly_edge_normals(
+        edge_to_vertex=shape.edge_to_vertex,
+        vertex_coordinates=shape.vertex_coordinates,
+    )

scadpy/d2/shape/topologies/edge/get_shape_edge_to_vertex.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+from numpy.typing import NDArray
+from typeguard import typechecked
+
+if TYPE_CHECKING:
+    from scadpy.d2.shape import Shape
+
+
+@typechecked
+def get_shape_edge_to_vertex(
+    shape: Shape,
+) -> NDArray[np.int64]:
+    """
+    For each edge in the shape, return the indices of its start and end vertices.
+
+    An edge connects two consecutive vertices within a ring. Edges are directed
+    implicitly by the ring winding order (CCW for exterior rings, CW for interior
+    rings in Shapely convention).
+
+    Parameters
+    ----------
+    shape : Shape
+        The shape to extract edge-to-vertex indices from.
+
+    Returns
+    -------
+    NDArray[np.int64]
+        2D array of shape ``(n_edges, 2)``. Each row is ``[start_vertex, end_vertex]``.
+        The number of edges equals the number of vertices (one edge per vertex,
+        since each ring is closed).
+
+    Examples
+    --------
+    >>> from scadpy import get_shape_edge_to_vertex, polygon, square
+
+    >>> # triangle: 3 vertices, 3 edges
+    >>> triangle = polygon([(0, 0), (1, 0), (0.5, 1)])
+    >>> get_shape_edge_to_vertex(triangle)
+    array([[0, 1],
+           [1, 2],
+           [2, 0]])
+
+    >>> # square: 4 vertices, 4 edges
+    >>> square_shape = square(1)
+    >>> get_shape_edge_to_vertex(square_shape).shape
+    (4, 2)
+    """
+    rings = [
+        ring
+        for g in map(lambda p: p.geometry, shape._parts)  # pyright: ignore[reportPrivateUsage]
+        for ring in (g.exterior, *g.interiors)
+    ]
+    if not rings:
+        return np.empty((0, 2), dtype=np.int64)
+
+    # Build edge_to_vertex: for each ring, consecutive vertex pairs (wrapping around)
+    edge_rows: list[NDArray[np.int64]] = []
+    offset = 0
+    for ring in rings:
+        n = len(ring.coords) - 1  # exclude closing duplicate
+        local_indices = np.arange(n, dtype=np.int64)
+        starts = offset + local_indices
+        ends = offset + (local_indices + 1) % n
+        edge_rows.append(np.stack([starts, ends], axis=1))
+        offset += n
+
+    return np.concatenate(edge_rows, axis=0)

scadpy/d2/shape/topologies/ring/__init__.py

@@ -0,0 +1,7 @@
+__all__ = [
+    "get_shape_ring_to_part",
+    "get_shape_ring_types",
+]
+
+from .get_shape_ring_to_part import get_shape_ring_to_part
+from .get_shape_ring_types import get_shape_ring_types

scadpy/d2/shape/topologies/ring/get_shape_ring_to_part.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+from numpy.typing import NDArray
+from typeguard import typechecked
+
+if TYPE_CHECKING:
+    from scadpy.d2.shape import Shape
+
+
+@typechecked
+def get_shape_ring_to_part(
+    shape: Shape,
+) -> NDArray[np.int64]:
+    """
+    For each ring in the shape, return its part index
+
+    Parameters
+    ----------
+    shape : Shape
+        The shape to extract ring part indices from.
+
+    Returns
+    -------
+    NDArray[np.float64]
+        1D array of shape (n_rings,), one element per ring.
+
+    Examples
+    --------
+    >>> from scadpy import get_shape_ring_to_part, square
+
+    >>> # square with a hole (2 rings in part 0)
+    >>> # unioned with a separate square (1 ring in part 1)
+    >>> shape = (square(2) - square(1)) | square(1).translate([5, 0])
+    >>> result = get_shape_ring_to_part(shape)
+    >>> result  # doctest: +NORMALIZE_WHITESPACE
+    array([0, 0, 1])
+    """
+    part_indices = [
+        i
+        for i, p in enumerate(shape._parts)  # pyright: ignore[reportPrivateUsage]
+        for _ in range(1 + len(p.geometry.interiors))
+    ]
+    return np.array(part_indices, dtype=np.int64)

scadpy/d2/shape/topologies/ring/get_shape_ring_types.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+from numpy.typing import NDArray
+from typeguard import typechecked
+
+if TYPE_CHECKING:
+    from scadpy.d2.shape import Shape
+
+
+@typechecked
+def get_shape_ring_types(
+    shape: Shape,
+) -> NDArray[np.object_]:
+    """
+    For each ring in the shape, return its type ('exterior' or 'interior').
+
+    Parameters
+    ----------
+    shape : Shape
+        The shape to extract ring types from.
+
+    Returns
+    -------
+    NDArray[np.object_]
+        1D array of shape (n_rings,), one element per ring.
+
+    Examples
+    --------
+    >>> from scadpy import get_shape_ring_types, square
+
+    >>> # square with a hole (exterior + interior)
+    >>> # unioned with a separate square (exterior only)
+    >>> shape = (square(2) - square(1)) | square(1).translate([5, 0])
+    >>> get_shape_ring_types(shape)  # doctest: +NORMALIZE_WHITESPACE
+    array(['exterior', 'interior', 'exterior'], dtype=object)
+    """
+    # extract and flatmap polygon ring types
+    ring_types = [
+        ring_type
+        for g in [p.geometry for p in shape._parts]  # pyright: ignore[reportPrivateUsage]
+        for ring_type in ["exterior"] + ["interior"] * len(g.interiors)
+    ]
+    return np.array(ring_types, dtype=np.object_)

scadpy/d2/shape/topologies/vertex/__init__.py

@@ -0,0 +1,11 @@
+__all__ = [
+    "get_shape_part_vertex_coordinates",
+    "get_shape_vertex_coordinates",
+    "get_shape_vertex_to_part",
+    "get_shape_vertex_to_ring",
+]
+
+from .get_shape_part_vertex_coordinates import get_shape_part_vertex_coordinates
+from .get_shape_vertex_coordinates import get_shape_vertex_coordinates
+from .get_shape_vertex_to_part import get_shape_vertex_to_part
+from .get_shape_vertex_to_ring import get_shape_vertex_to_ring

scadpy/d2/shape/topologies/vertex/get_shape_part_vertex_coordinates.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+from numpy.typing import NDArray
+from shapely.coords import CoordinateSequence
+from shapely.geometry import Polygon
+from typeguard import typechecked
+
+if TYPE_CHECKING:
+    from scadpy.core.part import Part
+
+
+@typechecked
+def get_shape_part_vertex_coordinates(part: Part[Polygon]) -> NDArray[np.float64]:
+    """
+    For each vertex in the part, return its coordinates
+
+    Parameters
+    ----------
+    part : Part[Polygon]
+        The shape part to extract vertex coordinates from.
+
+    Returns
+    -------
+    NDArray[np.float64]
+        2D array of shape (n_vertices, 2), one row per vertex.
+
+    Examples
+    --------
+    >>> from shapely.geometry import Polygon
+    >>> from scadpy import Part, get_shape_part_vertex_coordinates
+    ...
+    >>> polygon = Polygon(
+    ...     shell=[(0, 0), (4, 0), (4, 4), (0, 4), (0, 0)],
+    ...     holes=[[(1, 1), (3, 1), (3, 3), (1, 3), (1, 1)]]
+    ... )
+    >>> get_shape_part_vertex_coordinates(
+    ...     Part.from_geometry(polygon)
+    ... ) # doctest: +NORMALIZE_WHITESPACE
+    array([[0., 0.],
+           [4., 0.],
+           [4., 4.],
+           ...
+           [3., 1.],
+           [3., 3.],
+           [1., 3.]])
+    """
+
+    def remove_closing_point(coordinates: CoordinateSequence) -> NDArray[np.float64]:
+        array = np.array(coordinates)
+        if len(array) > 1 and np.allclose(array[0], array[-1]):  # pyright: ignore[reportAny]
+            return array[:-1]
+        return array
+
+    geometry = part.geometry
+    exterior = remove_closing_point(geometry.exterior.coords)
+    interiors = [remove_closing_point(interior.coords) for interior in geometry.interiors]
+    if not interiors:
+        return exterior
+    return np.vstack([exterior] + interiors)

scadpy/d2/shape/topologies/vertex/get_shape_vertex_coordinates.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+from numpy.typing import NDArray
+from typeguard import typechecked
+
+if TYPE_CHECKING:
+    from scadpy import Shape
+
+
+@typechecked
+def get_shape_vertex_coordinates(shape: Shape) -> NDArray[np.float64]:
+    """
+    For each vertex in the shape, return its coordinates.
+
+    Parameters
+    ----------
+    shape : Shape
+        The shape to extract vertex coordinates from.
+
+    Returns
+    -------
+    NDArray[np.float64]
+        2D array of shape (n_vertices, 2), one row per vertex.
+
+    Examples
+    --------
+    >>> from shapely.geometry import Polygon
+    >>> from scadpy import Shape, get_shape_vertex_coordinates
+
+    >>> polygon = Polygon([(0, 0), (2, 0), (2, 2), (0, 2)])
+    >>> get_shape_vertex_coordinates(
+    ...     Shape.from_geometry(polygon)
+    ... ) # doctest: +NORMALIZE_WHITESPACE
+    array([[0., 0.],
+           [2., 0.],
+           [2., 2.],
+           [0., 2.]])
+    """
+    from scadpy import get_assembly_vertex_coordinates, get_shape_part_vertex_coordinates
+
+    return get_assembly_vertex_coordinates(shape._parts, get_shape_part_vertex_coordinates, 2)

scadpy/d2/shape/topologies/vertex/get_shape_vertex_to_part.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+from numpy.typing import NDArray
+from typeguard import typechecked
+
+if TYPE_CHECKING:
+    from scadpy import Shape
+
+
+@typechecked
+def get_shape_vertex_to_part(shape: Shape) -> NDArray[np.int64]:
+    """
+    For each vertex in the shape, return its part index.
+
+    Parameters
+    ----------
+    shape : Shape
+        The shape to extract part indices from.
+
+    Returns
+    -------
+    NDArray[np.int64]
+        1D array of shape (n_vertices,), one element per vertex.
+
+    Examples
+    --------
+    >>> from shapely.geometry import Polygon
+    >>> from scadpy import Shape, get_shape_vertex_to_part
+
+    >>> p1 = Polygon([(0, 0), (2, 0), (2, 2), (0, 2)])
+    >>> p2 = Polygon([(10, 10), (12, 10), (12, 12), (10, 12)])
+    >>> get_shape_vertex_to_part(
+    ...     Shape.from_geometries([p1, p2])
+    ... ) # doctest: +NORMALIZE_WHITESPACE
+    array([0, 0, 0, 0, 1, 1, 1, 1])
+    """
+    from scadpy import get_assembly_vertex_to_part, get_shape_part_vertex_coordinates
+
+    return get_assembly_vertex_to_part(shape._parts, get_shape_part_vertex_coordinates)

scadpy/d2/shape/topologies/vertex/get_shape_vertex_to_ring.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+from numpy.typing import NDArray
+from typeguard import typechecked
+
+if TYPE_CHECKING:
+    from scadpy.d2.shape import Shape
+
+
+@typechecked
+def get_shape_vertex_to_ring(
+    shape: Shape,
+) -> NDArray[np.int64]:
+    """
+    For each vertex in the shape, return the index of the ring (exterior or interior) it belongs to.
+
+    Parameters
+    ----------
+    shape : Shape
+        The shape to extract vertex ring indices from.
+
+    Returns
+    -------
+    NDArray[np.float64]
+        1D array of shape (n_vertices,), one element per vertex.
+
+    Examples
+    --------
+    >>> from scadpy import get_shape_vertex_to_ring, polygon, square
+
+    >>> # two separate triangles: 3 vertices in ring 0, 3 in ring 1
+    >>> shape = (
+    ...     polygon([(0, 0), (1, 0), (0.5, 1)])
+    ...     | polygon([(5, 0), (6, 0), (5.5, 1)])
+    ... )
+    >>> result = get_shape_vertex_to_ring(shape)
+    >>> result  # doctest: +NORMALIZE_WHITESPACE
+    array([0, 0, 0, 1, 1, 1])
+
+    >>> # square with a hole: 4 exterior vertices in ring 0,
+    >>> # 4 interior vertices in ring 1
+    >>> shape = square(4) - square(2)
+    >>> result = get_shape_vertex_to_ring(shape)
+    >>> result  # doctest: +NORMALIZE_WHITESPACE
+    array([0, 0, 0, 0, 1, 1, 1, 1])
+    """
+    # extract and flatmap polygon rings
+    rings = [
+        ring
+        for g in map(lambda p: p.geometry, shape._parts)  # pyright: ignore[reportPrivateUsage]
+        for ring in (g.exterior, *g.interiors)
+    ]
+    # no ring found
+    if not rings:
+        return np.array([], dtype=np.int64)
+
+    ring_indices = np.concatenate(
+        [np.full(len(ring.coords) - 1, i, dtype=np.int64) for i, ring in enumerate(rings)]
+    )
+    return np.array(ring_indices, dtype=np.int64)

scadpy/d2/shape/transformations/__init__.py

@@ -0,0 +1,43 @@
+__all__ = [
+    "chamfer_shape",
+    "color_shape",
+    "convexify_shape",
+    "fill_shape",
+    "fillet_shape",
+    "grow_shape",
+    "linear_cut_shape",
+    "linear_extrude_shape",
+    "linear_slice_shape",
+    "mirror_shape",
+    "pull_shape",
+    "push_shape",
+    "radial_extrude_shape",
+    "radial_slice_shape",
+    "recoordinate_shape",
+    "resize_shape",
+    "rotate_shape",
+    "scale_shape",
+    "shrink_shape",
+    "translate_shape",
+]
+
+from .chamfer_shape import chamfer_shape
+from .color_shape import color_shape
+from .convexify_shape import convexify_shape
+from .fill_shape import fill_shape
+from .fillet_shape import fillet_shape
+from .grow_shape import grow_shape
+from .linear_cut_shape import linear_cut_shape
+from .linear_extrude_shape import linear_extrude_shape
+from .linear_slice_shape import linear_slice_shape
+from .mirror_shape import mirror_shape
+from .pull_shape import pull_shape
+from .push_shape import push_shape
+from .radial_extrude_shape import radial_extrude_shape
+from .radial_slice_shape import radial_slice_shape
+from .recoordinate_shape import recoordinate_shape
+from .resize_shape import resize_shape
+from .rotate_shape import rotate_shape
+from .scale_shape import scale_shape
+from .shrink_shape import shrink_shape
+from .translate_shape import translate_shape