35:null 36:["$","title",null,{"children":"How Terrain Masking Lets Drones Avoid Detection | Benji | Observable"}] 3c:T4c7,The war in Ukraine has shown that drones are becoming an increasingly effective, and rather terrifying tool on the battlefield. While drones have existed in many forms for decades, recent advancements in technology and engineering have made these machines increasingly accessible. Tasks that once required hundreds of thousands, if not millions of dollars in technology and research, can now be done with a few hundred dollars in drone equipment and a bit of know-how. Drones introduce many difficult challenges both offensively and defensively. From autonomously calculating optimal routes to trying to defend against numerous intelligent, highly agile threats, militaries all over the world are pouring billions of dollars into solving these new challenges. While there are countless ways this technology could be used for good, the unfortunate reality is that, like nuclear fission, it is inevitably used as a tool of war. This project models the challenges in detecting small, low-flying aircraft, and how rough terrain can make it increasingly difficult. With the large variation in terrain, the Missoula Valley is a great example of how ridges and valleys can provide hiding places for these new (ish) technologies.3d:T4d8,// control panel controls2 = { const group = (title, hint, ...items) => html`

${title} ${hint ? html`

${hint}

` : ""} ${items}

`; return html`

${group("Flight", "Altitude above ground is the biggest lever: lower = more terrain to hide behind.", viewof altitude2, viewof enduranceLimit2)} ${group("Sensors and detection", "Notional radar: R50 = range where one scan detects half the time.", viewof layoutPreset2, viewof detForm2)} ${group("Routes", "0 = pure least exposure; higher values favour shorter routes.", viewof lengthPenalty2, viewof mapView2)} ${group("Map clicks", "Left map: click to move the goal. Right map: edits whatever is selected here.", viewof editMode2, viewof endpoints2, viewof layout2)}

`; }3e:T681,// the two final visuals, side by side dashboard2 = { const {lit, dark} = shadowStyle; const legend = Plot.legend({ color: { domain: [0, 1], interpolate: (t) => `rgb(${dark.map((v, k) => (v * (1 - t) + lit[k] * t) * 0.85 * (0.25 + 0.75 * t))})`, tickFormat: "%", label: `Chance of detection per km flown at ${altitude2} m AGL (buffer dimmed)` }, width: 320 }); const e = routeEval2, f = (r) => `${(r.length / 1000).toFixed(1)} km, ${r.cumHazard.toFixed(1)} expected detections`; const panel = (title, hint, content) => html`

${title}

${hint}

${content}

`; return html`

${panel("Where safe routes flow", "Particles follow the least-exposure path to the goal (yellow) from everywhere. Click to move the goal.", flowField2)} ${panel(mapView2, `Cyan: terrain-aware route · orange: range-only · dashed: straight. Clicks edit ${editMode2 === "Sensors" ? "sensors (click add, drag move, shift-click remove)" : "route endpoints (start = green, goal = yellow)"}.`, html`${exposureMap2}${legend}

Terrain-aware: ${f(e.terrain)} · Range-only: ${f(e.rangeOnly)} · Straight: ${f(e.straight)}

`)}

