ScadPy 0.1.0__py3-none-any.whl

scadpy/d3/solid/topologies/vertex/get_solid_vertex_coordinates.py

@@ -0,0 +1,39 @@
+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 Solid
+
+
+@typechecked
+def get_solid_vertex_coordinates(solid: Solid) -> NDArray[np.float64]:
+    """For each vertex in the solid, return its coordinates.
+
+    Parameters
+    ----------
+    solid : Solid
+        The solid to extract vertex coordinates from.
+
+    Returns
+    -------
+    NDArray[np.float64]
+        2D array of shape (n_vertices, 3), one row per vertex.
+
+    Examples
+    --------
+    >>> from scadpy import cuboid, get_solid_vertex_coordinates
+
+    >>> vertex_coordinates = get_solid_vertex_coordinates(cuboid(2))
+    >>> vertex_coordinates.shape
+    (8, 3)
+    """
+    from scadpy import get_assembly_vertex_coordinates
+
+    return get_assembly_vertex_coordinates(
+        solid._parts, lambda p: p.geometry.vertices, 3
+    )

scadpy/d3/solid/topologies/vertex/get_solid_vertex_to_part.py

@@ -0,0 +1,37 @@
+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 Solid
+
+
+@typechecked
+def get_solid_vertex_to_part(solid: Solid) -> NDArray[np.int64]:
+    """For each vertex in the solid, return its part index.
+
+    Parameters
+    ----------
+    solid : Solid
+        The solid to extract part indices from.
+
+    Returns
+    -------
+    NDArray[np.int64]
+        1D array of shape (n_vertices,), one element per vertex.
+
+    Examples
+    --------
+    >>> from scadpy import cuboid, get_solid_vertex_to_part
+
+    >>> solid = cuboid(2) + cuboid(2).translate(5)
+    >>> get_solid_vertex_to_part(solid)
+    array([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1])
+    """
+    from scadpy import get_assembly_vertex_to_part
+
+    return get_assembly_vertex_to_part(solid._parts, lambda p: p.geometry.vertices)

scadpy/d3/solid/transformations/__init__.py

@@ -0,0 +1,23 @@
+__all__ = [
+    "color_solid",
+    "convexify_solid",
+    "mirror_solid",
+    "pull_solid",
+    "push_solid",
+    "recoordinate_solid",
+    "resize_solid",
+    "rotate_solid",
+    "scale_solid",
+    "translate_solid",
+]
+
+from .color_solid import color_solid
+from .convexify_solid import convexify_solid
+from .mirror_solid import mirror_solid
+from .pull_solid import pull_solid
+from .push_solid import push_solid
+from .recoordinate_solid import recoordinate_solid
+from .resize_solid import resize_solid
+from .rotate_solid import rotate_solid
+from .scale_solid import scale_solid
+from .translate_solid import translate_solid

scadpy/d3/solid/transformations/color_solid.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from typeguard import typechecked
+
+if TYPE_CHECKING:
+    from scadpy import Color, Solid
+
+
+@typechecked
+def color_solid(solid: Solid, color: Color) -> Solid:
+    """Set the color of all parts in a solid.
+
+    Parameters
+    ----------
+    solid : Solid
+        The solid whose parts will be recolored.
+    color : Color
+        The RGBA color to apply to all parts.
+
+    Returns
+    -------
+    Solid
+        A new solid with all parts set to the given color.
+
+    Examples
+    --------
+    >>> from scadpy import cuboid, color_solid
+    >>> from scadpy.color.constants import RED
+
+    >>> color_solid(solid=cuboid(4), color=RED) # doctest: +SKIP
+
+    .. render-example::
+        :name: color_solid
+        :example: color_solid(solid=cuboid(4), color=RED)
+        :keep-color:
+    """
+    from scadpy import Solid, color_assembly
+
+    return color_assembly(
+        assembly=solid,
+        color=color,
+        get_assembly_parts=lambda assembly: assembly._parts,
+        concat_parts=Solid.from_parts,
+    )

