ScadPy 0.1.0__py3-none-any.whl

scadpy/core/component/exporters/map_component_to_screen.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import sys
+import tempfile
+from collections.abc import Callable
+
+from IPython.core.display import HTML
+from PySide6.QtCore import QUrl
+from PySide6.QtWebEngineCore import QWebEngineSettings
+from PySide6.QtWebEngineWidgets import QWebEngineView
+from PySide6.QtWidgets import QApplication
+from typeguard import typechecked
+
+
+@typechecked
+def map_component_to_screen[Component](
+    component: Component, to_html: Callable[[Component], HTML]
+):
+    """
+    Render a component as HTML and display it in a Qt-based window.
+
+    Parameters
+    ----------
+    component : Component
+        The component to export and display.
+    to_html : Callable[[Component], HTML]
+        Function that converts the component to an IPython HTML object.
+
+    Examples
+    --------
+    >>> from IPython.core.display import HTML
+    >>> from scadpy import map_component_to_screen
+
+    >>> component = "Hello, World!"
+    >>> map_component_to_screen(
+    ...     component,
+    ...     to_html=lambda c: HTML(f"<h1>{c}</h1>")
+    ... )  # doctest: +SKIP
+    """
+
+    html = str(to_html(component).data)
+
+    app = QApplication.instance()
+    if app is None:
+        app = QApplication(sys.argv)
+
+    tmp = tempfile.NamedTemporaryFile(mode="w", suffix=".html", delete=False, encoding="utf-8")
+    tmp.write(html)
+    tmp.close()
+
+    view = QWebEngineView()
+    view.settings().setAttribute(
+        QWebEngineSettings.WebAttribute.LocalContentCanAccessRemoteUrls, True
+    )
+    view.load(QUrl.fromLocalFile(tmp.name))
+    view.setWindowTitle("ScadPy")
+    view.resize(800, 800)
+    view.show()
+
+    view.raise_()
+    view.activateWindow()
+
+    sys.exit(app.exec())

scadpy/core/component/features/__init__.py

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

scadpy/core/component/features/get_component_bounds.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import numpy as np
+from numpy.typing import NDArray
+from typeguard import typechecked
+
+
+@typechecked
+def get_component_bounds(vertex_coordinates: NDArray[np.float64]) -> NDArray[np.float64]:
+    """
+    Compute the axis-aligned bounding box from vertex coordinates.
+
+    Parameters
+    ----------
+    vertex_coordinates : NDArray[np.float64]
+        2D array of shape ``(n_vertices, n_dimensions)`` with vertex coordinates.
+
+    Returns
+    -------
+    NDArray[np.float64]
+        1D array ``[min_x, min_y, (min_z,) max_x, max_y, (max_z,)]``.
+        Returns zeros if there are no vertices.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scadpy import get_component_bounds
+
+    >>> get_component_bounds(np.array([[0., 0., 0.], [1., 2., 3.]]))
+    array([0., 0., 0., 1., 2., 3.])
+
+    >>> get_component_bounds(np.empty((0, 2)))
+    array([0., 0., 0., 0.])
+    """
+    if len(vertex_coordinates) == 0:
+        dimensions = vertex_coordinates.shape[1]
+        return np.zeros(2 * dimensions, dtype=np.float64)
+    return np.concatenate([vertex_coordinates.min(axis=0), vertex_coordinates.max(axis=0)])

scadpy/core/component/utils/__init__.py

@@ -0,0 +1,9 @@
+__all__ = [
+    "blend_component_colors",
+    "get_intersecting_component_index_groups",
+]
+
+from .blend_component_colors import blend_component_colors
+from .get_intersecting_component_index_groups import (
+    get_intersecting_component_index_groups,
+)