`; }3f:T4e6,// cumulative expected detections along each route { const series = [ ["Terrain-aware", routeEval2.terrain], ["Range-only", routeEval2.rangeOnly], ["Straight line", routeEval2.straight] ]; const yMax = d3.max(series, ([, e]) => e.cumHazard) || 1; // symlog is linear below `constant` and logarithmic above it. Scaling it to the // data keeps 0..small from eating the chart whatever the range of values is. const constant = Math.max(0.05, yMax / 30); // 1-2-5 ticks (…, 1, 2, 5, 10, 20, 50, …) spanning the data, plus 0. const ticks = [0, ...d3.range(-2, 6).flatMap((p) => [1, 2, 5].map((m) => m * 10 ** p)) .filter((t) => t >= constant / 2 && t <= yMax * 1.05)]; return Plot.plot({ width: 640, height: 360, x: {label: "Distance flown (km)"}, y: {label: "Cumulative expected detections", type: "symlog", constant, domain: [0, yMax * 1.05], ticks, tickFormat: "f", grid: true}, color: {domain: series.map(([name]) => name), range: ["#3fd8ff", "#ffa03c", "#888"], legend: true}, marks: [ ...series.map(([name, e]) => Plot.line(e.profile.filter((_, i) => i % 10 === 0), {x: (d) => d.d / 1000, y: "cumHazard", stroke: () => name}) ), Plot.ruleY([0]) ] }); }40:Tecb,# Conclusion The safest routes consistently use small-scale low ground (gullies and lee slopes inside rugged hills, not the open main valley), and that advantage is largest for the lowest-flying drones. ## Testing the hypothesis *Ran outside of Observable due to browser computation constraints* \ *Processed using a Ryzen 7600x, 32GB RAM* The test asks the same question over and over: **when a drone takes the safest route, what kind of terrain does that route pass through?** For each test case, the following were chosen: - a random sensor layout (10 different layouts), - a random start and goal inside the area (20 pairs per layout), - a flight altitude (10, 20, 30, 50, 100, 150 or 300 m above ground). Between the same start and goal, three routes were planned: 1. **Terrain-aware:** the safest route, using hills and valleys to hide. 2. **Range-only:** the safest route if terrain couldn't block line of sight, so the drone can only stay far from sensors. 3. **Straight line.** That gives 10 × 20 × 7 = 1,400 cases and 4,200 routes. The key comparison is **terrain-aware vs range-only**: both routes try to avoid sensors, so any difference between them comes from terrain. ### What was measured along each route Three terrain measures were averaged along every route: - **TPI / DEV:** is the route *lower* or *higher* than the ground around it? Negative means lower, like a valley, gully or the lee side of a ridge. DEV is the same idea scaled so that rugged and gentle terrain are comparable. - **Relief:** how much up-and-down there is nearby. High means rugged, low means flat. Each was measured at three different scales to catch certain landscape features: 150 m (small gullies), 500 m (medium valleys) and 1.5 km (large landforms). ### Reading the effect size Effect size answers the following question: did the terrain-aware route sit lower or higher than the range-only route? The effect size (rank-biserial *r*) sums that up on a scale from −1 to +1: - **−1:** the terrain-aware route was lower in every case. - **0:** no consistent difference. - **+1:** higher in every case. ### Finding 1: safe routes hug low, rugged ground (supported) At the 150 m scale: - **TPI/DEV are about −0.75 to −0.89.** Safe routes are almost always lower than their immediate surroundings. - **Relief is about +0.75.** Safe routes almost always pass through more rugged ground. - **This holds everywhere:** at every altitude and in every one of the 10 sensor layouts. To avoid detection, the drone tucks into small dips, gullies and the sheltered sides of ridges. This is the same pattern the "rivers" in the flow field show, now confirmed statistically. ### Finding 2: the benefit shrinks as the drone flies higher (partly supported) | Altitude | Detection avoided compared with range-only | |---|---| | 10 m | 89% | | 50 m | 74% | | 100 m | 65% | | 300 m | 44% | The *direction* stays the same at every height: routes still prefer low ground, even at 300 m. But the *payoff* is smaller, and routes dip less deeply. A drone at 300 m is above most of the folds that could hide it, which is why the ability to fly low makes drones so hard to detect. ### Finding 3: small folds matter, not big valleys (not supported) My hypothesis predicted that the useful terrain scale would grow with altitude: small dips hiding low drones, large valleys hiding higher ones. Instead, **the 150m scale is the strongest at every altitude.** At the 1.5 km scale the sign even flips: safe routes are actually *higher* than their large-scale surroundings. The broad Missoula valley floor is low but flat and wide open, so many sensors can see across it. The safe routes run through the hills around it instead, threading the small gullies within that higher, broken terrain.41:T75d,// map: click to place sensor and view visible areas/shadows shadowMap = { const {width: W, height: H, cell_m: cell, xmin, ymax} = meta; const {deep, lit, dark, outOfRange} = shadowStyle; const hs = layers.hillshade; const sc = (sensor.x - xmin) / cell - 0.5, sr = (ymax - sensor.y) / cell - 0.5; const ctx = DOM.context2d(W, H, 1); const img = ctx.createImageData(W, H), px = img.data; for (let i = 0; i < W * H; i++) { const g = 0.3 + 0.7 * Math.min(Math.max(hs[i], 0), 1); // terrain relief shading const a = minAGL[i]; if (Number.isNaN(a)) { for (let k = 0; k < 3; k++) px[4 * i + k] = outOfRange[k] * g; } else { const d = Math.hypot(i % W - sc, Math.floor(i / W) - sr) * cell / maxRange; const glow = 1 - 0.3 * d * d; // gentle lamp falloff (cosmetic only, for now) const s = Math.sqrt(Math.min(a, deep) / deep); // 0 = lit, 1 = deep shadow const b = g * glow * (1 - 0.75 * s); for (let k = 0; k < 3; k++) px[4 * i + k] = (lit[k] * (1 - s) + dark[k] * s) * b; } px[4 * i + 3] = 255; } ctx.putImageData(img, 0, 0); // Range ring and sensor marker ctx.strokeStyle = "rgba(255,255,255,0.6)"; ctx.beginPath(); ctx.arc(sc + 0.5, sr + 0.5, maxRange / cell, 0, 2 * Math.PI); ctx.stroke(); ctx.fillStyle = "#ff5028"; ctx.strokeStyle = "white"; ctx.lineWidth = 1.5; ctx.beginPath(); ctx.arc(sc + 0.5, sr + 0.5, 5, 0, 2 * Math.PI); ctx.fill(); ctx.stroke(); const canvas = ctx.canvas; canvas.style.cssText = "width: 100%; max-width: 667px; cursor: crosshair"; canvas.onclick = (e) => { const r = canvas.getBoundingClientRect(); viewof sensor.value = { x: xmin + (e.clientX - r.left) / r.width * W * cell, y: ymax - (e.clientY - r.top) / r.height * H * cell }; viewof sensor.dispatchEvent(new Event("input", {bubbles: true})); }; return canvas; }42:T4fc,## Iteration II The visual below turned out pretty good. Zero-detection zones were much less common than I would have thought; however, this doesn't take into account range, only line of sight to any sensor. Detection per-km flown is probably the more useful metric here. Being able to move the sensors around is a nice feature to gain intuition as to what is going on, but I think I prefer the default placements here since they seem more realistic than just throwing a sensor on the side of a mountain. Either way, it's still pretty cool. I'll be honest, I had to play around with the sensor placement a bit to figure out if my code was actually doing what I wanted it to, and I believe it does. This is one nice aspect of the adjustable sensor locations, but it might be hard for an unfamiliar reader to understand exactly what is going on. I'll have to keep this in mind for my final visual to ensure everything is as intuitive as it can be, given the complexity of what is going on. Will definitely need a legend, and maybe a small writeup that describes what the data is showing. Now that the area is mapped out and we have a *somewhat* optimal sensor array, we can start on the least-exposure routing. This is where the hypothesis will finally start getting tested.43:Tb16,// interactive exposure map exposureMap = { const {width: W, height: H, cell_m: cell, xmin, ymax} = meta; const {deep, lit, dark, outOfRange} = shadowStyle; const hs = layers.hillshade, detect = mapView === "Detection per km flown"; const ctx = DOM.context2d(W, H, 1); const img = ctx.createImageData(W, H), px = img.data; for (let i = 0; i < W * H; i++) { const g = 0.3 + 0.7 * Math.min(Math.max(hs[i], 0), 1); if (detect) { const t = 1 - Math.exp(-1000 * hazard[i]); // P(detected per km flown): 0 = dark, 1 = lit const b = g * (0.25 + 0.75 * t); for (let k = 0; k < 3; k++) px[4 * i + k] = (dark[k] * (1 - t) + lit[k] * t) * b; } else { const a = coverMinAGL[i]; if (Number.isNaN(a)) { for (let k = 0; k < 3; k++) px[4 * i + k] = outOfRange[k] * g; } else { const s = Math.sqrt(Math.min(a, deep) / deep); const b = g * (1 - 0.75 * s); for (let k = 0; k < 3; k++) px[4 * i + k] = (lit[k] * (1 - s) + dark[k] * s) * b; } } px[4 * i + 3] = 255; } ctx.putImageData(img, 0, 0); ctx.fillStyle = "#ff5028"; ctx.strokeStyle = "white"; ctx.lineWidth = 1.5; for (const s of layout) { ctx.beginPath(); ctx.arc((s.x - xmin) / cell, (ymax - s.y) / cell, 5, 0, 2 * Math.PI); ctx.fill(); ctx.stroke(); } // Editing: click empty map to add a sensor, drag a sensor to move, shift-click a sensor to remove. const canvas = ctx.canvas; canvas.style.cssText = "width: 100%; max-width: 667px; cursor: crosshair; touch-action: none"; const clamp = (v, lo, hi) => Math.min(Math.max(v, lo), hi); const toXY = (e) => { const r = canvas.getBoundingClientRect(); return { x: clamp(xmin + (e.clientX - r.left) / r.width * W * cell, xmin, xmin + W * cell - 1), y: clamp(ymax - (e.clientY - r.top) / r.height * H * cell, ymax - H * cell + 1, ymax) }; }; const hitRadius = () => 8 * W * cell / canvas.getBoundingClientRect().width; // 8 screen px in metres const hit = (p) => layout.findIndex((s) => Math.hypot(s.x - p.x, s.y - p.y) < hitRadius()); const commit = (value) => { viewof layout.value = value; viewof layout.dispatchEvent(new Event("input", {bubbles: true})); }; let drag = -1; canvas.onpointerdown = (e) => { const p = toXY(e), i = hit(p); if (i < 0) return commit([...layout, p]); if (e.shiftKey) return commit(layout.filter((_, j) => j !== i)); drag = i; canvas.setPointerCapture(e.pointerId); canvas.style.cursor = "grabbing"; }; canvas.onpointerup = (e) => { if (drag < 0) return; const p = toXY(e), i = drag; drag = -1; canvas.style.cursor = "crosshair"; if (Math.hypot(p.x - layout[i].x, p.y - layout[i].y) > hitRadius() / 4) { commit(layout.map((s, j) => (j === i ? p : s))); } }; return canvas; }44:T60d,## Iteration III This looks great, but there's one problem. Because of the layout of the sensors, the least-exposure path follows the unseen regions more than the topography. There's nothing inherently wrong with this, and it is realistic assuming the attacker knows where the sensors are, but the hypothesis states "in a region watched by line-of-sight sensors" and gaps between coverage mean some area isn't being watched. Also, because we only place sensors inside of the AOI, the path will hug the edges of the AOI since they are technically the farthest from any sensor (there are no sensors outside of the AOI). How can we handle this? For the coverage gaps, we can simply increase the default R50 to 3km and set the max range to 2.5 x R50 while still maintaining realistic detection dropoff. Of course, placing more sensors could do the trick, but that would always make detection easier, and resources are not unlimited. This would also present the problem of increased lines-of-sight, not just increasing coverage radius. Increasing R50 and max range only eliminates the coverage gaps without giving the defender access to however many sensors they want. To deal with the edge preference, we have to take a different approach. We expand the domain beyond the AOI and do exactly what I proposed not doing earlier; we add more sensors. However, we only add sensors outside of the AOI in order to account for the edge preference, we don't actually increase the detection within the AOI. We add 18 new sensors outside of the AOI to do this.45:Tfcd,// exposure map with routes plotted over top exposureMap1 = { const {width: W, height: H, cell_m: cell, xmin, ymax} = meta; const {deep, lit, dark, outOfRange} = shadowStyle; const hs = layers.hillshade, detect = mapView === "Detection per km flown"; const ctx = DOM.context2d(W, H, 1); const img = ctx.createImageData(W, H), px = img.data; for (let i = 0; i < W * H; i++) { const g = 0.3 + 0.7 * Math.min(Math.max(hs[i], 0), 1); if (detect) { const t = 1 - Math.exp(-1000 * hazard[i]); // P(detected per km flown): 0 = dark, 1 = lit const b = g * (0.25 + 0.75 * t); for (let k = 0; k < 3; k++) px[4 * i + k] = (dark[k] * (1 - t) + lit[k] * t) * b; } else { const a = coverMinAGL[i]; if (Number.isNaN(a)) { for (let k = 0; k < 3; k++) px[4 * i + k] = outOfRange[k] * g; } else { const s = Math.sqrt(Math.min(a, deep) / deep); const b = g * (1 - 0.75 * s); for (let k = 0; k < 3; k++) px[4 * i + k] = (lit[k] * (1 - s) + dark[k] * s) * b; } } px[4 * i + 3] = 255; } ctx.putImageData(img, 0, 0); // Routes (canvas pixel = cell). const cx = (x) => (x - xmin) / cell, cy = (y) => (ymax - y) / cell; const {start, goal} = endpoints; ctx.setLineDash([6, 4]); ctx.strokeStyle = "rgba(255,255,255,0.8)"; ctx.lineWidth = 1.5; ctx.beginPath(); ctx.moveTo(cx(start.x), cy(start.y)); ctx.lineTo(cx(goal.x), cy(goal.y)); ctx.stroke(); ctx.setLineDash([]); const pts = bestRoute.points; for (const [w, color] of [[4.5, "rgba(0,0,0,0.6)"], [2.5, "#3fd8ff"]]) { ctx.lineWidth = w; ctx.strokeStyle = color; ctx.lineJoin = "round"; ctx.beginPath(); pts.forEach(([x, y], k) => (k ? ctx.lineTo(cx(x), cy(y)) : ctx.moveTo(cx(x), cy(y)))); ctx.stroke(); } // Sensors and endpoints. ctx.fillStyle = "#ff5028"; ctx.strokeStyle = "white"; ctx.lineWidth = 1.5; for (const s of layout) { ctx.beginPath(); ctx.arc(cx(s.x), cy(s.y), 5, 0, 2 * Math.PI); ctx.fill(); ctx.stroke(); } for (const [p, color] of [[start, "#3ddc84"], [goal, "#ffd23f"]]) { ctx.fillStyle = color; ctx.strokeStyle = "black"; ctx.fillRect(cx(p.x) - 5, cy(p.y) - 5, 10, 10); ctx.strokeRect(cx(p.x) - 5, cy(p.y) - 5, 10, 10); } // Editing. Sensors mode: click empty map to add, drag to move, shift-click to remove. // Route endpoints mode: click sets start, then goal, alternately. const canvas = ctx.canvas; canvas.style.cssText = "width: 100%; max-width: 667px; cursor: crosshair; touch-action: none"; const clamp = (v, lo, hi) => Math.min(Math.max(v, lo), hi); const toXY = (e) => { const r = canvas.getBoundingClientRect(); return { x: clamp(xmin + (e.clientX - r.left) / r.width * W * cell, xmin, xmin + W * cell - 1), y: clamp(ymax - (e.clientY - r.top) / r.height * H * cell, ymax - H * cell + 1, ymax) }; }; const hitRadius = () => 8 * W * cell / canvas.getBoundingClientRect().width; const hit = (p) => layout.findIndex((s) => Math.hypot(s.x - p.x, s.y - p.y) < hitRadius()); const commit = (view, value) => { view.value = value; view.dispatchEvent(new Event("input", {bubbles: true})); }; let drag = -1; canvas.onpointerdown = (e) => { const p = toXY(e); if (editMode === "Route endpoints") { const el = viewof endpoints, which = el.next; el.next = which === "start" ? "goal" : "start"; return commit(el, {...endpoints, [which]: p}); } const i = hit(p); if (i < 0) return commit(viewof layout, [...layout, p]); if (e.shiftKey) return commit(viewof layout, layout.filter((_, j) => j !== i)); drag = i; canvas.setPointerCapture(e.pointerId); canvas.style.cursor = "grabbing"; }; canvas.onpointerup = (e) => { if (drag < 0) return; const p = toXY(e), i = drag; drag = -1; canvas.style.cursor = "crosshair"; if (Math.hypot(p.x - layout[i].x, p.y - layout[i].y) > hitRadius() / 4) { commit(viewof layout, layout.map((s, j) => (j === i ? p : s))); } }; return canvas; }46:T44f,// new sensor layout, similar to before viewof layout2 = { const el = html`

