3e:null 3f:["$","title",null,{"children":"Generating realistic CoMapeo data | Gregor MacLennan | Observable"}] 45:T5af,# Generating realistic CoMapeo data This notebook generates random CoMapeo data in a way designed to reflect real-life usage. It's used by the [footprint](./footprint) and [extent](./extent) notebooks to demonstrate the algorithms used to estimate the area covered by a CoMapeo monitoring or mapping team. Scenarios use a basic (mullberry32) seeded PRNG. Each scenario comprises of three things: - **Territory**: a community's actual territory, as one or more polygons. Either natural boundaries (generated to resemble following a mountain range or river), or 4–7 sided polygons, each with a random aspect ratio and orientation. Territories are drawn from 100 to 10,000 km² with a median near 2,000 km². - **Access**: footpaths, rivers and roads which people use to move around their territory. These are used to restrict how collected data is generated: real-life monitoring data is restricted by the access routes within a territory. - **Patrols**: generated 1–4 day drips where a team would collect data along access routes. Walk at 4 km/h, 5—15km per day, recording observations in clusters on the way. 1/10 trips include a motorised leg (boat, vehicle) and ¼ of trips record a track. The area estimators only see the records (observations and tracks) generated by this data. The goal is to visualize the difference between the estimated area monitored and/or mapped, and the actual territory that might be monitored as part of a project.46:T593,const map = scenarioMap({ toMetres: projection.toMetres, xyRecords, scenario, title: `${scenario.name}. Drag to pan, wheel to zoom, double-click to fit.` }); const trackKm = scenario.tracks.reduce((sum, t) => sum + lonLatLengthM(t.coords), 0) / 1000; const routeKm = scenario.routes.reduce((sum, r) => sum + lonLatLengthM(r.coords), 0) / 1000; const routeKinds = [...new Set(scenario.routes.map((r) => r.kind))]; const infoPanel = html`

Records	${scenario.points.length + scenario.tracks.length}: ${scenario.points.length} observations, ${scenario.tracks.length} tracks (${trackKm.toFixed(1)} km)
Territory	${scenario.territoryKm2.toFixed(2)} km² ${scenario.territory.length} polygon(s)
Access	${scenario.routes.length ? `${scenario.routes.length} ${routeKinds.join(" and ")} route(s), ${routeKm.toFixed(1)} km; patrols follow them` : scenario.territoryKm2 ? "patrols roam the territory from a settlement" : "none"}
Collection	${scenario.collection}
Projection	equirectangular about latitude ${projection.meanLatDeg.toFixed(4)}

`; display(html`

${map} ${infoPanel}

`);47:T5fe,// Given x, y from origin BASE, calculate the lon, lat function lonLatFromBase([x, y]) { const [lon0, lat0] = BASE; const dLat = (y / EARTH_RADIUS_M) * (180 / Math.PI); const dLon = (x / (EARTH_RADIUS_M * Math.cos((lat0 * Math.PI) / 180))) * (180 / Math.PI); return [lon0 + dLon, lat0 + dLat]; } // Flat-earth approximation of distance between two points function lonLatDistanceM([lon0, lat0], [lon1, lat1]) { const meanLat = ((lat0 + lat1) / 2) * (Math.PI / 180); const dx = (lon1 - lon0) * (Math.PI / 180) * EARTH_RADIUS_M * Math.cos(meanLat); const dy = (lat1 - lat0) * (Math.PI / 180) * EARTH_RADIUS_M; return Math.hypot(dx, dy); } // Approximate length of a coordinate array function lonLatLengthM(coords) { let total = 0; for (let i = 0; i + 1 < coords.length; i++) total += lonLatDistanceM(coords[i], coords[i + 1]); return total; } // Longitude and latitude into estimator metres. Equirectangular about the // mean latitude, taken over sorted coordinates so the mean does not depend on input // order. function metresProjection(coords) { const sorted = coords.slice().sort((a, b) => a[0] - b[0] || a[1] - b[1]); let latSum = 0; for (const [, lat] of sorted) latSum += lat; const meanLatDeg = sorted.length ? latSum / sorted.length : BASE[1]; const xScale = (EARTH_RADIUS_M * Math.cos((meanLatDeg * Math.PI) / 180) * Math.PI) / 180; const yScale = (EARTH_RADIUS_M * Math.PI) / 180; return { meanLatDeg, toMetres: ([lon, lat]) => [lon * xScale, lat * yScale] }; }48:T784,function polygonAreaM2(polygon) { let sum = 0; for (let i = 0; i < polygon.length; i++) { const [x0, y0] = polygon[i]; const [x1, y1] = polygon[(i + 1) % polygon.length]; sum += x0 * y1 - x1 * y0; } return Math.abs(sum) / 2; } function pointInPolygon(x, y, polygon) { let inside = false; for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) { const [xi, yi] = polygon[i]; const [xj, yj] = polygon[j]; if (yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi) inside = !inside; } return inside; } function boundsOf(points) { const xs = points.map((p) => p[0]); const ys = points.map((p) => p[1]); return { minX: Math.min(...xs), maxX: Math.max(...xs), minY: Math.min(...ys), maxY: Math.max(...ys) }; } // Distance from `origin` along `angle` to the farthest crossing of the polygon boundary. function rayToBoundary(polygon, [ox, oy], angle) { const dx = Math.cos(angle); const dy = Math.sin(angle); let farthest = 0; for (let i = 0; i < polygon.length; i++) { const [ax, ay] = polygon[i]; const [bx, by] = polygon[(i + 1) % polygon.length]; const ex = bx - ax; const ey = by - ay; const denominator = dx * ey - dy * ex; if (Math.abs(denominator) < 1e-9) continue; const t = ((ax - ox) * ey - (ay - oy) * ex) / denominator; const u = ((ax - ox) * dy - (ay - oy) * dx) / denominator; if (t > 0 && u >= 0 && u <= 1) farthest = Math.max(farthest, t); } return farthest; } // Pieces of a line whose vertices lie inside the polygon. function clipLineToPolygon(line, polygon) { const pieces = []; let current = []; for (const point of line) { if (pointInPolygon(point[0], point[1], polygon)) current.push(point); else { if (current.length > 1) pieces.push(current); current = []; } } if (current.length > 1) pieces.push(current); return pieces; }49:T6a8,{ const rng = seededRandom(seed + counter1); const shapes = d3 .range(10) .map(() => territoryShape(rng, {areaKm2: communityAreaKm2(rng)})); display( html`

Ten random territories, each drawn at its own scale so the shapes can be compared. The dot is the settlement that settlementIn would place.

` ); display( html`

${shapes.map( (shape) => { const {minX, maxX, minY, maxY} = boundsOf(shape.polygon); const span = Math.max(maxX - minX, maxY - minY) * 1.1; const cx = (minX + maxX) / 2; const cy = (minY + maxY) / 2; const s = 200 / span; const d = "M" + shape.polygon .map( ([x, y]) => `${(100 + (x - cx) * s).toFixed(1)},${(100 - (y - cy) * s).toFixed(1)}` ) .join("L") + "Z"; const [bx, by] = settlementIn(rng, shape); return html`

${shape.kind}, ${shape.areaKm2.toFixed(0)} km², aspect ${shape.aspect.toFixed(1)}, rotated ${((shape.rotation * 180) / Math.PI).toFixed(0)}°

`; } )}

