ScadPy 0.1.0__py3-none-any.whl

scadpy/core/assembly/combinations/unify_assemblies.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable, Sequence
+
+from typeguard import typechecked
+
+
+@typechecked
+def unify_assemblies[A, P](
+    assemblies: Sequence[A],
+    get_assembly_parts: Callable[[A], Iterable[P]],
+    unify_parts: Callable[[Sequence[P]], A],
+) -> A:
+    """
+    Unite (union) multiple assemblies into a single assembly by unifying all their parts.
+
+    This function uses dependency injection to remain type-agnostic, allowing it
+    to work with any assembly/part domain model by providing appropriate accessor
+    and unification functions.
+
+    Parameters
+    ----------
+    assemblies : Sequence[A]
+        Sequence of assembly objects to be unified.
+    get_assembly_parts : Callable[[A], Iterable[P]]
+        Function that extracts parts from an assembly.
+    unify_parts : Callable[[Sequence[P]], Assembly]
+        Function that unifies a sequence of parts into a new assembly.
+
+    Returns
+    -------
+    A
+        The assembly object created by unifying all parts from all input assemblies.
+
+    Examples
+    --------
+    >>> from scadpy import unify_assemblies
+
+    >>> assemblies = [
+    ...     [[0, 0, 2, 2], [1, 1, 3, 3]],
+    ...     [[5, 5, 6, 6]]
+    ... ]
+    ...
+    >>> def unify_parts(parts):
+    ...     minx = min(p[0] for p in parts)
+    ...     miny = min(p[1] for p in parts)
+    ...     maxx = max(p[2] for p in parts)
+    ...     maxy = max(p[3] for p in parts)
+    ...     return [[minx, miny, maxx, maxy]]
+    ...
+    >>> result = unify_assemblies(
+    ...     assemblies,
+    ...     get_assembly_parts=lambda a: a,
+    ...     unify_parts=unify_parts
+    ... )
+    >>> result == [[0, 0, 6, 6]]
+    True
+    """
+    return unify_parts([p for a in assemblies for p in get_assembly_parts(a)])

scadpy/core/assembly/topologies/__init__.py

@@ -0,0 +1,41 @@
+__all__ = [
+    "get_assembly_directed_edge_directions",
+    "get_assembly_directed_edge_to_edge",
+    "get_assembly_directed_edge_to_vertex",
+    "get_assembly_edge_lengths",
+    "get_assembly_edge_midpoints",
+    "get_assembly_edge_normals",
+    "get_assembly_face_corner_angles",
+    "get_assembly_face_corner_normals",
+    "get_assembly_face_corner_to_incoming_directed_edge",
+    "get_assembly_face_corner_to_outgoing_directed_edge",
+    "get_assembly_face_directed_edge_to_corner",
+    "get_assembly_part_colors",
+    "get_assembly_vertex_coordinates",
+    "get_assembly_vertex_to_part",
+]
+
+from .directed_edge import (
+    get_assembly_directed_edge_directions,
+    get_assembly_directed_edge_to_edge,
+    get_assembly_directed_edge_to_vertex,
+)
+from .edge import (
+    get_assembly_edge_lengths,
+    get_assembly_edge_midpoints,
+    get_assembly_edge_normals,
+)
+from .face_corner import (
+    get_assembly_face_corner_angles,
+    get_assembly_face_corner_normals,
+    get_assembly_face_corner_to_incoming_directed_edge,
+    get_assembly_face_corner_to_outgoing_directed_edge,
+    get_assembly_face_directed_edge_to_corner,
+)
+from .part import (
+    get_assembly_part_colors,
+)
+from .vertex import (
+    get_assembly_vertex_coordinates,
+    get_assembly_vertex_to_part,
+)

scadpy/core/assembly/topologies/directed_edge/__init__.py

@@ -0,0 +1,9 @@
+__all__ = [
+    "get_assembly_directed_edge_directions",
+    "get_assembly_directed_edge_to_edge",
+    "get_assembly_directed_edge_to_vertex",
+]
+
+from .get_assembly_directed_edge_directions import get_assembly_directed_edge_directions
+from .get_assembly_directed_edge_to_edge import get_assembly_directed_edge_to_edge
+from .get_assembly_directed_edge_to_vertex import get_assembly_directed_edge_to_vertex