scadpy/d3/solid/transformations/convexify_solid.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+from trimesh import Trimesh
+from typeguard import typechecked
+
+if TYPE_CHECKING:
+    from scadpy import Solid, TopologyFilter
+
+
+@typechecked
+def convexify_solid(
+    solid: Solid, part_filter: TopologyFilter[Solid] | None = None
+) -> Solid:
+    """Create a new solid whose selected parts are replaced by their convex hull.
+
+    Parameters
+    ----------
+    solid : Solid
+        The input solid whose parts will be convexified.
+    part_filter : TopologyFilter[Solid] | None, optional
+        A boolean mask selecting which parts to convexify. Parts not selected are
+        left unchanged. If None, all parts are convexified together.
+
+    Returns
+    -------
+    Solid
+        A new solid consisting of the convex hull of the selected parts, plus the
+        unselected parts unchanged.
+
+    Examples
+    --------
+    >>> from scadpy import cuboid, sphere, convexify_solid
+
+    >>> convexify_solid(  # doctest: +SKIP
+    ...     cuboid(4) + sphere(radius=2).translate([3, 3, 3])
+    ... )
+
+    .. render-example::
+        :name: convexify_solid
+        :example: convexify_solid(cuboid(4) + sphere(radius=2).translate([3, 3, 3]))
+        :ghost: cuboid(4) + sphere(radius=2).translate([3, 3, 3])
+    """
+    from scadpy import Part, Solid, blend_part_colors, transform_filtered_parts
+
+    return transform_filtered_parts(
+        assembly=solid,
+        parts=solid._parts,
+        part_filter=part_filter,
+        transform=lambda parts: [
+            Part[Trimesh].from_geometry(
+                Trimesh(
+                    vertices=np.vstack([p.geometry.vertices for p in parts])
+                ).convex_hull,
+                blend_part_colors(
+                    parts=parts,
+                    get_part_magnitude=lambda p: p.geometry.volume,
+                ),
+            )
+        ],
+        concat_parts=Solid.from_parts,
+    )

scadpy/d3/solid/transformations/mirror_solid.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 Solid
+
+
+@typechecked
+def mirror_solid(
+    solid: Solid,
+    normal: float | Iterable[float],
+    pivot: float | Iterable[float] = 0,
+) -> Solid:
+    """Mirror a solid across a plane defined by a normal vector and a pivot point.
+
+    Parameters
+    ----------
+    solid : Solid
+        The solid to mirror.
+    normal : float | Iterable[float]
+        The normal vector of the mirror plane. 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 plane passes. If a single float is
+        provided, it is broadcast to all coordinate dimensions. Defaults to the origin.
+
+    Returns
+    -------
+    Solid
+        A new solid with all vertices mirrored across the specified plane.
+
+    Examples
+    --------
+    >>> from scadpy import cuboid, mirror_solid
+
+    >>> mirror_solid(  # doctest: +SKIP
+    ...     solid=cuboid(4), normal=[1, 0, 0], pivot=[2, 0, 0]
+    ... )
+
+    .. render-example::
+        :name: mirror_solid
+        :example: mirror_solid(solid=cuboid(4), normal=[1, 0, 0], pivot=[2, 0, 0])
+        :ghost: cuboid(4)
+    """
+    from scadpy import mirror_vertex_coordinates
+
+    return solid.recoordinate(
+        mirror_vertex_coordinates(solid.vertex_coordinates, normal, pivot)
+    )