` ); }4a:Td57,function pathLengthM(path) { let total = 0; for (let i = 1; i < path.length; i++) total += Math.hypot( path[i][0] - path[i - 1][0], path[i][1] - path[i - 1][1] ); return total; } // Position and unit direction at a distance along a metre path. function alongPath(path, distanceM) { let remaining = distanceM; for (let i = 0; i + 1 < path.length; i++) { const dx = path[i + 1][0] - path[i][0]; const dy = path[i + 1][1] - path[i][1]; const segment = Math.hypot(dx, dy); if (remaining <= segment || i + 2 === path.length) { const t = segment === 0 ? 0 : Math.min(1, remaining / segment); return { point: [path[i][0] + dx * t, path[i][1] + dy * t], direction: [dx / (segment || 1), dy / (segment || 1)] }; } remaining -= segment; } return {point: path[path.length - 1], direction: [1, 0]}; } function truncatePath(path, lengthM) { const out = [path[0]]; let total = 0; for (let i = 1; i < path.length && total < lengthM; i++) { total += Math.hypot( path[i][0] - path[i - 1][0], path[i][1] - path[i - 1][1] ); out.push(path[i]); } return out; } // A footpath: heading drifts as a random walk but is pulled back towards the // target direction, so the path wanders without doubling back. function meanderPath( rng, origin, angle, lengthM, {stepM = 100, wiggle = 0.5} = {} ) { const path = [origin]; let heading = angle; let [x, y] = origin; for (let s = stepM; s <= lengthM; s += stepM) { heading += (rng() - 0.5) * wiggle + (angle - heading) * 0.15; x += stepM * Math.cos(heading); y += stepM * Math.sin(heading); path.push([x, y]); } return path; } // A river or road: heading `angle` from `start` for `lengthM` with a sine meander // plus a random drift. function meanderLine( rng, [x0, y0], angle, lengthM, amplitudeM, wavelengthM, stepM = 200 ) { const line = []; let drift = 0; for (let s = 0; s <= lengthM; s += stepM) { drift += (rng() * 2 - 1) * 40; const across = amplitudeM * Math.sin((2 * Math.PI * s) / wavelengthM) + drift; line.push([ x0 + s * Math.cos(angle) - across * Math.sin(angle), y0 + s * Math.sin(angle) + across * Math.cos(angle) ]); } return line; } // A line crossing the whole territory along its long axis at a fraction of its width, // clipped to the territory. Returns pieces in metres. function crossingLine(rng, shape, widthFraction, amplitudeM, wavelengthM) { const {minX, maxX, minY, maxY} = shape.localBounds; const y0 = minY + widthFraction * (maxY - minY); const local = meanderLine( rng, [minX - 2000, y0], 0, maxX - minX + 4000, amplitudeM, wavelengthM ); return clipLineToPolygon(local.map(shape.toMetres), shape.polygon); } function wobblyLoop(rng, centre, perimeterM) { const meanRadius = perimeterM / (2 * Math.PI); const harmonics = [2, 3, 4, 5].map((k) => ({ k, amplitude: 0.04 + rng() * 0.1, phase: rng() * 2 * Math.PI })); const loop = []; for (let i = 0; i < 200; i++) { const theta = (i / 200) * 2 * Math.PI; let r = 1; for (const h of harmonics) r += h.amplitude * Math.sin(h.k * theta + h.phase); loop.push([ centre[0] + meanRadius * r * Math.cos(theta), centre[1] + meanRadius * r * Math.sin(theta) ]); } loop.push(loop[0]); return loop; }4b:T41f,function observation([x, y], device, time) { return {x, y, device, time}; } function pickDevice(rng, count, offset = 0) { return DEVICES[offset + Math.floor(rng() * count)]; } function timeOfDay(day, hour) { return EPOCH + day * DAY_MS + hour * 3600 * 1000; } function randomTime(rng, firstDay, dayCount) { return timeOfDay(firstDay + Math.floor(rng() * dayCount), 6 + rng() * 12); } function discObservations( rng, centre, radiusM, count, {devices = 3, deviceOffset = 0, firstDay = 0, days = 90} = {} ) { const points = []; for (let i = 0; i < count; i++) { const r = radiusM * Math.sqrt(rng()); const angle = rng() * 2 * Math.PI; points.push( observation( [centre[0] + r * Math.cos(angle), centre[1] + r * Math.sin(angle)], pickDevice(rng, devices, deviceOffset), randomTime(rng, firstDay, days) ) ); } return points; } function jitterLine(rng, line, jitterM) { return line.map(([x, y]) => [ x + (rng() * 2 - 1) * jitterM, y + (rng() * 2 - 1) * jitterM ]); }4c:T5fb,## Patrols This is the heart of the generator, because it is where the data starts to look like data from the field. A patrol day is one device walking at 4 km/h from 07:00. Daily distance is 5 to 15 km, capped at 2 km times the square root of the area in km², so a 1 km² village gets walks of 1 to 2 km and anything over 56 km² gets the full range. Trips have a purpose. From a settlement, a **roaming trip** is one of three kinds: an out-and-back day that heads in one direction and comes home by a different meander; a loop of the day's length around an area, starting and ending at the settlement; or an expedition of two to four days that walks outward for one or two days and then home, the only way to reach the edge of a large territory. A **motorised trip** (about one in ten) rides to a distant part of the territory, walks a loop there, and rides back, with no observations during the ride. Where access is a river or a road, a **route trip** walks a stretch of it, and on a motorised day rides 10 to 30 km along it between two walked stretches. `meanderInside` keeps a walk inside the territory by turning for home when a step would leave it; `meanderTowards` walks home with wander that dies away as it gets close. `patrolDay` places the day's observations on the walked legs at the time the patrol reached each point. `patrolCampaign` schedules trips over a period on free days and stamps devices, times and tracks. `villageCampaign` adds a settlement's everyday records to a campaign of roaming trips from it. 4d:T1217,const WALK_KMH = 4; const MOTOR_KMH = 25; const WALK_LENGTH_M = [5000, 15000]; function dailyWalkM(rng, areaKm2) { const cap = Math.min( WALK_LENGTH_M[1], Math.max(2000, 2000 * Math.sqrt(areaKm2)) ); return between(rng, Math.min(WALK_LENGTH_M[0], cap * 0.5), cap); } // A walk that keeps roughly to `angle` with some wander, turning for home when the // next step would leave the territory. function meanderInside( rng, polygon, start, angle, lengthM, home = start, {stepM = 100, wiggle = 0.5} = {} ) { const path = [start]; let target = angle; let heading = angle; let [x, y] = start; for (let s = stepM; s <= lengthM; s += stepM) { heading += (rng() - 0.5) * wiggle + (target - heading) * 0.1; let nx = x + stepM * Math.cos(heading); let ny = y + stepM * Math.sin(heading); if (!pointInPolygon(nx, ny, polygon)) { target = Math.atan2(home[1] - y, home[0] - x) + (rng() - 0.5); heading = target; nx = x + stepM * Math.cos(heading); ny = y + stepM * Math.sin(heading); if (!pointInPolygon(nx, ny, polygon)) continue; } [x, y] = [nx, ny]; path.push([x, y]); } return path; } // A walk home: heads for `to` with wander that dies away as it gets close, and stops // there or after `maxLengthM`. Steps that would leave the territory are turned aside. function meanderTowards( rng, from, to, maxLengthM, polygon = null, {stepM = 100, wiggle = 0.8} = {} ) { const path = [from]; let [x, y] = from; let heading = Math.atan2(to[1] - y, to[0] - x); for (let s = stepM; s <= maxLengthM; s += stepM) { const remaining = Math.hypot(to[0] - x, to[1] - y); if (remaining <= stepM) { path.push(to); break; } const bearing = Math.atan2(to[1] - y, to[0] - x); const pull = Math.min(1, (3 * stepM) / remaining); heading += (rng() - 0.5) * wiggle * (1 - pull) + (bearing - heading) * (0.15 + 0.85 * pull); let moved = false; for (const turn of [0, 0.6, -0.6, 1.2, -1.2, 1.8, -1.8]) { const nx = x + stepM * Math.cos(heading + turn); const ny = y + stepM * Math.sin(heading + turn); if (polygon && !pointInPolygon(nx, ny, polygon)) continue; [x, y] = [nx, ny]; heading += turn; moved = true; break; } if (moved) path.push([x, y]); } return path; } // A motorised transfer: near enough straight between two points. function transitPath(rng, from, to, stepM = 200) { const steps = Math.max( 1, Math.ceil(Math.hypot(to[0] - from[0], to[1] - from[1]) / stepM) ); const path = []; for (let i = 0; i <= steps; i++) { const t = i / steps; const jitter = i === 0 || i === steps ? 0 : 30; path.push([ from[0] + (to[0] - from[0]) * t + (rng() - 0.5) * jitter, from[1] + (to[1] - from[1]) * t + (rng() - 0.5) * jitter ]); } return path; } // The part of a route between two distances along it, in travel order. function subPath(route, fromM, toM) { const [a, b] = fromM <= toM ? [fromM, toM] : [toM, fromM]; const path = [alongPath(route, a).point]; let travelled = 0; for (let i = 1; i < route.length; i++) { travelled += Math.hypot( route[i][0] - route[i - 1][0], route[i][1] - route[i - 1][1] ); if (travelled > a && travelled < b) path.push(route[i]); } path.push(alongPath(route, b).point); return fromM <= toM ? path : path.reverse(); } function nearestDistanceAlong(route, [px, py]) { let best = 0; let bestDistance = Infinity; let travelled = 0; for (let i = 0; i < route.length; i++) { if (i > 0) travelled += Math.hypot( route[i][0] - route[i - 1][0], route[i][1] - route[i - 1][1] ); const d = Math.hypot(route[i][0] - px, route[i][1] - py); if (d < bestDistance) [best, bestDistance] = [travelled, d]; } return best; } // A loop of about `lengthM` starting and ending at `from`, or null if it would leave the territory. function loopFrom(rng, polygon, from, lengthM) { const radius = lengthM / (2 * Math.PI); const angle = rng() * 2 * Math.PI; const loop = wobblyLoop( rng, [from[0] + radius * Math.cos(angle), from[1] + radius * Math.sin(angle)], lengthM ); if (!loop.every(([x, y]) => pointInPolygon(x, y, polygon))) return null; let nearest = 0; loop.forEach((p, i) => { if ( Math.hypot(p[0] - from[0], p[1] - from[1]) < Math.hypot(loop[nearest][0] - from[0], loop[nearest][1] - from[1]) ) nearest = i; }); const rotated = [...loop.slice(nearest, -1), ...loop.slice(0, nearest)]; return [from, ...rotated, from]; }4e:Tdd0,// A trip that roams the territory from a settlement: an out-and-back day, a loop day, // or an expedition of two to four days. A motorised trip rides to another part of the // territory, walks a loop there, and rides back. Returns one array of legs per day. function roamingTrip( rng, {polygon, base, areaKm2, motorised, transit = transitPath, kind} ) { const dayLength = () => dailyWalkM(rng, areaKm2); if (motorised) { const far = uniformInPolygon(rng, polygon, 1)[0]; const walk = loopFrom(rng, polygon, far, dayLength()) ?? outAndBack(rng, polygon, far, dayLength()); return [ [ {path: transit(rng, base, far), motorised: true}, {path: walk, motorised: false}, {path: transit(rng, far, base), motorised: true} ] ]; } const roll = rng(); const chosen = kind ?? (roll < 0.45 ? "out and back" : roll < 0.75 ? "loop" : "expedition"); if (chosen === "out and back") return [ [{path: outAndBack(rng, polygon, base, dayLength()), motorised: false}] ]; if (chosen === "loop") return [ [ { path: loopFrom(rng, polygon, base, dayLength()) ?? outAndBack(rng, polygon, base, dayLength()), motorised: false } ] ]; // Expedition: one or two days outward in one direction, then the same number back. const outDays = 1 + Math.floor(rng() * 2); const angle = rng() * 2 * Math.PI; const days = []; let position = base; for (let d = 0; d < outDays; d++) { const leg = meanderInside( rng, polygon, position, angle + (rng() - 0.5) * 0.4, dayLength(), base ); position = leg[leg.length - 1]; days.push([{path: leg, motorised: false}]); } for (let d = 0; d < outDays; d++) { const last = d === outDays - 1; const leg = last ? meanderTowards(rng, position, base, 3 * WALK_LENGTH_M[1], polygon) : meanderTowards(rng, position, base, dayLength(), polygon); position = leg[leg.length - 1]; days.push([{path: leg, motorised: false}]); } return days; } function outAndBack(rng, polygon, base, lengthM) { const out = meanderInside( rng, polygon, base, rng() * 2 * Math.PI, lengthM / 2, base ); const back = meanderTowards(rng, out[out.length - 1], base, lengthM, polygon); return [...out, ...back.slice(1)]; } // A one-day trip along access routes (rivers, a road). A motorised day rides 10 to // 30 km along the route between two walked stretches. function routeTrip(rng, routes, motorised) { const lengths = routes.map(pathLengthM); const total = lengths.reduce((a, b) => a + b, 0); let pick = rng() * total; let index = 0; while (index + 1 < routes.length && pick > lengths[index]) pick -= lengths[index++]; const route = routes[index]; const routeLength = lengths[index]; const clamp = (d) => Math.max(0, Math.min(routeLength, d)); const direction = rng() < 0.5 ? 1 : -1; const walk = between(rng, ...WALK_LENGTH_M); const a = rng() * routeLength; if (!motorised) return [ [{path: subPath(route, a, clamp(a + direction * walk)), motorised: false}] ]; const b = clamp(a + direction * walk * 0.4); const c = clamp(b + direction * between(rng, 10000, 30000)); const d = clamp(c + direction * walk * 0.6); return [ [ {path: subPath(route, a, b), motorised: false}, {path: subPath(route, b, c), motorised: true}, {path: subPath(route, c, d), motorised: false} ] ]; }4f:T10b8,// One patrol day: observations fall on the walked legs only, at the time the patrol // reached that point; the returned route is the whole day, motorised legs included. function patrolDay( rng, legs, {day, device, count, jitterM = 20, startHour = 7} ) { let elapsedH = 0; const timed = legs.map((leg) => { const lengthM = pathLengthM(leg.path); const speedKmh = leg.motorised ? MOTOR_KMH : WALK_KMH; const info = {...leg, lengthM, speedKmh, startH: elapsedH}; elapsedH += lengthM / 1000 / speedKmh; return info; }); const walked = timed.filter((leg) => !leg.motorised && leg.lengthM > 0); const walkedM = walked.reduce((sum, leg) => sum + leg.lengthM, 0); const points = []; for (let i = 0; i < count && walkedM > 0; i++) { let along = rng() * walkedM; let leg = walked[0]; for (const candidate of walked) { leg = candidate; if (along <= candidate.lengthM) break; along -= candidate.lengthM; } const {point} = alongPath(leg.path, along); const hour = startHour + leg.startH + along / 1000 / leg.speedKmh; points.push( observation( [ point[0] + (rng() * 2 - 1) * jitterM, point[1] + (rng() * 2 - 1) * jitterM ], device, timeOfDay(day, hour) ) ); } return {points, route: legs.flatMap((leg) => leg.path)}; } // A campaign of trips. `tripFor(rng, motorised, day)` returns one array of legs per day // of the trip; the campaign schedules trips on free days and stamps the records. function patrolCampaign( rng, { days, firstDay = 0, patrolShare, devices = 3, motorisedShare = 0.1, trackShare = 0.25, observationsPerDay, jitterM = 20, tripFor } ) { const points = []; const tracks = []; const summary = { patrolDays: 0, trips: 0, multiDayTrips: 0, motorisedTrips: 0, trackedTrips: 0 }; const [lo, hi] = observationsPerDay; for (let day = 0; day < days; day++) { if (rng() >= patrolShare) continue; const motorised = rng() < motorisedShare; const trip = tripFor(rng, motorised, day) .map((legs) => legs.filter((leg) => leg.path.length > 1)) .filter((legs) => legs.length > 0); if (trip.length === 0) continue; const device = pickDevice(rng, devices); const recordTrack = rng() < trackShare; trip.forEach((legs, offset) => { const count = lo + Math.floor(rng() * (hi - lo + 1)); const patrol = patrolDay(rng, legs, { day: firstDay + day + offset, device, count, jitterM }); points.push(...patrol.points); if (recordTrack) tracks.push({ device, time: timeOfDay(firstDay + day + offset, 7), coords: jitterLine(rng, patrol.route, 5) }); }); summary.patrolDays += trip.length; summary.trips++; if (trip.length > 1) summary.multiDayTrips++; if (motorised) summary.motorisedTrips++; if (recordTrack) summary.trackedTrips++; day += trip.length - 1; } return {points, tracks, ...summary}; } function describeCollection(...campaigns) { const total = (key) => campaigns.reduce((sum, c) => sum + c[key], 0); return `${total("trips")} patrol trips over ${total("patrolDays")} days (${total("multiDayTrips")} of them multi-day), ${total("motorisedTrips")} with a motorised leg, ${total("trackedTrips")} with a recorded track`; } // A settlement with its everyday records plus a campaign of roaming trips from it. function villageCampaign( rng, shape, base, { days = 90, firstDay = 0, patrolShare = 0.5, devices = 3, motorisedShare = 0.1, villageRecords = 40, observationsPerDay = [3, 6], transit } = {} ) { const campaign = patrolCampaign(rng, { days, firstDay, patrolShare, devices, motorisedShare, observationsPerDay, tripFor: (r, motorised) => roamingTrip(r, { polygon: shape.polygon, base, areaKm2: shape.areaKm2, motorised, transit }) }); const village = discObservations(rng, base, 400, villageRecords, { devices, firstDay, days }); return { ...campaign, points: [...village, ...campaign.points], villageRecords }; }50:T8b2,{ const rng = seededRandom(seed + 17); const shape = territoryShape(rng, {areaKm2: 600}); const base = settlementIn(rng, shape); const trips = [ ["out and back", false], ["loop", false], ["expedition", false], ["loop with a motorised transfer", true] ].map(([kind, motorised], i) => { const days = roamingTrip(rng, { polygon: shape.polygon, base, areaKm2: shape.areaKm2, motorised, kind: motorised ? undefined : kind }); const device = DEVICES[i]; const patrols = days.map((legs, offset) => patrolDay(rng, legs, {day: i * 10 + offset, device, count: 4}) ); return { kind, days: days.length, km: days.reduce( (sum, legs) => sum + legs.reduce((s, leg) => s + pathLengthM(leg.path), 0), 0 ) / 1000, points: patrols.flatMap((p) => p.points), tracks: patrols.map((p, offset) => ({ device, time: timeOfDay(i * 10 + offset, 7), coords: p.route })) }; }); const demo = finish({ points: trips.flatMap((t) => t.points), tracks: trips.flatMap((t) => t.tracks), territory: [shape.polygon] }); const {projection, xyRecords} = projectRecords(buildRecords(demo)); const time = (t) => new Date(t).toISOString().slice(5, 16).replace("T", " "); display( html`

