Nodes · Transform

BS_VectorWarp

Transformv2coreNeeds full input

Overview

Paint once, carry it everywhere. Routes from the reference frame to this one along the chain of baked hops that accumulates the least error, composes ONE map, and filters the source once.

How to

Set bake_path and a reference frame.
Set output to error and read the heatmap before painting.
Paint on the reference frame with hold_frame on.
For a long shot, list several references and turn on morph_keys.

Inputs

Input	What it takes
in	the image this node works on
matte	the alpha that drives this node
paint	—

Outputs

Output	Type
out	Image

Parameters

Parameter	Type	Default	What it does
bake_path	Text		The BS_VectorBake sequence this warp routes through (`pattern.####.exr`). Set by ← on the bake, or type it. A Nuke SmartVector render (its Write's EXRs) works here too: its next/previous vectors are read as one-frame hops.
reference	Float	1.0	Which neighbouring frame the motion is measured against: +1 = the next frame, −1 = the previous.
hold_frame	Bool	true	Read the source at the reference frame(s) only and carry it to every other frame — the patch workflow. Off warps whatever the source shows at each frame.
frame_distance	Choice	auto	The longest hop the route may take through the bake (Nuke's frame distance). 1 chains one-frame hops, the most reliable vectors; a longer distance reaches the reference in fewer hops where the long vectors hold; auto lets the confidence route choose among every baked distance. `1248163264auto`
output	Choice	warped	`warped` is the picture; `stmap` the map it used (UV in rg); `confidence` how much the route trusted each pixel; `error` the round-trip heatmap in pixels (see `error_scale`); `winner` which reference each pixel took, as a colour. `warpedstmapconfidenceerrorwinner`
references	Text		Several reference frames, comma-separated — the keymix rig Foundry's docs tell you to build, per pixel: each pixel takes the reference whose route accumulated the most confidence. With `morph_keys` on they are paint keys instead.
stickiness	Float	6.0	How decisively pixels pick between references: 8 is a hard winner, 1 a soft dissolve. High enough and the choice stops flickering between two near-ties.
morph_keys	Bool	false	Treat `references` as PAINT KEYS: between two adjacent keys the patch is warped from both ends and cross-dissolved, so error resets at every key instead of growing over the shot.
bake_budget_mb	Float	4096.0	How much of the bake may sit in memory at once, shared by every BS_VectorWarp in the session. Only the fields a route walks through are read from the bake files, so a scrub loads a handful of them per frame; past this budget the least recently used are dropped and read again when needed.
fade_in_occlusion	Bool	false	Fade the patch to nothing where the route's confidence fell under the floor, instead of carrying it with its confident neighbours. Off by default: on real footage confidence is spotty and the fade shreds the patch; turn it on for a patch that must vanish behind an occluder.
conf_floor	Float	0.05	Confidence below this counts as untrackable: the route will not pass through it at a single hop and the patch fades there.
edge	Choice	fade	What a route that walks off the plate does: `fade` the patch out, or `hold` the edge pixel. `fadehold`
untrackable	Text		Frame spans the artist knows are untrackable, e.g. `120-135, 200-203`. The solver never routes THROUGH them at distance one, only over them, and hold-frame patches freeze-and-fade across them.
error_scale	Float	4.0	The error heatmap's white point in pixels — the `error` output saturates here.
mode	Choice	propagate	propagate carries the reference frame's pixels to this frame (the patch workflow). stabilise pins this frame to the reference's space so the subject sits still to paint on. unstabilise carries what was painted on the paint input back here as a premultiplied patch whose alpha is the regrain matte. `propagatestabiliseunstabilise`
rigidity	Float	0.0	Blend the flow toward a coarse mesh fitted to it: 0 = raw flow, 1 = the mesh alone. Cloth with a logo wants ~0.3 — the mesh drops the per-pixel bubbling and keeps the folds; skin wants lower.
refine	Bool	true	Check the composed warp against the pictures (on by default). A long reach is many hops, and each hop's small error adds up; refine solves the rest of the motion between this frame and the reference, starting from the chained map, using the plate the bake carries. On the artist's shot it takes the head at +24 frames from 0.46 to 0.34 of the unwarped error and +40 from 0.56 to 0.40. Costs a few seconds a frame, once (the result is cached). Needs a bake from this version; an older bake or a Nuke SmartVector file warps unrefined.
mesh_size	Float	48.0	The rigidity mesh's cell size in pixels. Smaller follows finer folds; larger is stiffer. Also the lattice ⤓ Export GridWarp hands you.
status	Text		What the last solve did: the route it took, the frames it held in memory, what it left out, and any refusal.
disabled	Bool	false	Bypass: the node passes its first input through untouched (D in the graph). The knobs keep their values for when it comes back.
label	Text		A note shown under the node in the graph — what this node is FOR. Never affects the render or the cache.
hide_input	Bool	false	Draw the node without its input wire — a tidy graph for a node whose source is obvious (a Dot, a viewer tap).

Known edges

Held pixels fade rather than smear when fade_in_occlusion is on. A bake made at another resolution is refused by name rather than stretched over the plate.

Since

27 Aug 2026