scadpy/d3/solid/transformations/pull_solid.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 Solid, TopologyFilter
+
+
+@typechecked
+def pull_solid(
+    solid: Solid,
+    distance: float,
+    pivot: float | Iterable[float] = 0,
+    vertex_filter: TopologyFilter[Solid] | None = None,
+) -> Solid:
+    """Move a subset of solid 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
+    ----------
+    solid : Solid
+        The solid 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[Solid] | None, default=None
+        A boolean array or callable selecting which vertices are affected. If ``None``,
+        all vertices are moved.
+
+    Returns
+    -------
+    Solid
+        A new solid with the selected vertices moved toward the pivot.
+
+    See Also
+    --------
+    push_solid : Move solid vertices away from a pivot point.
+
+    Examples
+    --------
+    >>> from scadpy import cuboid, pull_solid
+    >>> import numpy as np
+
+    >>> pull_solid(  # doctest: +SKIP
+    ...     solid=cuboid(4), distance=1.0, pivot=[2, 2, 2],
+    ...     vertex_filter=np.ones(8, dtype=bool),
+    ... )
+
+    .. render-example::
+        :name: pull_solid
+        :example: pull_solid(solid=cuboid(4), distance=1.0, pivot=[2, 2, 2], vertex_filter=cuboid(4).vertex_coordinates[:, 0] < 1)
+        :ghost: cuboid(4)
+    """
+    from scadpy import resolve_topology_filter, pull_vertex_coordinates
+
+    resolved_vertex_filter = resolve_topology_filter(solid, len(solid.vertex_coordinates), vertex_filter)
+    return solid.recoordinate(
+        pull_vertex_coordinates(solid.vertex_coordinates, distance, pivot, resolved_vertex_filter)
+    )

scadpy/d3/solid/transformations/push_solid.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 Solid, TopologyFilter
+
+
+@typechecked
+def push_solid(
+    solid: Solid,
+    distance: float,
+    pivot: float | Iterable[float] = 0,
+    vertex_filter: TopologyFilter[Solid] | None = None,
+) -> Solid:
+    """Move a subset of solid 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
+    ----------
+    solid : Solid
+        The solid 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[Solid] | None, default=None
+        A boolean array or callable selecting which vertices are affected. If ``None``,
+        all vertices are moved.
+
+    Returns
+    -------
+    Solid
+        A new solid with the selected vertices moved away from the pivot.
+
+    See Also
+    --------
+    pull_solid : Move solid vertices toward a pivot point.
+
+    Examples
+    --------
+    >>> from scadpy import cuboid, push_solid
+    >>> import numpy as np
+
+    >>> push_solid(  # doctest: +SKIP
+    ...     solid=cuboid(4), distance=1.0, pivot=[2, 2, 2],
+    ...     vertex_filter=np.ones(8, dtype=bool),
+    ... )
+
+    .. render-example::
+        :name: push_solid
+        :example: push_solid(solid=cuboid(4), distance=1.0, pivot=[2, 2, 2], vertex_filter=cuboid(4).vertex_coordinates[:, 0] < 1)
+        :ghost: cuboid(4)
+    """
+    from scadpy import resolve_topology_filter, push_vertex_coordinates
+
+    resolved_vertex_filter = resolve_topology_filter(solid, len(solid.vertex_coordinates), vertex_filter)
+    return solid.recoordinate(
+        push_vertex_coordinates(solid.vertex_coordinates, distance, pivot, resolved_vertex_filter)
+    )

