ScadPy 0.1.0__py3-none-any.whl

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

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import numpy as np
+from numpy.typing import NDArray
+from typeguard import typechecked
+
+
+@typechecked
+def get_assembly_face_corner_to_incoming_directed_edge(
+    corner_to_vertex: NDArray[np.int64],
+    directed_edge_to_vertex: NDArray[np.int64],
+) -> NDArray[np.int64]:
+    """
+    For each corner, return the index of its incoming directed edge.
+
+    The incoming directed edge of corner ``(prev, curr, next)`` is
+    ``prev → curr``.
+
+    Parameters
+    ----------
+    corner_to_vertex : NDArray[np.int64]
+        2D array of shape ``(n_corners, 3)``. Each row is
+        ``[prev_vertex, curr_vertex, next_vertex]``.
+    directed_edge_to_vertex : NDArray[np.int64]
+        2D array of shape ``(n_directed_edges, 2)``. Each row is
+        ``[start_vertex, end_vertex]``.
+
+    Returns
+    -------
+    NDArray[np.int64]
+        1D array of shape ``(n_corners,)``. Each entry is the index of
+        the incoming directed edge for that corner.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scadpy import (
+    ...     get_assembly_face_corner_to_incoming_directed_edge,
+    ... )
+
+    >>> # triangle: directed edges
+    >>> # [0→1]=0, [1→0]=1, [1→2]=2, [2→1]=3, [2→0]=4, [0→2]=5
+    >>> directed_edge_to_vertex = np.array(
+    ...     [[0, 1], [1, 0], [1, 2], [2, 1], [2, 0], [0, 2]],
+    ...     dtype=np.int64,
+    ... )
+    >>> # corners: (2,0,1), (0,1,2), (1,2,0)
+    >>> # incoming: 2→0, 0→1, 1→2
+    >>> corner_to_vertex = np.array(
+    ...     [[2, 0, 1], [0, 1, 2], [1, 2, 0]], dtype=np.int64
+    ... )
+    >>> get_assembly_face_corner_to_incoming_directed_edge(
+    ...     corner_to_vertex, directed_edge_to_vertex
+    ... )
+    array([4, 0, 2])
+    """
+    if len(corner_to_vertex) == 0:
+        return np.empty(0, dtype=np.int64)
+
+    from scadpy.core.assembly.utils import lookup_pairs
+
+    return lookup_pairs(
+        queries=corner_to_vertex[:, 0:2],
+        haystack=directed_edge_to_vertex,
+    )

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

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import numpy as np
+from numpy.typing import NDArray
+from typeguard import typechecked
+
+
+@typechecked
+def get_assembly_face_corner_to_outgoing_directed_edge(
+    corner_to_vertex: NDArray[np.int64],
+    directed_edge_to_vertex: NDArray[np.int64],
+) -> NDArray[np.int64]:
+    """
+    For each corner, return the index of its outgoing directed edge.
+
+    The outgoing directed edge of corner ``(prev, curr, next)`` is
+    ``curr → next``.
+
+    Parameters
+    ----------
+    corner_to_vertex : NDArray[np.int64]
+        2D array of shape ``(n_corners, 3)``. Each row is
+        ``[prev_vertex, curr_vertex, next_vertex]``.
+    directed_edge_to_vertex : NDArray[np.int64]
+        2D array of shape ``(n_directed_edges, 2)``. Each row is
+        ``[start_vertex, end_vertex]``.
+
+    Returns
+    -------
+    NDArray[np.int64]
+        1D array of shape ``(n_corners,)``. Each entry is the index of
+        the outgoing directed edge for that corner.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scadpy import (
+    ...     get_assembly_face_corner_to_outgoing_directed_edge,
+    ... )
+
+    >>> # triangle: directed edges
+    >>> # [0→1]=0, [1→0]=1, [1→2]=2, [2→1]=3, [2→0]=4, [0→2]=5
+    >>> directed_edge_to_vertex = np.array(
+    ...     [[0, 1], [1, 0], [1, 2], [2, 1], [2, 0], [0, 2]],
+    ...     dtype=np.int64,
+    ... )
+    >>> # corners: (2,0,1), (0,1,2), (1,2,0)
+    >>> # outgoing: 0→1, 1→2, 2→0
+    >>> corner_to_vertex = np.array(
+    ...     [[2, 0, 1], [0, 1, 2], [1, 2, 0]], dtype=np.int64
+    ... )
+    >>> get_assembly_face_corner_to_outgoing_directed_edge(
+    ...     corner_to_vertex, directed_edge_to_vertex
+    ... )
+    array([0, 2, 4])
+    """
+    if len(corner_to_vertex) == 0:
+        return np.empty(0, dtype=np.int64)
+
+    from scadpy.core.assembly.utils import lookup_pairs
+
+    return lookup_pairs(
+        queries=corner_to_vertex[:, 1:3],
+        haystack=directed_edge_to_vertex,
+    )

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

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import numpy as np
+from numpy.typing import NDArray
+from typeguard import typechecked
+
+
+@typechecked
+def get_assembly_face_directed_edge_to_corner(
+    corner_to_outgoing_directed_edge: NDArray[np.int64],
+    corner_to_incoming_directed_edge: NDArray[np.int64],
+) -> NDArray[np.int64]:
+    """
+    For each directed edge, return the indices of its source and target corners.
+
+    The source corner of a directed edge ``curr → next`` is the corner
+    ``(prev, curr, next)`` — the one that *emits* the directed edge as outgoing.
+    The target corner is the corner ``(curr, next, next_next)`` — the one that
+    *receives* it as incoming.
+
+    Parameters
+    ----------
+    corner_to_outgoing_directed_edge : NDArray[np.int64]
+        1D array of shape ``(n_corners,)``. Each entry is the index of the
+        outgoing directed edge for that corner.
+    corner_to_incoming_directed_edge : NDArray[np.int64]
+        1D array of shape ``(n_corners,)``. Each entry is the index of the
+        incoming directed edge for that corner.
+
+    Returns
+    -------
+    NDArray[np.int64]
+        2D array of shape ``(n_directed_edges, 2)``. Each row is
+        ``[source_corner, target_corner]``. Column 0 is the corner that emits
+        the directed edge (outgoing), column 1 is the corner that receives it
+        (incoming).
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scadpy import get_assembly_face_directed_edge_to_corner
+
+    >>> # triangle: 3 corners, 3 edges → 6 directed edges
+    >>> # corners: (2,0,1)=0, (0,1,2)=1, (1,2,0)=2
+    >>> # outgoing: corner 0 → de 0 (0→1),
+    >>> #           corner 1 → de 2 (1→2), corner 2 → de 4 (2→0)
+    >>> # incoming: corner 0 → de 4 (2→0),
+    >>> #           corner 1 → de 0 (0→1), corner 2 → de 2 (1→2)
+    >>> corner_to_outgoing = np.array([0, 2, 4], dtype=np.int64)
+    >>> corner_to_incoming = np.array([4, 0, 2], dtype=np.int64)
+    >>> get_assembly_face_directed_edge_to_corner(
+    ...     corner_to_outgoing, corner_to_incoming
+    ... )
+    array([[0, 1],
+           [1, 0],
+           [1, 2],
+           [2, 1],
+           [2, 0],
+           [0, 2]])
+    """
+    if len(corner_to_outgoing_directed_edge) == 0:
+        return np.empty((0, 2), dtype=np.int64)
+
+    n_corners = len(corner_to_outgoing_directed_edge)
+    n_directed_edges = n_corners * 2
+    source_corner = np.empty(n_directed_edges, dtype=np.int64)
+    target_corner = np.empty(n_directed_edges, dtype=np.int64)
+
+    corner_indices = np.arange(n_corners, dtype=np.int64)
+
+    # Forward directed edges: source = corner that emits (outgoing), target = corner that receives (incoming)
+    source_corner[corner_to_outgoing_directed_edge] = corner_indices
+    target_corner[corner_to_incoming_directed_edge] = corner_indices
+
+    # Backward directed edges (index ^ 1): source/target are swapped vs forward
+    source_corner[corner_to_outgoing_directed_edge ^ 1] = target_corner[corner_to_outgoing_directed_edge]
+    target_corner[corner_to_outgoing_directed_edge ^ 1] = corner_indices
+
+    return np.stack([source_corner, target_corner], axis=1)

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