Four trips from one settlement in a 600 km² territory, each with its route drawn as a recorded track and four observations a day. Hover an observation for its device and time.

` ); display(html`

${scenarioMap({toMetres: projection.toMetres, xyRecords, scenario: {territory: demo.territory}, title: "Four trips", width: 720, height: 480})}

${trips.map((t) => html``)}

trip	days	km	observations
${t.kind}	${t.days}	${t.km.toFixed(1)}	${t.points.length}, from ${time(Math.min(...t.points.map((p) => p.time)))} to ${time(Math.max(...t.points.map((p) => p.time)))}

`); }51:T814a,const COMMUNITY = "a community territory (100 to 10,000 km², median near 2,000)"; // One settlement in a community territory with trips from it; shared by the scenarios // that vary the records of the same base, so their figures can be compared directly. function villageBase(rng, options) { const shape = territoryShape(rng, {areaKm2: communityAreaKm2(rng)}); const base = settlementIn(rng, shape); const campaign = villageCampaign(rng, shape, base, options); return {shape, base, campaign}; } // A round no-go area of the given radius, wholly inside the territory with room to walk // around it, and at least a kilometre clear of the settlement. function noGoArea(rng, shape, base, radiusM) { const fits = (centre) => Math.hypot(centre[0] - base[0], centre[1] - base[1]) > radiusM + 1000 && d3.range(0, 360, 10).every((degrees) => { const angle = (degrees * Math.PI) / 180; return pointInPolygon( centre[0] + (radiusM + 700) * Math.cos(angle), centre[1] + (radiusM + 700) * Math.sin(angle), shape.polygon ); }); let centre = shape.toMetres([0, 0]); for (let i = 0; i < 200 && !fits(centre); i++) [centre] = uniformInPolygon(rng, shape.polygon, 1); return {centre, radiusM}; } // Records inside a no-go area are removed, and tracks are cut where they cross it. function keepOutside({points, tracks}, {centre, radiusM}) { const outside = ([x, y]) => Math.hypot(x - centre[0], y - centre[1]) > radiusM; const pieces = []; for (const track of tracks) { let piece = []; for (const coord of [...track.coords, null]) { if (coord && outside(coord)) piece.push(coord); else { if (piece.length > 1) pieces.push({...track, coords: piece}); piece = []; } } } return {points: points.filter((p) => outside([p.x, p.y])), tracks: pieces}; } // A walk around a no-go area that wanders up to 500 m outside its edge, clipped to the territory. function boundaryLegs(rng, {centre, radiusM}, polygon) { let offsetM = rng() * 500; const ring = d3.range(0, 361, 3).map((degrees) => { const angle = (degrees * Math.PI) / 180; offsetM = Math.max(0, Math.min(500, offsetM + (rng() - 0.5) * 300)); return [ centre[0] + (radiusM + offsetM) * Math.cos(angle), centre[1] + (radiusM + offsetM) * Math.sin(angle) ]; }); return clipLineToPolygon(ring, polygon).map((path) => ({ path, motorised: false })); } const scenarioCatalogue = [ { name: "Village territory", seed: 1, tests: `One settlement in ${COMMUNITY}, with three months of trips from it: out-and-back days, loops, and a few multi-day expeditions towards the edges. The baseline for a real project: how far short of the territory do the footprint and the extent land when only a settlement's surroundings are walked?`, make(rng) { const {shape, campaign} = villageBase(rng); return finish({ ...campaign, territory: [shape.polygon], collection: describeCollection(campaign) + `, plus ${campaign.villageRecords} records in the village` }); } }, { name: "Two territories", seed: 2, tests: "Two community territories of 100 to 1,000 km², each with its own settlement and trips, far enough apart not to touch. The extent should find two clusters, keep both, and leave the land between them out.", make(rng) { const areaA = 10 ** (2 + rng()); const areaB = 10 ** (2 + rng()); const separation = 2.5 * 1.2 * (Math.sqrt((areaA * KM2) / Math.PI) + Math.sqrt((areaB * KM2) / Math.PI)); const first = territoryShape(rng, {areaKm2: areaA}); const second = territoryShape(rng, { areaKm2: areaB, centreM: [separation, 0] }); const a = villageCampaign(rng, first, settlementIn(rng, first), { patrolShare: 0.45 }); const b = villageCampaign(rng, second, settlementIn(rng, second), { patrolShare: 0.3 }); return finish({ points: [...a.points, ...b.points], tracks: [...a.tracks, ...b.tracks], territory: [first.polygon, second.polygon], collection: describeCollection(a, b) + ", plus village records at each settlement" }); } }, { name: "Territory plus a training day 300 km away", seed: 3, tests: `${COMMUNITY[0].toUpperCase()}${COMMUNITY.slice(1)} with a settlement and its trips, plus five records within 80 m of each other, 300 km away, on one day. The training records are not part of the territory; the stray-cluster rule should drop them.`, make(rng) { const {shape, campaign} = villageBase(rng); const training = discObservations(rng, [300000, 20000], 80, 5, { devices: 1, deviceOffset: 4, firstDay: 45, days: 1 }); return finish({ ...campaign, points: [...campaign.points, ...training], territory: [shape.polygon], collection: describeCollection(campaign) + ", plus one training day" }); } }, { name: "Territory plus a training day 25 km away", seed: 22, tests: "The same as the training day 300 km away, but about 25 km from the settlement: inside the stray distance, so the extent keeps it as a small disc. The rule cannot tell a training day in the next town from a real visit.", make(rng) { const {shape, campaign} = villageBase(rng); const training = discObservations(rng, [20000, 10000], 80, 5, { devices: 1, deviceOffset: 4, firstDay: 45, days: 1 }); return finish({ ...campaign, points: [...campaign.points, ...training], territory: [shape.polygon], collection: describeCollection(campaign) + ", plus one training day" }); } }, { name: "8 km transect (survey fixture)", seed: 4, tests: "Not a territory: a long thin 8 x 1 km survey block walked once as a straight 8 km transect with twenty observations within 30 m of the line. Both figures only see the line, so both should report a corridor well under the block.", make(rng) { const shape = territoryShape(rng, { areaKm2: 8, kind: "polygon", aspect: 8 }); const {minX, maxX} = shape.localBounds; const axis = []; for (let i = 0; i < 40; i++) axis.push( shape.toMetres([minX + 200 + ((maxX - minX - 400) * i) / 39, 0]) ); const track = jitterLine(rng, axis, 5); const {points} = patrolDay(rng, [{path: track, motorised: false}], { day: 10, device: "A", count: 20, jitterM: 30 }); return finish({ points, tracks: [{device: "A", time: timeOfDay(10, 8), coords: track}], territory: [shape.polygon], routes: [{kind: "path", coords: axis}], collection: "one transect day with a recorded track" }); } }, { name: "Parallel paths in a 3 km block (survey fixture)", seed: 5, tests: "Not a territory: a rotated 3 x 3 km survey block covered by eight parallel tracks 400 m apart with four observations each. The tracks are well within the linking distance of each other, so the extent should fill the block; the footprint should stay clearly lower.", make(rng) { const shape = territoryShape(rng, { areaKm2: 9, kind: "square", aspect: 1 }); const {minX, minY, maxY} = shape.localBounds; const tracks = []; const points = []; for (let i = 0; i < 8; i++) { const x = minX + 100 + i * 400; const local = []; for (let k = 0; k < 30; k++) local.push([x, minY + 100 + ((maxY - minY - 200) * k) / 29]); const track = jitterLine(rng, local.map(shape.toMetres), 10); const device = DEVICES[i % 2]; tracks.push({device, time: timeOfDay(i * 3, 8), coords: track}); points.push( ...patrolDay(rng, [{path: track, motorised: false}], { day: i * 3, device, count: 4 }).points ); } return finish({ points, tracks, territory: [shape.polygon], collection: "eight survey days, each with a recorded track" }); } }, { name: "Straight road (survey fixture)", seed: 23, tests: "Not a territory: a 20 km² block twenty times longer than wide, with a road along it walked once and recorded as a track with only its two end points, plus ten observations exactly on the line. Samples in a straight line are the case Delaunay triangulation handles worst. The extent should still be a corridor twice the margin wide, and the footprint a corridor twice the buffer wide.", make(rng) { const shape = territoryShape(rng, { areaKm2: 20, kind: "polygon", aspect: 20 }); const {minX, maxX} = shape.localBounds; const road = [ shape.toMetres([minX + 200, 0]), shape.toMetres([maxX - 200, 0]) ]; const {points} = patrolDay(rng, [{path: road, motorised: false}], { day: 5, device: "A", count: 10, jitterM: 0 }); return finish({ points, tracks: [{device: "A", time: timeOfDay(5, 8), coords: road}], territory: [shape.polygon], routes: [{kind: "road", coords: road}], collection: "one day on the road, with the track recorded as its two ends" }); } }, { name: "Dense village (survey fixture)", seed: 6, tests: "Not a territory: a 1 km² village mapped almost daily for two months by four devices on short walks of 1 to 2 km, 5 to 10 observations a day. Both figures should stay near 1 km², not tens.", make(rng) { const shape = territoryShape(rng, {areaKm2: 1}); const campaign = patrolCampaign(rng, { days: 60, patrolShare: 0.7, devices: 4, motorisedShare: 0, observationsPerDay: [5, 10], tripFor: (r, motorised) => roamingTrip(r, { polygon: shape.polygon, base: shape.toMetres([0, 0]), areaKm2: 1, motorised }) }); return finish({ ...campaign, territory: [shape.polygon], collection: describeCollection(campaign) }); } }, { name: "Territory on three rivers", seed: 7, tests: `${COMMUNITY[0].toUpperCase()}${COMMUNITY.slice(1)} crossed by three meandering rivers and patrolled along them: walks along a bank, a boat ride on motorised days, observations within 300 m of the water and nothing in the forest between. The footprint sees three ribbons. Whether the extent fences in the forest between the rivers depends on how their spacing compares with the linking distance.`, make(rng) { const shape = territoryShape(rng, { areaKm2: communityAreaKm2(rng), kind: "polygon" }); const scale = Math.sqrt(shape.areaKm2 / 400); const rivers = [0.2, 0.5, 0.8].flatMap((f) => crossingLine( rng, shape, f + (rng() - 0.5) * 0.08, between(rng, 1000, 2000) * scale, between(rng, 6000, 9000) * scale ) ); const campaign = patrolCampaign(rng, { days: 180, patrolShare: 0.3, observationsPerDay: [3, 5], jitterM: 300, tripFor: (r, motorised) => routeTrip(r, rivers, motorised) }); return finish({ ...campaign, territory: [shape.polygon], routes: rivers.map((coords) => ({kind: "river", coords})), collection: describeCollection(campaign) }); } }, { name: "Empty", seed: 8, tests: "No records and no territory. Every figure should be zero and nothing should error.", make() { return finish({collection: "none"}); } }, { name: "Single point", seed: 9, tests: "One observation and no territory. The footprint is one disc of the buffer radius; the extent is one disc of the margin, because the largest cluster is always kept.", make() { return finish({ points: [observation([0, 0], "A", timeOfDay(0, 9))], collection: "one observation" }); } }, { name: "Three observations, one far away", seed: 24, tests: "Two observations 850 m apart and a third 100 km away, no territory. The far one holds a third of the records, so the share rule keeps it and the extent includes a disc 100 km away. With this few records the stray rule cannot tell a mistake from a second site.", make() { return finish({ points: [ observation([0, 0], "A", timeOfDay(0, 9)), observation([800, 300], "A", timeOfDay(0, 10)), observation([100000, 0], "B", timeOfDay(3, 9)) ], collection: "three observations" }); } }, { name: "Sightings-only patrols", seed: 11, tests: `${COMMUNITY[0].toUpperCase()}${COMMUNITY.slice(1)} patrolled twice on the same 15 to 25 km loop from the settlement, by two devices on different days, each time with 6 to 12 observations within 20 m of the loop recorded only where something was seen, and no track. The footprint under-reports even the walked corridor; implied paths recover some of it, and the two days should overlap rather than double. The extent fences in the loop only where the gaps between sightings are within the linking distance.`, make(rng) { const shape = territoryShape(rng, {areaKm2: communityAreaKm2(rng)}); const base = settlementIn(rng, shape); const loop = loopFrom(rng, shape.polygon, base, between(rng, 15000, 25000)) ?? outAndBack(rng, shape.polygon, base, between(rng, 15000, 25000)); const points = [ ...patrolDay(rng, [{path: loop, motorised: false}], { day: 3, device: "A", count: 6 + Math.floor(rng() * 7) }).points, ...patrolDay(rng, [{path: loop, motorised: false}], { day: 10, device: "B", count: 6 + Math.floor(rng() * 7) }).points ]; return finish({ points, territory: [shape.polygon], routes: [{kind: "loop", coords: loop}], collection: "two patrol days on the loop, no tracks" }); } }, { name: "Hub and spokes", seed: 12, tests: `${COMMUNITY[0].toUpperCase()}${COMMUNITY.slice(1)} used from one village along five to seven meandering footpaths that reach 60 to 95 % of the way to the boundary. Most trips walk out along a path and back the same day; once a month a trip walks a whole path out and back over several days. Nothing between the paths is visited. The footprint follows the paths; the extent fences in the wedges between neighbouring paths wherever they come within the linking distance of each other.`, make(rng) { const shape = territoryShape(rng, {areaKm2: communityAreaKm2(rng)}); const village = settlementIn(rng, shape); const spokeCount = 5 + Math.floor(rng() * 3); const phase = rng() * 2 * Math.PI; const spokes = []; for (let i = 0; i < spokeCount; i++) { const angle = phase + ((i + (rng() - 0.5) * 0.6) * 2 * Math.PI) / spokeCount; const reach = rayToBoundary(shape.polygon, village, angle) * between(rng, 0.6, 0.95); spokes.push(meanderPath(rng, village, angle, reach)); } const outAndBackOn = (path) => [...path, ...path.slice(0, -1).reverse()]; const daily = patrolCampaign(rng, { days: 90, patrolShare: 0.55, motorisedShare: 0, observationsPerDay: [2, 5], tripFor: (r) => [ [ { path: outAndBackOn( truncatePath( spokes[Math.floor(r() * spokeCount)], between(r, 2500, 7500) ) ), motorised: false } ] ] }); // Whole-path trips: a spoke walked out and back at 12 km a day, over as many days as that takes. const expeditions = patrolCampaign(rng, { days: 90, patrolShare: 1 / 30, motorisedShare: 0, trackShare: 1, observationsPerDay: [3, 6], tripFor: (r, motorised, day) => { const spoke = spokes[Math.floor(day / 30) % spokeCount]; const route = outAndBackOn(spoke); const total = pathLengthM(route); const dayCount = Math.max(1, Math.ceil(total / 12000)); const days = []; for (let d = 0; d < dayCount; d++) days.push([ { path: subPath( route, (total * d) / dayCount, (total * (d + 1)) / dayCount ), motorised: false } ]); return days; } }); const points = [ ...discObservations(rng, village, 400, 60), ...daily.points, ...expeditions.points ]; return finish({ points, tracks: [...daily.tracks, ...expeditions.tracks], territory: [shape.polygon], routes: spokes.map((coords) => ({kind: "path", coords})), collection: describeCollection(daily, expeditions) + ", plus 60 records in the village" }); } }, { name: "Coastal territory", seed: 13, tests: "A strip of land 3 to 8 km deep along a 40 to 80 km shoreline with open water on one side, used from two or three shore villages: walks inside the strip, boat rides along the shore on motorised days. A hull that fences in a bay counts water, and the water is drawn so that is visible.", make(rng) { const half = between(rng, 20000, 40000); const rotation = rng() * 2 * Math.PI; const cos = Math.cos(rotation); const sin = Math.sin(rotation); const place = ([x, y]) => [x * cos - y * sin, x * sin + y * cos]; const shoreX = (y) => 2500 * Math.sin((2 * Math.PI * y) / 30000) + 1200 * Math.sin((2 * Math.PI * y) / 9000 + 1); const depthPhase = rng() * 2 * Math.PI; const depth = (y) => 5500 + 2500 * Math.sin((2 * Math.PI * y) / 35000 + depthPhase); const shore = []; const inland = []; for (let y = -half; y <= half; y += 250) { shore.push(place([shoreX(y), y])); inland.push(place([shoreX(y) - depth(y), y])); } const territory = [...shore, ...inland.reverse()]; const water = [...shore, place([25000, half]), place([25000, -half])]; const shape = { polygon: territory, areaKm2: polygonAreaM2(territory) / KM2 }; const villageCount = 2 + Math.floor(rng() * 2); const villages = []; for (let i = 0; i < villageCount; i++) { const y = -half + ((i + 0.5 + (rng() - 0.5) * 0.5) * 2 * half) / villageCount; villages.push(place([shoreX(y) - 700, y])); } const shoreTransit = (r, from, to) => subPath( shore, nearestDistanceAlong(shore, from), nearestDistanceAlong(shore, to) ); const campaigns = villages.map((village) => villageCampaign(rng, shape, village, { patrolShare: 0.25, days: 120, villageRecords: 25, transit: shoreTransit }) ); return finish({ points: campaigns.flatMap((c) => c.points), tracks: campaigns.flatMap((c) => c.tracks), territory: [territory], water, collection: describeCollection(...campaigns) + `, plus 25 records at each of ${villageCount} villages` }); } }, { name: "Two villages sharing hunting grounds", seed: 15, tests: "One elongated territory of 100 to 1,000 km² holding two villages a third of its length apart. Trips start from one village or the other; expeditions reach into the shared ground between. Whether the two clusters join into one depends on the linking distance and on how far the expeditions reach.", make(rng) { const shape = territoryShape(rng, { areaKm2: 10 ** (2 + rng()), aspect: between(rng, 3, 4) }); const {minX, maxX} = shape.localBounds; const villages = [ shape.toMetres([minX + (maxX - minX) * 0.3, 0]), shape.toMetres([minX + (maxX - minX) * 0.7, 0]) ]; const campaigns = villages.map((village, i) => villageCampaign(rng, shape, village, { patrolShare: 0.3, firstDay: i, villageRecords: 40 }) ); return finish({ points: campaigns.flatMap((c) => c.points), tracks: campaigns.flatMap((c) => c.tracks), territory: [shape.polygon], collection: describeCollection(...campaigns) + ", plus 40 records at each village" }); } }, { name: "GPS noise", seed: 1, tests: "The same territory and trips as Village territory, with 5 % of observations displaced 100 to 500 m (bad fixes) and 1 % displaced 20 to 100 km (wrong-place fixes). Wrong-place fixes beyond the stray distance should be dropped and nearer ones kept as small discs. Compare with Village territory to see how much the extent grows.", make(rng) { const {shape, campaign} = villageBase(rng); const points = campaign.points.map((p) => { const roll = rng(); const angle = rng() * 2 * Math.PI; const shift = roll < 0.01 ? 20000 + rng() * 80000 : roll < 0.06 ? 100 + rng() * 500 : 0; return { ...p, x: p.x + shift * Math.cos(angle), y: p.y + shift * Math.sin(angle) }; }); return finish({ points, tracks: campaign.tracks, territory: [shape.polygon], collection: describeCollection(campaign) + `, plus ${campaign.villageRecords} village records; 6 % of observations displaced` }); } }, { name: "Duplicated records", seed: 1, tests: "The same territory and trips as Village territory, with every observation recorded a second time by another device with 10 m jitter, a minute later. Both figures should match Village territory to within a fraction of a percent; only the record count doubles.", make(rng) { const {shape, campaign} = villageBase(rng); const copies = campaign.points.map((p) => ({ ...p, x: p.x + (rng() - 0.5) * 20, y: p.y + (rng() - 0.5) * 20, device: "B", time: p.time + 60000 })); return finish({ points: [...campaign.points, ...copies], tracks: campaign.tracks, territory: [shape.polygon], collection: describeCollection(campaign) + ", every observation duplicated" }); } }, { name: "Densely recorded tracks", seed: 25, tests: "A village territory with six weeks of trips, every track recorded once a second, about a vertex per metre. Both figures should match the same tracks recorded every 100 m; only the vertex count changes, which the footprint reports before and after simplification.", make(rng) { const {shape, campaign} = villageBase(rng, {days: 45}); const dense = (coords) => { const out = []; for (let i = 1; i < coords.length; i++) { const [ax, ay] = coords[i - 1]; const [bx, by] = coords[i]; const steps = Math.max(1, Math.round(Math.hypot(bx - ax, by - ay))); for (let k = 0; k < steps; k++) out.push([ ax + ((bx - ax) * k) / steps + (rng() - 0.5) * 2, ay + ((by - ay) * k) / steps + (rng() - 0.5) * 2 ]); } out.push(coords[coords.length - 1]); return out; }; return finish({ ...campaign, tracks: campaign.tracks.map((t) => ({...t, coords: dense(t.coords)})), territory: [shape.polygon], collection: describeCollection(campaign) + ", tracks recorded once a second" }); } }, { name: "Tracks with a signal gap", seed: 26, tests: "A village territory where every recorded track loses its middle third to a signal gap, leaving one straight segment that shortcuts the real route. Both figures treat the segment as walked. Splitting tracks at long segments would change that; this scenario shows by how much.", make(rng) { const {shape, campaign} = villageBase(rng); const gapped = (coords) => [ ...coords.slice(0, Math.floor(coords.length * 0.4)), ...coords.slice(Math.floor(coords.length * 0.7)) ]; return finish({ ...campaign, tracks: campaign.tracks.map((t) => ({...t, coords: gapped(t.coords)})), territory: [shape.polygon], collection: describeCollection(campaign) + ", each track missing its middle third" }); } }, { name: "Road corridor", seed: 19, tests: "A long thin territory (about 100 x 5 km) with a winding road along its length, patrolled by walks along the road with vehicle rides between stretches on one trip in five; observations within 50 m of the road, no interior. The footprint is a corridor; the extent also fences in bends of the road that come within the linking distance of each other. Both fall far short of the territory.", make(rng) { const shape = territoryShape(rng, { areaKm2: 500, kind: "polygon", aspect: between(rng, 15, 20) }); const road = crossingLine( rng, shape, 0.5, between(rng, 600, 1000), between(rng, 12000, 18000) ); const campaign = patrolCampaign(rng, { days: 120, patrolShare: 0.3, motorisedShare: 0.2, observationsPerDay: [3, 5], jitterM: 50, tripFor: (r, motorised) => routeTrip(r, road, motorised) }); return finish({ ...campaign, territory: [shape.polygon], routes: road.map((coords) => ({kind: "road", coords})), collection: describeCollection(campaign) }); } }, { name: "Large territory, few points", seed: 21, tests: "The largest community territory (10,000 km²) visited on about a dozen trips in a year, half of them with a vehicle transfer to a distant part, 2 to 4 observations a day. Sparse records shrink both figures. Each distant trip forms its own cluster with only a few records, and should be kept unless it lies beyond the stray distance.", make(rng) { const shape = territoryShape(rng, {areaKm2: 10000, kind: "polygon"}); const base = settlementIn(rng, shape); const campaign = patrolCampaign(rng, { days: 365, patrolShare: 0.033, devices: 2, motorisedShare: 0.5, observationsPerDay: [2, 4], tripFor: (r, motorised) => roamingTrip(r, { polygon: shape.polygon, base, areaKm2: shape.areaKm2, motorised }) }); return finish({ ...campaign, territory: [shape.polygon], collection: describeCollection(campaign) }); } }, { name: "Sacred site, boundary walked", seed: 27, tests: "A village territory with a round no-go area 11 km across (about 100 km²) inside it: a sacred site that patrols never enter, with any record inside it removed and tracks cut where they cross it. One day's walk around its edge, wandering up to 500 m out, is recorded as a track with observations. Records surround the site on all sides, so it should count: the triangle rule fills it, and the closing does once encircled ground up to about 210 km² is filled.", make(rng) { const {shape, base, campaign} = villageBase(rng); const site = noGoArea(rng, shape, base, 5700); const kept = keepOutside(campaign, site); const legs = boundaryLegs(rng, site, shape.polygon); const walk = patrolDay(rng, legs, {day: 40, device: "E", count: 12}); return finish({ points: [...kept.points, ...walk.points], tracks: [ ...kept.tracks, { device: "E", time: timeOfDay(40, 7), coords: jitterLine(rng, walk.route, 5) } ], territory: [shape.polygon], routes: legs.map(({path}) => ({kind: "loop", coords: path})), collection: describeCollection(campaign) + ", plus one walk around the no-go area" }); } }, { name: "Sacred site, sightings only", seed: 28, tests: "The same no-go area, but the walk around it left only two dozen observations and no track. The ring is closed only where neighbouring sightings are within a linking distance of each other; at 5 km it is, so both rules can count the site, and lowering the linking distance opens it.", make(rng) { const {shape, base, campaign} = villageBase(rng); const site = noGoArea(rng, shape, base, 5700); const kept = keepOutside(campaign, site); const legs = boundaryLegs(rng, site, shape.polygon); const walk = patrolDay(rng, legs, {day: 40, device: "E", count: 24}); return finish({ points: [...kept.points, ...walk.points], tracks: kept.tracks, territory: [shape.polygon], routes: legs.map(({path}) => ({kind: "loop", coords: path})), collection: describeCollection(campaign) + ", plus two dozen sightings around the no-go area" }); } }, { name: "Concession on the territory edge", seed: 29, tests: "A concession 14 km across straddling the territory boundary, most of it outside. Patrols walk its inland edge and never enter it. Records surround it on one side only, so neither rule should count it: it is a bay in the shape, not a hole.", make(rng) { const {shape, campaign} = villageBase(rng); const vertex = shape.polygon[Math.floor(rng() * shape.polygon.length)]; const middle = shape.toMetres([0, 0]); const away = Math.hypot(vertex[0] - middle[0], vertex[1] - middle[1]); const site = { centre: [ vertex[0] + ((vertex[0] - middle[0]) / away) * 4000, vertex[1] + ((vertex[1] - middle[1]) / away) * 4000 ], radiusM: 7000 }; const kept = keepOutside(campaign, site); const legs = boundaryLegs(rng, site, shape.polygon); const walk = patrolDay(rng, legs, {day: 40, device: "E", count: 10}); return finish({ points: [...kept.points, ...walk.points], tracks: [ ...kept.tracks, ...legs.map(({path}, i) => ({ device: "E", time: timeOfDay(40 + i, 7), coords: jitterLine(rng, path, 5) })) ], territory: [shape.polygon], routes: legs.map(({path}) => ({kind: "loop", coords: path})), collection: describeCollection(campaign) + ", plus a walk along the concession's inland edge" }); } }, { name: "Logging concession, boundary patrolled", seed: 30, tests: "A territory of 2,000 to 5,000 km² with a logging concession 14 km across (about 160 km²) inside it that nobody can enter, its boundary walked over three days with tracks. The triangle rule counts it; the closing counts it only when encircled ground up to about 300 km² is filled, which is the slider's job.", make(rng) { const shape = territoryShape(rng, {areaKm2: between(rng, 2000, 5000)}); const base = settlementIn(rng, shape); const campaign = villageCampaign(rng, shape, base); const site = noGoArea(rng, shape, base, 7100); const kept = keepOutside(campaign, site); const [{path: ring}] = boundaryLegs(rng, site, shape.polygon); const third = Math.ceil(ring.length / 3); const days = d3.range(3).map((i) => ({ path: ring.slice(i * third, Math.min(ring.length, (i + 1) * third + 1)), day: 60 + 7 * i })); const walks = days.map(({path, day}) => ({ day, ...patrolDay(rng, [{path, motorised: false}], { day, device: "D", count: 6 }) })); return finish({ points: [...kept.points, ...walks.flatMap((w) => w.points)], tracks: [ ...kept.tracks, ...walks.map((w) => ({ device: "D", time: timeOfDay(w.day, 7), coords: jitterLine(rng, w.route, 5) })) ], territory: [shape.polygon], routes: [{kind: "loop", coords: ring}], collection: describeCollection(campaign) + ", plus three days walking the concession boundary" }); } } ];52:T1156,// Consecutive observations by the same device on the same UTC day, closer in // time than the gap and closer in space than the distance, are joined into a path. function impliedPaths(points, gapHours, maxKm) { const gapMs = gapHours * 3600 * 1000; const maxM = maxKm * 1000; const byDeviceAndDay = new Map(); for (const p of points) { const key = `${p.device}|${Math.floor(p.time / DAY_MS)}`; if (!byDeviceAndDay.has(key)) byDeviceAndDay.set(key, []); byDeviceAndDay.get(key).push(p); } const paths = []; for (const key of [...byDeviceAndDay.keys()].sort()) { const dayPoints = byDeviceAndDay .get(key) .slice() .sort((a, b) => a.time - b.time || a.lon - b.lon || a.lat - b.lat); let run = [dayPoints[0]]; const flush = () => { if (run.length > 1) paths.push({ device: run[0].device, time: run[0].time, coords: run.map((p) => [p.lon, p.lat]) }); }; for (let i = 1; i < dayPoints.length; i++) { const previous = dayPoints[i - 1]; const next = dayPoints[i]; const closeInTime = next.time - previous.time <= gapMs; const closeInSpace = lonLatDistanceM([previous.lon, previous.lat], [next.lon, next.lat]) <= maxM; if (closeInTime && closeInSpace) run.push(next); else { flush(); run = [next]; } } flush(); } return paths; } function buildRecords( scenario, {impliedPaths: on = true, gapHours = 2, maxKm = 2} = {} ) { const points = scenario.points.map((p) => ({ kind: "point", device: p.device, time: p.time, coords: [[p.lon, p.lat]] })); const tracks = scenario.tracks.map((t) => ({ kind: "track", device: t.device, time: t.time, coords: t.coords })); const implied = on ? impliedPaths(scenario.points, gapHours, maxKm).map((t) => ({ kind: "implied", ...t })) : []; return [...points, ...tracks, ...implied]; } // The crossing from longitude and latitude into estimator metres. The projection is // returned with the records because everything downstream has to share this one frame. function projectRecords(records) { const projection = metresProjection(records.flatMap((r) => r.coords)); const xyRecords = records.map((r) => ({ ...r, xy: r.coords.map(projection.toMetres) })); return {projection, xyRecords}; } // Observations plus every track sampled every stepM along each segment, tagged // with the record index and sorted so nothing downstream depends on record order. function samplesAlong(xyRecords, stepM) { const samples = []; xyRecords.forEach((record, index) => { const line = record.xy; if (line.length === 1) samples.push({x: line[0][0], y: line[0][1], record: index}); for (let i = 0; i + 1 < line.length; i++) { const [x0, y0] = line[i]; const [x1, y1] = line[i + 1]; const steps = Math.max( 1, Math.ceil(Math.hypot(x1 - x0, y1 - y0) / stepM) ); for (let k = 0; k <= steps; k++) samples.push({ x: x0 + ((x1 - x0) * k) / steps, y: y0 + ((y1 - y0) * k) / steps, record: index }); } }); samples.sort((a, b) => a.x - b.x || a.y - b.y || a.record - b.record); // Adjacent segments share a vertex, so drop repeated positions from the same record. return samples.filter( (s, i) => i === 0 || s.x !== samples[i - 1].x || s.y !== samples[i - 1].y || s.record !== samples[i - 1].record ); } // The scenario as it stood after the first n records in time order, for n in // `steps` even shares of the total. Both estimator notebooks draw their // accumulation curve by running the estimator over this list. function accumulationSteps(scenario, steps = 16) { const ordered = [ ...scenario.points.map((p) => ({kind: "point", ...p})), ...scenario.tracks.map((t) => ({kind: "track", ...t})) ].sort((a, b) => a.time - b.time); const counts = new Set(); for (let i = 1; i <= steps; i++) { const n = Math.round((ordered.length * i) / steps); if (n > 0) counts.add(n); } return [...counts].map((records) => { const subset = ordered.slice(0, records); return { records, scenario: { ...scenario, points: subset.filter((r) => r.kind === "point"), tracks: subset.filter((r) => r.kind === "track") } }; }); }53:Td67,// A unit outline centred on the origin. "natural" wobbles like ridges and river // bends; "polygon" has 4 to 7 vertices as a technical mapper would draw between // neighbouring titles; "square" is a square. function unitOutline(rng, kind) { if (kind === "square") return [ [-1, -1], [1, -1], [1, 1], [-1, 1] ]; if (kind === "polygon") { const n = 4 + Math.floor(rng() * 4); const phase = rng() * 2 * Math.PI; const outline = []; for (let i = 0; i < n; i++) { const angle = phase + ((i + (rng() - 0.5) * 0.7) * 2 * Math.PI) / n; const radius = 0.6 + rng() * 0.4; outline.push([radius * Math.cos(angle), radius * Math.sin(angle)]); } return outline; } const harmonics = [2, 3, 4, 5, 6].map((k) => ({ k, amplitude: (0.04 + rng() * 0.1) / (k <= 3 ? 1 : 1.5), phase: rng() * 2 * Math.PI })); const outline = []; for (let i = 0; i < 160; i++) { const theta = (i / 160) * 2 * Math.PI; let r = 1; for (const h of harmonics) r += h.amplitude * Math.sin(h.k * theta + h.phase); outline.push([ Math.max(0.3, r) * Math.cos(theta), Math.max(0.3, r) * Math.sin(theta) ]); } return outline; } function randomKind(rng) { const roll = rng(); return roll < 0.45 ? "natural" : roll < 0.85 ? "polygon" : "square"; } // Aspect ratios lean towards round but reach 4 (a long thin territory). function randomAspect(rng) { return 1 + rng() * rng() * 3; } // Community territories run from 100 to 10,000 km² with a median near 2,000 km². function communityAreaKm2(rng) { return 10 ** (2 + 2 * rng() ** 0.6); } // A territory of the given area. `local` is the unrotated outline centred on the // origin with its long axis along x, so routes can be laid out in that frame and // mapped through `toMetres`, which applies the rotation and the centre. function territoryShape( rng, { areaKm2, kind = randomKind(rng), aspect = randomAspect(rng), rotation = rng() * Math.PI, centreM = [0, 0] } ) { const stretched = unitOutline(rng, kind).map(([x, y]) => [ x * Math.sqrt(aspect), y / Math.sqrt(aspect) ]); const scale = Math.sqrt((areaKm2 * KM2) / polygonAreaM2(stretched)); const local = stretched.map(([x, y]) => [x * scale, y * scale]); const cos = Math.cos(rotation); const sin = Math.sin(rotation); const toMetres = ([x, y]) => [ centreM[0] + x * cos - y * sin, centreM[1] + x * sin + y * cos ]; const polygon = local.map(toMetres); return { kind, aspect, rotation, centreM, local, toMetres, polygon, areaKm2: polygonAreaM2(polygon) / KM2, localBounds: boundsOf(local) }; } function uniformInPolygon(rng, polygon, count, minSeparationM = 0) { const {minX, maxX, minY, maxY} = boundsOf(polygon); const points = []; let attempts = 0; while (points.length < count && attempts++ < 100000) { const x = minX + rng() * (maxX - minX); const y = minY + rng() * (maxY - minY); if (!pointInPolygon(x, y, polygon)) continue; if (points.some(([px, py]) => Math.hypot(px - x, py - y) < minSeparationM)) continue; points.push([x, y]); } return points; } // A settlement somewhere in the inner part of a territory. function settlementIn(rng, shape) { const inner = shape.local.map(([x, y]) => shape.toMetres([x * 0.5, y * 0.5])); return uniformInPolygon(rng, inner, 1)[0]; }54:T45b,55:[] 43:{"id":"4b7987c30492a1b9","slug":"scenarios","title":"Generating realistic CoMapeo data","thumbnail":"64d7d8a49b82f8e8d2eebf1690478da46cbca4cb6c31cd82b9c9dd3c3a82f0ec","access_level":"public","create_time":"$D2026-09-14T09:08:32.047Z","update_time":"$D2026-10-14T16:30:40.343Z","view_time":null,"first_public_time":"$D2026-09-16T19:14:31.071Z","has_unpublished_edits":null,"fork":false,"stars":0,"starred":false,"owner":{"type":"team","id":"b8f17b38290a2173","login":"gmaclennan","name":"Gregor MacLennan","avatar_url":"https://avatars-next.observableusercontent.com/63198fee32cdf9a62fee6dd70e000a4d5ed970cb33b7194192381ee674ab230d","tier":"starter_2024","bio":""},"version":348,"publish_version":348,"role":null,"authored":false,"authors":[{"type":"individual","id":"fb7d131148ad1e60","login":"gmaclennan","name":"Gregor MacLennan","avatar_url":"https://avatars-next.observableusercontent.com/63198fee32cdf9a62fee6dd70e000a4d5ed970cb33b7194192381ee674ab230d","tier":null,"bio":""}],"members":[{"type":"team","id":"b8f17b38290a2173","login":"gmaclennan","name":"Gregor MacLennan","avatar_url":"https://avatars-next.observableusercontent.com/63198fee32cdf9a62fee6dd70e000a4d5ed970cb33b7194192381ee674ab230d","tier":"starter_2024","role":"editor"}],"comments":[],"custom_thumbnail":false,"trashed":false,"lapsed":null,"subscribed":null,"forks":0,"collection":null,"type":"notebook","body":{"titling":"auto","title":"Generating realistic CoMapeo data","cells":[{"id":1,"value":"$45","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":25,"value":"## Seed\n\nEvery scenario below is drawn from this seed. Type a number or press the button for a fresh one.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":29,"value":"view(Inputs.number([0, 999999], {\n label: \"Seed\",\n value: seed,\n step: 1\n}))","pinned":false,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":26,"value":"const seed = view(Inputs.button(\"New seed\", {\n value: 1,\n reduce: () => Math.floor(Math.random() * 10000)\n}));\n","pinned":false,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":30,"value":"## All scenarios at a glance\n\nEvery scenario at the current seed. Grey is the territory, dotted grey lines are the access routes, blue lines are recorded tracks, dots are observations. Click a map to open that scenario below.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":65,"value":"display(html`Selected: ${selectedSpec.name}`)\nconst scenario = makeScenario(selectedSpec, seed)\nconst {projection, xyRecords} = projectRecords(buildRecords(scenario));","pinned":false,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":31,"value":"html`

