Merge branch 'main' into feature/chromastack

docs/HLSD/chromastack.md: what the colour model is and why it is
Beer-Lambert, what the solve does, how a stack attaches to a texture
displacement layer, why the swaps are height ranges, what the preview
shader draws, and the geometry the whole thing assumes.

docs/HLSD/chromastack.md

@@ -0,0 +1,239 @@
+# ChromaStack - High Level Design
+
+## Purpose and scope
+
+ChromaStack prints a colour picture on a single face of a model: a few filaments are printed one on
+top of another, the printer swaps filament at fixed layer boundaries, and the *height* of every
+pixel decides how many of those layers reach it. Filament is translucent, so a pixel that stops
+part-way through a run shows a blend of that run's filament and whatever is under it, which is
+where the colours come from - far more of them than there are filaments loaded.
+
+This is that model inside OrcaSlicer, as a mode of a texture displacement layer. The picture and
+the filament stack are the input; the output is a grayscale height map and a set of filament swaps.
+Nothing about it is a new pipeline: the height map is handed to the layer the user painted, so the
+existing projection, preview and bake turn it into real geometry, and the swaps are handed to the
+object's height ranges, which is the slicer's own way of printing a Z band in another filament.
+
+It does not import other filament-painting tools' project files, and it does not choose the filaments or
+their order - that is the user's artistic decision, and the panel exists to make its result
+visible before the print.
+
+## The colour model
+
+`libslic3r/ChromaStack.hpp` holds the whole of it, free of any GUI dependency, which is what lets the
+solve run against plain image bytes and be unit tested.
+
+A **stack** (`ChromaStack`) is a list of **bands** (`ChromaBand`), bottom-up: a filament and
+how many layers it gets. Alongside them it carries the print's layer height, which the colours
+depend on directly, and the **base**: how many layers of solid backing the picture sits on.
+
+The base is not a band. It is a measurement of the model - everything below the painted face, often
+a hundred layers or more on a tall part - while a band is a handful of layers the user chooses. It
+prints in the bottom band's filament, because that is what is loaded when the print starts, so it
+extends that band's height range down to the first layer instead of being a swap of its own. Only
+the bands are quantized into the height map, which is why the 255-layer limit
+(`CHROMA_MAX_RELIEF_LAYERS`) bounds the picture and not the stack.
+
+Each filament carries its **transmission distance** (TD), the usual measure for how deep
+light gets into it: about 1 for an opaque filament, 4 to 7 for a usefully translucent one, 8 and
+above for a nearly clear one. TD lives in the filament preset, as
+`filament_transmission_distance` - it is a property of the material, so it belongs with the
+material and ships with a profile rather than being retyped per project. It has no effect on
+slicing.
+
+`chroma_palette()` turns a stack into the colour it shows at every possible column height, which
+is all the solver ever needs. The model is Beer-Lambert absorption, layer by layer: a layer of
+thickness `h` in a filament of transmission distance `TD` passes
+
+    T = exp(-h / (CHROMA_TD_OPAQUE_FRACTION * TD / 3))
+
+of the light from under it and shows its own colour with the rest, so walking up from an opaque
+base,
+
+    C_k = (1 - T_k) * c_k + T_k * C_(k-1),  C_0 = c_1
+
+The constants say what TD means in physical terms: a filament stops showing what is behind it at
+about a tenth of its TD number (`CHROMA_TD_OPAQUE_FRACTION`), and three e-folding lengths of
+absorption pass 5% of the light, which is where the eye stops seeing through. Those are calibrated
+against how the community's TD step prints behave, not derived from first principles - TD is an
+empirical scale.
+
+How fast that happens is the single most useful fact about a stack, and `chroma_layers_to_opaque()`
+is it: a filament hides what is under it at about a tenth of its TD, so how many *layers* that takes
+depends entirely on how thick they are. TD 4 covers in two layers at 0.2 mm and in five at 0.08 mm.
+Below about two layers a band has no intermediate colours at all - the picture can only use the
+filament or not use it - which is why an otherwise sound stack prints as flat steps at a coarse
+layer height. The panel reports the number under the palette ramp, and warns when it falls below
+two, because nothing else makes it visible: the filaments look fine, the bands look long enough, and
+the result looks like the colour model is wrong when it is the layer height.
+
+How many of a picture's layers actually earn their place is a second question, and
+`chroma_distinct_levels()` answers it: a band eventually hides what is under it, and another layer of
+it then shows the colour the one below already showed. It is measured against the palette rather than
+against TD, because how long a band keeps paying depends on what is under it as much as on the
+filament - a light band over a dark one is finished in four or five layers, while a dark one over a
+light one goes on moving the colour perceptibly well past the depth at which it is nominally opaque,
+since the last few percent of light coming through still shifts a near-black colour. `Trim` shortens
+each band to its last layer that still changes anything.
+
+Beer-Lambert is also the only model that stays self-consistent applied per layer: transmittance
+multiplies, so a run of n layers of one filament passes `exp(-n h / d)` whether it is composited in
+one step or n, and the palette therefore does not depend on how the stack happens to be cut into
+bands. A unit test asserts exactly that. Compositing is done on linear light, because the quantity
+being attenuated is light rather than an sRGB code.
+
+The base is assumed opaque. That is what makes a column's colour depend only on the layers above it,
+and it is why the panel warns when the base is thin.
+
+## The solve
+
+`chroma_solve()` maps each pixel of the picture to the column height whose palette colour is
+closest to it, perceptually: both sides go to CIELAB and the match is a CIE76 distance. A 1-D
+palette of a few dozen entries makes the extra accuracy of CIEDE2000 hard to see and the cost of it
+easy to feel - several hundred million comparisons for a large picture - so the cheaper metric is
+the deliberate choice here, unlike the texture colour quantizer, which matches against a
+two-dimensional palette of filament mixes and uses a precomputed CIEDE2000 cube.
+
+Optional Floyd-Steinberg error diffusion, serpentine, trades the bands a photograph shows across a
+sky or a cheek for fine stipple. Off by default, since stipple is the artifact rather than the cure
+for flat-coloured artwork.
+
+Three things come back: the per-pixel layer count, the same thing as an 8-bit grayscale height map
+(0 at the base, 255 at the top of the stack), and the palette colours chosen, as an RGB image. The
+quantization belongs to the solve rather than to the displacement because the relief's steps have
+to land on layer boundaries, and a grey level is the only channel the displacement reads.
+
+The solve also reports the mean and worst colour difference it had to accept. That is the only
+honest answer to "will this stack reproduce my picture": under about 5 is a good match, over about
+15 means the filaments cannot reach the picture's colours and no number of layers will help.
+
+## How it attaches to a texture displacement layer
+
+A ChromaStack layer is an ordinary `TextureDisplacementLayer` whose height map is computed rather than
+imported:
+
+- `chroma_source` keeps the picture the user chose, so the solve can be redone whenever the stack,
+  the layer height or the picture changes;
+- `chroma` is the stack;
+- `image_data` - the same field every other layer uses - holds whatever the last solve produced.
+
+So everything downstream needs no changes at all and knows nothing about colour stacks. It also
+means the solve writes `depth_mm` (the relief is exactly as tall as the layers above the base) and
+pins `invert`, `midlevel` and `smoothing`: blurring a solved height map moves its steps off the
+layer boundaries they were solved for.
+
+Colour by filament swap and the layer's own `color_enabled` (one filament per triangle, via
+`mmu_segmentation_facets`) are mutually exclusive, and the panel enforces it. They are two
+different ways of colouring the same surface, and painting the relief per triangle would hide the
+very stack the heights were solved against.
+
+## The filament swaps
+
+`chroma_ranges()` turns the bands into Z bands in the object's own coordinates, merging any two
+adjacent bands that share a filament, since nothing is swapped between them. The panel writes them
+onto the object as `layer_config_ranges`, each range carrying `extruder` - which
+`apply_to_print_region_config()` spreads over every feature filament the range does not otherwise
+override, i.e. the whole band prints in that filament - and `layer_height`, both because the solve
+is only valid at the height it was run at and because `layer_height_profile_from_ranges()` reads
+that option without checking it is there.
+
+Height ranges rather than colour-change custom G-code: they are object-relative, so they survive
+the object being moved, they are saved in the project file, and they appear in the object list where
+the user can see and edit them. The cost is that an object can only have one set of them, so
+applying a stack replaces whatever ranges the object had, with a confirmation when it had any.
+
+`ObjectList::rebuild_layer_ranges()` mirrors them in the object tree without touching the
+selection - changing the selection while a gizmo is open tears the gizmo down under the user.
+
+## Geometry the model assumes
+
+A filament swap happens at one Z across the whole plate, and the relief grows along the painted
+surface's normal. The two agree only where that surface is horizontal, so:
+
+- the painted patch's height above the bottom of the object is what the base layer count has to
+  match, and the panel measures it from the patch and offers the number rather than leaving the user
+  to work it out;
+- a patch that is not flat in Z gets a warning, because its colours will only be right where it is
+  level. The relief itself is still computed, since a gently domed plaque is a legitimate thing to
+  print and only the user can judge how much error is acceptable.
+
+The model itself is the user's: the stack needs a slab of the base thickness with a face to paint,
+and nothing here creates or thickens geometry.
+
+## Seeing the colours
+
+The colours are blends of translucent filaments. No single filament makes them, so they cannot be
+expressed as the per-triangle filament assignment the 3D scene paints with, and there is nothing for
+the ordinary view to draw. They exist in two places: the sliced preview, which shows the filament
+bands as they print, and an overlay the gizmo draws over whatever surface is on screen.
+
+That overlay is a shader, `resources/shaders/*/chromastack.*`, and it reads the colour from each
+fragment's own **print Z** rather than from the height map or from anything in the mesh. A filament
+swap happens at one Z across the whole plate, so the layer a point sits in is what decides its
+colour whatever the picture says. Two things follow. A band edge lands exactly on the layer boundary
+however coarse the triangles are - a per-triangle colouring puts it wherever the mesh happens to
+have an edge. And it keeps working after a bake, when the relief is real geometry, the paint has
+been cleared and the height map is attached to nothing on screen; the overlay is built from the live
+preview's displaced mesh before a bake and from the volume's own mesh after one.
+
+The stack's colours reach the shader as a texture of one texel per printed layer, because a base can
+be several hundred layers and no uniform array holds that. The mesh carries nothing about the stack,
+so editing the stack costs a palette upload rather than a mesh rebuild.
+
+On top of the colour the shader tries to look like printed plastic, because a flat shaded colour
+reads as a rendering and the whole point of the overlay is judging a print:
+
+- the terminator is **wrapped** and the grazing angles **glow**, both scaled by the transmission
+  distance of the filament on top - filament translucent enough to be worth stacking scatters light
+  rather than reflecting it, and an opaque stack correctly gets neither;
+- the walls carry **layer lines**, a groove at every layer boundary that also modulates the
+  specular, so a wall glints in stripes as a printed one does. Terraces get none: a terrace is one
+  layer's top surface and has no lines to show.
+
+Both effects are driven by the fragment's height, so they are free of any texture or UV, and both
+fade out through `fwidth` once a pixel covers more than about half a layer - lines finer than a
+pixel are noise, and a colour read from one layer out of the dozen under a pixel flickers as the
+camera moves. The palette lookup slides off the texel centres over the same range so the linear
+filter averages the bands a pixel covers instead of picking one of them.
+
+The overlay is drawn pulled forward and without depth writes, the same pass the painted-colour
+overlay uses, since it is the same surface as whatever is underneath it.
+
+## What the panel shows
+
+The kind of a layer is the layer's own, chosen when it is added and fixed from then on: **Add layer**
+offers *Relief layer* or *ChromaStack picture*, and the card carries its kind as a chip. There is no
+panel-wide mode, so one object can hold a picture on its face and a knurl on its rim, and a card
+never shows a control that cannot do anything on it.
+
+What the two cards do not share:
+
+| Control | Relief card | ChromaStack card |
+| --- | --- | --- |
+| Depth | slider | the solve writes it; the card prints the result |
+| Tile size | repeats the pattern | **Picture size**, the same number named for what it does |
+| Midlevel, Smoothing, Invert, Edge fade | present | absent: each would move the steps off the layer boundaries |
+| Colors, Mix filaments, Denoise | one filament per triangle | absent: swaps are how this card colours |
+| Tile, tile method | present | absent: one copy, never tiled |
+| Blend | four modes | absent: it is the top layer and replaces what is under it |
+| Picture, prediction, stack, palette, match, Dither, Solve, Apply swaps | absent | present |
+
+A ChromaStack card has no grip and cannot be reordered: its colours come from swapping filament at a
+height, so anything printed above it would bury them. An object may hold only one, refused when the
+layer is added rather than when the swaps are applied, because the swaps are the object's own height
+ranges and there is one set of those.
+
+The card itself, top to bottom: what it is in one line, the picture and the predicted print side by
+side at the same size, the match figures, the base with the measurement from the painted face offered
+beside it, a row per band - swatch, filament, layer count, TD - the colours the stack reaches as a
+ramp, the totals, dither with the layer height it is solved against, and the two actions. Base and
+band counts are typed fields rather than sliders: a base is measured in hundreds of layers and a band
+in single digits, and dragging past the end of a slider's range is how a stack silently loses its
+backing.
+
+The ramp is computed from the stack alone, before any solve. It is what answers "can these filaments
+print this picture" without spending a solve to find out they cannot: a short or flat ramp means the
+filaments are too alike, or too opaque, to give the picture anything to work with.
+
+A per-slot flag records that the stack has been edited since the last solve, because a stale height
+map looks exactly like a good one.

resources/shaders/110/chromastack.fs

@@ -0,0 +1,92 @@
+#version 110
+
+// What a ChromaStack print looks like, shaded per fragment.
+//
+// The colour is not a vertex attribute and not a texture on the surface: it is read from the
+// fragment's own height. A filament swap happens at one print Z across the whole plate, so the layer
+// a point sits in is what decides its colour - which means a band edge lands exactly on the layer
+// boundary however coarse the mesh is, and the same shader is right before a bake (on the preview's
+// displaced mesh) and after one (on the volume's own).
+//
+// On top of that it tries to look like printed plastic rather than like flat shaded colour: the
+// terminator is wrapped and the grazing angles glow, because filament translucent enough to be worth
+// stacking scatters light rather than reflecting it; and the walls carry layer lines, because that is
+// the first thing the eye uses to read a print as a print.
+
+#define INTENSITY_CORRECTION 0.6
+const vec3 LIGHT_TOP_DIR = vec3(-0.4574957, 0.4574957, 0.7624929);
+#define LIGHT_TOP_DIFFUSE    (0.8 * INTENSITY_CORRECTION)
+#define LIGHT_TOP_SPECULAR   (0.125 * INTENSITY_CORRECTION)
+#define LIGHT_TOP_SHININESS  20.0
+const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074);
+#define LIGHT_FRONT_DIFFUSE  (0.3 * INTENSITY_CORRECTION)
+#define INTENSITY_AMBIENT    0.3
+
+// The stack's colours, one texel per printed layer, bottom to top. A texture rather than a uniform
+// array because a base can be several hundred layers and no uniform array survives that.
+uniform sampler2D palette;
+uniform float     palette_size;  // texels in `palette`, i.e. the stack's total printed layers
+uniform float     base_z;        // world Z of the bottom of the object
+uniform float     layer_height;  // mm
+// How translucent the stack reads, 0 to 1, from the transmission distance of the filament on top.
+// It drives the wrap and the rim: an opaque stack should not glow.
+uniform float     translucency;
+uniform float     alpha;
+
+varying vec3  clipping_planes_dots;
+varying vec3  eye_normal;
+varying vec3  eye_position;
+varying vec3  world_normal;
+varying float world_z;
+
+void main()
+{
+    if (any(lessThan(clipping_planes_dots, vec3(0.0))))
+        discard;
+
+    float z_rel  = world_z - base_z;
+    float layers = max(z_rel / layer_height, 0.0);
+    // How much of a layer one pixel covers. Everything below is faded out as this grows: layer lines
+    // finer than a pixel are noise, and a colour read from one layer out of the dozen under a pixel
+    // flickers as the camera moves.
+    float px     = fwidth(layers);
+
+    // The layer this fragment sits in, 1-based. Up close that is an exact texel of the palette; once a
+    // pixel spans a layer or more it slides to a continuous coordinate so the linear filter averages
+    // the bands it covers instead of picking one of them at random.
+    float stepped = clamp(ceil(layers - 1.0e-4), 1.0, palette_size) - 0.5;
+    float smooth_ = clamp(layers, 0.5, palette_size - 0.5);
+    float u       = mix(stepped, smooth_, clamp(px - 0.5, 0.0, 1.0)) / palette_size;
+    vec3  albedo  = texture2D(palette, vec2(u, 0.5)).rgb;
+
+    vec3 N = normalize(eye_normal);
+    vec3 V = normalize(-eye_position);
+
+    // Layer lines, on the walls only: a terrace is one layer's top surface and has none to show. The
+    // groove runs round the part at every layer boundary, so it is a function of height alone.
+    float wall   = 1.0 - abs(world_normal.z);
+    float phase  = fract(layers);
+    float groove = smoothstep(0.0, 0.16, phase) * smoothstep(1.0, 0.84, phase);
+    groove       = mix(groove, 0.65, clamp(px * 1.5, 0.0, 1.0)); // fade to flat when too fine to resolve
+    float lines  = mix(1.0, 0.84 + 0.16 * groove, wall * 0.9);
+    albedo      *= lines;
+
+    // Diffuse, with a wrapped terminator: light entering translucent filament comes back out a little
+    // way round the curve, so the shaded side never goes as dark as an opaque surface's would.
+    float wrap    = 0.25 + 0.45 * translucency;
+    float ndotl   = dot(N, LIGHT_TOP_DIR);
+    float diffuse = max((ndotl + wrap) / (1.0 + wrap), 0.0) * LIGHT_TOP_DIFFUSE;
+    diffuse      += max((dot(N, LIGHT_FRONT_DIR) + wrap) / (1.0 + wrap), 0.0) * LIGHT_FRONT_DIFFUSE;
+
+    // Specular, strongest along a layer line, which is what makes a printed wall glint in stripes
+    // rather than evenly.
+    float spec = LIGHT_TOP_SPECULAR * pow(max(dot(V, reflect(-LIGHT_TOP_DIR, N)), 0.0), LIGHT_TOP_SHININESS);
+    spec      *= mix(1.0, 0.35 + 0.65 * groove, wall * 0.9);
+
+    // Scattering out of the edges: a translucent part lights up where it is seen at a grazing angle
+    // and where it is thin. Tinted by the filament, because what comes back out has been through it.
+    float rim = pow(1.0 - clamp(dot(N, V), 0.0, 1.0), 4.0);
+
+    vec3 color = albedo * (INTENSITY_AMBIENT + diffuse) + vec3(spec) + albedo * rim * translucency * 0.55;
+    gl_FragColor = vec4(color, alpha);
+}

resources/shaders/110/chromastack.vs

@@ -0,0 +1,40 @@
+#version 110
+
+uniform mat4 view_model_matrix;
+uniform mat4 projection_matrix;
+uniform mat3 view_normal_matrix;
+uniform mat4 volume_world_matrix;
+// The volume's normal matrix in world space, so the fragment shader can tell a wall from a terrace -
+// which is what decides whether layer lines show at all.
+uniform mat3 world_normal_matrix;
+// Clipping plane, x = min z, y = max z (the FFF/SLA preview's top/bottom cut).
+uniform vec2 z_range;
+// Clipping plane, general orientation (the section view).
+uniform vec4 clipping_plane;
+
+// GLModel's P3N3 layout, which is what init_from(indexed_triangle_set) produces - this shader needs
+// nothing per vertex that the mesh does not already carry, because the colour comes from the
+// fragment's own height rather than from anything baked into the vertices.
+attribute vec3 v_position;
+attribute vec3 v_normal;
+
+varying vec3  clipping_planes_dots;
+varying vec3  eye_normal;
+varying vec3  eye_position;
+varying vec3  world_normal;
+varying float world_z;
+
+void main()
+{
+    vec4 model_pos = vec4(v_position, 1.0);
+    vec4 world_pos = volume_world_matrix * model_pos;
+    world_z        = world_pos.z;
+    world_normal   = normalize(world_normal_matrix * v_normal);
+    eye_normal     = normalize(view_normal_matrix * v_normal);
+
+    vec4 eye_pos = view_model_matrix * model_pos;
+    eye_position = eye_pos.xyz;
+    gl_Position  = projection_matrix * eye_pos;
+
+    clipping_planes_dots = vec3(dot(world_pos, clipping_plane), world_pos.z - z_range.x, z_range.y - world_pos.z);
+}

resources/shaders/140/chromastack.fs

@@ -0,0 +1,94 @@
+#version 140
+
+// What a ChromaStack print looks like, shaded per fragment.
+//
+// The colour is not a vertex attribute and not a texture on the surface: it is read from the
+// fragment's own height. A filament swap happens at one print Z across the whole plate, so the layer
+// a point sits in is what decides its colour - which means a band edge lands exactly on the layer
+// boundary however coarse the mesh is, and the same shader is right before a bake (on the preview's
+// displaced mesh) and after one (on the volume's own).
+//
+// On top of that it tries to look like printed plastic rather than like flat shaded colour: the
+// terminator is wrapped and the grazing angles glow, because filament translucent enough to be worth
+// stacking scatters light rather than reflecting it; and the walls carry layer lines, because that is
+// the first thing the eye uses to read a print as a print.
+
+#define INTENSITY_CORRECTION 0.6
+const vec3 LIGHT_TOP_DIR = vec3(-0.4574957, 0.4574957, 0.7624929);
+#define LIGHT_TOP_DIFFUSE    (0.8 * INTENSITY_CORRECTION)
+#define LIGHT_TOP_SPECULAR   (0.125 * INTENSITY_CORRECTION)
+#define LIGHT_TOP_SHININESS  20.0
+const vec3 LIGHT_FRONT_DIR = vec3(0.6985074, 0.1397015, 0.6985074);
+#define LIGHT_FRONT_DIFFUSE  (0.3 * INTENSITY_CORRECTION)
+#define INTENSITY_AMBIENT    0.3
+
+// The stack's colours, one texel per printed layer, bottom to top. A texture rather than a uniform
+// array because a base can be several hundred layers and no uniform array survives that.
+uniform sampler2D palette;
+uniform float     palette_size;  // texels in `palette`, i.e. the stack's total printed layers
+uniform float     base_z;        // world Z of the bottom of the object
+uniform float     layer_height;  // mm
+// How translucent the stack reads, 0 to 1, from the transmission distance of the filament on top.
+// It drives the wrap and the rim: an opaque stack should not glow.
+uniform float     translucency;
+uniform float     alpha;
+
+in vec3  clipping_planes_dots;
+in vec3  eye_normal;
+in vec3  eye_position;
+in vec3  world_normal;
+in float world_z;
+
+out vec4 out_color;
+
+void main()
+{
+    if (any(lessThan(clipping_planes_dots, vec3(0.0))))
+        discard;
+
+    float z_rel  = world_z - base_z;
+    float layers = max(z_rel / layer_height, 0.0);
+    // How much of a layer one pixel covers. Everything below is faded out as this grows: layer lines
+    // finer than a pixel are noise, and a colour read from one layer out of the dozen under a pixel
+    // flickers as the camera moves.
+    float px     = fwidth(layers);
+
+    // The layer this fragment sits in, 1-based. Up close that is an exact texel of the palette; once a
+    // pixel spans a layer or more it slides to a continuous coordinate so the linear filter averages
+    // the bands it covers instead of picking one of them at random.
+    float stepped = clamp(ceil(layers - 1.0e-4), 1.0, palette_size) - 0.5;
+    float smooth_ = clamp(layers, 0.5, palette_size - 0.5);
+    float u       = mix(stepped, smooth_, clamp(px - 0.5, 0.0, 1.0)) / palette_size;
+    vec3  albedo  = texture(palette, vec2(u, 0.5)).rgb;
+
+    vec3 N = normalize(eye_normal);
+    vec3 V = normalize(-eye_position);
+
+    // Layer lines, on the walls only: a terrace is one layer's top surface and has none to show. The
+    // groove runs round the part at every layer boundary, so it is a function of height alone.
+    float wall   = 1.0 - abs(world_normal.z);
+    float phase  = fract(layers);
+    float groove = smoothstep(0.0, 0.16, phase) * smoothstep(1.0, 0.84, phase);
+    groove       = mix(groove, 0.65, clamp(px * 1.5, 0.0, 1.0)); // fade to flat when too fine to resolve
+    float lines  = mix(1.0, 0.84 + 0.16 * groove, wall * 0.9);
+    albedo      *= lines;
+
+    // Diffuse, with a wrapped terminator: light entering translucent filament comes back out a little
+    // way round the curve, so the shaded side never goes as dark as an opaque surface's would.
+    float wrap    = 0.25 + 0.45 * translucency;
+    float ndotl   = dot(N, LIGHT_TOP_DIR);
+    float diffuse = max((ndotl + wrap) / (1.0 + wrap), 0.0) * LIGHT_TOP_DIFFUSE;
+    diffuse      += max((dot(N, LIGHT_FRONT_DIR) + wrap) / (1.0 + wrap), 0.0) * LIGHT_FRONT_DIFFUSE;
+
+    // Specular, strongest along a layer line, which is what makes a printed wall glint in stripes
+    // rather than evenly.
+    float spec = LIGHT_TOP_SPECULAR * pow(max(dot(V, reflect(-LIGHT_TOP_DIR, N)), 0.0), LIGHT_TOP_SHININESS);
+    spec      *= mix(1.0, 0.35 + 0.65 * groove, wall * 0.9);
+
+    // Scattering out of the edges: a translucent part lights up where it is seen at a grazing angle
+    // and where it is thin. Tinted by the filament, because what comes back out has been through it.
+    float rim = pow(1.0 - clamp(dot(N, V), 0.0, 1.0), 4.0);
+
+    vec3 color = albedo * (INTENSITY_AMBIENT + diffuse) + vec3(spec) + albedo * rim * translucency * 0.55;
+    out_color  = vec4(color, alpha);
+}

resources/shaders/140/chromastack.vs

@@ -0,0 +1,40 @@
+#version 140
+
+uniform mat4 view_model_matrix;
+uniform mat4 projection_matrix;
+uniform mat3 view_normal_matrix;
+uniform mat4 volume_world_matrix;
+// The volume's normal matrix in world space, so the fragment shader can tell a wall from a terrace -
+// which is what decides whether layer lines show at all.
+uniform mat3 world_normal_matrix;
+// Clipping plane, x = min z, y = max z (the FFF/SLA preview's top/bottom cut).
+uniform vec2 z_range;
+// Clipping plane, general orientation (the section view).
+uniform vec4 clipping_plane;
+
+// GLModel's P3N3 layout, which is what init_from(indexed_triangle_set) produces - this shader needs
+// nothing per vertex that the mesh does not already carry, because the colour comes from the
+// fragment's own height rather than from anything baked into the vertices.
+in vec3 v_position;
+in vec3 v_normal;
+
+out vec3  clipping_planes_dots;
+out vec3  eye_normal;
+out vec3  eye_position;
+out vec3  world_normal;
+out float world_z;
+
+void main()
+{
+    vec4 model_pos = vec4(v_position, 1.0);
+    vec4 world_pos = volume_world_matrix * model_pos;
+    world_z        = world_pos.z;
+    world_normal   = normalize(world_normal_matrix * v_normal);
+    eye_normal     = normalize(view_normal_matrix * v_normal);
+
+    vec4 eye_pos = view_model_matrix * model_pos;
+    eye_position = eye_pos.xyz;
+    gl_Position  = projection_matrix * eye_pos;
+
+    clipping_planes_dots = vec3(dot(world_pos, clipping_plane), world_pos.z - z_range.x, z_range.y - world_pos.z);
+}

src/libslic3r/Arachne/WallToolPaths.cpp