scadpy/core/component/utils/blend_component_colors.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+
+import numpy as np
+from typeguard import typechecked
+
+from scadpy.color import Color
+
+
+@typechecked
+def blend_component_colors[C](
+    components: Sequence[C],
+    get_component_color: Callable[[C], Color],
+    get_component_magnitude: Callable[[C], float],
+) -> Color:
+    """
+    Compute the weighted average (blend) of component colors, using each component's magnitude as the weight.
+
+    This function is fully generic and uses dependency injection for all domain-specific
+    operations, making it suitable for a wide range of applications (2D, 3D, CAD, etc.).
+    Colors are expected to be RGBA sequences (length 4). If the total magnitude is zero,
+    a default color is returned.
+
+    Parameters
+    ----------
+    components : Sequence[C]
+        List of components whose colors will be blended.
+    get_component_color : Callable[[C], Color]
+        Function to extract the color from a component (as a list or tuple of 4 floats: RGBA).
+    get_component_magnitude : Callable[[C], float]
+        Function to extract a magnitude (e.g., area, volume) from a component for weighting.
+
+    Returns
+    -------
+    Color
+        The blended color as a list of 4 floats (RGBA).
+
+    Examples
+    --------
+    >>> from scadpy import blend_component_colors, DEFAULT_COLOR
+
+    >>> components = [
+    ...     {'color': [1, 0, 0, 1], 'magnitude': 1},
+    ...     {'color': [0, 1, 0, 1], 'magnitude': 2}
+    ... ]
+    ...
+    >>> blend_component_colors(
+    ...     components,
+    ...     get_component_color=lambda c: c['color'],
+    ...     get_component_magnitude=lambda c: c['magnitude']
+    ... )
+    [0.3333333333333333, 0.6666666666666666, 0.0, 1.0]
+
+    >>> blend_component_colors(
+    ...     [],
+    ...     get_component_color=lambda c: c['color'],
+    ...     get_component_magnitude=lambda c: c['magnitude']
+    ... ) == DEFAULT_COLOR
+    True
+    """
+    from scadpy.color import DEFAULT_COLOR
+
+    total_magnitude = 0.0
+    weighted_color = np.zeros(4, dtype=np.float64)
+
+    for component in components:
+        color = np.array(get_component_color(component))
+        magnitude = get_component_magnitude(component)
+        weighted_color += color * magnitude
+        total_magnitude += magnitude
+
+    if total_magnitude == 0:
+        return DEFAULT_COLOR
+
+    blended = weighted_color / total_magnitude
+    return [float(x) for x in blended]  # pyright: ignore[reportAny]

scadpy/core/component/utils/get_intersecting_component_index_groups.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+
+import numpy as np
+from numpy.typing import NDArray
+from rtree import index as rtree_index
+from typeguard import typechecked
+
+
+@typechecked
+def get_intersecting_component_index_groups[C](
+    components: Sequence[C],
+    get_component_bounds: Callable[[C], NDArray[np.float64]],
+    are_components_intersecting: Callable[[C, C], bool],
+) -> list[list[int]]:
+    """
+    Find groups of mutually intersecting components by their indices.
+
+    This function uses an R-tree for efficient spatial indexing and a graph traversal
+    to group components that are directly or indirectly intersecting. It is fully
+    generic and uses dependency injection for all domain-specific operations.
+
+    Parameters
+    ----------
+    components : Sequence[C]
+        Sequence of components to group.
+    get_component_bounds : Callable[[C], NDArray[np.float64]]
+        Function to extract the bounding box of a component (as [minx, miny, maxx, maxy]).
+    are_components_intersecting : Callable[[C, C], bool]
+        Function to determine if two components intersect.
+
+    Returns
+    -------
+    list[list[int]]
+        A list of groups, each group being a list of indices into the original components
+        sequence, where all components in a group are mutually intersecting (directly or indirectly).
+
+    Examples
+    --------
+    >>> from scadpy import get_intersecting_component_index_groups
+
+    >>> components = [
+    ...     {'bounds': [0, 0, 2, 2]},
+    ...     {'bounds': [1, 1, 3, 3]},
+    ...     {'bounds': [5, 5, 6, 6]}
+    ... ]
+    ...
+    >>> def are_intersecting(c1, c2):
+    ...     b1, b2 = c1['bounds'], c2['bounds']
+    ...     return not (b1[2] <= b2[0] or b2[2] <= b1[0] or
+    ...                 b1[3] <= b2[1] or b2[3] <= b1[1])
+    ...
+    >>> get_intersecting_component_index_groups(
+    ...     components,
+    ...     get_component_bounds=lambda c: c['bounds'],
+    ...     are_components_intersecting=are_intersecting
+    ... )
+    [[0, 1], [2]]
+
+    >>> get_intersecting_component_index_groups(
+    ...     [],
+    ...     get_component_bounds=lambda c: c['bounds'],
+    ...     are_components_intersecting=are_intersecting
+    ... )
+    []
+    """
+    if not components:
+        return []
+
+    first_bounding_box = len(get_component_bounds(components[0]))
+
+    properties = rtree_index.Property()
+    properties.dimension = int(first_bounding_box / 2)
+    rtree = rtree_index.Index(properties=properties)
+    for i, component in enumerate(components):
+        rtree.insert(i, get_component_bounds(component))
+
+    neighbors: list[set[int]] = [set() for _ in range(len(components))]
+
+    for i, component_i in enumerate(components):
+        component_i_bounds = get_component_bounds(component_i)
+        candidate_indices = list(rtree.intersection(component_i_bounds))
+
+        for j in candidate_indices:
+            if j <= i:
+                # avoid double counting
+                continue
+            component_j = components[j]
+            if are_components_intersecting(component_i, component_j):
+                neighbors[i].add(j)
+                neighbors[j].add(i)
+
+    groups: list[list[int]] = []
+    visited: set[int] = set()
+    for i in range(len(components)):
+        if i not in visited:
+            stack = [i]
+            group: list[int] = []
+            while stack:
+                idx = stack.pop()
+                if idx not in visited:
+                    visited.add(idx)
+                    group.append(idx)
+                    stack.extend(neighbors[idx] - visited)
+            groups.append(group)
+
+    return groups

