Contour Order option: trace outlines before or after each layer's infill

- New Contour Order dropdown in the Generate G-Code options: "After
infill" (default, unchanged behavior) or "Before infill", which traces
each layer's contours right after the Z lift and runs the raster
afterwards.
- The same order drives every shape, so shared reference motion stays in
sync across parallel heads (verified: identical path lengths and
endpoints with contours first).
- Included in the stale-G-code fingerprint and the settings export/import
round trip.

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

README.md

@@ -61,6 +61,7 @@ Then open the local Gradio URL in your browser, upload STL files or load the bun
 - Appends a shape outline contour after each enabled shape layer by tracing that layer's polygon boundary
 - Offers a choice of raster pattern for G-code generation; all shapes always share one combined reference outline for motion (one nozzle path; each dispenses only its own geometry), and every move is emitted as `G1` at one constant speed (no `G0` rapid travel)
 - **Sweep Buffer (mm)** sets the valve-settle travel before and after each raster line (default 0.8, 0 disables it); it applies to the axis rasters and both woodpiles, and the same value drives every shape so the shared motion stays in sync
+- **Contour Order** picks when each layer's contours are traced: after the layer's infill (default) or before it, right after the layer's Z lift; the same order drives every shape so the shared motion stays in sync
 - Slicing is automatic: **Generate G-Code** slices every shape (fresh or stale) before writing G-code, and **Split Selected Shape into Grid Pieces** slices before splitting — "upload, then Generate G-Code" works in one click with no separate slice step
 - The generation status leads with the shared print path length and a time estimate at the Visualization tab's nozzle speed, and generation auto-renders the parallel view so switching to the Visualization tab always shows the current print
 - A **stale-G-code banner** appears above the Generate button whenever the table or any generation option changes after files were generated (each file carries a settings fingerprint), so outdated G-code is never downloaded or printed unnoticed

app.py

@@ -41,6 +41,8 @@ from stl_slicer import (
 )
 from vector_gcode import MAX_PRESSURE_PSI, generate_vector_gcode
 from vector_toolpath import (
+    CONTOUR_ORDER_CHOICES,
+    CONTOUR_ORDER_LAST,
     LEAD_IN_DIRECTION_CHOICES,
     LEAD_IN_DIRECTION_LEFT,
     LEAD_IN_LINE_AUTO,
@@ -4335,6 +4337,7 @@ def _gcode_settings_snapshot(
     scale_mode: str | None,
     sweep_buffer: float = 0.8,
     lead_in_orientation: str | None = None,
+    contour_order: str | None = None,
 ) -> dict:
     """Fingerprint of every setting that shapes this record's G-code.
 
@@ -4366,6 +4369,7 @@ def _gcode_settings_snapshot(
         "fil_width": round(_coerce_float(fil_width, 0.8), 6),
         "scale_mode": _normalize_scale_mode(scale_mode),
         "sweep_buffer": round(_coerce_float(sweep_buffer, 0.8), 6),
+        "contour_order": str(contour_order or CONTOUR_ORDER_LAST),
     }
 
 
@@ -4389,6 +4393,7 @@ def check_gcode_staleness(
     scale_mode: str | None,
     sweep_buffer: float = 0.8,
     lead_in_orientation: str | None = None,
+    contour_order: str | None = None,
 ) -> str:
     """Warning banner text when generated G-code no longer matches the settings."""
     records = _apply_shape_settings(records or [], settings_table)
@@ -4406,6 +4411,7 @@ def check_gcode_staleness(
         scale_mode,
         sweep_buffer,
         lead_in_orientation,
+        contour_order,
     )
     for record in records:
         if not record.get("gcode_path"):
@@ -4447,6 +4453,7 @@ def export_project_settings(
     lead_in_direction: str | None,
     lead_in_orientation: str | None,
     nozzle_speed: Any,
+    contour_order: str | None = None,
 ) -> tuple[str | None, str]:
     """Write the session's settings to a small JSON file, keyed by STL name.
 
@@ -4483,6 +4490,7 @@ def export_project_settings(
             "lead_in_direction": str(lead_in_direction or LEAD_IN_DIRECTION_LEFT),
             "lead_in_orientation": str(lead_in_orientation or LEAD_IN_LINE_AUTO),
             "nozzle_speed": _coerce_float(nozzle_speed, 10.0),
+            "contour_order": str(contour_order or CONTOUR_ORDER_LAST),
         },
     }
     settings_path = Path(tempfile.mkdtemp(prefix="pp_settings_")) / "parallelprint_settings.json"