scadpy/d3/solid/transformations/recoordinate_solid.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+from numpy.typing import NDArray
+from trimesh import Trimesh
+from typeguard import typechecked
+
+if TYPE_CHECKING:
+    from scadpy.d3.solid import Solid
+
+
+@typechecked
+def recoordinate_solid(
+    solid: Solid, vertex_coordinates: NDArray[np.float64]
+) -> Solid:
+    """Rebuild a solid with new vertex coordinates, preserving topology and colors.
+
+    Parameters
+    ----------
+    solid : Solid
+        The source solid providing topology (part/face structure) and colors.
+    vertex_coordinates : NDArray[np.float64]
+        New vertex coordinates of shape ``(n_vertices, 3)``, in the same order
+        as :func:`get_assembly_vertex_coordinates`.
+
+    Returns
+    -------
+    Solid
+        A new solid with the same topology as *solid* but at the new positions.
+
+    Examples
+    --------
+    >>> from scadpy import cuboid, recoordinate_solid
+
+    >>> recoordinate_solid(  # doctest: +SKIP
+    ...     solid=cuboid(4),
+    ...     vertex_coordinates=cuboid(4).vertex_coordinates + [2.0, 1.0, 0.0],
+    ... )
+
+    .. render-example::
+        :name: recoordinate_solid
+        :example: recoordinate_solid(solid=cuboid(4), vertex_coordinates=cuboid(4).vertex_coordinates + [2.0, 1.0, 0.0])
+        :ghost: cuboid(4)
+    """
+    from scadpy import Part, map_parts_to_solid
+
+    vertex_to_part = solid.vertex_to_part
+    part_colors = solid.part_colors
+
+    parts = []
+    for part_index in np.unique(vertex_to_part):
+        part_mask = vertex_to_part == part_index
+        part_vertex_coordinates = vertex_coordinates[part_mask]
+        color = list(part_colors[part_index])
+
+        parts.append(
+            Part[Trimesh].from_geometry(
+                Trimesh(
+                    vertices=part_vertex_coordinates,
+                    faces=solid._parts[part_index].geometry.faces,
+                ),
+                color,
+            )
+        )
+
+    return map_parts_to_solid(parts)

scadpy/d3/solid/transformations/resize_solid.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import TYPE_CHECKING
+
+from typeguard import typechecked
+
+if TYPE_CHECKING:
+    from scadpy import Solid, TopologyFilter
+
+
+@typechecked
+def resize_solid(
+    solid: Solid,
+    size: Iterable[float | None],
+    auto: bool = False,
+    pivot: float | Iterable[float] | None = None,
+    vertex_filter: TopologyFilter[Solid] | None = None,
+) -> Solid:
+    """Resize a solid to fit target dimensions.
+
+    Scales the solid so that each non-``None`` axis matches the given target
+    size. The scaling pivot defaults to the center of the bounding box so the
+    solid stays in place.
+
+    Shortcut delegating to :func:`resize_vertex_coordinates`.
+
+    Parameters
+    ----------
+    solid : Solid
+        The solid to resize.
+    size : Iterable[float | None]
+        Target dimensions ``[width, height, depth]``. Pass ``None`` for an
+        axis to leave it unchanged (or scale it proportionally when
+        ``auto=True``).
+    auto : bool, default=False
+        If ``True``, axes with ``None`` are scaled proportionally to the
+        average ratio of the defined axes. If ``False``, ``None`` axes are
+        left unchanged.
+    pivot : float | Iterable[float] | None, default=None
+        The point relative to which scaling is performed. Defaults to the
+        center of the bounding box.
+    vertex_filter : TopologyFilter[Solid] | None, default=None
+        Boolean array or callable selecting which vertices are resized. If ``None``, all
+        vertices are resized.
+
+    Returns
+    -------
+    Solid
+        A new solid resized to the target dimensions.
+
+    Examples
+    --------
+    >>> from scadpy import cuboid, resize_solid
+
+    >>> # resize to an exact size on all axes:
+    >>> resize_solid(solid=cuboid([4, 2, 1]), size=[6, 6, 6]) # doctest: +SKIP
+
+    .. render-example::
+       :name: resize_solid_exact
+       :example: resize_solid(solid=cuboid([4, 2, 1]), size=[6, 6, 6])
+       :ghost: cuboid([4, 2, 1])
+
+    >>> # freeze two axes (``None``) and scale only the first:
+    >>> resize_solid(solid=cuboid([4, 2, 1]), size=[6, None, None]) # doctest: +SKIP
+
+    .. render-example::
+       :name: resize_solid_freeze
+       :example: resize_solid(solid=cuboid([4, 2, 1]), size=[6, None, None])
+       :ghost: cuboid([4, 2, 1])
+
+    >>> # scale frozen axes proportionally with ``auto=True``:
+    >>> resize_solid(solid=cuboid([4, 2, 1]), size=[6, None, None], auto=True) # doctest: +SKIP
+
+    .. render-example::
+       :name: resize_solid_auto
+       :example: resize_solid(solid=cuboid([4, 2, 1]), size=[6, None, None], auto=True)
+       :ghost: cuboid([4, 2, 1])
+    """
+    from scadpy import resolve_topology_filter, resize_vertex_coordinates
+
+    resolved_vertex_filter = resolve_topology_filter(solid, len(solid.vertex_coordinates), vertex_filter)
+    return solid.recoordinate(
+        resize_vertex_coordinates(
+            solid.vertex_coordinates,
+            size=size,
+            n_dims=3,
+            auto=auto,
+            pivot=pivot,
+            vertex_filter=resolved_vertex_filter,
+        )
+    )

