nex_shift/src/components/ImageAnnotator.tsx

744 lines
25 KiB
TypeScript

import { writeImage } from "@tauri-apps/plugin-clipboard-manager";
import { isTauri } from "@tauri-apps/api/core";
import {
ArrowUpRight,
Check,
CircleCheck,
CircleX,
Copy,
Crop,
Droplets,
EyeOff,
Grid3X3,
Highlighter,
ImagePlus,
ListOrdered,
LoaderCircle,
Save,
Scissors,
Square,
Star,
Type,
Undo2,
} from "lucide-react";
import { useEffect, useRef, useState } from "react";
import { useI18n } from "../i18n";
import { api } from "../lib/api";
type Tool =
| "rectangle"
| "arrow"
| "highlight"
| "redact"
| "blur"
| "pixelate"
| "number"
| "crop"
| "text"
| "stamp";
/// Stamps are vector glyphs so they stay sharp at any canvas resolution.
export type Stamp = "check" | "cross" | "star";
interface Annotation {
tool: Tool;
x1: number;
y1: number;
x2: number;
y2: number;
text?: string;
number?: number;
stamp?: Stamp;
}
interface Point {
x: number;
y: number;
}
interface ImageSnapshot {
src: string;
annotations: Annotation[];
}
interface Props {
path: string;
onSaved: (path: string) => void;
}
/// Soften a region by downscaling it and painting it back blurred. Unlike
/// pixelate, which is deliberately blocky, this keeps the shapes readable while
/// removing detail, and it is baked into the output rather than a translucent
/// overlay, so a blurred area cannot be recovered from the saved PNG.
export function drawBlur(
context: CanvasRenderingContext2D,
left: number,
top: number,
boxWidth: number,
boxHeight: number,
) {
const source = document.createElement("canvas");
source.width = Math.max(1, Math.round(boxWidth));
source.height = Math.max(1, Math.round(boxHeight));
const sourceContext = source.getContext("2d");
if (!sourceContext) return;
sourceContext.drawImage(context.canvas, left, top, boxWidth, boxHeight, 0, 0, source.width, source.height);
const factor = 10;
const small = document.createElement("canvas");
small.width = Math.max(1, Math.round(source.width / factor));
small.height = Math.max(1, Math.round(source.height / factor));
const smallContext = small.getContext("2d");
if (!smallContext) return;
smallContext.imageSmoothingEnabled = true;
smallContext.drawImage(source, 0, 0, small.width, small.height);
context.save();
context.beginPath();
context.rect(left, top, boxWidth, boxHeight);
context.clip();
context.imageSmoothingEnabled = true;
// The filter widens the soft edge the downscale alone leaves behind.
context.filter = `blur(${Math.max(2, Math.round(Math.min(boxWidth, boxHeight) / 24))}px)`;
context.drawImage(small, 0, 0, small.width, small.height, left, top, boxWidth, boxHeight);
context.restore();
}
function stampPath(context: CanvasRenderingContext2D, stamp: Stamp, radius: number) {
context.beginPath();
if (stamp === "check") {
context.lineWidth = Math.max(4, radius * 0.34);
context.moveTo(-radius * 0.46, radius * 0.04);
context.lineTo(-radius * 0.12, radius * 0.42);
context.lineTo(radius * 0.5, -radius * 0.4);
context.stroke();
return;
}
if (stamp === "cross") {
context.lineWidth = Math.max(4, radius * 0.3);
const arm = radius * 0.42;
context.moveTo(-arm, -arm);
context.lineTo(arm, arm);
context.moveTo(arm, -arm);
context.lineTo(-arm, arm);
context.stroke();
return;
}
const points = 5;
for (let index = 0; index < points * 2; index += 1) {
const outer = index % 2 === 0 ? radius * 0.62 : radius * 0.26;
const angle = (Math.PI / points) * index - Math.PI / 2;
const x = Math.cos(angle) * outer;
const y = Math.sin(angle) * outer;
if (index === 0) context.moveTo(x, y);
else context.lineTo(x, y);
}
context.closePath();
context.fill();
}
/// A filled disc plus a glyph, centred on the tap and sized from the canvas so a
/// stamp stays proportional on a 4K screenshot and a small crop alike.
function drawStamp(context: CanvasRenderingContext2D, annotation: Annotation, width: number) {
const stamp = annotation.stamp ?? "check";
const radius = Math.max(18, Math.round(width / 22));
context.save();
context.translate(annotation.x1, annotation.y1);
context.fillStyle = stamp === "cross" ? "#e0342b" : stamp === "star" ? "#f5a623" : "#1aa260";
context.beginPath();
context.arc(0, 0, radius, 0, Math.PI * 2);
context.fill();
context.strokeStyle = "rgba(255,255,255,0.94)";
context.fillStyle = "#fffdf9";
context.lineCap = "round";
context.lineJoin = "round";
stampPath(context, stamp, radius);
context.restore();
}
function drawAnnotation(
context: CanvasRenderingContext2D,
annotation: Annotation,
width: number,
) {
const lineWidth = Math.max(3, Math.round(width / 420));
const left = Math.min(annotation.x1, annotation.x2);
const top = Math.min(annotation.y1, annotation.y2);
const boxWidth = Math.abs(annotation.x2 - annotation.x1);
const boxHeight = Math.abs(annotation.y2 - annotation.y1);
context.save();
context.lineCap = "round";
context.lineJoin = "round";
context.lineWidth = lineWidth;
if (annotation.tool === "rectangle") {
context.strokeStyle = "#ff5a2f";
context.strokeRect(left, top, boxWidth, boxHeight);
} else if (annotation.tool === "highlight") {
context.fillStyle = "rgba(255, 213, 59, 0.42)";
context.fillRect(left, top, boxWidth, boxHeight);
} else if (annotation.tool === "redact") {
context.fillStyle = "#111111";
context.fillRect(left, top, boxWidth, boxHeight);
} else if (annotation.tool === "blur" && boxWidth > 0 && boxHeight > 0) {
drawBlur(context, left, top, boxWidth, boxHeight);
} else if (annotation.tool === "stamp" && annotation.stamp) {
drawStamp(context, annotation, width);
} else if (annotation.tool === "pixelate" && boxWidth > 0 && boxHeight > 0) {
const sampleWidth = Math.max(1, Math.round(boxWidth / 12));
const sampleHeight = Math.max(1, Math.round(boxHeight / 12));
const sample = document.createElement("canvas");
sample.width = sampleWidth;
sample.height = sampleHeight;
const sampleContext = sample.getContext("2d");
if (sampleContext) {
sampleContext.drawImage(
context.canvas,
left,
top,
boxWidth,
boxHeight,
0,
0,
sampleWidth,
sampleHeight,
);
context.save();
context.beginPath();
context.rect(left, top, boxWidth, boxHeight);
context.clip();
context.imageSmoothingEnabled = false;
context.drawImage(sample, left, top, boxWidth, boxHeight);
context.restore();
}
} else if (annotation.tool === "number") {
const radius = Math.max(16, Math.round(width / 55));
context.fillStyle = "#f04f24";
context.beginPath();
context.arc(annotation.x1, annotation.y1, radius, 0, Math.PI * 2);
context.fill();
context.fillStyle = "#fffdf9";
context.font = `700 ${Math.round(radius * 1.05)}px -apple-system, BlinkMacSystemFont, sans-serif`;
context.textAlign = "center";
context.textBaseline = "middle";
context.fillText(String(annotation.number ?? 1), annotation.x1, annotation.y1);
} else if (annotation.tool === "crop") {
context.strokeStyle = "#fff4e8";
context.setLineDash([10, 7]);
context.strokeRect(left, top, boxWidth, boxHeight);
} else if (annotation.tool === "text" && annotation.text) {
const fontSize = Math.max(18, Math.round(width / 32));
context.font = `600 ${fontSize}px -apple-system, BlinkMacSystemFont, sans-serif`;
context.textBaseline = "top";
context.lineWidth = Math.max(3, fontSize / 8);
context.strokeStyle = "rgba(255,255,255,0.92)";
context.fillStyle = "#f04f24";
context.strokeText(annotation.text, annotation.x1, annotation.y1);
context.fillText(annotation.text, annotation.x1, annotation.y1);
} else {
context.strokeStyle = "#ff5a2f";
context.beginPath();
context.moveTo(annotation.x1, annotation.y1);
context.lineTo(annotation.x2, annotation.y2);
context.stroke();
const angle = Math.atan2(annotation.y2 - annotation.y1, annotation.x2 - annotation.x1);
const head = Math.max(12, lineWidth * 5);
context.beginPath();
context.moveTo(annotation.x2, annotation.y2);
context.lineTo(
annotation.x2 - head * Math.cos(angle - Math.PI / 7),
annotation.y2 - head * Math.sin(angle - Math.PI / 7),
);
context.moveTo(annotation.x2, annotation.y2);
context.lineTo(
annotation.x2 - head * Math.cos(angle + Math.PI / 7),
annotation.y2 - head * Math.sin(angle + Math.PI / 7),
);
context.stroke();
}
context.restore();
}
export function ImageAnnotator({ path, onSaved }: Props) {
const { t } = useI18n();
const canvasRef = useRef<HTMLCanvasElement>(null);
const imageRef = useRef<HTMLImageElement | null>(null);
const [tool, setTool] = useState<Tool>("rectangle");
const [annotations, setAnnotations] = useState<Annotation[]>([]);
const [cropRect, setCropRect] = useState<Annotation | null>(null);
const [preview, setPreview] = useState<Annotation | null>(null);
const [start, setStart] = useState<Point | null>(null);
const [busy, setBusy] = useState(false);
const [copying, setCopying] = useState(false);
const [error, setError] = useState<string | null>(null);
const [stamp, setStamp] = useState<Stamp>("check");
const [textPoint, setTextPoint] = useState<Point | null>(null);
const [textDraft, setTextDraft] = useState("");
const [imageHistory, setImageHistory] = useState<ImageSnapshot[]>([]);
useEffect(() => {
let cancelled = false;
setAnnotations([]);
setCropRect(null);
setPreview(null);
setStart(null);
setTextPoint(null);
setTextDraft("");
setImageHistory([]);
const image = new Image();
image.onload = () => {
if (cancelled) return;
imageRef.current = image;
const canvas = canvasRef.current;
if (!canvas) return;
canvas.width = image.naturalWidth;
canvas.height = image.naturalHeight;
const context = canvas.getContext("2d");
if (context) context.drawImage(image, 0, 0);
};
image.onerror = () => {
if (!cancelled) setError(t("pinLoadFailed"));
};
if (isTauri()) {
void api
.readImageData(path)
.then((url) => {
if (!cancelled) image.src = url;
})
.catch((reason) => {
if (!cancelled) setError(String(reason).replace(/^Error:\s*/, ""));
});
} else {
image.src = "/demo-preview.svg";
}
return () => {
cancelled = true;
};
}, [path]);
useEffect(() => {
const canvas = canvasRef.current;
const image = imageRef.current;
if (!canvas || !image) return;
const context = canvas.getContext("2d");
if (!context) return;
context.clearRect(0, 0, canvas.width, canvas.height);
context.drawImage(image, 0, 0);
for (const annotation of annotations) {
drawAnnotation(context, annotation, canvas.width);
}
if (cropRect) {
drawAnnotation(context, cropRect, canvas.width);
context.save();
context.fillStyle = "rgba(20, 14, 12, 0.46)";
const left = Math.min(cropRect.x1, cropRect.x2);
const top = Math.min(cropRect.y1, cropRect.y2);
const right = Math.max(cropRect.x1, cropRect.x2);
const bottom = Math.max(cropRect.y1, cropRect.y2);
context.fillRect(0, 0, canvas.width, top);
context.fillRect(0, bottom, canvas.width, canvas.height - bottom);
context.fillRect(0, top, left, bottom - top);
context.fillRect(right, top, canvas.width - right, bottom - top);
context.restore();
}
if (preview) drawAnnotation(context, preview, canvas.width);
}, [annotations, cropRect, preview]);
function pointFromEvent(event: React.PointerEvent<HTMLCanvasElement>): Point {
const canvas = canvasRef.current!;
const rect = canvas.getBoundingClientRect();
return {
x: ((event.clientX - rect.left) / rect.width) * canvas.width,
y: ((event.clientY - rect.top) / rect.height) * canvas.height,
};
}
function renderEditedCanvas(): HTMLCanvasElement | null {
const canvas = canvasRef.current;
const image = imageRef.current;
if (!canvas || !image) return null;
const output = document.createElement("canvas");
output.width = canvas.width;
output.height = canvas.height;
const context = output.getContext("2d");
if (!context) return null;
context.drawImage(image, 0, 0);
for (const annotation of annotations) {
drawAnnotation(context, annotation, output.width);
}
return output;
}
async function saveCopy(copyAfterSave: boolean) {
if (busy || copying) return;
setCopying(copyAfterSave);
setBusy(true);
setError(null);
try {
const canvas = renderEditedCanvas();
if (!canvas) return;
const saved = await api.saveImageData(path, canvas.toDataURL("image/png"), " (annotated)");
onSaved(saved);
if (copyAfterSave) {
await writeImage(saved);
}
} catch (reason) {
setError(String(reason));
} finally {
setBusy(false);
setCopying(false);
}
}
function applyCrop() {
if (!cropRect) return;
const canvas = renderEditedCanvas();
if (!canvas) return;
const left = Math.max(0, Math.min(cropRect.x1, cropRect.x2));
const top = Math.max(0, Math.min(cropRect.y1, cropRect.y2));
const right = Math.min(canvas.width, Math.max(cropRect.x1, cropRect.x2));
const bottom = Math.min(canvas.height, Math.max(cropRect.y1, cropRect.y2));
const width = Math.round(right - left);
const height = Math.round(bottom - top);
if (width < 4 || height < 4) return;
pushImageHistory();
const output = document.createElement("canvas");
output.width = width;
output.height = height;
output.getContext("2d")?.drawImage(canvas, left, top, width, height, 0, 0, width, height);
const next = new Image();
next.onload = () => {
imageRef.current = next;
const target = canvasRef.current;
if (target) {
target.width = width;
target.height = height;
}
setAnnotations([]);
setPreview(null);
setCropRect(null);
setStart(null);
};
next.src = output.toDataURL("image/png");
}
function addBackground() {
const canvas = renderEditedCanvas();
if (!canvas) return;
pushImageHistory();
const padding = Math.max(24, Math.round(Math.max(canvas.width, canvas.height) * 0.07));
const output = document.createElement("canvas");
output.width = canvas.width + padding * 2;
output.height = canvas.height + padding * 2;
const context = output.getContext("2d");
if (!context) return;
const gradient = context.createLinearGradient(0, 0, output.width, output.height);
gradient.addColorStop(0, "#ffb45f");
gradient.addColorStop(0.52, "#ff7048");
gradient.addColorStop(1, "#c56fe6");
context.fillStyle = gradient;
context.fillRect(0, 0, output.width, output.height);
const radius = Math.max(14, Math.round(padding * 0.45));
context.save();
context.beginPath();
context.roundRect(padding, padding, canvas.width, canvas.height, radius);
context.clip();
context.drawImage(canvas, padding, padding);
context.restore();
const next = new Image();
next.onload = () => {
imageRef.current = next;
const target = canvasRef.current;
if (target) {
target.width = output.width;
target.height = output.height;
}
setAnnotations([]);
setPreview(null);
setCropRect(null);
setStart(null);
};
next.src = output.toDataURL("image/png");
}
function removeBackground() {
const canvas = renderEditedCanvas();
if (!canvas) return;
const context = canvas.getContext("2d");
if (!context) return;
pushImageHistory();
const imageData = context.getImageData(0, 0, canvas.width, canvas.height);
const data = imageData.data;
const samples = [
[0, 0],
[canvas.width - 1, 0],
[0, canvas.height - 1],
[canvas.width - 1, canvas.height - 1],
].map(([x, y]) => {
const index = (y * canvas.width + x) * 4;
return [data[index], data[index + 1], data[index + 2]];
});
const background = samples.reduce(
(sum, color) => [
sum[0] + color[0] / samples.length,
sum[1] + color[1] / samples.length,
sum[2] + color[2] / samples.length,
],
[0, 0, 0],
);
const tolerance = 42;
for (let index = 0; index < data.length; index += 4) {
const distance = Math.hypot(
data[index] - background[0],
data[index + 1] - background[1],
data[index + 2] - background[2],
);
if (distance <= tolerance) {
data[index + 3] = 0;
}
}
context.putImageData(imageData, 0, 0);
const next = new Image();
next.onload = () => {
imageRef.current = next;
setAnnotations([]);
setPreview(null);
setCropRect(null);
setStart(null);
};
next.src = canvas.toDataURL("image/png");
}
function pushImageHistory() {
const image = imageRef.current;
if (!image?.src) return;
setImageHistory((current) => [
...current,
{ src: image.src, annotations: [...annotations] },
]);
}
function undo() {
if (annotations.length > 0) {
setAnnotations((current) => current.slice(0, -1));
return;
}
const previous = imageHistory[imageHistory.length - 1];
if (!previous) return;
setImageHistory((current) => current.slice(0, -1));
const next = new Image();
next.onload = () => {
imageRef.current = next;
const target = canvasRef.current;
if (target) {
target.width = next.naturalWidth;
target.height = next.naturalHeight;
}
setAnnotations(previous.annotations);
setPreview(null);
setCropRect(null);
setStart(null);
};
next.src = previous.src;
}
const tools = [
{ id: "rectangle" as const, icon: Square, label: t("rectangle") },
{ id: "arrow" as const, icon: ArrowUpRight, label: t("arrow") },
{ id: "highlight" as const, icon: Highlighter, label: t("highlight") },
{ id: "redact" as const, icon: EyeOff, label: t("redact") },
{ id: "pixelate" as const, icon: Grid3X3, label: t("pixelate") },
{ id: "blur" as const, icon: Droplets, label: t("blur") },
{ id: "number" as const, icon: ListOrdered, label: t("number") },
{ id: "stamp" as const, icon: CircleCheck, label: t("stamp") },
{ id: "crop" as const, icon: Crop, label: t("crop") },
{ id: "text" as const, icon: Type, label: t("textAnnotation") },
];
const stamps: { id: Stamp; icon: typeof CircleCheck; label: string }[] = [
{ id: "check", icon: CircleCheck, label: t("stampCheck") },
{ id: "cross", icon: CircleX, label: t("stampCross") },
{ id: "star", icon: Star, label: t("stampStar") },
];
return (
<div className="annotator-shell">
<div className="annotator-toolbar">
{tools.map(({ id, icon: Icon, label }) => (
<button
key={id}
className={`annotator-tool ${tool === id ? "is-active" : ""}`}
title={label}
onClick={() => setTool(id)}
>
<Icon size={15} />
<span>{label}</span>
</button>
))}
<span className="annotator-separator" />
{tool === "stamp"
? stamps.map(({ id, icon: Icon, label }) => (
<button
key={id}
className={`annotator-tool annotator-stamp ${stamp === id ? "is-active" : ""}`}
title={label}
onClick={() => setStamp(id)}
>
<Icon size={15} />
</button>
))
: null}
<span className="annotator-separator" />
{cropRect ? (
<button className="annotator-tool is-primary" onClick={applyCrop}>
<Check size={15} />
{t("applyCrop")}
</button>
) : null}
<button className="annotator-tool" onClick={addBackground} title={t("addBackground")}>
<ImagePlus size={15} />
{t("addBackground")}
</button>
<button className="annotator-tool" onClick={removeBackground} title={t("cutout")}>
<Scissors size={15} />
{t("cutout")}
</button>
<button
className="annotator-tool"
title={t("undo")}
disabled={annotations.length === 0 && imageHistory.length === 0}
onClick={undo}
>
<Undo2 size={15} />
</button>
<button className="annotator-tool is-primary" onClick={() => void saveCopy(false)}>
{busy && !copying ? <LoaderCircle size={15} className="spin" /> : <Save size={15} />}
{t("saveCopy")}
</button>
<button className="annotator-tool" onClick={() => void saveCopy(true)}>
{copying ? <LoaderCircle size={15} className="spin" /> : <Copy size={15} />}
{t("copy")}
</button>
</div>
<div className="annotator-canvas-wrap">
<canvas
ref={canvasRef}
onPointerDown={(event) => {
const point = pointFromEvent(event);
if (tool === "text") {
setTextPoint(point);
setTextDraft("");
return;
}
if (tool === "stamp") {
setAnnotations((current) => [
...current,
{ tool: "stamp", stamp, x1: point.x, y1: point.y, x2: point.x, y2: point.y },
]);
return;
}
if (tool === "number") {
setAnnotations((current) => {
const nextNumber =
current.reduce(
(max, annotation) =>
annotation.tool === "number"
? Math.max(max, annotation.number ?? 0)
: max,
0,
) + 1;
return [
...current,
{
tool: "number" as const,
x1: point.x,
y1: point.y,
x2: point.x,
y2: point.y,
number: nextNumber,
},
];
});
return;
}
setStart(point);
setPreview({ tool, x1: point.x, y1: point.y, x2: point.x, y2: point.y });
event.currentTarget.setPointerCapture(event.pointerId);
}}
onPointerMove={(event) => {
if (!start) return;
const point = pointFromEvent(event);
setPreview({ tool, x1: start.x, y1: start.y, x2: point.x, y2: point.y });
}}
onPointerUp={(event) => {
if (!start) return;
const point = pointFromEvent(event);
const annotation = { tool, x1: start.x, y1: start.y, x2: point.x, y2: point.y };
if (Math.hypot(point.x - start.x, point.y - start.y) > 3) {
if (tool === "crop") {
setCropRect(annotation);
} else {
setAnnotations((current) => [...current, annotation]);
}
}
setStart(null);
setPreview(null);
event.currentTarget.releasePointerCapture(event.pointerId);
}}
/>
{error ? <div className="annotator-error">{error}</div> : null}
{textPoint ? (
<div className="annotator-text-entry">
<input
autoFocus
value={textDraft}
placeholder={t("textAnnotation")}
onChange={(event) => setTextDraft(event.target.value)}
onKeyDown={(event) => {
if (event.key === "Escape") {
setTextPoint(null);
setTextDraft("");
}
if (event.key === "Enter" && textDraft.trim()) {
setAnnotations((current) => [
...current,
{
tool: "text",
x1: textPoint.x,
y1: textPoint.y,
x2: textPoint.x,
y2: textPoint.y,
text: textDraft.trim(),
},
]);
setTextPoint(null);
setTextDraft("");
}
}}
/>
<button
onClick={() => {
if (!textDraft.trim()) return;
setAnnotations((current) => [
...current,
{
tool: "text",
x1: textPoint.x,
y1: textPoint.y,
x2: textPoint.x,
y2: textPoint.y,
text: textDraft.trim(),
},
]);
setTextPoint(null);
setTextDraft("");
}}
>
<Check size={14} />
</button>
</div>
) : null}
</div>
</div>
);
}