Free open-source image editor for the browser
import { type PointerEvent, useEffect, useRef, useState } from "react";
import { useGpu } from "vgpu-react";
import { BrushCanvas } from "@/components/editor/brush-canvas";
import { useDocumentMapping } from "@/components/editor/mapping";
import { useRenderer } from "@/components/editor/pipeline";
import { useDocument, useSelectedLayer } from "@/components/editor/session";
import { useToolLayer } from "@/components/editor/tool-layer";
import { useViewport } from "@/components/editor/viewport";
import {
type BrushStroke,
findLayer,
type HealPatch,
type Layer,
} from "@/core/document";
import type { Point } from "@/core/image/frame";
import { useDisposable } from "@/hooks/use-disposable";
import { containsTarget } from "@/lib/dom";
import { anchorReach, HealAnchor } from "./anchor";
import {
addHealPatch,
addHealStroke,
addRemovePatch,
extendHealPatch,
setHealSource,
} from "./edits";
import { useHealing } from "./mode";
import { dabTouchesImage, findHealPatch } from "./model";
import { HealPatchOutline, HealStrokePreview } from "./outline";
import { createHealSearch } from "./source";
function isHealLayer(layer: Layer): layer is Extract<Layer, { kind: "heal" }> {
return layer.kind === "heal";
}
/** Sends brush strokes to retouch edits and resolves Heal/Clone donors after painting. */
export function HealOverlay({
onCreate,
onDone,
}: {
onCreate: () => void;
onDone: () => void;
}) {
const document = useDocument();
const renderer = useRenderer();
const camera = useViewport();
const mapping = useDocumentMapping();
const gpu = useGpu();
const search = useDisposable(() => createHealSearch(gpu), [gpu]);
const {
brush,
mode,
source,
setSource,
selectedPatch,
selectPatch,
hoveredPatch,
} = useHealing();
const [drawingPatch, setDrawingPatch] = useState<string>();
const [draft, setDraft] = useState<BrushStroke>();
const [resolvingSource, setResolvingSource] = useState<string>();
// A manual donor belongs to this visit to the tool.
useEffect(() => () => setSource(undefined), [setSource]);
const selectedHealLayer = useToolLayer({
accepts: isHealLayer,
create: onCreate,
leave: onDone,
});
const layer = useSelectedLayer();
const healLayer = layer && isHealLayer(layer) ? layer : undefined;
const patches = healLayer?.patches ?? [];
const selected = patches.find((patch) => patch.id === selectedPatch);
const hovered = patches.some((patch) => patch.id === hoveredPatch)
? hoveredPatch
: undefined;
const visiblePatch = drawingPatch ?? hovered ?? selectedPatch;
/** The patch whose handles show: the selected one, while its outline shows and no stroke draws on it. */
const handled =
selected && visiblePatch === selected.id && drawingPatch !== selected.id
? selected
: undefined;
const pending = useRef<
| { layer: string; stroke: BrushStroke; patch?: string }
| {
layer: string;
mode: "heal" | "clone";
patch: string;
automatic: boolean;
}
| undefined
>(undefined);
async function complete(signal: AbortSignal) {
const current = pending.current;
try {
if (
!current ||
"stroke" in current ||
!current.automatic ||
signal.aborted
)
return;
const scene = document.scene.getState();
const patch = findHealPatch(scene, current.layer, current.patch);
if (!patch) return;
await renderer.update(
scene,
current.patch,
true,
undefined,
document.preview.getState().density,
);
if (signal.aborted) return;
const image = renderer.inputImage(current.patch);
if (!image) throw Error("Heal input is unavailable.");
const dimensions = document.resources.get(scene.layers[0].source).image
.size;
const offset = await search.find(image, dimensions, patch.strokes);
// The stroke's group stays open through the search; undo or cancel aborts it and removes the patch.
if (
signal.aborted ||
!findHealPatch(document.scene.getState(), current.layer, current.patch)
) {
return;
}
setHealSource(document, current.layer, current.patch, offset);
} finally {
if (current && !("stroke" in current)) {
setResolvingSource((id) => (id === current.patch ? undefined : id));
}
}
}
const marker = source && mapping.toScreen(source);
/** Where a patch's first point shows, moved by `offset` for its source; none behind the horizon. */
function firstShown(patch: HealPatch, offset: Point = [0, 0]) {
const [x, y] = patch.strokes[0].points[0];
return mapping.toScreen([x + offset[0], y + offset[1]]);
}
/**
* A press on the first point of a patch that isn't selected selects the topmost one instead of
* painting, unless the selected patch's handles show there to take it; elsewhere it paints, so a new
* patch can start over another. A second finger belongs to the canvas, which turns a stroke into a
* pinch.
*/
function selectPatchAt(event: PointerEvent<HTMLDivElement>) {
if (
!containsTarget(event) ||
event.button !== 0 ||
!event.isPrimary ||
event.shiftKey ||
event.altKey ||
camera.panMode
) {
return;
}
const box = camera.ref.current?.getBoundingClientRect();
if (!box) return;
const at: Point = [event.clientX - box.left, event.clientY - box.top];
const reaches = (anchor?: Point) =>
anchor !== undefined &&
Math.hypot(anchor[0] - at[0], anchor[1] - at[1]) <= anchorReach;
if (
handled &&
(reaches(firstShown(handled)) ||
(handled.mode !== "remove" &&
handled.id !== resolvingSource &&
reaches(firstShown(handled, handled.offset))))
) {
return;
}
const hit = patches.findLast(
(patch) => patch.id !== selectedPatch && reaches(firstShown(patch)),
);
if (!hit) return;
event.preventDefault();
event.stopPropagation();
selectPatch(hit.id);
}
return (
<div className="absolute inset-0" onPointerDownCapture={selectPatchAt}>
<BrushCanvas
label="Healing canvas"
erase={false}
editOnRelease={({ shift, alt }) =>
mode === "remove" || Boolean(selected && (shift || alt))
}
onStart={(stroke, { shift, alt }) => {
const layer = selectedHealLayer();
if (!layer) return false;
const [x, y] = stroke.points[0];
const size = document.resources.get(
document.scene.getState().layers[0].source,
).image.size;
if (!dabTouchesImage([x, y], stroke.size / 2, size)) return false;
// Keep the displayed feather when starting a stroke changes the patch selection.
brush.update({ feather: stroke.feather });
const painted = { ...stroke, flow: 1 };
if (selected && (shift || alt)) {
const stroke: BrushStroke = {
...painted,
mode: alt ? "erase" : "paint",
};
pending.current = { layer: layer.id, patch: selected.id, stroke };
setDraft(stroke);
setDrawingPatch(selected.id);
return true;
}
if (mode === "remove") {
pending.current = { layer: layer.id, stroke: painted };
setDraft(painted);
selectPatch(undefined);
return true;
}
const offset: Point = source
? [source[0] - x, source[1] - y]
: [0, 0];
const patch = addHealPatch(document, layer.id, painted, offset, mode);
setDrawingPatch(patch);
setResolvingSource(source ? undefined : patch);
selectPatch(patch);
pending.current = {
layer: layer.id,
mode,
patch,
automatic: !source,
};
return true;
}}
onExtend={(points) => {
const current = pending.current;
if (!current) return;
if ("stroke" in current) {
const stroke = {
...current.stroke,
points: [...current.stroke.points, ...points],
};
pending.current = { ...current, stroke };
setDraft(stroke);
return;
}
extendHealPatch(document, current.layer, points);
}}
onComplete={complete}
onFinish={(committed) => {
const current = pending.current;
if (current && "stroke" in current) {
pending.current = undefined;
setDraft(undefined);
const scene = document.scene.getState();
const available = current.patch
? findHealPatch(scene, current.layer, current.patch)
: findLayer(scene.layers, current.layer)?.kind === "heal";
if (committed && available) {
if (current.patch) {
addHealStroke(
document,
current.layer,
current.patch,
current.stroke,
);
} else {
selectPatch(
addRemovePatch(document, current.layer, current.stroke),
);
}
}
}
setDrawingPatch(undefined);
if (!committed) setResolvingSource(undefined);
}}
onPickSource={mode === "remove" || selected ? undefined : setSource}
onDone={onDone}
>
{draft && (
<svg
aria-hidden="true"
className="pointer-events-none absolute inset-0 size-full overflow-visible"
>
<HealStrokePreview
strokes={
drawingPatch && selected
? [...selected.strokes, draft]
: [draft]
}
/>
</svg>
)}
{healLayer && patches.length > 0 && (
<svg
aria-hidden="true"
className="absolute inset-0 size-full overflow-visible"
style={{ pointerEvents: "none" }}
>
{/* Every other patch shows its first point, which selects it, under the outline shown. */}
{patches.map((patch) => {
if (patch.id === visiblePatch) return null;
const center = firstShown(patch);
return (
center && (
<HealAnchor
key={`anchor-${patch.id}`}
kind="destination"
center={center}
/>
)
);
})}
{patches.map(
(patch) =>
visiblePatch === patch.id &&
!(draft && drawingPatch === patch.id) && (
<g key={`outline-${patch.id}`} data-heal-patch={patch.id}>
<HealPatchOutline
layer={healLayer.id}
patch={patch}
showSource={
patch.id !== drawingPatch &&
patch.id !== resolvingSource
}
interactive={patch.id === handled?.id}
/>
</g>
),
)}
</svg>
)}
{marker && mode !== "remove" && (
<svg
aria-hidden="true"
className="pointer-events-none absolute inset-0 size-full overflow-visible"
>
<circle
cx={marker[0]}
cy={marker[1]}
r="8"
fill="none"
stroke="white"
/>
<path
d={`M${marker[0] - 12} ${marker[1]}h24M${marker[0]} ${marker[1] - 12}v24`}
stroke="white"
/>
</svg>
)}
</BrushCanvas>
</div>
);
}