FUDA Image Adaptation

You've got an image with the exact lighting and color palette you want, and another image whose subject you'd rather keep. Normally that's an IP-Adapter job - and it costs you models, VRAM, and a fighting chance that the adapter smears your subject into the reference. FUDA Image Adaptation does the boring 90% of the job for free: it transfers the look (color, brightness, tone) of one image onto another while leaving the content structurally untouched. No model files, no VRAM, no trained weights - it's a handful of FFTs, and it runs in milliseconds.

Why you'd reach for it

This is the ComfyUI port of the FUDA paper ("Boosting unsupervised domain adaptation: A Fourier approach", Wang et al., Knowledge-Based Systems 2023), which itself builds on the original Fourier Domain Adaptation idea from Yang et al. 2020. The research context is domain adaptation for downstream vision models, but in a creative workflow it behaves like a very opinionated color-grading node: make a batch of renders match one reference photo, unify the look of a product shot set, or pull a scene's palette toward a golden-hour reference before you feed it to an upscaler.

It's not a competitor to IP-Adapter or IC-Light. Those can invent or restructure content; this one can't, and that's the selling point. It's closer in spirit to the color-correction utilities in WAS Node Suite, except the "correction" is defined by a reference image instead of your sliders.

How it works

The Fourier transform splits an image into two halves: amplitude, which carries low-level statistics like color and brightness, and phase, which carries the structure - edges, shape, semantics. FUDA's trick is to mix only the low-frequency amplitude of the reference into the source, then rebuild the image from the mixed amplitude plus the source's untouched phase.

Concretely, the node:

1. FFTs both images and shifts the DC component to center.
2. Takes the source's amplitude and phase, and the reference's amplitude.
3. Blends a centered box of reference amplitude into the source, sized by beta and weighted by alpha.
4. Rebuilds with inverse FFT and clamps to a valid image.

Because phase is never touched, the geometry of your source image is preserved perfectly. You get the reference's palette, not its subject. The source code does two nice things automatically: if your reference is a single image and your source is a batch, it broadcasts the reference across the batch, and it silently resizes the reference to match the source's dimensions - so mismatched sizes aren't something you have to babysit.

The two sliders that actually matter

Everything comes down to beta and alpha.

• beta (0.001–0.5, default 0.09) - the radius of the low-frequency band being mixed, as a fraction of the shorter image dimension. Small values (0.01–0.1) move global color and tone; larger values start pulling in mid-frequency texture, which gets you more of the reference's look but also more artifacts.
• alpha (0–1, default 0.5) - how strongly the reference amplitude replaces the source's. 0 is no change, 1 is full reference style (which reproduces the original, hard-replacement FDA method).

Start at the defaults and move one knob at a time. The README's rough map: subtle grading beta=0.03, alpha=0.3; moderate 0.09/0.5; strong 0.2/0.8. If you get that "overcooked" wobbly-texture look, beta is too big.

The only output is adapted_image (an IMAGE tensor), which wires straight into a Preview or Save Image node, or onward into anything else in the graph.

Install

Grab it under FUDA in ComfyUI Manager, or clone it the old-fashioned way:

cd ComfyUI/custom_nodes
git clone https://github.com/bemoregt/ComfyUI_FUDA

Then restart ComfyUI. That's the whole install - the pack has no dependencies beyond torch and numpy, which ComfyUI already ships, and no model downloads. It'll show up in the FUDA category.

Gotchas

Honest caveats. This is a very new, single-commit pack with essentially no community track record yet, so treat it as a fresh utility: it works, but there's nobody's war stories to lean on if it misbehaves. The usual custom-node hygiene applies - it's tiny (a few hundred lines, MIT-licensed), so it's easy to eyeball before you trust it. Feed it decoded images (Load Image output), not latents - it expects float IMAGE tensors in [0, 1]. And if the result looks like nothing happened, check that alpha isn't sitting at 0 and that your reference actually has the color you think it does; a flat, low-saturation reference transfers a flat, low-saturation result.