Auto Align: grid layout with rigid assembly block, no overlaps, centered pieces

- Auto Align Split Parts now computes explicit positions and encodes them
into the spacing table: each run of split siblings is placed as ONE
rigid block at its exact world offsets, and every other shape flows
into the split's grid arrangement, pushed sideways until it clears
everything already placed (default spacings as the margins). New grid
rows start below the true lowest edge of all placed parts, so no shape
can ever land inside the assembly - fixing the overlaps that appeared
whether the pieces came before or after the other shapes.
- The pair-gap table is solved by inverting the layout's chaining math
(rounding compensated pair-to-pair), so the rendered layout reproduces
the computed positions exactly.
- Split pieces now center their nominal cell on the shared motion's
common center (grid-snapped) instead of anchoring at the frame corner:
material sits in the middle of the print path, removing the one-sided
travel, while seams keep their exact one-fil pitch.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

README.md

@@ -84,6 +84,7 @@ Whenever shapes are sliced (automatically, during G-code generation or a split),
 
 - Shapes are aligned by centering each shape's XY bounding box on a common center before the union.
 - Alignment is centered placement (in exact millimetres), not bottom-left anchoring.
+- Grid-split pieces center their nominal cell on the same common center (snapped to the filament grid so seams keep their exact one-fil pitch): each piece's material sits in the middle of the shared path instead of off in a corner, minimizing one-sided travel.
 
 ### Multi-Material Assemblies (shared nozzle numbers)
 
@@ -126,7 +127,7 @@ The **Multi-Nozzle Split** accordion on the **Shapes & G-Code** tab can split on
 - **Combined reference outline for motion** (always on): every shape's *motion* is taken from the combined reference layer union while each shape's *valve/dispensing* comes from its own layer polygons — so parallel print heads share one synchronized nozzle path and each deposits only its own geometry. The reference union is rebuilt automatically whenever shapes are sliced or G-code is generated. Contour tracing stays synchronized too: every shape traces every traced shape's contour, opening its valve only on its own outline.
 - Generated files contain only machine commands (no metadata comments). The toolpath's world anchor — the position, in the shape's own frame, that the relative moves start from — is kept on the shape's session record and used to place parallel parts so split pieces reassemble.
 - **Raster Pattern**: `X-direction raster` sweeps every layer back-and-forth in X. `Y-direction raster` rasters every layer in Y. `90° Woodpile raster` alternates the raster axis by layer, switching between X-direction and Y-direction sweeps. `45° Woodpile raster` rotates the sweep 45 degrees per layer, cycling 0, 45, 90, 135 degrees. `Rectangular Spiral raster` walks rectangular loops from the outside toward the center, then reverses from center to edge on the next layer; the loops live on one family anchored to the shape frame, so every layer (and every split sibling) walks the same rectangles and the walls stack — outer loops that cannot touch a layer's material are skipped instead of traveled. `Circle Spiral raster` prints concentric circles stepping inward by one line width per revolution — each revolution stays at a constant radius, so the walls are smooth true circles — then reverses outward on the next layer. The outermost revolution is a perimeter wall hugging the layer's material edge (half a bead inside its farthest boundary point), so the printed silhouette follows the shape smoothly; a matching inner wall hugs a central hole when there is one. The fill rings between the walls come from one global radii grid anchored at the shape frame's center, so interior rings stack exactly across layers, and rings that cannot touch a layer's material (or would overlap a wall bead) are skipped instead of traveled. Walls always dispense even under partial infill, like contour tracing; elsewhere the valve opens only where the path is inside material. Under shared reference motion every shape's own wall radius joins the one shared ring set (all heads travel all walls, each dispenses only its own), and rings that would graze a shape's boundary are suppressed for that shape — so each parallel shape keeps a smooth, complete outer circle regardless of its dimensions.