scadpy/core/assembly/topologies/directed_edge/get_assembly_directed_edge_directions.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import numpy as np
+from numpy.typing import NDArray
+from typeguard import typechecked
+
+
+@typechecked
+def get_assembly_directed_edge_directions(
+    directed_edge_to_vertex: NDArray[np.int64],
+    vertex_coordinates: NDArray[np.float64],
+) -> NDArray[np.float64]:
+    """
+    For each directed edge, return its unit direction vector.
+
+    The direction vector points from the start vertex to the end vertex,
+    normalized to unit length.
+
+    Parameters
+    ----------
+    directed_edge_to_vertex : NDArray[np.int64]
+        2D array of shape ``(n_directed_edges, 2)`` mapping each directed edge
+        to its ``[start_vertex, end_vertex]`` indices.
+    vertex_coordinates : NDArray[np.float64]
+        2D array of shape ``(n_vertices, 2)`` with vertex coordinates.
+
+    Returns
+    -------
+    NDArray[np.float64]
+        2D array of shape ``(n_directed_edges, 2)``. Each row is a unit vector
+        ``[dx, dy]`` pointing from start to end vertex.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scadpy import get_assembly_directed_edge_directions
+
+    >>> # square: forward edges go right, up, left, down;
+    >>> # backward edges are reversed
+    >>> directed_edge_to_vertex = np.array([
+    ...     [0, 1], [1, 0],
+    ...     [1, 2], [2, 1],
+    ...     [2, 3], [3, 2],
+    ...     [3, 0], [0, 3],
+    ... ], dtype=np.int64)
+    >>> vertex_coordinates = np.array(
+    ...     [[0., 0.], [1., 0.], [1., 1.], [0., 1.]]
+    ... )
+    >>> get_assembly_directed_edge_directions(
+    ...     directed_edge_to_vertex, vertex_coordinates
+    ... ).round(4)
+    array([[ 1.,  0.],
+           [-1.,  0.],
+           [ 0.,  1.],
+           [ 0., -1.],
+           [-1.,  0.],
+           [ 1.,  0.],
+           [ 0., -1.],
+           [ 0.,  1.]])
+    """
+    if len(directed_edge_to_vertex) == 0:
+        d = vertex_coordinates.shape[1] if vertex_coordinates.ndim == 2 else 0
+        return np.empty((0, d), dtype=np.float64)
+
+    starts = vertex_coordinates[directed_edge_to_vertex[:, 0]]
+    ends = vertex_coordinates[directed_edge_to_vertex[:, 1]]
+
+    directions = ends - starts
+    lengths = np.linalg.norm(directions, axis=1, keepdims=True)
+    return directions / lengths

scadpy/core/assembly/topologies/directed_edge/get_assembly_directed_edge_to_edge.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import numpy as np
+from numpy.typing import NDArray
+from typeguard import typechecked
+
+
+@typechecked
+def get_assembly_directed_edge_to_edge(
+    n_edges: int,
+) -> NDArray[np.int64]:
+    """
+    For each directed edge, return the index of its parent undirected edge.
+
+    Since directed edges are interleaved (``directed_edge 2i`` and
+    ``directed_edge 2i+1`` both belong to ``edge i``), the mapping is:
+
+    .. code-block:: text
+
+        edge index = directed_edge index // 2
+
+    Parameters
+    ----------
+    n_edges : int
+        Number of undirected edges.
+
+    Returns
+    -------
+    NDArray[np.int64]
+        1D array of shape ``(2 * n_edges,)``. Each entry is the index of
+        the parent undirected edge.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scadpy import get_assembly_directed_edge_to_edge
+
+    >>> # triangle: 3 edges → 6 directed edges
+    >>> get_assembly_directed_edge_to_edge(3)
+    array([0, 0, 1, 1, 2, 2])
+
+    >>> # square: 4 edges → 8 directed edges
+    >>> get_assembly_directed_edge_to_edge(4)
+    array([0, 0, 1, 1, 2, 2, 3, 3])
+    """
+    if n_edges == 0:
+        return np.empty(0, dtype=np.int64)
+
+    return np.arange(n_edges, dtype=np.int64).repeat(2)

