Image Segmentation
PyTorch
English
painting-vision-robotics-kit
semantic-segmentation
robotics
edge-ai
construction-ai
autonomous-painting
wall-painting-robot
paint-coverage-estimation
building-facade
drywall
skirting-detection
window-detection
lidar
depth-validation
segformer
deeplabv3
Eval Results (legacy)
Update code: real-machine G-code adapter, commissioning gate, machine_job runner, pump watchdog firmware, twin completion gate, realism and masking modules (card and weights unchanged)
4eecd03 verified Download console/app.js from constructelligence/painting-vision-robotics-kit: direct link, hf CLI and curl.
- Browser
- Download file 46.4 kB
-
https://huggingface.co/constructelligence/painting-vision-robotics-kit/resolve/main/console/app.js
- Command line
-
hf download hf://constructelligence/painting-vision-robotics-kit/console/app.js
-
curl -L -o app.js https://huggingface.co/constructelligence/painting-vision-robotics-kit/resolve/main/console/app.js
46.4 kB
| // Operator console front end: no framework, talks to console_server.py. | |
| ; | |
| const $ = (sel) => document.querySelector(sel); | |
| const STATUS = { | |
| ready_to_paint: ["Ready to paint", "The gate passes. Check the green area, then approve."], | |
| prep_required: ["Prep first", "Damage must be scraped/treated and primed, then the wall rescanned before the coat."], | |
| touch_up_only: ["Touch-up only", "The wall is signed off; only small unconfirmed patches remain."], | |
| complete: ["Complete", "The wall is signed off. Nothing to paint."], | |
| blocked: ["Blocked", "The safety gate stops this job. Fix or confirm the reasons below."], | |
| approved: ["Approved", "This work order is frozen and recorded."], | |
| }; | |
| const RELEVANT = { not_wallpaper: /wallpaper/i, depth_waived: /depth/i, uncertainty_reviewed: /uncertain|re-observ/i, | |
| colour_checked: /colour|ΔE00|tin/i }; | |
| let health = null; | |
| let job = null; | |
| let tool = "none"; | |
| let dirty = false; | |
| let drawing = false; | |
| const editCanvas = $("#edits"); | |
| const ectx = editCanvas.getContext("2d"); | |
| // a non-blocking message instead of a modal alert(): errors stay a little longer, and a screen reader hears it (aria-live) | |
| function toast(message, kind = "error") { | |
| const box = $("#toasts"); | |
| if (!box) { console.warn(message); return; } | |
| const el = document.createElement("div"); | |
| el.className = `toast ${kind}`; | |
| el.textContent = String(message); | |
| box.appendChild(el); | |
| while (box.children.length > 3) box.firstChild.remove(); | |
| setTimeout(() => { el.classList.add("out"); setTimeout(() => el.remove(), 260); }, kind === "error" ? 6500 : 3200); | |
| } | |
| function esc(s) { | |
| return String(s ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&", "<": "<", ">": ">", '"': """, "'": "'" }[c])); | |
| } | |
| function sqft(mm2) { | |
| const ft = mm2 / 92903.04; | |
| return ft < 0.1 ? "< 0.1 sq ft" : `${fmt(ft, ft < 10 ? 1 : 0)} sq ft`; | |
| } | |
| function fmt(n, digits = 0) { | |
| return n == null ? "—" : Number(n).toLocaleString(undefined, { maximumFractionDigits: digits }); | |
| } | |
| async function api(path, options = {}) { | |
| const res = await fetch(path, options); | |
| const body = await res.json().catch(() => ({})); | |
| if (!res.ok) throw new Error(body.error || `${res.status} ${res.statusText}`); | |
| return body; | |
| } | |
| function store(key, value) { | |
| try { value === undefined ? localStorage.getItem(key) : localStorage.setItem(key, value); } catch (_) { /* private mode */ } | |
| } | |
| function recall(key) { | |
| try { return localStorage.getItem(key) || ""; } catch (_) { return ""; } | |
| } | |
| // ------------------------------------------------------------------ boot | |
| async function boot() { | |
| $("#operator").value = recall("pv.operator"); | |
| $("#operator").addEventListener("change", (e) => store("pv.operator", e.target.value.trim())); | |
| try { | |
| health = await api("/api/health"); | |
| const m = health.model || {}; | |
| $("#model").textContent = `${m.checkpoint || "model"} · ${m.arch || ""} · ${m.device || ""}`; | |
| if ((m.warnings || []).length) { | |
| $("#banner").hidden = false; | |
| $("#banner").textContent = "Model not fully calibrated: " + m.warnings.join(" · "); | |
| } | |
| } catch (err) { | |
| $("#model").textContent = "console offline: " + err.message; | |
| } | |
| renderConfirmations(); | |
| await refreshJobs(); | |
| const id = new URLSearchParams(location.hash.slice(1)).get("job"); | |
| if (id) openJob(id); | |
| } | |
| async function refreshJobs() { | |
| const jobs = await api("/api/jobs").catch(() => []); | |
| const list = $("#job-list"); | |
| list.innerHTML = ""; | |
| for (const j of jobs) { | |
| const li = document.createElement("li"); | |
| const b = document.createElement("button"); | |
| const status = j.approved ? "approved" : j.status; | |
| b.innerHTML = `<span class="name">${esc(j.wall_id || j.filename || j.id)}</span> | |
| <span class="small muted">${esc(new Date(j.created).toLocaleString())}</span> | |
| <span class="pill ${esc(status)}">${esc((STATUS[status] || [status])[0])}</span>`; | |
| if (job && job.id === j.id) b.classList.add("active"); | |
| b.addEventListener("click", () => openJob(j.id)); | |
| li.appendChild(b); | |
| list.appendChild(li); | |
| } | |
| if (typeof loadEvidence === "function") loadEvidence(); // drawings count as evidence (a generated one does not) | |
| } | |
| // ------------------------------------------------------------------ upload | |
| async function upload(file) { | |
| if (!file) return; | |
| const status = $("#upload-status"); | |
| status.textContent = `Analysing ${file.name}… (about 10–20 s on CPU)`; | |
| try { | |
| const q = new URLSearchParams({ filename: file.name, wall_id: $("#wall-id").value.trim() }); | |
| const created = await api(`/api/jobs?${q}`, { method: "POST", body: file, headers: { "Content-Type": file.type || "application/octet-stream" } }); | |
| status.textContent = ""; | |
| $("#wall-id").value = ""; | |
| showJob(created); | |
| refreshJobs(); | |
| } catch (err) { | |
| status.textContent = "Upload failed: " + err.message; | |
| } | |
| } | |
| $("#file").addEventListener("change", (e) => upload(e.target.files[0])); | |
| const drop = $("#drop"); | |
| ["dragenter", "dragover"].forEach((t) => drop.addEventListener(t, (e) => { e.preventDefault(); drop.classList.add("over"); })); | |
| ["dragleave", "drop"].forEach((t) => drop.addEventListener(t, (e) => { e.preventDefault(); drop.classList.remove("over"); })); | |
| drop.addEventListener("drop", (e) => upload(e.dataTransfer.files[0])); | |
| // ------------------------------------------------------------------ job view | |
| async function openJob(id) { | |
| try { showJob(await api(`/api/jobs/${encodeURIComponent(id)}`)); } catch (err) { toast(err.message); } | |
| } | |
| function showJob(j) { | |
| job = j; | |
| history.replaceState(null, "", `#job=${j.id}`); | |
| const v = `?v=${encodeURIComponent(j.updated || j.created)}`; | |
| $("#empty").hidden = true; | |
| $("#stage").hidden = false; | |
| const photo = $("#photo"); | |
| photo.src = `/api/jobs/${j.id}/photo.jpg`; | |
| for (const name of ["paint", "keepout", "uncertain", "touchup"]) { | |
| const fill = document.querySelector(`img.layer[data-layer="${name}"]:not(.edge)`); | |
| fill.src = `/api/jobs/${j.id}/layer_${name}.png${v}`; | |
| // the outline twin of each fill: a coloured ring with a white halo, readable on any wall colour | |
| let edge = document.querySelector(`img.layer.edge[data-layer="${name}"]`); | |
| if (!edge) { edge = document.createElement("img"); edge.className = "layer edge"; edge.alt = ""; edge.dataset.layer = name; fill.after(edge); } | |
| edge.hidden = false; | |
| edge.classList.toggle("off", !document.querySelector(`#layer-toggles input[data-layer="${name}"]`).checked); | |
| edge.src = `/api/jobs/${j.id}/layer_${name}_edge.png${v}`; | |
| } | |
| editCanvas.width = j.width; | |
| editCanvas.height = j.height; | |
| ectx.clearRect(0, 0, j.width, j.height); | |
| if (j.has_edits) { | |
| const img = new Image(); | |
| img.onload = () => ectx.drawImage(img, 0, 0); | |
| img.src = `/api/jobs/${j.id}/layer_edits.png${v}`; | |
| } | |
| setDirty(false); | |
| renderVector(); | |
| renderPanel(); | |
| applyLayerToggles(); | |
| document.querySelectorAll(".job-list button").forEach((b) => b.classList.remove("active")); | |
| refreshJobs(); | |
| } | |
| function svgEl(name, attrs) { | |
| const el = document.createElementNS("http://www.w3.org/2000/svg", name); | |
| for (const [k, v] of Object.entries(attrs)) el.setAttribute(k, v); | |
| return el; | |
| } | |
| const pts = (poly) => (poly || []).map(([x, y]) => `${x},${y}`).join(" "); | |
| function renderVector() { | |
| const svg = $("#vector"); | |
| svg.innerHTML = ""; | |
| svg.setAttribute("viewBox", `0 0 ${job.width} ${job.height}`); | |
| svg.setAttribute("preserveAspectRatio", "none"); | |
| const damage = svgEl("g", { "data-layer": "damage" }); | |
| (job.regions || []).forEach((r, i) => { | |
| if (r.prep_zone_xy && r.prep_zone_xy.length > 2) damage.appendChild(svgEl("polygon", { points: pts(r.prep_zone_xy), class: "prep-zone" })); | |
| if (r.outline_xy && r.outline_xy.length > 2) damage.appendChild(svgEl("polygon", { points: pts(r.outline_xy), class: "damage", "data-region": i })); | |
| }); | |
| svg.appendChild(damage); | |
| const paths = svgEl("g", { "data-layer": "paths" }); | |
| const lines = (strokes, cls) => (strokes || []).forEach(([[x0, y0], [x1, y1]]) => | |
| paths.appendChild(svgEl("line", { x1: x0, y1: y0, x2: x1, y2: y1, class: cls }))); | |
| for (const step of (job.work_order || {}).steps || []) { | |
| if (step.step === "paint" && step.plan) { | |
| lines(step.plan.plan.strokes, "roller"); | |
| lines(step.plan.plan.trim.strokes, "trim"); | |
| } | |
| if (step.step === "prep") step.tasks.forEach((t) => lines(t.strokes_px, "prep-path")); | |
| if (step.step === "touch_up") step.tasks.forEach((t) => lines(t.strokes_px, "touch-path")); | |
| } | |
| svg.appendChild(paths); | |
| } | |
| function renderPanel() { | |
| const order = job.work_order || {}; | |
| const status = job.approved ? "approved" : order.status; | |
| const [title, text] = STATUS[status] || [status || "—", ""]; | |
| const decision = $("#decision"); | |
| decision.className = `decision ${status}`; | |
| decision.innerHTML = `<h3>${esc(title)}</h3><p>${esc(text)}</p>`; | |
| const reasons = (order.gate || {}).reasons || []; | |
| const warnings = order.warnings || []; | |
| $("#reasons").innerHTML = reasons.length || warnings.length | |
| ? `<ul class="reasons">${reasons.map((r) => `<li class="bad">${esc(r)}</li>`).join("")}${warnings.map((w) => `<li class="warn">${esc(w)}</li>`).join("")}</ul>` | |
| : ""; | |
| // Confirmations: check the ones already signed; highlight the ones a reason asks for. | |
| const signed = new Set((order.confirmations || []).map((c) => c.name)); | |
| document.querySelectorAll("#confirmations input").forEach((box) => { | |
| box.checked = signed.has(box.value); | |
| const label = box.closest("label"); | |
| label.classList.toggle("relevant", reasons.some((r) => (RELEVANT[box.value] || /$^/).test(r))); | |
| box.disabled = !!job.approved; | |
| }); | |
| const s = order.summary || {}; | |
| const scale = order.scale || {}; | |
| const areaFt = s.paint_area_ft2 != null ? `${fmt(s.paint_area_ft2, 1)} sq ft` : `${fmt(s.paint_area_px)} px`; | |
| const m = (job.measurements || {}).faces || []; | |
| // What colour is on the wall (and does it match the spec), and what equipment is on site. | |
| const colour = job.paint_color || {}; | |
| const objects = job.site_objects || {}; | |
| const coat = colour.dominant; | |
| const spec = colour.reference; | |
| const coatCell = coat | |
| ? `<span class="swatch" data-hex="${esc(coat.hex)}"></span> ${esc(coat.name)} | |
| <span class="muted">${esc(coat.hex)}</span>${spec ? ` · spec | |
| <b class="${spec.verdict === "match" ? "" : "warn"}">${esc(spec.verdict)}</b> | |
| <span class="muted">ΔE00 ${fmt(spec.delta_e, 1)}</span>` : ""}` | |
| : "not reported"; | |
| const seen = (objects.present || []).map((n) => n.replace(/_/g, " ")); | |
| const equipmentCell = objects.status | |
| ? `${seen.length ? esc(seen.join(", ")) : "none seen"}${(objects.missing_tools || []).length | |
| ? ` <span class="warn">· missing ${esc(objects.missing_tools.join(", ").replace(/_/g, " "))}</span>` : ""}` | |
| : "not reported"; | |
| const paintSwatches = () => document.querySelectorAll("#areas .swatch[data-hex]").forEach((el) => { el.style.background = el.dataset.hex; }); | |
| $("#areas").innerHTML = ` | |
| <dt>Paint area</dt><dd>${areaFt}</dd> | |
| <dt>Coat colour</dt><dd class="small">${coatCell}</dd> | |
| <dt>Equipment seen</dt><dd class="small">${equipmentCell}</dd> | |
| <dt>Prep regions</dt><dd>${fmt(s.prep_regions)}</dd> | |
| <dt>Touch-up patches</dt><dd>${fmt(s.touch_up_patches)}</dd> | |
| <dt>Wall faces measured</dt><dd>${fmt(m.length)}</dd> | |
| <dt>Scale</dt><dd class="small">${scale.mm_per_px ? `${fmt(scale.mm_per_px, 2)} mm/px` : "none"}</dd> | |
| ${scale.source ? `<dd class="small muted full">${esc(scale.source.replace(/_/g, " "))}</dd>` : ""}`; | |
| paintSwatches(); | |
| const steps = $("#steps"); | |
| steps.innerHTML = ""; | |
| for (const step of order.steps || []) { | |
| const li = document.createElement("li"); | |
| let inner = `<span class="step-name">${esc(step.step.replace("_", " "))}</span>`; | |
| if (step.skipped) inner += ` <span class="small muted">— ${esc(step.skipped)}</span>`; | |
| if (step.provisional) inner += ` <span class="small warn">provisional until rescan</span>`; | |
| if (step.hold_minutes) inner += ` <span class="small muted">· hold ${fmt(step.hold_minutes)} min</span>`; | |
| if (step.step === "rescan") inner += `<div class="small muted">${esc(step.reason)}</div>`; | |
| if (step.plan) { | |
| const p = step.plan.plan; | |
| inner += `<div class="small muted">${fmt(p.passes)} roller passes · ${fmt(p.trim.segments)} trim strokes</div>`; | |
| } | |
| if (step.step === "setup") { | |
| // What has to be on site before any paint: tools the plan needs, colour check, clutter. | |
| inner += "<ul>" + step.tasks.map((t) => `<li class="task"><b>${esc(String(t.task).replace(/-/g, " "))}</b> | |
| <div class="muted">${esc(t.detail || "")}</div></li>`).join("") + "</ul>"; | |
| } else if (step.step === "spot_prime") { | |
| // One line per primer: the zones are the prep zones above. | |
| const groups = {}; | |
| step.tasks.forEach((t) => { | |
| const g = (groups[t.primer] = groups[t.primer] || { n: 0, mm2: 0, px: 0 }); | |
| g.n += 1; g.mm2 += t.zone_area_mm2 || 0; g.px += t.zone_area_px || 0; | |
| }); | |
| inner += "<ul>" + Object.entries(groups).map(([primer, g]) => `<li class="task"><b>${esc(primer)}</b> | |
| <div class="muted">${g.n} zone${g.n > 1 ? "s" : ""} · ${g.mm2 ? sqft(g.mm2) : fmt(g.px) + " px"}</div></li>`).join("") + "</ul>"; | |
| } else if (step.tasks) { | |
| const card = (t, i) => `<li class="task" data-task="${i}" data-step="${esc(step.step)}"> | |
| <b>${esc(t.type ? t.type.replace("_", " ") : t.task)}</b> | |
| ${t.method ? `<div>${esc(t.method)}</div>` : ""} | |
| <div class="muted">${t.zone_area_mm2 || t.area_mm2 ? sqft(t.zone_area_mm2 || t.area_mm2) : fmt(t.zone_area_px ?? t.area_px) + " px"} | |
| ${t.confidence ? ` · conf ${fmt(t.confidence.mean, 2)}` : ""}</div></li>`; | |
| // Largest first for display (the order itself stays in travel order). | |
| const ranked = step.tasks.map((t, i) => [t, i]).sort((a, b) => (b[0].zone_area_px ?? b[0].area_px) - (a[0].zone_area_px ?? a[0].area_px)); | |
| const head = ranked.slice(0, 3).map(([t, i]) => card(t, i)).join(""); | |
| const rest = ranked.slice(3).map(([t, i]) => card(t, i)).join(""); | |
| inner += `<ul>${head}</ul>` + (rest ? `<details class="more"><summary class="small">Show ${ranked.length - 3} more</summary><ul>${rest}</ul></details>` : ""); | |
| } | |
| li.innerHTML = inner; | |
| steps.appendChild(li); | |
| } | |
| // Hovering a prep/prime task highlights its damage region (tasks are in travel order; match by centre). | |
| steps.querySelectorAll(".task").forEach((el) => { | |
| const step = (order.steps || []).find((s) => s.step === el.dataset.step); | |
| const task = step && step.tasks[+el.dataset.task]; | |
| const region = task && regionFor(task); | |
| el.addEventListener("mouseenter", () => highlight(region, true)); | |
| el.addEventListener("mouseleave", () => highlight(region, false)); | |
| }); | |
| const locked = !!job.approved; | |
| $("#replan").disabled = locked; | |
| $("#approve").disabled = locked || order.status === "blocked"; | |
| $("#approve").title = order.status === "blocked" ? "The safety gate blocks this order" : ""; | |
| $("#download").hidden = false; | |
| $("#download").href = `/api/jobs/${job.id}/work_order.json?download=1`; | |
| $("#approved").innerHTML = locked | |
| ? `Approved by <b>${esc(job.approved.by)}</b> at ${esc(new Date(job.approved.at).toLocaleString())}<br><span class="muted">registry ${esc(job.approved.registry_hash.slice(0, 16))}…</span>` | |
| : ""; | |
| document.querySelectorAll("[data-tool]").forEach((b) => (b.disabled = locked && b.dataset.tool !== "none")); | |
| $("#clear-edits").disabled = locked; | |
| } | |
| function regionFor(task) { | |
| const poly = JSON.stringify(task.zone_polygon_px || null); | |
| return (job.regions || []).findIndex((r) => JSON.stringify(r.prep_zone_xy || null) === poly); | |
| } | |
| function highlight(index, on) { | |
| if (index == null || index < 0) return; | |
| const el = document.querySelector(`#vector [data-region="${index}"]`); | |
| if (el) el.classList.toggle("hl", on); | |
| } | |
| function renderConfirmations() { | |
| const box = $("#confirmations"); | |
| box.innerHTML = ""; | |
| for (const [name, meaning] of Object.entries((health && health.confirmations) || {})) { | |
| const label = document.createElement("label"); | |
| label.innerHTML = `<input type="checkbox" value="${esc(name)}"><span>${esc(meaning)}</span>`; | |
| label.querySelector("input").addEventListener("change", () => setDirty(true)); | |
| box.appendChild(label); | |
| } | |
| } | |
| // ------------------------------------------------------------------ layers | |
| function applyLayerToggles() { | |
| const opacity = $("#opacity").value / 100; | |
| document.querySelectorAll("#layer-toggles input").forEach((box) => { | |
| const name = box.dataset.layer; | |
| document.querySelectorAll(`[data-layer="${name}"]:not(input)`).forEach((el) => { | |
| if (el instanceof SVGElement) el.style.display = box.checked ? "" : "none"; // .hidden is HTML-only | |
| else { el.classList.toggle("off", !box.checked); el.hidden = false; } // fade via CSS (.layer.off), not display:none | |
| // the slider sets a variable the stylesheet reads, not an inline opacity: an inline value would beat the Fill / Outline / Both rules | |
| if (el.tagName === "IMG") $("#stage").style.setProperty("--ov-opacity", String(opacity)); | |
| }); | |
| }); | |
| } | |
| document.querySelectorAll("#layer-toggles input").forEach((b) => b.addEventListener("change", applyLayerToggles)); | |
| $("#opacity").addEventListener("input", applyLayerToggles); | |
| // ------------------------------------------------------------------ brush | |
| document.querySelectorAll("[data-tool]").forEach((b) => b.addEventListener("click", () => { | |
| tool = b.dataset.tool; | |
| document.querySelectorAll("[data-tool]").forEach((x) => { | |
| x.classList.toggle("on", x === b); | |
| x.setAttribute("aria-pressed", String(x === b)); | |
| }); | |
| $("#stage").classList.toggle("drawing", tool !== "none"); | |
| if (tool !== "none") { | |
| const edits = document.querySelector('#layer-toggles input[data-layer="edits"]'); | |
| edits.checked = true; | |
| applyLayerToggles(); | |
| } | |
| })); | |
| function toImage(e) { | |
| const r = editCanvas.getBoundingClientRect(); | |
| return { x: (e.clientX - r.left) * (editCanvas.width / r.width), y: (e.clientY - r.top) * (editCanvas.height / r.height), scale: editCanvas.width / r.width }; | |
| } | |
| function dab(e) { | |
| if (!editCanvas.getBoundingClientRect().width || !$("#photo").complete) return; // photo not laid out yet | |
| const { x, y, scale } = toImage(e); | |
| const radius = ($("#brush").value / 2) * scale; | |
| ectx.globalCompositeOperation = tool === "erase" ? "destination-out" : "source-over"; | |
| ectx.fillStyle = tool === "add" ? "rgb(0,255,0)" : "rgb(255,0,0)"; | |
| ectx.beginPath(); | |
| ectx.arc(x, y, radius, 0, Math.PI * 2); | |
| ectx.fill(); | |
| setDirty(true); | |
| } | |
| function moveCursor(e) { | |
| const cursor = $("#cursor"); | |
| const stage = $("#stage").getBoundingClientRect(); | |
| cursor.hidden = tool === "none"; | |
| const size = $("#brush").value; | |
| cursor.style.width = cursor.style.height = `${size}px`; | |
| cursor.style.left = `${e.clientX - stage.left}px`; | |
| cursor.style.top = `${e.clientY - stage.top}px`; | |
| } | |
| editCanvas.addEventListener("pointerdown", (e) => { | |
| if (tool === "none" || (job && job.approved)) return; | |
| drawing = true; | |
| editCanvas.setPointerCapture(e.pointerId); | |
| dab(e); | |
| }); | |
| editCanvas.addEventListener("pointermove", (e) => { moveCursor(e); if (drawing) dab(e); }); | |
| editCanvas.addEventListener("pointerup", () => (drawing = false)); | |
| editCanvas.addEventListener("pointerleave", () => ($("#cursor").hidden = true)); | |
| $("#clear-edits").addEventListener("click", () => { ectx.clearRect(0, 0, editCanvas.width, editCanvas.height); setDirty(true); }); | |
| function setDirty(on) { | |
| dirty = on; | |
| $("#dirty").hidden = !on; | |
| } | |
| function editsPayload() { | |
| const data = ectx.getImageData(0, 0, editCanvas.width, editCanvas.height).data; | |
| for (let i = 3; i < data.length; i += 4) if (data[i]) return editCanvas.toDataURL("image/png"); | |
| return ""; | |
| } | |
| // ------------------------------------------------------------------ actions | |
| $("#replan").addEventListener("click", async () => { | |
| if (!job) return; | |
| const confirmations = [...document.querySelectorAll("#confirmations input:checked")].map((b) => b.value); | |
| const btn = $("#replan"); | |
| btn.disabled = true; | |
| btn.textContent = "Planning…"; | |
| try { | |
| showJob(await api(`/api/jobs/${job.id}/plan`, { | |
| method: "POST", headers: { "Content-Type": "application/json" }, | |
| body: JSON.stringify({ edits_png: editsPayload(), confirmations, operator: $("#operator").value.trim() }), | |
| })); | |
| } catch (err) { | |
| toast(err.message); | |
| } finally { | |
| btn.textContent = "Re-plan"; | |
| btn.disabled = !!(job && job.approved); | |
| } | |
| }); | |
| $("#approve").addEventListener("click", async () => { | |
| if (!job) return; | |
| if (dirty) { toast("Re-plan first: your edits or confirmations are not in this work order yet."); return; } | |
| const operator = $("#operator").value.trim(); | |
| if (!operator) { $("#operator").focus(); toast("Enter your name to approve."); return; } | |
| if (!confirm(`Approve this work order as ${operator}? It will be frozen and recorded.`)) return; | |
| try { | |
| showJob(await api(`/api/jobs/${job.id}/approve`, { | |
| method: "POST", headers: { "Content-Type": "application/json" }, | |
| body: JSON.stringify({ operator, note: $("#note").value }), | |
| })); | |
| } catch (err) { | |
| toast(err.message); | |
| } | |
| }); | |
| boot(); | |
| // ------------------------------------------------------------------ job drawings | |
| // A plan or elevation attached to the job: click two points on a known dimension to set the drawing's scale, measure the | |
| // wall (width or height), and use that length to scale the photo. Nothing is read automatically from the drawing. | |
| const dd = { dlg: $("#drawing-dialog"), img: $("#dd-img"), svg: $("#dd-svg"), list: $("#dd-list"), item: null, tool: "calibrate", pts: [] }; | |
| function parseLength(text) { | |
| const m = String(text || "").trim().toLowerCase().replace(/[’′]/g, "'").replace(/[”″]/g, '"') | |
| .match(/^(\d+(?:\.\d+)?)\s*(mm|cm|m|meters?|metres?|ft|feet|'|in|inch(?:es)?|")?(?:\s*(\d+(?:\.\d+)?)\s*(in|"|inch(?:es)?)?)?$/); | |
| if (!m) return null; | |
| const a = parseFloat(m[1]), u = m[2] || "m"; | |
| if (u === "mm") return a; | |
| if (u === "cm") return a * 10; | |
| if (u.startsWith("m")) return a * 1000; | |
| if (u === "ft" || u === "feet" || u === "'") return a * 304.8 + (m[3] ? parseFloat(m[3]) * 25.4 : 0); | |
| return a * 25.4; | |
| } | |
| function lengthText(mm) { | |
| const inches = mm / 25.4, ft = Math.floor(inches / 12), rem = inches - ft * 12; | |
| return `${(mm / 1000).toFixed(2)} m · ${ft}′ ${rem.toFixed(1)}″`; | |
| } | |
| async function refreshDrawings() { | |
| const list = $("#drawing-list"); | |
| $("#drawing-job").textContent = job ? "" : "· open a job first"; | |
| $("#gen-btn").disabled = !job; | |
| list.innerHTML = ""; | |
| if (!job) return; | |
| const items = await api(`/api/jobs/${job.id}/drawings`).catch(() => []); | |
| for (const d of items) { | |
| const li = document.createElement("li"), b = document.createElement("button"); | |
| b.className = "drawing-item"; | |
| b.innerHTML = `<img src="/api/jobs/${job.id}/drawings/${d.id}.png" alt=""><span><span class="name">${esc(d.filename)}</span><br> | |
| <span class="small muted">${d.calibration ? "scale set" : "needs scale"} · ${d.measurements.length} measurement(s)</span> | |
| ${d.generated ? `<span class="badge${d.provenance && d.provenance.scale_assumed ? " warn" : ""}">${d.provenance && d.provenance.scale_assumed ? "draft · assumed height" : "generated · draft"}</span>` : ""}</span>`; | |
| b.addEventListener("click", () => openDrawing(d)); | |
| li.appendChild(b); | |
| list.appendChild(li); | |
| } | |
| } | |
| $("#dfile").addEventListener("change", async (e) => { | |
| const file = e.target.files[0]; | |
| e.target.value = ""; | |
| if (!file) return; | |
| if (!job) { toast("Open or create a job first: a drawing belongs to one wall."); return; } | |
| try { | |
| const d = await api(`/api/jobs/${job.id}/drawings?filename=${encodeURIComponent(file.name)}`, { method: "POST", body: await file.arrayBuffer() }); | |
| await refreshDrawings(); | |
| openDrawing(d); | |
| } catch (err) { toast(err.message); } | |
| }); | |
| function openDrawing(item) { | |
| dd.item = item; dd.pts = []; dd.tool = item.calibration ? "measure" : "calibrate"; | |
| $("#dd-title").textContent = item.filename; | |
| dd.img.onload = () => { dd.svg.setAttribute("viewBox", `0 0 ${item.width} ${item.height}`); drawDrawing(); }; | |
| dd.img.src = `/api/jobs/${job.id}/drawings/${item.id}.png`; | |
| setDrawingTool(dd.tool); | |
| if (!dd.dlg.open) dd.dlg.showModal(); | |
| resetMatchPanel(item); | |
| renderProvenance(item); | |
| } | |
| function renderProvenance(item) { | |
| const box = $("#dd-prov"), dl = $("#dd-dl"); | |
| const p = item.generated && item.provenance; | |
| box.hidden = dl.hidden = !p; | |
| if (!p) return; | |
| box.className = `prov${p.scale_assumed ? " warn" : ""}`; | |
| const notes = (p.notes || []).map((n) => `<li>${esc(n)}</li>`).join(""); | |
| const SRC = { measured_height: "the wall height you entered", measured_width: "the wall width you entered", depth_scale: "the job's saved scale (mm per pixel)" }; | |
| const src = SRC[p.scale_source] || (String(p.scale_source).startsWith("assumed_ceiling_") ? `an assumed ceiling height of ${String(p.scale_source).replace("assumed_ceiling_", "").replace("ft", " ft")}` : p.scale_source); | |
| box.innerHTML = `<strong>Draft drawn from a photo.</strong> Scale from ${esc(src)}${p.scale_assumed ? " (assumed: check it)" : ""}. ${esc(p.disclaimer || "")}${notes ? `<ul>${notes}</ul>` : ""}`; | |
| const base = `/api/jobs/${job.id}/drawings/${item.id}`; | |
| dl.innerHTML = `<a class="ghost button small" href="${base}.svg" target="_blank" rel="noopener">View sheet</a>` | |
| + ["svg", "dxf", "json"].map((x) => `<a class="ghost button small" href="${base}.${x}?download=1">${x.toUpperCase()}</a>`).join(""); | |
| } | |
| $("#gen-btn").addEventListener("click", async () => { | |
| if (!job) { toast("Open or create a job first: a drawing is made from one wall's photo."); return; } | |
| const btn = $("#gen-btn"), raw = $("#gen-h").value.trim(); | |
| if (raw && !(Number(raw) >= 4 && Number(raw) <= 40)) { toast("Wall height should be between 4 and 40 ft (or leave it empty)."); return; } | |
| btn.disabled = true; btn.textContent = "Drawing…"; | |
| try { | |
| const d = await api(`/api/jobs/${job.id}/drawings/generate`, { method: "POST", headers: { "Content-Type": "application/json" }, | |
| body: JSON.stringify(raw ? { wall_height_ft: Number(raw) } : {}) }); | |
| await refreshDrawings(); | |
| toast(`Drew ${d.openings} opening${d.openings === 1 ? "" : "s"} on a ${(d.wall_mm[0] / 1000).toFixed(2)} × ${(d.wall_mm[1] / 1000).toFixed(2)} m wall.` | |
| + (d.provenance.scale_assumed ? " Height was assumed: enter the real height for true dimensions." : ""), d.provenance.scale_assumed ? "warn" : "ok"); | |
| openDrawing(d); | |
| } catch (e) { toast(e.message || e); } | |
| finally { btn.textContent = "Draw this wall to scale"; btn.disabled = !job; } | |
| }); | |
| function setDrawingTool(t) { | |
| dd.tool = t; dd.pts = []; | |
| document.querySelectorAll("[data-dtool]").forEach((b) => b.classList.toggle("on", b.dataset.dtool === t)); | |
| $("#dd-hint").textContent = t === "calibrate" | |
| ? "Click both ends of a dimension you know (a printed dimension string or a scale bar), then enter its length." | |
| : dd.item.calibration ? "Click both ends of the wall (or any line) to measure it." : "Set the scale first."; | |
| drawDrawing(); | |
| } | |
| document.querySelectorAll("[data-dtool]").forEach((b) => b.addEventListener("click", (e) => { e.preventDefault(); setDrawingTool(b.dataset.dtool); })); | |
| const pxLen = (a, b) => Math.hypot(b[0] - a[0], b[1] - a[1]); | |
| function svgLine(a, b, cls, label) { | |
| const k = dd.item.width / 900; | |
| return `<line x1="${a[0]}" y1="${a[1]}" x2="${b[0]}" y2="${b[1]}" class="${cls}" stroke-width="${3 * k}" stroke-linecap="round" ${cls === "cal" ? `stroke-dasharray="${10 * k} ${7 * k}"` : ""}/> | |
| <circle cx="${a[0]}" cy="${a[1]}" r="${5 * k}" class="${cls}"/><circle cx="${b[0]}" cy="${b[1]}" r="${5 * k}" class="${cls}"/> | |
| ${label ? `<text x="${(a[0] + b[0]) / 2}" y="${(a[1] + b[1]) / 2 - 10 * k}" font-size="${15 * k}" font-weight="700" text-anchor="middle" class="lbl" stroke-width="${4 * k}">${esc(label)}</text>` : ""}`; | |
| } | |
| function drawDrawing() { | |
| const it = dd.item; if (!it) return; | |
| const mm = it.calibration && it.calibration.mm_per_px; | |
| let out = ""; | |
| if (it.calibration && it.calibration.pts) out += svgLine(it.calibration.pts[0], it.calibration.pts[1], "cal", it.calibration.label || lengthText(it.calibration.length_mm)); | |
| it.measurements.forEach((m) => { if (m.pts) out += svgLine(m.pts[0], m.pts[1], "mea", mm ? lengthText(m.length_px * mm) : ""); }); | |
| if (dd.pts.length === 1) out += `<circle cx="${dd.pts[0][0]}" cy="${dd.pts[0][1]}" r="${6 * it.width / 900}" class="pend"/>`; | |
| dd.svg.innerHTML = out; | |
| $("#dd-scale").textContent = mm ? `Scale: ${fmt(mm, 2)} mm per drawing pixel` : "No scale yet"; | |
| dd.list.innerHTML = ""; | |
| it.measurements.forEach((m, i) => { | |
| const li = document.createElement("li"), len = mm ? m.length_px * mm : null; | |
| li.innerHTML = `<div class="len">${len ? lengthText(len) : "—"}</div><div class="muted small">${esc(m.label || "Line " + (i + 1))}</div> | |
| <div class="acts">${len ? `<button data-axis="width">Wall width</button><button data-axis="height">Wall height</button>` : ""}<button data-del="1">Delete</button></div>`; | |
| li.querySelectorAll("[data-axis]").forEach((b) => b.addEventListener("click", () => useAsScale(len, b.dataset.axis, m.label || "Line " + (i + 1)))); | |
| li.querySelector("[data-del]").addEventListener("click", async () => { | |
| it.measurements.splice(i, 1); | |
| await saveDrawing({ measurements: it.measurements }); | |
| }); | |
| dd.list.appendChild(li); | |
| }); | |
| } | |
| async function saveDrawing(patch) { | |
| const it = dd.item; | |
| const send = {}; | |
| if ("calibration" in patch) send.calibration = patch.calibration; | |
| if ("measurements" in patch) send.measurements = patch.measurements.map((m) => ({ id: m.id, length_px: m.length_px, label: m.label, pts: m.pts })); | |
| const saved = await api(`/api/jobs/${job.id}/drawings/${it.id}`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(send) }); | |
| Object.assign(it, saved); | |
| drawDrawing(); | |
| refreshDrawings(); | |
| } | |
| $("#dd-stage").addEventListener("click", async (e) => { | |
| const it = dd.item; if (!it) return; | |
| if (dd.tool === "measure" && !it.calibration) { $("#dd-hint").textContent = "Set the scale first (tool 1)."; return; } | |
| const r = dd.svg.getBoundingClientRect(); | |
| dd.pts.push([(e.clientX - r.left) / r.width * it.width, (e.clientY - r.top) / r.height * it.height]); | |
| drawDrawing(); | |
| if (dd.pts.length < 2) return; | |
| const [a, b] = dd.pts; dd.pts = []; | |
| const len = pxLen(a, b); | |
| if (len < 8) { drawDrawing(); return; } | |
| try { | |
| if (dd.tool === "calibrate") { | |
| const mm = parseLength(prompt("Real length of that line? e.g. 3.2 m, 10 ft, 10 ft 6 in, 2400 mm")); | |
| if (!mm) { drawDrawing(); return; } | |
| await saveDrawing({ calibration: { length_mm: mm, length_px: len, label: "known", pts: [a, b] } }); | |
| setDrawingTool("measure"); | |
| } else { | |
| it.measurements.push({ id: Math.random().toString(36).slice(2, 8), length_px: len, label: `Line ${it.measurements.length + 1}`, pts: [a, b] }); | |
| await saveDrawing({ measurements: it.measurements }); | |
| } | |
| } catch (err) { toast(err.message); drawDrawing(); } | |
| }); | |
| async function useAsScale(lengthMm, axis, label) { | |
| try { | |
| const s = await api(`/api/jobs/${job.id}/scale`, { method: "POST", headers: { "Content-Type": "application/json" }, | |
| body: JSON.stringify({ length_mm: lengthMm, axis, label }) }); | |
| dd.dlg.close(); | |
| $("#upload-status").textContent = `Photo scale set from the drawing: ${fmt(s.mm_per_px, 2)} mm/px. Re-planning…`; | |
| $("#replan").click(); | |
| } catch (err) { toast(err.message); } | |
| } | |
| // the drawing list follows the open job | |
| const _showJob = showJob; | |
| showJob = function (j) { _showJob(j); refreshDrawings(); }; | |
| refreshDrawings(); | |
| // ------------------------------------------------------------------ auto-match to the drawing, and the optional AI helper | |
| // Auto-match reads the drawing's windows and doors (needs the scale from tool 1) and finds this photo's wall on it. The scale is only | |
| // applied when the operator presses "Use this scale" AND the match is usable (several openings agree, no equally good alternative). | |
| // The AI helper is advice only: it is off unless the server has an API key, and nothing it says changes a plan, a gate or an approval. | |
| let lastMatch = null; | |
| let aiStatus = null; | |
| function resetMatchPanel(item) { | |
| lastMatch = item && item.auto_match ? item.auto_match : null; | |
| $("#dd-apply").hidden = true; | |
| renderMatch(); | |
| loadAiStatus(); | |
| } | |
| function renderMatch() { | |
| const out = $("#dd-matchout"); | |
| const m = lastMatch; | |
| if (!m) { out.innerHTML = ""; renderAi(); return; } | |
| const rows = []; | |
| if (!m.matched) rows.push(`<strong>No match.</strong> ${esc(m.reason || "")}`); | |
| else { | |
| rows.push(`<strong>${esc(m.confidence)} confidence</strong> · ${m.matched_openings.length} opening${m.matched_openings.length === 1 ? "" : "s"} agree`); | |
| if (m.usable_for_scale) rows.push(`Scale ≈ ${fmt(m.mm_per_px_at_centre, 2)} mm per photo pixel${m.applied ? " · <strong>applied</strong>" : ""}`); | |
| if (m.ambiguous) rows.push(`<span class="warn">Several placements fit equally well. Pick the sheet or add a photo that includes a distinguishing feature.</span>`); | |
| if (m.in_photo_not_in_drawing && m.in_photo_not_in_drawing.length) rows.push(`${m.in_photo_not_in_drawing.length} opening(s) in the photo are not on the drawing`); | |
| if (m.in_drawing_not_in_photo && m.in_drawing_not_in_photo.length) rows.push(`${m.in_drawing_not_in_photo.length} drawn opening(s) are not in the photo`); | |
| if (m.note && !m.ambiguous) rows.push(esc(m.note)); | |
| } | |
| out.innerHTML = rows.map((r) => `<div>${r}</div>`).join(""); | |
| $("#dd-apply").hidden = !(m.matched && m.usable_for_scale && !m.applied); | |
| renderAi(); | |
| } | |
| $("#dd-match").addEventListener("click", async () => { | |
| const btn = $("#dd-match"); | |
| btn.disabled = true; | |
| $("#dd-matchout").textContent = "Matching…"; | |
| try { | |
| const res = await api(`/api/jobs/${job.id}/drawings/${dd.item.id}/match`, { method: "POST", headers: { "Content-Type": "application/json" }, body: "{}" }); | |
| lastMatch = dd.item.auto_match = res.match; | |
| renderMatch(); | |
| } catch (e) { | |
| lastMatch = null; | |
| $("#dd-matchout").innerHTML = `<span class="warn">${esc(e.message || e)}</span>`; | |
| renderAi(); | |
| } finally { btn.disabled = false; } | |
| }); | |
| $("#dd-apply").addEventListener("click", async () => { | |
| try { | |
| const res = await api(`/api/jobs/${job.id}/drawings/${dd.item.id}/match`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ apply: true }) }); | |
| lastMatch = dd.item.auto_match = res.match; | |
| setDirty(true); // the scale reaches the work order at the next Re-plan | |
| loadEvidence(); | |
| renderMatch(); | |
| } catch (e) { $("#dd-matchout").innerHTML = `<span class="warn">${esc(e.message || e)}</span>`; } | |
| }); | |
| async function loadAiStatus() { | |
| try { aiStatus = await api("/api/assist/status"); } catch { aiStatus = { enabled: false, reason: "The AI helper is unavailable." }; } | |
| renderAi(); | |
| } | |
| function renderAi() { | |
| const on = !!(aiStatus && aiStatus.enabled); | |
| $("#dd-q").hidden = !on; | |
| $("#dd-ai").disabled = !(on && lastMatch); | |
| $("#dd-aiout").classList.remove("answer"); | |
| if (!aiStatus) return; | |
| $("#dd-aiout").textContent = !on ? `AI helper off: ${aiStatus.reason}` | |
| : !lastMatch ? "Run Match to photo first. The AI explains a match and suggests what to check next." | |
| : "Sends a short summary of this match (counts and confidence only: no photo, no file names) and your question to the AI provider. Advice only: it cannot approve or change anything."; | |
| } | |
| $("#dd-ai").addEventListener("click", async () => { | |
| const btn = $("#dd-ai"); | |
| btn.disabled = true; | |
| $("#dd-aiout").textContent = "Asking…"; | |
| try { | |
| const res = await api("/api/assist", { method: "POST", headers: { "Content-Type": "application/json" }, | |
| body: JSON.stringify({ context: lastMatch, question: $("#dd-q").value.trim() }) }); | |
| const out = $("#dd-aiout"); | |
| out.classList.add("answer"); | |
| out.textContent = res.ok ? res.answer : (res.error || "No answer."); | |
| if (res.ok) out.insertAdjacentHTML("beforeend", `<div class="muted small">AI advice only · it cannot approve or change anything</div>`); | |
| } catch (e) { $("#dd-aiout").textContent = e.message || String(e); } | |
| finally { renderAiButton(); } | |
| }); | |
| function renderAiButton() { $("#dd-ai").disabled = !(aiStatus && aiStatus.enabled && lastMatch); } | |
| // ------------------------------------------------------------------ overlay style: fill / both / outline | |
| function setOverlayStyle(mode) { | |
| try { localStorage.setItem("pv-overlay", mode); } catch { /* private mode: the choice just is not remembered */ } | |
| $("#stage").dataset.ov = mode; | |
| document.querySelectorAll("[data-ov]").forEach((b) => { | |
| if (b.tagName !== "BUTTON") return; | |
| const on = b.dataset.ov === mode; | |
| b.classList.toggle("on", on); | |
| b.setAttribute("aria-pressed", on ? "true" : "false"); | |
| }); | |
| } | |
| document.querySelectorAll("button[data-ov]").forEach((b) => b.addEventListener("click", () => setOverlayStyle(b.dataset.ov))); | |
| setOverlayStyle((() => { try { return localStorage.getItem("pv-overlay") || "both"; } catch { return "both"; } })()); | |
| // ------------------------------------------------------------------ evidence confidence: the more independent evidence, the higher the score | |
| // The number is an evidence score (evidence.py), not a probability, and the card says so. It is capped while the scale is only an assumption. | |
| const EV_COLOURS = ["#0a84ff", "#34c759", "#af52de", "#ff9f0a", "#64d2ff"]; | |
| let evShown = 0, evAnim = 0; | |
| const EV_SUMMARY = { rough: "Not enough to trust the measurements yet.", fair: "Good enough for a rough estimate. Check key sizes by hand.", good: "Measurements are well supported for planning.", high: "Measurements are strongly supported." }; | |
| const EV_PART = { | |
| "Scale anchor": { name: "A known size", hint: "Something real in the photo that fixes the scale: a drawing, a door, a tape measure." }, | |
| "Wall coverage": { name: "Whole wall in view", hint: "How much of the wall's edges you can see in the photos." }, | |
| "Independent views": { name: "Other angles", hint: "Extra photos or video of the same wall." }, | |
| "Drawings": { name: "Drawing match", hint: "A plan or elevation that agrees with the photo." }, | |
| "Depth plane check": { name: "Depth scan", hint: "A LiDAR or depth capture that confirms the wall is flat." }, | |
| }; | |
| function countTo(el, target) { | |
| cancelAnimationFrame(evAnim); | |
| const reduce = window.matchMedia && window.matchMedia("(prefers-reduced-motion: reduce)").matches; | |
| if (reduce) { el.textContent = `${target}%`; evShown = target; return; } | |
| const from = evShown, t0 = performance.now(); | |
| const step = (ts) => { | |
| const k = Math.min(1, (ts - t0) / 650), v = Math.round(from + (target - from) * (1 - Math.pow(1 - k, 3))); | |
| el.textContent = `${v}%`; | |
| if (k < 1) evAnim = requestAnimationFrame(step); else evShown = target; | |
| }; | |
| evAnim = requestAnimationFrame(step); | |
| } | |
| function renderEvidence(ev) { | |
| const box = $("#evidence"); | |
| if (!ev) { box.hidden = true; return; } | |
| box.hidden = false; | |
| box.dataset.level = ev.label.toLowerCase(); | |
| $("#ev-label").textContent = ev.label; | |
| $("#ev-sum").textContent = EV_SUMMARY[ev.label.toLowerCase()] || ""; | |
| countTo($("#ev-pct"), ev.score); | |
| const bar = $("#ev-bar"); | |
| bar.innerHTML = ""; | |
| ev.parts.forEach((p, i) => { | |
| const seg = document.createElement("span"); | |
| seg.className = "ev-seg"; seg.style.flexGrow = String(p.max); seg.title = `${p.name}: ${p.points} of ${p.max}`; | |
| const fill = document.createElement("i"); | |
| fill.style.background = EV_COLOURS[i % EV_COLOURS.length]; fill.style.width = "0%"; | |
| seg.appendChild(fill); bar.appendChild(seg); | |
| requestAnimationFrame(() => requestAnimationFrame(() => { fill.style.width = `${Math.round(100 * p.points / p.max)}%`; })); | |
| }); | |
| bar.setAttribute("aria-label", `Evidence score ${ev.score} out of 100`); | |
| const errEl = $("#ev-error"); | |
| errEl.textContent = ""; | |
| const typ = Number(ev.typical_error_pct), hi = Number(ev.high_error_pct); | |
| if (Number.isFinite(typ) && typ > 0) { | |
| const head = document.createElement("strong"); | |
| head.textContent = `Sizes could be off by about ${Math.round(typ)}%` + (Number.isFinite(hi) && hi > typ ? ` (worst case ${Math.round(hi)}%)` : ""); | |
| const why = document.createElement("span"); | |
| why.textContent = ` Why: ${String(ev.expected_error || "").replace(/^\W+/, "").replace(/\.$/, "")}.`; | |
| errEl.append(head, why); | |
| } else errEl.textContent = `Expected size of the error: ${ev.expected_error}.`; | |
| const list = $("#ev-parts"); | |
| list.textContent = ""; | |
| ev.parts.forEach((p, i) => { // built with DOM calls: the page's CSP forbids inline style attributes | |
| const info = EV_PART[p.name] || { name: p.name, hint: "" }; | |
| const frac = p.max ? p.points / p.max : 0, state = frac >= 0.85 ? "full" : frac > 0.05 ? "part" : "none"; | |
| const li = document.createElement("li"), dot = document.createElement("i"), txt = document.createElement("div"), name = document.createElement("span"), hint = document.createElement("small"); | |
| const pts = document.createElement("b"), meter = document.createElement("div"), fill = document.createElement("i"); | |
| li.dataset.state = state; dot.className = "ev-state"; dot.setAttribute("aria-hidden", "true"); | |
| dot.textContent = state === "full" ? "✓" : state === "part" ? "◐" : "○"; | |
| name.textContent = info.name; hint.textContent = info.hint; txt.className = "ev-txt"; txt.append(name, hint); | |
| pts.textContent = `${Math.round(p.points)} of ${p.max}`; meter.className = "ev-meter"; fill.style.width = `${Math.round(100 * frac)}%`; fill.style.background = EV_COLOURS[i % EV_COLOURS.length]; | |
| meter.appendChild(fill); li.title = `${p.name}: ${p.points} of ${p.max} points`; | |
| li.append(dot, txt, pts, meter); list.appendChild(li); | |
| }); | |
| const notes = []; | |
| if (ev.conflict) notes.push(`<strong>Conflict (−${ev.penalty}):</strong> ${esc(ev.conflict)}`); | |
| if (ev.cap) notes.push(`<strong>Capped:</strong> ${esc(ev.cap)}`); | |
| const bad = (ev.views || []).filter((v) => !v.registered); | |
| if (bad.length) notes.push(`${bad.length} extra view${bad.length === 1 ? "" : "s"} did not register to this wall and ${bad.length === 1 ? "is" : "are"} not counted: ${esc(bad[0].reason || "")}`); | |
| if (ev.depth && ev.depth.warnings && ev.depth.warnings.length) notes.push(esc(ev.depth.warnings[0])); | |
| $("#ev-note").hidden = !notes.length; | |
| $("#ev-note").innerHTML = notes.map((n) => `<div>${n}</div>`).join(""); | |
| $("#ev-next").innerHTML = ev.next.length ? `<div class="small muted">Do this next to raise it</div>` + ev.next.map((n, i) => | |
| `<button class="ev-idea" data-i="${i}"><b>+${n.gain}</b><span>${esc(n.do)}</span><em>→ ${n.to}%</em></button>`).join("") : `<div class="small muted">Nothing left to add: more evidence would not change this score.</div>`; | |
| $("#ev-next").querySelectorAll(".ev-idea").forEach((b) => b.addEventListener("click", () => doIdea(ev.next[Number(b.dataset.i)].do))); | |
| $("#ev-disc").textContent = ev.disclaimer; | |
| } | |
| function doIdea(text) { | |
| const t = text.toLowerCase(); | |
| if (/depth plane|depth \/ lidar|lidar/.test(t)) $("#ev-depth-file").click(); | |
| else if (/height/.test(t)) $("#ev-height").focus(); | |
| else if (/drawing/.test(t)) $("#dfile").click(); | |
| else $("#ev-view-file").click(); | |
| } | |
| async function loadEvidence() { | |
| if (!job) { renderEvidence(null); return; } | |
| const id = job.id; | |
| try { const ev = await api(`/api/jobs/${id}/evidence`); if (job && job.id === id) renderEvidence(ev); } catch { renderEvidence(null); } | |
| } | |
| $("#ev-view-file").addEventListener("change", async (e) => { | |
| const file = e.target.files[0]; e.target.value = ""; | |
| if (!file || !job) return; | |
| toast("Checking the new view against this wall…", "ok"); | |
| try { | |
| const r = await api(`/api/jobs/${job.id}/views?filename=${encodeURIComponent(file.name)}`, { method: "POST", body: await file.arrayBuffer() }); | |
| const bad = r.added.filter((a) => !a.registered); | |
| toast(`${r.registered} of ${r.tried} registered to this wall` + (bad.length ? `; ${bad.length} did not (${bad[0].reason}).` : "."), r.registered ? "ok" : "warn"); | |
| renderEvidence(r.evidence); | |
| } catch (err) { toast(err.message); } | |
| }); | |
| $("#ev-depth-file").addEventListener("change", async (e) => { | |
| const file = e.target.files[0]; e.target.value = ""; | |
| if (!file || !job) return; | |
| const q = new URLSearchParams({ filename: file.name }); | |
| if ($("#ev-fx").value.trim()) q.set("fx", $("#ev-fx").value.trim()); | |
| if ($("#ev-hfov").value.trim()) q.set("hfov_deg", $("#ev-hfov").value.trim()); | |
| try { | |
| const r = await api(`/api/jobs/${job.id}/depth?${q}`, { method: "POST", body: await file.arrayBuffer() }); | |
| const rep = r.report; | |
| toast(rep.plane_ok ? `Depth scan used: wall plane agrees (${Math.round(100 * rep.wall_fraction_on_plane)}% of the wall), scale ${rep.mm_per_px} mm/px${rep.intrinsics_source === "assumed" ? " (focal length assumed)" : ""}. Re-plan to use it.` | |
| : `Depth scan checked but not used: ${(rep.warnings && rep.warnings[0]) || "the wall plane does not agree with the photo"}`, rep.plane_ok ? "ok" : "warn"); | |
| renderEvidence(r.evidence); | |
| if (rep.plane_ok) setDirty(true); | |
| } catch (err) { toast(err.message); } | |
| }); | |
| $("#ev-height-set").addEventListener("click", async () => { | |
| const ft = Number($("#ev-height").value); | |
| if (!job) { toast("Open or create a job first."); return; } | |
| if (!(ft >= 4 && ft <= 40)) { toast("Enter the wall's real floor-to-ceiling height in feet (4 to 40)."); return; } | |
| try { | |
| const r = await api(`/api/jobs/${job.id}/scale`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ length_mm: ft * 304.8, axis: "height", source: "operator" }) }); | |
| toast(`Scale set from your measured height: ${(r.mm_per_px).toFixed(2)} mm/px. Re-plan to use it.`, "ok"); | |
| renderEvidence(r.evidence); setDirty(true); | |
| } catch (err) { toast(err.message); } | |
| }); | |
| // the evidence follows the open job and refreshes after anything that changes it | |
| const _showJobEv = showJob; | |
| showJob = function (j) { _showJobEv(j); loadEvidence(); }; | |
| if (job) loadEvidence(); | |