-- **Auto Align Split Parts**: in Nozzle Spacing, computes exact per-connection grid gaps from the split pieces' generated G-code (world toolpath anchors + toolpath bounds), sets the grid columns/rows from the split, and fills the Advanced Grid Spacing table. Works for every raster pattern, filament width, reference-motion setting, and overlapping-layer split. Requires the pieces' G-code to be generated first. **Generate G-Code runs it automatically** whenever the table contains split pieces, so the parallel view comes up already reassembled; the button remains for re-aligning after manual spacing edits.
+- **Auto Align Split Parts**: in Nozzle Spacing, computes exact per-connection grid gaps from the split pieces' generated G-code (world toolpath anchors + toolpath bounds), sets the grid columns/rows from the split, and fills the Advanced Grid Spacing table. Works for every raster pattern, filament width, reference-motion setting, and overlapping-layer split. Requires the pieces' G-code to be generated first. **Generate G-Code runs it automatically** whenever the table contains split pieces, so the parallel view comes up already reassembled; the button remains for re-aligning after manual spacing edits. The layout keeps the split's grid arrangement: the reassembled pieces form one rigid block, and non-split shapes flow into the remaining grid slots, always kept clear of everything already placed (with the default column/row spacing as the margins) — nothing can overlap.
 - **Contour Tracing**: enabled per row in Shape Settings. The app traces the layer polygon's boundary rings (holes traced separately), travels from the layer raster end to the nearest contour point, prints the contour, then returns to the raster endpoint before the next layer. For grid-split pieces only the parent shape's true outer surface is traced — the cut seams between sibling pieces are excluded (open arcs are printed end-to-end without closing the loop; fully interior pieces get no contour). Multi-material assembly parts (shapes sharing a nozzle) work the same way: boundary within half a bead of a sibling material counts as an internal interface and is not contoured — only the assembled shape's true outer surface is traced, and a part fully embedded in the assembly gets no contour at all.
 
 ### Print vs Travel Classification

app.py