@@ -812,8 +812,7 @@ bool WallToolPaths::removeEmptyToolPaths(std::vector<VariableWidthLines> &toolpa
      * Get the order constraints of the insets when printing walls per region / hole.
      * Each returned pair consists of adjacent wall lines where the left has an inset_idx one lower than the right.
      *
-     * Odd walls follow the same order as even ones, so that the centre line of a narrow wall is an inner wall
-     * like any other when printing inner to outer.
+     * Odd walls should always go after their enclosing wall polygons.
      *
      * \param outer_to_inner Whether the wall polygons with a lower inset_idx should go before those with a higher one.
  */
@@ -887,7 +886,12 @@ WallToolPaths::ExtrusionLineSet WallToolPaths::getRegionOrder(const std::vector<
                 continue; // not directly adjacent
             if (!shorter_then(loc_here - lineloc_nearby.j.p, (lineloc_here.j.w + lineloc_nearby.j.w) / 2 * diagonal_extension))
                 continue; // points are too far away from each other
-            if ((nearby->inset_idx < here->inset_idx) == outer_to_inner) {
+            if (here->is_odd || nearby->is_odd) {
+                if (here->is_odd && !nearby->is_odd && nearby->inset_idx < here->inset_idx)
+                    order_requirements.emplace(std::make_pair(nearby, here));
+                if (nearby->is_odd && !here->is_odd && here->inset_idx < nearby->inset_idx)
+                    order_requirements.emplace(std::make_pair(here, nearby));
+            } else if ((nearby->inset_idx < here->inset_idx) == outer_to_inner) {
                 order_requirements.emplace(std::make_pair(nearby, here));
             } else {
                 assert((nearby->inset_idx > here->inset_idx) == outer_to_inner);

src/libslic3r/CMakeLists.txt

@@ -327,6 +327,8 @@ set(lisbslic3r_sources
     Geometry/VoronoiUtils.cpp
     Geometry/VoronoiUtils.hpp
     Geometry/VoronoiVisualUtils.hpp
+    ChromaStack.cpp
+    ChromaStack.hpp
     IMEXArrange.cpp
     IMEXArrange.hpp
     IMEXHelpers.cpp

src/libslic3r/ChromaStack.cpp

@@ -0,0 +1,394 @@
+#include "ChromaStack.hpp"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <limits>
+#include <cstdlib>
+#include <numeric>
+
+#include <tbb/blocked_range.h>
+#include <tbb/parallel_for.h>
+
+#include <miniz.h>
+
+namespace Slic3r {
+
+// How many e-folding lengths of absorption count as "the colour beneath no longer shows". Three
+// passes 5% of the light, which is about where the eye stops seeing what is under a layer.
+static constexpr float OPAQUE_EFOLDS = 3.f;
+
+// TD is a filament property, so a zero or negative value in a preset is a data error rather than a
+// request for an infinitely opaque filament. Clamp instead: below this the filament is opaque at a
+// single layer anyway.
+static constexpr float TD_MIN_MM = 0.05f;
+static constexpr float TD_MAX_MM = 100.f;
+
+static float srgb_to_linear(float c)
+{
+    return c <= 0.04045f ? c / 12.92f : std::pow((c + 0.055f) / 1.055f, 2.4f);
+}
+
+static float linear_to_srgb(float c)
+{
+    return c <= 0.0031308f ? c * 12.92f : 1.055f * std::pow(c, 1.f / 2.4f) - 0.055f;
+}
+
+// CIELAB under D65, from non-linear sRGB in [0, 1]. Only used for nearest-colour search, so the
+// absolute white point matters far less than both sides using the same one.
+struct Lab
+{
+    float l = 0.f, a = 0.f, b = 0.f;
+};
+
+static Lab srgb_to_lab(float r, float g, float b)
+{
+    const float rl = srgb_to_linear(r), gl = srgb_to_linear(g), bl = srgb_to_linear(b);
+    const float x = (0.4124f * rl + 0.3576f * gl + 0.1805f * bl) / 0.95047f;
+    const float y = (0.2126f * rl + 0.7152f * gl + 0.0722f * bl);
+    const float z = (0.0193f * rl + 0.1192f * gl + 0.9505f * bl) / 1.08883f;
+    auto        f = [](float t) {
+        return t > 0.008856f ? std::cbrt(t) : (7.787f * t + 16.f / 116.f);
+    };
+    const float fx = f(x), fy = f(y), fz = f(z);
+    return Lab{ 116.f * fy - 16.f, 500.f * (fx - fy), 200.f * (fy - fz) };
+}
+
+static float delta_e(const Lab &p, const Lab &q)
+{
+    const float dl = p.l - q.l, da = p.a - q.a, db = p.b - q.b;
+    return std::sqrt(dl * dl + da * da + db * db);
+}
+
+int ChromaStack::relief_layers() const
+{
+    int n = 0;
+    for (const ChromaBand &band : bands)
+        n += std::max(0, band.layers);
+    return n;
+}
+
+int ChromaStack::total_layers() const { return std::max(0, base_layers) + relief_layers(); }
+
+float ChromaStack::depth_mm() const { return float(relief_layers()) * layer_height_mm; }
+
+std::vector<ColorRGB> chroma_palette(const ChromaStack &stack)
+{
+    const int total = stack.total_layers();
+    // No bands means no picture and no filament to print the base in, whatever base_layers says.
+    if (total <= 0 || stack.bands.empty() || stack.layer_height_mm <= 0.f)
+        return {};
+
+    // The filament each printed layer is in, bottom-up: the base first, in the bottom band's filament,
+    // then the bands themselves.
+    std::vector<const ChromaFilament *> per_layer;
+    per_layer.reserve(size_t(total));
+    for (int i = 0; i < std::max(0, stack.base_layers); ++i)
+        per_layer.push_back(&stack.bands.front().filament);
+    for (const ChromaBand &band : stack.bands)
+        for (int i = 0; i < band.layers; ++i)
+            per_layer.push_back(&band.filament);
+
+    std::vector<ColorRGB> palette(size_t(total) + 1);
+
+    // Linear light, walking up from an opaque base: C_0 is the bottom layer's own colour, so a
+    // column one layer tall comes out exactly that colour however translucent the filament is.
+    std::array<float, 3> acc{ srgb_to_linear(per_layer.front()->color.r()), srgb_to_linear(per_layer.front()->color.g()),
+                              srgb_to_linear(per_layer.front()->color.b()) };
+    auto                 store = [&palette](size_t k, const std::array<float, 3> &lin) {
+        palette[k] = ColorRGB(std::clamp(linear_to_srgb(lin[0]), 0.f, 1.f), std::clamp(linear_to_srgb(lin[1]), 0.f, 1.f),
+                              std::clamp(linear_to_srgb(lin[2]), 0.f, 1.f));
+    };
+    store(0, acc);
+
+    for (int k = 1; k <= total; ++k) {
+        const ChromaFilament &f  = *per_layer[size_t(k - 1)];
+        const float             td = std::clamp(f.td_mm, TD_MIN_MM, TD_MAX_MM);
+        // The depth at which this filament hides what is behind it, turned into the e-folding length
+        // of its absorption; see CHROMA_TD_OPAQUE_FRACTION.
+        const float efold = CHROMA_TD_OPAQUE_FRACTION * td / OPAQUE_EFOLDS;
+        const float t     = std::exp(-stack.layer_height_mm / efold);
+        const std::array<float, 3> own{ srgb_to_linear(f.color.r()), srgb_to_linear(f.color.g()),
+                                        srgb_to_linear(f.color.b()) };
+        for (int c = 0; c < 3; ++c)
+            acc[size_t(c)] = (1.f - t) * own[size_t(c)] + t * acc[size_t(c)];
+        store(size_t(k), acc);
+    }
+    return palette;
+}
+
+ChromaSolve chroma_solve(const uint8_t *rgb, int width, int height, const ChromaStack &stack)
+{
+    ChromaSolve solve;
+    const int     total  = stack.total_layers();
+    const int     base   = std::max(0, stack.base_layers);
+    const int     relief = stack.relief_layers();
+    if (rgb == nullptr || width <= 0 || height <= 0 || relief <= 0 || relief > CHROMA_MAX_RELIEF_LAYERS)
+        return solve;
+
+    const std::vector<ColorRGB> palette = chroma_palette(stack);
+    if (int(palette.size()) != total + 1)
+        return solve;
+
+    // Only the heights the solver may choose: base (nothing of the relief printed) up to total.
+    const int               choices = relief + 1;
+    const size_t                        choice_count = size_t(choices);
+    std::vector<Lab>                    choice_lab(choice_count);
+    std::vector<std::array<uint8_t, 3>> choice_rgb(choice_count);
+    for (int i = 0; i < choices; ++i) {
+        const ColorRGB &c = palette[size_t(base + i)];
+        choice_lab[size_t(i)] = srgb_to_lab(c.r(), c.g(), c.b());
+        choice_rgb[size_t(i)] = { uint8_t(std::lround(c.r() * 255.f)), uint8_t(std::lround(c.g() * 255.f)),
+                                  uint8_t(std::lround(c.b() * 255.f)) };
+    }
+
+    const size_t count = size_t(width) * size_t(height);
+    solve.width        = width;
+    solve.height       = height;
+    solve.levels.resize(count);
+    solve.grey.resize(count);
+    solve.preview.resize(count * 3);
+
+    std::vector<float> errors(count, 0.f);
+
+    auto pick = [&](float r, float g, float b, float &out_error) {
+        const Lab target = srgb_to_lab(std::clamp(r, 0.f, 1.f), std::clamp(g, 0.f, 1.f), std::clamp(b, 0.f, 1.f));
+        int       best   = 0;
+        float     best_d = std::numeric_limits<float>::max();
+        for (int i = 0; i < choices; ++i) {
+            const float d = delta_e(target, choice_lab[size_t(i)]);
+            if (d < best_d) {
+                best_d = d;
+                best   = i;
+            }
+        }
+        out_error = best_d;
+        return best;
+    };
+
+    // The grey level a chosen height is written as. Rounded to the nearest of 256 levels, which for
+    // any practical layer budget (a few dozen) maps every height to its own level exactly - the
+    // relief's steps stay on layer boundaries, which is the whole point of quantizing here.
+    auto grey_of = [relief](int choice) {
+        return uint8_t(std::lround(255.0 * double(choice) / double(relief)));
+    };
+
+    auto write = [&](size_t px, int choice, float err) {
+        solve.levels[px]        = uint16_t(base + choice);
+        solve.grey[px]          = grey_of(choice);
+        solve.preview[px * 3]     = choice_rgb[size_t(choice)][0];
+        solve.preview[px * 3 + 1] = choice_rgb[size_t(choice)][1];
+        solve.preview[px * 3 + 2] = choice_rgb[size_t(choice)][2];
+        errors[px]              = err;
+    };
+
+    if (stack.dither) {
+        // Floyd-Steinberg, serpentine so the error does not drift consistently to one side. The
+        // diffusion buffer holds the two rows the kernel reaches, in sRGB - which is where the
+        // artifact being traded away lives, and what every reference implementation diffuses in.
+        const size_t                      row_len = size_t(width);
+        std::vector<std::array<float, 3>> row(row_len), next(row_len);
+        for (int x = 0; x < width; ++x) {
+            const uint8_t *src = rgb + size_t(x) * 3;
+            row[size_t(x)]     = { src[0] / 255.f, src[1] / 255.f, src[2] / 255.f };
+        }
+        for (int y = 0; y < height; ++y) {
+            if (y + 1 < height)
+                for (int x = 0; x < width; ++x) {
+                    const uint8_t *src = rgb + (size_t(y + 1) * size_t(width) + size_t(x)) * 3;
+                    next[size_t(x)]    = { src[0] / 255.f, src[1] / 255.f, src[2] / 255.f };
+                }
+            const bool ltr = (y % 2) == 0;
+            for (int i = 0; i < width; ++i) {
+                const int    x  = ltr ? i : width - 1 - i;
+                const size_t px = size_t(y) * size_t(width) + size_t(x);
+                float        err = 0.f;
+                const int    choice = pick(row[size_t(x)][0], row[size_t(x)][1], row[size_t(x)][2], err);
+                write(px, choice, err);
+
+                std::array<float, 3> residual{};
+                for (int c = 0; c < 3; ++c)
+                    residual[size_t(c)] = row[size_t(x)][size_t(c)] - choice_rgb[size_t(choice)][size_t(c)] / 255.f;
+
+                const int  ahead = ltr ? x + 1 : x - 1;
+                const int  back  = ltr ? x - 1 : x + 1;
+                auto spread = [&](std::vector<std::array<float, 3>> &dst, int at, float w) {
+                    if (at < 0 || at >= width)
+                        return;
+                    for (int c = 0; c < 3; ++c)
+                        dst[size_t(at)][size_t(c)] += residual[size_t(c)] * w;
+                };
+                spread(row, ahead, 7.f / 16.f);
+                if (y + 1 < height) {
+                    spread(next, back, 3.f / 16.f);
+                    spread(next, x, 5.f / 16.f);
+                    spread(next, ahead, 1.f / 16.f);
+                }
+            }
+            row.swap(next);
+        }
+    } else {
+        tbb::parallel_for(tbb::blocked_range<int>(0, height), [&](const tbb::blocked_range<int> &range) {
+            for (int y = range.begin(); y < range.end(); ++y)
+                for (int x = 0; x < width; ++x) {
+                    const size_t   px  = size_t(y) * size_t(width) + size_t(x);
+                    const uint8_t *src = rgb + px * 3;
+                    float          err = 0.f;
+                    write(px, pick(src[0] / 255.f, src[1] / 255.f, src[2] / 255.f, err), err);
+                }
+        });
+    }
+
+    solve.mean_delta_e = count == 0 ? 0. : std::accumulate(errors.begin(), errors.end(), 0.) / double(count);
+    solve.max_delta_e  = errors.empty() ? 0. : double(*std::max_element(errors.begin(), errors.end()));
+    return solve;
+}
+
+float chroma_layers_to_opaque(float td_mm, float layer_height_mm)
+{
+    if (layer_height_mm <= 0.f)
+        return 0.f;
+    return CHROMA_TD_OPAQUE_FRACTION * std::clamp(td_mm, TD_MIN_MM, TD_MAX_MM) / layer_height_mm;
+}
+
+// Below about one dE two colours are the same colour to the eye. Half of that is the threshold for
+// "this layer changed something", so a step has to be comfortably invisible before a layer is called
+// wasted.
+static constexpr float VISIBLE_DE = 0.5f;
+
+static float step_delta_e(const ColorRGB &a, const ColorRGB &b)
+{
+    return delta_e(srgb_to_lab(a.r(), a.g(), a.b()), srgb_to_lab(b.r(), b.g(), b.b()));
+}
+
+int chroma_distinct_levels(const ChromaStack &stack)
+{
+    const std::vector<ColorRGB> palette = chroma_palette(stack);
+    const int                   base    = std::max(0, stack.base_layers);
+    if (int(palette.size()) <= base + 1)
+        return 0;
+    int n = 0;
+    for (size_t i = size_t(base) + 1; i < palette.size(); ++i)
+        if (step_delta_e(palette[i - 1], palette[i]) > VISIBLE_DE)
+            ++n;
+    return n;
+}
+
+void chroma_trim_bands(ChromaStack &stack)
+{
+    // Walked over the stack's own palette rather than over the filaments' TD, because how fast a band
+    // runs out of anything to say depends on what is under it as much as on the filament. A light band
+    // over a dark one is finished in four or five layers; a dark one over a light one goes on paying
+    // for many more, long past the depth at which it is nominally opaque, because the last few percent
+    // of light coming through still moves a near-black colour perceptibly.
+    const std::vector<ColorRGB> palette = chroma_palette(stack);
+    if (palette.empty())
+        return;
+    int layer = std::max(0, stack.base_layers); // palette index of the layer under the band being looked at
+    for (ChromaBand &band : stack.bands) {
+        int keep = 1;
+        for (int i = 1; i <= band.layers; ++i) {
+            const size_t cur = size_t(layer) + size_t(i);
+            if (cur >= palette.size())
+                break;
+            if (step_delta_e(palette[cur - 1], palette[cur]) > VISIBLE_DE)
+                keep = i; // the last layer of this band that still changes the colour
+        }
+        layer += band.layers;
+        band.layers = std::clamp(keep, 1, band.layers);
+    }
+}
+
+int chroma_level_at(const ChromaStack &stack, double z_mm)
+{
+    const int total = stack.total_layers();
+    if (total <= 0 || stack.layer_height_mm <= 0.f)
+        return 0;
+    // Layer k occupies ((k-1)h, k h], so a point inside it rounds up. The epsilon keeps a surface
+    // sitting exactly on a layer boundary in the layer that printed it rather than in the one above,
+    // which is the difference between a terrace showing its own colour and showing the next band's.
+    const int k = int(std::ceil(z_mm / double(stack.layer_height_mm) - 1e-6));
+    return std::clamp(k, 1, total);
+}
+
+std::vector<unsigned char> chroma_encode_height_png(const ChromaSolve &solve)
+{
+    if (solve.empty())
+        return {};
+    size_t      size = 0;
+    void       *png  = tdefl_write_image_to_png_file_in_memory_ex(solve.grey.data(), solve.width, solve.height, 1, &size,
+                                                                  MZ_DEFAULT_LEVEL, MZ_FALSE);
+    if (png == nullptr || size == 0)
+        return {};
+    const unsigned char       *bytes = static_cast<const unsigned char *>(png);
+    std::vector<unsigned char> out(bytes, bytes + size);
+    mz_free(png);
+    return out;
+}
+
+std::vector<ChromaRange> chroma_ranges(const ChromaStack &stack, double z_bottom)
+{
+    std::vector<ChromaRange> out;
+    if (stack.layer_height_mm <= 0.f)
+        return out;
+    // The layer height is stored as a float, like every other dimension of a texture displacement
+    // layer, so multiplying it up leaves noise in the last few digits - 5 layers of 0.1 mm come out as
+    // 0.5000000074. The slicer derives its own layer boundaries from the print config in double
+    // precision and lands on 0.5 exactly, and a boundary that misses it by any amount is a boundary a
+    // layer can fall on the wrong side of. Rounding to the nanometre removes the noise without
+    // disturbing any layer height a profile can express.
+    const auto snap = [](double z) { return std::round(z * 1e6) / 1e6; };
+
+    // The base is printed in the bottom band's filament - it is what is loaded when the print starts -
+    // so it extends that band's range down to the first layer instead of being a swap of its own.
+    int  layer = std::max(0, stack.base_layers);
+    bool first = true;
+    for (const ChromaBand &band : stack.bands) {
+        if (band.layers <= 0)
+            continue;
+        const double z_min = snap(z_bottom + (first ? 0. : double(layer) * double(stack.layer_height_mm)));
+        first = false;
+        layer += band.layers;
+        const double z_max = snap(z_bottom + double(layer) * double(stack.layer_height_mm));
+        if (!out.empty() && out.back().filament == band.filament.filament)
+            out.back().z_max = z_max; // no swap happens here, so it is one range
+        else
+            out.push_back(ChromaRange{ z_min, z_max, band.filament.filament });
+    }
+    return out;
+}
+
+ChromaStack chroma_default_stack(const std::vector<ChromaFilament> &filaments, float layer_height_mm,
+                                     int base_layers, int relief_layers)
+{
+    ChromaStack stack;
+    stack.layer_height_mm = layer_height_mm > 0.f ? layer_height_mm : 0.08f;
+    stack.base_layers     = std::max(0, base_layers);
+    if (filaments.empty() || relief_layers <= 0)
+        return stack;
+
+    std::vector<ChromaFilament> ordered = filaments;
+    std::stable_sort(ordered.begin(), ordered.end(), [](const ChromaFilament &a, const ChromaFilament &b) {
+        // Relative luminance of the linear colour: the perceptual order, so a saturated yellow
+        // counts as light and a saturated blue as dark, which a plain r+g+b sum gets wrong.
+        auto lum = [](const ColorRGB &c) {
+            return 0.2126f * srgb_to_linear(c.r()) + 0.7152f * srgb_to_linear(c.g()) + 0.0722f * srgb_to_linear(c.b());
+        };
+        return lum(a.color) > lum(b.color);
+    });
+
+    const int count = int(ordered.size());
+    int       left  = relief_layers;
+    for (int i = 0; i < count; ++i) {
+        // Spread the remainder over the first bands rather than piling it onto the last one.
+        const int share = left / (count - i) + ((left % (count - i)) > 0 ? 1 : 0);
+        ChromaBand band;
+        band.filament = ordered[size_t(i)];
+        band.layers   = std::max(1, share);
+        left -= share;
+        stack.bands.push_back(band);
+    }
+    return stack;
+}
+
+} // namespace Slic3r

src/libslic3r/ChromaStack.hpp

@@ -0,0 +1,286 @@
+#ifndef slic3r_ChromaStack_hpp_
+#define slic3r_ChromaStack_hpp_
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include <cereal/cereal.hpp>
+#include <cereal/types/vector.hpp>
+
+#include "Color.hpp"
+
+namespace Slic3r {
+
+// ChromaStack-style colour printing: a picture is reproduced on a single face by stacking thin layers
+// of a few filaments, swapping filament at fixed layer boundaries, and varying the *height* of each
+// pixel's column. Where the column is low, the layers above it are missing and the filament below
+// shows; where it is high, the topmost filament covers everything beneath it. Because filament is
+// translucent, a column that stops part-way through a run shows a blend of that run's filament and
+// what is under it, which is what gives far more colours than there are filaments loaded.
+//
+// So there are only two things to compute, and they are both here:
+//  - the *palette*: the colour the stack shows at every possible column height (chroma_palette());
+//  - the *height map*: per pixel, the column height whose palette colour is closest to the picture
+//    (chroma_solve()).
+//
+// Everything else is machinery that already exists. The height map is handed to a texture
+// displacement layer as its height texture, so the existing projection/preview/bake pipeline turns
+// it into real geometry (see TextureDisplacement.hpp), and the filament swaps are handed to the
+// object's height ranges (ModelObject::layer_config_ranges), which is the slicer's own way of
+// saying "print this Z band with that filament".
+
+// The depth of filament that blocks essentially all the light behind it, as a fraction of the
+// filament's transmission distance (TD).
+//
+// TD's scale is empirical, not physical: its values run from about 1
+// for an opaque filament to 10 and above for a nearly clear one, and the community's calibration
+// prints (the "seashell" step test) read a TD off the step where the colour beneath stops showing.
+// That step is about a tenth of the TD number, which is the only thing this constant encodes - a
+// filament of TD 2 stops hiding what is under it at roughly 0.2 mm, i.e. after two or three layers,
+// while one of TD 8 needs most of a millimetre. The model below turns that into a per-layer
+// transmittance; see chroma_palette().
+static constexpr float CHROMA_TD_OPAQUE_FRACTION = 0.1f;
+
+// What a fresh stack gets above the base. Twenty-four layers is about two millimetres at a fine layer
+// height: enough steps for a continuous tonal ramp, and still a print that finishes in an evening.
+static constexpr int CHROMA_DEFAULT_RELIEF_LAYERS = 24;
+
+// The most picture layers the solve can express. A column's height above the base is stored as one
+// byte per pixel in the 8-bit grayscale height map the displacement reads, so beyond this two
+// different heights would have to share a grey level and the relief's steps would stop landing on
+// layer boundaries - which is the one thing the quantization exists to guarantee.
+//
+// It bounds the bands, not the stack: the base is whatever the model already is under the painted
+// face, often hundreds of layers on a tall part, and nothing about it is quantized into the height
+// map. As a limit on the picture it is not one in practice - 255 layers is 20 mm of relief at
+// 0.08 mm, far past where a picture gains anything.
+static constexpr int CHROMA_MAX_RELIEF_LAYERS = 255;
+
+// The most filament changes one stack may hold. Every band is a swap the printer has to make, so this is
+// a limit on patience rather than on the model; the palette itself is bounded by the layer count.
+static constexpr size_t CHROMA_MAX_BANDS = 16;
+
+// One filament as the colour model sees it: what colour it is, and how far light gets into it.
+struct ChromaFilament
+{
+    // 0-based index into the project's filaments, which is what a height range's `extruder` option
+    // (1-based) is written from. -1 for a filament that is not loaded, which the GUI refuses to
+    // solve with rather than silently printing in the wrong colour.
+    int      filament = -1;
+    ColorRGB color;
+    // The filament preset's own name, so the panel can say which filament this is. Six similar greys
+    // are six identical swatches and six identical numbers otherwise. Stored rather than looked up on
+    // demand because a stack outlives the project's filament list - a preset can be swapped out from
+    // under a saved stack, and then the name is the only record of what it was solved against.
+    std::string name;
+    // Transmission distance, mm, as the filament preset reports it
+    // (`filament_transmission_distance`). Clamped to a sane range when the palette is built: zero
+    // would make a layer infinitely opaque and a negative value is meaningless.
+    float    td_mm = 4.f;
+
+    template<class Archive> void serialize(Archive &ar)
+    {
+        float r = color.r(), g = color.g(), b = color.b();
+        ar(filament, r, g, b, td_mm, name);
+        color = ColorRGB(r, g, b);
+    }
+};
+
+// A run of consecutive layers printed in one filament. The stack is a list of these, bottom-up, so
+// a band boundary is exactly where the print pauses and the filament is changed.
+struct ChromaBand
+{
+    ChromaFilament filament;
+    int              layers = 1;
+
+    template<class Archive> void serialize(Archive &ar) { ar(filament, layers); }
+};
+
+// The whole recipe: which filaments, in which order, how thick a layer is, and how much of the
+// bottom is solid backing rather than picture.
+struct ChromaStack
+{
+    std::vector<ChromaBand> bands; // bottom-up; bands.front() is the one the base is printed in
+
+    // The print's layer height, mm. Taken from the print profile rather than chosen here - a stack
+    // solved against 0.08 mm layers prints as the wrong picture at 0.2 mm, so the GUI re-solves when
+    // the profile's layer height changes.
+    float layer_height_mm = 0.08f;
+
+    // Layers of solid backing under the picture: everything the model already is below the painted
+    // face. Not part of any band - the bands are the picture - but printed in the bottom band's
+    // filament, since that is what is loaded when the print starts.
+    //
+    // Keeping it out of the bands is what lets it be what it really is: a measurement of the model,
+    // often a hundred layers or more, while a band is a handful. Folding the two together put a
+    // three-digit number on a slider meant for single digits and made "how thick is the backing" and
+    // "how many layers does the first filament get" the same control, which they are not.
+    //
+    // The colour model treats the base as opaque. That is what makes a column's colour depend only on
+    // the layers above it, and why the panel warns about a base thin enough to let the plate show
+    // through.
+    int  base_layers = 4;
+
+    // Whether `base_layers` follows the model or was typed in. It follows by default, and it should:
+    // the painted face is wherever the geometry puts it, and a base that disagrees with it shifts
+    // every colour in the picture - the stack ends up anchored at the bottom of the part instead of
+    // under the face, so the picture's whole range is squeezed into the first few millimetres and
+    // everything above it clamps to the top band.
+    //
+    // It cannot be measured once and left: a layer is created, and its picture chosen, before there
+    // is any paint to measure, and the face moves again whenever the part is scaled or the layer
+    // height changes. So the panel re-measures it every frame while this is set.
+    bool base_auto = true;
+
+    // Spread the quantization error into neighbouring pixels (Floyd-Steinberg, serpentine) instead
+    // of rounding each pixel to its nearest palette colour on its own. A palette of twenty or thirty
+    // colours has to cover a photograph's whole range, so plain rounding leaves visible bands across
+    // a sky or a cheek; diffusing the error trades them for fine stipple, which at a tenth of a
+    // millimetre per pixel reads as the intermediate colour. Off for flat-coloured artwork, where
+    // stipple is the artifact rather than the cure.
+    bool dither = false;
+
+    // Total printed layers, base included: what the tallest column is.
+    int  total_layers() const;
+    // Layers the picture is built from, i.e. the bands' own total above the base.
+    int  relief_layers() const;
+    // The relief's height in mm, which is the `depth_mm` of the texture displacement layer the
+    // height map is handed to.
+    float depth_mm() const;
+    bool  empty() const { return bands.empty(); }
+
+    template<class Archive> void serialize(Archive &ar) { ar(bands, layer_height_mm, base_layers, dither, base_auto); }
+};
+
+// The colour the stack shows at every column height: entry k is a column of exactly k printed
+// layers, so the vector has total_layers() + 1 entries.
+//
+// The model is Beer-Lambert absorption, layer by layer. A layer of thickness h in a filament of
+// transmission distance TD passes
+//
+//     T = exp(-h / (CHROMA_TD_OPAQUE_FRACTION * TD / 3))
+//
+// of the light coming from under it and shows its own colour with the rest, so
+//
+//     C_k = (1 - T_k) * c_k + T_k * C_(k-1)
+//
+// walking up from an opaque base, C_0 = c_1. The divisor is what makes "opaque at
+// CHROMA_TD_OPAQUE_FRACTION * TD" true: three e-folding lengths pass 5% of the light, which is
+// where the colour beneath stops being visible to the eye.
+//
+// Beer-Lambert is not just the physically honest choice here, it is the only one that stays
+// consistent when applied per layer: transmittance multiplies, so a run of n layers of one filament
+// passes exp(-n h / d) whether it is composited in one step or n, and the palette does not depend on
+// how the stack happens to be cut into bands.
+//
+// Compositing is done on linear light and the entries are converted back to sRGB, because the
+// quantity being attenuated is light, not an sRGB code.
+std::vector<ColorRGB> chroma_palette(const ChromaStack &stack);
+
+// What chroma_solve() produced.
+struct ChromaSolve
+{
+    int width  = 0;
+    int height = 0;
+
+    // Per pixel, row-major and top-to-bottom like DecodedHeightTexture: the column's printed layer
+    // count, between base_layers and total_layers(). Sixteen bits because it counts from the build
+    // plate, and the base alone can be several hundred layers on a tall part.
+    std::vector<uint16_t> levels;
+    // The same thing as the 8-bit grayscale height map the displacement samples: 0 at base_layers,
+    // 255 at total_layers(). This is what gets encoded as a PNG into the layer's `image_data`, which
+    // is why the solve has to be the thing that owns the quantization - the relief's steps have to
+    // land on layer boundaries, and a grey level is the only channel the displacement reads.
+    std::vector<uint8_t> grey;
+    // Per pixel RGB: the palette colour the solve chose, i.e. what the print is predicted to look
+    // like. Shown in the panel next to the source picture, since the 3D view can only show the
+    // relief - the colours do not exist until the print swaps filament.
+    std::vector<uint8_t> preview;
+
+    // How far the prediction landed from the picture, as a mean and worst-case CIE76 dE over all
+    // pixels. The panel reports it because it is the only honest answer to "will this stack
+    // reproduce my image": under about 5 is a good match, over about 15 means the filaments cannot
+    // reach the picture's colours and no amount of layers will fix it.
+    double mean_delta_e = 0.;
+    double max_delta_e  = 0.;
+
+    bool empty() const { return width <= 0 || height <= 0 || levels.empty(); }
+};
+
+// Solves `rgb` (width * height * 3 bytes, row-major, top-to-bottom) against the stack's palette.
+// An empty stack, a zero-sized image or a stack with no relief layers gives an empty result.
+ChromaSolve chroma_solve(const uint8_t *rgb, int width, int height, const ChromaStack &stack);
+
+// How many layers of this filament it takes to hide what is under it, at this layer height. The
+// single most useful number about a stack and the one nothing else makes visible: it is what decides
+// whether a band is a gradient or a step.
+//
+// A filament hides what is behind it at about CHROMA_TD_OPAQUE_FRACTION of its TD (see
+// chroma_palette()), so this is that depth in layers. Below two the band has no intermediate colours
+// at all - the picture can only use the filament or not use it - which is what a coarse layer height
+// does to an otherwise good stack: TD 4 at 0.2 mm covers in two layers, the same filament at 0.08 mm
+// in five.
+float chroma_layers_to_opaque(float td_mm, float layer_height_mm);
+
+// How many of the picture's layers actually change the colour.
+//
+// A band eventually stops saying anything: once it hides what is under it, another layer of it shows
+// the colour the one below already showed. Those layers still cost print time and still take up
+// relief height, and nothing about the stack makes them visible - the band looks like ten layers of
+// gradient and is, say, five of gradient and five of flat.
+//
+// Measured against the palette rather than against TD, because how long a band keeps paying depends
+// on what is under it as much as on the filament: a light band over a dark one is finished in four or
+// five layers, while a dark one over a light one goes on moving the colour perceptibly well past the
+// depth at which it is nominally opaque.
+int chroma_distinct_levels(const ChromaStack &stack);
+
+// Shortens every band to its last layer that still changes the colour. Bands already shorter than
+// that are left alone: they are still inside their fade, where every layer counts.
+void chroma_trim_bands(ChromaStack &stack);
+
+// The printed layer a point `z_mm` above the bottom of the object falls in: 1-based, clamped to the
+// stack, 0 for a stack that prints nothing. Pair it with chroma_palette() to get the colour shown
+// there.
+//
+// This, rather than the height map, is what decides the colour a surface shows. A filament swap
+// happens at one print Z across the whole plate, so every surface crossing that height changes colour
+// whatever the picture says - the terraces of the relief, the walls between them, and the sides of the
+// model alike. Colouring a preview this way is therefore not an approximation of the print; it is what
+// the print does, and it keeps working after the relief has been baked into the mesh and the height
+// map is no longer attached to anything on screen.
+int chroma_level_at(const ChromaStack &stack, double z_mm);
+
+// The solve's height map as an 8-bit grayscale PNG, ready to be stored in a
+// TextureDisplacementLayer's `image_data`.
+std::vector<unsigned char> chroma_encode_height_png(const ChromaSolve &solve);
+
+// One filament swap as an object height range: the Z band, in the object's own coordinates (0 at its
+// bottom), that prints in `filament` (0-based).
+struct ChromaRange
+{
+    double z_min = 0.;
+    double z_max = 0.;
+    int    filament = -1;
+};
+
+// The stack's bands as height ranges, in object coordinates, starting at `z_bottom` (which is 0 for
+// a stack whose base starts at the object's first layer). Bands printed in the same filament as the
+// band below are merged, so a stack that repeats a filament does not produce a pointless swap.
+std::vector<ChromaRange> chroma_ranges(const ChromaStack &stack, double z_bottom = 0.);
+
+// A starting point for a stack: the given filaments, lightest at the bottom, each with an equal
+// share of `relief_layers` on top of `base_layers`.
+//
+// Light-to-dark is the convention filament-painting guides teach, and it is not arbitrary: a dark
+// filament over a light one reads as a midtone at one or two layers and as the dark colour at four,
+// so putting the dark filaments last is what buys the long tonal ramp. The reverse order gives a few
+// washed-out steps and then nothing.
+ChromaStack chroma_default_stack(const std::vector<ChromaFilament> &filaments, float layer_height_mm,
+                                     int base_layers, int relief_layers);
+
+} // namespace Slic3r
+
+#endif // slic3r_ChromaStack_hpp_

src/libslic3r/GCode.cpp

@@ -3985,16 +3985,6 @@ void GCode::_do_export(Print& print, GCodeOutputStream &file, ThumbnailsGenerato
     this->placeholder_parser().set("print_time_minute", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Print_Time_Minute_Placeholder)));
     this->placeholder_parser().set("print_time_sec", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Print_Time_Sec_Placeholder)));
     this->placeholder_parser().set("used_filament_length", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Used_Filament_Length_Placeholder)));