scadpy/core/assembly/topologies/directed_edge/get_assembly_directed_edge_to_vertex.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import numpy as np
+from numpy.typing import NDArray
+from typeguard import typechecked
+
+
+@typechecked
+def get_assembly_directed_edge_to_vertex(
+    edge_to_vertex: NDArray[np.int64],
+) -> NDArray[np.int64]:
+    """
+    For each directed edge, return the indices of its start and end vertices.
+
+    Each undirected edge ``i`` gives rise to two directed edges, interleaved:
+
+    - ``directed_edge 2i``   : forward  → ``[start, end]``
+    - ``directed_edge 2i+1`` : backward → ``[end, start]``
+
+    Parameters
+    ----------
+    edge_to_vertex : NDArray[np.int64]
+        2D array of shape ``(n_edges, 2)`` mapping each edge to its
+        ``[start_vertex, end_vertex]`` indices.
+
+    Returns
+    -------
+    NDArray[np.int64]
+        2D array of shape ``(2 * n_edges, 2)``. Each row is
+        ``[start_vertex, end_vertex]`` for the directed edge.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scadpy import get_assembly_directed_edge_to_vertex
+
+    >>> # triangle: 3 edges → 6 directed edges
+    >>> edge_to_vertex = np.array(
+    ...     [[0, 1], [1, 2], [2, 0]], dtype=np.int64
+    ... )
+    >>> get_assembly_directed_edge_to_vertex(edge_to_vertex)
+    array([[0, 1],
+           [1, 0],
+           [1, 2],
+           [2, 1],
+           [2, 0],
+           [0, 2]])
+    """
+    if len(edge_to_vertex) == 0:
+        return np.empty((0, 2), dtype=np.int64)
+
+    forward = edge_to_vertex
+    backward = edge_to_vertex[:, ::-1]
+    return np.stack([forward, backward], axis=1).reshape(-1, 2)

scadpy/core/assembly/topologies/edge/__init__.py

@@ -0,0 +1,9 @@
+__all__ = [
+    "get_assembly_edge_lengths",
+    "get_assembly_edge_midpoints",
+    "get_assembly_edge_normals",
+]
+
+from .get_assembly_edge_lengths import get_assembly_edge_lengths
+from .get_assembly_edge_midpoints import get_assembly_edge_midpoints
+from .get_assembly_edge_normals import get_assembly_edge_normals

scadpy/core/assembly/topologies/edge/get_assembly_edge_lengths.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import numpy as np
+from numpy.typing import NDArray
+from typeguard import typechecked
+
+
+@typechecked
+def get_assembly_edge_lengths(
+    edge_to_vertex: NDArray[np.int64],
+    vertex_coordinates: NDArray[np.float64],
+) -> NDArray[np.float64]:
+    """
+    For each edge, return the Euclidean distance between its two vertices.
+
+    Parameters
+    ----------
+    edge_to_vertex : NDArray[np.int64]
+        2D array of shape ``(n_edges, 2)`` mapping each edge to its
+        ``[start_vertex, end_vertex]`` indices.
+    vertex_coordinates : NDArray[np.float64]
+        2D array of shape ``(n_vertices, d)`` with vertex coordinates.
+
+    Returns
+    -------
+    NDArray[np.float64]
+        1D array of shape ``(n_edges,)``, one length per edge.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scadpy.core.assembly import get_assembly_edge_lengths
+
+    >>> edge_to_vertex = np.array(
+    ...     [[0, 1], [1, 2], [2, 0]], dtype=np.int64
+    ... )
+    >>> vertex_coordinates = np.array([[0., 0.], [3., 0.], [0., 4.]])
+    >>> get_assembly_edge_lengths(edge_to_vertex, vertex_coordinates)
+    array([3., 5., 4.])
+    """
+    if len(edge_to_vertex) == 0:
+        return np.empty(0, dtype=np.float64)
+
+    starts = vertex_coordinates[edge_to_vertex[:, 0]]
+    ends = vertex_coordinates[edge_to_vertex[:, 1]]
+    return np.linalg.norm(ends - starts, axis=1)