scadpy/core/part/__init__.py

@@ -0,0 +1,3 @@
+from .combinations import *  # noqa: F403
+from .types import *  # noqa: F403
+from .utils import *  # noqa: F403

scadpy/core/part/combinations/__init__.py

@@ -0,0 +1,11 @@
+__all__ = [
+    "concat_parts",
+    "intersect_parts",
+    "subtract_parts",
+    "unify_parts",
+]
+
+from .concat_parts import concat_parts
+from .intersect_parts import intersect_parts
+from .subtract_parts import subtract_parts
+from .unify_parts import unify_parts

scadpy/core/part/combinations/concat_parts.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+
+from typeguard import typechecked
+
+
+@typechecked
+def concat_parts[A, P](
+    parts: Sequence[P],
+    make_assembly_from_parts: Callable[[Sequence[P]], A],
+) -> A:
+    """
+    Combine multiple parts into a single assembly using a user-provided constructor.
+
+    This function uses dependency injection to remain type-agnostic, allowing it
+    to work with any part and assembly domain model by providing an appropriate
+    assembly constructor function. No validation or modification of the parts is performed.
+
+    Parameters
+    ----------
+    parts : Sequence[P]
+        Sequence of part objects to be combined.
+    make_assembly_from_parts : Callable[[Sequence[P]], A]
+        Function that takes a sequence of parts and returns an assembly object.
+
+    Returns
+    -------
+    A
+        The assembly object created by combining the provided parts.
+
+    Examples
+    --------
+    >>> from scadpy import concat_parts
+
+    >>> parts = [1, 2, 3]
+    >>> concat_parts(
+    ...     parts, make_assembly_from_parts=lambda ps: sum(ps)
+    ... )
+    6
+
+    >>> parts = ['a', 'b', 'c']
+    >>> concat_parts(
+    ...     parts, make_assembly_from_parts=lambda ps: ''.join(ps)
+    ... )
+    'abc'
+    """
+    return make_assembly_from_parts(parts)