`; // Highest point in the central 60% of each block: the 12 AOI blocks from // iteration 1 plus a ring of 5 km buffer blocks (UTM 12N m). el.value = [ [263625, 5207115], [268605, 5207445], [273615, 5205495], [278385, 5207595], [280635, 5207325], [288495, 5206545], [263625, 5202165], [267675, 5202105], [272445, 5201265], [278475, 5202255], [281805, 5202255], [286365, 5201985], [260925, 5191695], [268605, 5194065], [273615, 5192505], [276705, 5192985], [283635, 5194485], [286905, 5193795], [261315, 5185485], [268605, 5187105], [273135, 5187465], [278085, 5184945], [281085, 5185245], [285645, 5185965], [260625, 5179785], [268485, 5182575], [273405, 5181885], [278625, 5182065], [282195, 5182425], [287295, 5179575] ].map(([x, y]) => ({x, y})); const show = () => el.textContent = `${el.value.length} sensors (faded = buffer). Sensors mode: click to add, drag to move, shift-click to remove.`; show(); el.addEventListener("input", show); return el; }47:T438,// comparison table { const fmtP = (p) => (p < 1e-4 ? p.toExponential(1) : (100 * p).toFixed(1) + "%"); const row = (name, e) => `| ${name} | ${(e.length / 1000).toFixed(1)} km | ${(100 * e.outside).toFixed(0)}% | ${e.cumHazard.toFixed(2)} | ${fmtP(e.pSurvive)} |`; const {limit} = routes2; const limitNote = !limit ? "Endurance limit off." : `Endurance limit on: max ${(limit.maxLength / 1000).toFixed(1)} km. ` + `Binding for terrain-aware: ${limit.terrainBinding ? "yes" : "no"}; range-only: ${limit.rangeOnlyBinding ? "yes" : "no"}.`; return md`At **${altitude2} m AGL**, R50 ${detParams2.r50} m (max range ${2.5 * detParams2.r50} m), all routes scored on the terrain-aware hazard. ${limitNote} | Route | Length | In buffer | Expected detections | P(survive undetected) | |---|---|---|---|---| ${row("Terrain-aware least exposure", routeEval2.terrain)} ${row("Range-only least exposure (control)", routeEval2.rangeOnly)} ${row("Straight line", routeEval2.straight)} The gap between the first two rows is what terrain adds once range is accounted for.`; }48:T44b,## Iteration IV This is a great visual, I think this will be the final iteration of this visual. It incorporates all the above techniques into a clear visual that shows two paths. The blue represents the absolute least-detection path, while the orange path ignores terrain and only focuses on staying as far from the sensors as possible. The fact that these paths are almost always different shows that terrain-masking absolutely does effect detection probability. Regarding my hypothesis, the truth really depends on your starting and ending points. Paths that must travel through open terrain have no choice but to stay as far from the sensors as possible, while paths that travel through rough terrain have the ability to hide in valleys and the leesides of ridges. This shows that my hypothesis is true, to an extent. There are times where it applies heavily, and times where it does not apply at all. There is only one step left, and that is to create a flow field. I'm not sure if it will run in observable, but we'll see. I think such a visual would show some extremely intersting results.49:T1066,// new map with extra domain buffer exposureMap2 = { const {width: W, height: H, cell_m: cell, xmin, ymax, aoi} = meta2; const {lit, dark} = shadowStyle; const hs = layers2.hillshade, h = mapView2 === "Terrain-aware detection" ? hazard2 : hazardRangeOnly2; const ctx = DOM.context2d(W, H, 1); const img = ctx.createImageData(W, H), px = img.data; for (let i = 0; i < W * H; i++) { const c = i % W, r = (i - c) / W; const inAOI = c >= aoi.col && c < aoi.col + aoi.size && r >= aoi.row && r < aoi.row + aoi.size; const g = 0.3 + 0.7 * Math.min(Math.max(hs[i], 0), 1); const t = 1 - Math.exp(-1000 * h[i]); // P(detected per km flown) const b = g * (0.25 + 0.75 * t) * (inAOI ? 1 : 0.55); // buffer dimmed for (let k = 0; k < 3; k++) px[4 * i + k] = (dark[k] * (1 - t) + lit[k] * t) * b; px[4 * i + 3] = 255; } ctx.putImageData(img, 0, 0); const cx = (x) => (x - xmin) / cell, cy = (y) => (ymax - y) / cell; ctx.strokeStyle = "white"; ctx.lineWidth = 1.5; ctx.strokeRect(aoi.col, aoi.row, aoi.size, aoi.size); // Routes: straight (dashed), range-only (orange), terrain-aware (cyan). const {start, goal} = endpoints2; ctx.setLineDash([6, 4]); ctx.strokeStyle = "rgba(255,255,255,0.8)"; ctx.beginPath(); ctx.moveTo(cx(start.x), cy(start.y)); ctx.lineTo(cx(goal.x), cy(goal.y)); ctx.stroke(); ctx.setLineDash([]); for (const [pts, color] of [[routes2.rangeOnly, "#ffa03c"], [routes2.terrain, "#3fd8ff"]]) { for (const [w, c] of [[4.5, "rgba(0,0,0,0.6)"], [2.5, color]]) { ctx.lineWidth = w; ctx.strokeStyle = c; ctx.lineJoin = "round"; ctx.beginPath(); pts.forEach(([x, y], k) => (k ? ctx.lineTo(cx(x), cy(y)) : ctx.moveTo(cx(x), cy(y)))); ctx.stroke(); } } // Sensors (buffer ones faded), then endpoints. ctx.strokeStyle = "white"; ctx.lineWidth = 1.5; for (const s of layout2) { const inside = s.x >= aoi.xmin && s.x <= aoi.xmax && s.y >= aoi.ymin && s.y <= aoi.ymax; ctx.fillStyle = inside ? "#ff5028" : "rgba(255,80,40,0.55)"; ctx.beginPath(); ctx.arc(cx(s.x), cy(s.y), 5, 0, 2 * Math.PI); ctx.fill(); ctx.stroke(); } for (const [p, color] of [[start, "#3ddc84"], [goal, "#ffd23f"]]) { ctx.fillStyle = color; ctx.strokeStyle = "black"; ctx.fillRect(cx(p.x) - 5, cy(p.y) - 5, 10, 10); ctx.strokeRect(cx(p.x) - 5, cy(p.y) - 5, 10, 10); } // Editing (same gestures as iteration 1). Endpoints are clamped to the AOI. const canvas = ctx.canvas; canvas.style.cssText = "width: 100%; max-width: 800px; cursor: crosshair; touch-action: none"; const clamp = (v, lo, hi) => Math.min(Math.max(v, lo), hi); const toXY = (e, box) => { const r = canvas.getBoundingClientRect(); return { x: clamp(xmin + (e.clientX - r.left) / r.width * W * cell, box.xmin, box.xmax - 1), y: clamp(ymax - (e.clientY - r.top) / r.height * H * cell, box.ymin + 1, box.ymax) }; }; const domainBox = {xmin, xmax: xmin + W * cell, ymin: ymax - H * cell, ymax}; const hitRadius = () => 8 * W * cell / canvas.getBoundingClientRect().width; const hit = (p) => layout2.findIndex((s) => Math.hypot(s.x - p.x, s.y - p.y) < hitRadius()); const commit = (view, value) => { view.value = value; view.dispatchEvent(new Event("input", {bubbles: true})); }; let drag = -1; canvas.onpointerdown = (e) => { if (editMode2 === "Route endpoints") { const el = viewof endpoints2, which = el.next; el.next = which === "start" ? "goal" : "start"; return commit(el, {...endpoints2, [which]: toXY(e, aoi)}); } const p = toXY(e, domainBox), i = hit(p); if (i < 0) return commit(viewof layout2, [...layout2, p]); if (e.shiftKey) return commit(viewof layout2, layout2.filter((_, j) => j !== i)); drag = i; canvas.setPointerCapture(e.pointerId); canvas.style.cursor = "grabbing"; }; canvas.onpointerup = (e) => { if (drag < 0) return; const p = toXY(e, domainBox), i = drag; drag = -1; canvas.style.cursor = "crosshair"; if (Math.hypot(p.x - layout2[i].x, p.y - layout2[i].y) > hitRadius() / 4) { commit(viewof layout2, layout2.map((s, j) => (j === i ? p : s))); } }; return canvas; }4a:Ta43,// sensor layout presets (writes into layout2; manual edits still work afterwards) // High ground = highest point in the central 60% of each block (the iteration 2 default). // Randomized = a random cell among the top 20% of elevations in each block, the rule and // seeds of prep/hypothesis_batch.mjs: random layouts 0-9 are exactly the batch's layouts. viewof layoutPreset2 = { const {width: W, height: H, cell_m: cell, xmin, ymax, aoi} = meta2, dem = layers2.dem; const B = aoi.col, A = aoi.size; const colEdges = [0, B, B + Math.floor(A / 4), B + Math.floor(A / 2), B + Math.floor(3 * A / 4), B + A, W]; const rowEdges = [0, B, B + Math.floor(A / 3), B + Math.floor(2 * A / 3), B + A, H]; const blocks = []; // cells of each block's central 60%, highest first for (let j = 0; j < rowEdges.length - 1; j++) for (let i = 0; i < colEdges.length - 1; i++) { const c0 = colEdges[i], c1 = colEdges[i + 1], r0 = rowEdges[j], r1 = rowEdges[j + 1]; const mc = Math.floor((c1 - c0) / 5), mr = Math.floor((r1 - r0) / 5), cells = []; for (let r = r0 + mr; r < r1 - mr; r++) for (let c = c0 + mc; c < c1 - mc; c++) cells.push(r * W + c); blocks.push(cells.sort((a, b) => dem[b] - dem[a])); } const toXY = (k) => ({x: xmin + (k % W + 0.5) * cell, y: ymax - (Math.floor(k / W) + 0.5) * cell}); const rng = (seed) => () => ((seed = (seed + 0x6D2B79F5) | 0), (((seed ^ (seed >>> 15)) * (1 | seed)) >>> 0) / 2 ** 32); const highGround = () => blocks.map((cells) => toXY(cells[0])); const randomized = (n) => { const rand = rng(1000 + n); return blocks.map((cells) => toXY(cells[Math.floor(rand() * Math.ceil(0.2 * cells.length))])); }; const select = html``; const button = html``; const el = html`

Sensor layout${select}${button}

WARNING: recomputing sensors takes time