-    // The final print statistics are known only after the whole G-code is generated, so they are filled in during post-processing too.
-    // The running extruded_* totals are left alone; profiles use them as numbers.
-    this->placeholder_parser().set("used_filament", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Used_Filament_Length_Placeholder)));
-    this->placeholder_parser().set("print_time", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Normal_Print_Time_Placeholder)));
-    this->placeholder_parser().set("normal_print_time", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Normal_Print_Time_Placeholder)));
-    this->placeholder_parser().set("silent_print_time", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Silent_Print_Time_Placeholder)));
-    this->placeholder_parser().set("total_weight", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Total_Weight_Placeholder)));
-    this->placeholder_parser().set("total_cost", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Total_Cost_Placeholder)));
-    this->placeholder_parser().set("total_wipe_tower_cost", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Total_Wipe_Tower_Cost_Placeholder)));
-    this->placeholder_parser().set("total_wipe_tower_filament", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Total_Wipe_Tower_Filament_Placeholder)));
 
     // Sync variant-mapped params into placeholder_parser before processing start gcode
     update_placeholder_parser_with_variant_params();

src/libslic3r/GCode/GCodeProcessor.cpp

@@ -120,13 +120,7 @@ const std::vector<std::string> GCodeProcessor::Reserved_Tags = {
     "@PRINT_TIME_HOUR@",
     "@PRINT_TIME_MINUTE@",
     "@PRINT_TIME_SEC@",
-    "@USED_FILAMENT_LENGTH@",
-    "@NORMAL_PRINT_TIME@",
-    "@SILENT_PRINT_TIME@",
-    "@TOTAL_WEIGHT@",
-    "@TOTAL_COST@",
-    "@TOTAL_WIPE_TOWER_COST@",
-    "@TOTAL_WIPE_TOWER_FILAMENT@"
+    "@USED_FILAMENT_LENGTH@"
 };
 
 const std::vector<std::string> GCodeProcessor::Reserved_Tags_compatible = {
@@ -153,13 +147,7 @@ const std::vector<std::string> GCodeProcessor::Reserved_Tags_compatible = {
     "@PRINT_TIME_HOUR@",
     "@PRINT_TIME_MINUTE@",
     "@PRINT_TIME_SEC@",
-    "@USED_FILAMENT_LENGTH@",
-    "@NORMAL_PRINT_TIME@",
-    "@SILENT_PRINT_TIME@",
-    "@TOTAL_WEIGHT@",
-    "@TOTAL_COST@",
-    "@TOTAL_WIPE_TOWER_COST@",
-    "@TOTAL_WIPE_TOWER_FILAMENT@"
+    "@USED_FILAMENT_LENGTH@"
 };
 
 
@@ -1276,22 +1264,19 @@ void GCodeProcessor::run_post_process()
         return ret;
     };
 
-    // Process inline placeholders (print_time_*, used_filament_length and the print statistics known only after export)
+    // Process inline placeholders (print_time_total_sec, print_time_day, print_time_hour, print_time_minute, print_time_sec and used_filament_length)
     auto process_inline_placeholders = [&](std::string& gcode_line) {
         bool processed = false;
         // Every inline placeholder contains '@', so a line without one has nothing to replace.
         if (gcode_line.find('@') == std::string::npos)
             return processed;
 
-        auto replace_tag = [&gcode_line, &processed](ETags tag, const std::string& value) {
-            const std::string& placeholder = reserved_tag(tag);
-            size_t pos = gcode_line.find(placeholder);
-            while (pos != std::string::npos) {
-                gcode_line.replace(pos, placeholder.length(), value);
-                processed = true;
-                pos = gcode_line.find(placeholder, pos + value.length());
-            }
-        };
+        const std::string& print_time_total_placeholder = reserved_tag(ETags::Print_Time_Total_Sec_Placeholder);
+        const std::string& print_time_day_placeholder = reserved_tag(ETags::Print_Time_Day_Placeholder);
+        const std::string& print_time_hour_placeholder = reserved_tag(ETags::Print_Time_Hour_Placeholder);
+        const std::string& print_time_minute_placeholder = reserved_tag(ETags::Print_Time_Minute_Placeholder);
+        const std::string& print_time_sec_placeholder = reserved_tag(ETags::Print_Time_Sec_Placeholder);
+        const std::string& used_filament_placeholder = reserved_tag(ETags::Used_Filament_Length_Placeholder);
 
         double print_time_total_sec = m_time_processor.machines[static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Normal)].time;
         if (print_time_total_sec < 0.0)
@@ -1304,31 +1289,70 @@ void GCodeProcessor::run_post_process()
         int print_time_minute = (day_remainder_seconds % 3600) / 60;
         int print_time_sec = day_remainder_seconds % 60;
 
-        double total_filament_mm = 0.0;
-        for (const auto& mm : filament_mm) {
-            total_filament_mm += mm;
+        // Replace print_time_total_sec
+        size_t pos = gcode_line.find(print_time_total_placeholder);
+        while (pos != std::string::npos) {
+            char buf[64];
+            sprintf(buf, "%.2f", print_time_total_sec);
+            gcode_line.replace(pos, print_time_total_placeholder.length(), buf);
+            processed = true;
+            pos = gcode_line.find(print_time_total_placeholder, pos + strlen(buf));
         }
 
-        replace_tag(ETags::Print_Time_Total_Sec_Placeholder, Slic3r::float_to_string_decimal_point(print_time_total_sec, 2));
-        replace_tag(ETags::Print_Time_Day_Placeholder, std::to_string(print_time_day));
-        replace_tag(ETags::Print_Time_Hour_Placeholder, std::to_string(print_time_hour));
-        replace_tag(ETags::Print_Time_Minute_Placeholder, std::to_string(print_time_minute));
-        replace_tag(ETags::Print_Time_Sec_Placeholder, std::to_string(print_time_sec));
-        replace_tag(ETags::Used_Filament_Length_Placeholder,
-                    Slic3r::float_to_string_decimal_point(total_filament_mm / 1000.0, 2)); // Convert mm to m
-        // Same values as the print statistics that filename_format gets (PrintStatistics::config(), filled in by
-        // update_print_estimated_stats() in GCode.cpp), which runs only after this post-processing.
-        replace_tag(ETags::Normal_Print_Time_Placeholder, get_time_dhm(PrintEstimatedStatistics::ETimeMode::Normal));
-        replace_tag(ETags::Silent_Print_Time_Placeholder, is_stealth_time_estimator_enabled() ?
-                                                              get_time_dhm(PrintEstimatedStatistics::ETimeMode::Stealth) :
-                                                              short_time("N/A"));
-        const double total_cost = filament_total_cost + m_print->config().time_cost.value * print_time_total_sec / 3600.0;
-        replace_tag(ETags::Total_Weight_Placeholder, Slic3r::float_to_string_decimal_point(filament_total_g, 2));
-        replace_tag(ETags::Total_Cost_Placeholder, Slic3r::float_to_string_decimal_point(total_cost, 2));
-        replace_tag(ETags::Total_Wipe_Tower_Cost_Placeholder,
-                    Slic3r::float_to_string_decimal_point(m_print->print_statistics().total_wipe_tower_cost, 2));
-        replace_tag(ETags::Total_Wipe_Tower_Filament_Placeholder,
-                    Slic3r::float_to_string_decimal_point(m_print->print_statistics().total_wipe_tower_filament, 2));
+        // Replace print_time_day
+        pos = gcode_line.find(print_time_day_placeholder);
+        while (pos != std::string::npos) {
+            char buf[64];
+            sprintf(buf, "%d", print_time_day);
+            gcode_line.replace(pos, print_time_day_placeholder.length(), buf);
+            processed = true;
+            pos = gcode_line.find(print_time_day_placeholder, pos + strlen(buf));
+        }
+
+        // Replace print_time_hour
+        pos = gcode_line.find(print_time_hour_placeholder);
+        while (pos != std::string::npos) {
+            char buf[64];
+            sprintf(buf, "%d", print_time_hour);
+            gcode_line.replace(pos, print_time_hour_placeholder.length(), buf);
+            processed = true;
+            pos = gcode_line.find(print_time_hour_placeholder, pos + strlen(buf));
+        }
+
+        // Replace print_time_minute
+        pos = gcode_line.find(print_time_minute_placeholder);
+        while (pos != std::string::npos) {
+            char buf[64];
+            sprintf(buf, "%d", print_time_minute);
+            gcode_line.replace(pos, print_time_minute_placeholder.length(), buf);
+            processed = true;
+            pos = gcode_line.find(print_time_minute_placeholder, pos + strlen(buf));
+        }
+
+        // Replace print_time_sec
+        pos = gcode_line.find(print_time_sec_placeholder);
+        while (pos != std::string::npos) {
+            char buf[64];
+            sprintf(buf, "%d", print_time_sec);
+            gcode_line.replace(pos, print_time_sec_placeholder.length(), buf);
+            processed = true;
+            pos = gcode_line.find(print_time_sec_placeholder, pos + strlen(buf));
+        }
+
+        // Replace used_filament_length
+        pos = gcode_line.find(used_filament_placeholder);
+        while (pos != std::string::npos) {
+            double total_filament_mm = 0.0;
+            for (const auto& mm : filament_mm) {
+                total_filament_mm += mm;
+            }
+            double used_filament_length = total_filament_mm / 1000.0; // Convert mm to m
+            char buf[64];
+            sprintf(buf, "%.2f", used_filament_length);
+            gcode_line.replace(pos, used_filament_placeholder.length(), buf);
+            processed = true;
+            pos = gcode_line.find(used_filament_placeholder, pos + strlen(buf));
+        }
 
         return processed;
     };

src/libslic3r/GCode/GCodeProcessor.hpp

@@ -601,12 +601,6 @@ inline constexpr float DEFAULT_FILAMENT_DENSITY = 1.245f;
             Print_Time_Minute_Placeholder,
             Print_Time_Sec_Placeholder,
             Used_Filament_Length_Placeholder,
-            Normal_Print_Time_Placeholder,
-            Silent_Print_Time_Placeholder,
-            Total_Weight_Placeholder,
-            Total_Cost_Placeholder,
-            Total_Wipe_Tower_Cost_Placeholder,
-            Total_Wipe_Tower_Filament_Placeholder,
         };
 
         static const std::string& reserved_tag(ETags tag) { return s_IsBBLPrinter ? Reserved_Tags[static_cast<unsigned char>(tag)] : Reserved_Tags_compatible[static_cast<unsigned char>(tag)]; }

src/libslic3r/PerimeterGenerator.cpp

@@ -62,12 +62,7 @@ public:
     // Depth in the hierarchy. External perimeter has depth = 0. An external perimeter could be both a contour and a hole.
     unsigned short                      depth;
     // ORCA: an external hole perimeter touching the next outer wall all around, with nothing between them.
-    // E.g. a 1mm tube wall with 0.5mm walls: 2 lines, the contour's outer wall and the hole's.
     bool                                is_thin_wall_hole = false;
-    // ORCA: an external hole perimeter with no room for an inner wall beside it, at most gap fill. Every thin wall
-    // hole is one, and so is e.g. a 1.5mm tube wall with 0.5mm walls: 3 lines, the two outer walls and gap fill
-    // between them. A 2mm tube wall has room for an inner wall a side and is not. Only set for Inner/Outer/Inner.
-    bool                                is_narrow_wall_hole = false;
     // Children contour, may be both CCW and CW oriented (outer contours or holes).
     std::vector<PerimeterGeneratorLoop> children;
 