scadpy/core/part/combinations/intersect_parts.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable, Sequence
+from typing import TYPE_CHECKING
+
+import numpy as np
+from numpy.typing import NDArray
+
+if TYPE_CHECKING:
+    from scadpy.color import Color
+
+
+# @typechecked
+def intersect_parts[A, P, G](
+    parts: Sequence[P],
+    get_part_color: Callable[[P], Color],
+    get_part_magnitude: Callable[[P], float],
+    get_part_bounds: Callable[[P], NDArray[np.float64]],
+    are_parts_intersecting: Callable[[P, P], bool],
+    get_part_geometry: Callable[[P], G],
+    intersect_geometries: Callable[[list[G]], Iterable[G]],
+    make_part_from_geometry: Callable[[G, Color], P],
+    make_assembly_from_parts: Callable[[Sequence[P]], A],
+) -> A:
+    """
+    Compute intersections of groups of parts, blend their colors (weighted by magnitude), and return a new assembly.
+
+    This function is fully generic and uses dependency injection for all domain-specific
+    operations, making it suitable for a wide range of applications (2D, 3D, CAD, etc.).
+    Colors are blended using a weighted average, where each part's color is weighted by its magnitude.
+
+    Parameters
+    ----------
+    parts : Sequence[P]
+        Sequence of part objects to process.
+    get_part_color : Callable[[P], Color]
+        Function to extract the color from a part (as a list or tuple of 4 floats: RGBA).
+    get_part_magnitude : Callable[[P], float]
+        Function to extract a magnitude (e.g., area, volume) from a part for color blending.
+    get_part_bounds : Callable[[P], NDArray[np.float64]]
+        Function to extract the bounding box of a part.
+    are_parts_intersecting : Callable[[P, P], bool]
+        Function to determine if two parts intersect.
+    get_part_geometry : Callable[[P], G]
+        Function to extract the geometry from a part.
+    intersect_geometries : Callable[[list[G]], Iterable[G]]
+        Function to compute the intersection of a list of geometries.
+    make_part_from_geometry : Callable[[G, Color], P]
+        Function to create a part from a geometry and a color.
+    make_assembly_from_parts : Callable[[Sequence[P]], A]
+        Function to create an assembly from a sequence of parts.
+
+    Returns
+    -------
+    A
+        The assembly object containing all intersected parts with blended colors.
+
+    Examples
+    --------
+    >>> from scadpy import intersect_parts
+
+    >>> # example: two parts intersect, third does not
+    >>> parts = [
+    ...     {
+    ...         'bounds': [0, 0, 2, 2],
+    ...         'color': [1, 0, 0, 1],
+    ...         'magnitude': 1,
+    ...     },
+    ...     {
+    ...         'bounds': [1, 1, 3, 3],
+    ...         'color': [0, 1, 0, 1],
+    ...         'magnitude': 2,
+    ...     },
+    ...     {
+    ...         'bounds': [5, 5, 6, 6],
+    ...         'color': [0, 0, 1, 1],
+    ...         'magnitude': 1,
+    ...     },
+    ... ]
+    ...
+    >>> def are_intersecting(p1, p2):
+    ...     b1, b2 = p1['bounds'], p2['bounds']
+    ...     return not (b1[2] <= b2[0] or b2[2] <= b1[0] or
+    ...                 b1[3] <= b2[1] or b2[3] <= b1[1])
+    ...
+    >>> def intersect_geometries(geometries):
+    ...     if len(geometries) == 1:
+    ...         return [geometries[0]]
+    ...     minx = max(g[0] for g in geometries)
+    ...     miny = max(g[1] for g in geometries)
+    ...     maxx = min(g[2] for g in geometries)
+    ...     maxy = min(g[3] for g in geometries)
+    ...     if minx < maxx and miny < maxy:
+    ...         return [[minx, miny, maxx, maxy]]
+    ...     return []
+    ...
+    >>> result = intersect_parts(
+    ...     parts,
+    ...     get_part_color=lambda p: p['color'],
+    ...     get_part_magnitude=lambda p: p['magnitude'],
+    ...     get_part_bounds=lambda p: p['bounds'],
+    ...     are_parts_intersecting=are_intersecting,
+    ...     get_part_geometry=lambda p: p['bounds'],
+    ...     intersect_geometries=intersect_geometries,
+    ...     make_part_from_geometry=lambda geometry, color: {
+    ...         'bounds': geometry,
+    ...         'color': [round(float(v), 2) for v in color]
+    ...     },
+    ...     make_assembly_from_parts=lambda parts: parts
+    ... )
+    ...
+    >>> result == [
+    ...     {'bounds': [1, 1, 2, 2], 'color': [0.33, 0.67, 0.0, 1.0]},
+    ...     {'bounds': [5, 5, 6, 6], 'color': [0.0, 0.0, 1.0, 1.0]}
+    ... ]
+    True
+    """
+    from scadpy.core.component import (
+        blend_component_colors,
+        get_intersecting_component_index_groups,
+    )
+
+    intersecting_part_index_groups: list[list[int]] = (
+        get_intersecting_component_index_groups(
+            parts,
+            get_component_bounds=get_part_bounds,
+            are_components_intersecting=are_parts_intersecting,
+        )
+    )
+    intersecting_part_groups: list[list[P]] = [
+        [parts[i] for i in group] for group in intersecting_part_index_groups
+    ]
+
+    intersected_parts: list[P] = []
+    for parts in intersecting_part_groups:
+        blended_color = blend_component_colors(
+            components=parts,
+            get_component_color=get_part_color,
+            get_component_magnitude=get_part_magnitude,
+        )
+        geometries = [get_part_geometry(p) for p in parts]
+        intersected_geometries = intersect_geometries(geometries)
+        intersected_parts += [
+            make_part_from_geometry(u, blended_color) for u in intersected_geometries
+        ]
+
+    return make_assembly_from_parts(intersected_parts)