scadpy/core/assembly/topologies/edge/get_assembly_edge_midpoints.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import numpy as np
+from numpy.typing import NDArray
+from typeguard import typechecked
+
+
+@typechecked
+def get_assembly_edge_midpoints(
+    edge_to_vertex: NDArray[np.int64],
+    vertex_coordinates: NDArray[np.float64],
+) -> NDArray[np.float64]:
+    """
+    For each edge, return the midpoint between its two vertices.
+
+    Parameters
+    ----------
+    edge_to_vertex : NDArray[np.int64]
+        2D array of shape ``(n_edges, 2)`` mapping each edge to its
+        ``[start_vertex, end_vertex]`` indices.
+    vertex_coordinates : NDArray[np.float64]
+        2D array of shape ``(n_vertices, d)`` with vertex coordinates.
+
+    Returns
+    -------
+    NDArray[np.float64]
+        2D array of shape ``(n_edges, d)``, one midpoint per edge.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scadpy.core.assembly import get_assembly_edge_midpoints
+
+    >>> edge_to_vertex = np.array(
+    ...     [[0, 1], [1, 2], [2, 0]], dtype=np.int64
+    ... )
+    >>> vertex_coordinates = np.array([[0., 0.], [2., 0.], [1., 2.]])
+    >>> get_assembly_edge_midpoints(
+    ...     edge_to_vertex, vertex_coordinates
+    ... )
+    array([[1. , 0. ],
+           [1.5, 1. ],
+           [0.5, 1. ]])
+    """
+    if len(edge_to_vertex) == 0:
+        d = vertex_coordinates.shape[1] if vertex_coordinates.ndim == 2 else 0
+        return np.empty((0, d), dtype=np.float64)
+
+    starts = vertex_coordinates[edge_to_vertex[:, 0]]
+    ends = vertex_coordinates[edge_to_vertex[:, 1]]
+    return (starts + ends) / 2

scadpy/core/assembly/topologies/edge/get_assembly_edge_normals.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import numpy as np
+from numpy.typing import NDArray
+from typeguard import typechecked
+
+
+@typechecked
+def get_assembly_edge_normals(
+    edge_to_vertex: NDArray[np.int64],
+    vertex_coordinates: NDArray[np.float64],
+) -> NDArray[np.float64]:
+    """
+    For each edge, return its outward unit normal.
+
+    The outward normal is the 90° clockwise rotation of the edge direction
+    vector ``(dx, dy) → (dy, -dx)``. For exterior rings (CCW winding), this
+    points away from the filled area. For interior rings (CW winding, i.e.
+    holes), this also points away from the filled area (outward into the hole).
+
+    Parameters
+    ----------
+    edge_to_vertex : NDArray[np.int64]
+        2D array of shape ``(n_edges, 2)`` mapping each edge to its
+        ``[start_vertex, end_vertex]`` indices.
+    vertex_coordinates : NDArray[np.float64]
+        2D array of shape ``(n_vertices, 2)`` with vertex coordinates.
+
+    Returns
+    -------
+    NDArray[np.float64]
+        2D array of shape ``(n_edges, 2)``. Each row is a unit vector
+        ``[nx, ny]`` perpendicular to the edge and pointing outward.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scadpy import get_assembly_edge_normals
+
+    >>> # square centered at origin: 4 edges, normals point outward
+    >>> edge_to_vertex = np.array(
+    ...     [[0, 1], [1, 2], [2, 3], [3, 0]], dtype=np.int64
+    ... )
+    >>> vertex_coordinates = np.array(
+    ...     [[-1., -1.], [1., -1.], [1., 1.], [-1., 1.]]
+    ... )
+    >>> get_assembly_edge_normals(
+    ...     edge_to_vertex, vertex_coordinates
+    ... ).round(4)
+    array([[ 0., -1.],
+           [ 1., -0.],
+           [ 0.,  1.],
+           [-1., -0.]])
+    """
+    if len(edge_to_vertex) == 0:
+        d = vertex_coordinates.shape[1] if vertex_coordinates.ndim == 2 else 0
+        return np.empty((0, d), dtype=np.float64)
+
+    starts = vertex_coordinates[edge_to_vertex[:, 0]]
+    ends = vertex_coordinates[edge_to_vertex[:, 1]]
+
+    directions = ends - starts
+    lengths = np.linalg.norm(directions, axis=1, keepdims=True)
+    directions_normalized = directions / lengths
+
+    # 90° CW rotation: (dx, dy) → (dy, -dx)
+    return np.stack([directions_normalized[:, 1], -directions_normalized[:, 0]], axis=1)