@@ -577,8 +572,7 @@ static ExtrusionEntityCollection traverse_extrusions(const PerimeterGenerator& p
                 extrusion_coll.append(std::move(extrusion_loop));
                 // Orca: Reverse the order of paths for thin wall holes. We define thin wall hole as a hole with only one perimeter.
                 const bool thin_wall_hole = !pg_extrusion.is_contour && pg_extrusions.size() == 2;
-                if (thin_wall_hole && perimeter_generator.config->wall_sequence != WallSequence::OuterInner &&
-                    !perimeter_generator.outer_walls_first_for_brim())
+                if (thin_wall_hole && perimeter_generator.config->wall_sequence != WallSequence::OuterInner)
                     std::reverse(extrusion_coll.entities.begin(), extrusion_coll.entities.end());
             }
             else {
@@ -1696,24 +1690,13 @@ void PerimeterGenerator::process_classic()
 
                 last = std::move(offsets);
 
-                // ORCA: a thin wall hole has no room for gap fill or an inner wall anywhere beside its outer wall, a
-                // narrow wall hole none for an inner wall, the room the next loop is offset by below.
+                // ORCA: a thin wall hole has no room for gap fill or an inner wall anywhere beside its outer wall.
                 if (i == 0 && ! holes[0].empty()) {
-                    auto reach = [&last](double room) {
-                        return to_polygons(offset2_ex(last, -float(room), float(room) + float(SCALED_EPSILON)));
-                    };
-                    auto out_of_reach = [](const Polygon &hole, const Polygons &reach) {
-                        return intersection_pl(Polylines{ hole.split_at_first_point() },
-                            ClipperUtils::clip_clipper_polygons_with_subject_bbox(reach, get_extents(hole).inflated(SCALED_EPSILON))).empty();
-                    };
-                    // Only Inner/Outer/Inner orders narrow wall holes apart.
-                    const bool     narrow_holes_ordered = this->config->wall_sequence == WallSequence::InnerOuterInner;
-                    const Polygons gap_fill_reach       = reach(0.5 * (ext_perimeter_spacing2 + gap_fill_min_width));
-                    const Polygons inner_wall_reach     = narrow_holes_ordered ? reach(ext_perimeter_spacing2 + min_spacing / 2.) : Polygons();
-                    for (PerimeterGeneratorLoop &hole : holes[0]) {
-                        hole.is_thin_wall_hole   = out_of_reach(hole.polygon, gap_fill_reach);
-                        hole.is_narrow_wall_hole = narrow_holes_ordered && out_of_reach(hole.polygon, inner_wall_reach);
-                    }
+                    const float    room  = float(0.5 * (ext_perimeter_spacing2 + gap_fill_min_width));
+                    const Polygons reach = to_polygons(offset2_ex(last, -room, room + float(SCALED_EPSILON)));
+                    for (PerimeterGeneratorLoop &hole : holes[0])
+                        hole.is_thin_wall_hole = intersection_pl(Polylines{ hole.polygon.split_at_first_point() },
+                            ClipperUtils::clip_clipper_polygons_with_subject_bbox(reach, get_extents(hole.polygon).inflated(SCALED_EPSILON))).empty();
                 }
 
                 //BBS: refer to superslicer
@@ -1852,16 +1835,18 @@ void PerimeterGenerator::process_classic()
 
             // if brim will be printed, reverse the order of perimeters so that
             // we continue inwards after having finished the brim
+            // TODO: add test for perimeter order
             bool is_outer_wall_first = this->config->wall_sequence == WallSequence::OuterInner;
-            // Orca: a contour with only a narrow wall hole beside it has nothing to sandwich, and prints the hole first,
-            // then the contour, then the gap fill between them, as Arachne does.
-            const PerimeterGeneratorLoops &island_loops = contours.front();
-            const bool narrow_wall_hole_island = island_loops.size() == 1 && island_loops.front().children.size() == 1 &&
-                                                 island_loops.front().children.front().is_narrow_wall_hole;
-            if (is_outer_wall_first || this->outer_walls_first_for_brim())
+            if (is_outer_wall_first ||
+                //BBS: always print outer wall first when there indeed has brim.
+                // btLeadingEdgeOnly is an outer brim too (a belt brim at the part's first contact).
+                (this->layer_id == 0 &&
+                    (this->object_config->brim_type == BrimType::btOuterOnly ||
+                     this->object_config->brim_type == BrimType::btLeadingEdgeOnly) &&
+                    this->object_config->brim_width.value > 0))
                 entities.reverse();
             // Orca: sandwich mode. Apply after 1st layer.
-            else if ((this->config->wall_sequence == WallSequence::InnerOuterInner) && layer_id > 0 && !narrow_wall_hole_island){
+            else if ((this->config->wall_sequence == WallSequence::InnerOuterInner) && layer_id > 0){
                 entities.reverse(); // reverse all entities - order them from external to internal
                 if(entities.entities.size()>2){ // 3 walls minimum needed to do inner outer inner ordering
                     int position = 0; // index to run the re-ordering for multiple external perimeters in a single island.
@@ -2427,25 +2412,11 @@ std::vector<PerimeterGeneratorArachneExtrusion> reorderPerimetersByProximity(std
 
     // Function to reorder perimeters starting from a given reference index
     auto reorderFromReference = [&](int referenceIndex) {
-        // Find first level touching perimeters. The odd centre line of a wall too narrow for two inner walls is shared
-        // by the outer walls on both sides, so those join this island and are printed before it too, holes first.
-        std::vector<int> outerIndices{referenceIndex};
-        std::vector<int> firstLevelTouchingIndices;
-        for (size_t next = 0; next < outerIndices.size(); ++next)
-            for (int idx : findAllTouchingPerimeters(entities, {outerIndices[next]}, threshold_external, threshold_internal, 1)) {
-                if (std::find(firstLevelTouchingIndices.begin(), firstLevelTouchingIndices.end(), idx) != firstLevelTouchingIndices.end())
-                    continue;
-                firstLevelTouchingIndices.push_back(idx);
-                if (!entities[idx].extrusion->is_odd)
-                    continue;
-                for (size_t i = 0; i < entities.size(); ++i)
-                    if (entities[i].extrusion->inset_idx == 0 && includedIndices.count(int(i)) == 0 &&
-                        std::find(outerIndices.begin(), outerIndices.end(), int(i)) == outerIndices.end() &&
-                        arachne_lines_touch(*entities[i].extrusion, *entities[idx].extrusion, double(threshold_external)))
-                        outerIndices.push_back(int(i));
-            }
-        std::stable_partition(outerIndices.begin(), outerIndices.end(),
-                              [&entities](int idx) { return entities[idx].extrusion->is_closed && !entities[idx].is_contour; });
+        std::unordered_set<int> firstLevelIndices;
+        firstLevelIndices.insert(referenceIndex);
+
+        // Find first level touching perimeters
+        std::vector<int> firstLevelTouchingIndices = findAllTouchingPerimeters(entities, firstLevelIndices, threshold_external, threshold_internal, 1);
         // Bring the largest first level perimeter to the front
         // The longest first neighbour is most likely the dominant proximate perimeter
         // hence printing it immediately after the external perimeter should speed things up
@@ -2456,10 +2427,8 @@ std::vector<PerimeterGeneratorArachneExtrusion> reorderPerimetersByProximity(std
             std::iter_swap(maxIt, firstLevelTouchingIndices.end() - 1);
         }
         // Insert first level perimeters into reordered list
-        for (int idx : outerIndices) {
-            reordered.push_back(entities[idx]);
-            includedIndices.insert(idx);
-        }
+        reordered.push_back(entities[referenceIndex]);
+        includedIndices.insert(referenceIndex);
 
         for (int idx : firstLevelTouchingIndices) {
             if (includedIndices.count(idx) == 0) {
@@ -2788,7 +2757,7 @@ void PerimeterGenerator::process_arachne()
         
         if (layer_id == 0){ // disable inner outer inner algorithm after the first layer
         	is_outer_wall_first =
-            	this->config->wall_sequence == WallSequence::OuterInner || this->outer_walls_first_for_brim();
+            	this->config->wall_sequence == WallSequence::OuterInner;
         }
         if (is_outer_wall_first) {
             start_perimeter = 0;
@@ -3073,16 +3042,6 @@ ExPolygons PerimeterGenerator::printable_slices(const ExPolygons &slices) const
     return min_width > EPSILON ? opening_ex(slices, float(scale_(min_width / 2.))) : slices;
 }
 
-bool PerimeterGenerator::outer_walls_first_for_brim() const
-{
-    return layer_id == 0 && brim_puts_outer_walls_first(object_config->brim_type.value, object_config->brim_width.value);
-}
-
-bool brim_puts_outer_walls_first(BrimType brim_type, double brim_width)
-{
-    return brim_width > 0 && (brim_type == btOuterOnly || brim_type == btOuterAndInner || brim_type == btLeadingEdgeOnly);
-}
-
 std::vector<Polygons> PerimeterGenerator::generate_lower_polygons_series(float width)
 {
     float nozzle_diameter = print_config->nozzle_diameter.get_at(config->outer_wall_filament_id - 1);

src/libslic3r/PerimeterGenerator.hpp

@@ -164,8 +164,6 @@ public:
     Polygons    lower_slices_polygons() const { return m_lower_slices_polygons; }
     // ORCA: the slices less the slivers the wall generator prints nothing for, so they never count as support.
     ExPolygons  printable_slices(const ExPolygons &slices) const;
-    // ORCA: whether this layer prints its outer walls first for the brim, see brim_puts_outer_walls_first().
-    bool        outer_walls_first_for_brim() const;
 
 private:
     std::vector<Polygons>     generate_lower_polygons_series(float width);
@@ -185,10 +183,6 @@ private:
     Polygons    m_lower_slices_polygons;
 };
 
-// ORCA: a brim against the outer walls makes the first layer print them first, whatever the wall sequence, so the
-// brim runs straight on into the outer wall. Auto, ear and painted brims may leave the outer walls bare.
-bool brim_puts_outer_walls_first(BrimType brim_type, double brim_width);
-
 }
 
 #endif

src/libslic3r/Preset.cpp

@@ -1489,7 +1489,7 @@ static std::vector<std::string> s_Preset_print_options{
 static std::vector<std::string> s_Preset_filament_options {/*"filament_colour", */ "default_filament_colour", "required_nozzle_HRC", "filament_diameter", "pellet_flow_coefficient", "volumetric_speed_coefficients", "filament_type",
                                                           "filament_soluble", "filament_is_support", "filament_printable", "filament_extruder_compatibility",
     "filament_max_volumetric_speed", "filament_adaptive_volumetric_speed",
-    "filament_flow_ratio", "filament_density", "filament_adhesiveness_category", "filament_cost", "filament_minimal_purge_on_wipe_tower",
+    "filament_flow_ratio", "filament_density", "filament_transmission_distance", "filament_adhesiveness_category", "filament_cost", "filament_minimal_purge_on_wipe_tower",
     "filament_tower_interface_pre_extrusion_dist", "filament_tower_interface_pre_extrusion_length", "filament_tower_ironing_area", "filament_tower_interface_purge_volume",
     "filament_tower_interface_print_temp",
     "nozzle_temperature", "nozzle_temperature_initial_layer",
@@ -2293,7 +2293,6 @@ void PresetCollection::load_project_embedded_presets(std::vector<Preset*>& proje
                 BOOST_LOG_TRIVIAL(error) << boost::format("can not find parent for config %1%!")%preset->file;
                 continue;
             }
-            extend_default_config_length(config, false, {});
             preset->config.update_diff_values_to_child_config(config, extruder_id_name, extruder_variant_name, *key_set1, *key_set2);
             //preset->config.apply(std::move(config));
             Preset::normalize(preset->config);

src/libslic3r/Print.cpp

@@ -228,6 +228,7 @@ bool Print::invalidate_state_by_config_options(const ConfigOptionResolver & /* n
         "filament_diameter",
          "volumetric_speed_coefficients",
         "filament_density",
+        "filament_transmission_distance",
         "filament_cost",
         "filament_notes",
         "outer_wall_acceleration",

src/libslic3r/PrintConfig.cpp

@@ -3440,6 +3440,20 @@ void PrintConfigDef::init_fff_params()
     def->mode = comAdvanced;
     def->set_default_value(new ConfigOptionFloats { 0. });
 
+    def = this->add("filament_transmission_distance", coFloats);
+    def->label = L("Transmission distance");
+    def->tooltip = L("How deep light gets into this filament, in millimetres, also called its "
+                     "transmission distance or TD. About 1 for an opaque filament, 4 to 7 for a usefully "
+                     "translucent one, 8 and above for a nearly clear one. Used only to predict the "
+                     "colours of a ChromaStack in the texture displacement tool; it has no effect on "
+                     "slicing. Measure it with a step test print, or take a published value for the "
+                     "filament.");
+    def->sidetext = L("mm");
+    def->min = 0;
+    def->max = 100;
+    def->mode = comAdvanced;
+    def->set_default_value(new ConfigOptionFloats { 4. });
+
     def = this->add("filament_type", coStrings);
     def->label = L("Type");
     def->tooltip = L("Filament material type");

src/libslic3r/PrintConfig.hpp

@@ -1709,6 +1709,9 @@ PRINT_CONFIG_CLASS_DEFINE(
     ((ConfigOptionStrings,             volumetric_speed_coefficients))
     ((ConfigOptionInts,              filament_adhesiveness_category))
     ((ConfigOptionFloats,              filament_density))
+    // Transmission distance: how deep light gets into this filament. Not used by
+    // slicing - it is the colour model of a ChromaStack stack (see ChromaStack.hpp).
+    ((ConfigOptionFloats,              filament_transmission_distance))
     ((ConfigOptionStrings,             filament_type))
     ((ConfigOptionBools,               filament_soluble))
     ((ConfigOptionStrings,             filament_ids))

src/libslic3r/PrintObject.cpp

@@ -17,7 +17,6 @@
 #include "I18N.hpp"
 #include "Layer.hpp"
 #include "MutablePolygon.hpp"
-#include "PerimeterGenerator.hpp"
 #include "PrintBase.hpp"
 #include "PrintConfig.hpp"
 #include "SLA/IndexedMesh.hpp"
@@ -1465,13 +1464,15 @@ bool PrintObject::invalidate_state_by_config_options(
             || opt_key == "top_surface_speed") {
             // Brim is printed below supports, support invalidates brim and skirt.
             steps.emplace_back(posSupportMaterial);
-            if (opt_key == "brim_type" || opt_key == "brim_width") {
-                // Regenerate the walls when the brim starts or stops putting the first layer's outer walls first.
-                auto outer_walls_first = [](const ConfigOptionResolver &config) {
-                    return brim_puts_outer_walls_first(config.option<ConfigOptionEnum<BrimType>>("brim_type")->value,
-                                                       config.option<ConfigOptionFloat>("brim_width")->value);
-                };
-                if (outer_walls_first(old_config) != outer_walls_first(new_config))
+            if (opt_key == "brim_type") {
+                const auto* old_brim_type = old_config.option<ConfigOptionEnum<BrimType>>(opt_key);
+                const auto* new_brim_type = new_config.option<ConfigOptionEnum<BrimType>>(opt_key);
+                //BBS: When switch to manual brim, the object must have brim, then re-generate perimeter
+                //to make the wall order of first layer to be outer-first
+                // btLeadingEdgeOnly is printed as an outer brim (Brim.cpp, BeltBrim.cpp), so it
+                // takes part in the same first-layer wall order rule.
+                if (old_brim_type->value == btOuterOnly || new_brim_type->value == btOuterOnly ||
+                    old_brim_type->value == btLeadingEdgeOnly || new_brim_type->value == btLeadingEdgeOnly)
                     steps.emplace_back(posPerimeters);
             }
         } else if (

src/libslic3r/Support/SupportCommon.cpp

@@ -707,10 +707,8 @@ void tree_supports_generate_paths(
                                             false);
         }
         if (eec) {
-            if (!eec->empty()) {
-                std::reverse(eec->entities.begin(), eec->entities.end());
-                dst.emplace_back(eec.release());
-            }
+            std::reverse(eec->entities.begin(), eec->entities.end());
+            dst.emplace_back(eec.release());
         }
     }
 }
@@ -1827,7 +1825,12 @@ void generate_support_toolpaths(
                     no_sort = true;
                 } else if (support_params.support_style == SupportMaterialStyle::smsTreeOrganic &&
                            (config.support_base_pattern == smpNone || config.support_base_pattern == smpDefault)) {
-                    tree_supports_generate_paths(base_layer.extrusions, base_layer.polygons_to_extrude(), flow, support_params);
+                    // Orca: A special case for the hollow Organic supports
+                    // Orca: If the tree supports are too tall, use a double wall to make it stronger
+                    SupportParameters support_params2 = support_params;
+                    if (support_layer.print_z > 100.0)
+                        support_params2.tree_branch_diameter_double_wall_area_scaled = 0.1;
+                    tree_supports_generate_paths(base_layer.extrusions, base_layer.polygons_to_extrude(), flow, support_params2);
                     done = true;
                 }
                 if (! done)

src/libslic3r/Support/TreeSupport.cpp

@@ -2149,9 +2149,7 @@ void TreeSupport::draw_circles()
     const bool with_lightning_infill = m_support_params.base_fill_pattern == ipLightning;
     coordf_t support_extrusion_width = m_support_params.support_extrusion_width;
     const float tree_brim_width = config.tree_support_brim_width.value;
-    // Reinforce branches moving more than half a support-line width between layers.
-    // Square the threshold for comparison with the squared XY movement below.
-    const double max_move_sq = sqr(double(scale_(m_object_config->support_line_width / 2)));
+
     // Belt floor: the first object layer is not on a flat bed — it rests on the
     // tilted, moving belt. So the first-object-layer adhesion features (the tree
     // support brim, the hybrid first-layer base expansion) must be suppressed:
@@ -2203,7 +2201,7 @@ void TreeSupport::draw_circles()
                 size_t           first_base_roof_area = 0;
                 bool             floor_interface_as_base = false;
                 bool has_circle_node = false;
-                ExPolygons extra_wall_areas;
+                bool need_extra_wall = false;
                 ExPolygons collision_sharp_tails;
                 ExPolygons collision_base;
                 auto             get_collision = [&](bool sharp_tail) -> ExPolygons             &{
@@ -2281,6 +2279,7 @@ void TreeSupport::draw_circles()
                         // area = diff_clipped({ ExPolygon(circle) }, get_collision(node.is_sharp_tail && node.distance_to_top <= 0));
 
                         if (!area.empty()) has_circle_node = true;
+                        if (node.need_extra_wall) need_extra_wall = true;
 
                         // merge overhang to get a smoother interface surface
                         // Do not merge when buildplate_only is on, because some underneath nodes may have been deleted.
@@ -2295,10 +2294,6 @@ void TreeSupport::draw_circles()
                         }
                     }
 
-                    // Use the Pythagorean theorem to compare movement magnitude (dx² + dy²) without a square root.
-                    if (node.is_processed && node.movement.cast<double>().squaredNorm() > max_move_sq)
-                        append(extra_wall_areas, area);
-
                     if (obj_layer_nr>0 && node.distance_to_top < 0)
                         append(roof_gap_areas, area);
                     else if (obj_layer_nr > 0 && node.support_roof_layers_below == 1 &&
@@ -2535,8 +2530,7 @@ void TreeSupport::draw_circles()
                     //if (area(expoly) < SQ(scale_(1))) continue;
                     area_groups.emplace_back(&expoly, SupportLayer::BaseType, max_layers_above_base);
                     area_groups.back().need_infill = overlaps({ expoly }, area_poly);
-                    area_groups.back().need_extra_wall = !area_groups.back().need_infill &&
-                        !extra_wall_areas.empty() && overlaps({expoly}, extra_wall_areas);
+                    area_groups.back().need_extra_wall = need_extra_wall && !area_groups.back().need_infill;
                 }
                 for (size_t roof_idx = 0; roof_idx < ts_layer->roof_areas.size(); ++roof_idx) {
                     auto &expoly = ts_layer->roof_areas[roof_idx];
@@ -3439,6 +3433,11 @@ void TreeSupport::smooth_nodes()
         }
     }
     
+    float max_move = scale_(m_object_config->support_line_width / 2);
+    // if the branch is very tall, the tip also needs extra wall
+    float thresh_tall_branch = 100;
+    float thresh_dist_to_top = 30;
+
     for (int layer_nr = 0; layer_nr< contact_nodes.size(); layer_nr++) {
         std::vector<SupportNode *> &curr_layer_nodes = contact_nodes[layer_nr];
         if (curr_layer_nodes.empty()) continue;
@@ -3448,17 +3447,20 @@ void TreeSupport::smooth_nodes()
                 std::vector<double> radii;
                 std::vector<SupportNode *>   branch;
                 SupportNode *              p_node = node;
+                float                        total_height = 0;
                 // add a fixed head if it's not a polygon node, see STUDIO-4403
                 // Polygon node can't be added because the move distance might be huge, making the nodes in between jump and dangling
                 if (node->child && node->child->type!=ePolygon) {
                     pts.push_back(p_node->child->position);
                     radii.push_back(p_node->child->radius);
                     branch.push_back(p_node->child);
+                    total_height += p_node->child->height;
                 }
                 do {
                     pts.push_back(p_node->position);
                     radii.push_back(p_node->radius);
                     branch.push_back(p_node);
+                    total_height += p_node->height;
                     p_node = p_node->parent;
                 } while (p_node && !p_node->is_processed);
                 if (pts.size() < 3) continue;
@@ -3477,6 +3479,9 @@ void TreeSupport::smooth_nodes()
                             branch[i]->radius = radii1[i];
                             branch[i]->movement = (pts[i + 1] - pts[i - 1]) / 2;
                             branch[i]->is_processed = true;
+                            if (branch[i]->parents.size() > 1 || (branch[i]->movement.x() > max_move || branch[i]->movement.y() > max_move) ||
+                                (total_height > thresh_tall_branch && branch[i]->dist_mm_to_top < thresh_dist_to_top))
+                                branch[i]->need_extra_wall = true;
                             BOOST_LOG_TRIVIAL(info) << "smooth_nodes: layer_nr=" << layer_nr << ", i=" << i << ", pt=" << pt << ", movement=" << branch[i]->movement << ", radius=" << branch[i]->radius;
                         }
                     }
@@ -3484,6 +3489,13 @@ void TreeSupport::smooth_nodes()
                         std::swap(pts, pts1);
                         std::swap(radii, radii1);
                     }
+                    else {
+                        // interpolate need_extra_wall in the end
+                        for (size_t i = 1; i < branch.size() - 1; i++) {
+                            if (branch[i - 1]->need_extra_wall && branch[i + 1]->need_extra_wall)
+                                branch[i]->need_extra_wall = true;
+                        }
+                    }
                 }
             }
         }

src/libslic3r/Support/TreeSupport.hpp

@@ -135,6 +135,7 @@ struct SupportNode
     TreeNodeType   type            = eCircle;
     bool           is_corner       = false;
     bool           is_processed    = false;
+    bool           need_extra_wall = false;
     bool           is_sharp_tail   = false;
     bool           valid = true;
     ExPolygon      overhang; // when type==ePolygon, set this value to get original overhang area

src/libslic3r/TextureDisplacement.hpp

@@ -18,6 +18,7 @@
 
 #include <array>
 
+#include "ChromaStack.hpp"
 #include "Point.hpp"
 #include "TriangleSelector.hpp"
 
@@ -353,16 +354,33 @@ struct TextureDisplacementLayer
     // for the boundary to be drawn on.
     bool color_enabled = false;
 
+    // ChromaStack (see ChromaStack.hpp): when set, `image_data` is not a texture the user picked but the
+    // height map chroma_solve() computed, so that the whole displacement pipeline - preview, UV
+    // editor, bake - goes on reading one grayscale height map and needs to know nothing about colour
+    // stacks. The picture it was solved from is kept here instead, because the solve has to be redone
+    // whenever the stack, the print's layer height or the picture itself changes.
+    //
+    // A ChromaStack layer gets its colour from filament swaps at fixed Z, which is what `chroma`
+    // records and what the object's height ranges carry out. That is a different mechanism from
+    // `color_enabled` (per-triangle filament assignment), and the two are mutually exclusive: the
+    // panel turns colour off on a ChromaStack layer, since painting the relief in one filament per
+    // triangle would hide the very stack the heights were solved against.
+    bool                                        chroma_enabled = false;
+    ChromaStack                               chroma;
+    std::shared_ptr<std::vector<unsigned char>> chroma_source;
+
     bool empty() const { return !image_data || image_data->empty(); }
 
     template<class Archive> void save(Archive &ar) const
     {
         std::string blob = image_data ? std::string(image_data->begin(), image_data->end()) : std::string();
+        std::string source = chroma_source ? std::string(chroma_source->begin(), chroma_source->end()) : std::string();
         ar(slot, name, path, path_in_3mf, blob, depth_mm, tiling_scale, rotation_deg, offset, invert, tile_enabled,
            static_cast<int>(tile_method), static_cast<int>(projection_method), lscm_seam_angle_deg, islands,
            static_cast<int>(blend_mode), midlevel, island_padding_mm, lscm_seam_edges, view_project_right,
            view_project_up, smoothing, edge_smoothing, edge_smoothing_amount, auto_connect_islands, island_groups,
-           lscm_uv_overrides, view_project_projective, view_project_matrix, color_enabled);
+           lscm_uv_overrides, view_project_projective, view_project_matrix, color_enabled, chroma_enabled, chroma,
+           source);
     }
     template<class Archive> void load(Archive &ar)
     {
@@ -370,12 +388,14 @@ struct TextureDisplacementLayer
         int         tile_method_int       = 0;
         int         projection_method_int = 0;
         int         blend_mode_int        = 0;
+        std::string source;
         ar(slot, name, path, path_in_3mf, blob, depth_mm, tiling_scale, rotation_deg, offset, invert, tile_enabled,
            tile_method_int, projection_method_int, lscm_seam_angle_deg, islands, blend_mode_int, midlevel,
            island_padding_mm, lscm_seam_edges, view_project_right, view_project_up, smoothing, edge_smoothing,
            edge_smoothing_amount, auto_connect_islands, island_groups, lscm_uv_overrides, view_project_projective,
-           view_project_matrix, color_enabled);
+           view_project_matrix, color_enabled, chroma_enabled, chroma, source);
         image_data        = blob.empty() ? nullptr : std::make_shared<std::vector<unsigned char>>(blob.begin(), blob.end());
+        chroma_source   = source.empty() ? nullptr : std::make_shared<std::vector<unsigned char>>(source.begin(), source.end());
         tile_method       = static_cast<TextureTileMethod>(tile_method_int);
         projection_method = static_cast<TextureProjectionMethod>(projection_method_int);
         blend_mode        = static_cast<TextureBlendMode>(blend_mode_int);

src/slic3r/GUI/ConnectPrinter.cpp

@@ -15,7 +15,6 @@
 #include <string>
 #include "slic3r/GUI/wxExtensions.hpp"
 #include "libslic3r/AppConfig.hpp"
-#include "IPrinterAgent.hpp"
 
 #include "DeviceCore/DevManager.h"
 
@@ -171,16 +170,14 @@ void ConnectPrinterDialog::on_input_enter(wxCommandEvent& evt)
 void ConnectPrinterDialog::on_button_confirm(wxCommandEvent &event)
 {
     wxString code = m_textCtrl_code->GetTextCtrl()->GetValue();
-    // Validate only what the user typed; the no-key sentinel is applied afterwards (it contains
-    // non-alphanumeric characters, so it must not go through this check).
+    if (code.empty() && (!m_obj || m_obj->printer_agent_id != MOONRAKER_PRINTER_AGENT_ID))
+        code = "88888888";
     for (char c : code) {
         if (!(('0' <= c && c <= '9') || ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z'))) {
             show_error(this, _L("Invalid input"));
             return;
         }
     }
-    if (code.empty())
-        code = NO_API_KEY_SENTINEL;
     if (m_obj) {
         m_obj->set_access_code(code.ToStdString());
     }

src/slic3r/GUI/DeviceManager.cpp

@@ -2685,8 +2685,7 @@ int MachineObject::connect()
 {
     if (m_access_revoked || get_dev_ip().empty()) return -1;
     std::string username = m_agent ? m_agent->default_lan_username() : std::string();
-    // The stored access code may be the "no API key" sentinel; agents expect an empty credential.
-    std::string password = normalize_access_code(get_access_code());
+    std::string password = get_access_code();
 
     std::string port;
     std::string input = get_dev_ip();

src/slic3r/GUI/GLShadersManager.cpp

@@ -114,6 +114,8 @@ std::pair<bool, std::string> GLShadersManager::init()
         valid &= append_shader("mm_gouraud", { prefix + "mm_gouraud.vs", prefix + "mm_gouraud.fs" });
     // Fast shaded preview for the texture displacement gizmo (see libslic3r/TextureDisplacement.hpp).
     valid &= append_shader("texture_displacement_shaded", { prefix + "texture_displacement_shaded.vs", prefix + "texture_displacement_shaded.fs" });
+    // ChromaStack: the printed colours on the model, read per fragment from its own height.
+    valid &= append_shader("chromastack", { prefix + "chromastack.vs", prefix + "chromastack.fs" });
     // UV-check overlay for the same gizmo: a procedural checker or a distortion heatmap over the
     // painted patch, to sanity-check the unwrap.
     valid &= append_shader("texture_displacement_uvcheck", { prefix + "texture_displacement_uvcheck.vs", prefix + "texture_displacement_uvcheck.fs" });

src/slic3r/GUI/GUI_App.cpp

@@ -4354,11 +4354,6 @@ void GUI_App::select_machine(const std::string& agent_id)
         machine.dev_ip = dev_id;
         machine.dev_name = dev_id;
         machine.printer_type = preset.config.opt_string("printer_model");
-        auto access_code = preset.config.opt_string("printhost_apikey");
-        // Orca expect non empty access code
-        if (access_code.empty()) {
-            access_code = NO_API_KEY_SENTINEL;
-        }
 
         existing = m_device_manager->insert_local_device(
             machine, "lan", "free", "", access_code);

src/slic3r/GUI/GUI_ObjectList.cpp

@@ -2875,6 +2875,37 @@ void ObjectList::del_layer_from_object(const int obj_idx, const t_layer_height_r
     changed_object(obj_idx);
 }
 
+void ObjectList::rebuild_layer_ranges(const int obj_idx)
+{
+    if (obj_idx < 0 || obj_idx >= int(m_objects->size()))
+        return;
+    const wxDataViewItem obj_item = m_objects_model->GetItemById(obj_idx);
+    if (!obj_item.IsOk())
+        return;
+
+    const t_layer_config_ranges& ranges = object(obj_idx)->layer_config_ranges;
+    // Adding and deleting tree items fires selection events on GTK; suppress them as every other
+    // bulk edit of the tree here does.
+    const bool prevent_events = m_prevent_list_events;
+    m_prevent_list_events = true;
+    wxDataViewItem root = m_objects_model->GetLayerRootItem(obj_item);
+    if (root.IsOk()) {
+        m_objects_model->DeleteChildren(root);
+        if (ranges.empty())
+            m_objects_model->Delete(root);
+        else {
+            for (const auto& range : ranges)
+                add_layer_item(range.first, root);
+            Expand(root);
+        }
+    } else {
+        add_layer_root_item(obj_item);
+    }
+    m_prevent_list_events = prevent_events;
+
+    changed_object(obj_idx);
+}
+
 void ObjectList::del_layers_from_object(const int obj_idx)
 {
     object(obj_idx)->layer_config_ranges.clear();

src/slic3r/GUI/GUI_ObjectList.hpp

@@ -321,6 +321,11 @@ public:
     void                del_settings_from_config(const wxDataViewItem& parent_item);
     void                del_instances_from_object(const int obj_idx);
     void                del_layer_from_object(const int obj_idx, const t_layer_height_range& layer_range);
+    // Mirrors an object's height ranges in the tree after they have been rewritten from outside the
+    // list - the texture displacement gizmo writes a whole set at once for a ChromaStack stack's
+    // filament swaps. Deliberately leaves the selection alone: changing it while a gizmo is open
+    // tears the gizmo down under the user.
+    void                rebuild_layer_ranges(const int obj_idx);
     void                del_layers_from_object(const int obj_idx);
     bool                del_from_cut_object(bool is_connector, bool is_model_part = false, bool is_negative_volume = false);
     bool                del_subobject_from_object(const int obj_idx, const int idx, const int type);

src/slic3r/GUI/Gizmos/GLGizmoTextureDisplacement.hpp

@@ -264,7 +264,11 @@ private:
     ModelVolume*       texture_volume();
     const ModelVolume* texture_volume() const;
 
-    void add_texture_layer();
+    // `chroma` picks the kind: a relief layer, a height map pushed into the surface, or a ChromaStack
+    // picture, a colour picture made of filament swaps. The kind is a property of the layer and is
+    // fixed when it is created - there is no panel-wide mode, so a plaque can carry a picture on its
+    // face and a knurl on its rim at the same time.
+    void add_texture_layer(bool chroma = false);
     void remove_texture_layer(int slot);
     // Moves the layer in `slot` to position `to_index` of the slot-ordered stack (an insertion index,
     // 0..layer count), which is the order blend modes apply in. Layers keep their data; what moves is
@@ -435,6 +439,109 @@ private:
     void set_layer_texture(TextureDisplacementLayer &layer, const TextureLibraryEntry &entry);
     void import_custom_texture(TextureDisplacementLayer &layer);
 
+    // ---- ChromaStack (see libslic3r/ChromaStack.hpp) ----
+    //
+    // A ChromaStack layer is an ordinary texture displacement layer whose height map is computed rather
+    // than imported: the picture the user picked is kept in `chroma_source`, the stack in
+    // `chroma`, and `image_data` holds whatever the last solve produced. Everything downstream -
+    // projection, preview, bake - therefore needs no changes at all, and this is the whole of the
+    // feature's GUI side: pick a picture, edit the stack, solve, hand the filament swaps to the
+    // object's height ranges.
+
+    // The project's loaded filaments as the colour model sees them: colour from the project, TD from
+    // each filament's preset. Index is the filament index the swaps are written from.
+    static std::vector<ChromaFilament> chroma_filaments();
+    // The layer height the print profile is set to, mm; 0 when there is no print preset. The solve is
+    // only valid for the layer height it was run at, so the panel compares it against the stack's.
+    static float print_layer_height();
+
+    // Where the active layer's painted patch sits, in the object's own printed coordinates - which is
+    // what the stack has to be lined up with, because a filament swap happens at a print Z and the
+    // relief grows upward from this patch.
+    struct ChromaPatch
+    {
+        bool  valid     = false;
+        float top_mm    = 0.f; // the patch's surface above the bottom of the object
+        float spread_mm = 0.f; // how far from flat the patch is in Z; 0 is a horizontal face
+        // The patch's extent in the plane the texture is projected from, in the bake frame - i.e. the
+        // (x, y) the Z-facing plane of the tri-planar projection samples by. This is what the picture
+        // has to be placed against: tiling_scale and offset are in that space, not in the patch's.
+        Vec2f planar_min = Vec2f::Zero();
+        Vec2f planar_max = Vec2f::Zero();
+    };
+    ChromaPatch chroma_patch(const TextureDisplacementLayer &layer) const;
+    // The painted face's height in layers, which is what the stack's base has to be: -1 when nothing
+    // is painted yet or there is no layer height to divide by.
+    int         chroma_measured_base(const TextureDisplacementLayer &layer) const;
+    // Extracting the painted patch is far too expensive to repeat once a frame, which is how often the
+    // panel wants the number. The paint's own timestamp and the transform the patch was measured in are
+    // between them everything the answer depends on.
+    mutable std::array<ChromaPatch, TEXTURE_DISPLACEMENT_MAX_LAYERS> m_chroma_patch_cache{};
+    mutable std::array<uint64_t, TEXTURE_DISPLACEMENT_MAX_LAYERS>      m_chroma_patch_stamp{};
+    mutable std::array<Transform3d, TEXTURE_DISPLACEMENT_MAX_LAYERS>   m_chroma_patch_trafo{};
+    // The patch is measured in two frames at once - the instance's, for the print height, and the
+    // bake's, for the placement - so both are part of what the cached answer depends on.
+    mutable std::array<Transform3d, TEXTURE_DISPLACEMENT_MAX_LAYERS>   m_chroma_patch_bake{};
+
+    // Picks a colour picture for the layer, turns ChromaStack on, and seeds a stack from the loaded
+    // filaments and the patch if the layer has none yet. Solves straight away, so the relief appears
+    // without a second click.
+    void chroma_pick_picture(TextureDisplacementLayer &layer);
+    // Re-runs the solve and replaces the layer's height map with its result. False (with the reason
+    // shown to the user) when the layer has no picture, no stack or no relief layers.
+    bool chroma_solve_layer(TextureDisplacementLayer &layer);
+    // Writes the stack's filament swaps onto the object as height ranges, replacing whatever ranges it
+    // had. Takes its own undo snapshot.
+    void chroma_apply_swaps(const TextureDisplacementLayer &layer);
+    // The stack's swaps as the object's height ranges already express them: true when applying would
+    // change nothing, which is what the panel's hint keys off.
+    bool chroma_swaps_applied(const TextureDisplacementLayer &layer) const;
+    // The whole of a ChromaStack card between its header and More settings: the picture and the print
+    // it predicts, the base, the filaments and the colours they reach, and the two actions.
+    void render_chroma_card(TextureDisplacementLayer &layer, float card_pad, float label_w, float wrap_w);
+
+    // The surface drawn in the colours the stack will print, over whatever neutral surface is there:
+    // the live preview's displaced mesh before a bake, the volume's own mesh after one. Every triangle
+    // takes the palette colour of the printed layer its centroid falls in (chroma_level_at()), which
+    // is what the eye will see at that height - so the relief's terraces read as the picture, the walls
+    // between them show the bands they cut through, and looking straight down gives the blended colours
+    // the whole feature exists to produce.
+    //
+    // Nothing else in the application can show this: the colours are blends of translucent filaments
+    // that no single filament can make, so they cannot be expressed as the per-triangle filament
+    // assignment the 3D scene paints with. They exist only here and in the sliced preview.
+    void rebuild_chroma_colors(const TextureDisplacementLayer &layer);
+    bool render_chroma_colors(const TextureDisplacementLayer &layer);
+    GLModel m_chroma_color_model;
+    // The surface the overlay was built from. The mesh alone: the colours are not in it, so a change
+    // to the stack costs a palette upload rather than a mesh rebuild.
+    size_t  m_chroma_color_key = 0;
+    // The stack's colours, one texel per printed layer, and what they were built from. A texture
+    // because a uniform array cannot hold a base of several hundred layers.
+    std::unique_ptr<GLTexture> m_chroma_palette_tex;
+    size_t                     m_chroma_palette_key = 0;
+    bool                       m_show_chroma_colors = true;
+
+    // What the last solve of each slot reported, for the panel. Not saved: it is a property of the
+    // solve, and a project is reopened with whatever height map the solve produced.
+    struct ChromaReport
+    {
+        bool   valid = false;
+        double mean  = 0.;
+        double max   = 0.;
+    };
+    std::array<ChromaReport, TEXTURE_DISPLACEMENT_MAX_LAYERS>              m_chroma_report{};
+    // The predicted print, per slot: the palette colours the solve chose, as a panel thumbnail. The
+    // 3D view cannot show this - the colours do not exist until the print swaps filament - so it is
+    // the only place the user sees what the stack will actually produce.
+    std::array<std::unique_ptr<GLTexture>, TEXTURE_DISPLACEMENT_MAX_LAYERS>  m_chroma_preview;
+    // The source picture's thumbnail, beside the prediction, keyed by the image it was built from.
+    std::array<std::unique_ptr<GLTexture>, TEXTURE_DISPLACEMENT_MAX_LAYERS>  m_chroma_source_thumb;
+    std::array<const void *, TEXTURE_DISPLACEMENT_MAX_LAYERS>                m_chroma_source_key{};
+    // Per slot: the stack has been edited since the height map was solved, so the relief on screen is the
+    // previous stack's. Nothing else can show this - a stale height map looks like a perfectly good one.
+    std::array<bool, TEXTURE_DISPLACEMENT_MAX_LAYERS>                        m_chroma_stale{};
+
     // Paint / Erase, from the panel. See get_left_button_state_type().
     bool m_erase_mode = false;
     // Per slot: whether the layer's card shows every setting or only Depth, Tile size and Rotation.

src/slic3r/GUI/ReleaseNote.cpp

@@ -2,7 +2,6 @@
 #include "I18N.hpp"
 
 #include "bambu_networking.hpp"
-#include "IPrinterAgent.hpp"
 #include "libslic3r/Utils.hpp"
 #include "GUI.hpp"
 #include "GUI_App.hpp"
@@ -1904,7 +1903,7 @@ void InputIpAddressDialog::on_ok(wxMouseEvent& evt)
     std::string str_ip = m_input_ip->GetTextCtrl()->GetValue().ToStdString();
     std::string str_access_code = m_input_access_code->GetTextCtrl()->GetValue().ToStdString();
     if (str_access_code.empty())
-        str_access_code = NO_API_KEY_SENTINEL;
+        str_access_code = "88888888";
     std::string str_name = m_input_printer_name->GetTextCtrl()->GetValue().Strip(wxString::both).ToStdString();
     // Serial number should not contain lower case letters, and bambu_network plugin crashes
     // if user entered the wrong serial number, so we call `Upper()` here.
@@ -1951,7 +1950,7 @@ void InputIpAddressDialog::on_send_retry()
     wxString ip              = m_input_ip->GetTextCtrl()->GetValue();
     wxString str_access_code = m_input_access_code->GetTextCtrl()->GetValue();
     if (str_access_code.IsEmpty())
-        str_access_code = NO_API_KEY_SENTINEL;
+        str_access_code = "88888888";
 
     // check support function
     if (!m_obj) return;

src/slic3r/GUI/Selection.cpp

@@ -474,14 +474,17 @@ void Selection::add_curr_plate()
     if (!m_valid)
         return;
 
-    std::vector<unsigned int> volume_idxs = get_volume_idxs_from_plate(wxGetApp().plater()->get_partplate_list().get_curr_plate_index());
-    if (volume_idxs.empty())
-        return;
-
     wxGetApp().plater()->take_snapshot(std::string("Selection-Add Curr Plate All!"));
     m_mode = Instance;
     clear();
-    do_add_volumes(volume_idxs);
+
+    PartPlate* plate = wxGetApp().plater()->get_partplate_list().get_curr_plate();
+    for (int obj_idx = 0; obj_idx < m_model->objects.size(); obj_idx++) {
+        if (plate && plate->contain_instance_totally(obj_idx, 0)) {
+            std::vector<unsigned int> volume_idxs = get_volume_idxs_from_object(obj_idx);
+            do_add_volumes(volume_idxs);
+        }
+    }
 
     update_type();
     this->set_bounding_boxes_dirty();
@@ -508,14 +511,20 @@ void Selection::remove_curr_plate()
     if (!m_valid)
         return;
 
-    std::vector<unsigned int> volume_idxs = get_volume_idxs_from_plate(wxGetApp().plater()->get_partplate_list().get_curr_plate_index());
-    if (volume_idxs.empty())
+    PartPlate* plate = wxGetApp().plater()->get_partplate_list().get_curr_plate();
+    if (plate->empty())
         return;
 
     wxGetApp().plater()->take_snapshot(std::string("Selection-Delete Curr Plate All"));
     m_mode = Instance;
     clear();
-    do_add_volumes(volume_idxs);
+
+    for (int obj_idx = 0; obj_idx < m_model->objects.size(); obj_idx++) {
+        if (plate && plate->contain_instance(obj_idx, 0)) {
+            std::vector<unsigned int> volume_idxs = get_volume_idxs_from_object(obj_idx);
+            do_add_volumes(volume_idxs);
+        }
+    }
 
     update_type();
     this->set_bounding_boxes_dirty();
@@ -2261,27 +2270,6 @@ std::vector<unsigned int> Selection::get_volume_idxs_from_volume(unsigned int ob
     return idxs;
 }
 
-std::vector<unsigned int> Selection::get_volume_idxs_from_plate(const int plate_idx) const
-{
-    PartPlate* plate = wxGetApp().plater()->get_partplate_list().get_plate(plate_idx);
-    std::vector<unsigned int> idxs;
-    if (!plate)
-        return idxs;
-
-    for (int obj_idx = 0; obj_idx < (int)m_model->objects.size(); obj_idx++) {
-        const ModelObject* obj = m_model->objects[obj_idx];
-        for (int inst_idx = 0; inst_idx < (int)obj->instances.size(); inst_idx++) {
-            // on this plate or overlapping it in some way (fully inside, oversized or partly outside)
-            if (plate->contain_instance(obj_idx, inst_idx) || plate->intersect_instance(obj_idx, inst_idx)) {
-                std::vector<unsigned int> inst_idxs = get_volume_idxs_from_instance(obj_idx, inst_idx);
-                idxs.insert(idxs.end(), inst_idxs.begin(), inst_idxs.end());
-            }
-        }
-    }
-
-    return idxs;
-}
-
 std::vector<unsigned int> Selection::get_missing_volume_idxs_from(const std::vector<unsigned int>& volume_idxs) const
 {
     std::vector<unsigned int> idxs;

src/slic3r/GUI/Selection.hpp

@@ -409,8 +409,6 @@ public:
     std::vector<unsigned int> get_volume_idxs_from_instance(unsigned int object_idx, unsigned int instance_idx) const;
     // returns the idx of the volume corresponding to the volume with the given idxs
     std::vector<unsigned int> get_volume_idxs_from_volume(unsigned int object_idx, unsigned int instance_idx, unsigned int volume_idx) const;
-    // returns the list of idxs of the volumes of all instances on the given plate or overlapping it. (fully inside, oversized or partly outside)
-    std::vector<unsigned int> get_volume_idxs_from_plate(const int plate_idx) const;
     // returns the list of idxs of the volumes contained in the selection but not in the given list
     std::vector<unsigned int> get_missing_volume_idxs_from(const std::vector<unsigned int>& volume_idxs) const;
     // returns the list of idxs of the volumes contained in the given list but not in the selection

src/slic3r/GUI/Tab.cpp

@@ -4538,6 +4538,7 @@ void TabFilament::build()
         optgroup->append_single_option_line("filament_adhesiveness_category", "material_basic_information#adhesiveness-category");
 
         optgroup->append_single_option_line("filament_density", "material_basic_information#density");
+        optgroup->append_single_option_line("filament_transmission_distance", "material_basic_information#transmission-distance");
         optgroup->append_single_option_line("filament_shrink", "material_basic_information#shrinkage-xy");
         optgroup->append_single_option_line("filament_shrinkage_compensation_z", "material_basic_information#shrinkage-z");
         optgroup->append_single_option_line("filament_cost", "material_basic_information#price");

src/slic3r/Utils/BBLPrinterAgent.cpp

@@ -204,9 +204,8 @@ int BBLPrinterAgent::command_axis_control(std::string dev_id, std::string axis,
         int dir = input_val > 0 ? 1 : -1;
         // i3-arch printers move the bed for Y/Z, so the on-screen direction is
         // reversed -- same negation the g-code fallback below applies.
-        if (!is_core_xy && (axis == "Y" || axis == "Z")) {
+        if (!is_core_xy && (axis == "Y" || axis == "Z"))
             dir = -dir;
-        }
 
         j["print"]["command"] = "xyz_ctrl";
         j["print"]["axis"] = axis;
@@ -216,9 +215,8 @@ int BBLPrinterAgent::command_axis_control(std::string dev_id, std::string axis,
     }
 
     double value = input_val;
-    if (!is_core_xy && (axis == "Y" || axis == "Z")) {
-        value = -1.0 * input_val;
-    }
+    if (!is_core_xy && (axis == "Y" || axis == "Z"))
+        value = -input_val;
 
     std::string value_str = (boost::format("%.1f") % (value * unit)).str();
     std::string gcode;
@@ -239,11 +237,10 @@ int BBLPrinterAgent::command_axis_control(std::string dev_id, std::string axis,
 int BBLPrinterAgent::publish(const std::string& dev_id, const nlohmann::json& j, bool lan_mode)
 {
     const int rtn = lan_mode ? send_message_to_printer(dev_id, j.dump(), 0, 0) : send_message(dev_id, j.dump(), 0, 0);
-    if (rtn == 0) {
+    if (rtn == 0)
         BOOST_LOG_TRIVIAL(info) << "publish_json: " << j.dump() << " code: " << rtn;
-    } else {
+    else
         BOOST_LOG_TRIVIAL(error) << "publish_json: " << j.dump() << " code: " << rtn;
-    }
     return rtn;
 }
 
@@ -589,21 +586,8 @@ int BBLPrinterAgent::start_local_print_with_record(PrintParams params, OnUpdateS
 
 int BBLPrinterAgent::start_send_gcode_to_sdcard(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn)
 {
-    // dispatch_start() moves out of `params`, so snapshot the diagnostic fields first;
-    // logging them after the call would print empty strings.
-    const bool        try_emmc_print = params.try_emmc_print;
-    const std::string dev_ip         = params.dev_ip;
-    const std::string dev_id         = params.dev_id;
-
-    int result = dispatch_start<func_start_send_gcode_to_sdcard_legacy, func_start_send_gcode_to_sdcard_0203>(
+    return dispatch_start<func_start_send_gcode_to_sdcard_legacy, func_start_send_gcode_to_sdcard_0203>(
         BBLNetworkPlugin::instance().get_start_send_gcode_to_sdcard(), params, update_fn, cancel_fn, wait_fn);
-    if (result != 0) {
-        BOOST_LOG_TRIVIAL(error) << "start_send_gcode_to_sdcard failed: result=" << result
-            << ", try_emmc_print=" << try_emmc_print
-            << ", legacy_mode=" << BBLNetworkPlugin::instance().use_legacy_network()
-            << ", dev_ip=" << dev_ip << ", dev_id=" << dev_id;
-    }
-    return result;
 }
 
 int BBLPrinterAgent::start_local_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn)

src/slic3r/Utils/BBLPrinterAgent.hpp

@@ -110,7 +110,6 @@ public:
     static std::string from_orca_payload(std::string json_text);
 
 private:
-    // why: the lan/cloud DECISION stays machine-side; keep this mechanical branch in sync with publish_json.
     int publish(const std::string& dev_id, const nlohmann::json& j, bool lan_mode);
 };
 

src/slic3r/Utils/CrealityPrintAgent.cpp

@@ -288,27 +288,22 @@ bool CrealityPrintAgent::parse_cfs_response(const std::string&    response,
     return true;
 }
 
-bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode)
+bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode /*sync_mode*/)
 {
-    if (sync_mode != get_filament_sync_mode())
-        return false;
-
-    const MoonrakerDeviceInfo info = snapshot_device_info();
-
-    if (info.dev_ip.empty()) {
+    if (device_info.dev_ip.empty()) {
         BOOST_LOG_TRIVIAL(warning)
             << "CrealityPrintAgent::fetch_filament_info: no device IP, falling back to base agent";
-        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id), sync_mode);
+        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id));
     }
 
     // Build a CrealityPrint helper so we can use its model detection + WS helpers
     // (added in upstream PR #13291).
     DynamicPrintConfig cfg;
-    cfg.set_key_value("print_host",                  new ConfigOptionString("http://" + info.dev_ip));
+    cfg.set_key_value("print_host",                  new ConfigOptionString("http://" + device_info.dev_ip));
     cfg.set_key_value("print_host_webui",            new ConfigOptionString(""));
     cfg.set_key_value("printhost_cafile",            new ConfigOptionString(""));
     cfg.set_key_value("printhost_port",              new ConfigOptionString(""));
-    cfg.set_key_value("printhost_apikey",            new ConfigOptionString(info.api_key));
+    cfg.set_key_value("printhost_apikey",            new ConfigOptionString(device_info.api_key));
     cfg.set_key_value("printhost_ssl_ignore_revoke", new ConfigOptionBool(false));
 
     CrealityPrint host(&cfg);
@@ -318,7 +313,7 @@ bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMod
         BOOST_LOG_TRIVIAL(info)
             << "CrealityPrintAgent: " << host.model_name()
             << " is not CFS-capable, deferring to base Moonraker agent";
-        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id), sync_mode);
+        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id));
     }
 
     BOOST_LOG_TRIVIAL(info)
@@ -333,7 +328,7 @@ bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMod
         BOOST_LOG_TRIVIAL(warning)
             << "CrealityPrintAgent: CFS query failed (" << parse_err << "), "
             << "falling back to base agent";
-        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id), sync_mode);
+        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id));
     }
 
     if (box_count == 0) {
@@ -342,7 +337,7 @@ bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMod
         // Moonraker exposes.
         BOOST_LOG_TRIVIAL(info)
             << "CrealityPrintAgent: no active CFS boxes, deferring to base agent";
-        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id), sync_mode);
+        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id));
     }
 
     BOOST_LOG_TRIVIAL(info)
@@ -387,7 +382,7 @@ bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMod
         }
     }
 
-    build_ams_payload(box_count, max_slots - 1, trays, sync_mode == FilamentSyncMode::pull);
+    build_ams_payload(box_count, max_slots - 1, trays);
     return true;
 }
 

src/slic3r/Utils/CrealityPrintAgent.hpp

@@ -37,13 +37,12 @@ public:
     };
 
     explicit CrealityPrintAgent(std::string log_dir);
-    ~CrealityPrintAgent() override { shutdown(); }
+    ~CrealityPrintAgent() override = default;
 
     static AgentInfo get_agent_info_static();
     AgentInfo        get_agent_info() override { return get_agent_info_static(); }
 
     bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
-    FilamentSyncMode get_filament_sync_mode() const override { return FilamentSyncMode::pull; }
 
     // Parse the boxsInfo JSON returned by CrealityPrint::query_boxes_info() into
     // a flat list of loaded slots, plus the count of CFS boxes the printer reports.

src/slic3r/Utils/IPrinterAgent.hpp

@@ -45,17 +45,6 @@ struct PrinterConnectionParams
     std::string ca_file;
 };
 
-// Sentinel stored as a LAN device's access code when the user has not supplied one, so the device
-// stays registered (has_access_right() is !access_code.empty()). It is not a real credential: every
-// printer agent must translate it back to an empty string before using/sending it on the wire.
-inline constexpr const char* NO_API_KEY_SENTINEL = "*_{NO_API_KEY}_*";
-
-// Returns an empty string when `code` is the "no API key" sentinel, otherwise `code` unchanged.
-inline std::string normalize_access_code(const std::string& code)
-{
-    return code == NO_API_KEY_SENTINEL ? std::string() : code;
-}
-
 /**
  * FilamentSyncMode - Modes for filament data synchronization.
  *
@@ -466,16 +455,9 @@ public:
     virtual CameraStreamMode get_camera_stream_mode() const { return CameraStreamMode::none; }
 
     /**
-     * Refresh filament info from the printer.
-     *
-     * When called with FilamentSyncMode::pull (which requires get_filament_sync_mode() to
-     * return pull) this is a blocking, synchronous call: when it returns true the MachineObject's
-     * DevFilaSystem has already been populated and the caller may read it immediately.
-     *
-     * When called with FilamentSyncMode::subscription — by an implementation's own status loop —
-     * the refresh may be performed asynchronously: a true return then means the refresh was
-     * scheduled (or is already in flight), and DevFilaSystem is updated later on the main thread.
-     * Callers must not assume the data is ready on return.
+     * Refresh filament info from the printer synchronously.
+     * Should only be called when get_filament_sync_mode() returns FilamentSyncMode::pull.
+     * Populates the MachineObject's DevFilaSystem with fetched filament data.
      */
     virtual bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) { return false; }
 

src/slic3r/Utils/MoonrakerPrinterAgent.hpp

@@ -12,9 +12,6 @@
 #include <set>
 #include <string>
 #include <thread>
-#include <chrono>
-#include <condition_variable>
-#include <deque>
 
 #include <nlohmann/json.hpp>
 #include <vector>
@@ -23,56 +20,6 @@ namespace Slic3r { class ICloudServiceAgent; }
 
 namespace Slic3r {
 
-class Http;
-
-bool moonraker_is_light_name(const std::string& name);
-// Direction encoded by a light name: +1 turns on, -1 turns off, 0 is an ambiguous toggle.
-// e.g. LIGHT_ON -> +1, LIGHT_OFF -> -1, LIGHT -> 0.
-int moonraker_light_name_direction(const std::string& name);
-
-struct MoonrakerWebcamSelection
-{
-    std::string      url;
-    CameraStreamMode mode = CameraStreamMode::none;
-    std::string      name;
-    std::string      error;  // set when no selectable webcam was found
-};
-
-// Selects a webcam from a parsed /server/webcams/list response (the top-level JSON or its
-// "result" value). Returns true and fills url/mode/name on success; on failure returns
-// false and sets error.
-bool moonraker_parse_webcam_list(const nlohmann::json& response, const std::string& base_url,
-                                 MoonrakerWebcamSelection& out);
-
-class MoonrakerWebsocket
-{
-public:
-    enum class ReadResult
-    {
-        message,
-        timeout,
-        closed,
-        error,
-    };
-
-    MoonrakerWebsocket(bool secure, std::string api_key, std::string ca_file);
-    ~MoonrakerWebsocket();
-
-    void connect(const std::string& host, const std::string& port, std::chrono::seconds timeout);
-    void tls_handshake(const std::string& host);
-    void handshake(const std::string& host, const std::string& target);
-    void text(bool enabled);
-    void write(const std::string& body);
-    ReadResult read(std::string& payload, std::string& error_message);
-    void close();
-    void expires_after(std::chrono::seconds timeout);
-    void abort();
-
-private:
-    struct Impl;
-    std::unique_ptr<Impl> m_impl;
-};
-
 class MoonrakerPrinterAgent : public IPrinterAgent
 {
 public:
@@ -118,24 +65,12 @@ public:
     int set_on_local_connect_fn(OnLocalConnectedFn fn) override;
     int set_on_local_message_fn(OnMessageFn fn) override;
     int set_queue_on_main_fn(QueueOnMainFn fn) override;
-    bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
-    CameraStreamMode get_camera_stream_mode() const override;
-    std::string get_camera_url() const override;
 
-    // Called by the fetch-thread RAII guard when a background filament fetch finishes.
-    // Serialized with the reservation so shutdown()'s wait cannot miss the transition to 0.
-    void release_fetch_slot() noexcept;
+    // Pull-mode agent (on-demand filament sync)
+    FilamentSyncMode get_filament_sync_mode() const override { return FilamentSyncMode::pull; }
+    bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
 
 protected:
-    struct ConnectionSettings
-    {
-        std::string dev_id;
-        std::string base_url;
-        std::string api_key;
-        bool        use_ssl = false;
-        std::string ca_file;
-    };
-
     struct MoonrakerDeviceInfo
     {
         std::string dev_id;
@@ -147,9 +82,7 @@ protected:
         std::string dev_name;
         std::string version;
         std::string klippy_state;
-        float       nozzle_diameter = 0.0f;
         bool        use_ssl = false;
-        std::string ca_file;
     } device_info;
 
     // Tray data for AMS payload building
@@ -163,44 +96,16 @@ protected:
         int         nozzle_temp = 0;     // Optional
     };
 
-    // Build ams JSON and call parser.
-    // apply_inline: when true the MachineObject mutation runs on the calling thread, which
-    // must therefore be the main thread; when false it is deferred through queue_on_main_fn.
-    // Pull-mode fetches run synchronously on the GUI thread and are read back immediately, so
-    // they pass true to avoid the deferred mutation landing after the caller's read.
-    //
-    // resolve_tray_ids: optional hook that runs as part of the commit, i.e. on the main thread.
-    // Agents that would otherwise resolve tray_info_idx against GUI-owned preset state on a
-    // background fetch thread must do it here to avoid racing the GUI. It must not capture
-    // `this` (the commit may outlive the agent).
-    using ResolveAmsTrayIdsFn = std::function<void(std::vector<AmsTrayData>&)>;
-    void build_ams_payload(int ams_count, int max_lane_index, const std::vector<AmsTrayData>& trays, bool apply_inline = false,
-                           ResolveAmsTrayIdsFn resolve_tray_ids = {});
+    // Build ams JSON and call parser
+    void build_ams_payload(int ams_count, int max_lane_index, const std::vector<AmsTrayData>& trays);
 
     // Methods that derived classes may need to override or access
-    virtual bool init_device_info(const PrinterConnectionParams& params);
-    virtual bool fetch_device_info(const ConnectionSettings& connection, MoonrakerDeviceInfo& info, std::string& error) const;
-    ConnectionSettings get_connection_settings() const;
-    // Copy of the mutable connection state, taken under connect_mutex. Background threads
-    // must use this instead of reading device_info directly.
-    MoonrakerDeviceInfo snapshot_device_info() const;
-    void configure_http(Http& http, const ConnectionSettings& connection) const;
-    static float parse_nozzle_diameter(const nlohmann::json& response);
+    virtual bool init_device_info(const std::string& dev_id, const std::string& dev_ip, const std::string& username, const std::string& password, bool use_ssl, const std::string& port);
+    virtual bool fetch_device_info(const std::string& base_url, const std::string& api_key, MoonrakerDeviceInfo& info, std::string& error) const;
 
     // State access for derived classes
     mutable std::recursive_mutex       state_mutex;
 
-    // Detached fetch threads hold a raw `this`; shutdown() waits for this to reach 0.
-    std::atomic<int> filament_fetch_in_flight{0};
-
-    // Idempotent teardown; must be called from the most-derived destructor.
-    void shutdown();
-    std::atomic<bool> shutting_down{false};
-
-    // Serializes the shutting_down check with the in-flight reservation.
-    std::mutex fetch_lifecycle_mutex;
-    std::condition_variable fetch_done_cv;  // notified when filament_fetch_in_flight reaches 0
-
     // Helpers
     bool        is_numeric(const std::string& value);
     std::string normalize_base_url(bool use_ssl, const std::string& host, const std::string& port);
@@ -213,30 +118,13 @@ protected:
     // Map filament type to OrcaFilamentLibrary preset ID for AMS sync compatibility
     static std::string map_filament_type_to_generic_id(const std::string& filament_type);
 
-    // Send a G-code script via Moonraker (/printer/gcode/script)
-    bool send_gcode(const std::string& dev_id, const std::string& gcode) const;
-    bool send_gcode(const std::string& dev_id, const std::string& gcode,
-                    const ConnectionSettings& connection) const;
-    bool post_print_action(const std::string& action) const;
-    bool post_print_action(const std::string& action,
-                           const ConnectionSettings& connection) const;
-
-    bool send_ws_rpc(const std::string& method, const nlohmann::json& params);
-
-    virtual void on_status_loop_tick(const std::string& dev_id) {}
-
-    // Queue work that may use agent state. The command worker is joined during
-    // destruction, so queued commands cannot outlive the agent.
-    void enqueue_command(std::function<void()> fn);
-    mutable std::recursive_mutex connect_mutex;
-
 private:
     int handle_request(const std::string& dev_id, const std::string& json_str);
     int send_version_info(const std::string& dev_id);
     int send_access_code(const std::string& dev_id);
 
-    bool fetch_object_list(const ConnectionSettings& connection, std::set<std::string>& objects, std::string& error) const;
-    bool query_printer_status(const ConnectionSettings& connection, nlohmann::json& status, std::string& error) const;
+    bool fetch_object_list(const std::string& base_url, const std::string& api_key, std::set<std::string>& objects, std::string& error) const;
+    bool query_printer_status(const std::string& base_url, const std::string& api_key, nlohmann::json& status, std::string& error) const;
     bool send_gcode_sync(const std::string& dev_id, const std::string& gcode) const;
     void send_gcode_async(const std::string& dev_id, const std::string& gcode,
                           std::function<void(bool)> on_result = {}) const;
@@ -244,45 +132,37 @@ private:
     void announce_printhost_device();
     void dispatch_local_connect(int state, const std::string& dev_id, const std::string& msg);
     void dispatch_printer_connected(const std::string& dev_id);
-
-    // Self-contained snapshot of the message callbacks. Async completions capture this
-    // by value so they never dereference `this` after the agent may have been destroyed.
-    struct MessageRouter
-    {
-        OnMessageFn   local_fn;
-        OnMessageFn   cloud_fn;
-        QueueOnMainFn queue_fn;
-        std::string   dev_id;
-
-        void deliver(std::string payload) const;
-    };
-
-    MessageRouter make_message_router(const std::string& dev_id) const;
     void dispatch_message(const std::string& dev_id, const std::string& payload);
-    void start_status_stream(const std::string& dev_id, ConnectionSettings connection);
+    void start_status_stream(const std::string& dev_id, const std::string& base_url, const std::string& api_key);
     void stop_status_stream();
-    void run_status_stream(std::string dev_id, ConnectionSettings connection);
-    void handle_ws_message(std::string dev_id, std::string payload, ConnectionSettings connection);
-    void refresh_thumbnail_url(const ConnectionSettings& connection);
+    void run_status_stream(std::string dev_id, std::string base_url, std::string api_key);
+    void handle_ws_message(const std::string& dev_id, const std::string& payload);
     void update_status_cache(const nlohmann::json& updates);
     nlohmann::json build_print_payload_locked() const;
 
+    // Print control helpers
+    int pause_print(const std::string& dev_id);
+    int resume_print(const std::string& dev_id);
+    int cancel_print(const std::string& dev_id);
+
     // File upload
     bool upload_gcode(const std::string& local_path, const std::string& filename,
-                      const ConnectionSettings& connection,
+                      const std::string& base_url, const std::string& api_key,
                       OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn);
 
+    // JSON-RPC helper
+    bool send_jsonrpc_command(const std::string& base_url, const std::string& api_key,
+                              const nlohmann::json& request, std::string& response) const;
+
     // Connection thread management
     void perform_connection_async(const std::string& dev_id,
-                                   ConnectionSettings connection,
+                                   const std::string& base_url,
+                                   const std::string& api_key,
                                    uint64_t generation);
 
-    void refresh_webcam_info() const;
-    bool fetch_webcam_info(const ConnectionSettings& connection, uint64_t generation) const;
-
     // System-specific filament fetch methods
-    bool fetch_hh_filament_info(const ConnectionSettings& connection, std::vector<AmsTrayData>& trays, int& max_lane_index);
-    bool fetch_moonraker_filament_data(const ConnectionSettings& connection, std::vector<AmsTrayData>& trays, int& max_lane_index);
+    bool fetch_hh_filament_info(std::vector<AmsTrayData>& trays, int& max_lane_index);
+    bool fetch_moonraker_filament_data(std::vector<AmsTrayData>& trays, int& max_lane_index);
 
     // JSON helper methods
     static std::string safe_json_string(const nlohmann::json& obj, const char* key);
@@ -308,43 +188,15 @@ private:
 
     mutable std::recursive_mutex payload_mutex;
     nlohmann::json     status_cache;
-    // note: guarded by payload_mutex; filled by refresh_thumbnail_url(), empty url = looked up, none found
-    std::string        thumbnail_filename;
-    std::string        thumbnail_url;
-    mutable std::string        webcam_stream_url;
-    mutable CameraStreamMode   webcam_stream_mode = CameraStreamMode::none;
-    // Next time the status loop may look the webcam up again (steady_clock ms).
-    mutable std::atomic<uint64_t> webcam_info_next_attempt_ms{0};
-    unsigned            thumbnail_lookup_attempts = 0;
-
-    static constexpr uint64_t WEBCAM_INFO_REFRESH_INTERVAL_MS = 30000;
-    static constexpr uint64_t WEBCAM_INFO_FAILURE_BACKOFF_MS  = 60000;
 
     std::atomic<int>       next_jsonrpc_id{1};
     std::set<std::string>  available_objects;  // Track for feature detection
-    bool                   assumed_light_on = false;
 
     std::atomic<bool>   ws_stop{false};
     std::atomic<bool>   ws_reconnect_requested{false};  // Flag to trigger reconnection
     std::atomic<uint64_t> ws_last_emit_ms{0};
     std::thread         ws_thread;
 
-    // stop_status_stream() invokes ws_abort_io to wake a blocked synchronous
-    // ws.read()/ws.write()/handshake in run_status_stream(): ws_stop is only
-    // observed between reads, and Beast's expires_after() does not bound
-    // synchronous operations.
-    std::mutex             ws_abort_mutex;
-    std::function<void()>  ws_abort_io;  // guarded by ws_abort_mutex
-
-    // Interrupts the exponential reconnect backoff in run_status_stream() when stopping.
-    std::mutex              ws_wait_mutex;
-    std::condition_variable ws_wait_cv;
-
-    // AMS/filament refresh cadence, independent of telemetry dispatch so a steady
-    // stream of status updates can't starve it (ws_last_emit_ms is reset by those).
-    static constexpr uint64_t AMS_REFRESH_INTERVAL_MS = 10000;
-    std::atomic<uint64_t> ams_last_fetch_ms{0};
-
     // Throttling configuration for WebSocket updates
     // Critical changes (state transitions) dispatch immediately; telemetry is throttled
     static constexpr uint64_t STATUS_UPDATE_INTERVAL_MS = 1000;  // 1 update/sec for telemetry
@@ -354,13 +206,7 @@ private:
     // Connection thread management
     std::atomic<uint64_t>  connect_generation{0};
     std::thread            connect_thread;
-
-    void run_command_worker();
-    std::thread cmd_thread;
-    std::deque<std::function<void()>> cmd_queue;
-    std::mutex cmd_mutex;
-    std::condition_variable cmd_cv;
-    bool cmd_stop = false;
+    std::recursive_mutex   connect_mutex;
 };
 
 } // namespace Slic3r

src/slic3r/Utils/QidiPrinterAgent.cpp

@@ -2,25 +2,18 @@
 #include "Http.hpp"
 #include "MoonrakerPrinterAgent.hpp"
 #include "IPrinterAgent.hpp"
-#include "bambu_networking.hpp"
 #include "libslic3r/PresetBundle.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
 
 #include "nlohmann/json.hpp"
-#include <atomic>
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/trim.hpp>
 #include <boost/algorithm/string/case_conv.hpp>
 #include <boost/log/trivial.hpp>
 #include <cctype>
-#include <cmath>
 #include "libslic3r/Preset.hpp"
-#include <cstddef>
-#include <exception>
 #include <map>
-#include <mutex>
 #include <sstream>
-#include <thread>
 #include <string>
 #include <utility>
 #include <vector>
@@ -41,40 +34,6 @@ bool has_visible_base_preset(const PresetCollection& filaments, const std::strin
     return false;
 }
 
-// RAII release of the in-flight fetch slot; movable so a failed thread start still releases it.
-struct InFlightGuard
-{
-    MoonrakerPrinterAgent* owner;
-    explicit InFlightGuard(MoonrakerPrinterAgent& o) noexcept : owner(&o) {}
-    InFlightGuard(InFlightGuard&& other) noexcept : owner(other.owner) { other.owner = nullptr; }
-    InFlightGuard(const InFlightGuard&) = delete;
-    InFlightGuard& operator=(const InFlightGuard&) = delete;
-    InFlightGuard& operator=(InFlightGuard&&) = delete;
-    ~InFlightGuard() { if (owner) owner->release_fetch_slot(); }
-};
-
-// nlohmann::json::value() returns the default only when the key is absent; a present but
-// null/wrong-typed value throws. Firmware JSON is untrusted, so read defensively.
-int read_int_or(const nlohmann::json& obj, const std::string& key, int fallback)
-{
-    auto it = obj.find(key);
-    if (it == obj.end()) {
-        return fallback;
-    }
-    if (it->is_number_integer()) {
-        return it->get<int>();
-    }
-    // Firmware may report an integral field as a JSON float (e.g. 2.0). Accept it only when it
-    // has no fractional part, so a genuinely fractional value falls back instead of truncating.
-    if (it->is_number_float()) {
-        const double value = it->get<double>();
-        if (value == std::floor(value)) {
-            return static_cast<int>(value);
-        }
-    }
-    return fallback;
-}
-
 } // anonymous namespace
 
 const std::string QidiPrinterAgent_VERSION = "0.0.1";
@@ -88,179 +47,51 @@ AgentInfo QidiPrinterAgent::get_agent_info_static()
     return AgentInfo{"qidi", "Qidi", QidiPrinterAgent_VERSION, "Qidi printer agent"};
 }
 
-FilamentSyncMode QidiPrinterAgent::get_filament_sync_mode() const
+bool QidiPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode /*sync_mode*/)
 {
-    if (GUI::wxGetApp().app_config->get_bool("use_printer_agents"))
-        return FilamentSyncMode::subscription;
-    return FilamentSyncMode::pull;
-}
+    std::string error;
 
-bool QidiPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode)
-{
-    if (sync_mode != get_filament_sync_mode())
-        return false;
-
-    // Snapshot what the fetch needs; a reconnect can rewrite device_info meanwhile.
-    ConnectionSettings connection = get_connection_settings();
-    std::string        model_id;
-    std::string        model_name;
+    // 1. Fetch device info and infer series_id
+    std::string series_id;
     {
-        std::lock_guard<std::recursive_mutex> lock(connect_mutex);
-        model_id   = device_info.model_id;
-        model_name = device_info.model_name;
-    }
-
-    // One implementation for both modes; only where it runs differs. pull is the documented
-    // blocking contract (the GUI thread reads DevFilaSystem right after the call), so it runs
-    // on the caller with the payload applied inline. subscription runs on a background thread
-    // so the status loop is not stalled, and the payload is marshalled back to the main thread.
-    auto work = [this, connection = std::move(connection), model_id, model_name](bool apply_inline) -> bool {
-        try {
-            std::string error;
-
-            // 1. Fetch device info and infer series_id
-            std::string series_id;
-            {
-                MoonrakerDeviceInfo info;
-                if (fetch_device_info(connection, info, error)) {
-                    series_id = infer_series_id(info.model_id, info.dev_name);
-                }
-            }
-            if (series_id.empty()) {
-                // Fall back to the configured Orca model if Moonraker doesn't expose a usable identifier.
-                series_id = infer_series_id(model_id, model_name);
-            }
-
-            // 2. Fetch filament dictionary
-            QidiFilamentDict dict;
-            if (!fetch_filament_dict(connection, dict, error)) {
-                BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::fetch_filament_info: Failed to fetch filament dict: " << error;
-            }
-
-            // 3. Fetch slot info and build AmsTrayData directly
-            std::vector<AmsTrayData> trays;
-            int box_count = 0;
-            if (!fetch_slot_info(connection, dict, series_id, trays, box_count, error)) {
-                BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::fetch_filament_info: Failed to fetch slot info: " << error;
-                return false;
-            }
-
-            // 4. Build the AMS payload, resolving preset-dependent ids on the main thread.
-            auto resolve_ids = [](std::vector<AmsTrayData>& resolved_trays) {
-                auto* bundle = GUI::wxGetApp().preset_bundle;
-                if (!bundle) {
-                    return; // keep the Qidi-specific ids computed from device data
-                }
-                for (auto& tray : resolved_trays) {
-                    if (!tray.has_filament) {
-                        continue;
-                    }
-                    if (!tray.tray_info_idx.empty() && has_visible_base_preset(bundle->filaments, tray.tray_info_idx)) {
-                        continue;
-                    }
-                    tray.tray_info_idx = bundle->filaments.filament_id_by_type(tray.tray_type);
-                }
-            };
-            build_ams_payload(box_count, box_count * 4 - 1, trays, apply_inline, resolve_ids);
-            return true;
-        } catch (const std::exception& e) {
-            // why: an exception escaping a detached thread is std::terminate, and firmware
-            // JSON is untrusted; mirror run_command_worker and swallow it here.
-            BOOST_LOG_TRIVIAL(error) << "QidiPrinterAgent::fetch_filament_info: unhandled exception: " << e.what();
-            return false;
-        } catch (...) {
-            BOOST_LOG_TRIVIAL(error) << "QidiPrinterAgent::fetch_filament_info: unhandled exception";
-            return false;
+        MoonrakerDeviceInfo info;
+        if (fetch_device_info(device_info.base_url, device_info.api_key, info, error)) {
+            series_id = infer_series_id(info.model_id, info.dev_name);
         }
-    };
-
-    if (sync_mode == FilamentSyncMode::pull) {
-        return work(/*apply_inline=*/true);
+    }
+    if (series_id.empty()) {
+        // Fall back to the configured Orca model if Moonraker doesn't expose a usable identifier.
+        series_id = infer_series_id(device_info.model_id, device_info.model_name);
     }
 
-    // Subscription: fire-and-forget. A `true` return means the refresh was scheduled (or is
-    // already running), not that DevFilaSystem has been updated. Reserve under the same mutex
-    // shutdown() uses, so the flag and the count can't race.
-    {
-        std::lock_guard<std::mutex> lock(fetch_lifecycle_mutex);
-        if (shutting_down.load())
-            return false;
-        if (filament_fetch_in_flight.load() > 0)
-            return true; // a fetch is already running; don't pile on
-        filament_fetch_in_flight.fetch_add(1, std::memory_order_relaxed);
+    // 2. Fetch filament dictionary
+    QidiFilamentDict dict;
+    if (!fetch_filament_dict(device_info.base_url, device_info.api_key, dict, error)) {
+        BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::fetch_filament_info: Failed to fetch filament dict: " << error;
     }
 
-    InFlightGuard guard{*this};
-    std::thread([work = std::move(work), guard = std::move(guard)]() mutable {
-        work(/*apply_inline=*/false);
-    }).detach();
+    // 3. Fetch slot info and build AmsTrayData directly
+    std::vector<AmsTrayData> trays;
+    int                      box_count = 0;
+    if (!fetch_slot_info(device_info.base_url, device_info.api_key, dict, series_id, trays, box_count, error)) {
+        BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::fetch_filament_info: Failed to fetch slot info: " << error;
+        return false;
+    }
+
+    // 4. Build the AMS payload
+    build_ams_payload(box_count, box_count * 4 - 1, trays);
     return true;
 }
 
-bool QidiPrinterAgent::apply_box_mapping(const PrintParams& params) const
-{
-    // enable_box mirrors task_use_ams: engage the multi-color box only when this
-    // job actually routes filament through it. (See qidi-ams-findings.md §2/§8.3 —
-    // if firmware treats enable_box as "a box exists" rather than "use it this job",
-    // switch this gate to HasAms()/box_count instead.)
-    const int         enable = params.task_use_ams ? 1 : 0;
-    const std::string dev_id = get_connection_settings().dev_id;
-
-    // Build one gcode/script request instead of N blocking HTTP calls: apply_box_mapping
-    // runs on the caller's (GUI) thread before the print starts, so per-tool round trips
-    // would freeze the UI.
-    std::string script = "SAVE_VARIABLE VARIABLE=enable_box VALUE=" + std::to_string(enable);
-
-    // When the box isn't used this job, leave the existing value_t<tool> slot
-    // assignments untouched (enable_box=0 is enough to disengage it).
-    if (enable) {
-        if (params.ams_mapping.empty()) {
-            BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::apply_box_mapping: enable_box set but ams_mapping is empty";
-        } else {
-            // ams_mapping (v0) is a JSON array indexed by filament/tool; each value is the
-            // physical box slot (-1 = unmapped). Mirror it onto value_t<tool>.
-            auto mapping = nlohmann::json::parse(params.ams_mapping, nullptr, /*allow_exceptions*/ false);
-            if (mapping.is_discarded() || !mapping.is_array()) {
-                BOOST_LOG_TRIVIAL(error) << "QidiPrinterAgent::apply_box_mapping: invalid ams_mapping: " << params.ams_mapping;
-                return false;
-            }
-            for (size_t tool = 0; tool < mapping.size(); ++tool) {
-                if (!mapping[tool].is_number_integer())
-                    continue;
-                const int slot = mapping[tool].get<int>();
-                if (slot < 0)
-                    continue; // unmapped filament — skip
-                script += "\nSAVE_VARIABLE VARIABLE=value_t" + std::to_string(tool) +
-                          " VALUE=\"'slot" + std::to_string(slot) + "'\"";
-            }
-        }
-    }
-
-    if (!send_gcode(dev_id, script)) {
-        BOOST_LOG_TRIVIAL(error) << "QidiPrinterAgent::apply_box_mapping: failed to send box mapping";
-        return false;
-    }
-    return true;
-}
-
-int QidiPrinterAgent::start_local_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn)
-{
-    // Only the LAN print path is implemented by the Moonraker base; the box config is emitted
-    // here, before the print starts. The cloud/record/sdcard variants inherited from the base
-    // deliberately return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED without side effects.
-    if (!apply_box_mapping(params))
-        return BAMBU_NETWORK_ERR_PRINT_LP_PUBLISH_MSG_FAILED;
-    return MoonrakerPrinterAgent::start_local_print(std::move(params), update_fn, cancel_fn);
-}
-
-bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
+bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
+                                       const std::string&        api_key,
                                        const QidiFilamentDict&   dict,
                                        const std::string&        series_id,
                                        std::vector<AmsTrayData>& trays,
                                        int&                      box_count,
                                        std::string&              error)
 {
-    std::string url = join_url(connection.base_url, "/printer/objects/query?save_variables=variables");
+    std::string url = join_url(base_url, "/printer/objects/query?save_variables=variables");
     for (int i = 0; i < 16; ++i) {
         url += "&box_stepper%20slot" + std::to_string(i) + "=runout_button";
     }
@@ -270,9 +101,8 @@ bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
     std::string http_error;
 
     auto http = Http::get(url);
-    configure_http(http, connection);
-    if (!connection.api_key.empty()) {
-        http.header("X-Api-Key", connection.api_key);
+    if (!api_key.empty()) {
+        http.header("X-Api-Key", api_key);
     }
     http.timeout_connect(5)
         .timeout_max(10)
@@ -297,12 +127,22 @@ bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
         return false;
     }
 
-    nlohmann::json status;
-    nlohmann::json variables;
-    if (!parse_slot_response(response_body, status, variables, error))
+    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
+    if (json.is_discarded()) {
+        error = "Invalid JSON response";
         return false;
+    }
 
-    box_count = read_int_or(variables, "box_count", 1);
+    if (!json.contains("result") || !json["result"].contains("status") || !json["result"]["status"].contains("save_variables") ||
+        !json["result"]["status"]["save_variables"].contains("variables")) {
+        error = "Unexpected JSON structure";
+        return false;
+    }
+
+    auto& variables = json["result"]["status"]["save_variables"]["variables"];
+    auto& status    = json["result"]["status"];
+
+    box_count = variables.value("box_count", 1);
     if (box_count < 0) {
         box_count = 0;
     }
@@ -325,9 +165,9 @@ bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
         tray.slot_index = i;
 
         // Read slot variables
-        const int color_index     = read_int_or(variables, "color_slot" + std::to_string(i), 1);
-        const int filament_type   = read_int_or(variables, "filament_slot" + std::to_string(i), 1);
-        const int vendor_type     = read_int_or(variables, "vendor_slot" + std::to_string(i), 0);
+        const int color_index     = variables.value("color_slot" + std::to_string(i), 1);
+        const int filament_type   = variables.value("filament_slot" + std::to_string(i), 1);
+        const int vendor_type     = variables.value("vendor_slot" + std::to_string(i), 0);
 
         // Check filament presence via runout sensor
         std::string box_stepper_key = "box_stepper slot" + std::to_string(i);
@@ -335,7 +175,7 @@ bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
         if (status.contains(box_stepper_key)) {
             auto& box_stepper = status[box_stepper_key];
             if (box_stepper.contains("runout_button") && !box_stepper["runout_button"].is_null()) {
-                const int runout_button = read_int_or(box_stepper, "runout_button", 0);
+                int runout_button = box_stepper["runout_button"].template get<int>();
                 tray.has_filament = (runout_button == 0);
             }
         }
@@ -349,9 +189,16 @@ bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
             }
             tray.tray_type = normalize_filament_type(filament_name);
 
-            // Qidi-specific setting id derived from device data only; the preset-dependent
-            // fallback runs on the main thread in the resolve hook passed to build_ams_payload.
-            tray.tray_info_idx = build_setting_id(filament_type, vendor_type, tray.tray_type);
+            // Try Qidi-specific setting ID first; fall back to visible preset by type
+            std::string setting_id = build_setting_id(filament_type, vendor_type, tray.tray_type);
+            auto* bundle = GUI::wxGetApp().preset_bundle;
+            if (!bundle) {
+                tray.tray_info_idx = setting_id;
+            } else if (!setting_id.empty() && has_visible_base_preset(bundle->filaments, setting_id)) {
+                tray.tray_info_idx = setting_id;
+            } else {
+                tray.tray_info_idx = bundle->filaments.filament_id_by_type(tray.tray_type);
+            }
 
             // Look up color from dictionary
             auto color_it = dict.colors.find(color_index);