scadpy/core/part/combinations/subtract_parts.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable, Sequence
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from scadpy.color import Color
+
+
+# @typechecked
+def subtract_parts[A, P, G](
+    to_be_subtracted: P,
+    to_subtract: P,
+    get_part_color: Callable[[P], Color],
+    get_part_geometry: Callable[[P], G],
+    subtract_geometries: Callable[[G, G], Iterable[G]],
+    make_part_from_geometry: Callable[[G, Color], P],
+    make_assembly_from_parts: Callable[[Sequence[P]], A],
+) -> A:
+    """
+    Subtract the geometry of one part from another and return a new assembly.
+
+    This function is fully generic and uses dependency injection for all domain-specific
+    operations, making it suitable for a wide range of applications (2D, 3D, CAD, etc.).
+    The color of the resulting part(s) is inherited from the part being subtracted from.
+
+    Parameters
+    ----------
+    to_be_subtracted : P
+        The part whose geometry will be subtracted from.
+    to_subtract : P
+        The part whose geometry will be subtracted.
+    get_part_color : Callable[[P], Color]
+        Function to extract the color from a part (as a list or tuple of 4 floats: RGBA).
+    get_part_geometry : Callable[[P], G]
+        Function to extract the geometry from a part.
+    subtract_geometries : Callable[[G, G], Iterable[G]]
+        Function to compute the subtraction of two geometries.
+    make_part_from_geometry : Callable[[G, Color], P]
+        Function to create a part from a geometry and a color.
+    make_assembly_from_parts : Callable[[Sequence[P]], A]
+        Function to create an assembly from a sequence of parts.
+
+    Returns
+    -------
+    A
+        The assembly object containing all subtracted parts.
+
+    Examples
+    --------
+    >>> from scadpy import subtract_parts
+
+    >>> part1 = {'bounds': [0, 0, 3, 3], 'color': [1, 0, 0, 1]}
+    >>> part2 = {'bounds': [1, 1, 2, 2], 'color': [0, 1, 0, 1]}
+    ...
+    >>> def subtract_geoms(g1, g2):
+    ...     if (g2[0] > g1[0] and g2[2] < g1[2]
+    ...             and g2[1] > g1[1] and g2[3] < g1[3]):
+    ...         return [
+    ...             [g1[0], g1[1], g2[0], g1[3]],  # left
+    ...             [g2[2], g1[1], g1[2], g1[3]],  # right
+    ...             [g2[0], g1[1], g2[2], g2[1]],  # bottom
+    ...             [g2[0], g2[3], g2[2], g1[3]],  # top
+    ...         ]
+    ...     return [g1]
+    ...
+    >>> result = subtract_parts(
+    ...     part1, part2,
+    ...     get_part_color=lambda p: p['color'],
+    ...     get_part_geometry=lambda p: p['bounds'],
+    ...     subtract_geometries=subtract_geoms,
+    ...     make_part_from_geometry=lambda geometry, color: {
+    ...         'bounds': geometry,
+    ...         'color': [float(v) for v in color]
+    ...     },
+    ...     make_assembly_from_parts=lambda parts: parts
+    ... )
+    ...
+    >>> result == [
+    ...     {'bounds': [0, 0, 1, 3], 'color': [1.0, 0.0, 0.0, 1.0]},
+    ...     {'bounds': [2, 0, 3, 3], 'color': [1.0, 0.0, 0.0, 1.0]},
+    ...     {'bounds': [1, 0, 2, 1], 'color': [1.0, 0.0, 0.0, 1.0]},
+    ...     {'bounds': [1, 2, 2, 3], 'color': [1.0, 0.0, 0.0, 1.0]}
+    ... ]
+    True
+    """
+    subtracted_geometries = subtract_geometries(
+        get_part_geometry(to_be_subtracted), get_part_geometry(to_subtract)
+    )
+    subtracted_parts = [
+        make_part_from_geometry(s, get_part_color(to_be_subtracted))
+        for s in subtracted_geometries
+    ]
+    return make_assembly_from_parts(subtracted_parts)