feat(prepare): per-plate regrid, prime-tower placement, kept support intent

CHANGELOG.md

@@ -7,6 +7,8 @@ All notable changes to this project are documented here. The format is based on
 ## [Unreleased]
 
 ### Fixed
+- Preparing a multi-plate project from a printer with a different plate size now lays each plate's objects out on the U1's plate grid (translation only; rotation, scale and painting untouched), in both modes, so Snapmaker Orca no longer lists the objects on later plates as outside. It is only done when every object's position matches the plate the project records for it; otherwise positions are left as they were and the prepared copy says why. Prime towers are not moved: Studio reports a tower it can prove is outside the plate or on an object, and otherwise says it cannot tell.
+- "Use Studio's U1 starter settings" keeps the support settings (`enable_support`, support type, support filament, interface filament) when the model itself marks where it needs support (painted support enforcers, support-enforcer volumes, or support switched on for an object); explicitly disabled supports stay off, and blocker-only data does not turn supports on.
 - Bed fit now reports each object's size and the instances' placement as separate facts; several small, separated objects are no longer summed into one "too big" object (#91).
 - Object placement judges each placed copy of a repeated object on its own, so a copy that hangs off the plate is no longer hidden by one that does not (#93).
 

backend/snapstudio_core/convert.py

@@ -113,6 +113,8 @@ def _action_reasons(report: dict) -> tuple[dict[str, str], set[str], set[str], d
               [report["preset_deviations_declared"]]
               if report.get("preset_deviations_declared") else []]
     groups.append(report.get("project_materials_changes", []))
+    # the prime tower keys the layout correction moved: reported with their own reason
+    groups.append(report.get("placement_corrections", []))
     identity = report.get("identity", {})
     groups.append(identity.get("changed", []) if isinstance(identity, dict) else [])
     for group in groups:
@@ -246,6 +248,25 @@ def _settings_summary(before: dict, after: dict, raw_config: bytes, outcome,
         "recommendations_available": prepare_mode == "preserve",
         "recommended_changes": recommended_changes if prepare_mode == "preserve" else [],
     }
+    layout = outcome.report.get("layout")
+    if layout:
+        summary["layout"] = {k: layout.get(k) for k in (
+            "status", "plates", "formula_check", "tower", "tower_note", "stride_source", "stride_target",
+            "cols", "items_moved", "unresolved")}
+        summary["placement_changes"] = list(layout.get("disclosure") or [])
+        summary["warnings"] = summary["warnings"] + [
+            line for line in layout.get("disclosure") or []
+            if line.startswith("Plate positions were left")
+            or ("prime tower is outside" in line) or ("prime tower sits on an object" in line)]
+    intent = outcome.report.get("support_intent")
+    if intent:
+        from . import support_intent as _support_intent
+
+        summary["support_intent"] = {
+            "decision": intent["decision"], "kept": bool(intent["explicit"]),
+            "evidence": intent["evidence"], "blocker_evidence": intent["blocker_evidence"],
+            "disable_evidence": intent["disable_evidence"], "keys": intent["keys"],
+            "statement": _support_intent.statement(intent)}
     # Preservation invariant: every changed source setting needs a specific
     # repair-pipeline reason, a deliberate foreign-value clear, or the
     # profile-owned machine/compat allowlist.  The independent diff is the
@@ -410,7 +431,7 @@ def convert_to_u1(path: str, out_dir: str | None = None, prepare_mode: str = "pr
     internal_mode = "preserve" if prepare_mode == "preserve" else "u1"
     outcome = do_repair(tm, mode=internal_mode, remap=None, dry_run=dry_run, opt_profile=None,
                         confirmed_presets=confirmed_presets, filament_catalog=filament_catalog,
-                        confirmed_colours=confirmed_colours)
+                        confirmed_colours=confirmed_colours, source_path=str(src))
     after = load_project_settings(tm.read_part(SETTINGS))
     if confirmed_presets:
         # Judged on what this mode will actually write, not on what the source declared:
@@ -428,7 +449,7 @@ def convert_to_u1(path: str, out_dir: str | None = None, prepare_mode: str = "pr
         # results cannot diverge from a real recommended conversion or write.
         do_repair(recommended_tm, mode="u1", remap=None, dry_run=True, opt_profile=None,
                   confirmed_presets=confirmed_presets, filament_catalog=filament_catalog,
-                  confirmed_colours=confirmed_colours)
+                  confirmed_colours=confirmed_colours, source_path=str(src))
         recommended_after = load_project_settings(recommended_tm.read_part(SETTINGS))
     summary = _settings_summary(before, after, raw_config, outcome, prepare_mode,
                                 recommended_after=recommended_after)

backend/snapstudio_core/fidelity.py

@@ -192,7 +192,9 @@ def _model_part_row(part: str, before: bytes, after: bytes,
     if placement_applied:
         return _row(_human(part), CHANGED, part=part,
                     detail="the same geometry, moved to different coordinates",
-                    reason="a placement fix moved the objects onto the U1 plate")
+                    reason=("the objects were repositioned for the U1 (a placement fix, or the plate "
+                            "layout corrected for the U1's plate grid): translation only, the "
+                            "geometry itself is unchanged"))
     if moved_after and not moved_before:
         return _row(_human(part), PRESERVED_SEMANTIC, part=part,
                     detail="the same geometry, split into one mesh per part",
@@ -747,12 +749,28 @@ def _placement_report(prepared: str) -> dict | None:
     from . import placement
 
     try:
+        if _plate_count(prepared) > 1:
+            # This report judges every object against ONE plate. A multi-plate project sits on a grid of
+            # plates (the second plate starts a plate-stride to the right), so it would call every object
+            # on plate 2 onward "outside" by hundreds of millimetres. The layout check Studio makes while
+            # preparing (per plate, against the U1's own cell) is the statement about those projects.
+            return None
         report = placement.assess(prepared)
     except Exception:  # noqa: BLE001 — a report, never a crash
         return None
     return report if report.get("available") else None
 
 
+def _plate_count(path: str) -> int:
+    """How many plates a prepared project records (0 when it cannot be read)."""
+    try:
+        from . import plate_placement
+
+        return len(plate_placement._plates_from_model_settings(ThreeMF.open(path)))
+    except Exception:  # noqa: BLE001
+        return 0
+
+
 def _settings_rows(a: ThreeMF, b: ThreeMF) -> list[dict]:
     return _settings_row(_json_or_none(a, PROJECT_SETTINGS), _json_or_none(b, PROJECT_SETTINGS))
 

backend/snapstudio_core/plate_placement.py

@@ -734,6 +734,45 @@ def fix_item(match: re.Match) -> str:
     return out.encode("utf-8"), moved
 
 
+_COMMENT_RE = re.compile(r"<!--.*?-->", re.S)
+
+
+def rewrite_items_by_index(raw: bytes, offsets: dict) -> tuple[bytes, int]:
+    """Translate build items by ordinal: ``offsets`` maps an item's index among the root model's ``<item>``
+    elements to ``(dx, dy)`` in the root model's own unit.
+
+    Like ``_rewrite_items`` it is byte-surgical (only the translation tokens of the matched tags change, every
+    other token is copied verbatim), but it addresses an INSTANCE, not an object id, so two uses of one object
+    on different plates move independently. Commented-out tags are not items and are skipped."""
+    text = raw.decode("utf-8", "strict")
+    spans = [(m.start(), m.end()) for m in _COMMENT_RE.finditer(text)]
+    out, last, ordinal, moved = [], 0, 0, 0
+    for match in _ITEM_TAG_RE.finditer(text):
+        if any(start <= match.start() < end for start, end in spans):
+            continue
+        index, ordinal = ordinal, ordinal + 1
+        offset = offsets.get(index)
+        if offset is None:
+            continue
+        tag = match.group(0)
+        dx, dy = offset
+        attr = _TRANSFORM_ATTR_RE.search(tag)
+        if attr is None:
+            insert = f' transform="{_identity_shifted(dx, dy)}"'
+            new = tag[:-2] + insert + "/>" if tag.endswith("/>") else tag[:-1] + insert + ">"
+        else:
+            shifted = _shift_transform(attr.group(2), dx, dy)
+            if shifted is None:
+                continue
+            new = tag[:attr.start()] + attr.group(1) + shifted + attr.group(3) + tag[attr.end():]
+        out.append(text[last:match.start()])
+        out.append(new)
+        last = match.end()
+        moved += 1
+    out.append(text[last:])
+    return "".join(out).encode("utf-8"), moved
+
+
 def _uniform_offset(dx: float, dy: float):
     return lambda _oid: (dx, dy)