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/robot.js from constructelligence/painting-vision-robotics-kit: direct link, hf CLI and curl.
- Browser
- Download file 68.9 kB
-
https://huggingface.co/constructelligence/painting-vision-robotics-kit/resolve/main/console/robot.js
- Command line
-
hf download hf://constructelligence/painting-vision-robotics-kit/console/robot.js
-
curl -L -o robot.js https://huggingface.co/constructelligence/painting-vision-robotics-kit/resolve/main/console/robot.js
68.9 kB
| // Animated painting robot: replays the job's planned work order over the photo. | |
| // | |
| // It animates what the planner actually produced (job.work_order): sanding/scraping on the prep regions, spot priming, then the roller | |
| // strokes in planned order and the trim strokes, leaving the paint it laid down. It is a visualisation of the plan, not a simulation of | |
| // a machine: the robot is a generic mast-and-arm rig, its drive and reach are plausible motion, and nothing it shows is measured, | |
| // approved or sent anywhere. A blocked or unplanned job has no strokes, so there is nothing to play and the button says why. | |
| // | |
| // What makes it read as real (all of it deterministic, so a replay or a scrub always looks the same): | |
| // * a two-link arm solved by inverse kinematics from a mast carriage that lags the roller, so the elbow bends and straightens as it reaches; | |
| // * the drive base keeps the roller inside its reach and rolls (wheel spin follows the distance driven); | |
| // * the roller is oriented the way a real one is: its axis is perpendicular to the stroke and its length IS the stripe it paints; | |
| // * the roller picks up paint at a tray (reload trips), and the paint it lays thins as the roller runs dry; | |
| // * fresh paint is wet (a sheen that dries to matt in ~2 s), has a faint nap texture, and now and then a drip runs from a stroke end; | |
| // * sanding raises dust that drifts down; arm, mast and roller cast a soft shadow on the wall. | |
| // | |
| // Two machines share one timeline: the ground robot above, and a tethered spray drone (like the hose-fed facade-washing drones): a quad with a boom | |
| // nozzle, fed by a hose from a ground pump cart, so it never reloads. The drone is simulated as a spring-damper chasing the nozzle target with a | |
| // deterministic wind sway and roll, lays a spray fan (soft overspray halo, dense core, speckle) instead of a roller stripe, and the tank on the cart | |
| // empties as the job progresses. Still an illustration of the plan, not a flight simulation. | |
| // | |
| // Public surface (window.PVRobot, also used by the tests): buildTimeline(job), seek(t), play(), pause(), pose(), state(), setRig("ground"|"drone"). | |
| (() => { | |
| "use strict"; | |
| const $ = (s) => document.querySelector(s); | |
| const REDUCED = window.matchMedia && window.matchMedia("(prefers-reduced-motion: reduce)").matches; | |
| const PHASE_STYLE = { | |
| prep: { label: "Prep: sanding and scraping", tint: "#d9a066", width: 0.55, alpha: 0.5 }, | |
| prime: { label: "Spot priming", tint: "#e8e4dc", width: 0.7, alpha: 0.85 }, | |
| paint: { label: "Rolling the wall", tint: null, width: 1, alpha: 0.84 }, | |
| trim: { label: "Cutting in the edges", tint: null, width: 0.45, alpha: 0.9 }, | |
| touch: { label: "Touch-up", tint: null, width: 0.8, alpha: 0.9 }, | |
| }; | |
| const DRONE_LABEL = { prep: "Prep: soft-washing the damage", prime: "Spot priming", paint: "Spraying the wall", trim: "Detail spray along the edges", touch: "Touch-up spray" }; | |
| const els = {}; | |
| let timeline = null; | |
| let t = 0, speed = 1, playing = false, raf = 0, lastTs = 0; | |
| let drawn = 0; | |
| let paintLayer = null, pctx = null, wetLayer = null, wctx = null, napPattern = null, mottlePattern = null; | |
| let rig = null, maskLayer = null, rollLayer = null, rctx = null, preLayer = null, qctx = null, tmpLayer = null, maskInfo = null; | |
| const RIG_DT = 1 / 30; | |
| let particles = [], lastPose = null, rigKind = "ground"; | |
| const getJob = () => (typeof job !== "undefined" ? job : null); // app.js declares `job` with let: a global binding, not window.job | |
| const dist = (a, b) => Math.hypot(b[0] - a[0], b[1] - a[1]); | |
| const clamp = (v, a, b) => Math.max(a, Math.min(b, v)); | |
| const lerp = (a, b, k) => a + (b - a) * k; | |
| const rng = (seed) => () => { seed |= 0; seed = (seed + 0x6D2B79F5) | 0; let r = Math.imul(seed ^ (seed >>> 15), 1 | seed); r = (r + Math.imul(r ^ (r >>> 7), 61 | r)) ^ r; return ((r ^ (r >>> 14)) >>> 0) / 4294967296; }; | |
| // ---------------------------------------------------------------------- timeline from the work order | |
| function segmentsOf(strokes) { | |
| return (strokes || []).filter((s) => Array.isArray(s) && s.length === 2 && s.every((p) => Array.isArray(p) && p.length === 2)) | |
| .map(([a, b]) => ({ kind: "seg", x0: a[0], y0: a[1], x1: b[0], y1: b[1], len: dist(a, b) })); | |
| } | |
| function reasonNoPlan(wo) { | |
| if (wo.status === "blocked") return "This job is blocked, so there is no paint plan to show. Resolve the reasons listed on the right first."; | |
| if (!(wo.steps || []).some((s) => s.step === "paint")) return "There is no paint step in this work order yet."; | |
| return "The plan has no roller strokes to animate."; | |
| } | |
| function buildTimeline(j, totalSeconds = 18, opts = {}) { | |
| const wo = (j && j.work_order) || {}; | |
| const W = (j && j.width) || 800, H = (j && j.height) || 600, u = Math.max(W, H) / 900; | |
| const raw = []; | |
| const widthPx = (step) => Math.max(6, Number(step.plan && step.plan.plan && step.plan.plan.stroke_width_units) || 0.04 * W); | |
| for (const step of wo.steps || []) { | |
| if (step.step === "prep") raw.push({ kind: "prep", segs: (step.tasks || []).flatMap((x) => segmentsOf(x.strokes_px)) }); | |
| else if (step.step === "spot_prime") raw.push({ kind: "prime", segs: (step.tasks || []).flatMap((x) => segmentsOf(x.strokes_px)) }); | |
| else if (step.step === "paint" && step.plan && step.plan.plan) { | |
| raw.push({ kind: "paint", segs: segmentsOf(step.plan.plan.strokes), widthPx: widthPx(step) }); | |
| raw.push({ kind: "trim", segs: segmentsOf((step.plan.plan.trim || {}).strokes), widthPx: widthPx(step) }); | |
| } else if (step.step === "touch_up") raw.push({ kind: "touch", segs: (step.tasks || []).flatMap((x) => segmentsOf(x.strokes_px)) }); | |
| } | |
| const phases = raw.filter((p) => p.segs.length); | |
| if (!phases.some((p) => p.kind === "paint")) return { phases: [], items: [], total: 0, reloads: 0, reason: reasonNoPlan(wo) }; | |
| const tray = { x: 0.115 * W, y: H - 46 * u }; // a paint tray standing on the floor at the left of the picture | |
| let reloads = 0, cursor = null; | |
| const items = []; | |
| const rand = rng(1234), toneRand = rng(555); | |
| let segIdx = 0; | |
| for (const p of phases) { | |
| const rollerKind = p.kind === "paint" || p.kind === "trim" || p.kind === "touch"; | |
| const every = opts.drone ? 1e9 : p.kind === "paint" ? Math.max(5, Math.ceil(p.segs.length / 5)) : p.kind === "trim" ? Math.max(14, Math.ceil(p.segs.length / 3)) : 1e9; | |
| p.track = []; | |
| p.width = (p.widthPx || Math.max(8, 0.022 * W)) * PHASE_STYLE[p.kind].width; | |
| let sinceLoad = 0; | |
| const addMove = (from, to, kind) => { const d = dist(from, to); if (d > 2) p.track.push({ kind, x0: from[0], y0: from[1], x1: to[0], y1: to[1], len: d, w: kind === "reload" ? 0.45 : 0.4 }); }; | |
| p.segs.forEach((s) => { | |
| if (rollerKind && sinceLoad >= every) { // run dry: go to the tray, dip, come back | |
| if (cursor) addMove(cursor, [tray.x, tray.y], "reload"); | |
| p.track.push({ kind: "dip", x0: tray.x, y0: tray.y, x1: tray.x, y1: tray.y, len: 0, dip: true }); | |
| cursor = [tray.x, tray.y]; sinceLoad = 0; reloads++; | |
| } | |
| if (cursor) addMove(cursor, [s.x0, s.y0], "move"); | |
| s.load = rollerKind && !opts.drone ? 1 - 0.38 * (sinceLoad / Math.max(every, 1)) : 1; | |
| s.tone = 0.9 + 0.1 * toneRand(); s.idx = segIdx++; // per-stroke tone, so overlaps and laps show | |
| // seeded, rare drips off the end of a heavily-loaded horizontal stroke | |
| if (!opts.drone && p.kind === "paint" && Math.abs(s.x1 - s.x0) > Math.abs(s.y1 - s.y0) && s.load > 0.92 && rand() < 0.09) | |
| s.drip = { x: lerp(s.x0, s.x1, 0.8 + 0.2 * rand()), y: s.y0 + p.width / 2, len: (16 + 24 * rand()) * u }; | |
| p.track.push(s); | |
| cursor = [s.x1, s.y1]; | |
| sinceLoad++; | |
| }); | |
| p.track.forEach((x) => { x.phase = p; }); | |
| items.push(...p.track); | |
| } | |
| // time: strokes by length; transits are quicker; a dip takes a fixed beat; prep passes are lighter | |
| const strokeLen = items.filter((x) => x.kind === "seg").reduce((a, x) => a + x.len, 0) || 1; | |
| const dipW = 0.045 * strokeLen; | |
| const weight = items.map((x) => (x.kind === "seg" ? x.len * (x.phase.kind === "prep" ? 0.6 : 1) : x.dip ? dipW : x.len * x.w)); | |
| const gap = 0.55; | |
| const sum = weight.reduce((a, b) => a + b, 0); | |
| const budget = totalSeconds - gap * (phases.length - 1); | |
| let clock = 0, phaseOf = null; | |
| items.forEach((x, i) => { | |
| if (phaseOf && x.phase !== phaseOf) clock += gap; | |
| phaseOf = x.phase; | |
| x.t0 = clock; clock += budget * (weight[i] / sum); x.t1 = clock; | |
| }); | |
| phases.forEach((p) => { p.segs = p.track.filter((x) => x.kind === "seg"); p.t0 = p.track[0].t0; p.t1 = p.track[p.track.length - 1].t1; p.label = opts.drone ? DRONE_LABEL[p.kind] : PHASE_STYLE[p.kind].label; }); | |
| return { phases, items, total: clock, reloads, tray, W, drone: !!opts.drone }; | |
| } | |
| // ---------------------------------------------------------------------- paint left behind (matt layer + wet sheen layer) | |
| function paintColour() { | |
| const c = (getJob() && getJob().paint_color) || {}; | |
| const ref = c.reference; // only a TARGET colour the job names; the wall's own detected colour would repaint it invisibly | |
| const rgb = ref && (ref.rgb || ref.srgb); | |
| return Array.isArray(rgb) ? [rgb[0] | 0, rgb[1] | 0, rgb[2] | 0] : [70, 150, 255]; | |
| } | |
| function makeNap() { | |
| const c = document.createElement("canvas"); c.width = c.height = 96; | |
| const x = c.getContext("2d"), r = rng(77), img = x.createImageData(96, 96); | |
| for (let i = 0; i < img.data.length; i += 4) { const v = 120 + (r() * 90) | 0; img.data[i] = img.data[i + 1] = img.data[i + 2] = v; img.data[i + 3] = 255; } | |
| x.putImageData(img, 0, 0); | |
| return c; | |
| } | |
| function makeMottle() { // low-frequency blotches: uneven film thickness | |
| const c = document.createElement("canvas"); c.width = c.height = 192; | |
| const x = c.getContext("2d"), r = rng(31); | |
| x.fillStyle = "#b4b4b4"; x.fillRect(0, 0, 192, 192); | |
| for (let i = 0; i < 160; i++) { | |
| const cx = r() * 192, cy = r() * 192, rad = 8 + r() * 26, v = 90 + (r() * 140) | 0; | |
| for (const ox of [-192, 0, 192]) for (const oy of [-192, 0, 192]) { | |
| const g = x.createRadialGradient(cx + ox, cy + oy, 0, cx + ox, cy + oy, rad); g.addColorStop(0, `rgba(${v},${v},${v},.55)`); g.addColorStop(1, `rgba(${v},${v},${v},0)`); | |
| x.fillStyle = g; x.fillRect(cx + ox - rad, cy + oy - rad, rad * 2, rad * 2); | |
| } | |
| } | |
| return c; | |
| } | |
| function resetLayers() { | |
| const j = getJob(); | |
| for (const k of ["paint", "wet"]) { | |
| const c = document.createElement("canvas"); c.width = j.width; c.height = j.height; | |
| const x = c.getContext("2d"); x.lineCap = "round"; x.lineJoin = "round"; | |
| if (k === "paint") { paintLayer = c; pctx = x; } else { wetLayer = c; wctx = x; } | |
| } | |
| napPattern = pctx.createPattern(makeNap(), "repeat"); | |
| mottlePattern = pctx.createPattern(makeMottle(), "repeat"); | |
| rollLayer = document.createElement("canvas"); rollLayer.width = j.width; rollLayer.height = j.height; | |
| rctx = rollLayer.getContext("2d"); rctx.lineCap = "round"; rctx.lineJoin = "round"; | |
| preLayer = document.createElement("canvas"); preLayer.width = j.width; preLayer.height = j.height; | |
| qctx = preLayer.getContext("2d"); qctx.lineCap = "round"; qctx.lineJoin = "round"; | |
| tmpLayer = document.createElement("canvas"); tmpLayer.width = j.width; tmpLayer.height = j.height; | |
| drawn = 0; particles = []; | |
| } | |
| // Rolled wall paint goes on its own layer so it can be clipped to where the plan says paint may go (a roller's round ends and the planner's stroke | |
| // width would otherwise paint over windows and keep-out areas); prep/prime sit under it; trim and touch-up sit over it and are not clipped (trim runs along the edges). | |
| const ctxOf = (s) => (s.phase.kind === "paint" ? rctx : s.phase.kind === "prep" || s.phase.kind === "prime" ? qctx : pctx); | |
| function buildMask(j) { | |
| const c = document.createElement("canvas"); c.width = j.width; c.height = j.height; | |
| const x = c.getContext("2d"); | |
| const layer = (name) => document.querySelector(`#stage img.layer[data-layer="${name}"]:not(.edge)`); | |
| const grab = (img) => { | |
| if (!img || !img.complete || !img.naturalWidth) return null; | |
| const t = document.createElement("canvas"); t.width = j.width; t.height = j.height; | |
| const tx = t.getContext("2d"); tx.drawImage(img, 0, 0, j.width, j.height); | |
| return tx.getImageData(0, 0, j.width, j.height).data; | |
| }; | |
| const paint = grab(layer("paint")), keep = grab(layer("keepout")); | |
| if (!paint) return null; // no paint layer to clip to: paint unclipped rather than hide everything | |
| const out = x.createImageData(j.width, j.height), d = out.data; | |
| let allowed = 0; | |
| for (let i = 0; i < d.length; i += 4) { | |
| const ok = paint[i + 3] > 0 && !(keep && keep[i + 3] > 0); | |
| d[i + 3] = ok ? 255 : 0; if (ok) allowed++; | |
| } | |
| x.putImageData(out, 0, 0); | |
| maskInfo = { allowed_px: allowed, total_px: j.width * j.height }; | |
| return c; | |
| } | |
| // One stretch of a stroke with hard (butt) ends, so consecutive slices abut without a darker bead where translucent round caps would overlap. A round | |
| // end cap is added only at the true start or end of the stroke, as a half disc facing outward so it never doubles up on the body. | |
| function seg(c, ax, ay, bx, by, w, capStart, capEnd) { | |
| const dx = bx - ax, dy = by - ay, m = Math.hypot(dx, dy), th = Math.atan2(dy, dx); | |
| c.lineCap = "butt"; c.lineWidth = w; | |
| if (m > 1e-6) { const ux = dx / m, uy = dy / m, e = capStart ? 0 : 0.6; c.beginPath(); c.moveTo(ax - ux * e, ay - uy * e); c.lineTo(bx, by); c.stroke(); } | |
| if (capStart || capEnd) { | |
| c.fillStyle = c.strokeStyle; | |
| if (m <= 1e-6) { c.beginPath(); c.arc(ax, ay, w / 2, 0, Math.PI * 2); c.fill(); return; } | |
| if (capStart) { c.beginPath(); c.arc(ax, ay, w / 2, th + Math.PI / 2, th + 1.5 * Math.PI); c.fill(); } | |
| if (capEnd) { c.beginPath(); c.arc(bx, by, w / 2, th - Math.PI / 2, th + Math.PI / 2); c.fill(); } | |
| } | |
| } | |
| // Split [a,b] (fractions of a stroke) into pieces whose edges do not depend on how the time slices fall: fine cells near each end, where a roller | |
| // or fan tails off, and one piece between. fn(p0, p1, taper) gets the fractions and an ink multiplier from 0.55 at the very end to 1 inside. | |
| function pieces(len, a, b, u, fn) { | |
| const tail = Math.min(0.07 * len, 30 * u), step = 3.5 * u, cuts = [0]; | |
| if (tail > step * 2) { for (let d = step; d < tail; d += step) cuts.push(d / len); cuts.push(tail / len, 1 - tail / len); for (let d = tail - step; d > 0; d -= step) cuts.push(1 - d / len); } | |
| cuts.push(1); | |
| for (let k = 0; k + 1 < cuts.length; k++) { | |
| const p0 = Math.max(cuts[k], a), p1 = Math.min(cuts[k + 1], b); | |
| if (p1 <= p0 + 1e-9) continue; | |
| const pm = (cuts[k] + cuts[k + 1]) / 2 * len, e = tail > 0 ? Math.min(pm / tail, (len - pm) / tail, 1) : 1, sm = e * e * (3 - 2 * e); | |
| fn(p0, p1, 0.55 + 0.45 * sm); | |
| } | |
| } | |
| function bake(from, to) { | |
| const rgb = paintColour(); | |
| const col = (a) => `rgba(${rgb[0]},${rgb[1]},${rgb[2]},${a})`; | |
| const u = Math.max(timeline.W || 800, 1) / 900; | |
| for (const s of timeline.items) { | |
| if (s.kind !== "seg" || s.t1 <= from || s.t0 >= to) continue; | |
| const st = PHASE_STYLE[s.phase.kind]; | |
| const pctx = ctxOf(s); | |
| const span = Math.max(s.t1 - s.t0, 1e-9); | |
| const a = clamp((from - s.t0) / span, 0, 1), b = clamp((to - s.t0) / span, 0, 1); | |
| const w = s.phase.width, kind = s.phase.kind, len = Math.max(s.len, 1e-6); | |
| const dx = s.x1 - s.x0, dy = s.y1 - s.y0; | |
| const at = (f) => [s.x0 + dx * f, s.y0 + dy * f]; | |
| pctx.globalCompositeOperation = "source-over"; pctx.globalAlpha = 1; | |
| if (timeline.drone && !st.tint) { sprayBake(pctx, s, a, b, w, rgb); } | |
| else pieces(len, a, b, u, (p0, p1, tp) => { | |
| const [ax, ay] = at(p0), [bx, by] = at(p1), flat = kind === "paint" && !timeline.drone; // a roller stops with a straight edge; a brush or fan rounds off | |
| const cs = !flat && p0 <= 1e-9, ce = !flat && p1 >= 1 - 1e-9; | |
| pctx.strokeStyle = st.tint ? st.tint : col(st.alpha * s.load * s.tone * tp * (kind === "prep" ? 0.6 : 1)); | |
| seg(pctx, ax, ay, bx, by, w, cs, ce); | |
| if (!st.tint || kind === "prime") { // a soft lighter core, the nap texture and a blotchy mottle: a roller does not lay a flat colour | |
| pctx.strokeStyle = "rgba(255,255,255,0.10)"; seg(pctx, ax, ay, bx, by, w * 0.55, cs, ce); | |
| pctx.globalCompositeOperation = "multiply"; | |
| pctx.strokeStyle = napPattern; pctx.globalAlpha = 0.16; seg(pctx, ax, ay, bx, by, w * 0.92, cs, ce); | |
| if (mottlePattern) { pctx.strokeStyle = mottlePattern; pctx.globalAlpha = 0.12; seg(pctx, ax, ay, bx, by, w * 0.98, cs, ce); } | |
| pctx.globalCompositeOperation = "source-over"; pctx.globalAlpha = 1; | |
| } | |
| if (kind === "paint") ridges(pctx, ax, ay, bx, by, w); | |
| if (kind === "trim") bristles(pctx, s, p0, p1, w, rgb, u); | |
| if (kind === "paint" || kind === "trim") wetStreak(s, ax, ay, bx, by, w, u, cs, ce); | |
| }); | |
| if (timeline.drone && (kind === "paint" || kind === "trim")) pieces(len, a, b, u, (p0, p1) => { const [ax, ay] = at(p0), [bx, by] = at(p1); wetStreak(s, ax, ay, bx, by, w * 0.8, u, p0 <= 1e-9, p1 >= 1 - 1e-9); }); | |
| } | |
| for (const s of timeline.items) { // drips grow after their stroke ends | |
| if (!s.drip) continue; | |
| const g0 = clamp((from - s.t1) / 1.6, 0, 1), g1 = clamp((to - s.t1) / 1.6, 0, 1); | |
| if (g1 <= g0) continue; | |
| const pctx = rctx; | |
| pctx.strokeStyle = col(0.8 * s.load); pctx.lineWidth = 2.6 * u; pctx.lineCap = "round"; | |
| pctx.beginPath(); pctx.moveTo(s.drip.x, s.drip.y + s.drip.len * g0); pctx.lineTo(s.drip.x, s.drip.y + s.drip.len * g1); pctx.stroke(); | |
| pctx.fillStyle = col(0.85 * s.load); pctx.beginPath(); pctx.arc(s.drip.x, s.drip.y + s.drip.len * g1, 2.4 * u, 0, Math.PI * 2); pctx.fill(); | |
| pctx.fillStyle = "rgba(255,255,255,0.22)"; pctx.beginPath(); pctx.arc(s.drip.x - 0.7 * u, s.drip.y + s.drip.len * g1 - 0.8 * u, 0.9 * u, 0, Math.PI * 2); pctx.fill(); // glint on the bead | |
| } | |
| rctx.globalAlpha = 1; qctx.globalAlpha = 1; pctx.globalAlpha = 1; | |
| } | |
| // Wet paint catches the light: a broad sheen plus a thin hard highlight toward the light (up and left). Both dry away in render(). | |
| function wetStreak(s, ax, ay, bx, by, w, u, cs, ce) { | |
| const dx = bx - ax, dy = by - ay, m = Math.hypot(dx, dy) || 1; | |
| let nx = -dy / m, ny = dx / m; if (nx + ny > 0) { nx = -nx; ny = -ny; } | |
| wctx.globalAlpha = 1; | |
| wctx.strokeStyle = "rgba(255,255,255,0.24)"; seg(wctx, ax, ay, bx, by, w * 0.7, cs, ce); | |
| wctx.strokeStyle = "rgba(255,255,255,0.46)"; seg(wctx, ax + nx * w * 0.2, ay + ny * w * 0.2, bx + nx * w * 0.2, by + ny * w * 0.2, Math.max(1.4 * u, w * 0.14), cs, ce); | |
| } | |
| // A brush cutting in leaves bristle streaks: a few thin lines of varying density that follow the stroke, placed from a hash so they never change on replay. | |
| function bristles(c, s, p0, p1, w, rgb, u) { | |
| const dx = s.x1 - s.x0, dy = s.y1 - s.y0, len = Math.max(s.len, 1e-6), nx = -dy / len, ny = dx / len; | |
| for (let k = 0; k < 6; k++) { | |
| const r = rng((s.idx + 3) * 2654435 + k * 97), off = (r() - 0.5) * w * 0.86, dark = r() < 0.5; | |
| c.strokeStyle = dark ? `rgba(${rgb[0] * 0.7 | 0},${rgb[1] * 0.7 | 0},${rgb[2] * 0.7 | 0},${0.12 + 0.12 * r()})` : "rgba(255,255,255,0.14)"; | |
| c.beginPath(); c.moveTo(s.x0 + dx * p0 + nx * off, s.y0 + dy * p0 + ny * off); c.lineTo(s.x0 + dx * p1 + nx * off, s.y0 + dy * p1 + ny * off); | |
| c.lineWidth = (0.7 + 0.9 * r()) * u; c.lineCap = "butt"; c.stroke(); | |
| } | |
| } | |
| // A roller leaves a faint ridge of paint along both edges of its stripe; where stripes overlap these show as the lap marks you see on a rolled wall. | |
| function ridges(c, ax, ay, bx, by, w) { | |
| const dx = bx - ax, dy = by - ay, m = Math.hypot(dx, dy); if (m < 0.5) return; | |
| const nx = -dy / m, ny = dx / m, o = w * 0.49, u = Math.max(timeline.W || 800, 1) / 900; | |
| for (const side of [-1, 1]) { | |
| c.strokeStyle = "rgba(0,0,0,0.07)"; c.lineWidth = 1.5 * u; | |
| c.beginPath(); c.moveTo(ax + nx * o * side, ay + ny * o * side); c.lineTo(bx + nx * o * side, by + ny * o * side); c.stroke(); | |
| c.strokeStyle = "rgba(255,255,255,0.09)"; c.lineWidth = 1 * u; | |
| c.beginPath(); c.moveTo(ax + nx * (o - 2 * u) * side, ay + ny * (o - 2 * u) * side); c.lineTo(bx + nx * (o - 2 * u) * side, by + ny * (o - 2 * u) * side); c.stroke(); | |
| } | |
| } | |
| // Spray: a soft overspray halo, the fan itself, a dense core, and speckle placed on a fixed lattice along the stroke (hashed by stroke and step) so a | |
| // scrub or replay lays exactly the same droplets however the time slices fall. | |
| function sprayBake(c, s, a, b, w, rgb) { | |
| const col = (al) => `rgba(${rgb[0]},${rgb[1]},${rgb[2]},${al})`, u = Math.max(timeline.W || 800, 1) / 900; | |
| const k = s.load * s.tone, trim = s.phase.kind === "trim", len = Math.max(s.len, 1e-6), dx = s.x1 - s.x0, dy = s.y1 - s.y0; | |
| const nx = -dy / len, ny = dx / len, at = (f) => [s.x0 + dx * f, s.y0 + dy * f]; | |
| c.globalCompositeOperation = "source-over"; c.globalAlpha = 1; | |
| pieces(len, a, b, u, (p0, p1, tp) => { // overspray halo, the fan itself, a dense core; all feather out at the ends of a pass | |
| const [ax, ay] = at(p0), [bx, by] = at(p1), cs = p0 <= 1e-9, ce = p1 >= 1 - 1e-9; | |
| c.strokeStyle = col(0.09 * k * tp); seg(c, ax, ay, bx, by, w * 1.55, cs, ce); | |
| c.strokeStyle = col((trim ? 0.62 : 0.5) * k * tp); seg(c, ax, ay, bx, by, w, cs, ce); | |
| c.strokeStyle = col(0.22 * k * tp); seg(c, ax, ay, bx, by, w * 0.5, cs, ce); | |
| }); | |
| const sp = 4 * u, k0 = Math.ceil(a * len / sp), k1 = Math.floor(b * len / sp); // speckle on a fixed lattice, hashed by stroke and step | |
| for (let q = k0; q <= k1; q++) { | |
| const r = rng((s.idx + 1) * 7919 + q * 104729), f = q * sp / len, cx = s.x0 + dx * f, cy = s.y0 + dy * f; | |
| for (let n = 0; n < 3; n++) { | |
| const off = (r() + r() - 1) * w * 0.95, rad = (0.5 + r() * 1.1) * u; | |
| c.fillStyle = col(0.35 + 0.4 * r()); | |
| c.beginPath(); c.arc(cx + nx * off, cy + ny * off, rad, 0, Math.PI * 2); c.fill(); | |
| } | |
| } | |
| } | |
| // ---------------------------------------------------------------------- where the roller is | |
| function headAt(time) { | |
| const items = timeline.items; | |
| let lo = 0, hi = items.length - 1, found = -1; | |
| while (lo <= hi) { const mid = (lo + hi) >> 1; if (items[mid].t0 <= time) { found = mid; lo = mid + 1; } else hi = mid - 1; } | |
| if (found < 0) return null; | |
| const s = items[found], ph = s.phase; | |
| if (time > s.t1 + 1e-9) return { x: s.x1, y: s.y1, kind: ph.kind, item: "idle", label: ph.label, vx: 0, vy: 0, idle: true, p: ph }; | |
| const u = (time - s.t0) / Math.max(s.t1 - s.t0, 1e-9); | |
| const ease = s.kind === "seg" ? u : u * u * (3 - 2 * u); // transits ease in and out; strokes are steady | |
| const label = s.kind === "reload" || s.kind === "dip" ? "Reloading the roller" : ph.label; | |
| return { x: lerp(s.x0, s.x1, ease), y: lerp(s.y0, s.y1, ease), kind: ph.kind, item: s.kind, label, vx: s.x1 - s.x0, vy: s.y1 - s.y0, | |
| idle: false, painting: s.kind === "seg", p: ph, seg: s, u }; | |
| } | |
| // ---------------------------------------------------------------------- pose: drive base, mast carriage, two-link arm by IK | |
| // The rig's state (drive position, mast carriage height, wheel and roller spin) depends on where it has been, so it is simulated ONCE at open() into a | |
| // table at 30 Hz and looked up by time. That is what makes a scrub or a replay show exactly the same picture as playing straight through. | |
| function stepRig(st, head, W, H) { | |
| const u = Math.max(W, H) / 900; | |
| const floor = H - 14 * u; | |
| const L1 = 0.145 * W, L2 = 0.145 * W; | |
| const tx = head ? head.x : st.x + 80 * u, ty = head ? head.y : H * 0.55; | |
| const near = 0.30 * (L1 + L2), far = 0.82 * (L1 + L2); | |
| let want = st.x; | |
| if (tx - st.x > far) want = tx - far; else if (st.x - tx > far) want = tx + far; else if (Math.abs(tx - st.x) < near) want = st.x + (tx >= st.x ? -1 : 1) * 0.15 * near; | |
| want = clamp(want, 0.06 * W, 0.94 * W); | |
| const moved = (want - st.x) * 0.075; | |
| st.x += moved; st.wheel += moved / (9 * u); | |
| st.cy += (clamp(ty, 40 * u, floor - 70 * u) - st.cy) * 0.07; | |
| if (head && !head.idle && head.item === "seg") st.spin += RIG_DT * 90 * u; | |
| } | |
| function buildRig(j) { | |
| const st = { x: j.width * 0.14, cy: j.height * 0.5, wheel: 0, spin: 0 }; | |
| const n = Math.ceil(timeline.total / RIG_DT) + 1, table = []; | |
| for (let i = 0; i <= n; i++) { stepRig(st, headAt(i * RIG_DT), j.width, j.height); table.push({ x: st.x, cy: st.cy, wheel: st.wheel, spin: st.spin }); } | |
| return table; | |
| } | |
| function rigAt(time) { | |
| const f = clamp(time / RIG_DT, 0, rig.length - 1), i = Math.floor(f), k = f - i, a = rig[i], b = rig[Math.min(i + 1, rig.length - 1)]; | |
| return { x: lerp(a.x, b.x, k), cy: lerp(a.cy, b.cy, k), wheel: lerp(a.wheel, b.wheel, k), spin: lerp(a.spin, b.spin, k) }; | |
| } | |
| function solvePose(head, W, H) { | |
| const u = Math.max(W, H) / 900; | |
| const floor = H - 14 * u; | |
| const L1 = 0.145 * W, L2 = 0.145 * W, maxReach = (L1 + L2) * 0.93; | |
| const st = rigAt(t); | |
| const tx = head ? head.x : st.x + 80 * u, ty = head ? head.y : H * 0.55; | |
| const sx = st.x, sy = st.cy; | |
| let dx = tx - sx, dy = ty - sy, d = Math.hypot(dx, dy); | |
| if (d > maxReach) { const k = maxReach / d; dx *= k; dy *= k; d = maxReach; } | |
| const wx = sx + dx, wy = sy + dy; // wrist (the roller frame hangs from here) | |
| const dd = clamp(d, Math.abs(L1 - L2) + 1, L1 + L2 - 1); // two-link IK by the law of cosines, elbow bent upward | |
| const a = (L1 * L1 - L2 * L2 + dd * dd) / (2 * dd), hgt = Math.sqrt(Math.max(L1 * L1 - a * a, 0)); | |
| const ux = dx / (d || 1), uy = dy / (d || 1); | |
| const side = ux >= 0 ? 1 : -1; | |
| const ex = sx + ux * a + uy * hgt * side, ey = sy + uy * a - ux * hgt * side; | |
| return { u, floor, L1, L2, base: { x: st.x, y: floor }, shoulder: { x: sx, y: sy }, elbow: { x: ex, y: ey }, wrist: { x: wx, y: wy }, | |
| head: { x: tx, y: ty }, reach: d, maxReach, wheel: st.wheel, spin: st.spin }; | |
| } | |
| // ---------------------------------------------------------------------- the drone: simulated once, like the ground rig | |
| // Body hovers above its nozzle. A spring-damper (slightly under-damped, so it overshoots a little at stroke ends) chases the target, a slow | |
| // two-tone gust sways it, and it rolls into its acceleration the way a quad does. | |
| const droneTarget = (head, st, W, H, u) => ({ x: head ? head.x : W * 0.14, y: (head ? head.y : H * 0.5) - 52 * u }); | |
| function buildDrone(j) { | |
| const W = j.width, H = j.height, u = Math.max(W, H) / 900, n = Math.ceil(timeline.total / RIG_DT) + 1, table = []; | |
| const g = droneTarget(headAt(0), null, W, H, u); | |
| const st = { x: g.x, y: g.y, vx: 0, vy: 0, roll: 0, rotor: 0, d: 1, kick: 0, wasSpraying: false }; | |
| const k = 70, c = 11; | |
| for (let i = 0; i <= n; i++) { | |
| const tt = i * RIG_DT, tg = droneTarget(headAt(tt), st, W, H, u), wind = windAt(tt); | |
| const ax = k * (tg.x - st.x) - c * st.vx + wind.fx * u * 40, ay = k * (tg.y - st.y) - c * st.vy + wind.fy * u * 40; | |
| st.vx += ax * RIG_DT; st.vy += ay * RIG_DT; st.x += st.vx * RIG_DT; st.y += st.vy * RIG_DT; | |
| const wantRoll = clamp(st.vx / (260 * u) * 0.3 + wind.fx * 0.05, -0.32, 0.32); | |
| st.roll += (wantRoll - st.roll) * 0.18; st.rotor += RIG_DT * 55; | |
| const hd = headAt(tt), spraying = !!(hd && !hd.idle && hd.item === "seg"); | |
| // The gun's recoil: at trigger open the jet shoves the airframe off the wall, then it settles (drone_path's kick). | |
| // Standoff: it closes on the wall to spray, backs off in transit, and rides a little further out while the jet runs. | |
| if (spraying && !st.wasSpraying) st.kick = 0.22; | |
| st.wasSpraying = spraying; | |
| st.kick *= Math.exp(-RIG_DT / 0.35); | |
| const dT = (spraying ? 0.4 : 1) + st.kick; | |
| st.d += (dT - st.d) * 0.09; | |
| table.push({ x: st.x, y: st.y, roll: st.roll, rotor: st.rotor, vx: st.vx, d: st.d, kick: st.kick }); | |
| } | |
| return table; | |
| } | |
| const windAt = (tt) => ({ fx: Math.sin(tt * 0.9) * 0.6 + Math.sin(tt * 2.3 + 1) * 0.3, fy: Math.sin(tt * 1.3 + 2) * 0.35 }); | |
| function droneAt(time) { | |
| const f = clamp(time / RIG_DT, 0, rig.length - 1), i = Math.floor(f), k = f - i, a = rig[i], b = rig[Math.min(i + 1, rig.length - 1)]; | |
| return { x: lerp(a.x, b.x, k), y: lerp(a.y, b.y, k), roll: lerp(a.roll, b.roll, k), rotor: lerp(a.rotor, b.rotor, k), vx: lerp(a.vx, b.vx, k), d: lerp(a.d, b.d, k) }; | |
| } | |
| function drawCart(ctx, u, H, rgb, frac, live, dr) { | |
| const cx = 0.085 * timeline.W, floor = H - 14 * u, w = 104 * u, h = 58 * u, x = cx - w / 2, y = floor - h - 12 * u; | |
| ctx.fillStyle = "rgba(0,0,0,.3)"; ctx.beginPath(); ctx.ellipse(cx, floor + 3 * u, w * 0.62, 6 * u, 0, 0, Math.PI * 2); ctx.fill(); | |
| for (const wx of [x + 16 * u, x + w - 16 * u]) { // wheels | |
| const g = ctx.createRadialGradient(wx - 2 * u, floor - 8 * u, 1, wx, floor - 6 * u, 11 * u); g.addColorStop(0, "#5b626d"); g.addColorStop(1, "#23272f"); | |
| ctx.fillStyle = g; ctx.beginPath(); ctx.arc(wx, floor - 7 * u, 10 * u, 0, Math.PI * 2); ctx.fill(); | |
| ctx.fillStyle = "#b9c0cb"; ctx.beginPath(); ctx.arc(wx, floor - 7 * u, 3.4 * u, 0, Math.PI * 2); ctx.fill(); | |
| } | |
| const g = ctx.createLinearGradient(0, y, 0, y + h); g.addColorStop(0, "#fbfbfc"); g.addColorStop(0.6, "#dfe4ea"); g.addColorStop(1, "#aeb6c2"); | |
| ctx.fillStyle = g; rr(ctx, x, y, w, h, 8 * u); ctx.fill(); ctx.strokeStyle = "rgba(0,0,0,.4)"; ctx.lineWidth = 1.5 * u; ctx.stroke(); | |
| const tx = x + 8 * u, ty = y + 7 * u, tw = 38 * u, th = h - 14 * u; // paint tank with a level window | |
| ctx.fillStyle = "#1d2128"; rr(ctx, tx, ty, tw, th, 5 * u); ctx.fill(); | |
| const lvl = th * (0.06 + 0.88 * (1 - 0.8 * frac)); | |
| ctx.save(); rr(ctx, tx + 2 * u, ty + 2 * u, tw - 4 * u, th - 4 * u, 4 * u); ctx.clip(); | |
| ctx.fillStyle = `rgb(${rgb[0]},${rgb[1]},${rgb[2]})`; ctx.fillRect(tx, ty + th - lvl, tw, lvl); | |
| ctx.fillStyle = "rgba(255,255,255,.28)"; ctx.fillRect(tx, ty + th - lvl, tw, 2.5 * u); | |
| ctx.fillStyle = "rgba(255,255,255,.14)"; ctx.fillRect(tx + 4 * u, ty, 5 * u, th); | |
| ctx.restore(); | |
| const gx = x + 66 * u, gy = y + 20 * u, gr = 12 * u; // pressure gauge: needle jitters while pumping | |
| ctx.fillStyle = "#f3f5f8"; ctx.beginPath(); ctx.arc(gx, gy, gr, 0, Math.PI * 2); ctx.fill(); ctx.strokeStyle = "#454c58"; ctx.lineWidth = 1.6 * u; ctx.stroke(); | |
| const ang = (live ? -0.4 + 0.12 * Math.sin(dr.rotor * 0.9) : -1.9) + 0.6; ctx.strokeStyle = "#d0301f"; ctx.lineWidth = 1.8 * u; | |
| ctx.beginPath(); ctx.moveTo(gx, gy); ctx.lineTo(gx + Math.cos(ang) * gr * 0.8, gy + Math.sin(ang) * gr * 0.8); ctx.stroke(); | |
| ctx.fillStyle = live ? "#0a84ff" : "#30d158"; ctx.globalAlpha = live ? 0.65 + 0.35 * Math.sin(performance.now() / 150) : 1; | |
| rr(ctx, x + 56 * u, y + 40 * u, 28 * u, 5 * u, 2.5 * u); ctx.fill(); ctx.globalAlpha = 1; | |
| ctx.fillStyle = "#1d1d1f"; ctx.font = `700 ${9 * u}px -apple-system, Helvetica, Arial, sans-serif`; ctx.fillText("PV-D", x + w - 28 * u, y + h - 5 * u); | |
| const rx = cx + 4 * u, ry = y - 9 * u, rrad = 15 * u; // hose reel on top, spokes turn as hose pays out | |
| ctx.fillStyle = "#2b303a"; ctx.beginPath(); ctx.arc(rx, ry, rrad, 0, Math.PI * 2); ctx.fill(); | |
| ctx.strokeStyle = "#7b8594"; ctx.lineWidth = 1.5 * u; ctx.stroke(); | |
| for (let q = 0; q < 6; q++) { const a = dr.x * 0.012 + q * Math.PI / 3; ctx.beginPath(); ctx.moveTo(rx, ry); ctx.lineTo(rx + Math.cos(a) * rrad * 0.85, ry + Math.sin(a) * rrad * 0.85); ctx.stroke(); } | |
| return { x: rx + rrad * 0.2, y: ry - rrad * 0.6 }; // hose leaves the reel here | |
| } | |
| function drawHose(ctx, a, b, u, tt) { | |
| const L = Math.hypot(b.x - a.x, b.y - a.y), sag = 0.14 * L + 26 * u, bow = Math.sin(tt * 0.9) * 8 * u; | |
| const mx = (a.x + b.x) / 2 + bow, my = (a.y + b.y) / 2 + sag * 1.6; | |
| const path = () => { ctx.beginPath(); ctx.moveTo(a.x, a.y); ctx.quadraticCurveTo(mx, my, b.x, b.y); }; | |
| ctx.lineCap = "round"; | |
| ctx.save(); ctx.translate(20 * u, 26 * u); ctx.strokeStyle = "rgba(0,0,0,.16)"; ctx.lineWidth = 7 * u; path(); ctx.stroke(); ctx.restore(); // shadow on the wall | |
| ctx.strokeStyle = "#1f2a35"; ctx.lineWidth = 6.2 * u; path(); ctx.stroke(); | |
| ctx.strokeStyle = "#566a80"; ctx.lineWidth = 2 * u; ctx.save(); ctx.translate(-1 * u, -1.4 * u); path(); ctx.stroke(); ctx.restore(); | |
| ctx.setLineDash([3 * u, 26 * u]); ctx.strokeStyle = "#ffcf3d"; ctx.lineWidth = 6.4 * u; path(); ctx.stroke(); ctx.setLineDash([]); // tape bands every few metres | |
| } | |
| function drawDrone(ctx, u, dr, head, rgb, tt) { | |
| const sc = 0.9 + 0.14 * dr.d, nz = { x: 0, y: 56 * u }; // nearer the camera (backed off the wall) reads bigger | |
| ctx.save(); ctx.translate(dr.x, dr.y); ctx.rotate(dr.roll); ctx.scale(sc, sc); | |
| ctx.shadowColor = `rgba(0,0,0,${0.46 - 0.16 * dr.d})`; ctx.shadowBlur = (4 + 18 * dr.d) * u; ctx.shadowOffsetX = (5 + 34 * dr.d) * u; ctx.shadowOffsetY = (7 + 44 * dr.d) * u; // far from the wall: long, soft, faint shadow | |
| ctx.strokeStyle = "#20252d"; ctx.lineCap = "round"; ctx.lineWidth = 6 * u; // arms | |
| ctx.beginPath(); ctx.moveTo(-76 * u, -4 * u); ctx.lineTo(76 * u, -4 * u); ctx.stroke(); | |
| ctx.lineWidth = 4 * u; ctx.beginPath(); ctx.moveTo(-44 * u, -10 * u); ctx.lineTo(44 * u, -10 * u); ctx.stroke(); | |
| ctx.lineWidth = 2.4 * u; ctx.strokeStyle = "#454c58"; // landing skids | |
| ctx.beginPath(); ctx.moveTo(-26 * u, 14 * u); ctx.quadraticCurveTo(-34 * u, 30 * u, -48 * u, 30 * u); ctx.moveTo(26 * u, 14 * u); ctx.quadraticCurveTo(34 * u, 30 * u, 48 * u, 30 * u); ctx.stroke(); | |
| ctx.lineWidth = 4.5 * u; ctx.strokeStyle = "#2b303a"; // spray boom + nozzle | |
| ctx.beginPath(); ctx.moveTo(0, 12 * u); ctx.lineTo(0, nz.y - 6 * u); ctx.stroke(); | |
| ctx.fillStyle = "#c9d0da"; ctx.beginPath(); ctx.moveTo(-5 * u, nz.y - 6 * u); ctx.lineTo(5 * u, nz.y - 6 * u); ctx.lineTo(2.2 * u, nz.y + 4 * u); ctx.lineTo(-2.2 * u, nz.y + 4 * u); ctx.closePath(); ctx.fill(); | |
| ctx.shadowColor = "transparent"; | |
| const rotors = [[-76, -4, 1], [76, -4, 1], [-44, -10, 0.78], [44, -10, 0.78]]; // far pair drawn first and a touch smaller | |
| rotors.sort((a, b) => a[2] - b[2]); | |
| const drawRotor = ([rx, ry, sc]) => { | |
| ctx.fillStyle = "#2b303a"; rr(ctx, (rx - 5) * u, (ry - 7) * u, 10 * u, 8 * u, 2 * u); ctx.fill(); | |
| const wd = 40 * u * sc, ph = dr.rotor * (rx < 0 ? 1 : -1); | |
| const g = ctx.createRadialGradient(rx * u, (ry - 8) * u, 2, rx * u, (ry - 8) * u, wd); g.addColorStop(0, "rgba(40,46,56,.34)"); g.addColorStop(0.7, "rgba(40,46,56,.16)"); g.addColorStop(1, "rgba(40,46,56,0)"); | |
| ctx.fillStyle = g; ctx.beginPath(); ctx.ellipse(rx * u, (ry - 8) * u, wd, 7 * u * sc, 0, 0, Math.PI * 2); ctx.fill(); | |
| ctx.strokeStyle = "rgba(20,24,30,.55)"; ctx.lineWidth = 1.6 * u; // blade tips seen edge-on, flickering | |
| ctx.beginPath(); ctx.moveTo(rx * u - Math.cos(ph) * wd * 0.95, (ry - 8) * u); ctx.lineTo(rx * u + Math.cos(ph) * wd * 0.95, (ry - 8) * u); ctx.stroke(); | |
| }; | |
| drawRotor(rotors[0]); drawRotor(rotors[1]); | |
| const g = ctx.createLinearGradient(0, -16 * u, 0, 18 * u); g.addColorStop(0, "#fbfbfc"); g.addColorStop(0.6, "#dfe4ea"); g.addColorStop(1, "#aeb6c2"); | |
| ctx.fillStyle = g; rr(ctx, -30 * u, -16 * u, 60 * u, 32 * u, 10 * u); ctx.fill(); // fuselage | |
| ctx.strokeStyle = "rgba(0,0,0,.4)"; ctx.lineWidth = 1.5 * u; ctx.stroke(); | |
| ctx.fillStyle = "#ffd04a"; rr(ctx, -30 * u, -16 * u, 60 * u, 8 * u, 5 * u); ctx.fill(); | |
| ctx.fillStyle = "#1d1d1f"; ctx.font = `700 ${8 * u}px -apple-system, Helvetica, Arial, sans-serif`; ctx.fillText("PV-D", -12 * u, 9 * u); | |
| ctx.fillStyle = "#15181d"; ctx.beginPath(); ctx.arc(20 * u, 0, 6.5 * u, 0, Math.PI * 2); ctx.fill(); // gimbal camera that watches the pass | |
| ctx.fillStyle = "#4a90ff"; ctx.beginPath(); ctx.arc(21.5 * u, -1.5 * u, 1.8 * u, 0, Math.PI * 2); ctx.fill(); | |
| ctx.fillStyle = "#8d98a8"; rr(ctx, -4 * u, -22 * u, 8 * u, 6 * u, 2 * u); ctx.fill(); // hose port on top | |
| const blink = Math.sin(tt * 9) > 0.6; | |
| ctx.fillStyle = blink ? "#ff453a" : "#7a2a26"; ctx.beginPath(); ctx.arc(-76 * u, -9 * u, 2 * u, 0, Math.PI * 2); ctx.fill(); | |
| ctx.fillStyle = blink ? "#30d158" : "#1f6b34"; ctx.beginPath(); ctx.arc(76 * u, -9 * u, 2 * u, 0, Math.PI * 2); ctx.fill(); | |
| drawRotor(rotors[2]); drawRotor(rotors[3]); | |
| ctx.restore(); | |
| const cos = Math.cos(dr.roll), sin = Math.sin(dr.roll); | |
| return { nozzle: { x: dr.x + (nz.x * cos - nz.y * sin) * sc, y: dr.y + (nz.x * sin + nz.y * cos) * sc } }; | |
| } | |
| // Two rangefinder dots either side of the spot, the way a standoff sensor reads the wall; they spread as the drone backs off. | |
| function drawStandoff(ctx, u, head, dr) { | |
| const gap = (22 + 22 * dr.d) * u; | |
| for (const sd of [-1, 1]) { | |
| const x = head.x + sd * gap, y = head.y - 12 * u, g = ctx.createRadialGradient(x, y, 0, x, y, 7 * u); | |
| g.addColorStop(0, "rgba(255,70,60,.95)"); g.addColorStop(0.35, "rgba(255,70,60,.45)"); g.addColorStop(1, "rgba(255,70,60,0)"); | |
| ctx.fillStyle = g; ctx.beginPath(); ctx.arc(x, y, 7 * u, 0, Math.PI * 2); ctx.fill(); | |
| } | |
| } | |
| function drawSpray(ctx, u, noz, head, rgb, standoff = 1) { | |
| const base = head.p ? head.p.width : 40 * u, w = base * Math.max(0.35, Math.min(1.2, standoff)); // fan width follows the standoff | |
| const m = Math.hypot(head.vx, head.vy) || 1, nx = -head.vy / m, ny = head.vx / m; | |
| const tint = head.kind === "prep" ? "200,225,245" : head.kind === "prime" ? "232,228,220" : `${rgb[0]},${rgb[1]},${rgb[2]}`; | |
| const ax = head.x + nx * w / 2, ay = head.y + ny * w / 2, bx = head.x - nx * w / 2, by = head.y - ny * w / 2; | |
| ctx.save(); | |
| const g = ctx.createLinearGradient(noz.x, noz.y, head.x, head.y); // jet from the nozzle to the wall | |
| g.addColorStop(0, `rgba(${tint},.0)`); g.addColorStop(0.35, `rgba(${tint},.28)`); g.addColorStop(1, `rgba(${tint},.5)`); | |
| ctx.fillStyle = g; ctx.beginPath(); ctx.moveTo(noz.x - 1.5 * u, noz.y); ctx.lineTo(ax, ay); ctx.lineTo(bx, by); ctx.lineTo(noz.x + 1.5 * u, noz.y); ctx.closePath(); ctx.fill(); | |
| const rg = ctx.createRadialGradient(head.x, head.y, 1, head.x, head.y, w * 0.8); // wet spot where the fan meets the wall | |
| rg.addColorStop(0, `rgba(${tint},.5)`); rg.addColorStop(1, `rgba(${tint},0)`); | |
| ctx.fillStyle = rg; ctx.beginPath(); ctx.arc(head.x, head.y, w * 0.8, 0, Math.PI * 2); ctx.fill(); | |
| ctx.restore(); | |
| } | |
| function renderDrone(ctx, cvs, head, dtSim, rgb) { | |
| const u = Math.max(cvs.width, cvs.height) / 900, tt = t, dr = droneAt(t), H = cvs.height; | |
| const live = !!head && !head.idle, wind = windAt(tt).fx; | |
| if (live && head.item === "seg") { | |
| if (head.kind === "prep") spawnDust(head, u, Math.max(dtSim, 0.016), "rgba(190,215,235,.9)"); | |
| else spawnPaintFlecks(head, u, Math.max(dtSim, 0.016), rgb, true, wind); | |
| } | |
| const frac = t / Math.max(timeline.total, 1e-6); | |
| const reel = drawCart(ctx, u, H, rgb, frac, live, dr); | |
| const cos = Math.cos(dr.roll), sin = Math.sin(dr.roll); | |
| if (live && head.item === "seg") drawStandoff(ctx, u, head, dr); | |
| drawHose(ctx, reel, { x: dr.x + 22 * u * sin, y: dr.y - 22 * u * cos }, u, tt); // hose first, so the drone sits on top of it | |
| const parts = drawDrone(ctx, u, dr, head, rgb, tt); | |
| if (live && head.item === "seg") drawSpray(ctx, u, parts.nozzle, head, rgb, dr.d); | |
| stepDust(ctx, Math.max(0.016, Math.min(dtSim, 0.1)), u); | |
| lastPose = { drone: dr, nozzle: parts.nozzle, head: { x: head ? head.x : 0, y: head ? head.y : 0 }, u }; | |
| } | |
| // ---------------------------------------------------------------------- live job stats: wall painted, paint used and left, passes, reloads, time left | |
| // Everything is derived from the plan being replayed. Area and litres need a scale: the work order's measured one, or its ASSUMED one (then every | |
| // figure is tagged "scale assumed"). Paint is 10 m2 per litre per coat, two coats, the same figures the "how much paint" answer uses; this animation | |
| // lays one coat. Time left is an estimate at a typical machine speed, not a measurement. | |
| const COVER_M2_PER_L = 10, COATS = 2, SPEED_MM_S = { ground: 250, drone: 500 }, RELOAD_S = 20; | |
| let statsBase = null; | |
| function buildStats(j) { | |
| const wo = (j && j.work_order) || {}, sc = wo.scale || {}, mmpp = Number(sc.mm_per_px) > 0 ? Number(sc.mm_per_px) : null; | |
| const items = timeline.items, kinds = { paint: 1, trim: 1, touch: 1 }; | |
| const cum = new Array(items.length), pass = new Array(items.length), dips = new Array(items.length); | |
| let a = 0, n = 0, d = 0; | |
| items.forEach((x, i) => { if (x.kind === "seg" && kinds[x.phase.kind]) { a += x.len * x.phase.width; n++; } if (x.dip) d++; cum[i] = a; pass[i] = n; dips[i] = d; }); | |
| const lenPx = items.filter((x) => x.kind === "seg" && kinds[x.phase.kind]).reduce((s2, x) => s2 + x.len, 0); | |
| const areaFt2 = wo.summary && Number(wo.summary.paint_area_ft2) > 0 ? Number(wo.summary.paint_area_ft2) : null; | |
| const coatL = areaFt2 ? areaFt2 * 0.092903 / COVER_M2_PER_L : null; | |
| statsBase = { cum, pass, dips, totalArea: Math.max(a, 1e-9), totalPass: n, totalDips: d, areaFt2, coatL, mmpp, lenPx, | |
| assumed: /assumed/i.test(String(sc.source || "")) || !mmpp, | |
| travelMin: mmpp ? (lenPx * mmpp / SPEED_MM_S[rigKind] + d * RELOAD_S) / 60 : null }; | |
| const root = els.stats; if (!root) return; | |
| root.textContent = ""; | |
| const tile = (id, label) => { | |
| const t2 = document.createElement("div"), l = document.createElement("span"), v = document.createElement("strong"), s3 = document.createElement("small"), m = document.createElement("div"), f = document.createElement("i"); | |
| t2.className = "rs-tile"; t2.dataset.id = id; l.className = "rs-label"; l.textContent = label; v.className = "rs-val"; s3.className = "rs-sub"; m.className = "rs-meter"; m.appendChild(f); | |
| t2.append(l, v, s3, m); root.appendChild(t2); return t2; | |
| }; | |
| tile("wall", "Wall painted"); tile("paint", "Paint left"); tile("passes", "Passes"); | |
| tile("machine", rigKind === "drone" ? "Supply" : "Reloads"); tile("time", "Time left"); | |
| } | |
| function statsAt(time) { | |
| const b = statsBase; if (!b) return; | |
| const items = timeline.items; | |
| let lo = 0, hi = items.length - 1, k = -1; | |
| while (lo <= hi) { const mid = (lo + hi) >> 1; if (items[mid].t0 <= time) { k = mid; lo = mid + 1; } else hi = mid - 1; } | |
| let area = 0, pass = 0, dips = 0; | |
| if (k >= 0) { | |
| const it = items[k], u = clamp((time - it.t0) / Math.max(it.t1 - it.t0, 1e-9), 0, 1); | |
| const before = k > 0 ? b.cum[k - 1] : 0, bp = k > 0 ? b.pass[k - 1] : 0, bd = k > 0 ? b.dips[k - 1] : 0; | |
| const isPaint = it.kind === "seg" && b.cum[k] > before; | |
| area = isPaint ? before + (b.cum[k] - before) * u : before; | |
| pass = isPaint ? bp + (u >= 1 ? 1 : 0) : bp; | |
| dips = it.dip ? bd - 1 + (u >= 1 ? 1 : 0) : bd; | |
| } | |
| const f = clamp(area / b.totalArea, 0, 1), done = time >= timeline.total - 1e-6, tag = b.assumed ? " · scale assumed" : ""; | |
| const set = (id, val, sub, frac, level) => { | |
| const t2 = els.stats.querySelector(`[data-id="${id}"]`); if (!t2) return; | |
| t2.querySelector(".rs-val").textContent = val; t2.querySelector(".rs-sub").textContent = sub; | |
| const m = t2.querySelector(".rs-meter"); m.hidden = frac == null; if (frac != null) m.firstChild.style.width = `${Math.round(100 * clamp(frac, 0, 1))}%`; | |
| t2.dataset.level = level || ""; | |
| }; | |
| set("wall", `${Math.round(100 * f)}%`, b.areaFt2 ? `${fmt1(f * b.areaFt2)} of ${fmt1(b.areaFt2)} sq ft${tag}` : "of the planned area", f); | |
| if (b.coatL) { | |
| const used = f * b.coatL, left = b.coatL - used, total = b.coatL * COATS; | |
| set("paint", `${fmt1(left)} L`, `${fmt1(used)} L used · coat 1 of ${COATS} · job ${fmt1(total)} L${tag}`, 1 - f, left / b.coatL < 0.12 && !done ? "low" : ""); | |
| } else set("paint", `${Math.round(100 * (1 - f))}%`, "of this coat to go (no scale: litres unknown)", 1 - f); | |
| set("passes", `${Math.min(pass, b.totalPass)} / ${b.totalPass}`, "roller passes and cut-in strokes", b.totalPass ? pass / b.totalPass : 0); | |
| if (rigKind === "drone") set("machine", "Hose-fed", "no reloads: pump cart refills the line", null); | |
| else set("machine", `${Math.min(dips, b.totalDips)} / ${b.totalDips}`, "dips in the paint tray", b.totalDips ? dips / b.totalDips : 1); | |
| if (b.travelMin != null) { const left = b.travelMin * (1 - time / Math.max(timeline.total, 1e-9)); set("time", done ? "Done" : fmtMin(left), `of ~${fmtMin(b.travelMin)} at ${SPEED_MM_S[rigKind] / 1000} m/s (estimate)`, null); } | |
| else set("time", "—", "needs a scale to estimate", null); | |
| } | |
| const fmt1 = (v) => (v >= 10 ? Math.round(v) : Math.round(v * 10) / 10).toLocaleString(); | |
| const fmtMin = (m) => (m < 1 ? "< 1 min" : m < 90 ? `${Math.round(m)} min` : `${Math.floor(m / 60)} h ${Math.round(m % 60)} min`); | |
| // ---------------------------------------------------------------------- drawing | |
| function rr(ctx, x, y, w, h, r) { | |
| ctx.beginPath(); ctx.moveTo(x + r, y); ctx.arcTo(x + w, y, x + w, y + h, r); ctx.arcTo(x + w, y + h, x, y + h, r); | |
| ctx.arcTo(x, y + h, x, y, r); ctx.arcTo(x, y, x + w, y, r); ctx.closePath(); | |
| } | |
| function link(ctx, a, b, w, c1, c2) { | |
| const ang = Math.atan2(b.y - a.y, b.x - a.x), len = Math.hypot(b.x - a.x, b.y - a.y); | |
| ctx.save(); ctx.translate(a.x, a.y); ctx.rotate(ang); | |
| const g = ctx.createLinearGradient(0, -w / 2, 0, w / 2); g.addColorStop(0, c1); g.addColorStop(0.5, c2); g.addColorStop(1, c1); | |
| ctx.fillStyle = g; rr(ctx, -w * 0.5, -w / 2, len + w, w, w / 2); ctx.fill(); | |
| ctx.strokeStyle = "rgba(0,0,0,.38)"; ctx.lineWidth = Math.max(1, w * 0.07); ctx.stroke(); | |
| ctx.restore(); | |
| } | |
| function joint(ctx, p, r) { | |
| const g = ctx.createRadialGradient(p.x - r * 0.3, p.y - r * 0.3, r * 0.1, p.x, p.y, r); | |
| g.addColorStop(0, "#e9edf3"); g.addColorStop(1, "#6a7381"); | |
| ctx.fillStyle = g; ctx.beginPath(); ctx.arc(p.x, p.y, r, 0, Math.PI * 2); ctx.fill(); | |
| ctx.strokeStyle = "rgba(0,0,0,.45)"; ctx.lineWidth = r * 0.16; ctx.stroke(); | |
| ctx.fillStyle = "#2b303a"; ctx.beginPath(); ctx.arc(p.x, p.y, r * 0.32, 0, Math.PI * 2); ctx.fill(); | |
| } | |
| function drawRoller(ctx, pose, head, rgb) { | |
| const u = pose.u, p = pose.wrist, painting = head && head.painting; | |
| const kind = head ? head.kind : "paint"; | |
| let ax = 0, ay = 1; // roller axis (unit): perpendicular to the way it is moving | |
| if (head && !head.idle && (head.vx || head.vy)) { const m = Math.hypot(head.vx, head.vy); ax = -head.vy / m; ay = head.vx / m; } | |
| if (ay < 0 || (Math.abs(ay) < 1e-6 && ax < 0)) { ax = -ax; ay = -ay; } | |
| const phaseW = head && head.p ? head.p.width : 40 * u; | |
| const length = clamp(kind === "prep" ? 36 * u : phaseW, 20 * u, 110 * u), dia = (kind === "trim" ? 11 : kind === "prep" ? 16 : 19) * u; | |
| ctx.save(); ctx.translate(p.x, p.y); ctx.rotate(Math.atan2(ay, ax)); | |
| ctx.strokeStyle = "#444b57"; ctx.lineWidth = 2.4 * u; ctx.lineCap = "round"; // wire frame from the arm to the roller ends | |
| ctx.beginPath(); ctx.moveTo(-length / 2 + 3 * u, 0); ctx.lineTo(-length / 2 + 3 * u, -dia * 0.9); ctx.lineTo(0, -dia * 1.35); ctx.stroke(); | |
| const dry = head && head.seg && head.seg.load < 1 ? clamp((1 - head.seg.load) / 0.38, 0, 1) * 0.55 : 0; // a roller running dry fades toward bare nap | |
| const mix = (c, to) => Math.round(c + (to - c) * dry); | |
| ctx.fillStyle = kind === "prep" ? "#c99a5e" : kind === "trim" ? "#7b8794" : `rgb(${mix(rgb[0], 226)},${mix(rgb[1], 220)},${mix(rgb[2], 208)})`; | |
| rr(ctx, -length / 2, -dia / 2, length, dia, dia * 0.5); ctx.fill(); | |
| const sh = ctx.createLinearGradient(0, -dia / 2, 0, dia / 2); | |
| sh.addColorStop(0, "rgba(255,255,255,.42)"); sh.addColorStop(0.45, "rgba(255,255,255,0)"); sh.addColorStop(1, "rgba(0,0,0,.34)"); | |
| ctx.fillStyle = sh; rr(ctx, -length / 2, -dia / 2, length, dia, dia * 0.5); ctx.fill(); | |
| ctx.save(); rr(ctx, -length / 2, -dia / 2, length, dia, dia * 0.5); ctx.clip(); // nap bands scroll as it rolls | |
| ctx.strokeStyle = "rgba(0,0,0,.16)"; ctx.lineWidth = 1 * u; | |
| const step = 5 * u, off = (pose.spin % step + step) % step; | |
| for (let k = -length / 2 - step; k < length / 2 + step; k += step) { ctx.beginPath(); ctx.moveTo(k + off, -dia / 2); ctx.lineTo(k + off, dia / 2); ctx.stroke(); } | |
| ctx.restore(); | |
| ctx.strokeStyle = "rgba(0,0,0,.4)"; ctx.lineWidth = 1.2 * u; rr(ctx, -length / 2, -dia / 2, length, dia, dia * 0.5); ctx.stroke(); | |
| if (painting) { ctx.strokeStyle = "rgba(255,255,255,.55)"; ctx.lineWidth = 1.4 * u; ctx.beginPath(); ctx.moveTo(-length / 2 + 4 * u, dia * 0.28); ctx.lineTo(length / 2 - 4 * u, dia * 0.28); ctx.stroke(); } | |
| ctx.restore(); | |
| } | |
| function drawTray(ctx, u, rgb, tray, dipping) { | |
| ctx.save(); ctx.translate(tray.x, tray.y); | |
| ctx.fillStyle = "rgba(0,0,0,.25)"; ctx.beginPath(); ctx.ellipse(0, 22 * u, 52 * u, 6 * u, 0, 0, Math.PI * 2); ctx.fill(); | |
| const g = ctx.createLinearGradient(0, -10 * u, 0, 24 * u); g.addColorStop(0, "#d8dde4"); g.addColorStop(1, "#8e98a6"); | |
| ctx.fillStyle = g; ctx.beginPath(); ctx.moveTo(-50 * u, -4 * u); ctx.lineTo(50 * u, -4 * u); ctx.lineTo(40 * u, 22 * u); ctx.lineTo(-40 * u, 22 * u); ctx.closePath(); ctx.fill(); | |
| ctx.strokeStyle = "rgba(0,0,0,.4)"; ctx.lineWidth = 1.2 * u; ctx.stroke(); | |
| ctx.fillStyle = `rgb(${rgb[0]},${rgb[1]},${rgb[2]})`; ctx.beginPath(); ctx.ellipse(0, -2 * u, 44 * u, 5 * u, 0, 0, Math.PI * 2); ctx.fill(); | |
| ctx.fillStyle = "rgba(255,255,255,.35)"; ctx.beginPath(); ctx.ellipse(-12 * u, -3.5 * u, 14 * u, 1.8 * u, 0, 0, Math.PI * 2); ctx.fill(); | |
| if (dipping) { ctx.strokeStyle = "rgba(255,255,255,.5)"; ctx.lineWidth = 1.5 * u; ctx.beginPath(); ctx.ellipse(0, -2 * u, 10 * u + 6 * u * Math.abs(Math.sin(performance.now() / 120)), 2.5 * u, 0, 0, Math.PI * 2); ctx.stroke(); } | |
| ctx.restore(); | |
| } | |
| function drawBase(ctx, pose, head) { | |
| const u = pose.u, bx0 = pose.base.x, floor = pose.floor; | |
| const bw = 132 * u, bh = 44 * u, bx = bx0 - bw / 2, by = floor - bh - 14 * u; | |
| ctx.fillStyle = "rgba(0,0,0,.3)"; ctx.beginPath(); ctx.ellipse(bx0, floor + 3 * u, bw * 0.66, 7 * u, 0, 0, Math.PI * 2); ctx.fill(); | |
| ctx.fillStyle = "#23272f"; rr(ctx, bx - 6 * u, by + bh - 6 * u, bw + 12 * u, 22 * u, 11 * u); ctx.fill(); // tracks | |
| for (let k = 0; k < 6; k++) { | |
| const wx = bx + 10 * u + k * ((bw - 20 * u) / 5), wy = by + bh + 5 * u; | |
| const g = ctx.createRadialGradient(wx - 1.5 * u, wy - 1.5 * u, 1, wx, wy, 7.5 * u); g.addColorStop(0, "#69717d"); g.addColorStop(1, "#343a44"); | |
| ctx.fillStyle = g; ctx.beginPath(); ctx.arc(wx, wy, 7.2 * u, 0, Math.PI * 2); ctx.fill(); | |
| ctx.strokeStyle = "#b9c0cb"; ctx.lineWidth = 1.3 * u; | |
| ctx.beginPath(); ctx.moveTo(wx, wy); ctx.lineTo(wx + Math.cos(pose.wheel + k) * 6 * u, wy + Math.sin(pose.wheel + k) * 6 * u); ctx.stroke(); | |
| } | |
| const g = ctx.createLinearGradient(0, by, 0, by + bh); g.addColorStop(0, "#fbfbfc"); g.addColorStop(0.55, "#dfe4ea"); g.addColorStop(1, "#aeb6c2"); | |
| ctx.fillStyle = g; rr(ctx, bx, by, bw, bh, 10 * u); ctx.fill(); | |
| ctx.strokeStyle = "rgba(0,0,0,.4)"; ctx.lineWidth = 1.6 * u; ctx.stroke(); | |
| ctx.fillStyle = "rgba(0,0,0,.12)"; rr(ctx, bx + 8 * u, by + bh * 0.62, bw - 16 * u, 4 * u, 2 * u); ctx.fill(); | |
| const live = head && !head.idle; // status strip: orange prep, blue paint, green idle | |
| const lamp = !live ? "#30d158" : head.kind === "prep" ? "#ff9f0a" : "#0a84ff"; | |
| ctx.fillStyle = lamp; ctx.globalAlpha = live ? 0.65 + 0.35 * Math.sin(performance.now() / 150) : 1; rr(ctx, bx + 12 * u, by + 9 * u, 34 * u, 6 * u, 3 * u); ctx.fill(); ctx.globalAlpha = 1; | |
| ctx.fillStyle = "#1d1d1f"; ctx.font = `700 ${11 * u}px -apple-system, Helvetica, Arial, sans-serif`; ctx.fillText("PV-1", bx + bw - 44 * u, by + 17 * u); | |
| const top = pose.shoulder.y, mx = pose.base.x; // mast: fixed lower section + telescoping upper section | |
| ctx.save(); ctx.shadowColor = "rgba(0,0,0,.32)"; ctx.shadowBlur = 10 * u; ctx.shadowOffsetX = 7 * u; ctx.shadowOffsetY = 9 * u; | |
| const outerTop = Math.max(top + 20 * u, by - 150 * u); | |
| const g2 = ctx.createLinearGradient(mx - 7 * u, 0, mx + 7 * u, 0); g2.addColorStop(0, "#2d333d"); g2.addColorStop(0.5, "#7b8594"); g2.addColorStop(1, "#2d333d"); | |
| ctx.fillStyle = g2; rr(ctx, mx - 7 * u, outerTop, 14 * u, by - outerTop + 4 * u, 3 * u); ctx.fill(); | |
| const g3 = ctx.createLinearGradient(mx - 4.5 * u, 0, mx + 4.5 * u, 0); g3.addColorStop(0, "#3d4552"); g3.addColorStop(0.5, "#a3adbb"); g3.addColorStop(1, "#3d4552"); | |
| ctx.fillStyle = g3; rr(ctx, mx - 4.5 * u, top - 8 * u, 9 * u, Math.max(outerTop - top + 40 * u, 10 * u), 2.5 * u); ctx.fill(); | |
| ctx.restore(); | |
| } | |
| // Mains umbilical from the drive base off the left edge: slack rises and falls with the distance driven, and it lies on the floor. | |
| function drawCable(ctx, pose) { | |
| const u = pose.u, a = { x: pose.base.x - 62 * u, y: pose.floor - 26 * u }, b = { x: -14 * u, y: pose.floor - 3 * u }; | |
| const dip = Math.min(40 * u, 8 * u + Math.abs(a.x - b.x) * 0.05); | |
| ctx.save(); ctx.lineCap = "round"; | |
| const path = () => { ctx.beginPath(); ctx.moveTo(a.x, a.y); ctx.bezierCurveTo(a.x - 30 * u, a.y + dip, b.x + 60 * u, b.y + 2 * u, b.x, b.y); }; | |
| ctx.strokeStyle = "rgba(0,0,0,.22)"; ctx.lineWidth = 5 * u; ctx.translate(0, 3 * u); path(); ctx.stroke(); ctx.translate(0, -3 * u); | |
| ctx.strokeStyle = "#e8742a"; ctx.lineWidth = 3.4 * u; path(); ctx.stroke(); | |
| ctx.strokeStyle = "rgba(255,255,255,.35)"; ctx.lineWidth = 1 * u; ctx.translate(0, -1 * u); path(); ctx.stroke(); | |
| ctx.restore(); | |
| } | |
| function drawArm(ctx, pose) { | |
| const u = pose.u; | |
| ctx.save(); ctx.shadowColor = "rgba(0,0,0,.34)"; ctx.shadowBlur = 12 * u; ctx.shadowOffsetX = 9 * u; ctx.shadowOffsetY = 12 * u; | |
| const g = ctx.createLinearGradient(0, pose.shoulder.y - 13 * u, 0, pose.shoulder.y + 13 * u); g.addColorStop(0, "#ffd04a"); g.addColorStop(1, "#d89a10"); | |
| ctx.fillStyle = g; rr(ctx, pose.shoulder.x - 15 * u, pose.shoulder.y - 13 * u, 30 * u, 26 * u, 6 * u); ctx.fill(); // carriage on the mast | |
| ctx.strokeStyle = "rgba(0,0,0,.4)"; ctx.lineWidth = 1.4 * u; ctx.stroke(); | |
| link(ctx, pose.shoulder, pose.elbow, 14 * u, "#9aa4b2", "#e8ecf1"); | |
| link(ctx, pose.elbow, pose.wrist, 11 * u, "#8b95a3", "#dfe4ea"); | |
| ctx.restore(); | |
| joint(ctx, pose.shoulder, 8 * u); joint(ctx, pose.elbow, 8.5 * u); joint(ctx, pose.wrist, 6.5 * u); | |
| } | |
| const dustRng = rng(9); | |
| function spawnDust(head, u, dt, colour) { | |
| const n = Math.floor(14 * dt * speed + dustRng() * 0.8); | |
| for (let k = 0; k < n; k++) particles.push({ x: head.x + (dustRng() - 0.5) * 22 * u, y: head.y + (dustRng() - 0.5) * 18 * u, vx: (dustRng() - 0.5) * 26 * u, vy: (-6 + dustRng() * 14) * u, life: 1, r: (1.2 + dustRng() * 2.2) * u, c: colour }); | |
| if (particles.length > 320) particles.splice(0, particles.length - 320); | |
| } | |
| // Paint flung off a fast roller, and drifting spray mist from the drone's fan: small, short-lived, coloured like the paint. | |
| function spawnPaintFlecks(head, u, dt, rgb, mist, wind) { | |
| const rate = mist ? 70 : 9, n = Math.floor(rate * dt * speed + dustRng() * (mist ? 1.4 : 0.5)); | |
| const sp = head.p ? head.p.width : 30 * u; | |
| for (let k = 0; k < n; k++) { | |
| const lateral = (dustRng() - 0.5) * sp * (mist ? 1.2 : 0.9); | |
| const m = Math.hypot(head.vx, head.vy) || 1, nx = -head.vy / m, ny = head.vx / m; | |
| particles.push({ x: head.x + nx * lateral, y: head.y + ny * lateral, vx: (mist ? wind * 14 * u : 0) + (dustRng() - 0.5) * (mist ? 22 : 60) * u, vy: (mist ? -4 : -20) * u + dustRng() * 14 * u, | |
| life: mist ? 0.55 + dustRng() * 0.45 : 1, r: (mist ? 0.8 + dustRng() * 1.6 : 0.9 + dustRng() * 1.4) * u, c: `rgb(${rgb[0]},${rgb[1]},${rgb[2]})`, g: mist ? 0.25 : 1, a: mist ? 0.5 : 0.85, d: mist ? 0.9 : 1.7 }); | |
| } | |
| if (particles.length > 320) particles.splice(0, particles.length - 320); | |
| } | |
| function stepDust(ctx, dt, u) { | |
| particles.forEach((p) => { p.life -= dt / (p.d || 1.7); p.vy += 60 * (p.g == null ? 1 : p.g) * dt * u; p.x += p.vx * dt; p.y += p.vy * dt; }); | |
| particles = particles.filter((p) => p.life > 0); | |
| for (const p of particles) { ctx.globalAlpha = Math.max(0, p.life) * (p.a || 0.7); ctx.fillStyle = p.c || "#e9dcc8"; ctx.beginPath(); ctx.arc(p.x, p.y, p.r, 0, Math.PI * 2); ctx.fill(); } | |
| ctx.globalAlpha = 1; | |
| } | |
| function render() { | |
| const j = getJob(); if (!j || !timeline || !timeline.phases.length) return; | |
| const cvs = els.canvas, ctx = cvs.getContext("2d"); | |
| if (t < drawn) resetLayers(); | |
| const dtSim = clamp(t - drawn, 0, 2); | |
| bake(drawn, t); drawn = t; | |
| if (dtSim > 0) { // the wet sheen dries to matt in about two seconds | |
| wctx.globalCompositeOperation = "destination-out"; wctx.fillStyle = `rgba(0,0,0,${1 - Math.exp(-dtSim / 1.9)})`; | |
| wctx.fillRect(0, 0, wetLayer.width, wetLayer.height); wctx.globalCompositeOperation = "source-over"; | |
| } | |
| ctx.clearRect(0, 0, cvs.width, cvs.height); | |
| ctx.drawImage(preLayer, 0, 0); | |
| if (maskLayer) { | |
| const tx = tmpLayer.getContext("2d"); | |
| tx.globalCompositeOperation = "source-over"; tx.clearRect(0, 0, tmpLayer.width, tmpLayer.height); | |
| tx.drawImage(rollLayer, 0, 0); tx.globalCompositeOperation = "destination-in"; tx.drawImage(maskLayer, 0, 0); tx.globalCompositeOperation = "source-over"; | |
| ctx.drawImage(tmpLayer, 0, 0); | |
| } else ctx.drawImage(rollLayer, 0, 0); | |
| ctx.drawImage(paintLayer, 0, 0); | |
| if (maskLayer) { | |
| const tx = tmpLayer.getContext("2d"); | |
| tx.globalCompositeOperation = "source-over"; tx.clearRect(0, 0, tmpLayer.width, tmpLayer.height); | |
| tx.drawImage(wetLayer, 0, 0); tx.globalCompositeOperation = "destination-in"; tx.drawImage(maskLayer, 0, 0); tx.globalCompositeOperation = "source-over"; | |
| ctx.drawImage(tmpLayer, 0, 0); | |
| } else ctx.drawImage(wetLayer, 0, 0); | |
| const head = headAt(t), rgb = paintColour(); | |
| statsAt(t); | |
| if (rigKind === "drone") { | |
| renderDrone(ctx, cvs, head, dtSim, rgb); | |
| els.phase.textContent = t >= timeline.total - 1e-6 ? "Finished" : (head ? head.label : "Ready"); | |
| const pctD = Math.round(100 * t / timeline.total); | |
| els.pct.textContent = `${pctD}%`; els.seek.value = String(Math.round(1000 * t / timeline.total)); els.root.dataset.progress = String(pctD); | |
| if (!playing) els.play.textContent = t >= timeline.total - 1e-6 ? "Replay" : "Play"; | |
| return; | |
| } | |
| const pose = solvePose(head, cvs.width, cvs.height); | |
| lastPose = pose; | |
| if (head && !head.idle && head.kind === "prep" && head.item === "seg") spawnDust(head, pose.u, Math.max(dtSim, 0.016)); | |
| else if (head && !head.idle && head.kind === "paint" && head.item === "seg") spawnPaintFlecks(head, pose.u, Math.max(dtSim, 0.016), rgb, false, 0); | |
| drawCable(ctx, pose); | |
| stepDust(ctx, Math.max(0.016, Math.min(dtSim, 0.1)), pose.u); | |
| drawTray(ctx, pose.u, rgb, timeline.tray, head && head.item === "dip" && !head.idle); | |
| drawBase(ctx, pose, head); | |
| drawArm(ctx, pose); | |
| if (head && !head.idle && head.item === "seg") { // the roller is pressed on the wall: tight dark contact shadow around it | |
| const w = Math.min(120 * pose.u, (head.p ? head.p.width : 40 * pose.u) * 0.9), g = ctx.createRadialGradient(pose.wrist.x, pose.wrist.y, 1, pose.wrist.x, pose.wrist.y, w); | |
| g.addColorStop(0, "rgba(0,0,0,.26)"); g.addColorStop(1, "rgba(0,0,0,0)"); | |
| ctx.fillStyle = g; ctx.beginPath(); ctx.arc(pose.wrist.x, pose.wrist.y, w, 0, Math.PI * 2); ctx.fill(); | |
| } | |
| ctx.save(); ctx.shadowColor = "rgba(0,0,0,.34)"; ctx.shadowBlur = 8 * pose.u; ctx.shadowOffsetX = 6 * pose.u; ctx.shadowOffsetY = 8 * pose.u; | |
| drawRoller(ctx, pose, head, rgb); | |
| ctx.restore(); | |
| els.phase.textContent = t >= timeline.total - 1e-6 ? "Finished" : (head ? head.label : "Ready"); | |
| const pct = Math.round(100 * t / timeline.total); | |
| els.pct.textContent = `${pct}%`; | |
| els.seek.value = String(Math.round(1000 * t / timeline.total)); | |
| els.root.dataset.progress = String(pct); | |
| if (!playing) els.play.textContent = t >= timeline.total - 1e-6 ? "Replay" : "Play"; | |
| } | |
| function frame(ts) { | |
| if (!playing) return; | |
| const dt = Math.min(0.05, (ts - lastTs) / 1000 || 0); lastTs = ts; | |
| t = Math.min(timeline.total, t + dt * speed); | |
| render(); | |
| if (t >= timeline.total) { setPlaying(false); return; } | |
| raf = requestAnimationFrame(frame); | |
| } | |
| function setPlaying(on) { | |
| playing = on && !!timeline && timeline.total > 0; | |
| els.play.textContent = playing ? "Pause" : (t >= timeline.total - 1e-6 ? "Replay" : "Play"); | |
| els.play.setAttribute("aria-pressed", playing ? "true" : "false"); | |
| cancelAnimationFrame(raf); | |
| if (playing) { lastTs = performance.now(); if (t >= timeline.total - 1e-6) { t = 0; } raf = requestAnimationFrame(frame); } | |
| } | |
| function seek(time) { | |
| if (!timeline || !timeline.total) return; | |
| t = clamp(time, 0, timeline.total); | |
| render(); | |
| } | |
| // ---------------------------------------------------------------------- open / close | |
| function open() { | |
| const j = getJob(); if (!j) return; | |
| timeline = buildTimeline(j, 18, { drone: rigKind === "drone" }); | |
| if (!timeline.phases.length) { window.toast && window.toast(timeline.reason, "warn"); return; } | |
| els.root.hidden = false; | |
| els.canvas.hidden = false; | |
| els.canvas.width = j.width; els.canvas.height = j.height; | |
| maskLayer = buildMask(j); | |
| resetLayers(); | |
| rig = rigKind === "drone" ? buildDrone(j) : buildRig(j); | |
| buildStats(j); | |
| t = 0; speed = Number(els.speed.value) || 1; | |
| document.querySelectorAll('#stage [data-layer="paint"], #stage [data-layer="touchup"]').forEach((e) => e.classList.add("robot-dim")); | |
| $("#robot-open").setAttribute("aria-pressed", "true"); | |
| if (REDUCED) { t = timeline.total; render(); setPlaying(false); els.play.textContent = "Replay"; } | |
| else { render(); setPlaying(true); } | |
| } | |
| // Switch machine mid-watch: same plan, same fraction of the way through, same play state. | |
| function setRig(kind) { | |
| if (kind !== "ground" && kind !== "drone") return false; | |
| rigKind = kind; | |
| document.querySelectorAll("#robot-rig [data-rig]").forEach((b) => { const on = b.dataset.rig === kind; b.classList.toggle("on", on); b.setAttribute("aria-pressed", on ? "true" : "false"); }); | |
| const j = getJob(); | |
| if (!j || !els.root || els.root.hidden || !timeline) return true; | |
| const frac = timeline.total ? t / timeline.total : 0, was = playing; | |
| setPlaying(false); | |
| timeline = buildTimeline(j, 18, { drone: kind === "drone" }); | |
| resetLayers(); rig = kind === "drone" ? buildDrone(j) : buildRig(j); | |
| buildStats(j); | |
| t = frac * timeline.total; particles = []; | |
| render(); if (was) setPlaying(true); | |
| return true; | |
| } | |
| function close() { | |
| setPlaying(false); | |
| els.root.hidden = true; els.canvas.hidden = true; | |
| document.querySelectorAll("#stage .robot-dim").forEach((e) => e.classList.remove("robot-dim")); | |
| $("#robot-open").setAttribute("aria-pressed", "false"); | |
| } | |
| function refreshButton() { | |
| const btn = $("#robot-open"); if (!btn) return; | |
| const j = getJob(); | |
| const tl = j ? buildTimeline(j) : { phases: [], reason: "Open a job first." }; | |
| btn.disabled = false; // always clickable: a click on a blocked job explains why, instead of a dead button | |
| btn.title = tl.phases.length ? "Watch the robot work through this plan" : tl.reason; | |
| btn.dataset.ready = tl.phases.length ? "1" : "0"; | |
| btn.textContent = els.root && !els.root.hidden ? "Stop watching" : "Watch it paint"; | |
| } | |
| function init() { | |
| els.root = $("#robot-bar"); els.canvas = $("#robot-canvas"); els.play = $("#robot-play"); els.seek = $("#robot-seek"); | |
| els.speed = $("#robot-speed"); els.stats = $("#robot-stats"); els.phase = $("#robot-phase"); els.pct = $("#robot-pct"); | |
| if (!els.root || !els.canvas) return; | |
| $("#robot-open").addEventListener("click", () => { if (els.root.hidden) open(); else close(); }); | |
| $("#robot-close").addEventListener("click", close); | |
| const rigSeg = $("#robot-rig"); | |
| if (rigSeg) rigSeg.addEventListener("click", (e) => { const b = e.target.closest("[data-rig]"); if (b) setRig(b.dataset.rig); }); | |
| els.play.addEventListener("click", () => setPlaying(!playing)); | |
| els.seek.addEventListener("input", () => { setPlaying(false); seek(timeline.total * Number(els.seek.value) / 1000); els.play.textContent = "Play"; }); | |
| els.speed.addEventListener("change", () => { speed = Number(els.speed.value) || 1; }); | |
| document.addEventListener("keydown", (e) => { | |
| if (els.root.hidden || /INPUT|TEXTAREA|SELECT/.test((e.target || {}).tagName || "")) return; | |
| if (e.key === " ") { e.preventDefault(); setPlaying(!playing); } | |
| else if (e.key === "Escape") close(); | |
| }); | |
| let seen = getJob(); // a job opened from the URL hash can load before this script runs: poll the job by identity | |
| setInterval(() => { | |
| const cur = getJob(); | |
| if (cur !== seen) { seen = cur; if (!els.root.hidden) close(); } | |
| refreshButton(); | |
| }, 400); | |
| refreshButton(); | |
| } | |
| // Test/diagnostic: how much roller paint lies outside the allowed area before clipping, and how much of it is actually shown. | |
| function spill() { | |
| if (!maskLayer || !rollLayer) return null; | |
| const W = rollLayer.width, H = rollLayer.height, g = (c) => c.getContext("2d").getImageData(0, 0, W, H).data; | |
| const raw = g(rollLayer), m = g(maskLayer), tx = tmpLayer.getContext("2d"); | |
| tx.globalCompositeOperation = "source-over"; tx.clearRect(0, 0, W, H); tx.drawImage(rollLayer, 0, 0); tx.globalCompositeOperation = "destination-in"; tx.drawImage(maskLayer, 0, 0); | |
| tx.globalCompositeOperation = "source-over"; | |
| const shown = g(tmpLayer); | |
| let rawOut = 0, shownOut = 0, inside = 0; | |
| for (let i = 3; i < raw.length; i += 4) { | |
| const allowed = m[i] > 0; | |
| if (raw[i] > 12 && !allowed) rawOut++; | |
| if (shown[i] > 12 && !allowed) shownOut++; | |
| if (shown[i] > 12 && allowed) inside++; | |
| } | |
| return { raw_outside_px: rawOut, shown_outside_px: shownOut, inside_px: inside, allowed_px: maskInfo.allowed_px }; | |
| } | |
| // Test hook: remove a rectangle (fractions of the picture) from the allowed area, as if a keep-out region sat there. | |
| function carveMask(fx, fy, fw, fh) { | |
| if (!maskLayer) return false; | |
| const x = maskLayer.getContext("2d"), W = maskLayer.width, H = maskLayer.height; | |
| x.globalCompositeOperation = "destination-out"; x.fillRect(fx * W, fy * H, fw * W, fh * H); x.globalCompositeOperation = "source-over"; | |
| return true; | |
| } | |
| window.PVRobot = { | |
| spill, carveMask, setRig, rig: () => rigKind, | |
| buildTimeline, seek, play: () => setPlaying(true), pause: () => setPlaying(false), open, close, | |
| pose: () => lastPose && lastPose.shoulder && { shoulder: lastPose.shoulder, elbow: lastPose.elbow, wrist: lastPose.wrist, head: lastPose.head, L1: lastPose.L1, L2: lastPose.L2, reach: lastPose.reach, maxReach: lastPose.maxReach, base: lastPose.base }, | |
| stats: () => { if (!statsBase) return null; const o = {}; els.stats.querySelectorAll(".rs-tile").forEach((t2) => { o[t2.dataset.id] = t2.querySelector(".rs-val").textContent; }); return o; }, | |
| state: () => ({ clipped: !!maskLayer, mask: maskInfo, t, total: timeline ? timeline.total : 0, playing, reloads: timeline ? timeline.reloads : 0, particles: particles.length, | |
| phases: timeline ? timeline.phases.map((p) => ({ kind: p.kind, segs: p.segs.length, t0: p.t0, t1: p.t1 })) : [] }), | |
| }; | |
| if (document.readyState === "loading") document.addEventListener("DOMContentLoaded", init); else init(); | |
| })(); | |