@@ -2450,10 +2450,19 @@ def _auto_align_grid_spacing_rows(
 
     Every generated G-code file records its PathOrigin: the world position of
     the relative toolpath's start. Anchoring each piece back into its world
-    frame turns the required pair gaps into the actual world-frame gaps
-    between the parts' toolpath bounding boxes — which automatically accounts
-    for the raster pattern, filament width, travel buffers, reference-stack
-    motion, and overlapping-layer splits. No hardcoded offsets.
+    frame gives the exact relative offsets that reassemble the pieces —
+    accounting automatically for the raster pattern, filament width, travel
+    buffers, reference-stack motion, and interlocking splits.
+
+    Two stages: (1) compute a DESIRED position for every nozzle's toolpath
+    box — each run of split siblings placed as ONE rigid block at its world
+    offsets, every other shape flowed into the grid row-major and pushed
+    sideways until it clears EVERYTHING already placed (the default
+    spacings are the flow margins); (2) encode those positions into the
+    pair-gap table by inverting `_resolve_nozzle_grid_layout`'s chaining,
+    so the layout reproduces them exactly. Nothing can overlap, and the
+    grid arrangement (pieces in their split grid, other shapes in the
+    remaining slots) is preserved.
     """
     spacing_rows, column_count, row_count = _grid_spacing_rows(
         records,
@@ -2463,40 +2472,179 @@ def _auto_align_grid_spacing_rows(
         row_spacing,
     )
     parts, _messages = _parts_from_records(records)
-    world = _nozzle_world_bounds(_group_parts_by_nozzle(parts))
+    grouped = _group_parts_by_nozzle(parts)
+    world = _nozzle_world_bounds(grouped)
     records_by_nozzle = _records_by_nozzle(records)
     ordered_nozzles = _ordered_nozzle_numbers(records)
 
-    aligned_count = 0
-    missing_count = 0
-    for index, (first, second) in enumerate(zip(ordered_nozzles, ordered_nozzles[1:])):
-        if not _split_pair_was_created_together(records_by_nozzle, first, second):
-            continue
+    pairs = list(zip(ordered_nozzles, ordered_nozzles[1:]))
+    sibling_pairs = {
+        index
+        for index, (first, second) in enumerate(pairs)
+        if _split_pair_was_created_together(records_by_nozzle, first, second)
+    }
+    aligned_pairs = {
+        index
+        for index in sibling_pairs
+        if pairs[index][0] in world and pairs[index][1] in world
+    }
+    aligned_count = len(aligned_pairs)
+    missing_count = len(sibling_pairs) - aligned_count
+    if aligned_count == 0 or any(nozzle not in grouped for nozzle in ordered_nozzles):
+        if any(nozzle not in grouped for nozzle in ordered_nozzles) and sibling_pairs:
+            return spacing_rows, column_count, row_count, 0, len(sibling_pairs)
+        return spacing_rows, column_count, row_count, 0, missing_count
+
+    bounds = {nozzle: _nozzle_group_bounds(grouped, nozzle) for nozzle in ordered_nozzles}
+    size = {
+        nozzle: (
+            bounds[nozzle][1][0] - bounds[nozzle][0][0],
+            bounds[nozzle][1][1] - bounds[nozzle][0][1],
+        )
+        for nozzle in ordered_nozzles
+    }
 
-        second_column = (index + 1) % column_count
-        if second_column == 0:
-            # Row transition: `second` opens a new grid row. The layout places
-            # it relative to the previous row's first nozzle (x) and the
-            # previous row's lowest edge (y).
-            previous_row = ordered_nozzles[index + 1 - column_count : index + 1]
-            anchors = [second, *previous_row]
-        else:
-            row_first = ordered_nozzles[index + 1 - second_column]
-            anchors = [first, second, row_first]
-        if any(nozzle not in world for nozzle in anchors):
-            missing_count += 1
+    # Rigid clusters: maximal runs of consecutive nozzles linked by aligned
+    # sibling connections.
+    cluster_of: dict[int, tuple[int, ...]] = {}
+    run: list[int] = []
+    for index, nozzle in enumerate(ordered_nozzles):
+        if run and (index - 1) in aligned_pairs:
+            run.append(nozzle)
             continue
+        if len(run) > 1:
+            for member in run:
+                cluster_of[member] = tuple(run)
+        run = [nozzle]
+    if len(run) > 1:
+        for member in run:
+            cluster_of[member] = tuple(run)
+
+    # ---- Stage 1: desired positions (box min-corners). --------------------
+    eps = 1e-6
+    x_gap = _coerce_float(column_spacing, 5.0)
+    y_gap = _coerce_float(row_spacing, 5.0)
+    placed: list[tuple[float, float, float, float]] = []
+    targets: dict[int, tuple[float, float]] = {}
+
+    def _push_clear(x: float, y: float, width: float, height: float) -> float:
+        pushed = True
+        while pushed:
+            pushed = False
+            for bx0, by0, bx1, by1 in placed:
+                if (
+                    x < bx1 - eps
+                    and x + width > bx0 + eps
+                    and y < by1 - eps
+                    and y + height > by0 + eps
+                ):
+                    x = bx1 + x_gap
+                    pushed = True
+        return x
+
+    for row in range(row_count):
+        row_nozzles = ordered_nozzles[row * column_count:(row + 1) * column_count]
+        if not row_nozzles:
+            break
+        row_y: float | None = None
+        cursor_x = 0.0
+        for nozzle in row_nozzles:
+            width, height = size[nozzle]
+            if nozzle in targets:
+                # Cluster member already placed with its block.
+                cursor_x = max(cursor_x, targets[nozzle][0] + width + x_gap)
+                if row_y is None:
+                    row_y = targets[nozzle][1]
+                continue
+            if row_y is None:
+                row_y = (max(box[3] for box in placed) + y_gap) if placed else 0.0
+            members = cluster_of.get(nozzle)
+            if members:
+                # Place the whole assembly as one rigid block: every
+                # member's frame at its exact world offset.
+                base_x, base_y = world[nozzle][0]
+                rel = {
+                    member: (
+                        world[member][0][0] - base_x,
+                        world[member][0][1] - base_y,
+                    )
+                    for member in members
+                }
+                block_min_x = min(rel[member][0] for member in members)
+                block_min_y = min(rel[member][1] for member in members)
+                block_w = max(rel[m][0] + size[m][0] for m in members) - block_min_x
+                block_h = max(rel[m][1] + size[m][1] for m in members) - block_min_y
+                block_x = _push_clear(cursor_x, row_y, block_w, block_h)
+                for member in members:
+                    targets[member] = (
+                        block_x + rel[member][0] - block_min_x,
+                        row_y + rel[member][1] - block_min_y,
+                    )
+                    m_w, m_h = size[member]
+                    placed.append(
+                        (
+                            targets[member][0],
+                            targets[member][1],
+                            targets[member][0] + m_w,
+                            targets[member][1] + m_h,
+                        )
+                    )
+                cursor_x = block_x + block_w + x_gap
+            else:
+                target_x = _push_clear(cursor_x, row_y, width, height)
+                targets[nozzle] = (target_x, row_y)
+                placed.append((target_x, row_y, target_x + width, row_y + height))
+                cursor_x = target_x + width + x_gap
+
+    # The layout pins the first nozzle's box at the origin.
+    base_x, base_y = targets[ordered_nozzles[0]]
+    targets = {
+        nozzle: (position[0] - base_x, position[1] - base_y)
+        for nozzle, position in targets.items()
+    }
 
-        (second_min_x, second_min_y), _second_max = world[second]
-        if second_column == 0:
-            gap_x = second_min_x - world[previous_row[0]][0][0]
-            gap_y = second_min_y - max(world[nozzle][1][1] for nozzle in previous_row)
-        else:
-            gap_x = second_min_x - world[first][1][0]
-            gap_y = second_min_y - world[row_first][0][1]
-        spacing_rows[index][2] = round(gap_x, 4)
-        spacing_rows[index][3] = round(gap_y, 4)
-        aligned_count += 1
+    # ---- Stage 2: encode positions into the pair-gap table. ---------------
+    # Mirrors `_resolve_nozzle_grid_layout`'s individual-spacing chaining and
+    # solves each gap; state advances on the ROUNDED values so rounding
+    # errors are compensated in the following gaps instead of accumulating.
+    offsets: dict[int, tuple[float, float]] = {}
+    row_start_x = 0.0
+    row_min_y = 0.0
+    row_bottom = 0.0
+    for row in range(row_count):
+        row_start_index = row * column_count
+        row_nozzles = ordered_nozzles[row_start_index:row_start_index + column_count]
+        if not row_nozzles:
+            break
+        for col, nozzle in enumerate(row_nozzles):
+            (xmin, ymin, _), _ = bounds[nozzle]
+            target_x, target_y = targets[nozzle]
+            if col == 0:
+                if row == 0:
+                    actual_x, actual_y = 0.0, 0.0
+                else:
+                    pair_index = row_start_index - 1
+                    shift_x = round(target_x - row_start_x, 4)
+                    row_gap = round(target_y - row_bottom, 4)
+                    spacing_rows[pair_index][2] = shift_x
+                    spacing_rows[pair_index][3] = row_gap
+                    row_start_x += shift_x
+                    row_min_y = row_bottom + row_gap
+                    actual_x, actual_y = row_start_x, row_min_y
+            else:
+                pair_index = row_start_index + col - 1
+                prev = row_nozzles[col - 1]
+                prev_right = offsets[prev][0] + bounds[prev][1][0]
+                gap_x = round(target_x - prev_right, 4)
+                gap_y = round(target_y - row_min_y, 4)
+                spacing_rows[pair_index][2] = gap_x
+                spacing_rows[pair_index][3] = gap_y
+                actual_x = prev_right + gap_x
+                actual_y = row_min_y + gap_y
+            offsets[nozzle] = (actual_x - xmin, actual_y - ymin)
+        row_bottom = max(
+            offsets[nozzle][1] + bounds[nozzle][1][1] for nozzle in row_nozzles
+        )
     return spacing_rows, column_count, row_count, aligned_count, missing_count
 
 
@@ -2535,6 +2683,10 @@ def auto_align_split_parts(
     row_spacing: Any,
 ) -> tuple:
     records = records or []
+    # Grid layout: the chain uses the split's own grid shape, so pieces sit
+    # in their split arrangement and other shapes flow into the remaining
+    # grid slots. Positions are computed globally (assembly as one rigid
+    # block, everything else pushed clear), so nothing can overlap.
     grid_shape = _split_grid_shape(records)
     if grid_shape is not None:
         columns, rows = grid_shape
@@ -2568,7 +2720,8 @@ def auto_align_split_parts(
     status = (
         f"Auto aligned {aligned_count} split nozzle connection(s) from the generated "
         f"G-code in a {column_count} x {row_count} grid. The exact per-connection "
-        "gaps are in the Advanced Grid Spacing table."
+        "gaps are in the Advanced Grid Spacing table; other shapes flow into the "
+        "remaining grid slots, kept clear of the reassembled pieces."
     )
     if missing_count:
         status += (

tests/test_nozzle_spacing.py

@@ -733,6 +733,100 @@ def test_auto_align_reports_missing_gcode_for_split_siblings(tmp_path) -> None:
     assert rows == [["Nozzle 1: Shape 1", "Nozzle 2: Shape 2", 10.0, 0.0]]
 
 
+def test_auto_align_pushes_non_split_shapes_clear_of_the_assembly(tmp_path) -> None:
+    from shapely.geometry import MultiPolygon, box
+
+    from app import _group_parts_by_nozzle, _nozzle_group_bounds
+    from stl_slicer import LayerStack
+    from vector_gcode import generate_vector_gcode
+
+    # A 2x2 split under shared reference motion: auto align pulls the rows
+    # together with negative gaps, so row 2's frames end HIGHER than row 1's.
+    records = _split_piece_records(tmp_path, columns=2, rows=2, use_reference_motion=True)
+
+    # An unrelated shape on the next nozzle. Placed only relative to row 2's
+    # bottom edge it would land inside row 1's frames.
+    layer = MultiPolygon([box(0.0, 0.0, 6.0, 5.0)])
+    stack = LayerStack(
+        layers=[layer, layer],
+        z_values=[0.5, 1.5],
+        bounds=((0.0, 0.0, 0.0), (6.0, 5.0, 2.0)),
+        layer_height=1.0,
+        name="extra",
+    )
+    origin_sink: dict = {}
+    gcode_path = generate_vector_gcode(
+        stack,
+        shape_name="extra",
+        pressure=25,
+        valve=9,
+        port=1,
+        fil_width=1.0,
+        origin_sink=origin_sink,
+        output_dir=tmp_path / "extra",
+    )
+    records.append(
+        {
+            "idx": 5,
+            "name": "extra",
+            "nozzle": 5,
+            "color": "#123456",
+            "gcode_path": str(gcode_path),
+            "path_origin": origin_sink.get("path_origin"),
+        }
+    )
+
+    from app import auto_align_split_parts
+
+    def _check_layout(records, piece_nozzles, extra_nozzle):
+        outputs = auto_align_split_parts(records, 2, 2, 5.0, 5.0)
+        spacing_rows = outputs[5]["value"]
+        cc = outputs[0]["value"]
+        rc = outputs[1]["value"]
+        # Grid layout: the chain keeps the split's 2-column grid shape.
+        assert cc == 2
+
+        parts, _messages = _parts_from_records(records)
+        offsets, _spacings = _resolve_nozzle_grid_layout(
+            parts, cc, rc, 5.0, 5.0, use_individual_spacing=True, spacing_table=spacing_rows
+        )
+        grouped = _group_parts_by_nozzle(parts)
+        boxes = {}
+        for nozzle, (offset_x, offset_y) in offsets.items():
+            (xmin, ymin, _), (xmax, ymax, _) = _nozzle_group_bounds(grouped, nozzle)
+            boxes[nozzle] = (xmin + offset_x, ymin + offset_y, xmax + offset_x, ymax + offset_y)
+
+        extra = boxes[extra_nozzle]
+        for nozzle in piece_nozzles:
+            piece = boxes[nozzle]
+            overlap_w = min(extra[2], piece[2]) - max(extra[0], piece[0])
+            overlap_h = min(extra[3], piece[3]) - max(extra[1], piece[1])
+            assert overlap_w <= 1e-6 or overlap_h <= 1e-6, (
+                f"non-split shape overlaps piece on nozzle {nozzle}: {extra} vs {piece}"
+            )
+
+        # The split pieces still reassemble exactly: every piece's layout
+        # offset differs from its world anchor by one shared constant.
+        anchors = {part["nozzle"]: part["parsed"]["path_origin"] for part in parts}
+        constants = [
+            (offsets[n][0] - anchors[n][0], offsets[n][1] - anchors[n][1])
+            for n in piece_nozzles
+        ]
+        for constant in constants[1:]:
+            assert abs(constant[0] - constants[0][0]) < 5e-4
+            assert abs(constant[1] - constants[0][1]) < 5e-4
+
+    # Pieces first (nozzles 1-4), the unrelated shape after them.
+    _check_layout(records, (1, 2, 3, 4), 5)
+
+    # Pieces LAST (the unrelated shape sorts first): the assembly's own
+    # negative gaps used to climb back over the earlier shape's row.
+    for record in records[:4]:
+        record["nozzle"] = record["nozzle"] + 1
+    records[4]["nozzle"] = 1
+    _check_layout(records, (2, 3, 4, 5), 1)
+
+
 def test_auto_align_grid_spacing_skips_unsplit_records() -> None:
     records = [
         {"idx": 1, "name": "first", "nozzle": 1},

tests/test_vector_gcode.py

@@ -1683,6 +1683,36 @@ def test_split_contour_gcode_never_traces_the_cuts(tmp_path) -> None:
     assert vertical_prints == []
 
 
+def test_split_pieces_center_on_the_shared_motion() -> None:
+    from vector_toolpath import _centering_delta
+
+    layer = box(0.0, 0.0, 8.0, 6.0)
+    stack = _stack(layer, layer, name="center")
+    pieces = split_layer_stack_grid(stack, columns=2, rows=2, grid=1.0)
+    reference = build_reference_stack(pieces, grid=1.0)
+
+    ref_x, ref_y = reference.align_center
+    placements = []
+    for piece in pieces:
+        delta_x, delta_y = _centering_delta(piece, reference)
+        (x0, y0, _), (x1, y1, _) = piece.bounds
+        center = ((x0 + x1) / 2, (y0 + y1) / 2)
+        placements.append((center, (delta_x, delta_y)))
+        # The piece's nominal cell lands centered on the shared motion
+        # (within half a fil from the grid snap) — material sits mid-path,
+        # not at the frame corner.
+        assert abs(center[0] + delta_x - ref_x) <= 0.5 + 1e-9
+        assert abs(center[1] + delta_y - ref_y) <= 0.5 + 1e-9
+
+    # Deltas differ between pieces by EXACT cell multiples: the pieces'
+    # relative world offsets — and with them seams and nozzle spacing —
+    # are preserved exactly.
+    (first_center, first_delta) = placements[0]
+    for center, delta in placements[1:]:
+        assert abs((delta[0] - first_delta[0]) + (center[0] - first_center[0])) < 1e-9
+        assert abs((delta[1] - first_delta[1]) + (center[1] - first_center[1])) < 1e-9
+
+
 def test_split_overlapping_rows_comb_within_each_layer() -> None:
     layer = box(0.0, 0.0, 8.0, 6.0)
     stack = _stack(layer, layer, name="comb")

vector_toolpath.py

@@ -1769,11 +1769,13 @@ def _centering_delta(stack: LayerStack, reference: LayerStack) -> tuple[float, f
     one-fil-width line pitch.
 
     Split siblings (stacks sharing the reference's scan frame) are aligned by
-    their cell corner within that frame instead of their centre: with cells
-    sized in whole grid multiples the deltas — and with them the required
-    nozzle spacing — come out uniform across all pieces, whereas snapping the
-    centres would wobble by up to one fil where the last cell's width (and so
-    its centre phase) differs.
+    their nominal CELL onto the reference centre, with the delta snapped to
+    the fil grid: every piece's material sits in the MIDDLE of the shared
+    motion instead of at the frame corner (less one-sided travel), the grid
+    snap keeps every piece's world scan-grid phase intact, and — because
+    grid-sized cells are all equal — every piece gets the same snap residue,
+    so the pieces' relative world offsets (and with them the required
+    nozzle spacing and seam pitch) stay exact.
 
     Multi-material group members (stacks carrying a shared `align_frame`)
     are aligned by the group frame's centre instead of their own bbox
@@ -1786,14 +1788,19 @@ def _centering_delta(stack: LayerStack, reference: LayerStack) -> tuple[float, f
         and stack.scan_frame is not None
         and stack.scan_frame == reference.scan_frame
     ):
-        (stack_min_x, stack_min_y, _sz), _stack_max = (
+        (stack_min_x, stack_min_y, _sz), (stack_max_x, stack_max_y, _sz2) = (
             stack.bounds[0],
             stack.bounds[1],
         )
-        frame_min_x, frame_min_y = stack.scan_frame[0], stack.scan_frame[1]
+        if reference.align_center is not None:
+            reference_x, reference_y = reference.align_center
+        else:
+            reference_x, reference_y = _stack_center(reference)
+        cell_center_x = (stack_min_x + stack_max_x) / 2.0
+        cell_center_y = (stack_min_y + stack_max_y) / 2.0
         return (
-            _snap_to_grid(frame_min_x - stack_min_x, grid),
-            _snap_to_grid(frame_min_y - stack_min_y, grid),
+            _snap_to_grid(reference_x - cell_center_x, grid),
+            _snap_to_grid(reference_y - cell_center_y, grid),
         )
 
     if reference.align_center is not None: