The two example sections were written from the inside of the graph: node class
names, the `<image1>` / `<image2>` notation, which loader to point where, and an
aside about which of the two 2.1 encoders keeps alpha. None of that helps
someone deciding whether to try the example.
Both sections now say what a user does and what comes back, in two sentences
each, and the news lines and the Updates entry follow. Example 31 also gains the
Workflow JSON link it was missing.
The MarkdownNote embedded in the Example 32 workflow gets the same treatment:
it keeps `<image1>` / `<image2>` (the instruction needs those) and drops the
`Join Image With Alpha` / `Load Image` MASK-output explanation.
The result image is byte-identical to the committed one; only the embedded
workflow metadata changed, which is why nothing was re-run.
The first version swapped a material onto the earcups without changing their
outline, so nothing in the result showed that the alpha channel is being
inpainted too - the silhouette moved by 47 pixels.
The mask now covers both earcups plus a ring of the transparent background
around them (25.1% of the frame, 70.9% of it on the headphones), and the
instruction asks for the earcups to be rebuilt as oversized turbine cups that
flare out past their old outline. The rebuilt region grows 11735 pixels of new
silhouette over what used to be empty background, 100% of it inside the mask,
while the headband, stitching, yokes and hinges stay pixel-identical (0.27/255
mean channel difference outside the mask).
A 25% mask is still clean here; the earlier 16% guidance came from a picture
whose mask had far less context left around it.
Also verified that the alpha is a real channel rather than a trimmed-off fourth
one: re-running with the identical RGB and a fully opaque alpha changes the
masked region by 61.9/255 on average (max 254).
This is the official `Qwen Image 2.1 Image Edit` graph - a `TextEncodeQwenImage21`
fed through its autogrow `images` input, with the prompt naming the references as
`<image1>` / `<image2>` - carrying a LanPaint mask.
Three changes against the stock template: `LanPaint_ImageEncode` takes the mask,
`LanPaint_KSampler` does the sampling, and `LanPaint_ImageDecode` merges the result
back inside the mask and keeps RGBA. No new node inputs or outputs.
The demo re-surfaces a pair of headphones' earcups with the iridescent titanium of a
second reference image. The mask is 14.8% of the frame and 89% of it sits on the
headphones; outside the mask the output is pixel-identical to the source (mean
channel difference 0.098/255), so the headband, the stitching and the hinges are
untouched rather than merely similar. The source and the result are both RGBA.
`Text Encode Qwen Image 2.1` is the right reference encoder for transparent pictures:
it hands the vision tower the alpha composited over white and encodes all four
channels into the reference latent, where the older `Text Encode Qwen Image Edit Plus`
trims to RGB.
Verified by replaying the API prompt embedded in the packaged PNG against the shipped
input files: bit-identical output. The README gets the news block, a TOC entry, the
example section and an Updates line; the previous 2.1 heading now says "with
Transparency" so the two 2.1 examples are distinguishable.
The section explained the VAE's channel count, the autogrow mismatch and the mask-size
measurements before saying where the example was. Keep what a reader needs: the model is
supported, transparency is inpainted too, and here is how to point it at your own picture.
The workflow's own note gets the same treatment.
The Features model list and the Updates log both predate the Qwen 2.1 example, so the
support was only discoverable from the table of contents. Example_31 also gets a
Comparison.png showing the original, the covered region and the result side by side,
since the new sole growing past the old outline is the part worth seeing.
LanPaint runs on Qwen-Image 2.1 unchanged: it is a rectified-flow model, so the
existing Flux/Qwen-Image conversions apply. Example_31 uses a text-to-image render
of its own model as the before/after, generated with a transparent background, and
keeps the inpainting mask in a separate greyscale file rather than in the picture's
alpha - 2.1's alpha channel means transparency, so overloading it would make the
two indistinguishable.
The transparency is carried into the latent and edited along with the pixels: the
2.1 VAE is 4-in/4-out (encoder.conv1 takes 4 channels, the decoder head emits 4),
and LoadImage's MASK output re-attaches through Join Image With Alpha, since that
mask is already 1 - alpha. The rebuilt sole grows past the old outline, so the
alpha in that region is generated rather than copied.
LanPaint_ImageDecode now matches the decoded channels to the source image: the 2.1
VAE always emits a 4th channel, which the merge could not broadcast. It keeps the
input's channel count, so an RGBA source comes back RGBA and an RGB source still
comes back RGB.
ComfyUI 0.34 (commit ff6c8a8a) hands MiniMax H3 a per-token denoise mask: the DiT derives per-row timesteps from it, presenting preserved rows at the video cond timestep (0.999) and the audio stream rescaled. LanPaint implements the 0.33 single-schedule contract in its own replace step and inner dynamics, so on 0.34 the mask-driven row timesteps contradicted the injected latents and both streams came out wrong.
Detect the contract from the ComfyUI version (>= 0.34) and hide the mask from the model's extra_conds for the paint loop, so the DiT keeps the uniform row timesteps LanPaint's math expects. Image models and ComfyUI <= 0.33 are unaffected.
Retire Beta/Friction/EarlyStop/InnerThreshold/InnerPatience/MinStepFrac
from all sampler nodes: the widgets are gone, the values are fixed
constants, and old prompts still validate via hidden inputs. A value
sanitizer falls back to defaults on invalid widget values, and the
frontend migrates old workflows by key-based widgets_values mapping
(LAYOUTS table) instead of positional arrays, so kept parameters
(PromptMode, Inpainting_mode) survive on old workflows.
MinStepFrac defaults to 1.0: the inner step size is pinned and the
inner-step count ramps linearly with the remaining noise fraction.
Video mask union: resample nearest-exact first, then a slice-level
sliding max-pool (experimental order) so the mask follows the painted
region's motion through the video.
Update Example_29 with the new output and re-export the workflow JSON.
The animated previews (InPainted gif and the combined showcase gif) stay
as the original versions; only the mp4 outputs are updated with the fixed
run.
MiniMaxH3 became ModelType.FLOW_AV in ComfyUI 0.31 (bdcb886a: audio
carriage redesign); our IS_FLOW checks only matched ModelType.FLOW, so H3
silently fell into the VE schedule branch and sampled garbage (corrupted
video, clipped audio). Treat FLOW_AV as a flow type via a version-safe
getattr tuple.
Example_29: replace the output with the fixed run (InPainted mp4/gif +
combined showcase), and re-export example_workflows JSON from the new
output's embedded metadata. Bump version to 2.0.1.
GitHub cannot render mp4 files inline, so the Example_29 media is also
published as GIFs (480px wide, 62 frames, ~3.9 MB) and the README links
(news block and MiniMax H3 section) point at the GIFs; the mp4 files stay
in the folder for download.
Add the MiniMax H3 video + audio inpainting announcement at the top of the
NEW blocks (with the mask-overlay visualization), pointing at the Example_29
media and the MiniMax H3 example section; the Updates list keeps the dated
entry.
Render the H3 example's actual interpolated mask sequence (from the 25
painted keyframes) as a red overlay on the input video, so the README can
show what was painted. The README's MiniMax H3 table now has three
columns (masked input / mask overlay / inpainted result), matching the
Wan example style.
The InPainted_Drag_Me_to_ComfyUI.png files of the converted examples are
replaced with the actual test-run outputs (which carry the workflow +
prompt tEXt chunks SaveImage embeds), so dragging them into ComfyUI loads
the new ImageEncode/ImageDecode workflows instead of the old encode chain.
Covers Examples 2, 7, 13, 14, 15, 20, 21, 23, 24, 25, 27, 28; verified
that every embedded workflow contains the new encode/decode nodes and has
no stale VAEEncode/SetLatentNoiseMask.
Add feature bullets for the video+audio inpainting pipeline and the
masks-in-video export, plus a MiniMax H3 section under Video Examples
covering the editor -> AVEncode -> sampler -> AVDecode flow, the
Example_29 media, the mask export/import workflow, and links to the
MiniMax H3 Hugging Face repo and ComfyUI docs.
- Qwen Image Edit upgraded to the 2509 model (qwen_image_edit_2509_fp8_e4m3fn)
with TextEncodeQwenImageEditPlus multi-image conditioning; old 2508/2509
pairs removed.
- New Z-Image base example (z_image_bf16, Example_25 input) using default
LanPaint parameters (NumSteps 5, Lambda 5.0, StepSize 0.2, Friction 15);
old turbo/base pairs removed.
- Renamed the converted examples to the *_EncodeDecode_Inpaint convention
(fresh names force the workflow gallery to reload them) and generated
preview jpgs from the test run outputs; superseded old pairs removed,
Qwen_Image_Outpaint and wan2_2_T2I_Partial kept as distinct use cases.
- Fixed the Qwen Image example mask reference: Example_12's file has no
alpha channel (it is an output example), so it now points at Example_13's
masked input (7).
- Repositioned the ImageEncode/ImageDecode nodes next to the sampler in all
converted workflows (the conversion agents had placed them far off-canvas).
- SD3.5 and HiDream examples removed on request.
- Example_29 now ships the H3 masked input video and the inpainted output
video (InPainted_Drag_Me_to_ComfyUI.mp4).
Mask-in-video (the masks now travel with the video file):
- New videometa module: write/read a JSON payload under the lanpaint-mask
mp4 metadata tag via PyAV (stream copy, movflags=use_metadata_tags), so
exporting produces a NEW file and the source is never modified.
- Two server routes: GET /lanpaint/video_mask_meta (read the payload back)
and POST /lanpaint/export_mask_video (remux into input/<base>_masked.mp4).
- The mask editor exports the painted keyframes (base64 PNGs) + audio
intervals into the video; loading a video with the tag auto-restores the
masks (editor and node preview). A video without the tag clears the
workflow's masks - the video is the source of truth. The export also
offers a native save dialog (showSaveFilePicker) when available.
- The video widget upload now uses video_upload so MP4s are selectable in
the file chooser (was image_upload).
- LanPaint_ImageEncode accepts 5D latents from video VAEs encoding a single
image (e.g. the Hunyuan video VAE) - fixes the Hunyuan example.
Example set conversion (one example per supported model, new files, old
pairs removed after being superseded):
- New *ImageEncode/*EncodeDecode example workflows for SDXL, Flux.1,
Flux.2 Dev, Flux2 Klein, SD3.5, Hunyuan, Ideogram4, Krea2, Qwen Edit,
Qwen Image, Z-Image, Wan 2.2 and MiniMax H3 (AV), all using
LanPaint_ImageEncode/ImageDecode instead of VAEEncode +
SetLatentNoiseMask + VAEDecode + MaskBlend; every example references its
own example folder's masked input (hash-verified); preview jpgs generated
from the test runs; the H3 example ships its output mp4 as a preview.
- HiDream example removed on request; Example_29 added with the H3 masked
input video.
Fixes along the way: normalize node input.link/output.links fields against
the links arrays in all converted workflows (the frontend renders
null-link nodes as disconnected); stale Inpainting_mode widget removed from
the Flux.2 sampler; Lambda defaults 5.0 (first-order scheme); torchaudio
resample test assertion relaxed (edge ringing); the videometa tests updated
to the final export signature.
The second-order damped-oscillator scheme (position + velocity) is
disabled, and the active first-order overdamped scheme has no momentum,
so the 16.0 bidirectional guidance scale that suited the damped
oscillator over-drives the masked region. Lower the default Lambda to
5.0 in the basic KSampler's hardcoded value, the Advanced sampler's
INPUT_TYPES default and default argument, and the two custom samplers.
LanPaint_ImageEncode replaces VAEEncode + SetLatentNoiseMask (plus the
manual mask ImageScale): the mask is snapped to the latent's actual
spatial size (nearest-exact) so VAE padding can never mismatch again.
LanPaint_ImageDecode replaces VAEDecode + LanPaint_MaskBlend (plus the
dimension-alignment round trip): the decoded image is resized to the
original's exact dimensions, then merged with the original inside the
mask with a MaskBlend-style boundary. The image workflow collapses to
LoadImage -> ImageEncode -> sampler -> ImageDecode -> SaveImage.
merge_video_with_mask now accepts a single 2D mask (broadcast over the
frame batch) and keys the merge count off the image/frame tensors
instead of the mask, so a 1-frame mask no longer truncates a batch.
Three frontend fixes for frame-accurate previews in the video mask
editor: (1) measureVideoFps now spans about 80 percent of the duration
instead of 1 second - the short span had +-1 frame of counting
uncertainty, so the editor and node preview could round to different
integers (e.g. 29 vs 30) and their frame grids drifted by a frame;
(2) the preview overlay maps playback time to the frame index with
floor (the browser presents floor(t*fps), round() mislabeled by one
whenever the video paused mid-frame); (3) the editor's frameAt seek
gets a +1e-6 nudge so index/fps float dust cannot land on the previous
frame.
Also fix a save-race crash: if the editor dialog is closed while the
keyframe uploads are in flight, _flash queried this.el after it was
nulled and the handler reported Save failed even though the save
succeeded. _flash now tolerates a closed editor.
The video mask editor's backend interpolation was dominated by the
pure-Python Felzenszwalb-Huttenlocher EDT: 20 keyframes at 864x480 took
~168s. _edt_2d now uses scipy.ndimage.distance_transform_edt (exact same
distances, C speed, ~100x faster; the Python fallback stays for
environments without scipy) - the same scenario now takes ~1.6s.
The frontend preview and the backend no longer keep two separate morph
implementations that can drift: the pure math (EDT, SDF, shifts, sigmoid,
per-frame morph) moved to web/lanpaint_mask_math.js, used by the editor
extension and pinned against the backend by tests/parity_mask_math.mjs +
test_js_python_mask_math_parity, which feeds the same 8-bit keyframes to
both sides and asserts the soft masks match within 1e-4 and the 0.5 level
sets are pixel-identical. The preview also switched from the quantized
sigmoid LUT to the exact sigmoid the backend uses.
Fixed a caller-contract bug found while verifying: computeSDFEntry
expects a pure alpha array, but the extension passed raw RGBA bytes
(getImageData data), so soft strokes were read as fully solid and the
index alignment scrambled the SDF (visible as odd strips). The caller now
extracts the alpha channel, and the function throws when handed a
non-w*h array so the mistake fails loudly.
LanPaint_AVEncode replaces the workflow chain GetVideoComponents ->
VAEEncode -> SetLatentNoiseMask + MiniMaxAudioEncode -> SetLatentNoiseMask
-> Concat AV Latent: it decodes the video's frames and audio track from
the VIDEO reference, encodes both streams, and returns a nested AV latent
with the video and audio masks attached per-stream (no stock
SetLatentNoiseMask, which crashes on 1D masks).
LanPaint_AVDecode is the mirror: it decodes both streams, merges the
inpainted video into the original with MaskBlend-style boundary blending
(blend_overlap), merges the audio by mask intervals with a crossfade
(audio_crossfade, replicate-padded ramp so even kernels keep the exact
length), resamples the inpainted audio to the original rate, resizes the
VAE decode output to the original dimensions, and writes the result with
the original file's fps and bit depth via VideoFromComponents. A source
without an audio track falls back to the inpainted audio.
reshape_mask rework: video masks are aggregated per latent token with a
window-4 temporal max (union) followed by nearest-exact resample, and the
frames-at-batch [F,1,H,W] convention produced by SetLatentNoiseMask is
handled; audio masks [F], [F,1] or [1,1,F,1] are resampled to the audio
latent's token grid. The stock per-stream mask prep is routed through our
prepare_mask (video_inpainting for 5D targets) inside override_sample_function,
which now guards against nested entry. Audio encode is a pure encoder.
Also: editor node fps fallback for VideoFromFile.get_frame_rate, 5D decode
batch combine, audio channel-count match, and MaskBlend.gaussian_kernel
now shares the guarded kernel helper (fixing NaN at overlap=1).
LanPaint_VideoMaskEditor now outputs a per-frame video mask and an audio
mask [F] (hard 0/1 at video frame rate) painted from time intervals in
the new hidden audio_mask widget. The frontend shows an audio waveform
strip under the video preview with red masked intervals and a playhead,
and the editor dialog supports drag-to-paint / click-to-clear intervals.
LanPaint_MiniMaxAudioEncode becomes a pure encoder (mask_start/mask_end
removed); the workflow attaches the editor's audio mask to the audio
latent with SetLatentNoiseMask and Concat AV Latent nests both per-stream
masks.
Video masks get the temporal union in reshape_mask: a latent token covers
~4 video frames and is all-or-nothing, so each token takes the window-4
max of its frames (nearest-exact) instead of trilinear averaging, which
could erase sparse temporal strokes. The stock per-stream mask prep is
routed through our prepare_mask (video_inpainting for 5D targets) and
handles the 1D [F] audio mask -> audio latent tokens case. Also handles
the VideoFromFile.get_frame_rate rename in newer ComfyUI.
- Add Krea2 banner, example section, and documentation to README
- Add new Example_28 with Krea2 LanPaint KSampler workflow
- Add workflow JSON and preview to example_workflows/
- Add Ideogram4 banner, example section, and documentation to README
- Add new Example_27 with Ideogram4 LanPaint Custom Sampler Advanced workflow
- Add workflow JSON to example_workflows/
- Fix widgets_values in Example_23 and Example_24 InPainted images
Add Anima (Example_26) inpainting/outpainting support: update README with Anima example and changelog entry, add three example images (Original, Masked, Inpainted). Modify example_workflows/Qwen_Image_Inpaint.json to restructure and extend the node graph (add VAE/encode/decode, mask/image scaling/conversion, mask blending, updated links and node ids) and bump frontendVersion/node metadata for compatibility. Update .gitignore to ignore Claude-related files. Replace the Example_13 inpainted image binary with an updated version.
When a LanPaint node is resized (e.g. to make the image preview bigger),
the LanPaint_Info multiline text box expanded along with it, wasting space.
Remove 'multiline: True' from the LanPaint_Info STRING input in all four
node types (LanPaint_KSampler, LanPaint_KSamplerAdvanced,
LanPaint_SamplerCustom, LanPaint_SamplerCustomAdvanced). The widget now
uses a fixed-height single-line display that does not grow when the node
is resized.
Fixes#61
scraed