@@ -0,0 +1,5 @@
+__all__ = [
+    "get_assembly_part_colors",
+]
+
+from .get_assembly_part_colors import get_assembly_part_colors

scadpy/core/assembly/topologies/part/get_assembly_part_colors.py

@@ -0,0 +1,55 @@
+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.core.assembly import Assembly
+
+
+@typechecked
+def get_assembly_part_colors[G](
+    assembly: Assembly[G],
+) -> NDArray[np.float64]:
+    """
+    For each part in the assembly, return its color (r, g, b, a).
+
+    Parameters
+    ----------
+    assembly : VertexableAssembly[G]
+        The assembly object to extract part colors from.
+
+    Returns
+    -------
+    NDArray[np.float64]
+        2D array of shape (n_parts, 4), one row per part.
+
+    Examples
+    --------
+    >>> from shapely.geometry import Polygon
+    >>> from scadpy import (
+    ...     BLUE, RED, get_assembly_part_colors, Part, Shape
+    ... )
+    ...
+    >>> polygon1 = Polygon(
+    ...     shell=[(0, 0), (2, 0), (2, 2), (0, 2)],
+    ...     holes=[[(0.5, 0.5), (1.5, 0.5), (1.5, 1.5), (0.5, 1.5)]]
+    ... )
+    >>> polygon2 = Polygon(
+    ...     shell=[(10, 10), (12, 10), (12, 12), (10, 12)]
+    ... )
+    >>> get_assembly_part_colors(
+    ...     Shape.from_parts([
+    ...         Part[Polygon].from_geometry(polygon1, BLUE),
+    ...         Part[Polygon].from_geometry(polygon2, RED)
+    ...     ]),
+    ... ) # doctest: +NORMALIZE_WHITESPACE
+    array([[0.1, 0.3, 0.9, 1. ],
+           [0.9, 0.1, 0.1, 1. ]])
+    """
+    if not assembly._parts:
+        return np.empty((0, 4), dtype=np.float64)
+    return np.array([p.color for p in assembly._parts])

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

@@ -0,0 +1,7 @@
+__all__ = [
+    "get_assembly_vertex_coordinates",
+    "get_assembly_vertex_to_part",
+]
+
+from .get_assembly_vertex_coordinates import get_assembly_vertex_coordinates
+from .get_assembly_vertex_to_part import get_assembly_vertex_to_part

scadpy/core/assembly/topologies/vertex/get_assembly_vertex_coordinates.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from typing import TYPE_CHECKING
+
+import numpy as np
+from numpy.typing import NDArray
+
+if TYPE_CHECKING:
+    from scadpy.core.part import Part
+
+
+# @typechecked is intentionally omitted: typeguard v4 cannot validate Callable types
+# that contain generic type variables (e.g. Part[G]) at runtime.
+def get_assembly_vertex_coordinates[G](
+    parts: Sequence[Part[G]],
+    get_part_vertex_coordinates: Callable[[Part[G]], NDArray[np.float64]],
+    dimensions: int,
+) -> NDArray[np.float64]:
+    """
+    For each vertex in the assembly, return its coordinates.
+
+    Parameters
+    ----------
+    parts : Sequence[Part[G]]
+        The parts of the assembly.
+    get_part_vertex_coordinates : Callable[[Part[G]], NDArray[np.float64]]
+        Function that extracts vertex coordinates from a single part.
+    dimensions : int
+        Number of spatial dimensions (used when ``parts`` is empty).
+
+    Returns
+    -------
+    NDArray[np.float64]
+        2D array of shape (n_vertices, dimensions), one row per vertex.
+
+    Examples
+    --------
+    >>> from shapely.geometry import Polygon
+    >>> from scadpy import (
+    ...     get_assembly_vertex_coordinates,
+    ...     get_shape_part_vertex_coordinates,
+    ...     Shape,
+    ... )
+
+    >>> polygon1 = Polygon(
+    ...     shell=[(0, 0), (2, 0), (2, 2), (0, 2)],
+    ...     holes=[[(0.5, 0.5), (1.5, 0.5), (1.5, 1.5), (0.5, 1.5)]]
+    ... )
+    >>> polygon2 = Polygon(
+    ...     shell=[(10, 10), (12, 10), (12, 12), (10, 12)]
+    ... )
+    >>> shape = Shape.from_geometries([polygon1, polygon2])
+    >>> get_assembly_vertex_coordinates(
+    ...     shape._parts,
+    ...     get_shape_part_vertex_coordinates,
+    ...     2,
+    ... ) # doctest: +NORMALIZE_WHITESPACE
+    array([[ 0. ,  0. ],
+           [ 2. ,  0. ],
+           [ 2. ,  2. ],
+           ...
+           [12. , 10. ],
+           [12. , 12. ],
+           [10. , 12. ]])
+    """
+    if not parts:
+        return np.empty((0, dimensions), dtype=np.float64)
+
+    return np.vstack([get_part_vertex_coordinates(p) for p in parts])

scadpy/core/assembly/topologies/vertex/get_assembly_vertex_to_part.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from typing import TYPE_CHECKING
+
+import numpy as np
+from numpy.typing import NDArray
+
+if TYPE_CHECKING:
+    from scadpy.core.part import Part
+
+
+# @typechecked is intentionally omitted: typeguard v4 cannot validate Callable types
+# that contain generic type variables (e.g. Part[G]) at runtime.
+def get_assembly_vertex_to_part[G](
+    parts: Sequence[Part[G]],
+    get_part_vertex_coordinates: Callable[[Part[G]], NDArray[np.float64]],
+) -> NDArray[np.int64]:
+    """
+    For each vertex in the assembly, return its part index.
+
+    Parameters
+    ----------
+    parts : Sequence[Part[G]]
+        The parts of the assembly.
+    get_part_vertex_coordinates : Callable[[Part[G]], NDArray[np.float64]]
+        Function that extracts vertex coordinates from a single part.
+
+    Returns
+    -------
+    NDArray[np.int64]
+        1D array of shape (n_vertices,), one element per vertex.
+
+    Examples
+    --------
+    >>> from shapely.geometry import Polygon
+    >>> from scadpy import (
+    ...     get_assembly_vertex_to_part,
+    ...     get_shape_part_vertex_coordinates,
+    ...     Shape,
+    ... )
+
+    >>> polygon1 = Polygon(
+    ...     shell=[(0, 0), (2, 0), (2, 2), (0, 2)],
+    ...     holes=[[(0.5, 0.5), (1.5, 0.5), (1.5, 1.5), (0.5, 1.5)]]
+    ... )
+    >>> polygon2 = Polygon(
+    ...     shell=[(10, 10), (12, 10), (12, 12), (10, 12)]
+    ... )
+    >>> shape = Shape.from_geometries([polygon1, polygon2])
+    >>> get_assembly_vertex_to_part(
+    ...     shape._parts,
+    ...     get_shape_part_vertex_coordinates,
+    ... ) # doctest: +NORMALIZE_WHITESPACE
+    array([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1])
+    """
+    if not parts:
+        return np.array([], dtype=np.int64)
+    return np.concatenate([
+        np.full(len(get_part_vertex_coordinates(p)), i, dtype=np.int64)
+        for i, p in enumerate(parts)
+    ])

scadpy/core/assembly/transformations/__init__.py

@@ -0,0 +1,19 @@
+__all__ = [
+    "color_assembly",
+    "mirror_vertex_coordinates",
+    "pull_vertex_coordinates",
+    "push_vertex_coordinates",
+    "resize_vertex_coordinates",
+    "rotate_vertex_coordinates",
+    "scale_vertex_coordinates",
+    "translate_vertex_coordinates",
+]
+
+from .color_assembly import color_assembly
+from .mirror_vertex_coordinates import mirror_vertex_coordinates
+from .pull_vertex_coordinates import pull_vertex_coordinates
+from .push_vertex_coordinates import push_vertex_coordinates
+from .resize_vertex_coordinates import resize_vertex_coordinates
+from .rotate_vertex_coordinates import rotate_vertex_coordinates
+from .scale_vertex_coordinates import scale_vertex_coordinates
+from .translate_vertex_coordinates import translate_vertex_coordinates

scadpy/core/assembly/transformations/color_assembly.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable, Sequence
+from typing import TYPE_CHECKING
+
+from typeguard import typechecked
+
+if TYPE_CHECKING:
+    from scadpy.color import Color
+    from scadpy.core.part import Part
+
+
+@typechecked
+def color_assembly[A, G](
+    assembly: A,
+    color: Color,
+    get_assembly_parts: Callable[[A], Iterable[Part[G]]],
+    concat_parts: Callable[[Sequence[Part[G]]], A],
+) -> A:
+    from scadpy.core.part import Part
+
+    return concat_parts(
+        [Part[G].from_geometry(p.geometry, color) for p in get_assembly_parts(assembly)]
+    )

scadpy/core/assembly/transformations/mirror_vertex_coordinates.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+import numpy as np
+from numpy.typing import NDArray
+from typeguard import typechecked
+
+
+@typechecked
+def mirror_vertex_coordinates(
+    vertex_coordinates: NDArray[np.float64],
+    normal: float | Iterable[float],
+    pivot: float | Iterable[float] = 0,
+) -> NDArray[np.float64]:
+    """
+    Mirror vertex coordinates across a line (2D) or plane (3D) defined by a normal vector and a pivot point.
+
+    Parameters
+    ----------
+    vertex_coordinates : NDArray[np.float64]
+        2D array of shape (n_vertices, dimensions).
+    normal : float | Iterable[float]
+        The normal vector of the mirror line (2D) or plane (3D). Does not need to be normalized.
+        If a single float is provided, it will be broadcast to all coordinate dimensions.
+    pivot : float | Iterable[float], default=0
+        The point through which the mirror line/plane passes. If a single float is provided, it will be broadcast to all coordinate dimensions.
+        Defaults to 0 (the origin).
+
+    Returns
+    -------
+    NDArray[np.float64]
+        Array of shape (n_vertices, dimensions), one row per vertex.
+
+    Examples
+    --------
+    >>> from shapely.geometry import Polygon
+    >>> from scadpy import mirror_vertex_coordinates, Shape
+
+    >>> polygon = Polygon([(0, 0), (2, 0), (2, 2), (0, 2)])
+    >>> shape = Shape.from_geometries([polygon])
+    >>> mirror_vertex_coordinates(
+    ...     shape.vertex_coordinates,
+    ...     normal=[1, 0],  # Mirror across y-axis
+    ...     pivot=[1, 0]
+    ... ) # doctest: +NORMALIZE_WHITESPACE
+    array([[2., 0.],
+           [0., 0.],
+           [0., 2.],
+           [2., 2.]])
+    """
+    from scadpy import resolve_vector
+
+    dimensions: int = vertex_coordinates.shape[1]
+
+    normal = resolve_vector(normal, 0, dimensions)
+    pivot = resolve_vector(pivot, 0, dimensions)
+
+    normal = normal / np.linalg.norm(normal)
+
+    # vector from pivot to each vertex
+    v = vertex_coordinates - pivot
+    # project v onto normal
+    projection = np.dot(v, normal)
+    # reflection formula
+    mirrored = vertex_coordinates - 2 * projection[:, np.newaxis] * normal
+
+    return mirrored

scadpy/core/assembly/transformations/pull_vertex_coordinates.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+import numpy as np
+from numpy.typing import NDArray
+from typeguard import typechecked
+
+
+@typechecked
+def pull_vertex_coordinates(
+    vertex_coordinates: NDArray[np.float64],
+    distance: float,
+    pivot: float | Iterable[float] = 0,
+    vertex_filter: NDArray[np.bool_] | None = None,
+) -> NDArray[np.float64]:
+    """
+    Move selected vertices toward a pivot point by at most ``distance`` units.
+
+    Each selected vertex is translated in the direction of the pivot by at most
+    ``distance``. Vertices already closer than ``distance`` to the pivot are moved
+    exactly to the pivot.
+
+    Parameters
+    ----------
+    vertex_coordinates : NDArray[np.float64]
+        2D array of shape (n_vertices, dimensions).
+    distance : float
+        The maximum distance each vertex is moved toward the pivot.
+    pivot : float | Iterable[float], default=0
+        The point vertices are pulled toward. If a single float is provided,
+        it is broadcast to all coordinate dimensions. Defaults to the origin.
+    vertex_filter : NDArray[np.bool_] | None, default=None
+        Boolean array selecting which vertices are moved. If ``None``, all
+        vertices are moved.
+
+    Returns
+    -------
+    NDArray[np.float64]
+        Array of shape (n_vertices, dimensions), one row per vertex.
+
+    See Also
+    --------
+    push_vertex_coordinates : Move vertices away from a pivot point.
+    """
+    from scadpy import resolve_vector
+
+    dimensions: int = vertex_coordinates.shape[1]
+    pivot_array = resolve_vector(pivot, 0, dimensions)
+
+    coords = vertex_coordinates if vertex_filter is None else vertex_coordinates[vertex_filter]
+    vectors = pivot_array - coords
+    lengths = np.linalg.norm(vectors, axis=1, keepdims=True)
+    directions = np.divide(
+        vectors, lengths, out=np.zeros_like(vectors), where=lengths != 0
+    )
+    translations = directions * np.minimum(distance, lengths)
+
+    if vertex_filter is None:
+        return vertex_coordinates + translations
+
+    result = np.array(vertex_coordinates)
+    result[vertex_filter] += translations
+    return result

scadpy/core/assembly/transformations/push_vertex_coordinates.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+import numpy as np
+from numpy.typing import NDArray
+from typeguard import typechecked
+
+
+@typechecked
+def push_vertex_coordinates(
+    vertex_coordinates: NDArray[np.float64],
+    distance: float,
+    pivot: float | Iterable[float] = 0,
+    vertex_filter: NDArray[np.bool_] | None = None,
+) -> NDArray[np.float64]:
+    """
+    Move selected vertices away from a pivot point by ``distance`` units.
+
+    Each selected vertex is translated in the direction away from the pivot by
+    exactly ``distance``. Vertices located exactly at the pivot are not moved
+    (undefined direction).
+
+    Parameters
+    ----------
+    vertex_coordinates : NDArray[np.float64]
+        2D array of shape (n_vertices, dimensions).
+    distance : float
+        The distance each vertex is moved away from the pivot.
+    pivot : float | Iterable[float], default=0
+        The point vertices are pushed away from. If a single float is provided,
+        it is broadcast to all coordinate dimensions. Defaults to the origin.
+    vertex_filter : NDArray[np.bool_] | None, default=None
+        Boolean array selecting which vertices are moved. If ``None``, all
+        vertices are moved.
+
+    Returns
+    -------
+    NDArray[np.float64]
+        Array of shape (n_vertices, dimensions), one row per vertex.
+
+    See Also
+    --------
+    pull_vertex_coordinates : Move vertices toward a pivot point.
+    """
+    from scadpy import resolve_vector
+
+    dimensions: int = vertex_coordinates.shape[1]
+    pivot_array = resolve_vector(pivot, 0, dimensions)
+
+    coords = vertex_coordinates if vertex_filter is None else vertex_coordinates[vertex_filter]
+    vectors = coords - pivot_array
+    lengths = np.linalg.norm(vectors, axis=1, keepdims=True)
+    directions = np.divide(
+        vectors, lengths, out=np.zeros_like(vectors), where=lengths != 0
+    )
+    translations = directions * distance
+
+    if vertex_filter is None:
+        return vertex_coordinates + translations
+
+    result = np.array(vertex_coordinates)
+    result[vertex_filter] += translations
+    return result