30:T17a5,plot = { const {PI} = Math; const {size} = plotOptions; const {xlo,xhi,ylo,yhi,spacing,G} = grid; const dr = spacing / 2; const aspect = (yhi-ylo+2*dr) / (xhi-xlo+2*dr); const [w,h] = (aspect > 1) ? [size/aspect, size] : [size, size*aspect]; //const x0 = (xlo + xhi) / 2, y0 = (ylo + yhi) / 2; const scale = size / (xhi - xlo + 2 * dr); const X = d3.scaleLinear().domain([xlo-dr,xhi+dr]).range([0,w]); const Y = d3.scaleLinear().domain([ylo-dr,yhi+dr]).range([h,0]); // Calculate pixel coords of world (mm) coordinate origin, which is generally off screen. const X0 = X(0), Y0 = Y(0); // Colors for [0,1,2] blocked robots const C = d3.scaleLinear().domain([0,1,2]).range(["palegreen","red","darkred"]); const index = d3.index(neighbors, d => d.DEVICE_ID); function drawPoly(poly) { const p = d3.path(); d3.transpose([poly.x,poly.y]).forEach(([x,y],i) => { if(i) p.lineTo(X(x), Y(y)); else p.moveTo(X(x), Y(y)); }); p.closePath(); return p; } const svg = d3.create("svg") .attr("width", w) .attr("height", h) .attr("viewBox", [0, 0, w, h]); invalidation.then(() => svg.interrupt()); const keepouts = svg.append("g") .attr("fill", "none") .attr("stroke-width", 2); const circles = svg.append("g") .attr("fill", "none") .attr("stroke", "black") .attr("stroke-dasharray", [2, 6]); const arms = svg.append("g") .attr("fill", "none") .attr("stroke", "red") .attr("stroke-width", 4); const labels = svg.append("g") .attr("font", "italic 11px san-serif") .attr("fill", "gray"); const rects = svg.append("g") .attr("stroke", "none") .attr("fill-opacity", 0.5); circles.selectAll("circle") .data(neighbors, d=>d.DEVICE_ID) .join("circle") .attr("cx", d => X(d.OFFSET_X)) .attr("cy", d => Y(d.OFFSET_Y)) .attr("r", d => X(d.LENGTH_R1+d.LENGTH_R2) - X0); keepouts.selectAll("g.keepout") .data(neighbors, d=>d.DEVICE_ID) .join("g") .attr("id", d => d.DEVICE_ID) .classed("keepout", true) // apply X,Y,T offsets .attr("transform", d => { const x = d.OFFSET_X, y = d.OFFSET_Y, T0 = d.OFFSET_T; return `translate(${X(x)-X0},${Y(y)-Y0}) rotate(${-T0},${X0},${Y0})`; }) .attr("stroke", d => d.NONFUNC ? "red" : "green") .attr("visibility", d => d.NONFUNC ? "visible" : "hidden") .call(R => { R.append("g") .classed("theta", true) // rotate by POS_T .attr("transform", d => `rotate(${-d.POS_T},${X0},${Y0})`) // draw theta keepout .call(S => { S.append("path") .attr("d", d => drawPoly(d.keepoutT)); const phi = S.append("g") // translate to P arm axis .attr("transform", d => `translate(${X(d.LENGTH_R1)-X0},0)`) .append("g") .classed("phi", true) // rotate by extP = POS_P+OFFSET_P .attr("transform", d => `rotate(${-(d.POS_P+d.OFFSET_P)},${X0},${Y0})`); // draw phi keepout phi.append("path") .attr("d", d => drawPoly(d.keepoutP)); }); }); function setAngles(posid, T, P) { const keepout = keepouts.select(`#${posid}`) .attr("visibility", "visible"); const theta = keepout.select("g.theta") .attr("transform", `rotate(${-T},${X0},${Y0})`); const phi = theta.select("g.phi") .attr("transform", `rotate(${-P},${X0},${Y0})`); } labels.selectAll("text") .data(neighbors) .join("text") .attr("x", d => X(d.OFFSET_X)) .attr("y", d => Y(d.OFFSET_Y)) .attr("text-anchor", "middle") .attr("alignment-baseline", "middle") .text(d => d.DEVICE_ID); rects.selectAll("rect") .data(G) .join("rect") .attr("x", d => X(d.x - spacing/2)) .attr("y", d => Y(d.y + spacing/2)) .attr("width", scale * spacing) .attr("height", scale * spacing) .attr("fill", d => C(d3.sum(d.hits, h => h.blocked))) .on("mouseover", (e,d) => { for(const n of neighbors) { keepouts.select(`#${n.DEVICE_ID}`) .attr("visibility", n.NONFUNC ? "visible" : "hidden"); }; for(const hit of d.hits) { if(!hit.blocked) setAngles(hit.DEVICE_ID, hit.T, hit.P); } arms.selectAll("line.theta") .data(d.hits, d => d.DEVICE_ID) .join("line") .attr("x1", g => X(index.get(g.DEVICE_ID).OFFSET_X)) .attr("y1", g => Y(index.get(g.DEVICE_ID).OFFSET_Y)) .attr("x2", g => X(g.XT)) .attr("y2", g => Y(g.YT)) .attr("stroke", g => g.blocked ? "red" : "green") .classed("theta", true); arms.selectAll("line.phi") .data(d.hits, d => d.DEVICE_ID) .join("line") .attr("x1", g => X(g.XT)) .attr("y1", g => Y(g.YT)) .attr("x2", g => X(d.x)) .attr("y2", g => Y(d.y)) .attr("stroke", g => g.blocked ? "red" : "green") .classed("phi", true); arms.attr("visibility", "visible"); }); function update(gridData, angles) { // Update angles for non-functional robots. nonfuncNeighbors.forEach( ({DEVICE_ID}) => setAngles(DEVICE_ID, angles[DEVICE_ID+"T"], angles[DEVICE_ID+"P"]) ); // Update grid colors. rects.selectAll("rect") .data(gridData) .join("rect") .attr("fill", d => C(d3.sum(d.hits, h => h.blocked))); } svg.on("mouseleave", e => { for(const n of neighbors) { arms.attr("visibility", "hidden"); if(!n.NONFUNC) keepouts.select(`#${n.DEVICE_ID}`).attr("visibility", "hidden"); } }); viewof setAngles.dispatchEvent(new Event("input", {bubbles: true})); const { ratio } = getStats(grid); //viewof initialRatio.value = ratio; //viewof initialRatio.dispatchEvent(new Event("input", {bubbles: true})); return Object.assign(svg.node(), { update }); }31:T519,grid = { const {density, pad} = gridOptions; // Get the extent of the (x,y) origins of the robots to include. let [xlo,xhi] = d3.extent(neighbors, n => n.OFFSET_X); let [ylo,yhi] = d3.extent(neighbors, n => n.OFFSET_Y); // Add padding to cover the patrol radius around the edges. xlo -= pad; xhi += pad; ylo -= pad; yhi += pad; // Calculate the grid spacing in mm const spacing = 1 / density; // Calculate the grid size const nx = Math.ceil((xhi - xlo) / spacing), ny = Math.ceil((yhi - ylo) / spacing); // Expand the grid if necessary to ensure exact spacing const x0 = (xlo + xhi) / 2, y0 = (ylo + yhi) / 2; xlo = x0 - 0.5 * nx * spacing; xhi = x0 + 0.5 * nx * spacing; ylo = y0 - 0.5 * ny * spacing; yhi = y0 + 0.5 * ny * spacing; // Calculate coordinates of each grid cell. const xGrid = d3.range(nx).map(i => xlo + i * (xhi - xlo) / (nx - 1)); const yGrid = d3.range(ny).map(i => ylo + i * (yhi - ylo) / (ny - 1)); // Build the grid. const G = d3.cross(xGrid, yGrid) .map(([x, y]) => { const hits = at(x, y); return {x, y, hits}; }) .filter(({hits}) => hits.length > 0); updateGrid(G, neighbors); const { ratio } = getStats({G,spacing}); console.log("new grid with ratio", ratio); return {xlo,xhi,ylo,yhi,spacing,G}; }32:T58e,function at(x,y) { const {sqrt,cos,sin,acos,atan2,abs,max,PI} = Math; // Get the list of neighbors that can reach (x,y) relative to the selected robot. const hits = [ ]; neighbors.forEach(({DEVICE_ID,OFFSET_X,OFFSET_Y,OFFSET_T, LENGTH_R1,LENGTH_R2,NONFUNC},i) => { if(NONFUNC) return; const X = x - OFFSET_X; const Y = y - OFFSET_Y; const Rsq = X**2 + Y**2, R = sqrt(Rsq); if(R > LENGTH_R1 + LENGTH_R2 || R < abs(LENGTH_R1 - LENGTH_R2)) return; const phi = atan2(Y,X), r1sq = LENGTH_R1**2, r2sq = LENGTH_R2**2; const s = (Rsq - r2sq + r1sq) / (2 * R); const a = sqrt(max(0, r1sq - s * s)); const beta = atan2(a, s); // Calculate T in the range (-PI,+PI). let T = phi - beta; if(T > PI) T -= 2*PI; // Calculate the coordinates of the elbow relative to the selected robot. const XT = OFFSET_X + LENGTH_R1 * cos(T); const YT = OFFSET_Y + LENGTH_R1 * sin(T); // Calculate P in the range (0,PI). const P = acos((Rsq - r1sq - r2sq) / (2 * LENGTH_R1 * LENGTH_R2)); // Calculate this neighbor's translated and rotated phi arm keepout. const {keepoutT,keepoutP} = getKeepouts(neighbors[i], T * 180/PI - OFFSET_T, P * 180/PI); // Save this hit with intT and extT in degrees. const blocked = false; hits.push({DEVICE_ID, T:T*180/PI-OFFSET_T, P:P*180/PI, XT, YT, keepoutT, keepoutP, blocked}); }); return hits; }33:T46b,neighbors = { return selected.map(DEVICE_ID => { const dev = dump.index.get(DEVICE_ID); // Lookup keepout polygons centered at (0,0) with extT=extP=0. const [xT,yT] = dump.meta.keepout.theta[dev.KEEPOUT_T]; const [xP,yP] = dump.meta.keepout.phi[dev.KEEPOUT_P]; // Take the convex hull for fast intersection tests const [xTc,yTc] = d3.transpose(d3.polygonHull(d3.transpose([xT,yT]))); dev.keepoutT = {x:xTc,y:yTc,length:xTc.length}; const [xPc,yPc] = d3.transpose(d3.polygonHull(d3.transpose([xP,yP]))); dev.keepoutP = {x:xPc,y:yPc,length:xPc.length}; // Calculate and save the keepouts at the current angles. if(dev.NONFUNC) console.log('init', DEVICE_ID, Math.round(dev.POS_T), Math.round(dev.POS_P+dev.OFFSET_P)); const {keepoutT:keepoutT0, keepoutP:keepoutP0} = getKeepouts( dev, Math.round(dev.POS_T), Math.round(dev.POS_P+dev.OFFSET_P)); // Save the list of this robot's non-functional neighbors. const nonfuncNeighbors = dev.NEIGHBORS.filter(DEVICE_ID => dump.index.get(DEVICE_ID).NONFUNC); return { ...dev, keepoutT0, keepoutP0, nonfuncNeighbors }; }); }34:T40d,function getKeepouts(dev, intT, extP, {theta=true,phi=true}={}) { const {sin,cos,PI} = Math, deg2rad = PI / 180; const extT = intT + dev.OFFSET_T; const t = extT * deg2rad, tp = (extT + extP) * deg2rad; const cost = cos(t), sint = sin(t), costp = cos(tp), sintp = sin(tp); let keepoutT, keepoutP; if(theta) { const {x,y,length} = dev.keepoutT, xnew = new Array(length), ynew = new Array(length); for(let i=0; i < length; ++i) { xnew[i] = dev.OFFSET_X + x[i] * cost - y[i] * sint; ynew[i] = dev.OFFSET_Y + y[i] * cost + x[i] * sint; } keepoutT = { x:xnew, y:ynew, length }; } if(phi) { const xT = dev.OFFSET_X + dev.LENGTH_R1 * cost, yT = dev.OFFSET_Y + dev.LENGTH_R1 * sint; const {x,y,length} = dev.keepoutP, xnew = new Array(length), ynew = new Array(length); for(let i = 0; i < length; ++i) { xnew[i] = xT + x[i] * costp - y[i] * sintp; ynew[i] = yT + y[i] * costp + x[i] * sintp; } keepoutP = { x:xnew, y:ynew, length }; } return {keepoutT, keepoutP}; }35:T432,dump = { const {data,datatype,meta}=await parseECSV(FileAttachment("fp-20250122.ecsv")); let small_data = data .filter(d => d.DEVICE_TYPE === "POS" || d.DEVICE_TYPE === "ETC") .map( ({PETAL_LOC,DEVICE_TYPE,KEEPOUT_T,KEEPOUT_P,LENGTH_R1,LENGTH_R2, DEVICE_ID,OFFSET_X,OFFSET_Y,OFFSET_T,OFFSET_P,POS_T,POS_P, KEEPOUT_EXPANSION_THETA_RADIAL, KEEPOUT_EXPANSION_THETA_ANGULAR, KEEPOUT_EXPANSION_PHI_RADIAL, KEEPOUT_EXPANSION_PHI_ANGULAR, DEVICE_CLASSIFIED_NONFUNCTIONAL,POS_NEIGHBORS}) => { const NONFUNC = DEVICE_CLASSIFIED_NONFUNCTIONAL === "True"; const NEIGHBORS = JSON.parse(POS_NEIGHBORS); return {PETAL_LOC,DEVICE_TYPE,DEVICE_ID,KEEPOUT_T,KEEPOUT_P,LENGTH_R1,LENGTH_R2, OFFSET_X,OFFSET_Y,OFFSET_T,OFFSET_P,POS_T,POS_P, KEEPOUT_EXPANSION_THETA_RADIAL, KEEPOUT_EXPANSION_THETA_ANGULAR, KEEPOUT_EXPANSION_PHI_RADIAL, KEEPOUT_EXPANSION_PHI_ANGULAR, NONFUNC,NEIGHBORS}; }); const index=d3.index(small_data, device=>device.DEVICE_ID); return {meta,index}; }36:T760,function collisionDistance(poly1, poly2, {origin=[0,0]}={}) { // Calculate the perpendicular distance between 2 convex polygons, specified as arrays // of [x,y] coordinates. Returns an offset vector [dx,dy] specifying the translation // of poly1 that would bring it into contact with poly2, and a signed perpendicular // distance between the polygons that equals zero when they are just making contact, // negative when they overlap, and otherwise positive. // Convexity of the inputs is not tested and the results might not be correct if one // polygon is fully contained within the other. const {sqrt,min,max} = Math; const BIG = Number.MAX_VALUE; const n1 = poly1.length, n2 = poly2.length; const [x0,y0] = origin; let ax0, ay0, dsmax = -BIG; const project = (P,ax,ay) => { let smin=+BIG, smax=-BIG; for(let k=0; k0)) throw new Error(`Invalid ${j}-${k} vertex separation: dx=${dx} dy=${dy} poly=${poly}`); const ax = -dy/dr, ay = dx/dr; const [s1min,s1max] = project(poly1,ax,ay); const [s2min,s2max] = project(poly2,ax,ay); // Find the signed separation between the polygons along this projection. const ds = max(s2min-s1max, s1min-s2max); if(ds > dsmax) { dsmax = ds; if(s2min-s1max > s1min-s2max) ax0 = ds*ax, ay0 = ds*ay; else ax0 = -ds*ax, ay0 = -ds*ay; } } return dsmax; }37:[{"id":"e6da2d67efcae074e3f453d8cd0037bdc7867668e0f98d9ff1c543525c800491dd025d72da8bd4c7202b3d66a17bc47a1349f31b91fbf8c21b173b9bb7b4dd0e","href":"https://static.observableusercontent.com/files/e6da2d67efcae074e3f453d8cd0037bdc7867668e0f98d9ff1c543525c800491dd025d72da8bd4c7202b3d66a17bc47a1349f31b91fbf8c21b173b9bb7b4dd0e","name":"fp-20250122.ecsv","type":"application/octet-stream","lastModified":1737687591865.995,"size":2388182}] 2e:{"title":"Robot Valet Parking","cells":[{"id":0,"value":"text1 = md`# Robot Valet Parking\n\nDESI has ${groups.size} clusters containing ${d3.sum([...dump.index.values()], d=>d.NONFUNC)} non-functional robots (as of ${dump.meta.snap_time.slice(0,10)}). Select one below to view how the fixed positions of non-functional robots impinge (red) upon the patrol area accessible (green) to their functional neighbors. **Can you find better parking spots that allows DESI to see more sky in future observations?**`","pinned":false,"hidden":false,"mode":"ojs"},{"id":12,"value":"viewof selected = Inputs.select(groups)","pinned":false,"hidden":false,"mode":"ojs"},{"id":375,"value":"text2 = md`Hover the mouse over any point within a patrol radius (circles) to see the resulting angles required to reach that point.\n\nUse the sliders to try and find better (less red) parking spots for the non-functional robots in this cluster that minimizes the impingment value (and maximizes the improvement) printed below, in units of a single robot patrol area ${tex`\\pi R^2`}. A 5% average improvement for 600 robots effectively recovers 30 robots!`","pinned":false,"hidden":false,"mode":"ojs"},{"id":653,"value":"viewof setAngles = {\n const nonfunc = neighbors.filter(({NONFUNC}) => NONFUNC);\n const initialAngles = nonfunc.map(\n ({DEVICE_ID,POS_T,POS_P,OFFSET_P}) => [\n [ DEVICE_ID+\"T\", Math.round(POS_T), [-180,180] ],\n [ DEVICE_ID+\"P\", Math.round(POS_P + OFFSET_P), [0,180] ],\n ]).flat();\n const step = 1;\n const sliders = Object.fromEntries(initialAngles.map(\n ([label,value,rng]) => [ label, Inputs.range(rng, {value, step, label}) ]));\n const buttons = Inputs.button([[\"RESET ANGLES\", () => {\n initialAngles.forEach(([label,value,rng]) => {\n sliders[label].value = value;\n });\n }]]);\n return Inputs.form(\n Object.assign(sliders, { buttons }), {\n template: (inputs) => html`

${Object.values(inputs)}`\n });\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":360,"value":"text3 = {\n setAngles;\n const { ratio } = getStats(grid);\n const { ratio:initialRatio } = initialStats;\n return md`**Total impingment = ${(100*ratio).toFixed(1)}% for ${(100*(initialRatio-ratio)).toFixed(1)}% improvement**`;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":58,"value":"$30","pinned":false,"hidden":false,"mode":"ojs"},{"id":389,"value":"---","pinned":false,"hidden":false,"mode":"md"},{"id":762,"value":"selected2 = findInGroup(\"M07688\")","pinned":false,"hidden":false,"mode":"ojs"},{"id":743,"value":"initialStats = {\n grid;\n return getStats(grid);\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":398,"value":"live = {\n // Update the keepouts for non-functional robots from the sliders\n neighbors.forEach((dev,k,A) => {\n if(dev.NONFUNC) {\n const intT = setAngles[dev.DEVICE_ID+\"T\"], extP = setAngles[dev.DEVICE_ID+\"P\"];\n const {keepoutT, keepoutP} = getKeepouts(dev, intT, extP);\n A[k].keepoutT0 = keepoutT;\n A[k].keepoutP0 = keepoutP;\n }\n });\n // Recalculate the grid\n updateGrid(grid.G, neighbors);\n // Update the plot\n plot.update(grid.G, setAngles);\n return true;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":441,"value":"function updateGrid(grid, neighbors) {\n const start = Date.now();\n grid.forEach(g => {\n g.hits.forEach((h,j,H) => {\n let blocked = false;\n const {DEVICE_ID:id1,keepoutP,keepoutT} = h;\n const {nonfuncNeighbors} = neighborsIndex.get(id1);\n for(const {DEVICE_ID:id2,keepoutP0,keepoutT0} of neighbors) {\n if(!nonfuncNeighbors.includes(id2)) continue;\n if(!blocked) blocked = collisionDistance(keepoutP, keepoutP0) < 0;\n if(!blocked) blocked = collisionDistance(keepoutP, keepoutT0) < 0;\n if(!blocked) blocked = collisionDistance(keepoutT, keepoutP0) < 0;\n if(blocked) break;\n }\n H[j].blocked = blocked;\n });\n });\n const elapsed = Date.now() - start;\n console.log(\"updateGrid: elapsed ms =\", elapsed.toFixed(1));\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":335,"value":"function getStats(grid) {\n const {sin,cos,PI} = Math;\n // Calculate area of the circle\n const R = 6;\n const Acircle = PI * R ** 2;\n // Calculate area of one overlap region\n const th = PI / 3;\n const Aoverlap = 2 * (th - cos(th/2)*sin(th/2));\n // Calculate smallest possible loss of area assuming nominal R\n const Amin = Acircle - 6 * Aoverlap;\n // Calculate area lost due to keepout collisions with the selected robot.\n const {G,spacing} = grid;\n const Nblocked = d3.sum(G, g => d3.sum(g.hits, h => h.blocked));\n const dA = spacing ** 2;\n const Ablocked = Nblocked * dA;\n const ratio = Ablocked / Acircle; \n return { Acircle, Amin, Ablocked, Nblocked, ratio };\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":60,"value":"plotOptions = ({size:Math.round(width * 0.75)})","pinned":false,"hidden":false,"mode":"ojs"},{"id":49,"value":"$31","pinned":false,"hidden":false,"mode":"ojs"},{"id":62,"value":"gridOptions = ({\n density: 5, /* pixels per mm */\n pad: 6, /* mm */\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":35,"value":"$32","pinned":false,"hidden":false,"mode":"ojs"},{"id":645,"value":"neighborsIndex = d3.index(neighbors, n => n.DEVICE_ID)","pinned":false,"hidden":false,"mode":"ojs"},{"id":686,"value":"nonfuncNeighbors = neighbors.filter(({NONFUNC}) => NONFUNC)","pinned":false,"hidden":false,"mode":"ojs"},{"id":31,"value":"$33","pinned":false,"hidden":false,"mode":"ojs"},{"id":241,"value":"$34","pinned":false,"hidden":false,"mode":"ojs"},{"id":760,"value":"function findInGroup(posid) {\n let group = null;\n groups.forEach((posids, name) => { if(posids.includes(posid)) group = posids; });\n return group;\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":475,"value":"groups = {\n const {index} = dump;\n const visited = new Set(), groups = [ ];\n function visit(dev, group = new Set()) {\n group.add(dev.DEVICE_ID);\n if(dev.NONFUNC) {\n visited.add(dev.DEVICE_ID);\n const neighbors = dev.NEIGHBORS;\n neighbors.forEach(device_id => {\n if(!visited.has(device_id)) visit(index.get(device_id), group);\n });\n }\n return group;\n }\n index.forEach((dev, DEVICE_ID) => {\n if(!visited.has(DEVICE_ID) && dev.NONFUNC) {\n const group = visit(dev);\n groups.push([...group]);\n }\n });\n return d3.index(groups, g => {\n const dev = index.get(g[0]);\n return `P${dev.PETAL_LOC}-${g[0]}`;\n });\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":750,"value":"expanded = {\n return [...dump.index.values()]\n .filter(\n dev => dev.KEEPOUT_EXPANSION_THETA_RADIAL != 0 || dev.KEEPOUT_EXPANSION_THETA_ANGULAR != 0)\n .map(({DEVICE_ID,KEEPOUT_EXPANSION_THETA_RADIAL,KEEPOUT_EXPANSION_THETA_ANGULAR}) =>\n ({DEVICE_ID,KEEPOUT_EXPANSION_THETA_RADIAL,KEEPOUT_EXPANSION_THETA_ANGULAR}));\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":5,"value":"$35","pinned":false,"hidden":false,"mode":"ojs"},{"id":259,"value":"$36","pinned":false,"hidden":false,"mode":"ojs"},{"id":7,"value":"import {parseECSV} from \"@dkirkby/ecsv\"","pinned":false,"hidden":false,"mode":"ojs"}],"files":"$W37","stdlib":"1","titling":"auto"}