Krea 2 accepts reference latents, but they arrive with no position, so the
model treats them as a loose style hint: it borrows the look and reinvents
the content. That is the whole reason an outpaint drifts instead of
continuing the photo.
Krea 2 Encode attaches the reference latents and emits the negative from
the same node, so a turbo graph at CFG 1.0 stops carrying a second text
encode that does nothing. Krea 2 Outpaint Model Patch registers those
reference tokens into the target grid at the rectangle the stitcher
records, on frame axis 1.
Load Image + Pad gained a `reference` output - the unpadded source, fitted
to a 384px long edge and a multiple of 16, because the VAE downsamples by
8 and the DiT patchifies by 2. It is APPENDED after `stitcher`, never
inserted: a workflow stores links by output slot index, so any other
position silently rewires every saved graph.
The stitcher now records where the source sits, as source_bbox in pixels
and bbox_normalized in 0..1. Padding knows the rectangle exactly, so it
rides with the canvas instead of a parallel wire that can be left
unplugged. apply_stitch reads neither key, so an older stitcher stitches
identically.
Ported from the lab rather than copied: the lab's _krea2_helpers had its
own pad_image, feather_pad_mask, plan_pad_canvas, parse_fill_color and
build_canvas_stitcher. Duplicating the padding engine here would let the
outpaint path and the inpaint path disagree about what a stitcher is, so
the public module keeps only what is specific to Krea 2 and uses the
existing helpers for the rest.
Two departures from the lab version. The model patch declared a kv_cache
input and never read it - the cache was always on - so it is wired up now.
And it imports comfy's flux internals when you run it rather than at
startup: a core release that moves one then surfaces as an error on that
node, instead of deleting it from the menu and leaving saved workflows
reporting it missing.
Dragging a node taller only ever widened its stage. The frontend
arranges widgets in one pass:
if (w.computeSize) -> fixed height, kept OUT of the split
else if (w.computeLayoutSize) -> joins distributeSpace(freeSpace, ...)
else -> one standard widget row
It is an else-if, so a widget declaring both is pinned by computeSize
and its computeLayoutSize is never called. Every stage, player and
filmstrip here derived that fixed height from the node's WIDTH, so the
extra height became dead space underneath. Compare was fixed by hand;
the other six had the same defect.
Adds js/shared/panel_layout.mjs with one fillNodeHeight() that deletes
computeSize and declares a floor with no ceiling - distributeSpace reads
a missing maxSize as Infinity, so the panel takes whatever is left.
Applied to Compare, Save Video, Load Video, Frame Chooser, Load Image +
Pad, Image Crop+Rotate+Pad, and the shared transform panel that Video
Crop+Rotate+Pad mounts. Removing computeSize also removed where those
nodes got their opening height, so Save Video, Load Video and Load Image
+ Pad now state a default; a saved size still wins through onConfigure.
Measured in the browser: all seven grow 1:1 with the node and clamp at
their own floor.
The panel audit now enforces it - a DOM panel is either a stage that
calls fillNodeHeight and never assigns computeSize, or is listed as
fixed by design - so a new panel cannot quietly reintroduce this.
Load Image + Pad does the same job from the same stage and starts from
the file, so the only thing the second node added was taking an IMAGE
wire - one idea holding two slots in the menu.
Deletes the node, its panel, its help doc and its stage-only shared
helpers (padEmptyStateText, findPadPreview), and drops it from
NODE_MODULES, PUBLIC_NODE_IDS, the README and the panel guard list.
The padding helpers are untouched; Load Image + Pad and Align Image both
use them. Two console labels there named the removed node, so
_fill_tensor now takes the source name - Align Image passes its own
pad_color, and a colour it cannot read is no longer reported against
padding. The BHWC and mode errors read "Padding"/"Pad mode" instead.
The on-node pad stage moves to ComfyUI-AusBoss-Lab, which has its own
AUSBOSS_LAB_PadImage.
The node produced a mask offset, grown and blurred - no contact
darkening, no perspective - so it read as a sticker halo rather than a
shadow in the scene. That is the approach, not a tuning problem, so it
comes out rather than shipping under the pack's name.
Deletes the node, its helper module, its test file and its help doc, and
drops it from NODE_MODULES, PUBLIC_NODE_IDS and the README. The colour
helper tests keep their two-callers case using Pad Image and Transform,
the real remaining call sites.
blur_mask and grow_shrink_mask stay in _mask_helpers - Crop For Inpaint
and Pad Image use both.
Six fixes found while testing every node against real workflows.
LoRA Loader: the "wrong base model" warning never fired on a modern stack.
It matched comfy's model class name against a table covering 8 of the 81
classes comfy ships, so Krea 2, Qwen, WAN, LTXV, Z-Image and friends read as
"unknown" and skipped the check entirely - an SD 1.5 LoRA on Krea 2 patched
nothing, changed nothing, and said nothing. It now measures the applied-patch
count across model and CLIP before and after each row and warns when a row
patched nothing, which needs no table, no LoRA metadata, and works on every
model family. base_model_family also stopped mining ss_sd_model_name: that is
the trainer's source filename, and reading substrings out of it labelled any
..._v1.safetensors as SD1.5 and anything containing xl as SDXL.
LM Studio Chat: reasoning returned in the server's own reasoning_content field
now reaches the thinking output. Only inline <think> tags were read, so with
gemma/qwen-style hybrids the whole reply landed in a field the node never
looked at and text came back blank. An empty answer now explains itself,
naming the max_tokens budget when the model ran out of room mid-thought.
Compare: the stage follows the node's height, not only its width. Its panel
declared a computeSize, and the widget layout gives any widget that defines one
a fixed height and leaves it out of the leftover-space split, so dragging the
node taller only added dead space under the image.
Pad Image / Load Image + Pad: a stitcher output, so an outpaint can put the
source back exactly. Padding now builds the same stitcher shape Crop For
Inpaint emits - the crop is simply the whole canvas - so the existing Stitch
Inpaint node serves both and no second stitch node has to exist. Appended
last, so saved workflows keep their links.
Settings menus: editing one row no longer reverts the others. Each save handed
back a value set rebuilt from stored defaults, silently replacing every other
row on a node whose workflow differed from those defaults.
LoRA templates popover: Save was clipped off the panel edge and each saved
row's delete x was stretched across the whole row - one blanket
.ausboss-lora-menu button rule outranked the specialized buttons inside it.
The audit compared every node against ComfyUI core and the major packs;
this lands its outcomes in one branch.
On-node visual editing (the old Codex-pack interaction, rebuilt):
- New Load Image + Pad: image loader with whole-edge pad dragging on the
node canvas, align-to-multiple rounding, and a megapixel target that
rescales the source before padding so the mask seam stays binary.
- Pad Image gains the same handle canvas, fed by an execution-time
snapshot of its input; wireframe with diagnostic empty states before
the first run. Widgets, outputs, and saved workflows unchanged.
- Image Crop + Rotate + Pad's compact panel is now a live stage - crop,
pad, and rotate handles on the node, one shared implementation with
the full-screen editor so the two surfaces cannot drift.
Feature gaps closed against the ecosystem:
- Crop For Inpaint: target_megapixels, selectable rescale_algorithm
(recorded in the stitcher for the paste-back), and extend_* inputs
that grow the frame itself for outpainting.
- Save Video: format choice - mp4 h264, mp4 h265, webm vp9 with Opus
(resampled to 48 kHz); CRF drives all three.
- Load Video: every_nth thinning (fps output divides to match) and a
max_frames cap that ends the decode early.
- LoRA Loader: saved stack templates behind a bar button, and a console
warning when a LoRA's base-model family disagrees with the checkpoint.
- LM Studio Chat: history in/out for multi-turn chains and a json_schema
widget for structured replies.
- Drop Shadow: multiply blend and a shadow_mask output. Align Image:
offset outputs for un-aligning after sampling. Color Match:
first_frame reference mode as a one-node video flicker fix.
Removed (backed up in git history): Select Frame Range and the Video
Bundle family - core ImageFromBatch and the core VIDEO wire now cover
both jobs. Dead NODE_ID module variables cleaned out of every node file.
455 Python tests, 216 JS tests, validate_nodes.py green on 19 node files.
Every display name swaps ' (AusBoss)' for ' 🆎' - menus, docs, tooltips,
the README, and the example workflow's notes. Mapping keys never change,
so saved workflows keep loading; 'ausboss' keeps finding everything via
the category, the AUSBOSS_NODES_ prefix, and SEARCH_ALIASES. Python error
messages drop the suffix entirely so exception text stays ASCII for
cp1252 consoles.
The LM Studio endpoint toolbar declared no getMinHeight, so the frontend
gave its wrapper a 12px sliver and the buttons clipped; it now declares
32px through every sizing path, and the buttons breathe at 22px.
Frame Chooser: the notice inflated the grid's auto flex basis and squeezed
the action buttons into the bottom clip - the grid now flexes from a zero
basis, the fixed rows never shrink, and idle gets a little more room.
LoRA Loader: the empty state is just 'No LoRAs yet' and is itself a click
target that adds a row and opens the picker.
Align Image: pad mode gained an anchor (pad_position), a fill choice
(replicate or color), and pad_color - all hidden outside pad mode, the
color field hidden until the color fill is chosen.
LM Studio Chat: the gear moved off the node's tail into an endpoint
toolbar - status light, Test (asks the server for its model list through a
new /ausboss/lmstudio/models route; green/red + toast), Models (pick from
the server's list straight into the model field), gear. A visible
unload_llm switch frees the LLM right after the reply via LM Studio's JIT
ttl, overriding the gear's idle timer.
invert_mask inpaints outside the drawn region, mask_grow dilates or
shrinks the sampling mask, mask_blur softens its edge for models that
honor soft masks, and context_pixels adds flat margin on top of
context_factor's growth. Defaults keep the old hard-edged behavior
bit-identical.
In hold mode the stage captured the pointer on press, which retargeted the
release and ate the mode button's click - one way into HOLD, no way out.
SLIDE and HOLD are now two labeled buttons, and presses born on the
toolbar never reach the stage behaviors.
lab keeps the old per-channel LAB mean/std behavior as the default; rgb
does the same in raw channels; mkl maps the full RGB covariance through
the closed-form Monge-Kantorovich linear transform; histogram matches each
channel's quantiles exactly. invert_mask flips which side of the mask gets
corrected, and the tooltips now spell out that the mask only scopes the
fix, which is why there is no mask output.
top-p, top-k, min-p, repeat and presence penalty, thinking on/off via
chat_template_kwargs with custom reasoning tags, LM Studio idle-unload
TTL, and free-ComfyUI-VRAM-first. Values ride hidden standard widgets so
they save with the workflow and reach the API; neutral defaults are
omitted from the request body.
Full-width filled Add button, master-toggle bar with the gear, rows in an
inset stack with a dashed empty state, system-ui info glyph. The gear
holds default strength, strength step, separate model/CLIP strengths, the
trigger-word separator (a hidden widget the output honors), hide-extension,
thumbnail, and Civitai-lookup preferences.
The teal pair the video nodes hard-painted becomes the AusBoss scheme row
and the pack-wide default; Load/Save Video stop painting themselves so the
appearance setting and per-node menu govern every node the same way. Every
AusBoss node also gets a quiet ? badge whose card is built from the node's
own DESCRIPTION and tooltips.
A schema-driven gear menu (toggles, numbers, text, segmented choices)
persisted per node type in localStorage, a reusable info-card popup, a
widget show/hide helper that keeps widgets_values stable, and a hand-drawn
gear icon - the plumbing the LoRA Loader and LM Studio gears build on.
The frontend sizes a DOM widget's wrapper as widget.width ?? node.width
(GraphView, useDomWidget updateWidgets), and LiteGraph's layout plants
widget.width during draws. Once planted it outranks the node width
forever: resize the node narrower and the wrapper keeps the old width,
parking the panel's right edge - and the LoRA row's strength and info
controls - outside the border. None of the containment guards could
reach it: border-box and the overflow clip act at the wrapper's edge,
which is precisely the thing that is too wide, and the minimum-width
paths only stop the node going BELOW a floor, not the wrapper staying
ABOVE the node.
Diagnosed from a console measurement in the reporting browser (wrapper
styled 470px on a 328px node, scale 1.21) and reproduced exactly by
planting widget.width = 470: overflow +183px. keepDomWidgetWidthAuto
defines width as a discard-writes accessor, so the frontend's lookup
stays on its node-width fallback for the life of the widget. All six
DOM panels call it, the policy test requires it, and the fix was
verified end-to-end in a live classic-renderer session: with the plant
attempted, the wrapper tracked the node through narrow, add-row,
linked, grow and shrink at -13px inside the border throughout.
The audit behind the LoRA fix found two residual gaps and closed the
policy hole that let them hide. Frame Chooser declared its minimum
width to the modern layout but not through options.minNodeSize, the
path older frontends read - so on those, the node could still be
resized under the panel, which holds MIN_WIDTH and pokes past the
border exactly like the LoRA row did; the overflow clip cannot help
there because it cuts at the panel's edge, not the node's. The
input-preview thumbnail now clips at its root as well, making every
root uniform.
The policy test now requires the full set of every resizable panel:
border-box and an overflow clip reaching the root class (a blanket
group selector counts), plus a minimum width on BOTH layout paths -
computeLayoutSize for modern frontends and options.minNodeSize for
older ones. Against main's pre-fix LoRA file it fails 4 of 6, and
stashing the chooser change fails 1, so both halves are proven to
catch what they were written for.
The strength box and info button hung past the node's right edge, two
gaps stacked: the panel's 10px padding rendered outside the width the
frontend allocates (content-box), and nothing declared a minimum width
to the modern layout - computeSize clamped the PANEL to 300px, but
without computeLayoutSize the NODE could be resized narrower, and the
row's fixed-width trailing controls kept their size while the picker
shrank to nothing.
Every other DOM panel in the pack already carries the full guard set -
border-box, an overflow clip, computeLayoutSize minWidth, minNodeSize -
through the shared video root or its own CSS; the LoRA loader was the
one that had none of it. It now matches the house pattern, sharing one
PANEL_MIN_WIDTH constant across every sizing path the frontends
consult so the panel and the node can never disagree about how narrow
is legal.
tests/panel_guards.test.mjs makes the pattern policy: every entry that
calls addDOMWidget must carry the guards or mount the shared root that
does. Against the pre-fix file it fails 3 of 5.
Align Image snaps width and height to a clean multiple - 16, 32,
whatever the model wants - because Qwen image models, VAEs and plenty of
samplers only behave on cleanly divisible sizes. Each mode implies its
own rounding, so there is no separate direction widget: resize rescales
to the nearest multiple, crop center-crops down, pad replicate-pads up,
and a side smaller than one multiple always grows to exactly one rather
than erroring. The new size comes out as INTs for wiring into latents.
Image Size reads width, height, longest edge and shortest edge off the
wire so resizes and latents key off the actual image instead of retyped
numbers that drift.
LM Studio Chat posts a prompt - and optionally one image - to a local
LM Studio server, or anything else speaking the OpenAI-compatible chat
API. The interface is the middle ground the installed ecosystem packs
miss on either side: endpoint string, model string where EMPTY means
whatever the server has loaded (a dropdown fetched at ComfyUI startup
goes stale whenever LM Studio was not running yet), optional system
prompt, prompt required unless an image is connected, temperature,
max_tokens, seed as the re-roll knob, a timeout, and an image downscale
cap. Reasoning-model think blocks land on their own output so the text
stays clean for conditioning. Stdlib urllib only - no new dependencies -
and the POST runs off the executor thread. Every error names what to
fix, with the server's own words when it had any.
Verified live against a running LM Studio: a JIT-loaded qwen3.5-9b
answered a text round trip in 7.6 s through the real node; the
no-model-loaded 400 and a dead port both surfaced their actionable
messages. The vision payload shape is unit-tested; the two local VL
quants refused images server-side (missing projector / failed load), so
the live vision check stays on the deployment checklist.
48 offline tests cover the alignment math, both size nodes, the URL and
payload builders, think-splitting, image encoding, and every mocked
network error path.
Morphology first, because three things stand on it: grow_shrink_mask now
dilates or erodes in one separable pass - n 3x3 max pools equal a single
(2n+1) square filter, which splits into two 1-D passes - instead of one
full-image pool per pixel of growth. Bit-identical on hard and soft
masks in both directions (asserted against the old iterated form), and
measured 6-7x at 32 px. The matting trimap, which was rebuilding that
morphology inside its per-frame loop, builds it once per batch: 11.0 s
of trimap work on 48 frames of 832x480 becomes 0.4 s.
Pad Image's pillarbox backdrop blurs at quarter resolution when sigma is
large enough that the blur destroys detail anyway - that one blur was
~90% of the node's runtime, and the low-res path is 6-7x cheaper with a
mean difference around 0.001 in a band that is then dimmed. Light blurs
stay on the exact full-resolution path, so small canvases (and the
existing tests) are unchanged.
Frame Interpolate estimates flow exactly once per source pair at every
batch_size: blend batches now take whole (a, b) groups, and a one-batch
flow cache covers a pair a tiny batch_size splits, so batch_size=1 - the
setting the tooltip recommends for limited VRAM - no longer re-solves
each pair once per output frame (4x the RAFT work at 24 -> 120 fps).
The counting-stub test pins solves to the unique-pair count and checks
outputs across batch sizes with a content-dependent flow, a tolerance a
deliberately poisoned cache overshoots by five orders of magnitude.
Smaller: the guide-image batch is validated as a view and converted per
frame instead of duplicated up front (398 MB resident for 16 frames of
1080p); the scene-cut scan reuses its subtraction temporary in place;
and the edge-halo spread drops EDGE_HALO_SPREAD_PIXELS - tuned to 0 and
provably a no-op - along with the full-batch alpha copy that rode on it,
clamping per frame instead so values are unchanged.
Frame Chooser, mostly. A pause did not survive a workflow load: LiteGraph
clears a graph by removing every node, so undo, a tab switch, Clear
Workflow and opening another file all fired the teardown a deleted node
uses to release its pause, and killed a run that was still going. That
now only fires for a real deletion. Answering "keep all" wrote the batch
out as 1,2,...,N into pick_list, so the next run dropped whatever the
enumeration did not reach or failed outright on a shorter clip; it
writes the empty answer it was given. And pick_list is only written back
under "keep last selection" - it pre-answers the node, so filling it in
automatically meant a chooser left at the default paused exactly once.
Refine Mask: smooth applies only the change it made to the jaggy edge
rather than binarizing everything, so an already-soft matte keeps its
alpha (binary masks stay bit-identical), and blur now reaches the
matting solve instead of being thresholded back out of the trimap.
Frame Interpolate's copy path honours batch_size; it gathered every
copied frame at once, which on a long clip at an integer multiple was a
multi-gigabyte allocation on the frames device that no setting bounded.
Subgraph execution ids are resolved by walking the chain instead of
stripping the prefix, which could match an unrelated node with the same
number. Status and runtime badges appear inside subgraphs again, and a
subgraph pause renders on the node that actually paused.
Also: the Custom colour scheme no longer strips every node's colour when
its stored colour is unreadable; Drop Shadow and Pad Image name their
own widget for an unreadable colour instead of blaming Transform; a
non-ASCII token and a non-object JSON body answer 400 rather than
throwing a 500 and stranding the pause; pick_list rejects Unicode
digits, which used to raise during validation or silently read as a
frame nobody typed.
Tooling: validate_nodes parses NODE_MODULES rather than matching it
anywhere in the text, and an unregistered module is an error - it used
to exit 0 printing nothing. It also refuses mapping keys declared
outside nodes/, which is how the registry fixtures came to be advertised
to ComfyUI-Manager as installable nodes; they are .py.txt now. And the
video test no longer leaves ComfyUI on sys.path, which was flipping
every fail-soft seam for whatever ran next.
Four holes. Two empty literals agree with each other, so a module that
registers nothing passed every rule. A del could retire a node the
scanner goes on advertising - the mirror image of the update() case
already covered. An alias made the mutation invisible: _registry =
NODE_CLASS_MAPPINGS then _registry.update(...) never says the mapping
name at all. And the permanent-id check grepped the whole file for
AUSBOSS_NODES_*, so a key renamed in the literal kept passing as long as
the old id survived in a docstring or a search alias.
The contract is now that a mapping is assigned once to a non-empty dict
literal and its name is never used again. That is what makes the rest
enforceable: the alias is refused where it is made, the last point
anything static can still see it, rather than chased through code no
checker can follow. Permanent ids are measured against the keys parsed
out of the literal.
bad_empty, bad_delete and bad_alias join the fixtures; each one was
dropped into nodes/ and confirmed to exit 1 on its own line.
Continue, cancel and the expiring countdown were all writing straight to
the pending object and reporting success. Two clicks a frame apart both
returned 200 with the second selection winning; a cancel behind a keep
turned a continuing run into an interrupt; the timer could discard an
answer the browser had just been told had landed.
Every terminal path now goes through claim_pause, which records the one
outcome under the store lock and tells every later claim it lost. The
route answers 410 for those, the panel treats 409/410 as already-handled
rather than an answer failure, and a resolved pause stops being offered
to a page that reloads before its waiter unwinds. A rejected selection
claims nothing, so the cancel a deleted node posts behind it still
releases the graph.
tests/test_chooser_pause.py drives the races with real threads; ten of
its nineteen tests fail against the previous unguarded write.
The pymatting solve costs roughly 90 ms per megapixel of paste window,
per frame - 48 ms for the 768x768 window a 1024x1024 frame produces,
106 ms for the 1440x816 window from 1080p, measured on a 16-thread
desktop CPU. A video batch with the toggle on therefore ran to the end
with no feedback and no way out. The spread now checks for a cancel and
reports progress between frames, through the same seams the LaMa helper
uses, and stops at the next frame boundary.
It also hands pymatting float32 instead of float64. The estimator casts
whatever it is given down to float32 before solving, so the wider
temporary bought nothing: outputs stay bitwise identical across the
toggle, batch and rescale paths, and writing frames into one buffer
instead of stacking them cuts peak memory growth by about a third on a
48-frame 1024x1024 batch.
Node help now carries the measured per-frame cost and says plainly that
the toggle is for finishing a chosen take, not for a long exploratory
batch.
Keep selected, Keep all, Cancel, Enter, Escape and the cancel a deleted
node sends all posted without checking whether an answer was already in
flight, so two quick Enters put the same one-use token on the wire twice
and the duplicate's 409 landed as "Answer failed" over the success the
first request had already painted. Every path now goes through a latch on
the panel state: a second submit never fires, the controls read as
unavailable until the reply lands, and the latch clears on success or
failure so a genuine network error can still be retried. Each submission
also captures the pause it was posted for, and a reply is dropped when the
panel has since resolved or moved to another token - which covers both the
late rejection and a new pause arriving on the same node mid-flight. The
latch and the staleness predicate live in js/shared/frame_chooser.mjs with
node:test coverage.
A feathered paste re-blends the background that the sampler already
mixed into its soft edge, which rims the seam. The new fix_edge_halo
toggle estimates the unmixed foreground color with pymatting and pastes
that instead, spreading on a slightly grown blend mask while
compositing with the ungrown one. The toggle is appended and off by
default; without pymatting the node warns once and pastes unchanged.
Pixels outside the blend region stay bit-identical either way.
Nodes can push a status line to their own badge through the new
push_node_status helper, which is a silent no-op without a live
PromptServer so a status update can never fail the run reporting it.
The LaMa inpainter emits "frame i/N" alongside its progress bar,
threading the node id in through a hidden UNIQUE_ID input -- hidden
entries never become widgets, so its visible inputs and saved
widgets_values are unchanged.
The badge rides its own Chrome setting, on by default: unlike the
runtime badge it only exists while a node is running, and it is
retired when the node moves on or the run ends, fails, or is stopped.
A pause that starts out of sight - hidden browser tab, node scrolled off
the canvas, or another workflow or subgraph fronted - now raises one
toast naming the node and pulses the waiting workflow tab when the
frontend exposes it. A filmstrip the user can see stays quiet, and the
notice latches on the pause token so re-renders never repeat it; the
check runs a beat after the pause lands, once the canvas has placed the
widget. The focused panel takes 1-9 to toggle a frame, A and N to flip
the whole selection, Enter to keep, and Escape to cancel, consuming only
mapped keys and leaving anything typed into a field alone. Clicks inside
the panel are ignored for 400ms after it appears, so a click aimed at
the canvas cannot answer a pause that just popped up. The decidable
parts - key map, cooldown, visibility - live in js/shared with
node:test coverage.
New edge_refine combo (off / guided filter / matting, default off) plus
an optional guide_image IMAGE input. 'guided filter' snaps the soft mask
to guide edges via cv2.ximgproc.guidedFilter with a radius derived from
the expand amount; 'matting' builds an erode/dilate trimap and solves
closed-form alpha matting with pymatting, with the levels remap cleaning
the result afterward. Both run per frame with the ComfyUI interrupt
check, broadcast a single guide frame across a mask batch, and fail soft
when their optional dependency is absent with an ASCII message naming
the pip install. Selecting a tier without guide_image errors clearly.
The two libraries are declared under [project.optional-dependencies] as
the guided-filter and matting groups; the required install is untouched.
Clamp-and-rescale applied as the final step: values at or below
black_point go fully black, values at or above white_point go fully
white, the range between rescales linearly. Clears gray haze left by
soft segmentation or feathering; degenerate point pairs collapse to a
hard threshold. Defaults (0.0 / 1.0) are an exact identity, so existing
workflows and outputs are unchanged.
Binarize at 0.5, gaussian blur with sigma ~ smooth, re-binarize at 0.5.
Removes segmentation staircase edges without feathering, unlike blur.
Appended after fill_holes with a 0 default so existing workflows and the
positional widget contract are untouched. Runs between fill holes and
the feather blur; the fixed op order is documented in the DESCRIPTION.
ausboss