@@ -368,45 +215,20 @@ bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
     return true;
 }
 
-bool QidiPrinterAgent::parse_slot_response(const std::string& response_body,
-                                           nlohmann::json&    status,
-                                           nlohmann::json&    variables,
-                                           std::string&       error)
-{
-    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
-    if (json.is_discarded()) {
-        error = "Invalid JSON response";
-        return false;
-    }
-
-    if (!json.is_object() || !json.contains("result") || !json["result"].is_object() || !json["result"].contains("status") ||
-        !json["result"]["status"].is_object() || !json["result"]["status"].contains("save_variables") ||
-        !json["result"]["status"]["save_variables"].is_object() || !json["result"]["status"]["save_variables"].contains("variables") ||
-        !json["result"]["status"]["save_variables"]["variables"].is_object()) {
-        // why: Qidi firmware may send null here, but json::value() throws for it.
-        error = "Unexpected JSON structure: save_variables.variables must be an object";
-        return false;
-    }
-
-    status    = json["result"]["status"];
-    variables = status["save_variables"]["variables"];
-    return true;
-}
-
-bool QidiPrinterAgent::fetch_filament_dict(const ConnectionSettings& connection,
+bool QidiPrinterAgent::fetch_filament_dict(const std::string& base_url,
+                                           const std::string& api_key,
                                            QidiFilamentDict& dict,
                                            std::string& error) const
 {
-    std::string url = join_url(connection.base_url, "/server/files/config/officiall_filas_list.cfg");
+    std::string url = join_url(base_url, "/server/files/config/officiall_filas_list.cfg");
 
     std::string response_body;
     bool        success = false;
     std::string http_error;
 
     auto http = Http::get(url);
-    configure_http(http, connection);
-    if (!connection.api_key.empty()) {
-        http.header("X-Api-Key", connection.api_key);
+    if (!api_key.empty()) {
+        http.header("X-Api-Key", api_key);
     }
     http.timeout_connect(5)
         .timeout_max(10)

src/slic3r/Utils/QidiPrinterAgent.hpp

@@ -3,8 +3,6 @@
 
 #include "IPrinterAgent.hpp"
 #include "MoonrakerPrinterAgent.hpp"
-#include "bambu_networking.hpp"
-#include "nlohmann/json_fwd.hpp"
 
 #include <map>
 #include <string>
@@ -16,7 +14,7 @@ class QidiPrinterAgent final : public MoonrakerPrinterAgent
 {
 public:
     explicit QidiPrinterAgent(std::string log_dir);
-    ~QidiPrinterAgent() override { shutdown(); }
+    ~QidiPrinterAgent() override = default;
 
     static AgentInfo get_agent_info_static();
     AgentInfo        get_agent_info() override { return get_agent_info_static(); }
@@ -24,22 +22,7 @@ public:
     // Override filament sync (Qidi-specific implementation)
     bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
 
-    static bool parse_slot_response(const std::string& response_body,
-                                    nlohmann::json&    status,
-                                    nlohmann::json&    variables,
-                                    std::string&       error);
-
-    // Print operations — emit QiDi multi-color box config, then delegate to base.
-    // Only the LAN print path is supported by the base; the cloud/record/sdcard variants
-    // are inherited and return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED.
-    int start_local_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn) override;
-
-    FilamentSyncMode get_filament_sync_mode() const override;
-
 private:
-    // Push enable_box + value_t<tool> SAVE_VARIABLEs before a print starts.
-    // Returns false if any command fails (caller should abort the print).
-    bool apply_box_mapping(const PrintParams& params) const;
     struct QidiFilamentDict
     {
         std::map<int, std::string> colors;
@@ -47,13 +30,14 @@ private:
     };
 
     // Qidi-specific methods
-    bool fetch_slot_info(const ConnectionSettings& connection,
+    bool fetch_slot_info(const std::string&        base_url,
+                         const std::string&        api_key,
                          const QidiFilamentDict&   dict,
                          const std::string&        series_id,
                          std::vector<AmsTrayData>& trays,
                          int&                      box_count,
                          std::string&              error);
-    bool fetch_filament_dict(const ConnectionSettings& connection, QidiFilamentDict& dict, std::string& error) const;
+    bool fetch_filament_dict(const std::string& base_url, const std::string& api_key, QidiFilamentDict& dict, std::string& error) const;
     std::string normalize_filament_type(const std::string& filament_type);
     std::string infer_series_id(const std::string& model_id, const std::string& dev_name);
     std::string normalize_model_key(std::string value);

src/slic3r/Utils/SnapmakerPrinterAgent.cpp

@@ -2,20 +2,11 @@
 #include "Http.hpp"
 #include "MoonrakerPrinterAgent.hpp"
 #include "IPrinterAgent.hpp"
-#include "bambu_networking.hpp"
 #include "libslic3r/PresetBundle.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
 
 #include "nlohmann/json.hpp"
-#include <atomic>
 #include <boost/log/trivial.hpp>
-#include <chrono>
-#include <cmath>
-#include <cstdint>
-#include <exception>
-#include <mutex>
-#include <sstream>
-#include <thread>
 #include <vector>
 #include <string>
 #include "libslic3r/Preset.hpp"
@@ -27,91 +18,6 @@ namespace Slic3r {
 namespace {
 
 constexpr const char* SNAPMAKER_AGENT_VERSION = "0.0.1";
-constexpr int64_t     CAMERA_REFRESH_INTERVAL_MS = 300'000;
-
-int64_t now_ms()
-{
-    return std::chrono::duration_cast<std::chrono::milliseconds>(
-        std::chrono::steady_clock::now().time_since_epoch()).count();
-}
-
-// RAII release of the in-flight fetch slot; movable so a failed thread start still releases it.
-struct InFlightGuard
-{
-    MoonrakerPrinterAgent* owner;
-    explicit InFlightGuard(MoonrakerPrinterAgent& o) noexcept : owner(&o) {}
-    InFlightGuard(InFlightGuard&& other) noexcept : owner(other.owner) { other.owner = nullptr; }
-    InFlightGuard(const InFlightGuard&) = delete;
-    InFlightGuard& operator=(const InFlightGuard&) = delete;
-    InFlightGuard& operator=(InFlightGuard&&) = delete;
-    ~InFlightGuard() { if (owner) owner->release_fetch_slot(); }
-};
-
-// nlohmann::json::value() returns the default only when the key is absent; a present but
-// null/wrong-typed value throws. Firmware JSON is untrusted, so read defensively.
-int read_int_or(const nlohmann::json& obj, const char* key, int fallback)
-{
-    auto it = obj.find(key);
-    if (it == obj.end()) {
-        return fallback;
-    }
-    if (it->is_number_integer()) {
-        return it->get<int>();
-    }
-    // Firmware may report an integral field as a JSON float (e.g. 2.0). Accept it only when it
-    // has no fractional part, so a genuinely fractional value falls back instead of truncating.
-    if (it->is_number_float()) {
-        const double value = it->get<double>();
-        if (value == std::floor(value)) {
-            return static_cast<int>(value);
-        }
-    }
-    return fallback;
-}
-
-std::vector<std::string> read_string_array_or(const nlohmann::json& obj, const char* key)
-{
-    auto it = obj.find(key);
-    if (it == obj.end() || !it->is_array())
-        return {};
-    std::vector<std::string> out;
-    out.reserve(it->size());
-    for (const auto& v : *it)
-        out.push_back(v.is_string() ? v.get<std::string>() : std::string{});
-    return out;
-}
-
-std::vector<bool> read_bool_array_or(const nlohmann::json& obj, const char* key)
-{
-    auto it = obj.find(key);
-    if (it == obj.end() || !it->is_array())
-        return {};
-    std::vector<bool> out;
-    out.reserve(it->size());
-    for (const auto& v : *it)
-        out.push_back(v.is_boolean() ? v.get<bool>() : false);
-    return out;
-}
-
-// Parse a hex colour, stopping at the first non-hex character. std::stoul throws on
-// empty/non-hex input, which must not escape the detached fetch thread.
-unsigned int parse_hex_color(const std::string& hex)
-{
-    unsigned int value = 0;
-    for (char c : hex) {
-        int digit;
-        if (c >= '0' && c <= '9')
-            digit = c - '0';
-        else if (c >= 'a' && c <= 'f')
-            digit = c - 'a' + 10;
-        else if (c >= 'A' && c <= 'F')
-            digit = c - 'A' + 10;
-        else
-            break;
-        value = (value << 4) | static_cast<unsigned int>(digit);
-    }
-    return value;
-}
 
 // Safely access a parallel array by index, returning a fallback if out of bounds.
 template<typename T>
@@ -134,16 +40,14 @@ std::string find_closest_color_preset_by_vendor_and_type(const PresetCollection&
             filaments.get_preset_base(p) == &p && p.config.opt_string("filament_vendor", 0u) == vendor_name &&
             p.config.opt_string("filament_type", 0u) == filament_type) {
             // The printer returns RGBA in the format RRGGBBAA, but profiles store color as #RRGGBB,
-            // so we must remove # and ignore alpha channel for distance calculation. Firmware
-            // colours are untrusted; parse_hex_color tolerates empty/non-hex instead of throwing.
-            unsigned int target_color_value =
-                parse_hex_color(color_rgba.substr(0, color_rgba.size() >= 2 ? color_rgba.size() - 2 : 0));
+            // so we must remove # and ignore alpha channel for distance calculation
+            unsigned int target_color_value = std::stoul(color_rgba.substr(0, color_rgba.length() - 2), nullptr, 16);
 
             std::string  p_color = p.config.opt_string("default_filament_colour", 0u);
-            unsigned int p_color_value = 0;
+            unsigned int p_color_value;
             if (!p_color.empty()) {
-                size_t hash_pos = p_color.find("#");
-                p_color_value   = parse_hex_color(p_color.substr(hash_pos != std::string::npos ? hash_pos + 1 : 0));
+                size_t       hash_pos = p_color.find("#");
+                p_color_value         = std::stoul(p_color.substr(hash_pos != std::string::npos ? hash_pos + 1 : 0), nullptr, 16);
             } else {
                 // Default to black if no color specified in profile. Assume other profiles might be a closer color match.
                 // Could be a problem if the target color is also black and there exist a specific profile for that type, vendor and color
@@ -170,31 +74,6 @@ std::string find_closest_color_preset_by_vendor_and_type(const PresetCollection&
 
 SnapmakerPrinterAgent::SnapmakerPrinterAgent(std::string log_dir) : MoonrakerPrinterAgent(std::move(log_dir)) {}
 
-void SnapmakerPrinterAgent::start_camera_monitor()
-{
-    enqueue_command([this] {
-        send_ws_rpc("camera.start_monitor",
-                    {{"domain", "lan"}, {"interval", 0}, {"expect_pw", false}});
-    });
-    m_camera_last_fire_ms.store(now_ms());
-}
-
-void SnapmakerPrinterAgent::on_status_loop_tick(const std::string& dev_id)
-{
-    (void) dev_id;
-    const int64_t last = m_camera_last_fire_ms.load();
-    if (last == 0 || now_ms() - last >= CAMERA_REFRESH_INTERVAL_MS) {
-        start_camera_monitor();
-    }
-}
-
-int SnapmakerPrinterAgent::command_start_camera(std::string dev_id)
-{
-    (void) dev_id;
-    start_camera_monitor();
-    return BAMBU_NETWORK_SUCCESS;
-}
-
 AgentInfo SnapmakerPrinterAgent::get_agent_info_static()
 {
     return AgentInfo{"snapmaker", "Snapmaker", SNAPMAKER_AGENT_VERSION, "Snapmaker printer agent"};
@@ -230,192 +109,127 @@ std::string SnapmakerPrinterAgent::combine_filament_type(const std::string& type
     return base;
 }
 
-bool SnapmakerPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode)
+bool SnapmakerPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode /*sync_mode*/)
 {
-    (void) dev_id;
-    if (sync_mode != get_filament_sync_mode())
+    std::string url = join_url(device_info.base_url, "/printer/objects/query?print_task_config&filament_detect");
+
+    std::string response_body;
+    bool        success = false;
+    std::string http_error;
+
+    auto http = Http::get(url);
+    if (!device_info.api_key.empty()) {
+        http.header("X-Api-Key", device_info.api_key);
+    }
+    http.timeout_connect(5)
+        .timeout_max(10)
+        .on_complete([&](std::string body, unsigned status) {
+            if (status == 200) {
+                response_body = body;
+                success       = true;
+            } else {
+                http_error = "HTTP error: " + std::to_string(status);
+            }
+        })
+        .on_error([&](std::string body, std::string err, unsigned status) {
+            http_error = err;
+            if (status > 0) {
+                http_error += " (HTTP " + std::to_string(status) + ")";
+            }
+        })
+        .perform_sync();
+
+    if (!success) {
+        BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: HTTP request failed: " << http_error;
         return false;
+    }
 
-    // Snapshot everything the fetch needs (URL, api key, TLS/CA): a reconnect can rewrite
-    // device_info meanwhile.
-    const ConnectionSettings connection = get_connection_settings();
+    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
+    if (json.is_discarded()) {
+        BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Invalid JSON response";
+        return false;
+    }
 
-    // One implementation for both modes; only where it runs differs. pull is the documented
-    // blocking contract (the GUI thread reads DevFilaSystem right after the call), so it runs
-    // on the caller with the payload applied inline. subscription runs on a background thread
-    // so the status loop is not stalled, and the payload is marshalled back to the main thread.
-    auto work = [this, connection](bool apply_inline) -> bool {
-        try {
-            const std::string url = join_url(connection.base_url, "/printer/objects/query?print_task_config&filament_detect");
+    // Navigate to result.status.print_task_config
+    if (!json.contains("result") || !json["result"].contains("status") ||
+        !json["result"]["status"].contains("print_task_config")) {
+        BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Missing print_task_config in response";
+        return false;
+    }
 
-            std::string response_body;
-            bool success = false;
-            std::string http_error;
+    auto& ptc = json["result"]["status"]["print_task_config"];
 
-            auto http = Http::get(url);
-            configure_http(http, connection);
-            if (!connection.api_key.empty()) {
-                http.header("X-Api-Key", connection.api_key);
-            }
-            http.timeout_connect(5)
-                .timeout_max(10)
-                .on_complete([&](std::string body, unsigned status) {
-                    if (status == 200) {
-                        response_body = body;
-                        success       = true;
-                    } else {
-                        http_error = "HTTP error: " + std::to_string(status);
-                    }
-                })
-                .on_error([&](std::string body, std::string err, unsigned status) {
-                    http_error = err;
-                    if (status > 0) {
-                        http_error += " (HTTP " + std::to_string(status) + ")";
-                    }
-                })
-                .perform_sync();
+    // Read parallel arrays from print_task_config
+    auto filament_exist    = ptc.value("filament_exist", std::vector<bool>{});
+    auto filament_type     = ptc.value("filament_type", std::vector<std::string>{});
+    auto filament_sub_type = ptc.value("filament_sub_type", std::vector<std::string>{});
+    auto filament_color    = ptc.value("filament_color_rgba", std::vector<std::string>{});
+    auto filament_vendor   = ptc.value("filament_vendor", std::vector<std::string>{});
 
-            if (!success) {
-                BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: HTTP request failed: " << http_error;
-                return false;
-            }
+    const int slot_count = static_cast<int>(filament_exist.size());
+    if (slot_count == 0) {
+        BOOST_LOG_TRIVIAL(info) << "SnapmakerPrinterAgent::fetch_filament_info: No filament slots reported";
+        return false;
+    }
 
-            auto json = nlohmann::json::parse(response_body, nullptr, false, true);
-            if (json.is_discarded()) {
-                BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Invalid JSON response";
-                return false;
-            }
+    // Read NFC filament_detect data for temperature info (optional)
+    nlohmann::json nfc_info;
+    if (json["result"]["status"].contains("filament_detect") &&
+        json["result"]["status"]["filament_detect"].contains("info")) {
+        nfc_info = json["result"]["status"]["filament_detect"]["info"];
+    }
 
-            // Navigate to result.status.print_task_config
-            if (!json.contains("result") || !json["result"].contains("status") || !json["result"]["status"].contains("print_task_config")) {
-                BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Missing print_task_config in response";
-                return false;
-            }
+    static const std::string empty_str;
+    static const std::string default_color = "FFFFFFFF";
 
-            auto& ptc = json["result"]["status"]["print_task_config"];
+    std::vector<AmsTrayData> trays;
+    trays.reserve(slot_count);
 
-            // Read parallel arrays from print_task_config
-            auto filament_exist    = read_bool_array_or(ptc, "filament_exist");
-            auto filament_type     = read_string_array_or(ptc, "filament_type");
-            auto filament_sub_type = read_string_array_or(ptc, "filament_sub_type");
-            auto filament_color    = read_string_array_or(ptc, "filament_color_rgba");
-            auto filament_vendor   = read_string_array_or(ptc, "filament_vendor");
+    for (int i = 0; i < slot_count; ++i) {
+        AmsTrayData tray;
+        tray.slot_index   = i;
+        tray.has_filament = filament_exist[i];
 
-            const int slot_count = static_cast<int>(filament_exist.size());
-            if (slot_count == 0) {
-                BOOST_LOG_TRIVIAL(info) << "SnapmakerPrinterAgent::fetch_filament_info: No filament slots reported";
-                return false;
-            }
+        if (tray.has_filament) {
+            tray.tray_type     = combine_filament_type(safe_at(filament_type, i, empty_str),
+                                                       safe_at(filament_sub_type, i, empty_str));
+            tray.tray_color    = safe_at(filament_color, i, default_color);
 
-            // Read NFC filament_detect data for temperature info (optional)
-            nlohmann::json nfc_info;
-            if (json["result"]["status"].contains("filament_detect") && json["result"]["status"]["filament_detect"].contains("info")) {
-                nfc_info = json["result"]["status"]["filament_detect"]["info"];
-            }
+            auto* bundle = GUI::wxGetApp().preset_bundle;
+            // Try to find a matching preset for this filament based on vendor, type and color.
+            // If not found, default to traditional search by type only or generic type mapping.
+            if (bundle) {
+                std::string vendor      = safe_at(filament_vendor, i, empty_str);
+                std::string filament_id = find_closest_color_preset_by_vendor_and_type(bundle->filaments, vendor, tray.tray_type,
+                                                                                       tray.tray_color);
 
-            static const std::string empty_str;
-            static const std::string default_color = "FFFFFFFF";
-
-            // Per-tray vendor names, kept so the preset lookup can run on the main thread.
-            std::vector<std::string> vendors(slot_count);
-
-            std::vector<AmsTrayData> trays;
-            trays.reserve(slot_count);
-
-            for (int i = 0; i < slot_count; ++i) {
-                AmsTrayData tray;
-                tray.slot_index   = i;
-                tray.has_filament = filament_exist[i];
-
-                if (tray.has_filament) {
-                    tray.tray_type  = combine_filament_type(safe_at(filament_type, i, empty_str), safe_at(filament_sub_type, i, empty_str));
-                    tray.tray_color = safe_at(filament_color, i, default_color);
-                    vendors[i]      = safe_at(filament_vendor, i, empty_str);
-
-                    // Generic id derived from device data only; the preset-dependent lookup runs
-                    // on the main thread in the resolve hook passed to build_ams_payload.
-                    tray.tray_info_idx = map_filament_type_to_generic_id(tray.tray_type);
-
-                    // Extract NFC temperature data if available
-                    if (nfc_info.is_array() && i < static_cast<int>(nfc_info.size()) && nfc_info[i].is_object()) {
-                        auto&       nfc_slot = nfc_info[i];
-                        std::string vendor   = "NONE";
-                        if (auto vendor_it = nfc_slot.find("VENDOR"); vendor_it != nfc_slot.end() && vendor_it->is_string()) {
-                            vendor = vendor_it->get<std::string>();
-                        }
-                        if (vendor != "NONE" && !vendor.empty()) {
-                            tray.bed_temp    = read_int_or(nfc_slot, "BED_TEMP", 0);
-                            tray.nozzle_temp = read_int_or(nfc_slot, "FIRST_LAYER_TEMP", 0);
-                        }
-                    }
+                if (!filament_id.empty()) {
+                    tray.tray_info_idx = filament_id;
+                    BOOST_LOG_TRIVIAL(warning) << "Filament sync: Found manufacturer-specific profile for slot " << i << ": "
+                                               << filament_id;
+                } else {
+                    tray.tray_info_idx = bundle->filaments.filament_id_by_type(tray.tray_type);
                 }
-
-                trays.emplace_back(std::move(tray));
+            } else {
+                tray.tray_info_idx = map_filament_type_to_generic_id(tray.tray_type);
             }
 
-            // Resolve against GUI-owned presets on the main thread (inside build_ams_payload).
-            auto resolve_ids = [vendors](std::vector<AmsTrayData>& resolved_trays) {
-                auto* bundle = GUI::wxGetApp().preset_bundle;
-                if (!bundle) {
-                    return; // keep the generic ids computed from device data
+            // Extract NFC temperature data if available
+            if (nfc_info.is_array() && i < static_cast<int>(nfc_info.size()) && nfc_info[i].is_object()) {
+                auto& nfc_slot = nfc_info[i];
+                std::string vendor = nfc_slot.value("VENDOR", "NONE");
+                if (vendor != "NONE" && !vendor.empty()) {
+                    tray.bed_temp    = nfc_slot.value("BED_TEMP", 0);
+                    tray.nozzle_temp = nfc_slot.value("FIRST_LAYER_TEMP", 0);
                 }
-                for (size_t i = 0; i < resolved_trays.size() && i < vendors.size(); ++i) {
-                    AmsTrayData& tray = resolved_trays[i];
-                    if (!tray.has_filament) {
-                        continue;
-                    }
-                    // Prefer a manufacturer/colour-specific preset, else fall back to type.
-                    std::string filament_id = find_closest_color_preset_by_vendor_and_type(bundle->filaments, vendors[i], tray.tray_type,
-                                                                                           tray.tray_color);
-                    tray.tray_info_idx = filament_id.empty() ? bundle->filaments.filament_id_by_type(tray.tray_type) : filament_id;
-                }
-            };
-            build_ams_payload(1, slot_count - 1, trays, apply_inline, resolve_ids);
-            return true;
-        } catch (const std::exception& e) {
-            // why: an exception escaping a detached thread is std::terminate, and firmware
-            // JSON is untrusted; mirror run_command_worker and swallow it here.
-            BOOST_LOG_TRIVIAL(error) << "SnapmakerPrinterAgent::fetch_filament_info: unhandled exception: " << e.what();
-            return false;
-        } catch (...) {
-            BOOST_LOG_TRIVIAL(error) << "SnapmakerPrinterAgent::fetch_filament_info: unhandled exception";
-            return false;
+            }
         }
-    };
 
-    if (sync_mode == FilamentSyncMode::pull) {
-        return work(/*apply_inline=*/true);
+        trays.emplace_back(std::move(tray));
     }
 
-    // Subscription: fire-and-forget. A `true` return means the refresh was scheduled (or is
-    // already running), not that DevFilaSystem has been updated. Reserve under the same mutex
-    // shutdown() uses, so the flag and the count can't race.
-    {
-        std::lock_guard<std::mutex> lock(fetch_lifecycle_mutex);
-        if (shutting_down.load())
-            return false;
-        if (filament_fetch_in_flight.load() > 0)
-            return true; // a fetch is already running; don't pile on
-        filament_fetch_in_flight.fetch_add(1, std::memory_order_relaxed);
-    }
-
-    InFlightGuard guard{*this};
-    std::thread([work = std::move(work), guard = std::move(guard)]() mutable {
-        work(/*apply_inline=*/false);
-    }).detach();
+    build_ams_payload(1, slot_count - 1, trays);
     return true;
 }
 
-std::string SnapmakerPrinterAgent::get_camera_url() const
-{
-    return join_url(get_connection_settings().base_url, "/server/files/camera/monitor.jpg");
-}
-
-FilamentSyncMode SnapmakerPrinterAgent::get_filament_sync_mode() const
-{
-    if (GUI::wxGetApp().app_config->get_bool("use_printer_agents"))
-        return FilamentSyncMode::subscription;
-    return FilamentSyncMode::pull;
-}
-
 } // namespace Slic3r

src/slic3r/Utils/SnapmakerPrinterAgent.hpp

@@ -3,8 +3,6 @@
 #include "IPrinterAgent.hpp"
 #include "MoonrakerPrinterAgent.hpp"
 
-#include <atomic>
-#include <cstdint>
 #include <string>
 
 namespace Slic3r {
@@ -13,25 +11,16 @@ class SnapmakerPrinterAgent final : public MoonrakerPrinterAgent
 {
 public:
     explicit SnapmakerPrinterAgent(std::string log_dir);
-    ~SnapmakerPrinterAgent() override { shutdown(); }
+    ~SnapmakerPrinterAgent() override = default;
 
     static AgentInfo get_agent_info_static();
     AgentInfo        get_agent_info() override { return get_agent_info_static(); }
 
     bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
-    FilamentSyncMode get_filament_sync_mode() const override;
-    int command_start_camera(std::string dev_id) override;
-    CameraStreamMode get_camera_stream_mode() const override { return CameraStreamMode::http_snapshot; }
-    std::string get_camera_url() const override;
 
 private:
     // Combine filament_type + filament_sub_type into a unified type string
     static std::string combine_filament_type(const std::string& type, const std::string& sub_type);
-
-    void start_camera_monitor();
-    void on_status_loop_tick(const std::string& dev_id) override;
-
-    std::atomic<int64_t> m_camera_last_fire_ms{0};
 };
 
 } // namespace Slic3r

tests/fff_print/test_perimeters.cpp

@@ -22,7 +22,6 @@
 #include "libslic3r/ClipperUtils.hpp"
 #include "libslic3r/ExPolygon.hpp"
 #include "libslic3r/Point.hpp"
-#include "libslic3r/Polygon.hpp"
 #include "libslic3r/Polyline.hpp"
 #include <limits>
 #include <string>
@@ -995,384 +994,3 @@ TEST_CASE("A hole whose outer wall touches the contour's runs with it", "[Perime
         CHECK(layers[i].holes_ccw.front() == ccw);
     }
 }
-
-namespace {
-
-// The outer radius of round_tube().
-const double tube_radius = 11.5;
-
-// Every setting the tube walls below are measured against. With 0.5mm walls a 1mm tube wall holds only the two
-// outer walls, touching, and every further 0.5mm makes room for one more inner wall.
-DynamicPrintConfig tube_config(const char *wall_generator, int wall_loops)
-{
-    DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
-    config.set_deserialize_strict({
-        { "wall_generator",             wall_generator },
-        { "wall_loops",                 wall_loops },
-        { "wall_sequence",              "inner wall/outer wall" },
-        { "wall_direction",             "ccw" },
-        { "layer_height",               0.2 },
-        { "initial_layer_print_height", 0.2 },
-        { "nozzle_diameter",            "0.4" },
-        { "outer_wall_line_width",      0.5 },
-        { "inner_wall_line_width",      0.5 },
-        { "precise_outer_wall",         true },
-        { "detect_thin_wall",           false },
-        { "only_one_wall_top",          false },
-        { "only_one_wall_first_layer",  false },
-        { "brim_type",                  "no_brim" },
-        { "detect_overhang_wall",       true },
-        { "overhang_reverse",           false },
-        { "overhang_reverse_threshold", "0%" },
-    });
-    return config;
-}
-
-// A 2mm tall round tube whose wall is `wall` mm thick.
-Print &round_tube(Print &print, Model &model, const DynamicPrintConfig &config, double wall)
-{
-    ModelObject *object = model.add_object();
-    object->name = "round_tube.stl";
-    object->add_volume(make_cylinder(tube_radius, 2.), ModelVolumeType::MODEL_PART, false);
-    object->add_volume(make_cylinder(tube_radius - wall, 2.), ModelVolumeType::NEGATIVE_VOLUME, false);
-    object->add_instance();
-    object->ensure_on_bed();
-
-    print.auto_assign_extruders(object);
-    print.apply(model, config);
-    print.validate();
-    print.set_status_silent();
-    print.process();
-    return print;
-}
-
-// The side of the tube wall a wall loop lies on. The centre is the middle of the tube wall, where Arachne lays the
-// inner wall both sides share when the tube wall is too narrow for a pair of them.
-enum class TubeSide { Contour, Hole, Centre };
-
-struct TubeLoop {
-    TubeSide side;
-    int      inset;
-    bool     ccw;
-};
-
-// The wall loops of every layer of round_tube() in extrusion order.
-std::vector<std::vector<TubeLoop>> tube_loops(const Print &print, double wall)
-{
-    const double centre = tube_radius - 0.5 * wall;
-    std::vector<std::vector<TubeLoop>> out;
-    for (const Layer *layer : print.objects().front()->layers()) {
-        const Vec2d axis = get_extents(layer->lslices).center().cast<double>();
-        std::vector<TubeLoop> &loops = out.emplace_back();
-        for (const LayerRegion *region : layer->regions())
-            for (const ExtrusionEntity *entity : region->perimeters.flatten().entities) {
-                if (! entity->is_loop())
-                    continue;
-                const ExtrusionLoop *loop    = static_cast<const ExtrusionLoop*>(entity);
-                const Polygon        polygon = loop->polygon();
-                double               radius  = 0.;
-                for (const Point &p : polygon.points)
-                    radius += unscaled<double>((p.cast<double>() - axis).norm());
-                radius /= double(polygon.points.size());
-                const TubeSide side = radius > centre + 0.1 ? TubeSide::Contour : radius < centre - 0.1 ? TubeSide::Hole : TubeSide::Centre;
-                loops.push_back({ side, loop->inset_idx, polygon.is_counter_clockwise() });
-            }
-    }
-    return out;
-}
-
-// The insets one side of a wall is printed in, given its deepest inset: inside out for Inner/Outer, outside in for
-// Outer/Inner, and for Inner/Outer/Inner the third wall onwards inside out, then the outer wall, then the first inner
-// wall. Inner/Outer/Inner prints its first layer Inner/Outer, and outside in when there is no third wall.
-std::vector<int> wall_sequence_insets(const std::string &wall_sequence, bool first_layer, int deepest)
-{
-    std::vector<int> insets;
-    if (wall_sequence == "inner wall/outer wall" || (wall_sequence == "inner-outer-inner wall" && first_layer)) {
-        for (int inset = deepest; inset >= 0; -- inset)
-            insets.push_back(inset);
-    } else if (wall_sequence == "outer wall/inner wall" || deepest < 2) {
-        for (int inset = 0; inset <= deepest; ++ inset)
-            insets.push_back(inset);
-    } else {
-        for (int inset = deepest; inset >= 2; -- inset)
-            insets.push_back(inset);
-        insets.push_back(0);
-        insets.push_back(1);
-    }
-    return insets;
-}
-
-// Whether a wall of round_tube() runs with the contour: all but the walls of the hole, and those too when the hole
-// is a thin wall hole, its outer wall touching the contour's with nothing between them.
-bool runs_with_contour(const TubeLoop &loop, bool thin_wall_hole)
-{
-    return loop.side != TubeSide::Hole || thin_wall_hole;
-}
-
-// The insets of the walls on one side of a round_tube() layer, the shared centre line included, in extrusion order.
-std::vector<int> side_insets(const std::vector<TubeLoop> &loops, TubeSide side)
-{
-    std::vector<int> insets;
-    for (const TubeLoop &loop : loops)
-        if (loop.side == side || loop.side == TubeSide::Centre)
-            insets.push_back(loop.inset);
-    return insets;
-}
-
-// The walls of a round_tube() layer in extrusion order, as side and inset: "c0 c1 h0 h1" is the contour's outer wall,
-// then its first inner wall, then the same for the hole, and "m" marks the wall in the middle both sides share.
-std::string wall_order(const std::vector<TubeLoop> &loops)
-{
-    std::string out;
-    for (const TubeLoop &loop : loops)
-        out += std::string(out.empty() ? "" : " ") + (loop.side == TubeSide::Contour ? "c" : loop.side == TubeSide::Hole ? "h" : "m") +
-               std::to_string(loop.inset);
-    return out;
-}
-
-} // namespace
-
-// Each side of a tube wall prints its walls in the order the wall sequence asks for, from two walls a side up to
-// four. The inner wall Arachne lays in the middle of a wall too narrow for a pair of them is an inner wall of both
-// sides; Classic fills that middle with gap fill instead, so it has one wall less a side there.
-TEST_CASE("Each side of a tube wall prints its walls in the wall sequence order", "[Perimeters]")
-{
-    struct TubeWall {
-        double wall;
-        int    wall_loops;
-        // Walls a side, a shared inner wall included.
-        int    arachne_walls;
-        int    classic_walls;
-    };
-    const TubeWall tube = GENERATE(values<TubeWall>({
-        { 1.5, 3, 2, 1 }, { 2.0, 2, 2, 2 }, { 2.5, 3, 3, 2 }, { 3.0, 3, 3, 3 }, { 4.0, 4, 4, 4 } }));
-    const char       *wall_generator = GENERATE("classic", "arachne");
-    const std::string wall_sequence  = GENERATE("inner wall/outer wall", "outer wall/inner wall", "inner-outer-inner wall");
-    CAPTURE(tube.wall, tube.wall_loops, wall_generator, wall_sequence);
-
-    DynamicPrintConfig config = tube_config(wall_generator, tube.wall_loops);
-    config.set_deserialize_strict("wall_sequence", wall_sequence);
-    Print print;
-    Model model;
-    round_tube(print, model, config, tube.wall);
-    const std::vector<std::vector<TubeLoop>> layers = tube_loops(print, tube.wall);
-    // 2mm at 0.2mm layers.
-    REQUIRE(layers.size() == 10);
-
-    const int walls = std::string(wall_generator) == "arachne" ? tube.arachne_walls : tube.classic_walls;
-    for (size_t i = 0; i < layers.size(); ++ i) {
-        for (const TubeSide side : { TubeSide::Contour, TubeSide::Hole }) {
-            const bool contour_side = side == TubeSide::Contour;
-            CAPTURE(i, contour_side);
-            const std::vector<int> insets = side_insets(layers[i], side);
-            REQUIRE(int(insets.size()) == walls);
-            CHECK(insets == wall_sequence_insets(wall_sequence, i == 0, walls - 1));
-        }
-    }
-}
-
-// The outer wall of a thin wall hole touches the contour's with nothing between them. The hole is printed first, so
-// the contour leans on it, unless the wall sequence puts the outer walls first.
-TEST_CASE("A thin wall hole is printed before the contour unless the outer walls go first", "[Perimeters]")
-{
-    const char       *wall_generator = GENERATE("classic", "arachne");
-    const std::string wall_sequence  = GENERATE("inner wall/outer wall", "outer wall/inner wall", "inner-outer-inner wall");
-    CAPTURE(wall_generator, wall_sequence);
-
-    DynamicPrintConfig config = tube_config(wall_generator, 3);
-    config.set_deserialize_strict("wall_sequence", wall_sequence);
-    Print print;
-    Model model;
-    round_tube(print, model, config, 1.);
-    const std::vector<std::vector<TubeLoop>> layers = tube_loops(print, 1.);
-    REQUIRE(layers.size() == 10);
-
-    const TubeSide first = wall_sequence == "outer wall/inner wall" ? TubeSide::Contour : TubeSide::Hole;
-    for (size_t i = 0; i < layers.size(); ++ i) {
-        CAPTURE(i);
-        REQUIRE(layers[i].size() == 2);
-        REQUIRE(layers[i][0].side != layers[i][1].side);
-        CHECK(layers[i].front().side == first);
-    }
-}
-
-// A 1.5mm tube wall leaves Inner/Outer/Inner no third wall to sandwich, only the inner wall Arachne lays in the middle
-// for both sides, or Classic's gap fill. Past the first layer it prints the hole first, then the contour, then the
-// middle.
-TEST_CASE("Inner/Outer/Inner prints the hole of a narrow tube wall first and the middle last", "[Perimeters]")
-{
-    const char *wall_generator = GENERATE("classic", "arachne");
-    CAPTURE(wall_generator);
-
-    DynamicPrintConfig config = tube_config(wall_generator, 3);
-    config.set_deserialize_strict("wall_sequence", "inner-outer-inner wall");
-    Print print;
-    Model model;
-    round_tube(print, model, config, 1.5);
-    const std::vector<std::vector<TubeLoop>> layers = tube_loops(print, 1.5);
-    REQUIRE(layers.size() == 10);
-
-    // Classic's gap fill is not a wall loop, and goes after the walls.
-    const std::string expected = std::string(wall_generator) == "arachne" ? "h0 c0 m1" : "h0 c0";
-    for (size_t i = 1; i < layers.size(); ++ i) {
-        CAPTURE(i);
-        CHECK(wall_order(layers[i]) == expected);
-    }
-}
-
-// The contour's walls run in the wall direction and the hole's against it, except that the walls of a thin wall
-// hole run with the contour, as does the inner wall Arachne shares between both sides of a 1.5mm tube wall.
-TEST_CASE("Tube walls run in the wall direction and hole walls against it", "[Perimeters]")
-{
-    const double      wall           = GENERATE(1.0, 1.5, 2.0, 3.0);
-    const char       *wall_generator = GENERATE("classic", "arachne");
-    const std::string wall_direction = GENERATE("ccw", "cw");
-    CAPTURE(wall, wall_generator, wall_direction);
-
-    DynamicPrintConfig config = tube_config(wall_generator, 3);
-    config.set_deserialize_strict("wall_direction", wall_direction);
-    Print print;
-    Model model;
-    round_tube(print, model, config, wall);
-    const std::vector<std::vector<TubeLoop>> layers = tube_loops(print, wall);
-    REQUIRE(layers.size() == 10);
-
-    const bool thin_wall_hole = wall == 1.;
-    for (size_t i = 0; i < layers.size(); ++ i) {
-        CAPTURE(i);
-        REQUIRE(std::any_of(layers[i].begin(), layers[i].end(), [](const TubeLoop &loop) { return loop.side == TubeSide::Contour; }));
-        REQUIRE(std::any_of(layers[i].begin(), layers[i].end(), [](const TubeLoop &loop) { return loop.side == TubeSide::Hole; }));
-        for (const TubeLoop &loop : layers[i]) {
-            CAPTURE(int(loop.side), loop.inset);
-            CHECK(loop.ccw == (runs_with_contour(loop, thin_wall_hole) == (wall_direction == "ccw")));
-        }
-    }
-}
-
-// Reverse on even with no threshold reverses every wall of every other layer, or only the inner walls when it is
-// restricted to them, and leaves the order of the walls alone.
-TEST_CASE("Reverse on even reverses the tube walls of every other layer", "[Perimeters]")
-{
-    const double wall                  = GENERATE(1.0, 1.5, 3.0);
-    const char  *wall_generator        = GENERATE("classic", "arachne");
-    const bool   reverse_internal_only = GENERATE(false, true);
-    CAPTURE(wall, wall_generator, reverse_internal_only);
-
-    auto slice = [&](bool overhang_reverse) {
-        DynamicPrintConfig config = tube_config(wall_generator, 3);
-        config.set_deserialize_strict({
-            { "overhang_reverse",               overhang_reverse },
-            { "overhang_reverse_internal_only", reverse_internal_only },
-        });
-        Print print;
-        Model model;
-        round_tube(print, model, config, wall);
-        return tube_loops(print, wall);
-    };
-    const std::vector<std::vector<TubeLoop>> plain    = slice(false);
-    const std::vector<std::vector<TubeLoop>> reversed = slice(true);
-    REQUIRE(plain.size() == 10);
-    REQUIRE(reversed.size() == plain.size());
-
-    for (size_t i = 0; i < plain.size(); ++ i) {
-        CAPTURE(i);
-        REQUIRE(reversed[i].size() == plain[i].size());
-        for (size_t j = 0; j < plain[i].size(); ++ j) {
-            CAPTURE(j);
-            CHECK(reversed[i][j].side == plain[i][j].side);
-            CHECK(reversed[i][j].inset == plain[i][j].inset);
-            const bool flips = i % 2 == 1 && (! reverse_internal_only || plain[i][j].inset > 0);
-            CHECK(reversed[i][j].ccw == (plain[i][j].ccw != flips));
-        }
-    }
-}
-
-namespace {
-
-DynamicPrintConfig brim_tube_config(const char *wall_generator, const std::string &wall_sequence, const char *brim_type, double brim_width)
-{
-    DynamicPrintConfig config = tube_config(wall_generator, 3);
-    config.set_deserialize_strict({
-        { "wall_sequence", wall_sequence },
-        { "brim_type",     brim_type },
-        { "brim_width",    brim_width },
-    });
-    return config;
-}
-
-} // namespace
-
-// A brim against the outer walls makes the first layer print them first, whatever the wall sequence, so the brim runs
-// straight on into the outer wall: each side of the tube wall outside in, and the contour before a thin wall hole.
-// Brims that may leave the outer walls bare keep the wall sequence, and so do the layers above.
-TEST_CASE("A brim against the outer walls makes the first layer print them first", "[Perimeters]")
-{
-    struct Brim {
-        const char *type;
-        double      width;
-        bool        outer_walls_first;
-    };
-    const Brim brim = GENERATE(values<Brim>({
-        { "no_brim", 5., false }, { "inner_only", 5., false }, { "auto_brim", 5., false }, { "outer_only", 0., false },
-        { "outer_only", 5., true }, { "outer_and_inner", 5., true }, { "leading_edge_only", 5., true } }));
-    const double      wall           = GENERATE(1.0, 3.0);
-    const char       *wall_generator = GENERATE("classic", "arachne");
-    const std::string wall_sequence  = GENERATE("inner wall/outer wall", "inner-outer-inner wall");
-    CAPTURE(brim.type, brim.width, wall, wall_generator, wall_sequence);
-
-    Print print;
-    Model model;
-    round_tube(print, model, brim_tube_config(wall_generator, wall_sequence, brim.type, brim.width), wall);
-    const std::vector<std::vector<TubeLoop>> layers = tube_loops(print, wall);
-    REQUIRE(layers.size() == 10);
-
-    // The thin wall hole has its outer wall a side, the 3mm tube wall three walls a side.
-    const size_t walls = wall == 1. ? 1 : 3;
-    for (const size_t i : { size_t(0), size_t(1) }) {
-        const bool outer_walls_first = brim.outer_walls_first && i == 0;
-        for (const TubeSide side : { TubeSide::Contour, TubeSide::Hole }) {
-            const bool contour_side = side == TubeSide::Contour;
-            CAPTURE(i, contour_side);
-            const std::vector<int> insets = side_insets(layers[i], side);
-            REQUIRE(insets.size() == walls);
-            CHECK(insets == wall_sequence_insets(outer_walls_first ? "outer wall/inner wall" : wall_sequence, i == 0, int(walls) - 1));
-        }
-        if (wall == 1.)
-            CHECK(layers[i].front().side == (outer_walls_first ? TubeSide::Contour : TubeSide::Hole));
-    }
-}
-
-// Changing the brim of a sliced print regenerates the walls when the first layer's wall order changes with it, so
-// the print gets the walls a slice from scratch with the new brim gets.
-TEST_CASE("Changing the brim updates the wall order of the first layer", "[Perimeters]")
-{
-    struct BrimChange {
-        const char *from_type;
-        double      from_width;
-        const char *to_type;
-        double      to_width;
-    };
-    const BrimChange change = GENERATE(values<BrimChange>({
-        { "outer_only", 0., "outer_only", 5. }, { "outer_only", 5., "outer_only", 0. },
-        { "no_brim", 5., "outer_and_inner", 5. }, { "outer_and_inner", 5., "inner_only", 5. } }));
-    const char *wall_generator = GENERATE("classic", "arachne");
-    CAPTURE(change.from_type, change.from_width, change.to_type, change.to_width, wall_generator);
-
-    const std::string wall_sequence = "inner wall/outer wall";
-    Print print;
-    Model model;
-    round_tube(print, model, brim_tube_config(wall_generator, wall_sequence, change.from_type, change.from_width), 3.);
-    const std::string before = wall_order(tube_loops(print, 3.).front());
-    print.apply(model, brim_tube_config(wall_generator, wall_sequence, change.to_type, change.to_width));
-    print.process();
-    const std::string after = wall_order(tube_loops(print, 3.).front());
-
-    Print fresh_print;
-    Model fresh_model;
-    round_tube(fresh_print, fresh_model, brim_tube_config(wall_generator, wall_sequence, change.to_type, change.to_width), 3.);
-    const std::string fresh = wall_order(tube_loops(fresh_print, 3.).front());
-
-    // The change does turn the first layer around.
-    REQUIRE(before != fresh);
-    CHECK(after == fresh);
-}

tests/fff_print/test_print.cpp

@@ -735,65 +735,6 @@ TEST_CASE("Custom G-code placeholders are substituted", "[Print]")
     CHECK(per_layer.find(";Layer:399 ") != std::string::npos);
 }
 
-// The final print statistics are known only after the whole G-code is generated, yet every custom G-code,
-// the file header included, gets the same values as filename_format.
-TEST_CASE("Print statistics in custom G-code match the final print statistics", "[Print][Regression]")
-{
-    const std::string gcode_key = GENERATE(as<std::string>{}, "file_start_gcode", "machine_start_gcode", "machine_end_gcode");
-    // Bambu printers use another tag table and G-code layout.
-    const bool is_bbl = GENERATE(false, true);
-    CAPTURE(gcode_key, is_bbl);
-
-    const std::vector<std::string> number_keys = { "total_weight", "used_filament", "total_cost", "total_wipe_tower_cost",
-                                                   "total_wipe_tower_filament" };
-    const std::vector<std::string> time_keys   = { "print_time", "normal_print_time", "silent_print_time" };
-    std::string                    templ;
-    for (const std::vector<std::string> *keys : { &number_keys, &time_keys })
-        for (const std::string &key : *keys)
-            templ += "; stat " + key + "={" + key + "}\n";
-
-    DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
-    config.set_deserialize_strict({
-        { gcode_key,          templ },
-        { "filament_density", "1.25" },
-        { "filament_cost",    "20" },
-        { "time_cost",        "2" },
-    });
-    Print print;
-    Model model;
-    init_print({ cube(20) }, print, model, config);
-    print.is_BBL_printer() = is_bbl;
-
-    std::string gcode;
-    REQUIRE_NOTHROW(gcode = Slic3r::Test::gcode(print));
-
-    // Match whole lines only: the config block repeats the template on a single line, and Bambu printers
-    // write that block before the start G-code.
-    const std::string lines    = "\n" + gcode;
-    const auto        value_of = [&lines](const std::string &key) {
-        const std::string prefix = "\n; stat " + key + "=";
-        const size_t      start  = lines.find(prefix);
-        REQUIRE(start != std::string::npos);
-        const size_t begin = start + prefix.size();
-        return lines.substr(begin, lines.find('\n', begin) - begin);
-    };
-    // The same statistics filename_format is expanded with.
-    DynamicConfig stats = print.print_statistics().config();
-    // A 20mm cube with filament_density 1.25 weighs something, unlike the running extruded_weight_total in the header.
-    CHECK(stats.opt_float("total_weight") > 0.);
-    for (const std::string &key : number_keys) {
-        CAPTURE(key);
-        const std::string value = value_of(key);
-        REQUIRE(value.find('@') == std::string::npos);
-        // Written with two decimals.
-        CHECK_THAT(std::stod(value), Catch::Matchers::WithinAbs(stats.opt_float(key), 0.006));
-    }
-    for (const std::string &key : time_keys) {
-        CAPTURE(key);
-        CHECK(value_of(key) == stats.opt_string(key));
-    }
-}
-
 TEST_CASE("export_gcode writes G-code without a result pointer", "[Print][export_gcode]")
 {
     Print print;

tests/libslic3r/CMakeLists.txt

@@ -37,6 +37,7 @@ add_executable(${_TEST_NAME}_tests
     test_fill_plane_path.cpp
     test_fill_tpms_adaptive.cpp
     test_geometry.cpp
+    test_chromastack.cpp
     test_imex_arrange.cpp
     test_imex_helpers.cpp
     test_imex_zones.cpp

tests/libslic3r/test_chromastack.cpp

@@ -0,0 +1,379 @@
+#include <catch2/catch_approx.hpp>
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/matchers/catch_matchers_floating_point.hpp>
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <vector>
+
+#include "libslic3r/Color.hpp"
+#include "libslic3r/ChromaStack.hpp"
+#include "libslic3r/PNGReadWrite.hpp"
+
+using namespace Slic3r;
+using Catch::Matchers::WithinAbs;
+using Catch::Matchers::WithinRel;
+
+namespace {
+
+ChromaFilament filament(int index, const ColorRGB &color, float td_mm)
+{
+    ChromaFilament f;
+    f.filament = index;
+    f.color    = color;
+    f.td_mm    = td_mm;
+    return f;
+}
+
+ChromaBand band(const ChromaFilament &f, int layers)
+{
+    ChromaBand b;
+    b.filament = f;
+    b.layers   = layers;
+    return b;
+}
+
+// An opaque filament (TD 1 hides what is under it within 0.1 mm) and a translucent one (TD 8 needs
+// most of a millimetre), which is the whole range the model has to behave sensibly over.
+const ChromaFilament WHITE_OPAQUE      = filament(0, ColorRGB(1.f, 1.f, 1.f), 1.f);
+const ChromaFilament BLACK_OPAQUE      = filament(1, ColorRGB(0.f, 0.f, 0.f), 1.f);
+const ChromaFilament BLACK_TRANSLUCENT = filament(2, ColorRGB(0.f, 0.f, 0.f), 8.f);
+
+float luminance(const ColorRGB &c) { return 0.2126f * c.r() + 0.7152f * c.g() + 0.0722f * c.b(); }
+
+} // namespace
+
+TEST_CASE("A stack's palette has one entry per printed layer", "[ChromaStack]")
+{
+    ChromaStack stack;
+    stack.layer_height_mm = 0.08f;
+    stack.base_layers     = 4;
+    stack.bands           = { band(WHITE_OPAQUE, 2), band(BLACK_TRANSLUCENT, 10) };
+
+    // The base is backing under the picture, not part of a band: the bands are the 12 layers the
+    // picture is built from, and the stack is those on top of the 4 the model already has.
+    REQUIRE(stack.relief_layers() == 12);
+    REQUIRE(stack.total_layers() == 16);
+    REQUIRE_THAT(stack.depth_mm(), WithinAbs(12 * 0.08f, 1e-6f));
+
+    const std::vector<ColorRGB> palette = chroma_palette(stack);
+    REQUIRE(palette.size() == 17);
+    // Index 0 is the base's own colour, so a column one layer tall is exactly its filament - whatever
+    // that filament's transmission distance.
+    REQUIRE(palette[0] == palette[1]);
+    REQUIRE_THAT(luminance(palette[1]), WithinAbs(1.f, 1e-3f));
+}
+
+TEST_CASE("A run of one filament gives the same palette however it is split into bands", "[ChromaStack]")
+{
+    // The property that justifies compositing layer by layer at all: transmittance multiplies, so
+    // cutting a run in two must not change the colours. A model without it would make the palette
+    // depend on how the stack was typed in.
+    ChromaStack one;
+    one.layer_height_mm = 0.1f;
+    one.base_layers     = 0;
+    one.bands           = { band(WHITE_OPAQUE, 2), band(BLACK_TRANSLUCENT, 8) };
+
+    ChromaStack split = one;
+    split.bands         = { band(WHITE_OPAQUE, 2), band(BLACK_TRANSLUCENT, 3), band(BLACK_TRANSLUCENT, 5) };
+
+    const std::vector<ColorRGB> a = chroma_palette(one);
+    const std::vector<ColorRGB> b = chroma_palette(split);
+    REQUIRE(a.size() == b.size());
+    for (size_t i = 0; i < a.size(); ++i)
+        REQUIRE_THAT(luminance(a[i]), WithinAbs(luminance(b[i]), 1e-5f));
+}
+
+TEST_CASE("A translucent filament darkens gradually and an opaque one at once", "[ChromaStack]")
+{
+    ChromaStack translucent;
+    translucent.layer_height_mm = 0.08f;
+    translucent.base_layers     = 0;
+    translucent.bands           = { band(WHITE_OPAQUE, 1), band(BLACK_TRANSLUCENT, 12) };
+    const std::vector<ColorRGB> slow = chroma_palette(translucent);
+
+    // Monotonically darker, and still short of the filament's own black after a single layer: that
+    // gradient is what a ChromaStack stack prints its midtones with.
+    for (size_t i = 2; i < slow.size(); ++i)
+        REQUIRE(luminance(slow[i]) < luminance(slow[i - 1]));
+    REQUIRE(luminance(slow[2]) > 0.5f);
+    // Twelve layers of a TD 8 filament pass under 3% of the light, which is the dark end of the ramp
+    // rather than true black - and that is the honest prediction, not a rounding artifact.
+    REQUIRE(luminance(slow.back()) < 0.25f);
+
+    ChromaStack opaque;
+    opaque.layer_height_mm = 0.08f;
+    opaque.base_layers     = 0;
+    opaque.bands           = { band(WHITE_OPAQUE, 1), band(BLACK_OPAQUE, 12) };
+    const std::vector<ColorRGB> fast = chroma_palette(opaque);
+    // TD 1 is opaque within about 0.1 mm, so two layers of it leave little of the white showing.
+    REQUIRE(luminance(fast[3]) < 0.2f);
+}
+
+TEST_CASE("Solving a picture of the palette's own colors reproduces it exactly", "[ChromaStack]")
+{
+    ChromaStack stack;
+    stack.layer_height_mm = 0.08f;
+    stack.base_layers     = 2;
+    stack.bands           = { band(WHITE_OPAQUE, 2), band(BLACK_TRANSLUCENT, 8) };
+
+    const std::vector<ColorRGB> palette = chroma_palette(stack);
+    const int                   relief  = stack.relief_layers();
+
+    // One pixel per reachable height, in order.
+    std::vector<uint8_t> rgb;
+    for (int i = 0; i <= relief; ++i) {
+        const ColorRGB &c = palette[size_t(stack.base_layers + i)];
+        rgb.push_back(uint8_t(std::lround(c.r() * 255.f)));
+        rgb.push_back(uint8_t(std::lround(c.g() * 255.f)));
+        rgb.push_back(uint8_t(std::lround(c.b() * 255.f)));
+    }
+
+    const ChromaSolve solve = chroma_solve(rgb.data(), relief + 1, 1, stack);
+    REQUIRE_FALSE(solve.empty());
+    REQUIRE(solve.width == relief + 1);
+    REQUIRE(solve.levels.size() == size_t(relief + 1));
+    // Every pixel comes back as the colour it was generated from, and the error is rounding only.
+    //
+    // The colour rather than the height: the bottom band prints in the same filament as the base, so
+    // its first layers show exactly the colour the base already showed, and any of those heights is a
+    // correct answer for that pixel. Asserting the height would be asserting which of several equally
+    // right answers the search happens to reach first.
+    for (int i = 0; i <= relief; ++i) {
+        const int chosen = int(solve.levels[size_t(i)]);
+        REQUIRE(chosen >= stack.base_layers);
+        REQUIRE(chosen <= stack.total_layers());
+        const ColorRGB &got  = palette[size_t(chosen)];
+        const ColorRGB &want = palette[size_t(stack.base_layers + i)];
+        REQUIRE_THAT(got.r(), WithinAbs(want.r(), 2.f / 255.f));
+        REQUIRE_THAT(got.g(), WithinAbs(want.g(), 2.f / 255.f));
+        REQUIRE_THAT(got.b(), WithinAbs(want.b(), 2.f / 255.f));
+    }
+    // Only 8-bit rounding of the palette separates the two, which near black is still under one dE.
+    REQUIRE(solve.max_delta_e < 2.);
+
+    // The height map's ends are the base and the top of the stack, which is what ties a grey level to
+    // a printed layer.
+    REQUIRE(solve.grey.front() == 0);
+    REQUIRE(solve.grey.back() == 255);
+}
+
+TEST_CASE("A picture the filaments cannot reach is reported as a poor match", "[ChromaStack]")
+{
+    ChromaStack stack;
+    stack.layer_height_mm = 0.08f;
+    stack.base_layers     = 2;
+    stack.bands           = { band(WHITE_OPAQUE, 2), band(BLACK_TRANSLUCENT, 8) };
+
+    // Saturated red against a stack of white and black: no height can produce it, and the panel's
+    // warning depends on the solve saying so rather than silently picking a grey.
+    const std::vector<uint8_t> red{ 255, 0, 0 };
+    const ChromaSolve        solve = chroma_solve(red.data(), 1, 1, stack);
+    REQUIRE_FALSE(solve.empty());
+    REQUIRE(solve.mean_delta_e > 15.);
+}
+
+TEST_CASE("Dithering keeps every pixel in the stack's range", "[ChromaStack]")
+{
+    ChromaStack stack;
+    stack.layer_height_mm = 0.08f;
+    stack.base_layers     = 2;
+    stack.bands           = { band(WHITE_OPAQUE, 2), band(BLACK_TRANSLUCENT, 8) };
+    stack.dither          = true;
+
+    // A flat mid-grey: the error diffusion has to spread it over neighbouring heights without ever
+    // leaving the stack, which is what a clamped palette index would quietly get wrong.
+    std::vector<uint8_t> grey(size_t(16 * 16) * 3, 128);
+    const ChromaSolve  solve = chroma_solve(grey.data(), 16, 16, stack);
+    REQUIRE_FALSE(solve.empty());
+    REQUIRE(solve.levels.size() == size_t(16 * 16));
+    const auto [lo, hi] = std::minmax_element(solve.levels.begin(), solve.levels.end());
+    REQUIRE(int(*lo) >= stack.base_layers);
+    REQUIRE(int(*hi) <= stack.total_layers());
+}
+
+TEST_CASE("The solved height map is an 8-bit grayscale PNG of the picture's size", "[ChromaStack]")
+{
+    // The displacement pipeline reads one thing from a layer: an 8-bit grayscale PNG. A solve that
+    // produced anything else would leave the relief silently flat.
+    ChromaStack stack;
+    stack.layer_height_mm = 0.08f;
+    stack.base_layers     = 2;
+    stack.bands           = { band(WHITE_OPAQUE, 2), band(BLACK_TRANSLUCENT, 6) };
+
+    std::vector<uint8_t> picture(size_t(8 * 4) * 3);
+    for (size_t i = 0; i < picture.size(); ++i)
+        picture[i] = uint8_t(i % 256);
+
+    const ChromaSolve              solve = chroma_solve(picture.data(), 8, 4, stack);
+    const std::vector<unsigned char> png   = chroma_encode_height_png(solve);
+    REQUIRE_FALSE(png.empty());
+
+    const png::ReadBuf  buf{ png.data(), png.size() };
+    png::ImageGreyscale decoded;
+    REQUIRE(png::is_png(buf));
+    REQUIRE(png::decode_png(buf, decoded));
+    REQUIRE(decoded.cols == 8);
+    REQUIRE(decoded.rows == 4);
+    REQUIRE(decoded.buf == solve.grey);
+}
+
+TEST_CASE("Each band becomes a height range, and a repeated filament is not a swap", "[ChromaStack]")
+{
+    ChromaStack stack;
+    stack.layer_height_mm = 0.1f;
+    stack.base_layers     = 0;
+    stack.bands           = { band(WHITE_OPAQUE, 5), band(BLACK_OPAQUE, 3), band(BLACK_OPAQUE, 2) };
+
+    const std::vector<ChromaRange> ranges = chroma_ranges(stack, 0.);
+    // Three bands, two filaments: the second and third merge, because nothing is swapped between them.
+    REQUIRE(ranges.size() == 2);
+    REQUIRE_THAT(ranges[0].z_min, WithinAbs(0., 1e-9));
+    REQUIRE_THAT(ranges[0].z_max, WithinAbs(0.5, 1e-9));
+    REQUIRE(ranges[0].filament == WHITE_OPAQUE.filament);
+    REQUIRE_THAT(ranges[1].z_min, WithinAbs(0.5, 1e-9));
+    REQUIRE_THAT(ranges[1].z_max, WithinAbs(1.0, 1e-9));
+    REQUIRE(ranges[1].filament == BLACK_OPAQUE.filament);
+}
+
+TEST_CASE("A default stack puts the lightest filament at the bottom", "[ChromaStack]")
+{
+    // Light to dark is what gives the long tonal ramp; the order is the one thing a seeded stack has
+    // to get right, since everything else is a layer count the user can drag.
+    const std::vector<ChromaFilament> loaded{ BLACK_OPAQUE, WHITE_OPAQUE,
+                                                filament(3, ColorRGB(0.5f, 0.5f, 0.5f), 4.f) };
+    const ChromaStack stack = chroma_default_stack(loaded, 0.08f, 4, 24);
+
+    REQUIRE(stack.bands.size() == 3);
+    REQUIRE(stack.bands.front().filament.filament == WHITE_OPAQUE.filament);
+    REQUIRE(stack.bands.back().filament.filament == BLACK_OPAQUE.filament);
+    REQUIRE(stack.base_layers == 4);
+    // The base is printed in the bottom band, so the relief is what was asked for and the base sits
+    // underneath it.
+    REQUIRE(stack.total_layers() == 4 + 24);
+    REQUIRE(stack.relief_layers() == 24);
+    REQUIRE_THAT(stack.layer_height_mm, WithinRel(0.08f));
+}
+
+TEST_CASE("An empty stack or picture solves to nothing", "[ChromaStack]")
+{
+    ChromaStack empty;
+    REQUIRE(chroma_palette(empty).empty());
+    REQUIRE(chroma_ranges(empty, 0.).empty());
+
+    // A base with nothing on it: there is no picture to solve, and no filament to print the base in.
+    ChromaStack base_only;
+    base_only.layer_height_mm = 0.08f;
+    base_only.base_layers     = 4;
+    REQUIRE(base_only.relief_layers() == 0);
+    REQUIRE(chroma_palette(base_only).empty());
+    const std::vector<uint8_t> pixel{ 128, 128, 128 };
+    REQUIRE(chroma_solve(pixel.data(), 1, 1, base_only).empty());
+
+    ChromaStack usable;
+    usable.layer_height_mm = 0.08f;
+    usable.base_layers     = 2;
+    usable.bands           = { band(WHITE_OPAQUE, 2), band(BLACK_OPAQUE, 4) };
+    REQUIRE(chroma_solve(nullptr, 4, 4, usable).empty());
+}
+
+TEST_CASE("The base extends the bottom band's range down to the first layer", "[ChromaStack]")
+{
+    // The base is not a swap of its own: it prints in whatever is loaded at the start, which is the
+    // bottom band's filament, so the first range has to reach the build plate.
+    ChromaStack stack;
+    stack.layer_height_mm = 0.1f;
+    stack.base_layers     = 20;
+    stack.bands           = { band(WHITE_OPAQUE, 5), band(BLACK_OPAQUE, 5) };
+
+    const std::vector<ChromaRange> ranges = chroma_ranges(stack, 0.);
+    REQUIRE(ranges.size() == 2);
+    REQUIRE_THAT(ranges[0].z_min, WithinAbs(0., 1e-9));
+    REQUIRE_THAT(ranges[0].z_max, WithinAbs(2.5, 1e-9)); // 20 base + 5 band layers at 0.1 mm
+    REQUIRE_THAT(ranges[1].z_min, WithinAbs(2.5, 1e-9));
+    REQUIRE_THAT(ranges[1].z_max, WithinAbs(3.0, 1e-9));
+    REQUIRE(ranges.back().z_max == Catch::Approx(double(stack.total_layers()) * double(stack.layer_height_mm)));
+}
+
+TEST_CASE("A surface's color follows the printed layer it sits at", "[ChromaStack]")
+{
+    // What the preview colours by: a swap happens at one print Z, so the layer a surface sits in is
+    // what decides its colour, whatever the height map says.
+    ChromaStack stack;
+    stack.layer_height_mm = 0.1f;
+    stack.base_layers     = 2;
+    stack.bands           = { band(WHITE_OPAQUE, 3), band(BLACK_OPAQUE, 5) };
+
+    REQUIRE(chroma_level_at(stack, 0.05) == 1);  // inside the first layer
+    REQUIRE(chroma_level_at(stack, 0.10) == 1);  // exactly its top, which that layer printed
+    REQUIRE(chroma_level_at(stack, 0.15) == 2);
+    REQUIRE(chroma_level_at(stack, 0.50) == 5);  // the top of the base plus the white band
+    // Clamped at both ends: below the plate and above the stack there is nothing else to show.
+    REQUIRE(chroma_level_at(stack, -1.) == 1);
+    REQUIRE(chroma_level_at(stack, 99.) == stack.total_layers());
+}
+
+TEST_CASE("How fast a filament covers is its TD against the layer height", "[ChromaStack]")
+{
+    // The number that decides whether a band is a gradient or a step, and the one the panel reports:
+    // a filament hides what is under it at about a tenth of its TD, so how many layers that is
+    // depends entirely on how thick they are.
+    REQUIRE_THAT(chroma_layers_to_opaque(4.f, 0.2f), WithinRel(2.f, 1e-4f));
+    REQUIRE_THAT(chroma_layers_to_opaque(4.f, 0.08f), WithinRel(5.f, 1e-4f));
+    REQUIRE_THAT(chroma_layers_to_opaque(8.f, 0.08f), WithinRel(10.f, 1e-4f));
+    // An opaque filament at a coarse layer height covers within one layer, which is where a stack
+    // stops having any colours between its filaments at all.
+    REQUIRE(chroma_layers_to_opaque(1.f, 0.2f) < 1.f);
+    REQUIRE_THAT(chroma_layers_to_opaque(4.f, 0.f), WithinAbs(0.f, 1e-6f));
+}
+
+TEST_CASE("A finer layer height buys colors between the filaments", "[ChromaStack]")
+{
+    // The whole of the user-visible problem in one assertion: the same stack, the same filaments, two
+    // layer heights. The coarse one steps from white to black in two layers; the fine one fades.
+    const auto distinct = [](float layer_height) {
+        ChromaStack stack;
+        stack.layer_height_mm = layer_height;
+        stack.base_layers     = 0;
+        stack.bands           = { band(WHITE_OPAQUE, 1), band(filament(5, ColorRGB(0.f, 0.f, 0.f), 8.f), 10) };
+        const std::vector<ColorRGB> palette = chroma_palette(stack);
+        int                         n       = 0;
+        for (size_t i = 1; i < palette.size(); ++i)
+            if (std::abs(luminance(palette[i]) - luminance(palette[i - 1])) > 0.02f)
+                ++n;
+        return n;
+    };
+    REQUIRE(distinct(0.08f) > distinct(0.3f));
+}
+
+TEST_CASE("Layers past a filament's covering depth add no color", "[ChromaStack]")
+{
+    // The band is twice as long as the filament needs to hide what is under it, so half of it shows a
+    // colour the layer below already showed. That is invisible in the stack and obvious here.
+    ChromaStack stack;
+    stack.layer_height_mm = 0.08f;
+    stack.base_layers     = 0;
+    stack.bands           = { band(WHITE_OPAQUE, 1), band(filament(5, ColorRGB(0.f, 0.f, 0.f), 4.f), 10) };
+
+    // Trimming keeps every layer that still changes the colour and drops the rest, so the stack gets
+    // shorter and loses none of its colours.
+    const int distinct = chroma_distinct_levels(stack);
+    const int before   = stack.relief_layers();
+    chroma_trim_bands(stack);
+    REQUIRE(stack.relief_layers() <= before);
+    REQUIRE(chroma_distinct_levels(stack) == distinct);
+    // The white band is a single layer and has nothing to give up.
+    REQUIRE(stack.bands.front().layers == 1);
+
+    // A light band over a dark one is the case where layers really are wasted: it saturates within a
+    // few layers, and the rest of a long band shows what the layer below already showed.
+    ChromaStack light_over_dark;
+    light_over_dark.layer_height_mm = 0.08f;
+    light_over_dark.base_layers     = 0;
+    light_over_dark.bands = { band(filament(5, ColorRGB(0.f, 0.f, 0.f), 4.f), 1), band(WHITE_OPAQUE, 14) };
+    const int kept = chroma_distinct_levels(light_over_dark);
+    chroma_trim_bands(light_over_dark);
+    REQUIRE(light_over_dark.bands.back().layers < 14);
+    REQUIRE(chroma_distinct_levels(light_over_dark) == kept);
+}

tests/libslic3r/test_preset_bundle_loading.cpp

@@ -985,37 +985,6 @@ TEST_CASE("A user filament synced to the cloud and back keeps its values and uns
     }
 }
 
-TEST_CASE("A project filament storing one value for a per-variant key applies it to every variant", "[Preset][Bundle][Regression]")
-{
-    PresetCollection filaments(Preset::TYPE_FILAMENT, Preset::filament_options(),
-                               static_cast<const PrintRegionConfig &>(FullPrintConfig::defaults()));
-    Preset &parent = add_inmemory_preset(filaments, "Parent Filament");
-    parent.config.set_key_value("filament_extruder_variant", new ConfigOptionStrings({"Direct Drive Standard", "Direct Drive High Flow"}));
-    parent.config.set_key_value("adaptive_pressure_advance_model", new ConfigOptionStrings({"parent standard", "parent high flow"}));
-    parent.config.set_deserialize_strict("pressure_advance", "0.02,0.03");
-    parent.is_system = true;
-
-    // A filament saved before these keys became per-variant lists both variants but stores each key once.
-    const std::string model = "0.025,15.6,5000";
-    DynamicPrintConfig config;
-    config.set_key_value(BBL_JSON_KEY_INHERITS, new ConfigOptionString("Parent Filament"));
-    config.set_key_value("filament_extruder_variant", new ConfigOptionStrings({"Direct Drive Standard", "Direct Drive High Flow"}));
-    config.set_key_value("adaptive_pressure_advance_model", new ConfigOptionStrings({model}));
-    config.set_deserialize_strict("pressure_advance", "0.016");
-    auto embedded                 = std::make_unique<Preset>(Preset::TYPE_FILAMENT, "Project Filament", false);
-    embedded->config              = std::move(config);
-    embedded->is_project_embedded = true;
-
-    std::vector<Preset *>      project_presets{embedded.get()};
-    PresetsConfigSubstitutions substitutions;
-    filaments.load_project_embedded_presets(project_presets, PRESET_FILAMENT_NAME, substitutions, ForwardCompatibilitySubstitutionRule::Disable);
-
-    const Preset *loaded = filaments.find_preset("Project Filament");
-    REQUIRE(loaded != nullptr);
-    CHECK(loaded->config.option<ConfigOptionStrings>("adaptive_pressure_advance_model")->values == std::vector<std::string>{model, model});
-    check_double_vector(loaded->config.option<ConfigOptionFloats>("pressure_advance")->values, {0.016, 0.016});
-}
-
 TEST_CASE("Repeated loads of a user preset directory produce the same presets", "[Preset][Bundle]")
 {
     ScopedTemporaryDir temp_dir;

tests/slic3rutils/CMakeLists.txt

@@ -30,7 +30,6 @@ add_executable(${_TEST_NAME}_tests
     test_plugin_capabilities_in_use.cpp
     test_plugin_status.cpp
     test_printer_agent.cpp
-    test_qidi_printer_agent.cpp
     test_plugin_install.cpp
     test_plugin_lifecycle.cpp
     test_plugin_resource_texture.cpp

tests/slic3rutils/test_printer_agent.cpp

@@ -1,30 +1,18 @@
 #include <catch2/catch_all.hpp>
 
-#include <functional>
-#include <slic3r/Utils/BBLPrinterAgent.hpp>
-#include <slic3r/Utils/IPrinterAgent.hpp>
-#include <slic3r/Utils/MoonrakerPrinterAgent.hpp>
 #include <memory>
 #include <slic3r/Utils/NetworkAgentFactory.hpp>
 
 #include <catch2/catch_test_macros.hpp>
 #include <pybind11/pytypes.h>
 #include <catch2/catch_message.hpp>
-#include "catch2/matchers/catch_matchers.hpp"
-#include "catch2/matchers/catch_matchers_floating_point.hpp"
 #include "python_test_support.hpp"
 
 #include <pybind11/embed.h>
 #include <pybind11/pybind11.h>
 
-#include <atomic>
-#include <chrono>
-#include <future>
-#include <slic3r/Utils/bambu_networking.hpp>
 #include <string>
-#include <thread>
 #include <pybind11/cast.h>
-#include <utility>
 
 namespace Slic3r { class ICloudServiceAgent; }
 namespace Slic3r { class IPrinterAgent; }
@@ -32,390 +20,12 @@ namespace Slic3r { class IPrinterAgent; }
 using namespace Slic3r;
 namespace py = pybind11;
 
-namespace {
-
-// Releases a promise on scope exit, so a throwing REQUIRE cannot leave a parked detached
-// thread (and any destructor that joins it) blocked forever.
-class ScopedPromiseRelease
-{
-public:
-    explicit ScopedPromiseRelease(std::shared_ptr<std::promise<void>> p) : m_p(std::move(p)) {}
-    ~ScopedPromiseRelease()
-    {
-        if (m_p) {
-            try {
-                m_p->set_value();
-            } catch (...) {
-                // promise already satisfied
-            }
-        }
-    }
-    ScopedPromiseRelease(const ScopedPromiseRelease&) = delete;
-    ScopedPromiseRelease& operator=(const ScopedPromiseRelease&) = delete;
-
-private:
-    std::shared_ptr<std::promise<void>> m_p;
-};
-
-} // namespace
-
-class MoonrakerParserProbe : public MoonrakerPrinterAgent
-{
-public:
-    using MoonrakerPrinterAgent::parse_nozzle_diameter;
-
-    explicit MoonrakerParserProbe(std::string log_dir) : MoonrakerPrinterAgent(std::move(log_dir)) {}
-};
-
-TEST_CASE("Moonraker parses nozzle diameter from configfile settings", "[MoonrakerPrinterAgent]")
-{
-    const auto response = nlohmann::json::parse(R"({
-        "result": {
-            "status": {
-                "configfile": {
-                    "settings": {
-                        "extruder": {
-                            "nozzle_diameter": 0.6
-                        }
-                    }
-                }
-            }
-        }
-    })");
-
-    CHECK_THAT(MoonrakerParserProbe::parse_nozzle_diameter(response), Catch::Matchers::WithinAbs(0.6f, 1e-4f));
-}
-
-TEST_CASE("Moonraker parses nozzle diameter from raw config and tolerates missing data", "[MoonrakerPrinterAgent]")
-{
-    const auto raw_config_response = nlohmann::json::parse(R"({
-        "result": {
-            "status": {
-                "configfile": {
-                    "config": {
-                        "extruder": {
-                            "nozzle_diameter": "0.8"
-                        }
-                    }
-                }
-            }
-        }
-    })");
-    const auto missing_response = nlohmann::json::object();
-
-    CHECK_THAT(MoonrakerParserProbe::parse_nozzle_diameter(raw_config_response), Catch::Matchers::WithinAbs(0.8f, 1e-4f));
-    CHECK_THAT(MoonrakerParserProbe::parse_nozzle_diameter(missing_response), Catch::Matchers::WithinAbs(0.0f, 1e-6f));
-}
-
-// why: an agent without a Bambu-dialect translation must refuse these commands before any network or wx path.
-TEST_CASE("default AMS commands report not supported", "[MoonrakerPrinterAgent]")
-{
-    MoonrakerPrinterAgent agent("");
-
-    CHECK(agent.command_ams_refresh_rfid("dev", 123, 1, 0, false) == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
-    CHECK(agent.command_ams_calibrate("dev", 1, 2, false) == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
-    CHECK(agent.command_ams_select_tray("dev", "123", 3, false) == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
-}
-
-TEST_CASE("Moonraker light name matching", "[MoonrakerPrinterAgent]")
-{
-    CHECK(moonraker_is_light_name("caselight"));
-    CHECK(moonraker_is_light_name("LED_STRIP"));
-    CHECK_FALSE(moonraker_is_light_name("beeper"));
-    CHECK(moonraker_is_light_name("FLASHLIGHT_SWITCH"));
-    CHECK(moonraker_is_light_name("MODLELIGHT_SWITCH"));
-}
-
-TEST_CASE("Moonraker webcam selection skips disabled webcams and prefers the first enabled one",
-          "[MoonrakerPrinterAgent]")
-{
-    const auto response = nlohmann::json::parse(R"({
-        "result": { "webcams": [
-            { "name": "disabled", "enabled": false, "stream_url": "http://192.168.1.9:8080/stream" },
-            { "name": "enabled",  "enabled": true,  "stream_url": "http://192.168.1.9:8080/stream" }
-        ]}
-    })");
-
-    MoonrakerWebcamSelection selection;
-    REQUIRE(moonraker_parse_webcam_list(response, "http://192.168.1.9:7125", selection));
-    CHECK(selection.name == "enabled");
-    CHECK(selection.url == "http://192.168.1.9:8080/stream");
-    CHECK(selection.mode == CameraStreamMode::http);
-    CHECK(selection.error.empty());
-}
-
-TEST_CASE("Moonraker webcam selection resolves relative URLs, maps rtsp, and rejects other schemes",
-          "[MoonrakerPrinterAgent]")
-{
-    const auto relative = nlohmann::json::parse(R"({
-        "result": { "webcams": [ { "name": "cam", "snapshot_url": "/webcam/?action=snapshot" } ] }
-    })");
-    MoonrakerWebcamSelection rel;
-    REQUIRE(moonraker_parse_webcam_list(relative, "http://192.168.1.9:7125", rel));
-    // Relative URLs use the printer web root, without the Moonraker API port.
-    CHECK(rel.url == "http://192.168.1.9/webcam/?action=snapshot");
-    CHECK(rel.mode == CameraStreamMode::http_snapshot);
-
-    const auto rtsp = nlohmann::json::parse(R"({
-        "result": { "webcams": [ { "name": "cam", "stream_url": "rtsp://192.168.1.9:554/live" } ] }
-    })");
-    MoonrakerWebcamSelection rt;
-    REQUIRE(moonraker_parse_webcam_list(rtsp, "http://192.168.1.9:7125", rt));
-    CHECK(rt.mode == CameraStreamMode::rtsp);
-
-    const auto unsupported = nlohmann::json::parse(R"({
-        "result": { "webcams": [ { "name": "cam", "stream_url": "weird://host/x" } ] }
-    })");
-    MoonrakerWebcamSelection bad;
-    CHECK_FALSE(moonraker_parse_webcam_list(unsupported, "http://192.168.1.9:7125", bad));
-    CHECK(bad.error == "Unsupported webcam URL");
-}
-
-TEST_CASE("Moonraker webcam selection reports no webcam and malformed structure", "[MoonrakerPrinterAgent]")
-{
-    const auto empty = nlohmann::json::parse(R"({ "result": { "webcams": [] } })");
-    MoonrakerWebcamSelection none;
-    CHECK_FALSE(moonraker_parse_webcam_list(empty, "http://host:7125", none));
-    CHECK(none.error == "No enabled webcam");
-
-    const auto disabled_only = nlohmann::json::parse(R"({
-        "result": { "webcams": [ { "name": "disabled", "enabled": false, "stream_url": "http://host/stream" } ] }
-    })");
-    MoonrakerWebcamSelection off;
-    CHECK_FALSE(moonraker_parse_webcam_list(disabled_only, "http://host:7125", off));
-
-    const auto malformed = nlohmann::json::parse(R"({ "result": { "nope": 1 } })");
-    MoonrakerWebcamSelection shape;
-    CHECK_FALSE(moonraker_parse_webcam_list(malformed, "http://host:7125", shape));
-    CHECK(shape.error == "Unexpected JSON structure");
-}
-
-// ===========================================================================
-// UNIT - handle_request's not-supported default.
-// The agent is the only thing that knows what it can translate, so an untranslated
-// command has to say so instead of returning success and letting the UI believe the
-// control worked. Guards the inverse too: the pushing namespace is genuinely
-// satisfied by the websocket status stream, and it re-fires from the keepalive timer
-// roughly once a second, so it must stay a success or it would raise a dialog on a
-// timer. Only branches that touch neither the network nor wx are exercised.
-// ===========================================================================
-TEST_CASE("Moonraker reports untranslated commands as not supported", "[MoonrakerPrinterAgent]")
-{
-    MoonrakerPrinterAgent agent("");
-
-    CHECK(agent.send_message("dev", R"({"print":{"command":"ams_change_filament"}})", 0, 0) ==
-          ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
-    CHECK(agent.send_message("dev", R"({"system":{"command":"set_door_stat"}})", 0, 0) ==
-          ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
-    CHECK(agent.send_message("dev", R"({"xcam":{"command":"xcam_control_set"}})", 0, 0) ==
-          ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
-
-    CHECK(agent.send_message("dev", R"({"pushing":{"command":"pushall"}})", 0, 0) == BAMBU_NETWORK_SUCCESS);
-    CHECK(agent.send_message("dev", R"({"pushing":{"command":"start"}})", 0, 0) == BAMBU_NETWORK_SUCCESS);
-
-    // why: malformed input is a different failure than an untranslated command, and the
-    // default must not swallow it into a misleading not-supported verdict.
-    CHECK(agent.send_message("dev", "{not json", 0, 0) == BAMBU_NETWORK_ERR_INVALID_RESULT);
-}
-
-// why: IPrinterAgent::fetch_filament_info is the single virtual hook derived agents override.
-// Pull-mode overrides must be synchronous (the caller reads DevFilaSystem as soon as it
-// returns), but subscription overrides may be fire-and-forget: QidiPrinterAgent/Snapmaker
-// spawn a detached thread when asked for subscription updates. QidiPrinterAgent is `final`,
-// so this probes the subscription contract with a controllable double instead.
-TEST_CASE("a fire-and-forget subscription fetch is not waited on by the caller",
-          "[MoonrakerPrinterAgent]")
-{
-    class RecordingAgent : public Slic3r::MoonrakerPrinterAgent
-    {
-    public:
-        explicit RecordingAgent(std::string log_dir) : MoonrakerPrinterAgent(std::move(log_dir)) {}
-
-        // Shared so the detached proxy fetch never touches `this`: a throwing REQUIRE
-        // then cannot leave it dereferencing a destroyed agent.
-        std::shared_ptr<std::atomic<bool>>  invoked{std::make_shared<std::atomic<bool>>(false)};
-        std::shared_ptr<std::promise<void>> release_gate{std::make_shared<std::promise<void>>()};
-        std::shared_ptr<std::promise<void>> done_promise{std::make_shared<std::promise<void>>()};
-
-        bool fetch_filament_info(std::string /*dev_id*/, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override
-        {
-            // Only the subscription path is allowed to be fire-and-forget.
-            if (sync_mode != FilamentSyncMode::subscription)
-                return true;
-
-            auto invoked_p      = invoked;
-            auto release_gate_p = release_gate;
-            auto done_promise_p = done_promise;
-            std::thread([invoked_p, release_gate_p, done_promise_p]() {
-                invoked_p->store(true);
-                // Block here until the test explicitly releases us, proving the caller
-                // (fetch_filament_info) does not wait for this to run.
-                release_gate_p->get_future().wait();
-                done_promise_p->set_value();
-            }).detach();
-            return true;
-        }
-    };
-
-    auto agent = std::make_shared<RecordingAgent>(std::string{});
-    auto done_future = agent->done_promise->get_future();
-    ScopedPromiseRelease release_gate_guard{agent->release_gate};
-
-    bool immediate_result = agent->fetch_filament_info("test-dev", FilamentSyncMode::subscription);
-
-    // fetch_filament_info must return before its background work completes — prove
-    // it by confirming the background call is still blocked on the gate right now.
-    REQUIRE(immediate_result == true);
-    REQUIRE(done_future.wait_for(std::chrono::milliseconds(100)) == std::future_status::timeout);
-
-    // Now let the background call finish and confirm it actually ran (polymorphic dispatch).
-    agent->release_gate->set_value();
-    REQUIRE(done_future.wait_for(std::chrono::seconds(2)) == std::future_status::ready);
-    REQUIRE(agent->invoked->load() == true);
-}
-
-namespace {
-
-// Globals so a parked proxy fetch thread never dereferences a freed agent.
-std::atomic<int>  g_deferred_fetch_running{0};
-std::atomic<bool> g_deferred_destroy_returned{false};
-
-// Releases the given gates, then joins on scope exit: so a throwing REQUIRE cannot leave
-// the thread blocked (deadlocking the join) or let it std::terminate.
-class ScopedJoiner
-{
-public:
-    ScopedJoiner(std::thread& t, std::shared_ptr<std::promise<void>> gate1, std::shared_ptr<std::promise<void>> gate2)
-        : m_thread(t), m_gates{std::move(gate1), std::move(gate2)}
-    {}
-    ~ScopedJoiner()
-    {
-        for (auto& gate : m_gates) {
-            if (gate) {
-                try {
-                    gate->set_value();
-                } catch (...) {
-                    // promise already satisfied
-                }
-            }
-        }
-        if (m_thread.joinable()) m_thread.join();
-    }
-    ScopedJoiner(const ScopedJoiner&) = delete;
-    ScopedJoiner& operator=(const ScopedJoiner&) = delete;
-
-private:
-    std::thread&                        m_thread;
-    std::shared_ptr<std::promise<void>> m_gates[2];
-};
-
-// A fetch that parks before touching the in-flight counter, so teardown's wait can
-// observe zero first.
-class DeferredFetchAgent : public MoonrakerPrinterAgent
-{
-public:
-    explicit DeferredFetchAgent(std::string log_dir) : MoonrakerPrinterAgent(std::move(log_dir)) {}
-
-    // Shared so a parked proxy fetch can never outlive the stack that owns it.
-    std::shared_ptr<std::promise<void>> entered{std::make_shared<std::promise<void>>()};
-    std::shared_ptr<std::promise<void>> allow_fetch{std::make_shared<std::promise<void>>()};
-    std::shared_ptr<std::promise<void>> allow_finish{std::make_shared<std::promise<void>>()};
-    std::shared_ptr<std::promise<void>> running{std::make_shared<std::promise<void>>()};
-
-    // Runs the callable on the command worker, which teardown joins.
-    void post(std::function<void()> fn) { enqueue_command(std::move(fn)); }
-
-    bool fetch_filament_info(std::string /*dev_id*/, FilamentSyncMode /*sync_mode*/ = FilamentSyncMode::pull) override
-    {
-        // Resumes after ~DeferredFetchAgent destroyed these members; snapshot up front.
-        auto entered_p      = entered;
-        auto allow_fetch_p  = allow_fetch;
-        auto allow_finish_p = allow_finish;
-        auto running_p      = running;
-
-        entered_p->set_value();
-        allow_fetch_p->get_future().wait();
-
-        filament_fetch_in_flight.fetch_add(1, std::memory_order_relaxed);
-        std::thread([this, finish = std::move(allow_finish_p), running = std::move(running_p)] {
-            struct InFlightGuard
-            {
-                MoonrakerPrinterAgent& owner;
-                ~InFlightGuard() { owner.release_fetch_slot(); }
-            } guard{*this};
-
-            g_deferred_fetch_running.fetch_add(1, std::memory_order_relaxed);
-            running->set_value();
-            finish->get_future().wait();
-            g_deferred_fetch_running.fetch_sub(1, std::memory_order_relaxed);
-        }).detach();
-        return true;
-    }
-};
-
-} // namespace
-
-// REGRESSION - teardown must not return while a fetch it started is in flight.
-// The command worker parks a fetch before it reserves the in-flight slot, forcing
-// the "wait already observed zero" interleaving deterministically.
-TEST_CASE("an agent's destruction waits for a fetch started by its worker during teardown",
-          "[MoonrakerPrinterAgent][Regression]")
-{
-    g_deferred_fetch_running.store(0);
-    g_deferred_destroy_returned.store(false);
-
-    auto agent        = std::make_shared<DeferredFetchAgent>(std::string{});
-    auto entered      = agent->entered;
-    auto allow_fetch  = agent->allow_fetch;
-    auto allow_finish = agent->allow_finish;
-    auto running      = agent->running;
-
-    // Safety net for the pre-destroyer failure paths: release both gates before the
-    // agent is destroyed (declared after it, so destroyed before it).
-    ScopedPromiseRelease release_finish{allow_finish};
-    ScopedPromiseRelease release_fetch{allow_fetch};
-
-    // Park a fetch inside the command worker while the agent is still complete.
-    agent->post([ptr = agent.get()] { ptr->fetch_filament_info("dev", FilamentSyncMode::pull); });
-    REQUIRE(entered->get_future().wait_for(std::chrono::seconds(5)) == std::future_status::ready);
-
-    // Destroy on another thread so this one can drive the parked fetch.
-    std::thread destroyer([owned = std::move(agent)]() mutable {
-        owned.reset();
-        g_deferred_destroy_returned.store(true);
-    });
-    // Releases both gates before joining, so a failing REQUIRE cannot deadlock the join.
-    ScopedJoiner join_destroyer{destroyer, allow_fetch, allow_finish};
-
-    // Let the worker reserve the in-flight slot and spawn its fetch, then wait until it
-    // is genuinely parked (no polling).
-    allow_fetch->set_value();
-    REQUIRE(running->get_future().wait_for(std::chrono::seconds(5)) == std::future_status::ready);
-    REQUIRE(g_deferred_fetch_running.load() == 1);
-
-    // A correct teardown cannot return while the fetch is parked; give a buggy one time.
-    for (int i = 0; i < 200 && !g_deferred_destroy_returned.load(); ++i)
-        std::this_thread::sleep_for(std::chrono::milliseconds(10));
-
-    if (g_deferred_destroy_returned.load()) {
-        // Bug: teardown returned with a fetch still running. Don't release allow_finish.
-        CHECK(g_deferred_fetch_running.load() == 0);
-        return;
-    }
-
-    // Fixed order: destruction is still blocked on the in-flight fetch.
-    allow_finish->set_value();
-    destroyer.join();
-    CHECK(g_deferred_destroy_returned.load());
-    CHECK(g_deferred_fetch_running.load() == 0);
-}
-
 // ===========================================================================
 // UNIT - printer-agent registry duplicate handling.
 // Confirms a duplicate agent id is rejected so a plugin cannot shadow a built-in
 // or previously registered agent.
 // ===========================================================================
-TEST_CASE("printer-agent registry register / lookup / duplicate-reject", "[PrinterAgent]")
+TEST_CASE("unit: printer-agent registry register / lookup / duplicate-reject", "[registry][unit]")
 {
     // why: the registry is process-global state shared by the test binary, and
     // Catch2 may run cases in any order. Use an id that cannot collide with
@@ -459,7 +69,7 @@ TEST_CASE("printer-agent registry register / lookup / duplicate-reject", "[Print
 // fails to load the codecs needed for the filesystem encoding. The shared helper
 // points PyConfig.home at the python/ runtime staged next to the test executable.
 
-TEST_CASE("orca.printer_agent binding surface", "[integration][Python]")
+TEST_CASE("integration: orca.printer_agent binding surface", "[integration][Python]")
 {
     py::module_ orca = import_orca_module();
 
@@ -510,7 +120,7 @@ TEST_CASE("orca.printer_agent binding surface", "[integration][Python]")
 // them in the lightweight embedded-interpreter test catches binding breakage
 // before the plugin-loader test needs to run.
 // ===========================================================================
-TEST_CASE("orca plugin-registration API surface + discovery-context guards", "[integration][Python]")
+TEST_CASE("integration: orca plugin-registration API surface + discovery-context guards", "[integration][Python]")
 {
     py::module_ orca = import_orca_module();
 

tests/slic3rutils/test_qidi_printer_agent.cpp

@@ -1,134 +0,0 @@
-#include "catch2/catch_test_macros.hpp"
-#include "catch2/matchers/catch_matchers.hpp"
-#include "catch2/matchers/catch_matchers_string.hpp"
-#include <catch2/catch_all.hpp>
-
-#include <nlohmann/json.hpp>
-
-#include <slic3r/Utils/QidiPrinterAgent.hpp>
-
-#include <string>
-
-using namespace Slic3r;
-
-TEST_CASE("Qidi slot response rejects null variables without throwing", "[QidiPrinterAgent]")
-{
-    const std::string response = R"({
-        "result": {
-            "status": {
-                "save_variables": {
-                    "variables": null
-                }
-            }
-        }
-    })";
-    nlohmann::json status;
-    nlohmann::json variables;
-    std::string    error;
-    bool           parsed = true;
-
-    REQUIRE_NOTHROW(parsed = QidiPrinterAgent::parse_slot_response(response, status, variables, error));
-    CHECK_FALSE(parsed);
-    CHECK_THAT(error, Catch::Matchers::ContainsSubstring("variables"));
-    CHECK_THAT(error, Catch::Matchers::ContainsSubstring("object"));
-}
-
-TEST_CASE("Qidi slot response rejects missing and non-object fields without throwing", "[QidiPrinterAgent]")
-{
-    std::string response;
-
-    SECTION("missing result")
-    {
-        response = R"({})";
-    }
-
-    SECTION("non-object result")
-    {
-        response = R"({"result":null})";
-    }
-
-    SECTION("missing status")
-    {
-        response = R"({"result":{}})";
-    }
-
-    SECTION("non-object status")
-    {
-        response = R"({"result":{"status":null}})";
-    }
-
-    SECTION("missing save_variables")
-    {
-        response = R"({"result":{"status":{}}})";
-    }
-
-    SECTION("non-object save_variables")
-    {
-        response = R"({"result":{"status":{"save_variables":null}}})";
-    }
-
-    SECTION("missing variables")
-    {
-        response = R"({"result":{"status":{"save_variables":{}}}})";
-    }
-
-    SECTION("scalar")
-    {
-        response = R"({"result":{"status":{"save_variables":{"variables":42}}}})";
-    }
-
-    SECTION("array")
-    {
-        response = R"({"result":{"status":{"save_variables":{"variables":[]}}}})";
-    }
-
-    nlohmann::json status;
-    nlohmann::json variables;
-    std::string    error;
-    bool           parsed = true;
-
-    REQUIRE_NOTHROW(parsed = QidiPrinterAgent::parse_slot_response(response, status, variables, error));
-    CHECK_FALSE(parsed);
-}
-
-TEST_CASE("Qidi slot response exposes valid status and variables", "[QidiPrinterAgent]")
-{
-    const std::string response = R"({
-        "result": {
-            "status": {
-                "save_variables": {
-                    "variables": {
-                        "box_count": 2,
-                        "color_slot0": 3
-                    }
-                },
-                "box_stepper slot0": {
-                    "runout_button": 0
-                }
-            }
-        }
-    })";
-    nlohmann::json status;
-    nlohmann::json variables;
-    std::string    error;
-    bool           parsed = false;
-
-    REQUIRE_NOTHROW(parsed = QidiPrinterAgent::parse_slot_response(response, status, variables, error));
-    REQUIRE(parsed);
-    CHECK(status.is_object());
-    CHECK(variables.is_object());
-    CHECK(variables.at("box_count") == 2);
-    CHECK(status.contains("box_stepper slot0"));
-}
-
-TEST_CASE("Qidi slot response rejects invalid JSON", "[QidiPrinterAgent]")
-{
-    nlohmann::json status;
-    nlohmann::json variables;
-    std::string    error;
-    bool           parsed = true;
-
-    REQUIRE_NOTHROW(parsed = QidiPrinterAgent::parse_slot_response("{not json", status, variables, error));
-    CHECK_FALSE(parsed);
-    CHECK(error == "Invalid JSON response");
-}