${scenarioCatalogue.map((spec, i) => {\n const s = makeScenario(spec, seed);\n const {projection, xyRecords} = projectRecords(buildRecords(s));\n const map = scenarioMap({toMetres: projection.toMetres, xyRecords, scenario: s, compact: true, width: 320, height: 240});\n return html`

selectSpec(spec)} title=${spec.tests}>${map}\n

${spec.name}
${s.points.length} observations, ${s.tracks.length} tracks; territory ${s.territoryKm2.toFixed(0)} km²

`;\n})}

`","pinned":false,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":68,"value":"### ${scenario.name} (seed ${scenario.seed})\n\n${scenario.tests}","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":69,"value":"$46","pinned":false,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":32,"value":"const selectedSpec = Mutable(scenarioCatalogue[0]);\nfunction selectSpec(spec) {\n selectedSpec.value = spec\n}","pinned":false,"hidden":true,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":36,"value":"# How the data is generated","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":37,"value":"## Constants","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":38,"value":"// Radius of the earth in meters\nconst EARTH_RADIUS_M = 6371008.8;\n// Center for territories (Amazon rainforest)\nconst BASE = [-62.2, -3.5];\nconst DAY_MS = 24 * 3600 * 1000;\nconst EPOCH = Date.UTC(2025, 0, 1);\n// Devices used for record generation\nconst DEVICES = [\"A\", \"B\", \"C\", \"D\", \"E\"];\nconst KM2 = 1e6;","pinned":true,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":39,"value":"## Seeded random number generator\n\nScenarios are randomly generated, but we use a seeded PNRG for reproducible data","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":35,"value":"function seededRandom(seed) {\n let state = seed >>> 0;\n return () => {\n state = (state + 0x6d2b79f5) >>> 0;\n let t = state;\n t = Math.imul(t ^ (t >>> 15), t | 1);\n t ^= t + Math.imul(t ^ (t >>> 7), t | 61);\n return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n };\n}\n\nconst between = (rng, lo, hi) => lo + rng() * (hi - lo);","pinned":true,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":41,"value":"## Coordinate & projection helpers\n\nThree coordinate systems are used:\n\n- **Generator metres.** The generator works in metres east and north of one base point in the Amazon (longitude -62.2, latitude -3.5). Territories, routes and walks are built here, where a metre is a metre and `polygonAreaM2` gives a territory's exact area\n- **Longitude and latitude.** Scenarios are published in unprojected lon and lat, reflecting real data from devices..\n- **Estimator metres.** To calculate areas we project the record set to meters: equirectangular about the median latitude of that record set.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":42,"value":"$47","pinned":true,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":43,"value":"## Planar geometry\n\nSmall helpers on polygons given as arrays of [x, y] metres: the shoelace area, a ray-casting point-in-polygon test, bounds, the distance from a point along a bearing to the far side of the polygon (used to size footpaths and tributaries so they stop short of the boundary), and clipping a line to the vertices that fall inside a polygon.\n","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":44,"value":"$48","pinned":true,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":46,"value":"const counter1 = view(Inputs.button(\"Re-generate Below\", { value: 0, reduce: value => value + 1 }))","pinned":false,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":45,"value":"$49","pinned":false,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":48,"value":"## Access routes\n\nRoutes are polylines in metres. `meanderPath` is a footpath: the heading drifts as a random walk but is pulled back towards its target direction, so it wanders without doubling back. `meanderLine` is a river or road: a sine meander plus a random drift about a straight heading. `crossingLine` lays a river or road across the whole territory along its long axis and clips it to the polygon. `wobblyLoop` is a patrol loop, a circle disturbed by harmonics. `alongPath` and `truncatePath` find positions and prefixes along a route.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":49,"value":"$4a","pinned":true,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":50,"value":"## Observations\n\nAn observation is a position in metres, a device letter and a timestamp; `finish` converts positions to longitude and latitude at the end. Settlements get some everyday records spread over a disc around them; everything else comes from patrols. Recorded tracks are the day's route with a few metres of GPS jitter.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":51,"value":"$4b","pinned":true,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":52,"value":"$4c","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":53,"value":"$4d","pinned":true,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":54,"value":"$4e","pinned":true,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":55,"value":"$4f","pinned":true,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":56,"value":"$50","pinned":false,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":57,"value":"## Assembling a scenario\n\n`finish` converts a metre-space draft into the scenario the estimator notebooks consume: observations and tracks in longitude and latitude, the territory polygons with their exact area, the access routes, any water, and a one-line description of how the records were collected.\n","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":58,"value":"// Convert a metre-space draft into the lon/lat scenario the notebooks consume.\nfunction finish({\n points = [],\n tracks = [],\n territory = [],\n routes = [],\n water = null,\n collection = \"\"\n}) {\n return {\n points: points.map(({x, y, device, time}) => {\n const [lon, lat] = lonLatFromBase([x, y]);\n return {lon, lat, device, time};\n }),\n tracks: tracks.map((t) => ({\n device: t.device,\n time: t.time,\n coords: t.coords.map(lonLatFromBase)\n })),\n territory: territory.map((polygon) => polygon.map(lonLatFromBase)),\n territoryKm2:\n territory.reduce((sum, polygon) => sum + polygonAreaM2(polygon), 0) / KM2,\n routes: routes.map((r) => ({\n kind: r.kind,\n coords: r.coords.map(lonLatFromBase)\n })),\n water: water ? water.map(lonLatFromBase) : null,\n collection\n };\n}","pinned":true,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":59,"value":"## Scenario catalogue\n\nEach entry names the scenario, gives it a seed offset, states in one line what it tests and what a reasonable answer looks like, and builds it from a seeded random function using the pieces above. Twenty-one scenarios: community territories with different access patterns, the awkward cases the estimators must not be fooled by (a training day far away, GPS noise, duplicated records, a single point, nothing at all), and three small survey fixtures.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":33,"value":"$51","pinned":true,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":60,"value":"// Every scenario draws from the notebook's seed mixed with its own number, so one\n// seed regenerates the whole catalogue.\nfunction makeScenario(spec, seed) {\n return {\n name: spec.name,\n tests: spec.tests,\n seed,\n ...spec.make(seededRandom((seed * 1000003 + spec.seed) >>> 0))\n };\n}","pinned":true,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":61,"value":"## Records for the estimators\n\nThe estimator notebooks do not read scenarios directly; they build a record list from one. `buildRecords` turns observations and tracks into records in longitude and latitude and, when the implied-path option is on, joins consecutive observations by one device on one day (closer than a time gap and a distance) into a path treated like a track. That join is the one piece of the pipeline that works on the records as stored.\n\n`projectRecords` is the crossing into estimator metres: it derives one projection from the record set and keeps it alongside the projected records, so everything downstream (the estimators and the map) uses the same frame. `samplesAlong` turns projected records into observation positions plus points every given step along each track, sorted so nothing downstream depends on record order. `accumulationSteps` replays a scenario in time order for the accumulation curves.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":62,"value":"$52","pinned":true,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":63,"value":"{\n const paths = impliedPaths(scenario.points, 2, 2);\n const km = paths.reduce((sum, p) => sum + lonLatLengthM(p.coords), 0) / 1000;\n display(\n html`

For the selected scenario (${scenario.name}), joining observations by one device on one day within 2 hours and 2 km of each other gives ${paths.length} implied paths totalling ${km.toFixed(1)} km. The footprint and extent notebooks expose those two thresholds as controls.

`\n );\n}","pinned":true,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":34,"value":"$53","pinned":true,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":64,"value":"$54","pinned":true,"hidden":false,"mode":"html","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":24,"value":"import { scenarioMap, PALETTE } from \"observable:@gmaclennan/scenario-map\"","pinned":true,"hidden":false,"mode":"ts","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"}],"files":"$W55","stdlib":"2"}} 44:"$43:body"