Spaces:
Running
Running
Download static/app.js from Ardaosta/FSF-Studio: direct link, hf CLI and curl.
- Browser
- Download file 37.9 kB
-
https://huggingface.co/spaces/Ardaosta/FSF-Studio/resolve/main/static/app.js
- Command line
-
hf download hf://spaces/Ardaosta/FSF-Studio/static/app.js
-
curl -L -o app.js https://huggingface.co/spaces/Ardaosta/FSF-Studio/resolve/main/static/app.js
37.9 kB
"use strict";
const $ = (id) => document.getElementById(id);
const state = {
layers: [], // see addLayerFromUpload
selectedLayerId: null,
panelWidthIn: 36,
panelHeightIn: 48,
intent: "cutouts",
composedToken: null,
composedPaths: null,
composedRawPaths: null,
composedW: 0,
composedH: 0,
composedInPerPx: null,
};
let nextLayerId = 1;
function newLayerId() { return `l${nextLayerId++}`; }
const els = {
dropzone: $("dropzone"),
fileInput: $("imageFile"),
layerList: $("layerList"),
layerEditor: $("layerEditor"),
editorName: $("editorName"),
modeSeg: $("modeSeg"),
thresholdRow: $("thresholdRow"),
threshold: $("threshold"),
thresholdOut: $("thresholdOut"),
blurRow: $("blurRow"),
blur: $("blur"),
blurOut: $("blurOut"),
invert: $("invert"),
layerWidthIn: $("layerWidthIn"),
layerXIn: $("layerXIn"),
layerYIn: $("layerYIn"),
layerCutSize: $("layerCutSize"),
panelWidthIn: $("panelWidthIn"),
panelHeightIn: $("panelHeightIn"),
intentSeg: $("intentSeg"),
kerfIn: $("kerfIn"),
minFeatureIn: $("minFeatureIn"),
maxGapIn: $("maxGapIn"),
warnings: $("warnings"),
steelMode: $("steelMode"),
showWarnings: $("showWarnings"),
measureBtn: $("measureBtn"),
measureSvg: $("measureSvg"),
measureLabel: $("measureLabel"),
cropOpenBtn: $("cropOpenBtn"),
cropResetBtn: $("cropResetBtn"),
cropModal: $("cropModal"),
cropArea: $("cropArea"),
cropImage: $("cropImage"),
cropRect: $("cropRect"),
cropDim: $("cropDim"),
cropApplyBtn: $("cropApplyBtn"),
cropCancelBtn: $("cropCancelBtn"),
cropClearBtn: $("cropClearBtn"),
genPrompt: $("genPrompt"),
genPlasmaStyle: $("genPlasmaStyle"),
genBtn: $("genBtn"),
composeBtn: $("composeBtn"),
exportSvgBtn: $("exportSvgBtn"),
exportDxfBtn: $("exportDxfBtn"),
status: $("status"),
stage: $("stage"),
stageInner: $("stageInner"),
layerPreviewWrap: $("layerPreviewWrap"),
traceSvg: $("traceSvg"),
warningOverlay: $("warningOverlay"),
dimsLabel: $("dimsLabel"),
};
// --- Status helper ---
function setStatus(msg, isError = false) {
els.status.textContent = msg || "";
els.status.classList.toggle("error", !!isError);
}
// --- Layer management ---
function selectedLayer() {
return state.layers.find((l) => l.id === state.selectedLayerId) || null;
}
async function addLayerFromGenerated(data, prompt) {
// The /generate endpoint already cached the image server-side and returned
// an image_token. Build a layer entry that mirrors what addLayerFromUpload
// produces, using the returned source_data_url so the crop modal works.
const defaultPolarity = "subtract";
const layer = {
id: newLayerId(),
name: data.name || (prompt.slice(0, 40)),
imageToken: data.image_token,
sourceUrl: data.source_data_url, // data URL of the full source PNG
originalWidth: data.width,
originalHeight: data.height,
sourceWidth: data.width,
sourceHeight: data.height,
thumbnail: data.thumbnail,
maskMode: "subject", // Plasma-friendly silhouettes work great with rembg
maskParams: { threshold: 128, blur: 0, invert: false, alpha_cutoff: 50, crop: null },
polarity: defaultPolarity,
maskPng: null,
visible: true,
xIn: state.panelWidthIn / 2 + state.layers.length * 2,
yIn: state.panelHeightIn / 2 + state.layers.length * 2,
// a panel drawing is the whole panel, not a motif dropped on one
widthIn: data.is_line_art
? state.panelWidthIn * 0.96
: Math.min(state.panelWidthIn, state.panelHeightIn) * 0.55,
aspect: data.width / Math.max(data.height, 1),
};
state.layers.push(layer);
state.selectedLayerId = layer.id;
await refreshLayerMask(layer);
renderLayerList();
renderEditor();
renderStageLayers();
els.composeBtn.disabled = false;
}
async function runGenerate() {
const prompt = els.genPrompt.value.trim();
if (!prompt) return;
const box = els.genBtn.closest(".generate-box");
box.classList.add("busy");
setStatus(`Generating "${prompt}"…`);
try {
const res = await fetch("/generate", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
prompt,
plasma_style: els.genPlasmaStyle.checked,
size: "1K",
}),
});
if (!res.ok) {
const err = await res.json().catch(() => ({}));
setStatus(err.error || `Generate failed (${res.status})`, true);
return;
}
const data = await res.json();
await addLayerFromGenerated(data, prompt);
setStatus(`Added "${data.name}" — extracting subject…`);
els.genPrompt.value = "";
} catch (err) {
setStatus(err.message || String(err), true);
} finally {
box.classList.remove("busy");
}
}
async function addLayerFromUpload(file) {
setStatus(`Uploading ${file.name}…`);
const fd = new FormData();
fd.append("image", file);
let res;
try {
res = await fetch("/upload", { method: "POST", body: fd });
} catch (err) {
setStatus(`Upload failed: ${err.message}`, true);
return;
}
if (!res.ok) {
setStatus(`Upload failed (${res.status})`, true);
return;
}
const data = await res.json();
const isFirst = state.layers.length === 0;
const sourceUrl = URL.createObjectURL(file);
const defaultPolarity = "subtract";
const layer = {
id: newLayerId(),
name: file.name.replace(/\.[^.]+$/, ""),
imageToken: data.image_token,
sourceUrl,
originalWidth: data.width,
originalHeight: data.height,
sourceWidth: data.width,
sourceHeight: data.height,
thumbnail: data.thumbnail,
// keep the bytes: a server restart drops the in-memory image cache and the
// layer has to be able to put itself back
sourceFile: file,
// Line art (an existing black-and-white drawing) must NOT go through rembg:
// it is a photo segmentation net and it smears fine linework into blobs.
// Threshold it instead, and invert, so the drawn black stays steel and the
// white around it is what gets cut.
maskMode: data.is_line_art ? "auto" : "subject",
maskParams: { threshold: 128, blur: 0, invert: !!data.is_line_art,
alpha_cutoff: 50, crop: null },
polarity: defaultPolarity,
maskPng: null,
visible: true,
xIn: state.panelWidthIn / 2 + state.layers.length * 2,
yIn: state.panelHeightIn / 2 + state.layers.length * 2,
widthIn: Math.min(state.panelWidthIn, state.panelHeightIn) * 0.55,
aspect: data.width / Math.max(data.height, 1),
};
state.layers.push(layer);
state.selectedLayerId = layer.id;
setStatus(data.is_line_art
? `Added ${layer.name}. Detected line art: using Auto Threshold + Invert (rembg would smear it).`
: `Added ${layer.name}. Computing mask…`);
await refreshLayerMask(layer);
renderLayerList();
renderEditor();
renderStageLayers();
els.composeBtn.disabled = false;
if (isFirst) {
setStatus(`Ready. Click "Compose & trace" to preview cuts.`);
}
}
// The image cache lives in memory, so a restart (or the HF Space waking from
// sleep) invalidates every token at once. Put the layer back from the bytes we
// still hold instead of showing "unknown image_token" and stopping.
async function reuploadLayer(layer) {
let blob = layer.sourceFile || null;
if (!blob && layer.sourceDataUrl) {
try { blob = await (await fetch(layer.sourceDataUrl)).blob(); } catch (e) { blob = null; }
}
if (!blob && layer.sourceUrl) {
try { blob = await (await fetch(layer.sourceUrl)).blob(); } catch (e) { blob = null; }
}
if (!blob) return false;
const fd = new FormData();
fd.append("image", blob, (layer.name || "layer") + ".png");
try {
const r = await fetch("/upload", { method: "POST", body: fd });
if (!r.ok) return false;
const d = await r.json();
layer.imageToken = d.image_token;
return true;
} catch (e) { return false; }
}
async function refreshLayerMask(layer, _retried) {
try {
const res = await fetch("/layer/preview", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
image_token: layer.imageToken,
mask_mode: layer.maskMode,
mask_params: layer.maskParams,
}),
});
if (!res.ok) {
const err = await res.json().catch(() => ({}));
const stale = /unknown image_token|expired/i.test(err.error || "");
if (stale && !_retried) {
setStatus("Server restarted; re-sending the image…");
if (await reuploadLayer(layer)) return refreshLayerMask(layer, true);
setStatus("Server restarted and the image is gone. Please re-add the layer.", true);
return;
}
setStatus(`Mask failed: ${err.error || res.status}`, true);
return;
}
const data = await res.json();
layer.maskPng = data.mask_png;
layer.subjectBbox = data.subject_bbox || null;
updateLayerMaskImage(layer);
if (state.selectedLayerId === layer.id) updateCutSizeReadout(layer);
} catch (err) {
setStatus(`Mask failed: ${err.message}`, true);
}
}
function computeSubjectCutSize(layer) {
if (!layer || !layer.subjectBbox) return null;
const sw = layer.sourceWidth;
const sh = layer.sourceHeight;
const { x0, y0, x1, y1 } = layer.subjectBbox;
const layerWidthIn = layer.widthIn;
const layerHeightIn = layer.widthIn / layer.aspect;
const cutWidthIn = (x1 - x0 + 1) / sw * layerWidthIn;
const cutHeightIn = (y1 - y0 + 1) / sh * layerHeightIn;
return {
cutWidthIn,
cutHeightIn,
layerWidthIn,
layerHeightIn,
fillPct: ((x1 - x0 + 1) * (y1 - y0 + 1)) / (sw * sh) * 100,
};
}
function updateCutSizeReadout(layer) {
if (!els.layerCutSize) return;
const s = computeSubjectCutSize(layer);
if (!s) {
els.layerCutSize.innerHTML = "";
return;
}
const placeholder = `${s.layerWidthIn.toFixed(2)} × ${s.layerHeightIn.toFixed(2)}″`;
const actual = `${s.cutWidthIn.toFixed(2)} × ${s.cutHeightIn.toFixed(2)}″`;
els.layerCutSize.innerHTML =
`Placeholder rect: ${placeholder} · Actual cut: <strong>${actual}</strong>`;
}
function deleteLayer(id) {
state.layers = state.layers.filter((l) => l.id !== id);
if (state.selectedLayerId === id) {
state.selectedLayerId = state.layers[0]?.id ?? null;
}
if (state.layers.length === 0) {
els.composeBtn.disabled = true;
state.composedRawPaths = null;
state.composedToken = null;
els.exportSvgBtn.disabled = true;
els.exportDxfBtn.disabled = true;
renderTracePaths([]);
renderWarnings({ warnings: [] });
setOverlay(null);
}
renderLayerList();
renderEditor();
renderStageLayers();
}
function toggleLayerVisible(id) {
const layer = state.layers.find((l) => l.id === id);
if (!layer) return;
layer.visible = !layer.visible;
renderLayerList();
renderStageLayers();
}
function selectLayer(id) {
state.selectedLayerId = id;
renderLayerList();
renderEditor();
updateLayerSelection();
}
// --- Rendering: layer list ---
function renderLayerList() {
els.layerList.innerHTML = "";
state.layers.forEach((layer) => {
const row = document.createElement("div");
row.className = "layer-row";
if (layer.id === state.selectedLayerId) row.classList.add("selected");
if (!layer.visible) row.classList.add("hidden-layer");
row.innerHTML = `
<img class="thumb" src="${layer.thumbnail}" alt="" />
<span class="layer-name" title="${escapeHtml(layer.name)}">${escapeHtml(layer.name)}</span>
<button class="icon-btn" data-act="visible" title="Toggle visibility">${layer.visible ? "👁" : "·"}</button>
<button class="icon-btn" data-act="delete" title="Delete">✕</button>
`;
row.addEventListener("click", (e) => {
const btn = e.target.closest("button");
if (btn) {
e.stopPropagation();
if (btn.dataset.act === "visible") toggleLayerVisible(layer.id);
if (btn.dataset.act === "delete") deleteLayer(layer.id);
return;
}
selectLayer(layer.id);
});
els.layerList.appendChild(row);
});
}
// --- Rendering: editor for the selected layer ---
function renderEditor() {
const layer = selectedLayer();
if (!layer) {
els.layerEditor.classList.add("hidden");
return;
}
els.layerEditor.classList.remove("hidden");
els.editorName.textContent = layer.name;
// Mode segmented control
els.modeSeg.querySelectorAll(".seg-btn").forEach((b) => {
b.classList.toggle("active", b.dataset.mode === layer.maskMode);
});
document.getElementById("polaritySeg").querySelectorAll(".seg-btn").forEach((b) => {
b.classList.toggle("active", b.dataset.polarity === (layer.polarity || "subtract"));
});
syncMaskRowsVisibility(layer);
els.threshold.value = layer.maskParams.threshold;
els.thresholdOut.textContent = layer.maskParams.threshold;
els.blur.value = layer.maskParams.blur;
els.blurOut.textContent = layer.maskParams.blur;
els.invert.checked = !!layer.maskParams.invert;
els.layerWidthIn.value = layer.widthIn.toFixed(2);
els.layerXIn.value = layer.xIn.toFixed(2);
els.layerYIn.value = layer.yIn.toFixed(2);
updateCutSizeReadout(layer);
els.cropResetBtn.disabled = !layer.maskParams.crop;
}
function syncMaskRowsVisibility(layer) {
const subject = layer.maskMode === "subject";
const auto = layer.maskMode === "auto";
els.thresholdRow.style.display = subject || auto ? "none" : "";
els.blurRow.style.display = subject ? "none" : "";
}
// --- Rendering: stage / canvas with layered previews ---
function fitStageInner() {
// Size the stage inner to match the panel aspect ratio, fit within stage box.
const box = els.stage.getBoundingClientRect();
const padding = 24;
const availW = Math.max(box.width - padding, 100);
const availH = Math.max(box.height - padding, 100);
const aspect = state.panelWidthIn / state.panelHeightIn;
let w, h;
if (availW / availH > aspect) {
h = availH; w = h * aspect;
} else {
w = availW; h = w / aspect;
}
els.stageInner.style.width = `${w}px`;
els.stageInner.style.height = `${h}px`;
return { w, h };
}
function applyLayerTransform(node, layer, pxPerInX, pxPerInY) {
const wPx = layer.widthIn * pxPerInX;
const hPx = (layer.widthIn / layer.aspect) * pxPerInY;
node.style.width = `${wPx}px`;
node.style.height = `${hPx}px`;
node.style.left = `${layer.xIn * pxPerInX - wPx / 2}px`;
node.style.top = `${layer.yIn * pxPerInY - hPx / 2}px`;
}
function renderStageLayers() {
// Full rebuild — call only when the layer set or visibility changes.
// For position/scale updates during drag or input edits, use
// updateLayerTransforms() which leaves DOM nodes intact (otherwise we
// destroy the node we're dragging and the pointer capture dies with it).
const { w: stageW, h: stageH } = fitStageInner();
const pxPerInX = stageW / state.panelWidthIn;
const pxPerInY = stageH / state.panelHeightIn;
els.layerPreviewWrap.innerHTML = "";
els.stage.classList.toggle("has-layers", state.layers.length > 0);
state.layers.forEach((layer) => {
if (!layer.visible) return;
const wrap = document.createElement("div");
wrap.className = "layer-preview";
if (layer.id === state.selectedLayerId) wrap.classList.add("selected");
wrap.classList.add(layer.polarity === "add" ? "polarity-add" : "polarity-subtract");
wrap.dataset.layerId = layer.id;
applyLayerTransform(wrap, layer, pxPerInX, pxPerInY);
if (layer.maskPng) {
const img = document.createElement("img");
img.src = layer.maskPng;
wrap.appendChild(img);
}
const handle = document.createElement("div");
handle.className = "handle";
handle.dataset.role = "resize";
wrap.appendChild(handle);
wrap.addEventListener("pointerdown", onLayerPointerDown);
els.layerPreviewWrap.appendChild(wrap);
});
}
function updateLayerTransforms() {
// Light update: reposition/resize existing nodes without rebuilding the DOM.
const { w: stageW, h: stageH } = fitStageInner();
const pxPerInX = stageW / state.panelWidthIn;
const pxPerInY = stageH / state.panelHeightIn;
els.layerPreviewWrap.querySelectorAll(".layer-preview").forEach((node) => {
const layer = state.layers.find((l) => l.id === node.dataset.layerId);
if (layer) applyLayerTransform(node, layer, pxPerInX, pxPerInY);
});
}
function updateLayerSelection() {
els.layerPreviewWrap.querySelectorAll(".layer-preview").forEach((node) => {
node.classList.toggle("selected", node.dataset.layerId === state.selectedLayerId);
});
}
function updateLayerMaskImage(layer) {
const node = els.layerPreviewWrap.querySelector(
`.layer-preview[data-layer-id="${layer.id}"]`
);
if (!node) return;
let img = node.querySelector("img");
if (!layer.maskPng) {
if (img) img.remove();
return;
}
if (!img) {
img = document.createElement("img");
node.insertBefore(img, node.firstChild);
}
img.src = layer.maskPng;
}
let dragCtx = null;
function onLayerPointerDown(e) {
const node = e.currentTarget;
const layerId = node.dataset.layerId;
selectLayer(layerId);
const role = e.target.dataset?.role === "resize" ? "resize" : "move";
const box = els.stageInner.getBoundingClientRect();
const stageW = box.width;
const stageH = box.height;
const layer = selectedLayer();
dragCtx = {
role, layerId,
startX: e.clientX, startY: e.clientY,
startLayerX: layer.xIn, startLayerY: layer.yIn,
startWidthIn: layer.widthIn,
pxPerInX: stageW / state.panelWidthIn,
pxPerInY: stageH / state.panelHeightIn,
};
node.setPointerCapture(e.pointerId);
node.classList.add("dragging");
node.addEventListener("pointermove", onLayerPointerMove);
node.addEventListener("pointerup", onLayerPointerUp, { once: true });
node.addEventListener("pointercancel", onLayerPointerUp, { once: true });
}
function onLayerPointerMove(e) {
if (!dragCtx) return;
const layer = state.layers.find((l) => l.id === dragCtx.layerId);
if (!layer) return;
const dx = e.clientX - dragCtx.startX;
const dy = e.clientY - dragCtx.startY;
if (dragCtx.role === "move") {
layer.xIn = dragCtx.startLayerX + dx / dragCtx.pxPerInX;
layer.yIn = dragCtx.startLayerY + dy / dragCtx.pxPerInY;
} else if (dragCtx.role === "resize") {
const proposed = dragCtx.startWidthIn + dx / dragCtx.pxPerInX;
layer.widthIn = Math.max(0.5, proposed);
}
// Update editor inputs and node styles without rebuilding the DOM.
els.layerWidthIn.value = layer.widthIn.toFixed(2);
els.layerXIn.value = layer.xIn.toFixed(2);
els.layerYIn.value = layer.yIn.toFixed(2);
updateLayerTransforms();
if (dragCtx.role === "resize") updateCutSizeReadout(layer);
}
function onLayerPointerUp(e) {
if (!dragCtx) return;
const node = els.layerPreviewWrap.querySelector(
`.layer-preview[data-layer-id="${dragCtx.layerId}"]`
);
if (node) {
node.classList.remove("dragging");
node.removeEventListener("pointermove", onLayerPointerMove);
}
dragCtx = null;
}
// --- Compose / analyze / export ---
async function runCompose() {
if (state.layers.length === 0) return;
els.composeBtn.disabled = true;
setStatus("Composing & tracing…");
try {
const res = await fetch("/compose", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
panel_w_in: state.panelWidthIn,
panel_h_in: state.panelHeightIn,
intent: state.intent,
layers: state.layers.map((l) => ({
image_token: l.imageToken,
mask_mode: l.maskMode,
mask_params: l.maskParams,
polarity: l.polarity || (state.intent === "silhouette" ? "add" : "subtract"),
x_in: l.xIn,
y_in: l.yIn,
scale_in: l.widthIn,
visible: l.visible,
})),
turdsize: 8,
alphamax: 1.0,
opttolerance: 0.4,
}),
});
if (!res.ok) {
const err = await res.json().catch(() => ({}));
setStatus(err.error || `Compose failed (${res.status})`, true);
return;
}
const data = await res.json();
state.composedToken = data.token;
state.composedRawPaths = data.paths;
state.composedPaths = data.svg_d;
state.composedW = data.width;
state.composedH = data.height;
state.composedInPerPx = data.in_per_px;
renderTracePaths(data.svg_d);
setStatus(`Composed — ${data.paths.length} cut path${data.paths.length === 1 ? "" : "s"}.`);
updateDimsLabel();
if (data.token) {
els.exportSvgBtn.disabled = false;
els.exportDxfBtn.disabled = false;
runAnalyze();
} else {
els.exportSvgBtn.disabled = true;
els.exportDxfBtn.disabled = true;
renderWarnings({ warnings: [] });
setOverlay(null);
}
} catch (err) {
setStatus(err.message || String(err), true);
} finally {
els.composeBtn.disabled = state.layers.length === 0;
}
}
function renderTracePaths(svgDs) {
if (!svgDs || !svgDs.length) {
els.traceSvg.innerHTML = "";
return;
}
els.traceSvg.setAttribute("viewBox", `0 0 ${state.composedW} ${state.composedH}`);
els.traceSvg.innerHTML = svgDs.map((d) => `<path d="${d}"/>`).join("");
}
async function runAnalyze() {
if (!state.composedToken) return;
try {
const res = await fetch("/analyze", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
token: state.composedToken,
width_in: state.panelWidthIn,
height_in: state.panelHeightIn,
intent: state.intent,
kerf_in: parseFloat(els.kerfIn.value) || 0.06,
min_feature_in: parseFloat(els.minFeatureIn.value) || 0.1,
max_gap_in: parseFloat(els.maxGapIn.value) || 0,
in_per_px: state.composedInPerPx,
}),
});
if (!res.ok) {
const err = await res.json().catch(() => ({}));
renderWarnings({ error: err.error || `Analyze failed (${res.status})` });
return;
}
const data = await res.json();
renderWarnings(data);
setOverlay(data.overlay_png_b64);
} catch (err) {
renderWarnings({ error: err.message || String(err) });
}
}
function setOverlay(b64) {
if (b64) {
els.warningOverlay.src = `data:image/png;base64,${b64}`;
els.stage.classList.toggle("show-warnings", els.showWarnings.checked);
} else {
els.warningOverlay.removeAttribute("src");
els.stage.classList.remove("show-warnings");
}
}
function renderWarnings(data) {
if (!data || data.error) {
els.warnings.classList.remove("clean");
els.warnings.innerHTML = `<p class="warnings-empty">${(data && data.error) || ""}</p>`;
return;
}
const ws = data.warnings || [];
if (ws.length === 0) {
els.warnings.classList.add("clean");
els.warnings.innerHTML = `<p>Looks cuttable. No thin features, floating islands or oversized gaps detected.</p>`;
return;
}
els.warnings.classList.remove("clean");
els.warnings.innerHTML = ws.map((w) => {
const meta = [];
if (w.kind === "thin_feature" && w.regions && w.regions.length) {
meta.push(w.regions.slice(0, 3).map((r) => `${r.min_width_in.toFixed(3)}″ wide`).join(", "));
}
if (w.kind === "gap_too_large" && w.regions && w.regions.length) {
meta.push(`Widest ${w.worst_in.toFixed(2)}" of ${w.max_allowed_in.toFixed(2)}" allowed`);
meta.push("Shown in blue on the panel");
}
if (w.kind === "floating_island" && data.islands && data.islands.length) {
meta.push("Sizes: " + data.islands.slice(0, 4).map((i) => `${i.area_in2.toFixed(2)} in²`).join(", "));
}
return `<div class="warning-item">
<div class="dot ${w.severity}"></div>
<div class="text">${escapeHtml(w.message)}
${meta.length ? `<div class="meta">${meta.map(escapeHtml).join(" · ")}</div>` : ""}
</div>
</div>`;
}).join("");
}
async function exportFile(endpoint, filename) {
if (!state.composedRawPaths) return;
setStatus(`Exporting ${filename}…`);
try {
const res = await fetch(endpoint, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
paths: state.composedRawPaths,
width_in: state.panelWidthIn,
height_in: state.panelHeightIn,
units: "inches",
in_per_px: state.composedInPerPx,
}),
});
if (!res.ok) {
const text = await res.text();
setStatus(`Export failed: ${text}`, true); return;
}
const blob = await res.blob();
const url = URL.createObjectURL(blob);
const a = document.createElement("a");
a.href = url; a.download = filename;
document.body.appendChild(a); a.click(); a.remove();
URL.revokeObjectURL(url);
setStatus(`Saved ${filename}.`);
} catch (err) {
setStatus(err.message || String(err), true);
}
}
function updateDimsLabel() {
const n = state.composedRawPaths?.length || 0;
els.dimsLabel.textContent = n > 0
? `Panel: ${state.panelWidthIn}″ × ${state.panelHeightIn}″ · ${n} cut path${n === 1 ? "" : "s"}`
: "";
}
// --- Event wiring ---
els.dropzone.addEventListener("click", () => els.fileInput.click());
els.fileInput.addEventListener("change", (e) => {
const f = e.target.files && e.target.files[0];
if (f) addLayerFromUpload(f);
e.target.value = "";
});
els.dropzone.addEventListener("dragover", (e) => { e.preventDefault(); els.dropzone.classList.add("drag"); });
els.dropzone.addEventListener("dragleave", () => els.dropzone.classList.remove("drag"));
els.dropzone.addEventListener("drop", (e) => {
e.preventDefault();
els.dropzone.classList.remove("drag");
const f = e.dataTransfer.files && e.dataTransfer.files[0];
if (f) addLayerFromUpload(f);
});
els.modeSeg.querySelectorAll(".seg-btn").forEach((btn) => {
btn.addEventListener("click", () => {
const layer = selectedLayer();
if (!layer) return;
layer.maskMode = btn.dataset.mode;
syncMaskRowsVisibility(layer);
els.modeSeg.querySelectorAll(".seg-btn").forEach((b) => b.classList.toggle("active", b === btn));
refreshLayerMask(layer);
});
});
document.getElementById("polaritySeg").querySelectorAll(".seg-btn").forEach((btn) => {
btn.addEventListener("click", () => {
const layer = selectedLayer();
if (!layer) return;
layer.polarity = btn.dataset.polarity;
document.getElementById("polaritySeg").querySelectorAll(".seg-btn").forEach((b) =>
b.classList.toggle("active", b === btn));
updateLayerPolarityClass(layer);
});
});
function updateLayerPolarityClass(layer) {
const node = els.layerPreviewWrap.querySelector(
`.layer-preview[data-layer-id="${layer.id}"]`
);
if (!node) return;
node.classList.toggle("polarity-add", layer.polarity === "add");
node.classList.toggle("polarity-subtract", layer.polarity !== "add");
// Compose result is now stale; re-run if we have an active composition.
if (state.composedToken) {
clearTimeout(maskRefreshTimer);
maskRefreshTimer = setTimeout(runCompose, 200);
}
}
els.threshold.addEventListener("input", () => {
els.thresholdOut.textContent = els.threshold.value;
const layer = selectedLayer();
if (!layer) return;
layer.maskParams.threshold = parseInt(els.threshold.value, 10);
scheduleLayerMaskRefresh(layer);
});
els.blur.addEventListener("input", () => {
els.blurOut.textContent = els.blur.value;
const layer = selectedLayer();
if (!layer) return;
layer.maskParams.blur = parseFloat(els.blur.value);
scheduleLayerMaskRefresh(layer);
});
els.invert.addEventListener("change", () => {
const layer = selectedLayer();
if (!layer) return;
layer.maskParams.invert = els.invert.checked;
refreshLayerMask(layer);
});
let maskRefreshTimer = null;
function scheduleLayerMaskRefresh(layer) {
clearTimeout(maskRefreshTimer);
maskRefreshTimer = setTimeout(() => refreshLayerMask(layer), 200);
}
[els.layerWidthIn, els.layerXIn, els.layerYIn].forEach((input) => {
input.addEventListener("input", () => {
const layer = selectedLayer();
if (!layer) return;
layer.widthIn = parseFloat(els.layerWidthIn.value) || layer.widthIn;
layer.xIn = parseFloat(els.layerXIn.value) || layer.xIn;
layer.yIn = parseFloat(els.layerYIn.value) || layer.yIn;
updateLayerTransforms();
updateCutSizeReadout(layer);
});
});
[els.panelWidthIn, els.panelHeightIn].forEach((input) => {
input.addEventListener("input", () => {
state.panelWidthIn = parseFloat(els.panelWidthIn.value) || state.panelWidthIn;
state.panelHeightIn = parseFloat(els.panelHeightIn.value) || state.panelHeightIn;
updateLayerTransforms();
updateDimsLabel();
});
});
els.intentSeg.querySelectorAll(".seg-btn").forEach((btn) => {
btn.addEventListener("click", () => {
state.intent = btn.dataset.intent;
els.intentSeg.querySelectorAll(".seg-btn").forEach((b) => b.classList.toggle("active", b === btn));
if (state.composedToken) runAnalyze();
});
});
[els.kerfIn, els.minFeatureIn, els.maxGapIn].forEach((input) => {
input.addEventListener("input", () => {
if (state.composedToken) {
clearTimeout(maskRefreshTimer);
maskRefreshTimer = setTimeout(runAnalyze, 200);
}
});
});
els.steelMode.addEventListener("change", () => {
els.stage.classList.toggle("steel", els.steelMode.checked);
});
els.stage.classList.toggle("steel", els.steelMode.checked);
els.showWarnings.addEventListener("change", () => {
els.stage.classList.toggle("show-warnings",
els.showWarnings.checked && !!els.warningOverlay.src);
});
els.composeBtn.addEventListener("click", runCompose);
els.genBtn.addEventListener("click", runGenerate);
els.genPrompt.addEventListener("keydown", (e) => {
if (e.key === "Enter") runGenerate();
});
els.exportSvgBtn.addEventListener("click", () => exportFile("/export/svg", "plasma-design.svg"));
els.exportDxfBtn.addEventListener("click", () => exportFile("/export/dxf", "plasma-design.dxf"));
// --- Drag-to-measure tool ---
let measureMode = false;
let measureState = null; // { startPx, currentPx } in stage-inner coordinates
function toggleMeasure(on) {
measureMode = on !== undefined ? on : !measureMode;
els.measureBtn.classList.toggle("active", measureMode);
els.stage.classList.toggle("measuring", measureMode);
if (!measureMode) clearMeasurement();
}
function clearMeasurement() {
measureState = null;
els.measureSvg.innerHTML = "";
els.measureLabel.textContent = "";
els.measureLabel.style.display = "none";
}
function pxToInches(dxPx, dyPx) {
const box = els.stageInner.getBoundingClientRect();
if (box.width === 0 || box.height === 0) return { dxIn: 0, dyIn: 0 };
const dxIn = dxPx * (state.panelWidthIn / box.width);
const dyIn = dyPx * (state.panelHeightIn / box.height);
return { dxIn, dyIn };
}
function renderMeasurement() {
if (!measureState) return;
const { startPx, currentPx } = measureState;
const box = els.stageInner.getBoundingClientRect();
els.measureSvg.setAttribute("viewBox", `0 0 ${box.width} ${box.height}`);
const dxPx = currentPx.x - startPx.x;
const dyPx = currentPx.y - startPx.y;
const distPx = Math.hypot(dxPx, dyPx);
const { dxIn, dyIn } = pxToInches(dxPx, dyPx);
const distIn = Math.hypot(dxIn, dyIn);
els.measureSvg.innerHTML = `
<line x1="${startPx.x}" y1="${startPx.y}" x2="${currentPx.x}" y2="${currentPx.y}"/>
<circle cx="${startPx.x}" cy="${startPx.y}" r="4"/>
<circle cx="${currentPx.x}" cy="${currentPx.y}" r="4"/>
`;
els.measureLabel.innerHTML =
`${distIn.toFixed(2)}″ <span style="color:#888">·</span> ` +
`Δx ${Math.abs(dxIn).toFixed(2)}″, Δy ${Math.abs(dyIn).toFixed(2)}″`;
els.measureLabel.style.left = `${currentPx.x}px`;
els.measureLabel.style.top = `${currentPx.y}px`;
els.measureLabel.style.display = "block";
}
function stagePointFromEvent(e) {
const box = els.stageInner.getBoundingClientRect();
return {
x: Math.max(0, Math.min(box.width, e.clientX - box.left)),
y: Math.max(0, Math.min(box.height, e.clientY - box.top)),
};
}
els.stageInner.addEventListener("pointerdown", (e) => {
if (!measureMode) return;
e.preventDefault();
e.stopPropagation();
const p = stagePointFromEvent(e);
measureState = { startPx: p, currentPx: p };
renderMeasurement();
els.stageInner.setPointerCapture(e.pointerId);
const move = (ev) => {
if (!measureState) return;
measureState.currentPx = stagePointFromEvent(ev);
renderMeasurement();
};
const up = () => {
els.stageInner.removeEventListener("pointermove", move);
els.stageInner.removeEventListener("pointerup", up);
els.stageInner.removeEventListener("pointercancel", up);
};
els.stageInner.addEventListener("pointermove", move);
els.stageInner.addEventListener("pointerup", up);
els.stageInner.addEventListener("pointercancel", up);
});
els.measureBtn.addEventListener("click", () => toggleMeasure());
// Escape exits measure mode
window.addEventListener("keydown", (e) => {
if (e.key === "Escape" && measureMode) toggleMeasure(false);
});
// --- Per-layer crop tool ---
let cropCtx = null; // { layer, pendingCrop }
function openCropModal() {
const layer = selectedLayer();
if (!layer || !layer.sourceUrl) return;
cropCtx = {
layer,
pendingCrop: layer.maskParams.crop || null,
};
els.cropImage.src = layer.sourceUrl;
els.cropModal.classList.remove("hidden");
// Wait for image load to know its rendered size, then position the existing rect.
els.cropImage.onload = () => renderCropRect();
}
function closeCropModal() {
els.cropModal.classList.add("hidden");
cropCtx = null;
els.cropRect.classList.remove("visible");
els.cropArea.classList.remove("has-rect");
}
function renderCropRect() {
if (!cropCtx) return;
const img = els.cropImage;
const { pendingCrop } = cropCtx;
els.cropApplyBtn.disabled = !pendingCrop;
if (!pendingCrop) {
els.cropRect.classList.remove("visible");
els.cropArea.classList.remove("has-rect");
return;
}
// Convert source-pixel crop to displayed-pixel crop
const scale = img.offsetWidth / img.naturalWidth;
const left = pendingCrop.x0 * scale;
const top = pendingCrop.y0 * scale;
const width = (pendingCrop.x1 - pendingCrop.x0) * scale;
const height = (pendingCrop.y1 - pendingCrop.y0) * scale;
els.cropRect.style.left = `${left}px`;
els.cropRect.style.top = `${top}px`;
els.cropRect.style.width = `${width}px`;
els.cropRect.style.height = `${height}px`;
els.cropRect.classList.add("visible");
els.cropArea.classList.add("has-rect");
els.cropDim.style.left = `${left + width}px`;
els.cropDim.style.top = `${top}px`;
els.cropDim.textContent = `${pendingCrop.x1 - pendingCrop.x0} × ${pendingCrop.y1 - pendingCrop.y0} px`;
}
let cropDrag = null;
els.cropArea.addEventListener("pointerdown", (e) => {
if (!cropCtx) return;
if (e.target !== els.cropImage && e.target !== els.cropArea) return;
const img = els.cropImage;
const box = img.getBoundingClientRect();
const startX = e.clientX - box.left;
const startY = e.clientY - box.top;
cropDrag = { startX, startY, box };
els.cropArea.setPointerCapture(e.pointerId);
});
els.cropArea.addEventListener("pointermove", (e) => {
if (!cropDrag || !cropCtx) return;
const img = els.cropImage;
const { startX, startY, box } = cropDrag;
const curX = Math.max(0, Math.min(box.width, e.clientX - box.left));
const curY = Math.max(0, Math.min(box.height, e.clientY - box.top));
const x0 = Math.min(startX, curX);
const x1 = Math.max(startX, curX);
const y0 = Math.min(startY, curY);
const y1 = Math.max(startY, curY);
// Convert displayed pixels to source pixels
const scale = img.naturalWidth / img.offsetWidth;
cropCtx.pendingCrop = {
x0: Math.round(x0 * scale),
y0: Math.round(y0 * scale),
x1: Math.round(x1 * scale),
y1: Math.round(y1 * scale),
};
renderCropRect();
});
els.cropArea.addEventListener("pointerup", () => { cropDrag = null; });
els.cropArea.addEventListener("pointercancel", () => { cropDrag = null; });
els.cropOpenBtn.addEventListener("click", openCropModal);
els.cropCancelBtn.addEventListener("click", closeCropModal);
els.cropClearBtn.addEventListener("click", () => {
if (!cropCtx) return;
cropCtx.pendingCrop = null;
renderCropRect();
});
els.cropApplyBtn.addEventListener("click", async () => {
if (!cropCtx || !cropCtx.pendingCrop) return;
const { layer, pendingCrop } = cropCtx;
layer.maskParams.crop = pendingCrop;
// Update layer's effective source dimensions + aspect ratio
layer.sourceWidth = pendingCrop.x1 - pendingCrop.x0;
layer.sourceHeight = pendingCrop.y1 - pendingCrop.y0;
layer.aspect = layer.sourceWidth / Math.max(layer.sourceHeight, 1);
closeCropModal();
setStatus("Re-running mask on cropped source…");
await refreshLayerMask(layer);
updateLayerTransforms();
renderLayerList(); // thumbnail still reflects original, but at least size updates
setStatus(`Crop applied to ${layer.name}.`);
els.cropResetBtn.disabled = false;
});
els.cropResetBtn.addEventListener("click", async () => {
const layer = selectedLayer();
if (!layer || !layer.maskParams.crop) return;
layer.maskParams.crop = null;
layer.sourceWidth = layer.originalWidth;
layer.sourceHeight = layer.originalHeight;
layer.aspect = layer.originalWidth / Math.max(layer.originalHeight, 1);
setStatus("Re-running mask on full source…");
await refreshLayerMask(layer);
updateLayerTransforms();
setStatus(`Crop cleared on ${layer.name}.`);
els.cropResetBtn.disabled = true;
});
window.addEventListener("keydown", (e) => {
if (e.key === "Escape" && !els.cropModal.classList.contains("hidden")) {
closeCropModal();
}
});
window.addEventListener("resize", () => updateLayerTransforms());
function escapeHtml(s) {
return String(s).replace(/[&<>"']/g, (c) => ({
"&": "&", "<": "<", ">": ">", '"': """, "'": "'"
}[c]));
}
renderStageLayers();
;
const $ = (id) => document.getElementById(id);
const state = {
layers: [], // see addLayerFromUpload
selectedLayerId: null,
panelWidthIn: 36,
panelHeightIn: 48,
intent: "cutouts",
composedToken: null,
composedPaths: null,
composedRawPaths: null,
composedW: 0,
composedH: 0,
composedInPerPx: null,
};
let nextLayerId = 1;
function newLayerId() { return `l${nextLayerId++}`; }
const els = {
dropzone: $("dropzone"),
fileInput: $("imageFile"),
layerList: $("layerList"),
layerEditor: $("layerEditor"),
editorName: $("editorName"),
modeSeg: $("modeSeg"),
thresholdRow: $("thresholdRow"),
threshold: $("threshold"),
thresholdOut: $("thresholdOut"),
blurRow: $("blurRow"),
blur: $("blur"),
blurOut: $("blurOut"),
invert: $("invert"),
layerWidthIn: $("layerWidthIn"),
layerXIn: $("layerXIn"),
layerYIn: $("layerYIn"),
layerCutSize: $("layerCutSize"),
panelWidthIn: $("panelWidthIn"),
panelHeightIn: $("panelHeightIn"),
intentSeg: $("intentSeg"),
kerfIn: $("kerfIn"),
minFeatureIn: $("minFeatureIn"),
maxGapIn: $("maxGapIn"),
warnings: $("warnings"),
steelMode: $("steelMode"),
showWarnings: $("showWarnings"),
measureBtn: $("measureBtn"),
measureSvg: $("measureSvg"),
measureLabel: $("measureLabel"),
cropOpenBtn: $("cropOpenBtn"),
cropResetBtn: $("cropResetBtn"),
cropModal: $("cropModal"),
cropArea: $("cropArea"),
cropImage: $("cropImage"),
cropRect: $("cropRect"),
cropDim: $("cropDim"),
cropApplyBtn: $("cropApplyBtn"),
cropCancelBtn: $("cropCancelBtn"),
cropClearBtn: $("cropClearBtn"),
genPrompt: $("genPrompt"),
genPlasmaStyle: $("genPlasmaStyle"),
genBtn: $("genBtn"),
composeBtn: $("composeBtn"),
exportSvgBtn: $("exportSvgBtn"),
exportDxfBtn: $("exportDxfBtn"),
status: $("status"),
stage: $("stage"),
stageInner: $("stageInner"),
layerPreviewWrap: $("layerPreviewWrap"),
traceSvg: $("traceSvg"),
warningOverlay: $("warningOverlay"),
dimsLabel: $("dimsLabel"),
};
// --- Status helper ---
function setStatus(msg, isError = false) {
els.status.textContent = msg || "";
els.status.classList.toggle("error", !!isError);
}
// --- Layer management ---
function selectedLayer() {
return state.layers.find((l) => l.id === state.selectedLayerId) || null;
}
async function addLayerFromGenerated(data, prompt) {
// The /generate endpoint already cached the image server-side and returned
// an image_token. Build a layer entry that mirrors what addLayerFromUpload
// produces, using the returned source_data_url so the crop modal works.
const defaultPolarity = "subtract";
const layer = {
id: newLayerId(),
name: data.name || (prompt.slice(0, 40)),
imageToken: data.image_token,
sourceUrl: data.source_data_url, // data URL of the full source PNG
originalWidth: data.width,
originalHeight: data.height,