`; let n = 0; const apply = (preset) => { el.value = {preset, n}; viewof layout2.value = preset === "high" ? highGround() : randomized(n); viewof layout2.dispatchEvent(new Event("input", {bubbles: true})); }; select.onchange = () => apply(select.value); button.onclick = () => { if (select.value === "random") n++; select.value = "random"; apply("random"); }; el.value = {preset: "high", n}; return el; }4b:T456,// testing hideable area given our new additions Plot.plot({ width: 760, height: 280, marginRight: 20, fx: {label: "Flight altitude (m AGL)"}, x: {label: "Per-scan R50 (m)", ticks: 4}, y: {label: "Share of AOI with < 50% detection per km", tickFormat: "%", grid: true}, color: { domain: ["range_gap", "all_dark", "edge_strip_dark"], range: ["#ffa03c", "#3f6fd8", "#c0392b"], tickFormat: (m) => ({range_gap: "Range gaps (no terrain)", all_dark: "All dark (with terrain)", edge_strip_dark: "Dark within 1.5 km of AOI edge"})[m], legend: true }, marks: [ Plot.line(gapData2.filter((d) => d.config === "Buffered domain"), {fx: "altitude", x: "r50", y: "value", stroke: "metric", strokeWidth: 2}), Plot.line(gapData2.filter((d) => d.config === "AOI only"), {fx: "altitude", x: "r50", y: "value", stroke: "metric", strokeDasharray: "4,3"}), Plot.ruleX([detParams2.r50], {stroke: "#999", strokeDasharray: "2,2"}), Plot.ruleY([0]) ], caption: "Solid: buffered domain (iteration 2, 30 sensors). Dashed: AOI only (iteration 1, 12 sensors). Max range = 2.5 x R50." })4c:Tb9a,// checking low altitude flight against higher resolution DEMs outside of this notebook // to see how much of an effect our 30m raster choice has against the original 10m raster // 'ramp' is basically how far above the horizon something has to be to be detected // it is a soft edge at the terrain-masking line that models grazing-angle signal loss lowAltitudeChecks = { const data = await FileAttachment("low_altitude_checks.csv").csv({typed: true}); const series = [ {name: "30 m DEM, ramp 0 m", check: "ramp", setting: 0}, {name: "30 m DEM, ramp 10 m", check: "ramp", setting: 10}, {name: "30 m DEM, ramp 20 m (default)", check: "ramp", setting: 20}, {name: "30 m DEM, ramp 40 m", check: "ramp", setting: 40}, {name: "10 m DEM, ramp 20 m", check: "dem", setting: "10 m"} ]; const colors = ["#9ecae1", "#6baed6", "#2171b5", "#08306b", "#e6550d"]; const rowsFor = (s, metric) => data.filter((d) => d.check === s.check && d.setting === s.setting && d.metric === metric); const dark = series.flatMap((s) => rowsFor(s, "dark_frac").map((d) => ({series: s.name, altitude: d.altitude, value: d.value}))); const saving = series.flatMap((s) => d3.groups(rowsFor(s, "saving"), (d) => d.altitude).map(([altitude, v]) => { const x = v.map((d) => d.value).sort(d3.ascending); return {series: s.name, altitude, median: d3.quantileSorted(x, 0.5), q1: d3.quantileSorted(x, 0.25), q3: d3.quantileSorted(x, 0.75)}; })); const common = { width: 380, height: 280, x: {label: "Flight altitude (m AGL)", type: "log", ticks: [10, 20, 30, 50, 100], tickFormat: "d"}, color: {domain: series.map((s) => s.name), range: colors}, }; const dash = (s) => (s.startsWith("10 m") ? "5,3" : null); const panel = (opts, marks) => Plot.plot({...common, ...opts, marks}); const left = panel({y: {label: "Dark share of AOI", tickFormat: "%", grid: true, domain: [0, null]}}, [ ...series.map((s) => Plot.line(dark.filter((d) => d.series === s.name), {x: "altitude", y: "value", stroke: "series", strokeDasharray: dash(s.name), marker: "dot"})), Plot.ruleY([0]) ]); const right = panel({y: {label: "Terrain saving vs range-only (median, IQR)", tickFormat: "%", grid: true}}, [ ...series.map((s) => Plot.ruleX(saving.filter((d) => d.series === s.name), {x: "altitude", y1: "q1", y2: "q3", stroke: "series", strokeOpacity: 0.35, strokeWidth: 6})), ...series.map((s) => Plot.line(saving.filter((d) => d.series === s.name), {x: "altitude", y: "median", stroke: "series", strokeDasharray: dash(s.name), marker: "dot"})), Plot.ruleY([0]) ]); return html`

${Plot.legend({color: common.color, columns: 3})}

${left}${right}

Robustness of the low-altitude results to the clearance-ramp width and DEM resolution. Iteration 4 setup, 10 random AOI start-goal pairs, endurance limit 2×.

`; }4d:T105c,// flow field, explanation is below the visual flowField2 = { const {width: W, height: H, cell_m: cell, xmin, ymax, aoi} = meta2; const {lit, dark} = shadowStyle; const {goal} = endpoints2; const goalIndex = Math.floor((ymax - goal.y) / cell) * W + Math.floor((goal.x - xmin) / cell); const {prev} = route.dijkstra(hazard2, meta2, goalIndex, {lengthPenalty: routes2.terrainPenalty}); // Background: dimmed exposure map, AOI outline, sensors, goal (drawn once). const bg = DOM.context2d(W, H, 1); const img = bg.createImageData(W, H), px = img.data, hs = layers2.hillshade; for (let i = 0; i < W * H; i++) { const c = i % W, r = (i - c) / W; const inAOI = c >= aoi.col && c < aoi.col + aoi.size && r >= aoi.row && r < aoi.row + aoi.size; const g = 0.3 + 0.7 * Math.min(Math.max(hs[i], 0), 1); const t = 1 - Math.exp(-1000 * hazard2[i]); const b = g * (0.25 + 0.75 * t) * (inAOI ? 0.55 : 0.35); for (let k = 0; k < 3; k++) px[4 * i + k] = (dark[k] * (1 - t) + lit[k] * t) * b; px[4 * i + 3] = 255; } bg.putImageData(img, 0, 0); const cx = (x) => (x - xmin) / cell, cy = (y) => (ymax - y) / cell; bg.strokeStyle = "rgba(255,255,255,0.6)"; bg.lineWidth = 1; bg.strokeRect(aoi.col, aoi.row, aoi.size, aoi.size); bg.fillStyle = "#ff5028"; bg.strokeStyle = "white"; for (const s of layout2) { bg.beginPath(); bg.arc(cx(s.x), cy(s.y), 4, 0, 2 * Math.PI); bg.fill(); bg.stroke(); } bg.fillStyle = "#ffd23f"; bg.strokeStyle = "black"; bg.fillRect(cx(goal.x) - 6, cy(goal.y) - 6, 12, 12); bg.strokeRect(cx(goal.x) - 6, cy(goal.y) - 6, 12, 12); // Particles: positions in cell units (cell centres at +0.5), following next-hop pointers. const N = 4000, MAX_AGE = 500, SPEED = 1.2; // SPEED in cells per frame const pX = new Float32Array(N), pY = new Float32Array(N), pCell = new Int32Array(N), pAge = new Int32Array(N); const spawn = (k) => { const i = Math.floor(Math.random() * W * H), c = i % W; pCell[k] = i; pX[k] = c + 0.5; pY[k] = (i - c) / W + 0.5; pAge[k] = Math.floor(Math.random() * MAX_AGE); }; for (let k = 0; k < N; k++) spawn(k); const ctx = DOM.context2d(W, H, 1); ctx.drawImage(bg.canvas, 0, 0); let raf; const frame = () => { ctx.globalAlpha = 0.06; // fade old trails back toward the background ctx.drawImage(bg.canvas, 0, 0); ctx.globalAlpha = 1; ctx.strokeStyle = "rgba(63,216,255,0.9)"; ctx.lineWidth = 1.2; ctx.beginPath(); for (let k = 0; k < N; k++) { const next = prev[pCell[k]]; if (next < 0 || ++pAge[k] > MAX_AGE) { spawn(k); continue; } const nc = next % W, tx = nc + 0.5, ty = (next - nc) / W + 0.5; const dx = tx - pX[k], dy = ty - pY[k], d = Math.hypot(dx, dy); ctx.moveTo(pX[k], pY[k]); if (d <= SPEED) { pX[k] = tx; pY[k] = ty; pCell[k] = next; } else { pX[k] += dx / d * SPEED; pY[k] += dy / d * SPEED; } ctx.lineTo(pX[k], pY[k]); } ctx.stroke(); raf = requestAnimationFrame(frame); }; frame(); invalidation.then(() => cancelAnimationFrame(raf)); // Click to move the goal (clamped to the AOI). const canvas = ctx.canvas; canvas.style.cssText = "width: 100%; max-width: 800px; cursor: crosshair; display: block"; canvas.onclick = (e) => { const r = canvas.getBoundingClientRect(), clamp = (v, lo, hi) => Math.min(Math.max(v, lo), hi); const g = { x: clamp(xmin + (e.clientX - r.left) / r.width * W * cell, aoi.xmin, aoi.xmax - 1), y: clamp(ymax - (e.clientY - r.top) / r.height * H * cell, aoi.ymin + 1, aoi.ymax) }; viewof endpoints2.value = {...endpoints2, goal: g}; viewof endpoints2.dispatchEvent(new Event("input", {bubbles: true})); }; return html`

${canvas}

Optimal headings toward the goal (yellow) from every cell at ${altitude2} m AGL. Particles follow the least-exposure path from wherever they start; bright streams are corridors many optimal routes share. ${enduranceLimit2 ? "Distance penalty from the endurance limit." : "No endurance limit: at low altitude, paths may detour far around the sensor network."} Click to move the goal.

