Free open-source image editor for the browser
import { effect, frame, init, target } from "vgpu";
import { createImageLayer, createLayer } from "@/app/editor/layers";
import { createEditorRenderer } from "@/app/editor/renderer";
import type { HealMode, Scene } from "@/core/document";
import { createImageSource } from "@/core/image";
import { imageFrame } from "@/core/image/frame";
/** A dark spot crosses a luminance edge on an HDR gradient. Its donor crosses the same edge. */
export async function renderHealReference({
mode = "heal",
opacity = 1,
}: {
mode?: Exclude<HealMode, "remove">;
opacity?: number;
} = {}) {
const gpu = await init();
const errors: string[] = [];
gpu.onError((error) => errors.push(error.message));
const image = target(gpu, { size: [256, 192], format: "rgba16float" });
const source = createImageSource(image);
const renderer = createEditorRenderer(gpu, source);
const shader = effect(
gpu,
`
@fragment fn fs_main(@builtin(position) p: vec4f) -> @location(0) vec4f {
let background = vec3f(0.2 + p.x * 0.002 + select(0.0, 0.5, p.x >= 128.0), 0.3 + p.y * 0.001, 1.4);
let defect = distance(p.xy, vec2f(128.0, 96.0)) < 10.0 || distance(p.xy, vec2f(158.0, 156.0)) < 2.0;
return vec4f(select(background, vec3f(0.02), defect), 0.75);
}
`,
);
const scene: Scene = {
frame: imageFrame(image.size),
layers: [
createImageLayer("source", "Reference"),
{
...createLayer("heal"),
patches: [
{
id: "spot",
mode,
feather: 0.25,
opacity,
strokes: [
{
mode: "paint",
size: 56,
feather: 0,
flow: 1,
points: [[128, 96, 1]],
},
],
offset: [0, 60],
},
],
},
],
};
try {
frame(gpu, (frame) => frame.pass(image, shader));
const results = [];
const healing = scene.layers[1];
if (healing.kind !== "heal") throw Error("Healing layer missing.");
for (const feather of [0, 0.75]) {
const renderScene: Scene = {
...scene,
layers: [
scene.layers[0],
{
...healing,
patches: healing.patches.map((patch) => ({
...patch,
feather,
})),
},
],
};
for (const proxy of [false, true]) {
await renderer.update(renderScene, "spot", proxy, undefined, 0.25);
const output = renderer.fullImage();
const pixels = await output.readFloats();
const input = renderer.inputImage("spot");
if (!input) throw Error("Patch input missing.");
const before =
mode === "clone" ? await input.readFloats() : new Float32Array();
const scale = 256 / output.size[0];
const samples = [
[128, 96],
[120, 96],
[136, 96],
[100, 96],
[158, 96],
[64, 64],
].map(([x, y], index) => {
const px = Math.floor(x / scale);
const py = Math.floor(y / scale);
const p = [(px + 0.5) * scale, (py + 0.5) * scale];
const i = (py * output.size[0] + px) * 4;
const background = [
0.2 + p[0] * 0.002 + (p[0] >= 128 ? 0.5 : 0),
0.3 + p[1] * 0.001,
1.4,
];
const inputPixel = (x: number, y: number) =>
(Math.floor((y * input.size[1]) / 192) * input.size[0] +
Math.floor((x * input.size[0]) / 256)) *
4;
const original = before.slice(
inputPixel(p[0], p[1]),
inputPixel(p[0], p[1]) + 3,
);
const donor = before.slice(
inputPixel(p[0], p[1] + 60),
inputPixel(p[0], p[1] + 60) + 3,
);
const cloned =
index < 3
? [...donor].map(
(value, channel) =>
original[channel] + (value - original[channel]) * opacity,
)
: background;
const expected = mode === "clone" ? cloned : background;
return {
actual: [...pixels.slice(i, i + 4)],
expected: [...expected, 0.75],
};
});
results.push({ feather, proxy, samples });
}
}
return { results, errors };
} finally {
renderer.dispose();
source.dispose();
gpu.dispose();
}
}