scadpy/core/assembly/topologies/face_corner/__init__.py

@@ -0,0 +1,13 @@
+__all__ = [
+    "get_assembly_face_corner_angles",
+    "get_assembly_face_corner_normals",
+    "get_assembly_face_corner_to_incoming_directed_edge",
+    "get_assembly_face_corner_to_outgoing_directed_edge",
+    "get_assembly_face_directed_edge_to_corner",
+]
+
+from .get_assembly_face_corner_angles import get_assembly_face_corner_angles
+from .get_assembly_face_corner_normals import get_assembly_face_corner_normals
+from .get_assembly_face_corner_to_incoming_directed_edge import get_assembly_face_corner_to_incoming_directed_edge
+from .get_assembly_face_corner_to_outgoing_directed_edge import get_assembly_face_corner_to_outgoing_directed_edge
+from .get_assembly_face_directed_edge_to_corner import get_assembly_face_directed_edge_to_corner

scadpy/core/assembly/topologies/face_corner/get_assembly_face_corner_angles.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import numpy as np
+from numpy.typing import NDArray
+from typeguard import typechecked
+
+
+@typechecked
+def get_assembly_face_corner_angles(
+    corner_to_vertex: NDArray[np.int64],
+    vertex_coordinates: NDArray[np.float64],
+) -> NDArray[np.float64]:
+    """
+    For each corner, return its interior angle in degrees.
+
+    The angle is always positive, in the range (0°, 180°). It represents
+    the turning angle at the corner, regardless of whether the corner is
+    convex or concave. Use convexity information separately to distinguish
+    the two cases.
+
+    The angle is computed as the absolute value of the signed angle from the
+    incoming edge to the outgoing edge at each corner, using the 2D cross
+    product to determine orientation.
+
+    Parameters
+    ----------
+    corner_to_vertex : NDArray[np.int64]
+        2D array of shape ``(n_corners, 3)``. Each row is
+        ``[prev_vertex, curr_vertex, next_vertex]``.
+    vertex_coordinates : NDArray[np.float64]
+        2D array of shape ``(n_vertices, 2)`` with vertex coordinates.
+
+    Returns
+    -------
+    NDArray[np.float64]
+        1D array of shape ``(n_corners,)``, one angle per corner in degrees.
+        All values are in the range (0°, 180°).
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scadpy import get_assembly_face_corner_angles
+
+    >>> # square: 4 right-angle corners
+    >>> corner_to_vertex = np.array(
+    ...     [[3, 0, 1], [0, 1, 2], [1, 2, 3], [2, 3, 0]],
+    ...     dtype=np.int64
+    ... )
+    >>> vertex_coordinates = np.array(
+    ...     [[-1., -1.], [1., -1.], [1., 1.], [-1., 1.]]
+    ... )
+    >>> get_assembly_face_corner_angles(
+    ...     corner_to_vertex, vertex_coordinates
+    ... )
+    array([90., 90., 90., 90.])
+    """
+    if len(corner_to_vertex) == 0:
+        return np.empty(0, dtype=np.float64)
+
+    prev_coords = vertex_coordinates[corner_to_vertex[:, 0]]
+    curr_coords = vertex_coordinates[corner_to_vertex[:, 1]]
+    next_coords = vertex_coordinates[corner_to_vertex[:, 2]]
+
+    v_in = curr_coords - prev_coords
+    v_out = next_coords - curr_coords
+
+    cross = v_in[:, 0] * v_out[:, 1] - v_in[:, 1] * v_out[:, 0]
+    dot = v_in[:, 0] * v_out[:, 0] + v_in[:, 1] * v_out[:, 1]
+
+    angles_rad = np.arctan2(cross, dot)
+
+    return np.abs(np.degrees(angles_rad))