`; }4e:Ted3,## Testing the hypothesis *Ran outside of Observable due to browser computation constraints* \ *Processed using a Ryzen 7600x, 32GB RAM* The test asks the same question over and over: **when a drone takes the safest route, what kind of terrain does that route pass through?** For each test case, the following were chosen: - a random sensor layout (10 different layouts), - a random start and goal inside the area (20 pairs per layout), - a flight altitude (10, 20, 30, 50, 100, 150 or 300 m above ground). Between the same start and goal, three routes were planned: 1. **Terrain-aware:** the safest route, using hills and valleys to hide. 2. **Range-only:** the safest route if terrain couldn't block line of sight, so the drone can only stay far from sensors. 3. **Straight line.** That gives 10 × 20 × 7 = 1,400 cases and 4,200 routes. The key comparison is **terrain-aware vs range-only**: both routes try to avoid sensors, so any difference between them comes from terrain. ### What was measured along each route Three terrain measures were averaged along every route: - **TPI / DEV:** is the route *lower* or *higher* than the ground around it? Negative means lower, like a valley, gully or the lee side of a ridge. DEV is the same idea scaled so that rugged and gentle terrain are comparable. - **Relief:** how much up-and-down there is nearby. High means rugged, low means flat. Each was measured at three different scales to catch certain landscape features: 150 m (small gullies), 500 m (medium valleys) and 1.5 km (large landforms). ### Reading the effect size Effect size answers the following question: did the terrain-aware route sit lower or higher than the range-only route? The effect size (rank-biserial *r*) sums that up on a scale from −1 to +1: - **−1:** the terrain-aware route was lower in every case. - **0:** no consistent difference. - **+1:** higher in every case. ### Finding 1: safe routes hug low, rugged ground (supported) At the 150 m scale: - **TPI/DEV are about −0.75 to −0.89.** Safe routes are almost always lower than their immediate surroundings. - **Relief is about +0.75.** Safe routes almost always pass through more rugged ground. - **This holds everywhere:** at every altitude and in every one of the 10 sensor layouts. To avoid detection, the drone tucks into small dips, gullies and the sheltered sides of ridges. This is the same pattern the "rivers" in the flow field show, now confirmed statistically. ### Finding 2: the benefit shrinks as the drone flies higher (partly supported) | Altitude | Detection avoided compared with range-only | |---|---| | 10 m | 89% | | 50 m | 74% | | 100 m | 65% | | 300 m | 44% | The *direction* stays the same at every height: routes still prefer low ground, even at 300 m. But the *payoff* is smaller, and routes dip less deeply. A drone at 300 m is above most of the folds that could hide it, which is why the ability to fly low makes drones so hard to detect. ### Finding 3: small folds matter, not big valleys (not supported) My hypothesis predicted that the useful terrain scale would grow with altitude: small dips hiding low drones, large valleys hiding higher ones. Instead, **the 150 m scale is the strongest at every altitude.** At the 1.5 km scale the sign even flips: safe routes are actually *higher* than their large-scale surroundings. The broad Missoula valley floor is low but flat and wide open, so many sensors can see across it. The safe routes run through the hills around it instead, threading the small gullies within that higher, broken terrain. ### In one sentence The safest routes consistently use small-scale low ground (gullies and lee slopes inside rugged hills, not the open main valley), and that advantage is largest for the lowest-flying drones.4f:[{"id":"61710dc7e8fd479cc805b4e0970008803591596f31e39b461211dfe92db7d95b278ca0befa90afaf96a3679c7a4492ff1a21d75d1e9ccfe6111b8f1fb5452598","href":"https://static.observableusercontent.com/files/61710dc7e8fd479cc805b4e0970008803591596f31e39b461211dfe92db7d95b278ca0befa90afaf96a3679c7a4492ff1a21d75d1e9ccfe6111b8f1fb5452598","name":"dem.f32","type":"application/octet-stream","lastModified":1792303383186,"size":1779556},{"id":"b831c8a3e56401f3d22a2584234aba535b474e6905bdb25f085793dcf535d4c92a47d1b3f141c236053902e2c112339c3b46245a2bf004e9e9d91d5b12387fd2","href":"https://static.observableusercontent.com/files/b831c8a3e56401f3d22a2584234aba535b474e6905bdb25f085793dcf535d4c92a47d1b3f141c236053902e2c112339c3b46245a2bf004e9e9d91d5b12387fd2","name":"dem.tif","type":"image/tiff","lastModified":1792303263390,"size":2359974},{"id":"05f51baa843ab161a78cdcb9089d022428ab05d599a3da2a492ed946e66cdb00ec3a712e4d1769e45b408d93083df409177307ba75c24d1075fc36f3bf7db771","href":"https://static.observableusercontent.com/files/05f51baa843ab161a78cdcb9089d022428ab05d599a3da2a492ed946e66cdb00ec3a712e4d1769e45b408d93083df409177307ba75c24d1075fc36f3bf7db771","name":"dev_150.f32","type":"application/octet-stream","lastModified":1792303383187,"size":1779556},{"id":"67302cfdd740718764f16abc75297a96467794b1851a98779f856d611f17643c78b069c4915da0b71ac89d62de098a80ac1a7fd335716f06bc51c36423a8b1b4","href":"https://static.observableusercontent.com/files/67302cfdd740718764f16abc75297a96467794b1851a98779f856d611f17643c78b069c4915da0b71ac89d62de098a80ac1a7fd335716f06bc51c36423a8b1b4","name":"dev_500.f32","type":"application/octet-stream","lastModified":1792303383187,"size":1779556},{"id":"14fc9f3d6702a9ef170dc8f0033e7f29876a2cec7cf3de950074834416789eda80566cf6a24103f25783b6a81b0b576f32dc4e70e4e76f6617144892a6812a4f","href":"https://static.observableusercontent.com/files/14fc9f3d6702a9ef170dc8f0033e7f29876a2cec7cf3de950074834416789eda80566cf6a24103f25783b6a81b0b576f32dc4e70e4e76f6617144892a6812a4f","name":"dev_1500.f32","type":"application/octet-stream","lastModified":1792303383188,"size":1779556},{"id":"9d97f1b33204d910d36edccdeea2f442747575e3bc87293f054a087848a3bb0900c766cfbc9d97278a05c2d474a867437677f104ddd28fd26716ec67ecca176c","href":"https://static.observableusercontent.com/files/9d97f1b33204d910d36edccdeea2f442747575e3bc87293f054a087848a3bb0900c766cfbc9d97278a05c2d474a867437677f104ddd28fd26716ec67ecca176c","name":"hillshade.f32","type":"application/octet-stream","lastModified":1792303383188,"size":1779556},{"id":"1fe4133f3e9149c337d71fe5427650fe47f1917f331d292eb0868439128a268b8901e3a23302fe402141500fc5a66a4b2a2ce5421d1c427912f01e2a3d6886b3","href":"https://static.observableusercontent.com/files/1fe4133f3e9149c337d71fe5427650fe47f1917f331d292eb0868439128a268b8901e3a23302fe402141500fc5a66a4b2a2ce5421d1c427912f01e2a3d6886b3","name":"meta.json","type":"application/json","lastModified":1792303263617,"size":1838},{"id":"ac092a5adcb8253204bf00ea71eaaa7c049f884866e57adddd1466baf988f7fce088a96d4c28bef1e68174b9161c00488e1b8f4d010e372b82dc091e08c5f3a8","href":"https://static.observableusercontent.com/files/ac092a5adcb8253204bf00ea71eaaa7c049f884866e57adddd1466baf988f7fce088a96d4c28bef1e68174b9161c00488e1b8f4d010e372b82dc091e08c5f3a8","name":"relief_150.f32","type":"application/octet-stream","lastModified":1792303383188,"size":1779556},{"id":"7abbcf35753dc3324341d8ab77d63e28bbc010fcd6f2ccf5d5c27ba7b24688889ad84dc8f5148bdf54be62155aaefd616058f67c85f87290585c959f207ff9ee","href":"https://static.observableusercontent.com/files/7abbcf35753dc3324341d8ab77d63e28bbc010fcd6f2ccf5d5c27ba7b24688889ad84dc8f5148bdf54be62155aaefd616058f67c85f87290585c959f207ff9ee","name":"relief_500.f32","type":"application/octet-stream","lastModified":1792303383188,"size":1779556},{"id":"53dc31fe099037027a574097dacd633a5c94a1bb0d817a7fdda58c6f1660ac8268b543edd9eef7b26e6215f4292ea7fcad58efbf8fe3d6e71f814e42d0b5b2bb","href":"https://static.observableusercontent.com/files/53dc31fe099037027a574097dacd633a5c94a1bb0d817a7fdda58c6f1660ac8268b543edd9eef7b26e6215f4292ea7fcad58efbf8fe3d6e71f814e42d0b5b2bb","name":"relief_1500.f32","type":"application/octet-stream","lastModified":1792303383189,"size":1779556},{"id":"f7cbba665d66e1806f122b1c7658d474721c7fce50cdfe02ba08d7f628055e7aee4368e7af029167cbbcac8fd5f1f49bd70d1810d4866799348c77799a657a8b","href":"https://static.observableusercontent.com/files/f7cbba665d66e1806f122b1c7658d474721c7fce50cdfe02ba08d7f628055e7aee4368e7af029167cbbcac8fd5f1f49bd70d1810d4866799348c77799a657a8b","name":"slope.f32","type":"application/octet-stream","lastModified":1792303383189,"size":1779556},{"id":"24808dc72543e64b05fe879f275bfb9d1f69b10e53114100a4700706721c4296d748693223c93286e477382c8a7aa5cec5c4c35b5aa42883bc8ebd88a828a6d8","href":"https://static.observableusercontent.com/files/24808dc72543e64b05fe879f275bfb9d1f69b10e53114100a4700706721c4296d748693223c93286e477382c8a7aa5cec5c4c35b5aa42883bc8ebd88a828a6d8","name":"tpi_150.f32","type":"application/octet-stream","lastModified":1792303383189,"size":1779556},{"id":"40694ab2d3dba7039a1b5dee08411f7d19f143598ac88aa3fabe08907dc72dd7cbcc1ebb589485545af510642e2251548f1cdfcdd13f4472c124c5b3bf7c0396","href":"https://static.observableusercontent.com/files/40694ab2d3dba7039a1b5dee08411f7d19f143598ac88aa3fabe08907dc72dd7cbcc1ebb589485545af510642e2251548f1cdfcdd13f4472c124c5b3bf7c0396","name":"tpi_500.f32","type":"application/octet-stream","lastModified":1792303383189,"size":1779556},{"id":"61fa3843b6604bd4d92ca962deaeda1b77cd936d301ea151d32bdb8ead0e23a72162af52dd8055da818ac157a7871ee8a2f732437522c39b9d9ff5cddb2b3f89","href":"https://static.observableusercontent.com/files/61fa3843b6604bd4d92ca962deaeda1b77cd936d301ea151d32bdb8ead0e23a72162af52dd8055da818ac157a7871ee8a2f732437522c39b9d9ff5cddb2b3f89","name":"tpi_1500.f32","type":"application/octet-stream","lastModified":1792303383190,"size":1779556},{"id":"306e574996aa2cc1869cb85c6ae464eb037d2615e2fd546908295213ea5ffdf21f62c3ce7ade58d5c22cf9cf3111e979c0be53133e0dbed5e8b6c99c78923c2c","href":"https://static.observableusercontent.com/files/306e574996aa2cc1869cb85c6ae464eb037d2615e2fd546908295213ea5ffdf21f62c3ce7ade58d5c22cf9cf3111e979c0be53133e0dbed5e8b6c99c78923c2c","name":"viewshed.js","type":"text/javascript","lastModified":1792353270443,"size":3043},{"id":"d2c3117d669dd98464976b101ec9e895b135678f69954437ad056a42fcc1ff120fb47df544f0b276d378786c546dee1b910d2fa8b645dca941dc376b32c3c012","href":"https://static.observableusercontent.com/files/d2c3117d669dd98464976b101ec9e895b135678f69954437ad056a42fcc1ff120fb47df544f0b276d378786c546dee1b910d2fa8b645dca941dc376b32c3c012","name":"detection.js","type":"text/javascript","lastModified":1792360481266,"size":3937},{"id":"14d6d53a5f0721ef42d1220d9841b8559f99c01ff52f8e8857a7135480082f726d4b04ed79e40877b6b4dff96af6b8fc60bb3a67e5a9ed25d7704b34c884fd34","href":"https://static.observableusercontent.com/files/14d6d53a5f0721ef42d1220d9841b8559f99c01ff52f8e8857a7135480082f726d4b04ed79e40877b6b4dff96af6b8fc60bb3a67e5a9ed25d7704b34c884fd34","name":"domain_dem.f32","type":"application/octet-stream","lastModified":1792375222175,"size":4008004},{"id":"d39847a6eed85c4be31b89c5bcc004888586a56b66a78fbaab9cc022c9c4cab339ee7b59441ef0314b3b5787bb6227a2060ad0aad8003176572c9484ea914d8b","href":"https://static.observableusercontent.com/files/d39847a6eed85c4be31b89c5bcc004888586a56b66a78fbaab9cc022c9c4cab339ee7b59441ef0314b3b5787bb6227a2060ad0aad8003176572c9484ea914d8b","name":"domain_hillshade.f32","type":"application/octet-stream","lastModified":1792375222176,"size":4008004},{"id":"ff1792132429ed45e8b46627c542aba0d44c7096d55f69e5db78e5e96bb6ecf010e057c9bae1a281e009b024ebbbfdcd852b22f65b23d5a71c399db37548abc3","href":"https://static.observableusercontent.com/files/ff1792132429ed45e8b46627c542aba0d44c7096d55f69e5db78e5e96bb6ecf010e057c9bae1a281e009b024ebbbfdcd852b22f65b23d5a71c399db37548abc3","name":"domain_meta.json","type":"application/json","lastModified":1792360392267,"size":798},{"id":"8dd1e325e0528990a2531fbe4614a4d9ea2f621c6db323e1da4c11b2f2b078fb0496e2bbb98f2eca709e82e578d31bffe50d71d24dc6272286d6ef2f4fd9ccfa","href":"https://static.observableusercontent.com/files/8dd1e325e0528990a2531fbe4614a4d9ea2f621c6db323e1da4c11b2f2b078fb0496e2bbb98f2eca709e82e578d31bffe50d71d24dc6272286d6ef2f4fd9ccfa","name":"gap_vs_r50.csv","type":"text/csv","lastModified":1792360652600,"size":5052},{"id":"9d6b5d2aff128738d81de00ae0d3c305ad928596ec5f4b2be31e264c63deaccd92c5c9778ebd071d98e77dc817f3a3d56961f0868efb2218f23bd565ee2a7fd8","href":"https://static.observableusercontent.com/files/9d6b5d2aff128738d81de00ae0d3c305ad928596ec5f4b2be31e264c63deaccd92c5c9778ebd071d98e77dc817f3a3d56961f0868efb2218f23bd565ee2a7fd8","name":"route.js","type":"text/javascript","lastModified":1792378680089,"size":7618},{"id":"0d92580e5c4ab7f74f6e1cd2a62102bde7b36618ce933d147df1e598c87b1733b3d28748ddee690a7db075d7d79a5951aa6449c8842aaa525157e1abf92b3b7b","href":"https://static.observableusercontent.com/files/0d92580e5c4ab7f74f6e1cd2a62102bde7b36618ce933d147df1e598c87b1733b3d28748ddee690a7db075d7d79a5951aa6449c8842aaa525157e1abf92b3b7b","name":"low_altitude_checks.csv","type":"text/csv","lastModified":1792381008770,"size":28773}] 3a:{"id":"13c98ffab38acd87","slug":"how-terrain-masking-lets-drones-avoid-detection","title":"How Terrain Masking Lets Drones Avoid Detection","thumbnail":"66f8364535cca15a4c55831ef632c5e83182a182e66b23bc8faead8d9570f582","access_level":"public","create_time":"$D2026-10-18T04:49:37.782Z","update_time":"$D2026-10-19T06:44:38.475Z","view_time":null,"first_public_time":"$D2026-10-19T06:41:18.005Z","has_unpublished_edits":null,"fork":false,"stars":4,"starred":false,"owner":{"type":"team","id":"5401807055ae8618","login":"benji823","name":"Benji","avatar_url":"https://avatars-next.observableusercontent.com/5116ea3621a099ca0069d79a87fa01f36ef9e7efd7e55dcba31fb687a18522e4","tier":"starter_2024","bio":"","following":false},"version":514,"publish_version":514,"role":null,"authored":false,"authors":[{"type":"individual","id":"35d7c478ca12bd85","login":"benji823","name":"Benji","avatar_url":"https://avatars-next.observableusercontent.com/5116ea3621a099ca0069d79a87fa01f36ef9e7efd7e55dcba31fb687a18522e4","tier":null,"bio":"","following":false}],"members":[{"type":"team","id":"5401807055ae8618","login":"benji823","name":"Benji","avatar_url":"https://avatars-next.observableusercontent.com/5116ea3621a099ca0069d79a87fa01f36ef9e7efd7e55dcba31fb687a18522e4","tier":"starter_2024","role":"editor"}],"comments":[],"custom_thumbnail":true,"trashed":false,"lapsed":null,"subscribed":null,"forks":0,"collection":null,"type":"notebook","body":{"titling":"auto","title":"How Terrain Masking Lets Drones Avoid Detection","cells":[{"id":1,"value":"# How Terrain Masking Lets Drones Avoid Detection\n\n## *Coverage vs. Concealment in the Missoula Valley*","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":3,"value":"### Data sources\nTopography - USGS 3DEP (3D Elevation Program) https://www.usgs.gov/3d-elevation-program \\\n 40x40km square from which a 20x20km AOI will be chosen \\\n 10m resolution, resampled to 30m \\\n EPSG:32612 \\\n Float32 GeoTIFF","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":2,"value":"$3c","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":67,"value":"## Hypothesis\nIn a bounded region watched by ground-based line-of-sight sensors, least-exposure routes between any two points for a low-altitude vehicle (such as a drone) pass through terrain with significantly lower relative elevation (drainages, leeside of ridges, valleys, etc.) and higher local relief than shortest-distance routes between the same endpoints. This effect holds across randomized sensor layouts and weakens as flight altitude (AGL) increases.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":104,"value":"$3d","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":105,"value":"$3e","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":108,"value":"$3f","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":106,"value":"$40","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":107,"value":"\n***\n","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":103,"value":"## Data prep, iterations, and testing","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":12,"value":"### Load/prep the data","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":14,"value":"load metadata for the 667 x 667 cell grid (30m cells)","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":4,"value":"meta = FileAttachment(\"meta.json\").json()","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":15,"value":"create aliases to the files","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":5,"value":"files = ({\n dem: FileAttachment(\"dem.f32\"),\n hillshade: FileAttachment(\"hillshade.f32\"),\n slope: FileAttachment(\"slope.f32\"),\n relief_150: FileAttachment(\"relief_150.f32\"),\n relief_500: FileAttachment(\"relief_500.f32\"),\n relief_1500: FileAttachment(\"relief_1500.f32\"),\n tpi_150: FileAttachment(\"tpi_150.f32\"),\n tpi_500: FileAttachment(\"tpi_500.f32\"),\n tpi_1500: FileAttachment(\"tpi_1500.f32\"),\n dev_150: FileAttachment(\"dev_150.f32\"),\n dev_500: FileAttachment(\"dev_500.f32\"),\n dev_1500: FileAttachment(\"dev_1500.f32\")\n})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":16,"value":"load in every file and convert to Float32Array, check that their sizes match the grid","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":7,"value":"layers = {\n const n = meta.width * meta.height;\n const out = {};\n await Promise.all(Object.entries(files).map(async ([name, f]) => {\n const a = new Float32Array(await f.arrayBuffer());\n if (a.length !== n) throw new Error(`${name}: ${a.length} values, expected ${n}`);\n out[name] = a;\n }));\n return out;\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":17,"value":"helpers for converting between cell positions and map coordinates","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":8,"value":"grid = {\n const {width, height, cell_m: cell, xmin, ymax} = meta;\n return {\n width, height, cell,\n index: (col, row) => row * width + col,\n toXY: (col, row) => [xmin + (col + 0.5) * cell, ymax - (row + 0.5) * cell],\n toCell(x, y) {\n const col = Math.floor((x - xmin) / cell), row = Math.floor((ymax - y) / cell);\n return col >= 0 && col < width && row >= 0 && row < height ? [col, row] : null;\n }\n };\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":9,"value":"// making sure the data loaded correctly, should output a hillshade\n\n{\n const {width: w, height: h} = meta;\n const ctx = DOM.context2d(w, h, 1);\n const img = ctx.createImageData(w, h);\n const hs = layers.hillshade;\n for (let i = 0; i < hs.length; i++) {\n const v = Math.max(0, hs[i]) * 255;\n img.data[4 * i] = img.data[4 * i + 1] = img.data[4 * i + 2] = v;\n img.data[4 * i + 3] = 255;\n }\n ctx.putImageData(img, 0, 0);\n return ctx.canvas;\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":28,"value":"Loading in the hillshade data worked, and looks pretty nice. I would have liked to go with a larger area but I'm not sure observable can handle much more than this.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":10,"value":"// validating data by comparing to the python script that originally pulled the data\n// should be ~1104.69\nlayers.dem[grid.index(...grid.toCell(270000, 5190000))]","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":18,"value":"// load the viewshed module from its attachment\nvs = {\n const src = await FileAttachment(\"viewshed.js\").text();\n return import(URL.createObjectURL(new Blob([src], {type: \"text/javascript\"})));\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":68,"value":"### Exposure mapping","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":19,"value":"// place sensor to view visible regions/elevations (click to place sensor)\nviewof sensor = {\n const el = html`