@@ -4506,7 +4514,7 @@ def import_project_settings(
     """
 
     def _skip_options() -> tuple:
-        return tuple(gr.skip() for _ in range(12))
+        return tuple(gr.skip() for _ in range(13))
 
     paths = _uploaded_file_paths(settings_upload)
     if not paths:
@@ -4568,6 +4576,7 @@ def import_project_settings(
         option("fil_width"),
         option("scale_mode"),
         option("nozzle_speed"),
+        option("contour_order"),
     )
 
 
@@ -4608,6 +4617,7 @@ def generate_dynamic_gcode(
     nozzle_speed: Any = None,
     sweep_buffer: float = 0.8,
     lead_in_orientation: str | None = None,
+    contour_order: str | None = None,
     progress: gr.Progress = gr.Progress(),
 ) -> tuple:
     records = _apply_shape_settings(records or [], settings_table)
@@ -4700,6 +4710,9 @@ def generate_dynamic_gcode(
                 raster_pattern=raster_pattern,
                 contour_sources=contour_sources,
                 active_contour_owner=int(record.get("idx", 0)),
+                # Same order for every shape: contour placement is part of
+                # the shared motion path.
+                contour_order=contour_order,
                 infill=_coerce_float(record.get("infill", 100.0), 100.0) / 100.0,
                 motion_infill_fractions=motion_infill_fractions,
                 emit_pressure_commands=owns_port_pressure,
@@ -4735,6 +4748,7 @@ def generate_dynamic_gcode(
                 scale_mode,
                 sweep_buffer,
                 lead_in_orientation,
+                contour_order,
             )
             messages.append(f"Shape {record['idx']}: wrote `{gcode_path.name}`.")
         except Exception as exc:
@@ -5285,6 +5299,15 @@ def build_dynamic_demo() -> gr.Blocks:
                     min_width=170,
                     info="Valve-settle travel before/after each raster line (0 = none).",
                 )
+                gcode_contour_order = gr.Dropdown(
+                    label="Contour Order",
+                    choices=list(CONTOUR_ORDER_CHOICES),
+                    value=CONTOUR_ORDER_LAST,
+                    allow_custom_value=False,
+                    scale=1,
+                    min_width=170,
+                    info="Trace shape outlines before or after each layer's infill.",
+                )
             with gr.Accordion("Lead In Options", open=False, elem_classes=["settings-accordion"]):
                 gr.Markdown("Applies to shapes with **Lead In** checked in the Shape Settings table.")
                 with gr.Row():
@@ -5669,6 +5692,7 @@ def build_dynamic_demo() -> gr.Blocks:
                 gcode_lead_in_direction,
                 gcode_lead_in_orientation,
                 viz_nozzle_speed,
+                gcode_contour_order,
             ],
             outputs=[settings_export_file, settings_status],
             queue=False,
@@ -5692,6 +5716,7 @@ def build_dynamic_demo() -> gr.Blocks:
                 fil_width,
                 scale_mode,
                 viz_nozzle_speed,
+                gcode_contour_order,
             ],
         )
 
@@ -5712,6 +5737,7 @@ def build_dynamic_demo() -> gr.Blocks:
             scale_mode,
             gcode_sweep_buffer,
             gcode_lead_in_orientation,
+            gcode_contour_order,
         ]
         shape_settings.change(
             fn=check_gcode_staleness,
@@ -5731,6 +5757,7 @@ def build_dynamic_demo() -> gr.Blocks:
             scale_mode,
             gcode_sweep_buffer,
             gcode_lead_in_orientation,
+            gcode_contour_order,
         ):
             stale_control.change(
                 fn=check_gcode_staleness,
@@ -5775,6 +5802,7 @@ def build_dynamic_demo() -> gr.Blocks:
                 viz_nozzle_speed,
                 gcode_sweep_buffer,
                 gcode_lead_in_orientation,
+                gcode_contour_order,
             ],
             outputs=[shape_records, ref_layers, gcode_downloads, gcode_status, gcode_text_source, gcode_source, gcode_download_all],
         ).then(

tests/test_vector_gcode.py

@@ -1683,6 +1683,98 @@ def test_split_contour_gcode_never_traces_the_cuts(tmp_path) -> None:
     assert vertical_prints == []
 
 
+def test_contour_order_option_places_contours_first_or_last(tmp_path) -> None:
+    from vector_toolpath import CONTOUR_ORDER_FIRST
+
+    layer = box(0.0, 0.0, 6.0, 4.0)
+    stack = _stack(layer, layer, name="order")
+    sources = [ContourSource(owner_idx=1, stack=stack)]
+
+    def per_layer_kinds(contour_order):
+        tag = str(contour_order or "default").replace(" ", "_")
+        gcode_path = generate_vector_gcode(
+            stack,
+            shape_name=f"order_{tag}",
+            pressure=25,
+            valve=4,
+            port=1,
+            fil_width=1.0,
+            contour_sources=sources,
+            active_contour_owner=1,
+            contour_order=contour_order,
+            output_dir=tmp_path / tag,
+        )
+        moves = _moves_with_colors(gcode_path.read_text())
+        prints = [move for move in moves if move["color"] == 255]
+        # The contour rims are the outermost printed Y lines; the X-raster
+        # scanlines run strictly inside them.
+        rim_lo = min(min(m["start"][1], m["end"][1]) for m in prints)
+        rim_hi = max(max(m["start"][1], m["end"][1]) for m in prints)
+
+        def kind(move: dict) -> str:
+            if abs(move["end"][1] - move["start"][1]) > 1e-9:
+                return "contour"  # vertical print: box side edge
+            on_rim = (
+                min(abs(move["start"][1] - rim_lo), abs(move["start"][1] - rim_hi))
+                < 1e-6
+            )
+            return "contour" if on_rim else "infill"
+
+        layers: list[list[str]] = [[]]
+        for move in moves:
+            if abs(move["end"][2] - move["start"][2]) > 1e-9:
+                layers.append([])
+                continue
+            if move["color"] != 255:
+                continue
+            layers[-1].append(kind(move))
+        return [kinds for kinds in layers if kinds]
+
+    # Default: infill first, contours close the layer.
+    for kinds in per_layer_kinds(None):
+        assert "contour" in kinds and "infill" in kinds
+        first_contour = kinds.index("contour")
+        assert all(kind == "contour" for kind in kinds[first_contour:])
+        assert kinds[0] == "infill"
+
+    # Before infill: contours open the layer, infill follows.
+    for kinds in per_layer_kinds(CONTOUR_ORDER_FIRST):
+        assert "contour" in kinds and "infill" in kinds
+        first_infill = kinds.index("infill")
+        assert all(kind == "infill" for kind in kinds[first_infill:])
+        assert kinds[0] == "contour"
+
+    # Shared motion stays in sync with contours first: every head traces one
+    # identical path.
+    stack_b = _stack(layer, layer, name="order_b")
+    reference = build_reference_stack([stack, stack_b], grid=1.0)
+    shared_sources = [
+        ContourSource(owner_idx=1, stack=stack),
+        ContourSource(owner_idx=2, stack=stack_b),
+    ]
+    lengths = set()
+    ends = set()
+    for idx, shape in enumerate((stack, stack_b), start=1):
+        path = generate_vector_gcode(
+            shape,
+            shape_name=f"sync_{idx}",
+            pressure=25,
+            valve=3 + idx,
+            port=1,
+            fil_width=1.0,
+            motion=reference,
+            contour_sources=shared_sources,
+            active_contour_owner=idx,
+            contour_order=CONTOUR_ORDER_FIRST,
+            output_dir=tmp_path / f"sync_{idx}",
+        )
+        moves = _moves_with_colors(path.read_text())
+        lengths.add(round(_total_length(moves), 4))
+        ends.add(moves[-1]["end"])
+    assert len(lengths) == 1
+    assert len(ends) == 1
+
+
 def test_split_pieces_center_on_the_shared_motion() -> None:
     from vector_toolpath import _centering_delta
 

vector_gcode.py

@@ -193,6 +193,7 @@ def generate_vector_gcode(
     motion: LayerStack | None = None,
     contour_sources: list[ContourSource] | None = None,
     active_contour_owner: int | None = None,
+    contour_order: str | None = None,
     infill: float = 1.0,
     motion_infill_fractions: list[float] | None = None,
     emit_pressure_commands: bool = True,
@@ -331,6 +332,9 @@ def generate_vector_gcode(
         # Valve-settle travel before/after each raster sweep; one fil_width
         # when not given. Pass the SAME value for every shape sharing motion.
         sweep_buffer=sweep_buffer,
+        # Same value for every shape sharing motion: contour placement is
+        # part of the shared path.
+        contour_order=contour_order,
     )
 
     # World anchor: the toolpath origin expressed in the shape's own frame.

vector_toolpath.py

@@ -1281,6 +1281,16 @@ def _append_layer_contours(
     return current_x, current_y
 
 
+CONTOUR_ORDER_LAST = "After infill"
+CONTOUR_ORDER_FIRST = "Before infill"
+CONTOUR_ORDER_CHOICES = (CONTOUR_ORDER_LAST, CONTOUR_ORDER_FIRST)
+
+
+def _contours_first(contour_order: str | None) -> bool:
+    text = str(contour_order or "").strip().lower()
+    return text.startswith("before") or text == "first"
+
+
 LEAD_IN_DIRECTION_LEFT = "Left"
 LEAD_IN_DIRECTION_RIGHT = "Right"
 LEAD_IN_DIRECTION_UP = "Up"
@@ -1440,9 +1450,14 @@ def plan_layer_moves(
     ring_center: tuple[float, float] | None = None,
     motion_infill_fractions: list[float] | None = None,
     sweep_buffer: float | None = None,
+    contour_order: str | None = None,
 ) -> tuple[list[dict], tuple[float, float]]:
     """Assemble per-layer segments into a relative move list for all patterns.
 
+    `contour_order` picks when each layer's contours are traced:
+    "After infill" (default) appends them after the layer's raster;
+    "Before infill" traces them first, right after the layer's Z lift.
+
     `scan_frame` (an XY box) pins the rasters' scanlines to a global grid so
     lines stack across layers and across split pieces, and provides the
     rotation pivot for diagonal layers.
@@ -1481,6 +1496,7 @@ def plan_layer_moves(
     origin_y = 0.0
     raster_origin_initialized = False
     contour_layers = contour_layers or []
+    contours_first = _contours_first(contour_order)
 
     for layer_number, (motion, valve) in enumerate(zip(motion_layers, valve_layers)):
         if motion is None or motion.is_empty:
@@ -1671,6 +1687,18 @@ def plan_layer_moves(
             origin_x, origin_y = first_x, first_y
             raster_origin_initialized = True
         elif layer_number > 0:
+            current_x, current_y = _append_relative_move(
+                gcode_list,
+                current_x,
+                current_y,
+                # Contours-first: lift Z in place — the contours run before
+                # the travel to the raster start.
+                current_x if contours_first else first_x,
+                current_y if contours_first else first_y,
+                0,
+                z_step=layer_height,
+            )
+        elif not contours_first:
             current_x, current_y = _append_relative_move(
                 gcode_list,
                 current_x,
@@ -1678,9 +1706,20 @@ def plan_layer_moves(
                 first_x,
                 first_y,
                 0,
-                z_step=layer_height,
             )
-        else:
+
+        if contours_first:
+            current_x, current_y = _append_layer_contours(
+                gcode_list,
+                current_x,
+                current_y,
+                contour_layers,
+                layer_number,
+                active_contour_owner,
+                origin_x,
+                origin_y,
+                shared_motion,
+            )
             current_x, current_y = _append_relative_move(
                 gcode_list,
                 current_x,
@@ -1708,26 +1747,27 @@ def plan_layer_moves(
                 color,
             )
 
-        layer_end_x, layer_end_y = current_x, current_y
-        current_x, current_y = _append_layer_contours(
-            gcode_list,
-            current_x,
-            current_y,
-            contour_layers,
-            layer_number,
-            active_contour_owner,
-            origin_x,
-            origin_y,
-            shared_motion,
-        )
-        current_x, current_y = _append_relative_move(
-            gcode_list,
-            current_x,
-            current_y,
-            layer_end_x,
-            layer_end_y,
-            0,
-        )
+        if not contours_first:
+            layer_end_x, layer_end_y = current_x, current_y
+            current_x, current_y = _append_layer_contours(
+                gcode_list,
+                current_x,
+                current_y,
+                contour_layers,
+                layer_number,
+                active_contour_owner,
+                origin_x,
+                origin_y,
+                shared_motion,
+            )
+            current_x, current_y = _append_relative_move(
+                gcode_list,
+                current_x,
+                current_y,
+                layer_end_x,
+                layer_end_y,
+                0,
+            )
 
     return gcode_list, (origin_x, origin_y)