scadpy/d3/solid/transformations/rotate_solid.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import TYPE_CHECKING
+
+import numpy as np
+from typeguard import typechecked
+
+if TYPE_CHECKING:
+    from scadpy.d3.solid import Solid
+    from scadpy import TopologyFilter
+
+
+@typechecked
+def rotate_solid(
+    solid: Solid,
+    angle: float,
+    axis: float | Iterable[float],
+    pivot: float | Iterable[float] = 0,
+    vertex_filter: TopologyFilter[Solid] | None = None,
+) -> Solid:
+    """Rotate a solid by a given angle around an axis passing through a pivot point.
+
+    Parameters
+    ----------
+    solid : Solid
+        The solid to rotate.
+    angle : float
+        The rotation angle in degrees.
+    axis : float | Iterable[float]
+        The rotation axis vector. If a single float is provided, it is broadcast
+        to all coordinate dimensions.
+    pivot : float | Iterable[float], default=0
+        The point around which rotation is applied. If a single float is provided,
+        it is broadcast to all coordinate dimensions. Defaults to the origin.
+    vertex_filter : TopologyFilter[Solid] | None, default=None
+        Boolean array or callable selecting which vertices are rotated. If ``None``, all
+        vertices are rotated.
+
+    Returns
+    -------
+    Solid
+        A new solid with the selected vertices rotated around the axis and pivot.
+
+    Examples
+    --------
+    >>> from scadpy import cuboid, rotate_solid
+
+    >>> rotate_solid(  # doctest: +SKIP
+    ...     solid=cuboid(4), angle=45,
+    ...     axis=[0, 0, 1], pivot=[2, 2, 2],
+    ... )
+
+    .. render-example::
+        :name: rotate_solid
+        :example: rotate_solid(solid=cuboid(4), angle=45, axis=[0, 0, 1], pivot=[2, 2, 2])
+        :ghost: cuboid(4)
+    """
+    from scadpy import resolve_topology_filter, rotate_vertex_coordinates, resolve_vector_3d
+
+    angle_rad = np.deg2rad(angle)
+    cosinus = np.cos(angle_rad)
+    sinus = np.sin(angle_rad)
+    one_minus_cosinus = 1 - cosinus
+
+    axis_array = resolve_vector_3d(axis, 0)
+    axis_array = axis_array / np.linalg.norm(axis_array)
+    x, y, z = axis_array
+
+    R = np.array(
+        [
+            [
+                cosinus + x * x * one_minus_cosinus,
+                x * y * one_minus_cosinus - z * sinus,
+                x * z * one_minus_cosinus + y * sinus,
+            ],
+            [
+                y * x * one_minus_cosinus + z * sinus,
+                cosinus + y * y * one_minus_cosinus,
+                y * z * one_minus_cosinus - x * sinus,
+            ],
+            [
+                z * x * one_minus_cosinus - y * sinus,
+                z * y * one_minus_cosinus + x * sinus,
+                cosinus + z * z * one_minus_cosinus,
+            ],
+        ]
+    )
+
+    resolved_vertex_filter = resolve_topology_filter(solid, len(solid.vertex_coordinates), vertex_filter)
+    return solid.recoordinate(
+        rotate_vertex_coordinates(solid.vertex_coordinates, R, pivot, resolved_vertex_filter)
+    )