scadpy/core/assembly/topologies/face_corner/get_assembly_face_corner_normals.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import numpy as np
+from numpy.typing import NDArray
+from typeguard import typechecked
+
+
+@typechecked
+def get_assembly_face_corner_normals(
+    corner_to_vertex: NDArray[np.int64],
+    vertex_coordinates: NDArray[np.float64],
+    are_corners_convex: NDArray[np.bool_],
+    epsilon: float = 1e-10,
+) -> NDArray[np.float64]:
+    """
+    For each corner, return its outward unit normal.
+
+    The normal is the bisector of the two adjacent edge normals (90° CW
+    rotation of each edge direction), oriented outward for convex corners
+    and inward for concave ones. For degenerate 180° corners where the
+    bisector vanishes, falls back to the incoming edge normal.
+
+    The term *face* distinguishes this from a purely topological corner:
+    the computation relies on face geometry (vertex coordinates) and face
+    orientation (convexity), making it applicable to both 2D shape rings
+    and 3D solid faces.
+
+    Parameters
+    ----------
+    corner_to_vertex : NDArray[np.int64]
+        2D array of shape ``(n_corners, 3)``. Each row is
+        ``[prev_vertex, curr_vertex, next_vertex]``.
+    vertex_coordinates : NDArray[np.float64]
+        2D array of shape ``(n_vertices, d)`` with vertex coordinates.
+    are_corners_convex : NDArray[np.bool_]
+        1D boolean array of shape ``(n_corners,)``. True if the corner
+        is convex (normal points outward), False if concave (normal points
+        inward).
+    epsilon : float, optional
+        Threshold below which the bisector norm is considered degenerate
+        (straight 180° corner). Defaults to ``1e-10``.
+
+    Returns
+    -------
+    NDArray[np.float64]
+        2D array of shape ``(n_corners, 2)``. Each row is a unit vector
+        ``[nx, ny]``.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scadpy import get_assembly_face_corner_normals
+
+    >>> # square: 4 convex corners, normals point outward
+    >>> # (diagonal directions)
+    >>> corner_to_vertex = np.array(
+    ...     [[3, 0, 1], [0, 1, 2], [1, 2, 3], [2, 3, 0]],
+    ...     dtype=np.int64
+    ... )
+    >>> vertex_coordinates = np.array(
+    ...     [[-1., -1.], [1., -1.], [1., 1.], [-1., 1.]]
+    ... )
+    >>> are_corners_convex = np.array([True, True, True, True])
+    >>> get_assembly_face_corner_normals(
+    ...     corner_to_vertex,
+    ...     vertex_coordinates,
+    ...     are_corners_convex,
+    ... ).round(4)
+    array([[-0.7071, -0.7071],
+           [ 0.7071, -0.7071],
+           [ 0.7071,  0.7071],
+           [-0.7071,  0.7071]])
+    """
+    if len(corner_to_vertex) == 0:
+        d = vertex_coordinates.shape[1] if vertex_coordinates.ndim == 2 else 0
+        return np.empty((0, d), dtype=np.float64)
+
+    prev_coords = vertex_coordinates[corner_to_vertex[:, 0]]
+    curr_coords = vertex_coordinates[corner_to_vertex[:, 1]]
+    next_coords = vertex_coordinates[corner_to_vertex[:, 2]]
+
+    v_in = curr_coords - prev_coords
+    v_out = next_coords - curr_coords
+
+    v_in_norm = v_in / np.linalg.norm(v_in, axis=1, keepdims=True)
+    v_out_norm = v_out / np.linalg.norm(v_out, axis=1, keepdims=True)
+
+    # outward edge normals: 90° CW rotation (dx, dy) → (dy, -dx)
+    n_in = np.stack([v_in_norm[:, 1], -v_in_norm[:, 0]], axis=1)
+    n_out = np.stack([v_out_norm[:, 1], -v_out_norm[:, 0]], axis=1)
+
+    bisector = n_in + n_out
+
+    # degenerate case: 180° corner — bisector vanishes, fall back to incoming edge normal
+    zero_mask = np.linalg.norm(bisector, axis=1) < epsilon
+    if np.any(zero_mask):
+        bisector[zero_mask] = n_in[zero_mask]
+
+    bisector_norm = bisector / np.linalg.norm(bisector, axis=1, keepdims=True)
+
+    sign = np.where(are_corners_convex, 1.0, -1.0)[:, np.newaxis]
+
+    return bisector_norm * sign