// 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(); })();