`;\n el.value = {x: 276705, y: 5192985}; // hilltop near the AOI centre (UTM 12N m)\n const show = () => el.textContent = `Sensor at E ${el.value.x.toFixed(0)}, N ${el.value.y.toFixed(0)}. Click the map to move it.`;\n show();\n el.addEventListener(\"input\", show);\n return el;\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":20,"value":"// mast height: height of the pole that a sensor would sit on since right on the ground is not ideal\nviewof mastHeight = Inputs.range([2, 50], {value: 10, step: 1, label: \"Mast height (m)\"})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":21,"value":"// max range: max range the sensor can see\nviewof maxRange = Inputs.range([1000, 10000], {value: 6000, step: 500, label: \"Max range (m)\"})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":22,"value":"// minimum visible altitude raster, per cell\nminAGL = vs.minVisibleAGL(layers.dem, meta, sensor, {height: mastHeight, maxRange})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":24,"value":"// setting the colors for the shadows, RGB\n// feel free to play around with this and make it look pretty\nshadowStyle = ({\n deep: 300, // AGL for darkest color\n lit: [255, 236, 190], // visible at ground level color\n dark: [60, 55, 160], // shadow tint\n outOfRange: [55, 58, 66] // beyond max range, dimmed\n})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":30,"value":"### Iteration I\n\nThe visual below turned out really nicely. Being able to click around the map and move the sensor makes it very intuitive what is going on and how things are computed.\n\nOne sensor isn't very realistic though, neither is a strict detection cutoff. With a typical detection range of 3-4km for small object like drones, it would make much more sense to have multiple sensors employed to cover an area.\n\nThe next step is to have multiple sensors, with the ability to move, add, or remove sensors using a similar technique to the \"click to place sensor\" on the chart below.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":26,"value":"$41","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":32,"value":"// load in the new detection module as 'det'\ndet = {\n const src = await FileAttachment(\"detection.js\").text();\n return import(URL.createObjectURL(new Blob([src], {type: \"text/javascript\"})));\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":33,"value":"// editable sensor layout, with 12 initial sensors at the highest point in each section of a 4x3 grid\nviewof layout = {\n const el = html`

`;\n el.value = [\n {x: 267675, y: 5202105}, {x: 272445, y: 5201265}, {x: 278475, y: 5202255}, {x: 281805, y: 5202255},\n {x: 268605, y: 5194065}, {x: 273615, y: 5192505}, {x: 276705, y: 5192985}, {x: 283635, y: 5194485},\n {x: 268605, y: 5187105}, {x: 273135, y: 5187465}, {x: 278085, y: 5184945}, {x: 281085, y: 5185245}\n ];\n const show = () => el.textContent = `${el.value.length} sensors. Click the map to add one, drag to move, shift-click to remove.`;\n show();\n el.addEventListener(\"input\", show);\n return el;\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":34,"value":"// slider for flight altitude to see how concealment changes with AGL\nviewof altitude = Inputs.range([10, 500], {value: 150, step: 10, label: \"Flight altitude (m AGL)\"})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":35,"value":"// adjustable detection model inputs\n// R50 is the range at which a sensor has a 50% chance of detecting something with a single pass\n// RCS is RADAR-Cross-Section, or the size of the object relative to the radar\n// Drone speed is how fast the drone is moving. Faster means it spends less time within any given cell, so less likely to be detected at higher speeds.\nviewof detForm = Inputs.form({\n r50: Inputs.range([500, 5000], {value: 2000, step: 100, label: \"Per-scan R50 (m)\"}),\n rcs: Inputs.select(new Map([\n [\"0.01 m² (small quadcopter)\", 0.01],\n [\"0.1 m² (large multirotor)\", 0.1],\n [\"1 m² (small fixed-wing)\", 1]\n ]), {label: \"Target RCS\"}),\n speed: Inputs.range([5, 40], {value: 15, step: 1, label: \"Drone speed (m/s)\"})\n})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":36,"value":"detParams = ({...det.defaults, ...detForm})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":37,"value":"// cache of per-sensor min-visible-AGL rasters, saves computing and speeds things up\nminAGLCache = new Map()","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":39,"value":"// records computed stats for each sensor so that only new or moved sensors need to be recomputed\nsensorRecords = {\n const keys = new Set();\n const records = layout.map(({x, y}) => {\n const key = `${x},${y},${mastHeight},${maxRange}`;\n keys.add(key);\n if (!minAGLCache.has(key)) {\n minAGLCache.set(key, vs.minVisibleAGL(layers.dem, meta, {x, y}, {height: mastHeight, maxRange}));\n }\n return {x, y, maxRange, z0: vs.groundElevation(layers.dem, meta, x, y) + mastHeight, minAGL: minAGLCache.get(key)};\n });\n for (const k of minAGLCache.keys()) if (!keys.has(k)) minAGLCache.delete(k);\n return records;\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":42,"value":"// lowest min altitude raster that considers all sensors (independent of flight AGL)\ncoverMinAGL = det.combinedMinAGL(sensorRecords, meta.width * meta.height)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":44,"value":"// how dangerous a cell is at the given altitude, as a raster\nhazard = det.hazardField(layers.dem, meta, sensorRecords, altitude, detParams)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":46,"value":"// selectors\nviewof mapView = Inputs.radio([\"Detection per km flown\", \"Zero-detection zones/depths\"], {value: \"Detection per km flown\", label: \"Show\"})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":49,"value":"$42","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":47,"value":"$43","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":48,"value":"// legend\nmapView === \"Detection per km flown\"\n ? Plot.legend({\n color: {\n domain: [0, 1],\n interpolate: (t) => {\n const {lit, dark} = shadowStyle, b = 0.85 * (0.25 + 0.75 * t);\n return `rgb(${dark.map((v, k) => (v * (1 - t) + lit[k] * t) * b)})`;\n },\n tickFormat: \"%\",\n label: `Chance of detection per km flown at ${altitude} m AGL`\n },\n width: 400\n })\n : Plot.legend({\n color: {\n type: \"sqrt\",\n domain: [0, shadowStyle.deep],\n interpolate: (t) => {\n const {lit, dark} = shadowStyle, b = 0.85 * (1 - 0.75 * t);\n return `rgb(${lit.map((v, k) => (v * (1 - t) + dark[k] * t) * b)})`;\n },\n label: \"Min visible height above ground, any sensor (m): darker = more room to hide\"\n },\n width: 400\n })","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":50,"value":"// summary of area at given AGL\nexposureStats = {\n const n = meta.width * meta.height;\n let masked = 0, risky = 0;\n for (let i = 0; i < n; i++) {\n if (!(coverMinAGL[i] < altitude)) masked++; // no sensor has line of sight (or none in range)\n if (1 - Math.exp(-1000 * hazard[i]) > 0.5) risky++; // > 50% detection chance per km flown\n }\n const pct = (v) => `${(100 * v / n).toFixed(0)}%`;\n return md`At **${altitude} m AGL** with ${layout.length} sensors: **${pct(masked)}** of the area is out of every sensor's line of sight, and **${pct(risky)}** has a better than 50% chance of detection per km flown.`;\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":51,"value":"// detection drop off sanity check, assumes flat ground. looks good.\nPlot.plot({\n width: 640,\n height: 260,\n x: {label: \"Slant range (m)\"},\n y: {label: \"Probability\", domain: [0, 1], grid: true},\n color: {legend: true},\n marks: [\n Plot.line(\n d3.range(100, 6001, 25).flatMap((R) => {\n const pd = det.pdScan(R, Infinity, detParams);\n return [\n {R, p: pd, kind: \"Per scan\"},\n {R, p: 1 - Math.exp(-1000 * det.hazardOf(pd, detParams)), kind: \"Per km flown at this range\"}\n ];\n }),\n {x: \"R\", y: \"p\", stroke: \"kind\"}\n ),\n Plot.ruleX([detParams.r50], {strokeDasharray: \"4,3\"}),\n Plot.ruleY([0])\n ]\n})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":52,"value":"// load the routing module (uses dijkstra to find least exposure routes)\nroute = {\n const src = await FileAttachment(\"route.js\").text();\n return import(URL.createObjectURL(new Blob([src], {type: \"text/javascript\"})));\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":54,"value":"//\nviewof editMode = Inputs.radio([\"Sensors\", \"Route endpoints\"], {value: \"Sensors\", label: \"Map clicks edit\"})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":55,"value":"// set route startpoint and endpoint by clicking on the map\nviewof endpoints = {\n const el = html`

