frameplot 0.1.0__py3-none-any.whl

frameplot/__init__.py

@@ -0,0 +1,7 @@
+"""Public API for building pipeline diagrams with frameplot."""
+
+from frameplot.api import Pipeline
+from frameplot.model import DetailPanel, Edge, Group, Node
+from frameplot.theme import Theme
+
+__all__ = ["DetailPanel", "Edge", "Group", "Node", "Pipeline", "Theme"]

frameplot/api.py

@@ -0,0 +1,61 @@
+"""High-level rendering API for frameplot diagrams."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from frameplot.layout import build_layout
+from frameplot.model import DetailPanel, Edge, Group, Node
+from frameplot.render import render_svg, save_png, svg_to_png_bytes
+from frameplot.theme import Theme
+
+__all__ = ["Pipeline"]
+
+
+@dataclass(slots=True)
+class Pipeline:
+    """Describe and render a pipeline diagram.
+
+    The constructor accepts any iterable of nodes, edges, and groups, then
+    normalizes them to tuples for deterministic rendering. Passing `theme=None`
+    uses the default :class:`Theme`.
+    """
+
+    nodes: tuple[Node, ...]
+    edges: tuple[Edge, ...]
+    groups: tuple[Group, ...] = ()
+    detail_panel: DetailPanel | None = None
+    theme: Theme | None = field(default_factory=Theme)
+
+    def __post_init__(self) -> None:
+        self.nodes = tuple(self.nodes)
+        self.edges = tuple(self.edges)
+        self.groups = tuple(self.groups)
+        if self.theme is None:
+            self.theme = Theme()
+
+    def to_svg(self) -> str:
+        """Render the pipeline as an SVG document string."""
+
+        layout = build_layout(self)
+        return render_svg(layout, self.theme)
+
+    def save_svg(self, path: str | Path) -> None:
+        """Write the rendered SVG document to `path` using UTF-8 encoding."""
+
+        Path(path).write_text(self.to_svg(), encoding="utf-8")
+
+    def to_png_bytes(self) -> bytes:
+        """Render the pipeline to PNG bytes with CairoSVG.
+
+        Raises:
+            RuntimeError: If CairoSVG is not installed in the active environment.
+        """
+
+        return svg_to_png_bytes(self.to_svg())
+
+    def save_png(self, path: str | Path) -> None:
+        """Render the pipeline to PNG and write it to `path`."""
+
+        save_png(self.to_svg(), path)

frameplot/layout/__init__.py

@@ -0,0 +1,268 @@
+"""Internal layout pipeline used by the public frameplot API."""
+
+from __future__ import annotations
+
+from frameplot.layout.order import order_nodes
+from frameplot.layout.place import place_nodes
+from frameplot.layout.rank import assign_ranks
+from frameplot.layout.route import compute_group_overlays, route_edges
+from frameplot.layout.scc import strongly_connected_components
+from frameplot.layout.text import measure_text
+from frameplot.layout.types import (
+    Bounds,
+    DetailPanelLayout,
+    GraphLayout,
+    GroupOverlay,
+    GuideLine,
+    LayoutNode,
+    LayoutResult,
+    Point,
+    RoutedEdge,
+)
+from frameplot.layout.validate import validate_pipeline
+
+__all__ = ["build_layout"]
+
+
+def build_layout(pipeline: "Pipeline") -> LayoutResult:
+    """Compute positions, routes, and overlays for a pipeline."""
+
+    validated = validate_pipeline(pipeline)
+    theme = validated.theme
+    main_graph = _layout_graph(validated)
+
+    detail_panel = None
+    width = main_graph.width
+    height = main_graph.height
+
+    if validated.detail_panel is not None:
+        detail_panel = _build_detail_panel_layout(validated.detail_panel, main_graph, theme)
+        width = max(width, detail_panel.bounds.right + theme.outer_margin)
+        height = max(height, detail_panel.bounds.bottom + theme.outer_margin)
+        for guide_line in detail_panel.guide_lines:
+            width = max(width, guide_line.bounds.right + theme.outer_margin)
+            height = max(height, guide_line.bounds.bottom + theme.outer_margin)
+
+    return LayoutResult(
+        main=main_graph,
+        detail_panel=detail_panel,
+        width=round(width, 2),
+        height=round(height, 2),
+    )
+
+
+def _layout_graph(validated: "ValidatedPipeline | ValidatedDetailPanel") -> GraphLayout:
+    measurements = measure_text(validated)
+    scc_result = strongly_connected_components(validated)
+    ranks = assign_ranks(validated, scc_result)
+    order = order_nodes(validated, ranks)
+    placed_nodes = place_nodes(validated, measurements, ranks, order)
+    routed_edges = route_edges(validated, placed_nodes)
+    overlays = compute_group_overlays(validated, placed_nodes, routed_edges)
+    return _normalize_graph_layout(placed_nodes, routed_edges, overlays, validated.theme)
+
+
+def _normalize_graph_layout(
+    placed_nodes: dict[str, LayoutNode],
+    routed_edges: tuple[RoutedEdge, ...],
+    overlays: tuple[GroupOverlay, ...],
+    theme: "Theme",
+) -> GraphLayout:
+    content_bounds = _collect_graph_bounds(placed_nodes, routed_edges, overlays)
+
+    shift_x = max(0.0, theme.outer_margin - content_bounds.x)
+    shift_y = max(0.0, theme.outer_margin - content_bounds.y)
+    if shift_x or shift_y:
+        placed_nodes = {node_id: _shift_node(node, shift_x, shift_y) for node_id, node in placed_nodes.items()}
+        routed_edges = tuple(_shift_edge(route, shift_x, shift_y) for route in routed_edges)
+        overlays = tuple(_shift_overlay(overlay, shift_x, shift_y) for overlay in overlays)
+        content_bounds = _collect_graph_bounds(placed_nodes, routed_edges, overlays)
+
+    return GraphLayout(
+        nodes=placed_nodes,
+        edges=routed_edges,
+        groups=overlays,
+        content_bounds=content_bounds,
+        width=round(content_bounds.right + theme.outer_margin, 2),
+        height=round(content_bounds.bottom + theme.outer_margin, 2),
+    )
+
+
+def _build_detail_panel_layout(
+    validated_panel: "ValidatedDetailPanel",
+    main_graph: GraphLayout,
+    theme: "Theme",
+) -> DetailPanelLayout:
+    panel_graph = _layout_graph(validated_panel)
+    focus_node = main_graph.nodes[validated_panel.panel.focus_node_id]
+
+    content_width = panel_graph.content_bounds.width
+    content_height = panel_graph.content_bounds.height
+    label_width = len(validated_panel.panel.label) * theme.subtitle_font_size * 0.62
+
+    panel_width = max(content_width + theme.detail_panel_padding * 2, label_width + theme.detail_panel_padding * 2)
+    panel_height = (
+        content_height + theme.detail_panel_header_height + theme.detail_panel_padding * 2
+    )
+
+    desired_x = focus_node.center_x - panel_width / 2
+    max_x = max(theme.outer_margin, main_graph.width - theme.outer_margin - panel_width)
+    panel_x = round(max(theme.outer_margin, min(desired_x, max_x)), 2)
+    panel_y = round(main_graph.content_bounds.bottom + theme.detail_panel_gap, 2)
+
+    content_x = panel_x + theme.detail_panel_padding
+    content_y = panel_y + theme.detail_panel_header_height + theme.detail_panel_padding
+    shifted_graph = _shift_graph_layout(
+        panel_graph,
+        shift_x=content_x - panel_graph.content_bounds.x,
+        shift_y=content_y - panel_graph.content_bounds.y,
+    )
+
+    bounds = Bounds(
+        x=panel_x,
+        y=panel_y,
+        width=round(panel_width, 2),
+        height=round(panel_height, 2),
+    )
+
+    return DetailPanelLayout(
+        panel=validated_panel.panel,
+        graph=shifted_graph,
+        bounds=bounds,
+        stroke=validated_panel.panel.stroke or theme.detail_panel_stroke,
+        fill=validated_panel.panel.fill or theme.detail_panel_fill,
+        guide_lines=_build_detail_guides(focus_node, bounds, theme),
+    )
+
+
+def _build_detail_guides(
+    focus_node: LayoutNode,
+    panel_bounds: Bounds,
+    theme: "Theme",
+) -> tuple[GuideLine, ...]:
+    start_left = Point(round(focus_node.x + focus_node.width * 0.2, 2), round(focus_node.bounds.bottom, 2))
+    start_right = Point(
+        round(focus_node.x + focus_node.width * 0.8, 2),
+        round(focus_node.bounds.bottom, 2),
+    )
+    shoulder_inset = min(40.0, panel_bounds.width * 0.18)
+    end_left = Point(
+        round(panel_bounds.x + shoulder_inset, 2),
+        round(panel_bounds.y, 2),
+    )
+    end_right = Point(
+        round(panel_bounds.right - shoulder_inset, 2),
+        round(panel_bounds.y, 2),
+    )
+    flare_x = max(theme.route_track_gap * 1.5, focus_node.width * 0.18)
+    bend_y = round(
+        start_left.y + max(18.0, min(theme.detail_panel_gap * 0.45, (panel_bounds.y - start_left.y) * 0.45)),
+        2,
+    )
+    mid_left = Point(
+        round(min(start_left.x - flare_x, (start_left.x + end_left.x) / 2), 2),
+        bend_y,
+    )
+    mid_right = Point(
+        round(max(start_right.x + flare_x, (start_right.x + end_right.x) / 2), 2),
+        bend_y,
+    )
+    guides = (
+        GuideLine(
+            points=(start_left, mid_left, end_left),
+            bounds=_line_bounds((start_left, mid_left, end_left), theme.detail_panel_guide_width),
+            stroke=theme.detail_panel_guide_color,
+        ),
+        GuideLine(
+            points=(start_right, mid_right, end_right),
+            bounds=_line_bounds((start_right, mid_right, end_right), theme.detail_panel_guide_width),
+            stroke=theme.detail_panel_guide_color,
+        ),
+    )
+    return guides
+
+
+def _collect_graph_bounds(
+    nodes: dict[str, LayoutNode],
+    edges: tuple[RoutedEdge, ...],
+    overlays: tuple[GroupOverlay, ...],
+) -> Bounds:
+    bounds = [node.bounds for node in nodes.values()]
+    bounds.extend(route.bounds for route in edges)
+    bounds.extend(overlay.bounds for overlay in overlays)
+    return Bounds(
+        x=min(bound.x for bound in bounds),
+        y=min(bound.y for bound in bounds),
+        width=max(bound.right for bound in bounds) - min(bound.x for bound in bounds),
+        height=max(bound.bottom for bound in bounds) - min(bound.y for bound in bounds),
+    )
+
+
+def _line_bounds(points: tuple[Point, ...], stroke_width: float) -> Bounds:
+    padding = max(1.0, stroke_width)
+    min_x = min(point.x for point in points) - padding
+    min_y = min(point.y for point in points) - padding
+    max_x = max(point.x for point in points) + padding
+    max_y = max(point.y for point in points) + padding
+    return Bounds(x=min_x, y=min_y, width=max_x - min_x, height=max_y - min_y)
+
+
+def _shift_graph_layout(graph: GraphLayout, shift_x: float, shift_y: float) -> GraphLayout:
+    shifted_nodes = {node_id: _shift_node(node, shift_x, shift_y) for node_id, node in graph.nodes.items()}
+    shifted_edges = tuple(_shift_edge(route, shift_x, shift_y) for route in graph.edges)
+    shifted_groups = tuple(_shift_overlay(overlay, shift_x, shift_y) for overlay in graph.groups)
+    shifted_bounds = _collect_graph_bounds(shifted_nodes, shifted_edges, shifted_groups)
+    return GraphLayout(
+        nodes=shifted_nodes,
+        edges=shifted_edges,
+        groups=shifted_groups,
+        content_bounds=shifted_bounds,
+        width=round(max(graph.width + shift_x, shifted_bounds.right), 2),
+        height=round(max(graph.height + shift_y, shifted_bounds.bottom), 2),
+    )
+
+
+def _shift_node(node: LayoutNode, shift_x: float, shift_y: float) -> LayoutNode:
+    return LayoutNode(
+        node=node.node,
+        rank=node.rank,
+        order=node.order,
+        component_id=node.component_id,
+        width=node.width,
+        height=node.height,
+        x=round(node.x + shift_x, 2),
+        y=round(node.y + shift_y, 2),
+        title_lines=node.title_lines,
+        subtitle_lines=node.subtitle_lines,
+        title_line_height=node.title_line_height,
+        subtitle_line_height=node.subtitle_line_height,
+        content_height=node.content_height,
+    )
+
+
+def _shift_edge(route: RoutedEdge, shift_x: float, shift_y: float) -> RoutedEdge:
+    return RoutedEdge(
+        edge=route.edge,
+        points=tuple(Point(point.x + shift_x, point.y + shift_y) for point in route.points),
+        bounds=Bounds(
+            x=route.bounds.x + shift_x,
+            y=route.bounds.y + shift_y,
+            width=route.bounds.width,
+            height=route.bounds.height,
+        ),
+        stroke=route.stroke,
+    )
+
+
+def _shift_overlay(overlay: GroupOverlay, shift_x: float, shift_y: float) -> GroupOverlay:
+    return GroupOverlay(
+        group=overlay.group,
+        bounds=Bounds(
+            x=overlay.bounds.x + shift_x,
+            y=overlay.bounds.y + shift_y,
+            width=overlay.bounds.width,
+            height=overlay.bounds.height,
+        ),
+        stroke=overlay.stroke,
+        fill=overlay.fill,
+    )

frameplot/layout/order.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+from collections import defaultdict, deque
+
+from frameplot.layout.types import ValidatedDetailPanel, ValidatedPipeline
+
+
+def order_nodes(
+    validated: ValidatedPipeline | ValidatedDetailPanel,
+    ranks: dict[str, int],
+) -> dict[str, int]:
+    nodes_by_rank: dict[int, list[str]] = defaultdict(list)
+    for node in validated.nodes:
+        nodes_by_rank[ranks[node.id]].append(node.id)
+
+    for rank_nodes in nodes_by_rank.values():
+        rank_nodes.sort(key=validated.node_index.__getitem__)
+
+    order = {
+        node_id: index
+        for rank_nodes in nodes_by_rank.values()
+        for index, node_id in enumerate(rank_nodes)
+    }
+
+    incoming, outgoing = _forward_neighbors(validated, ranks)
+    ordered_ranks = sorted(nodes_by_rank)
+
+    for _ in range(4):
+        for rank in ordered_ranks[1:]:
+            _resort_rank(nodes_by_rank[rank], incoming, order, validated)
+            _refresh_order(nodes_by_rank[rank], order)
+        for rank in reversed(ordered_ranks[:-1]):
+            _resort_rank(nodes_by_rank[rank], outgoing, order, validated)
+            _refresh_order(nodes_by_rank[rank], order)
+
+    if getattr(validated, "detail_panel", None) is not None:
+        _apply_detail_panel_bias(validated, nodes_by_rank, ranks, order)
+
+    return order
+
+
+def _forward_neighbors(
+    validated: ValidatedPipeline | ValidatedDetailPanel,
+    ranks: dict[str, int],
+) -> tuple[dict[str, list[str]], dict[str, list[str]]]:
+    incoming: dict[str, list[str]] = defaultdict(list)
+    outgoing: dict[str, list[str]] = defaultdict(list)
+
+    for edge in validated.edges:
+        if ranks[edge.source] < ranks[edge.target]:
+            incoming[edge.target].append(edge.source)
+            outgoing[edge.source].append(edge.target)
+
+    return incoming, outgoing
+
+
+def _resort_rank(
+    rank_nodes: list[str],
+    neighbors: dict[str, list[str]],
+    order: dict[str, int],
+    validated: ValidatedPipeline | ValidatedDetailPanel,
+) -> None:
+    rank_nodes.sort(
+        key=lambda node_id: (
+            _barycenter(neighbors.get(node_id, ()), order, validated.node_index[node_id]),
+            validated.node_index[node_id],
+            node_id,
+        )
+    )
+
+
+def _barycenter(neighbors: list[str] | tuple[str, ...], order: dict[str, int], fallback: int) -> float:
+    if not neighbors:
+        return float(fallback)
+    return sum(order[neighbor] for neighbor in neighbors) / len(neighbors)
+
+
+def _refresh_order(rank_nodes: list[str], order: dict[str, int]) -> None:
+    for index, node_id in enumerate(rank_nodes):
+        order[node_id] = index
+
+
+def _apply_detail_panel_bias(
+    validated: ValidatedPipeline,
+    nodes_by_rank: dict[int, list[str]],
+    ranks: dict[str, int],
+    order: dict[str, int],
+) -> None:
+    focus_node_id = validated.detail_panel.panel.focus_node_id
+    focus_path_nodes = _detail_focus_path_nodes(validated, ranks, focus_node_id)
+    if not focus_path_nodes:
+        return
+
+    component_nodes = _weak_component_nodes(validated, focus_node_id)
+    component_ranks = sorted({ranks[node_id] for node_id in component_nodes})
+    max_row = max(len(nodes_by_rank[rank]) for rank in component_ranks) - 1
+
+    for rank in component_ranks:
+        rank_nodes = nodes_by_rank[rank]
+        rank_focus_nodes = [node_id for node_id in rank_nodes if node_id in focus_path_nodes]
+        if not rank_focus_nodes:
+            _refresh_order(rank_nodes, order)
+            continue
+
+        rank_other_nodes = [node_id for node_id in rank_nodes if node_id not in focus_path_nodes]
+        start_row = max_row - len(rank_focus_nodes) + 1
+
+        for index, node_id in enumerate(rank_other_nodes):
+            order[node_id] = index
+        for index, node_id in enumerate(rank_focus_nodes):
+            order[node_id] = start_row + index
+
+
+def _detail_focus_path_nodes(
+    validated: ValidatedPipeline,
+    ranks: dict[str, int],
+    focus_node_id: str,
+) -> set[str]:
+    forward_outgoing: dict[str, list[str]] = defaultdict(list)
+    forward_incoming: dict[str, list[str]] = defaultdict(list)
+
+    for edge in validated.edges:
+        if edge.dashed or ranks[edge.source] >= ranks[edge.target]:
+            continue
+        forward_outgoing[edge.source].append(edge.target)
+        forward_incoming[edge.target].append(edge.source)
+
+    ancestors = _reachable(focus_node_id, forward_incoming)
+    descendants = _reachable(focus_node_id, forward_outgoing)
+    focus_path = ancestors | descendants | {focus_node_id}
+
+    if focus_path:
+        return focus_path
+    return {focus_node_id}
+
+
+def _reachable(start: str, adjacency: dict[str, list[str]]) -> set[str]:
+    seen: set[str] = set()
+    queue = deque([start])
+
+    while queue:
+        node_id = queue.popleft()
+        for neighbor in adjacency.get(node_id, ()):
+            if neighbor in seen:
+                continue
+            seen.add(neighbor)
+            queue.append(neighbor)
+
+    return seen
+
+
+def _weak_component_nodes(validated: ValidatedPipeline, start_node_id: str) -> set[str]:
+    adjacency: dict[str, set[str]] = {node.id: set() for node in validated.nodes}
+    for edge in validated.edges:
+        adjacency[edge.source].add(edge.target)
+        adjacency[edge.target].add(edge.source)
+
+    seen = {start_node_id}
+    queue = deque([start_node_id])
+
+    while queue:
+        node_id = queue.popleft()
+        for neighbor in sorted(adjacency[node_id], key=validated.node_index.__getitem__):
+            if neighbor in seen:
+                continue
+            seen.add(neighbor)
+            queue.append(neighbor)
+
+    return seen

frameplot/layout/place.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+from collections import defaultdict, deque
+
+from frameplot.layout.types import LayoutNode, MeasuredText
+
+
+def place_nodes(
+    validated: "ValidatedPipeline | ValidatedDetailPanel",
+    measurements: dict[str, MeasuredText],
+    ranks: dict[str, int],
+    order: dict[str, int],
+) -> dict[str, LayoutNode]:
+    components = _weak_components(validated)
+    placed: dict[str, LayoutNode] = {}
+    current_top = validated.theme.outer_margin
+
+    for component_id, component_nodes in enumerate(components):
+        local_ranks = {node_id: ranks[node_id] for node_id in component_nodes}
+        local_rows = {node_id: order[node_id] for node_id in component_nodes}
+        min_rank = min(local_ranks.values())
+
+        nodes_by_rank: dict[int, list[str]] = defaultdict(list)
+        for node_id in component_nodes:
+            nodes_by_rank[local_ranks[node_id] - min_rank].append(node_id)
+
+        for rank_nodes in nodes_by_rank.values():
+            rank_nodes.sort(key=lambda node_id: (local_rows[node_id], validated.node_index[node_id]))
+
+        component_rows = sorted({local_rows[node_id] for node_id in component_nodes})
+        ranks_in_component = sorted(nodes_by_rank)
+
+        row_heights = {
+            row: max(measurements[node_id].height for node_id in component_nodes if local_rows[node_id] == row)
+            for row in component_rows
+        }
+        row_gap_after = _row_gap_after(
+            validated,
+            component_nodes,
+            local_rows,
+        )
+        column_widths = {
+            rank: max(measurements[node_id].width for node_id in nodes)
+            for rank, nodes in nodes_by_rank.items()
+        }
+        rank_gap_after = _rank_gap_after(
+            validated,
+            component_nodes,
+            local_ranks,
+            min_rank=min_rank,
+        )
+
+        row_tops: dict[int, float] = {}
+        cursor_y = current_top
+        for index, row in enumerate(component_rows):
+            row_tops[row] = cursor_y
+            cursor_y += row_heights[row]
+            if index < len(component_rows) - 1:
+                cursor_y += row_gap_after[row]
+        component_height = cursor_y - current_top
+
+        x_positions: dict[int, float] = {}
+        cursor_x = validated.theme.outer_margin
+        for rank in ranks_in_component:
+            x_positions[rank] = cursor_x
+            cursor_x += column_widths[rank]
+            if rank != ranks_in_component[-1]:
+                cursor_x += rank_gap_after[rank]
+
+        for rank in ranks_in_component:
+            for node_id in nodes_by_rank[rank]:
+                node = validated.node_lookup[node_id]
+                measured = measurements[node_id]
+                row = local_rows[node_id]
+                placed[node_id] = LayoutNode(
+                    node=node,
+                    rank=local_ranks[node_id],
+                    order=row,
+                    component_id=component_id,
+                    width=round(column_widths[rank], 2),
+                    height=round(row_heights[row], 2),
+                    x=round(x_positions[rank], 2),
+                    y=round(row_tops[row], 2),
+                    title_lines=measured.title_lines,
+                    subtitle_lines=measured.subtitle_lines,
+                    title_line_height=measured.title_line_height,
+                    subtitle_line_height=measured.subtitle_line_height,
+                    content_height=measured.content_height,
+                )
+
+        current_top += component_height + validated.theme.component_gap
+
+    return placed
+
+
+def _weak_components(validated: "ValidatedPipeline | ValidatedDetailPanel") -> list[tuple[str, ...]]:
+    adjacency: dict[str, set[str]] = {node.id: set() for node in validated.nodes}
+    for edge in validated.edges:
+        adjacency[edge.source].add(edge.target)
+        adjacency[edge.target].add(edge.source)
+
+    components: list[tuple[str, ...]] = []
+    seen: set[str] = set()
+
+    for node in validated.nodes:
+        if node.id in seen:
+            continue
+        queue = deque([node.id])
+        seen.add(node.id)
+        members: list[str] = []
+        while queue:
+            node_id = queue.popleft()
+            members.append(node_id)
+            for neighbor in sorted(adjacency[node_id], key=validated.node_index.__getitem__):
+                if neighbor in seen:
+                    continue
+                seen.add(neighbor)
+                queue.append(neighbor)
+        members.sort(key=validated.node_index.__getitem__)
+        components.append(tuple(members))
+
+    return components
+
+
+def _row_gap_after(
+    validated: "ValidatedPipeline | ValidatedDetailPanel",
+    component_nodes: tuple[str, ...],
+    rows: dict[str, int],
+) -> dict[int, float]:
+    row_ids = sorted({rows[node_id] for node_id in component_nodes})
+    crossing_counts = {row: 0 for row in row_ids[:-1]}
+    component_set = set(component_nodes)
+
+    for edge in validated.edges:
+        if edge.source not in component_set or edge.target not in component_set:
+            continue
+        source_row = rows[edge.source]
+        target_row = rows[edge.target]
+        if source_row == target_row:
+            continue
+        for row in range(min(source_row, target_row), max(source_row, target_row)):
+            crossing_counts[row] = crossing_counts.get(row, 0) + 1
+
+    gap_after: dict[int, float] = {}
+    for row in row_ids[:-1]:
+        lanes = crossing_counts.get(row, 0)
+        gap_after[row] = round(
+            _base_row_gap(validated.theme)
+            + max(0, lanes - 1) * validated.theme.route_track_gap,
+            2,
+        )
+    return gap_after
+
+
+def _rank_gap_after(
+    validated: "ValidatedPipeline | ValidatedDetailPanel",
+    component_nodes: tuple[str, ...],
+    ranks: dict[str, int],
+    *,
+    min_rank: int,
+) -> dict[int, float]:
+    component_set = set(component_nodes)
+    normalized_ranks = {node_id: rank - min_rank for node_id, rank in ranks.items()}
+    rank_ids = sorted({normalized_ranks[node_id] for node_id in component_nodes})
+    crossing_counts = {rank: 0 for rank in rank_ids[:-1]}
+
+    for edge in validated.edges:
+        if edge.source not in component_set or edge.target not in component_set:
+            continue
+        source_rank = normalized_ranks[edge.source]
+        target_rank = normalized_ranks[edge.target]
+        if source_rank == target_rank:
+            continue
+        for rank in range(min(source_rank, target_rank), max(source_rank, target_rank)):
+            crossing_counts[rank] = crossing_counts.get(rank, 0) + 1
+
+    gap_after: dict[int, float] = {}
+    for rank in rank_ids[:-1]:
+        lanes = crossing_counts.get(rank, 0)
+        gap_after[rank] = round(
+            _base_rank_gap(validated.theme)
+            + max(0, lanes - 1) * validated.theme.route_track_gap,
+            2,
+        )
+    return gap_after
+
+
+def _base_row_gap(theme: "Theme") -> float:
+    return max(theme.route_track_gap * 1.5, theme.node_gap * 0.75)
+
+
+def _base_rank_gap(theme: "Theme") -> float:
+    return max(theme.route_track_gap * 2.5, theme.rank_gap * 0.6)