`;\n el.value = {start: {x: 266000, y: 5190000}, goal: {x: 276000, y: 5200000}};\n el.next = \"start\";\n const show = () => el.textContent =\n `Start E ${el.value.start.x.toFixed(0)} N ${el.value.start.y.toFixed(0)} → goal E ${el.value.goal.x.toFixed(0)} N ${el.value.goal.y.toFixed(0)}. ` +\n `Next click sets the ${el.next}.`;\n show();\n el.addEventListener(\"input\", show);\n return el;\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":56,"value":"// path distance penalty (drones can't fly forever, so shorter routes *can* be better at times)\nviewof lengthPenalty = Inputs.range([0, 0.2], {value: 0, step: 0.005, label: \"Distance penalty (per km)\"})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":58,"value":"// the optimal route\nbestRoute = route.leastExposureRoute(hazard, meta, endpoints.start, endpoints.goal, {lengthPenalty: lengthPenalty / 1000})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":59,"value":"// compare the least-exposure route against the shortest distance route (is it better?)\nrouteEval = {\n const {start: s, goal: g} = endpoints;\n return {\n best: route.evaluateRoute(bestRoute.points, hazard, meta),\n straight: route.evaluateRoute([[s.x, s.y], [g.x, g.y]], hazard, meta)\n };\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":62,"value":"# Comparing least-exposure route to the shortest distance route\n\n*P(survive undetected) is just the probability of making it to the destination undetected* \\\n*Actually taking out the target is a much different problem*","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":60,"value":"// comparison table between shortest route and dijkstra least-exposure route\n{\n const row = (name, e) => `| ${name} | ${(e.length / 1000).toFixed(1)} km | ${e.cumHazard.toFixed(2)} | ${e.pSurvive < 1e-4 ? e.pSurvive.toExponential(1) : (100 * e.pSurvive).toFixed(1) + \"%\"} |`;\n return md`At **${altitude} m AGL**:\n\n| Route | Length | Expected detections | P(survive undetected) |\n|---|---|---|---|\n${row(\"Least exposure\", routeEval.best)}\n${row(\"Straight line\", routeEval.straight)}\n\nExpected detections = −ln P(survive): the cumulative hazard along the route.`;\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":63,"value":"// cumulative detection chance along each route, charted\nPlot.plot({\n width: 640,\n height: 280,\n x: {label: \"Distance flown (km)\"},\n y: {label: \"Cumulative P(detected)\", domain: [0, 1], grid: true, tickFormat: \"%\"},\n color: {domain: [\"Least exposure\", \"Straight line\"], range: [\"#3fd8ff\", \"#888\"], legend: true},\n marks: [\n ...[[\"Least exposure\", routeEval.best], [\"Straight line\", routeEval.straight]].map(([name, e]) =>\n Plot.line(e.profile.filter((_, i) => i % 10 === 0), {x: (d) => d.d / 1000, y: \"pDetected\", stroke: () => name})\n ),\n Plot.ruleY([0])\n ]\n})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":66,"value":"$44","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":65,"value":"$45","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":69,"value":"meta2 = FileAttachment(\"domain_meta.json\").json()","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":70,"value":"// load in new stuff so we don't affect the previous iterations\nlayers2 = {\n const n = meta2.width * meta2.height;\n const load = async (f) => {\n const a = new Float32Array(await f.arrayBuffer());\n if (a.length !== n) throw new Error(`${a.length} values, expected ${n}`);\n return a;\n };\n return {\n dem: await load(FileAttachment(\"domain_dem.f32\")),\n hillshade: await load(FileAttachment(\"domain_hillshade.f32\"))\n };\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":71,"value":"VIEW_RANGE2 = 2.5 * 3500","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":72,"value":"$46","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":73,"value":"// flight altitude slider\nviewof altitude2 = Inputs.range([10, 500], {value: 50, step: 10, label: \"Flight altitude (m AGL)\"})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":74,"value":"// detection parameter sliders\nviewof detForm2 = Inputs.form({\n r50: Inputs.range([2000, 3500], {value: 3000, step: 250, label: \"Per-scan R50 (m)\"}),\n rcs: Inputs.select(new Map([\n [\"0.01 m² (small quadcopter)\", 0.01],\n [\"0.1 m² (large multirotor)\", 0.1],\n [\"1 m² (small fixed-wing)\", 1]\n ]), {label: \"Target RCS\"}),\n speed: Inputs.range([5, 40], {value: 15, step: 1, label: \"Drone speed (m/s)\"})\n})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":75,"value":"detParams2 = ({...det.defaults, ...detForm2})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":76,"value":"minAGLCache2 = new Map()","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":77,"value":"// caching per sensor records and viewsheds so only new or moved sensors need recomputed\nsensorRecords2 = {\n const keys = new Set(), maxRange = 2.5 * detParams2.r50;\n const records = layout2.map(({x, y}) => {\n const key = `${x},${y},${mastHeight}`;\n keys.add(key);\n if (!minAGLCache2.has(key)) {\n minAGLCache2.set(key, vs.minVisibleAGL(layers2.dem, meta2, {x, y}, {height: mastHeight, maxRange: VIEW_RANGE2}));\n }\n return {x, y, maxRange, z0: vs.groundElevation(layers2.dem, meta2, x, y) + mastHeight, minAGL: minAGLCache2.get(key)};\n });\n for (const k of minAGLCache2.keys()) if (!keys.has(k)) minAGLCache2.delete(k);\n return records;\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":78,"value":"// hazards per meter\nhazard2 = det.hazardField(layers2.dem, meta2, sensorRecords2, altitude2, detParams2)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":79,"value":"// hazards per meter without terrain masking to differentiate between sensor gap following and terrain following\nhazardRangeOnly2 = {\n const zero = new Float32Array(meta2.width * meta2.height);\n return det.hazardField(layers2.dem, meta2, sensorRecords2.map((s) => ({...s, minAGL: zero})), altitude2, detParams2);\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":80,"value":"// used to determine if outcome changes with terrain awareness or just sensor-range awareness\nviewof mapView2 = Inputs.radio([\"Terrain-aware detection\", \"Range-only detection\"], {value: \"Terrain-aware detection\", label: \"Show\"})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":81,"value":"// clicking edits sensors or route endpoints\nviewof editMode2 = Inputs.radio([\"Sensors\", \"Route endpoints\"], {value: \"Sensors\", label: \"Map clicks edit\"})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":82,"value":"// route endpoints\nviewof endpoints2 = {\n const el = html`

`;\n el.value = {start: {x: 266000, y: 5190000}, goal: {x: 276000, y: 5200000}};\n el.next = \"start\";\n const show = () => el.textContent =\n `Start E ${el.value.start.x.toFixed(0)} N ${el.value.start.y.toFixed(0)} → goal E ${el.value.goal.x.toFixed(0)} N ${el.value.goal.y.toFixed(0)}. ` +\n `Next click sets the ${el.next} (clamped to the AOI).`;\n show();\n el.addEventListener(\"input\", show);\n return el;\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":83,"value":"// adjustable distance penalty\nviewof lengthPenalty2 = Inputs.range([0, 0.2], {value: 0, step: 0.005, label: \"Distance penalty (per km)\"})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":84,"value":"// optimal routes for terrain-aware, route-aware-only, both limited by endurance (detour) factor\nroutes2 = {\n const {start, goal} = endpoints2, opts = {lengthPenalty: lengthPenalty2 / 1000};\n const maxLength = DETOUR_FACTOR2 * Math.hypot(goal.x - start.x, goal.y - start.y);\n const plan = (h) => enduranceLimit2\n ? route.leastExposureRouteWithin(h, meta2, start, goal, maxLength, opts)\n : route.leastExposureRoute(h, meta2, start, goal, opts);\n const terrain = plan(hazard2), rangeOnly = plan(hazardRangeOnly2);\n return {\n terrain: terrain.points,\n rangeOnly: rangeOnly.points,\n straight: [[start.x, start.y], [goal.x, goal.y]],\n terrainPenalty: enduranceLimit2 ? terrain.penalty : opts.lengthPenalty, // per metre; reused by flowField2\n limit: enduranceLimit2 ? {maxLength, terrainBinding: terrain.binding, rangeOnlyBinding: rangeOnly.binding} : null\n };\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":85,"value":"// compare all routes on total exposure score\nrouteEval2 = {\n const {aoi} = meta2;\n const outside = (pts) => pts.filter(([x, y]) => x < aoi.xmin || x > aoi.xmax || y < aoi.ymin || y > aoi.ymax).length / pts.length;\n return Object.fromEntries([\"terrain\", \"rangeOnly\", \"straight\"].map((k) =>\n [k, {...route.evaluateRoute(routes2[k], hazard2, meta2), outside: k === \"straight\" ? 0 : outside(routes2[k])}]));\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":86,"value":"$47","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":87,"value":"// cumulative expected detections along each route\nPlot.plot({\n width: 640,\n height: 280,\n x: {label: \"Distance flown (km)\"},\n y: {label: \"Cumulative expected detections\", type: \"symlog\", grid: true},\n color: {\n domain: [\"Terrain-aware\", \"Range-only\", \"Straight line\"],\n range: [\"#3fd8ff\", \"#ffa03c\", \"#888\"],\n legend: true\n },\n marks: [\n ...[[\"Terrain-aware\", routeEval2.terrain], [\"Range-only\", routeEval2.rangeOnly], [\"Straight line\", routeEval2.straight]].map(([name, e]) =>\n Plot.line(e.profile.filter((_, i) => i % 10 === 0), {x: (d) => d.d / 1000, y: \"cumHazard\", stroke: () => name})\n ),\n Plot.ruleY([0])\n ]\n})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":99,"value":"$48","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":88,"value":"$49","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":89,"value":"// legend\nPlot.legend({\n color: {\n domain: [0, 1],\n interpolate: (t) => {\n const {lit, dark} = shadowStyle, b = 0.85 * (0.25 + 0.75 * t);\n return `rgb(${dark.map((v, k) => (v * (1 - t) + lit[k] * t) * b)})`;\n },\n tickFormat: \"%\",\n label: `Chance of detection per km flown at ${altitude2} m AGL (buffer dimmed)`\n },\n width: 400\n})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":90,"value":"gapData2 = FileAttachment(\"gap_vs_r50.csv\").csv({typed: true})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":109,"value":"$4a","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":91,"value":"$4b","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":93,"value":"// max route length as a factor of the straight line route (drones can't fly forever)\nDETOUR_FACTOR2 = 2","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":94,"value":"// detour factor selector\nviewof enduranceLimit2 = Inputs.toggle({label: `Endurance limit (${DETOUR_FACTOR2}× straight-line distance)`, value: false})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":97,"value":"Checking low altitude flight against higher resolution DEMs outside of this notebook\nto see how much of an effect our 30m raster choice has against the original 10m raster.\n'ramp' is basically how far above the horizon something has to be to be detected;\nit is a soft edge at the terrain-masking line that models grazing-angle signal loss","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":95,"value":"$4c","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":100,"value":"## Flow field (Iteration V)\n\nI think this is the most powerful visual in terms of representing my hypothesis so far. While the static visuals are nice, they only show the results of a single, hand-picked path. By drawing and animating the least-detection paths from any given point on the map to a single target, it becomes clear that these optimal routes do indeed follow divots in the terrain, when they can, just like a river. This relies on all of the same parameters as Iteration IV, so adjusting anything there will affect this visual too.\n\nClick anywhere on the map to set a new target and watch the Dijkstra algorithm compute least-detection paths from every point on the map. You'll notice that some of the \"rivers\" that form are nearly universal across any target, showing how certain areas of terrain (most often drainages) provide the best hiding places for low-altitude aircraft.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":98,"value":"$4d","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":101,"value":"$4e","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"}],"files":"$W4f","stdlib":"2"}} 3b:"$3a:body"