leaflet-city-mapper 0.0.2 → 0.0.4

package/src/traffic/uploadTrafficLanes.js

@@ -0,0 +1,21 @@
+import { trafficStorage } from './trafficStorage.js';
+
+export function uploadTrafficLanes(state, device) {
+  let lane, i, point, count = 0;
+  for (lane of state.lanes) count += lane.points.length;
+  const data = /* alloc */ new Float32Array(count * 4);
+  let offset = 0;
+  for (lane of state.lanes) {
+    lane.start = offset / 4;
+    for (i = 0; i < lane.points.length; i++) {
+      point = lane.points[i];
+      data[offset++] = point[0];
+      data[offset++] = point[1];
+      data[offset++] = point[2];
+      data[offset++] = lane.lengths[i];
+    }
+  }
+  state.gpu.points?.destroy();
+  state.gpu.points = trafficStorage(device, data);
+  state.lanesDirty = false;
+}

package/src/traffic/vehicleOffsets.js

@@ -0,0 +1,12 @@
+import { speed } from '../globals/speed.js';
+
+
+/** Evenly spaced starting offsets (metres) for `flow` vehicles/h moving at `velocity` m/s on a `length` metres lane. */
+
+export function vehicleOffsets(length, flow, velocity = speed) {
+  const count = Math.round(length * flow / 3600 / velocity);
+  const offsets = Array.from(/* alloc */ { length: count });
+  let i;
+  for (i = 0; i < offsets.length; i++) offsets[i] = (i + 0.5) * length / count;
+  return offsets;
+}

package/src/triangulation/area.js

@@ -0,0 +1,9 @@
+export function area(ring) {
+  let sum = 0;
+  let i, p, q;
+  for (i = 0; i < ring.length; i++) {
+    p = ring[i], q = ring[(i + 1) % ring.length];
+    sum += p.x * q.y - q.x * p.y;
+  }
+  return Math.abs(sum) / 2;
+}

package/src/triangulation/clean.js

@@ -0,0 +1,18 @@
+import { cross } from './cross.js';
+import { equal } from './equal.js';
+
+export function clean(ring) {
+  let changed = true;
+  let i, a, b, c;
+  while (changed && ring.length > 3) {
+    changed = false;
+    for (i = 0; i < ring.length; i++) {
+      a = ring[(i + ring.length - 1) % ring.length], b = ring[i], c = ring[(i + 1) % ring.length];
+      if (equal(a, b) || Math.abs(cross(a, b, c)) < 1e-10) {
+        ring.splice(i, 1); changed = true; break;
+      }
+    }
+  }
+  if (ring.length < 3) throw /* alloc */ new Error('Degenerate polygon ring');
+  return ring;
+}

package/src/triangulation/clipEars.js

@@ -0,0 +1,23 @@
+import { cross } from './cross.js';
+import { containsVertex } from './containsVertex.js';
+
+export function clipEars(polygon) {
+  const result = /* alloc */ [];
+  let clipped, i, a, b, c, p;
+  while (polygon.length > 3) {
+    clipped = false;
+    for (i = 0; i < polygon.length; i++) {
+      a = polygon[(i + polygon.length - 1) % polygon.length], b = polygon[i], c = polygon[(i + 1) % polygon.length];
+      if (cross(a, b, c) <= 1e-10) continue;
+      if (containsVertex(polygon, a, b, c)) continue;
+      result.push(/* alloc */ [a.index, b.index, c.index]); polygon.splice(i, 1); clipped = true; break;
+    }
+    if (!clipped) throw /* alloc */ new Error('Unable to triangulate polygon: invalid or self-intersecting rings');
+  }
+  if (cross(...polygon) > 1e-10) {
+    const triangle = /* alloc */ [];
+    for (p of polygon) triangle.push(p.index);
+    result.push(triangle);
+  }
+  return result;
+}

package/src/triangulation/connectHole.js

@@ -0,0 +1,18 @@
+import { inside } from './inside.js';
+import { insideHole } from './insideHole.js';
+import { crossesBoundary } from './crossesBoundary.js';
+
+export function connectHole(polygon, hole, rings, mid) {
+  let h2 = -1, p2 = -1, distance = Infinity, h, p, a, b, d;
+  for (h = 0; h < hole.length; h++) for (p = 0; p < polygon.length; p++) {
+    a = hole[h], b = polygon[p], d = (a.x - b.x) ** 2 + (a.y - b.y) ** 2;
+    if (d >= distance) continue;
+    mid.x = (a.x + b.x) / 2; mid.y = (a.y + b.y) / 2;
+    if (!inside(mid, rings[0]) || insideHole(mid, rings)) continue;
+    if (crossesBoundary(a, b, polygon, rings)) continue;
+    h2 = h; p2 = p; distance = d;
+  }
+  if (h2 < 0) throw /* alloc */ new Error('Unable to connect polygon hole');
+  return /* alloc */ [...polygon.slice(0, p2 + 1), ...hole.slice(h2), ...hole.slice(0, h2 + 1),
+    polygon[p2], ...polygon.slice(p2 + 1)];
+}

package/src/triangulation/containsVertex.js

@@ -0,0 +1,11 @@
+import { equal } from './equal.js';
+import { cross } from './cross.js';
+
+export function containsVertex(polygon, a, b, c) {
+  let p;
+  for (p of polygon) {
+    if (!equal(p, a) && !equal(p, b) && !equal(p, c) &&
+      cross(a, b, p) >= 0 && cross(b, c, p) >= 0 && cross(c, a, p) >= 0) return true;
+  }
+  return false;
+}

package/src/triangulation/cross.js

@@ -0,0 +1,3 @@
+export function cross(a, b, c) {
+  return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+}

package/src/triangulation/crossesBoundary.js

@@ -0,0 +1,8 @@
+import { crossesRing } from './crossesRing.js';
+
+export function crossesBoundary(a, b, polygon, rings) {
+  if (crossesRing(a, b, polygon)) return true;
+  let i;
+  for (i = 1; i < rings.length; i++) if (crossesRing(a, b, rings[i])) return true;
+  return false;
+}

package/src/triangulation/crossesRing.js

@@ -0,0 +1,9 @@
+import { intersects } from './intersects.js';
+
+export function crossesRing(a, b, ring) {
+  let i;
+  for (i = 0; i < ring.length; i++) {
+    if (intersects(a, b, ring[i], ring[(i + 1) % ring.length])) return true;
+  }
+  return false;
+}

package/src/triangulation/equal.js

@@ -0,0 +1,3 @@
+export function equal(a, b) {
+  return a.x === b.x && a.y === b.y;
+}

package/src/triangulation/inside.js

@@ -0,0 +1,10 @@
+export function inside(point, ring) {
+  let result = false;
+  let i, j, a, b;
+  for (i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+    a = ring[i], b = ring[j];
+    if ((a.y > point.y) !== (b.y > point.y) &&
+      point.x < (b.x - a.x) * (point.y - a.y) / (b.y - a.y) + a.x) result = !result;
+  }
+  return result;
+}

package/src/triangulation/insideHole.js

@@ -0,0 +1,7 @@
+import { inside } from './inside.js';
+
+export function insideHole(point, rings) {
+  let i;
+  for (i = 1; i < rings.length; i++) if (inside(point, rings[i])) return true;
+  return false;
+}

package/src/triangulation/intersects.js

@@ -0,0 +1,11 @@
+import { equal } from './equal.js';
+import { cross } from './cross.js';
+import { on } from './on.js';
+
+export function intersects(a, b, c, d) {
+  if (equal(a, c) || equal(a, d) || equal(b, c) || equal(b, d)) return false;
+  const abC = cross(a, b, c), abD = cross(a, b, d), cdA = cross(c, d, a), cdB = cross(c, d, b);
+  return abC * abD < 0 && cdA * cdB < 0 ||
+    abC === 0 && on(a, b, c) || abD === 0 && on(a, b, d) ||
+    cdA === 0 && on(c, d, a) || cdB === 0 && on(c, d, b);
+}

package/src/triangulation/isClockWise.js

@@ -0,0 +1,13 @@
+/**
+ * @returns {boolean} Whether the `{x, y}` points are in clockwise order.
+ */
+
+export function isClockWise(points) {
+  let area = 0;
+  let i, a, b;
+  for (i = 0; i < points.length; i++) {
+    a = points[i], b = points[(i + 1) % points.length];
+    area += a.x * b.y - b.x * a.y;
+  }
+  return area < 0;
+}

package/src/triangulation/mergeHoles.js

@@ -0,0 +1,11 @@
+export function mergeHoles(source, target, start, width) {
+  const middle = Math.min(start + width, source.length), end = Math.min(start + width * 2, source.length);
+  let left = start, right = middle, output;
+  for (output = start; output < end; output++) {
+    if (left < middle && (right >= end || source[left].x <= source[right].x)) {
+      target[output] = source[left++];
+    } else {
+      target[output] = source[right++];
+    }
+  }
+}

package/src/triangulation/minimumX.js

@@ -0,0 +1,6 @@
+export function minimumX(ring) {
+  let minimum = Infinity;
+  let point;
+  for (point of ring) minimum = Math.min(minimum, point.x);
+  return minimum;
+}

package/src/triangulation/on.js

@@ -0,0 +1,4 @@
+export function on(p, q, r) {
+  return Math.min(p.x, q.x) <= r.x && r.x <= Math.max(p.x, q.x) &&
+    Math.min(p.y, q.y) <= r.y && r.y <= Math.max(p.y, q.y);
+}

package/src/triangulation/polygonRings.js

@@ -0,0 +1,14 @@
+import { clean } from './clean.js';
+import { isClockWise } from './isClockWise.js';
+
+export function polygonRings(paths, vertices) {
+  const rings = /* alloc */ [];
+  let offset = 0, index, path, ring;
+  for (index = 0; index < paths.length; index++) {
+    path = paths[index];
+    ring = clean(vertices.slice(offset, offset += path.length));
+    if (isClockWise(ring) !== Boolean(index)) ring.reverse();
+    rings.push(ring);
+  }
+  return rings;
+}

package/src/triangulation/sortHoles.js

@@ -0,0 +1,21 @@
+import { minimumX } from './minimumX.js';
+import { mergeHoles } from './mergeHoles.js';
+
+export function sortHoles(holes) {
+  if (holes.length < 2) return holes;
+  const buffer = /* alloc */ new Array(holes.length);
+  const entries = /* alloc */ [];
+  let ring, width, start, previous, i;
+  for (ring of holes) entries.push(/* alloc */ { ring, x: minimumX(ring) });
+  let source = entries, target = buffer;
+  for (width = 1; width < entries.length; width *= 2) {
+    for (start = 0; start < entries.length; start += width * 2) {
+      mergeHoles(source, target, start, width);
+    }
+    previous = source;
+    source = target;
+    target = previous;
+  }
+  for (i = 0; i < holes.length; i++) holes[i] = source[i].ring;
+  return holes;
+}

package/src/triangulation/triangulate.js

@@ -0,0 +1,48 @@
+import { geometryEmpty } from '../globals/geometryEmpty.js';
+import { sortHoles } from './sortHoles.js';
+import { polygonRings } from './polygonRings.js';
+import { connectHole } from './connectHole.js';
+import { clipEars } from './clipEars.js';
+import { validateArea } from './validateArea.js';
+
+
+/**
+ * Triangulates a polygon given as `{x, y}` points.
+ * Rings omit the repeated closing point; winding is normalized internally.
+ * Vertex indices remain relative to the original inputs after duplicate/collinear
+ * cleanup. Hole bridges duplicate endpoints, not source vertices.
+ * @param {Object[]} contour Outer boundary.
+ * @param {Object[][]} [holes] Interior boundaries.
+ *
+ * @returns {number[][]} Triangles as indices in `[...contour, ...holes.flat()]`.
+ */
+
+export function triangulate(contour, holes = geometryEmpty) {
+  const paths = /* alloc */ [contour, ...holes];
+  const points = paths.flat();
+  let p, index, hole;
+  for (p of points) {
+    if (!Number.isFinite(p.x) || !Number.isFinite(p.y)) throw /* alloc */ new Error('Invalid polygon coordinates');
+  }
+  // Translate near the origin to avoid cancellation with geographic coordinates.
+  const vertices = /* alloc */ [];
+  for (index = 0; index < points.length; index++) {
+    p = points[index];
+    vertices.push(/* alloc */ { x: p.x - contour[0].x, y: p.y - contour[0].y, index });
+  }
+  // Remove zero-area corners before connecting holes; keep original vertex indices.
+  const rings = polygonRings(paths, vertices);
+  let polygon = rings[0].slice();
+  // A bridge must stay inside the outer boundary, outside every hole, and cross no edge.
+  // ponytail: quadratic ear clipping for building footprints; use spatial indexing for large rings.
+  const holesToConnect = sortHoles(rings.slice(1));
+  const mid = holesToConnect.length ? /* alloc */ { x: 0, y: 0 } : null;
+  for (hole of holesToConnect) {
+    polygon = connectHole(polygon, hole, rings, mid);
+  }
+  // Clip a convex corner only when no other vertex is inside/on its triangle.
+  const result = clipEars(polygon);
+  // Reject incomplete coverage instead of silently emitting a partial roof.
+  validateArea(rings, vertices, result);
+  return result;
+}

package/src/triangulation/validateArea.js

@@ -0,0 +1,10 @@
+import { area } from './area.js';
+import { cross } from './cross.js';
+
+export function validateArea(rings, vertices, result) {
+  let holeArea = 0, actual = 0, i, triangle;
+  for (i = 1; i < rings.length; i++) holeArea += area(rings[i]);
+  const expected = area(rings[0]) - holeArea;
+  for (triangle of result) actual += cross(vertices[triangle[0]], vertices[triangle[1]], vertices[triangle[2]]) / 2;
+  if (expected <= 0 || Math.abs(actual - expected) > Math.max(1e-7, expected * 1e-8)) throw /* alloc */ new Error('Polygon triangulation area mismatch');
+}

package/src/utils/channel.js

@@ -1,4 +1,4 @@
-export const channel = (n, h, l, a) => {
+export function channel(n, h, l, a) {
   const k = (n + h * 12) % 12;
   return l - a * Math.max(-1, Math.min(k - 3, 9 - k, 1));
-};
+}

package/src/utils/compareDistance.js

@@ -0,0 +1,3 @@
+export function compareDistance(a, b) {
+  return a.distance - b.distance;
+}

package/src/utils/noOperation.js

@@ -0,0 +1 @@
+export function noOperation() {}

package/src/utils/parseColor.js

@@ -11,7 +11,7 @@ import { channel } from "./channel.js";
 export function parseColor(value) {
   if (value && typeof value === 'object' && 'h' in value) {
     const a = value.s * Math.min(value.l, 1 - value.l);
-    return {
+    return /* alloc */ {
       r: toSRGB(channel(0, value.h, value.l, a)),
       g: toSRGB(channel(8, value.h, value.l, a)),
       b: toSRGB(channel(4, value.h, value.l, a))
@@ -21,20 +21,20 @@ export function parseColor(value) {
     return value;
   }
   if (typeof value === 'number') {
-    return {
+    return /* alloc */ {
       r: (value >> 16 & 255) / 255,
       g: (value >> 8 & 255) / 255,
       b: (value & 255) / 255,
     };
   }
   if (typeof value !== 'string' || !CSS.supports('color', value)) {
-    throw new Error('Invalid 3D color');
+    throw /* alloc */ new Error('Invalid 3D color');
   }
   const context = document.createElement('canvas').getContext('2d');
   context.fillStyle = value;
   context.fillRect(0, 0, 1, 1);
   const [r, g, b] = context.getImageData(0, 0, 1, 1).data;
-  return {
+  return /* alloc */ {
     r: r / 255,
     g: g / 255,
     b: b / 255

package/src/utils/toSRGB.js

@@ -1 +1,3 @@
-export const toSRGB = value => value <= 0.0031308 ? value * 12.92 : 1.055 * value ** (1 / 2.4) - 0.055;
+export function toSRGB(value) {
+  return value <= 0.0031308 ? value * 12.92 : 1.055 * value ** (1 / 2.4) - 0.055;
+}

package/src/utils/wrap.js

@@ -1 +1,3 @@
-export const wrap = angle => Math.atan2(Math.sin(angle), Math.cos(angle));
+export function wrap(angle) {
+  return Math.atan2(Math.sin(angle), Math.cos(angle));
+}

package/src/vehicles/bicycleModel.js

@@ -0,0 +1,24 @@
+import { paints } from '../globals/paints.js';
+import { dark } from '../globals/dark.js';
+import { skin } from '../globals/skin.js';
+import { trousers } from '../globals/trousers.js';
+
+import { box } from '../geometry/box.js';
+
+export function bicycleModel(index) {
+  const paint = paints[index % paints.length];
+  return /* alloc */ [
+    /* alloc */ [box(-0.045, 0.045, -0.85, -0.25), 0.02, 0.62, dark],
+    /* alloc */ [box(-0.045, 0.045, 0.25, 0.85), 0.02, 0.62, dark],
+    /* alloc */ [box(-0.06, 0.06, -0.5, 0.5), 0.4, 0.65, paint],
+    /* alloc */ [box(-0.32, 0.32, -0.58, -0.5), 0.95, 1.02, dark],
+    /* alloc */ [box(-0.1, 0.1, 0.15, 0.4), 0.85, 0.92, dark],
+    /* alloc */ [box(-0.18, 0.18, -0.12, 0.28), 1, 1.5, paint],
+    /* alloc */ [box(-0.11, 0.11, -0.22, 0), 1.5, 1.72, skin],
+    /* alloc */ [box(-0.13, 0.13, -0.23, 0.01), 1.72, 1.8, paint],
+    /* alloc */ [box(-0.25, -0.15, -0.5, -0.05), 1, 1.25, skin],
+    /* alloc */ [box(0.15, 0.25, -0.5, -0.05), 1, 1.25, skin],
+    /* alloc */ [box(-0.2, -0.08, 0, 0.32), 0.3, 1, trousers],
+    /* alloc */ [box(0.08, 0.2, -0.25, 0.07), 0.3, 1, trousers],
+  ];
+}

package/src/vehicles/boatBenches.js

@@ -0,0 +1,9 @@
+import { mirror } from './mirror.js';
+
+export function boatBenches() {
+  const benches = /* alloc */ [];
+  let i;
+  for (i = 0; i < 12; i++) benches.push(...mirror(0.5, 3.8, -12 + i * 3, -11.3 + i * 3, 3.9, 4.4,
+    /* alloc */ [0.62, 0.1, 0.1]));
+  return benches;
+}

package/src/vehicles/boatModel.js

@@ -0,0 +1,35 @@
+import { hull } from '../globals/hull.js';
+import { white } from '../globals/white.js';
+import { glass } from '../globals/glass.js';
+
+
+import { box } from '../geometry/box.js';
+
+import { mirror } from './mirror.js';
+
+import { boatBenches } from './boatBenches.js';
+
+// Panoramic river cruiser, about 60 x 11 m.
+export function boatModel() {
+  return /* alloc */ [
+    /* alloc */ [
+      hull, 0, 0.8, /* alloc */ [0.1, 0.16, 0.26]],
+    /* alloc */ [hull, 0.8, 1.4, white],
+    /* alloc */ [box(-5, 5, -18, 26), 1.4, 3.7, glass, box(-4.6, 4.6, -17.4, 25.6)],
+    ...mirror(4.64, 4.74, -17, 25, 3.25, 3.45, /* alloc */ [1.6, 1.25, 0.8]),
+    /* alloc */ [box(-4.8, 4.8, -17.8, 25.8), 3.7, 3.9, white],
+    ...boatBenches(),
+    ...mirror(4.65, 4.8, -13.6, 25.8, 3.9, 4.8, white),
+    /* alloc */ [box(-4.8, 4.8, 25.65, 25.8), 3.9, 4.8, white],
+    /* alloc */ [box(-2.2, 2.2, -17.6, -14), 3.9, 4.7, white],
+    /* alloc */ [box(-2.2, 2.2, -17.6, -14), 4.7, 5.5, glass],
+    /* alloc */ [box(-2.5, 2.5, -18, -13.6), 5.5, 5.7, white],
+    /* alloc */ [
+      box(-2.45, -2.2, -16.2, -15.8), 5, 5.3, /* alloc */ [2, 0.15, 0.1]],
+    /* alloc */ [
+      box(2.2, 2.45, -16.2, -15.8), 5, 5.3, /* alloc */ [0.1, 2, 0.4]],
+    /* alloc */ [box(-0.1, 0.1, -15.9, -15.7), 5.7, 6.6, white],
+    /* alloc */ [
+      box(-0.15, 0.15, -15.95, -15.65), 6.6, 6.8, /* alloc */ [2, 2, 1.9]],
+  ];
+}

package/src/vehicles/busModel.js

@@ -0,0 +1,6 @@
+import { routeColor } from '../traffic/routeColor.js';
+import { carriage } from './carriage.js';
+
+export function busModel(index, properties) {
+  return carriage(0, 12, routeColor(properties));
+}

package/src/vehicles/carModel.js

@@ -0,0 +1,38 @@
+import { paints } from '../globals/paints.js';
+import { tyre } from '../globals/tyre.js';
+import { glass } from '../globals/glass.js';
+import { headlight } from '../globals/headlight.js';
+import { taillight } from '../globals/taillight.js';
+
+import { box } from '../geometry/box.js';
+
+
+import { mirror } from './mirror.js';
+
+
+
+
+export function carModel(i) {
+  const paint = paints[i % paints.length];
+  return /* alloc */ [
+    ...mirror(0.7, 0.92, -1.68, -1.02, 0, 0.64, tyre),
+    ...mirror(0.7, 0.92, 1.02, 1.68, 0, 0.64, tyre),
+    /* alloc */ [
+      /* alloc */ [
+        /* alloc */ [-0.9, -1.95],
+        /* alloc */ [-0.72, -2.25],
+        /* alloc */ [0.72, -2.25],
+        /* alloc */ [0.9, -1.95],
+        /* alloc */ [0.9, 2.05],
+        /* alloc */ [0.76, 2.25],
+        /* alloc */ [-0.76, 2.25],
+        /* alloc */ [-0.9, 2.05],
+      ],
+      0.28, 0.82, paint],
+    // Greenhouse: the windscreen leans back, the rear window less.
+    /* alloc */ [box(-0.84, 0.84, -0.75, 1.6), 0.82, 1.38, glass, box(-0.7, 0.7, -0.05, 1.3)],
+    /* alloc */ [box(-0.71, 0.71, -0.06, 1.31), 1.38, 1.46, paint],
+    ...mirror(0.38, 0.8, -2.3, -2.16, 0.56, 0.76, headlight),
+    /* alloc */ [box(-0.78, 0.78, 2.16, 2.3), 0.6, 0.76, taillight],
+  ];
+}

package/src/vehicles/carriage.js

@@ -0,0 +1,20 @@
+import { glass } from '../globals/glass.js';
+import { white } from '../globals/white.js';
+import { tyre } from '../globals/tyre.js';
+import { headlight } from '../globals/headlight.js';
+import { taillight } from '../globals/taillight.js';
+
+import { box } from '../geometry/box.js';
+
+export function carriage(center, length, color) {
+  const front = center - length / 2, rear = center + length / 2;
+  return /* alloc */ [
+    /* alloc */ [box(-1.25, 1.25, front, rear), 0.45, 1.25, color],
+    /* alloc */ [box(-1.2, 1.2, front + 0.15, rear - 0.15), 1.25, 2.65, glass],
+    /* alloc */ [box(-1.25, 1.25, front, rear), 2.65, 3.1, white],
+    /* alloc */ [box(-1.15, -0.85, front + 1, front + 2), 0, 0.7, tyre],
+    /* alloc */ [box(0.85, 1.15, rear - 2, rear - 1), 0, 0.7, tyre],
+    /* alloc */ [box(-0.9, 0.9, front - 0.03, front), 0.8, 1.05, headlight],
+    /* alloc */ [box(-0.9, 0.9, rear, rear + 0.03), 0.8, 1.05, taillight],
+  ];
+}

package/src/vehicles/metroModel.js

@@ -0,0 +1,9 @@
+import { routeColor } from '../traffic/routeColor.js';
+import { carriage } from './carriage.js';
+
+export function metroModel(index, properties) {
+  const color = routeColor(properties), parts = /* alloc */ [];
+  let car;
+  for (car = 0; car < 5; car++) parts.push(...carriage((car - 2) * 15, 14, color));
+  return parts;
+}

package/src/vehicles/mirror.js

@@ -0,0 +1,8 @@
+import { box } from "../geometry/box.js";
+
+export function mirror(x0, x1, z0, z1, ...rest) {
+  return /* alloc */ [
+    /* alloc */ [box(x0, x1, z0, z1), ...rest],
+    /* alloc */ [box(-x1, -x0, z0, z1), ...rest]
+  ];
+}

package/src/vehicles/pedestrianModel.js

@@ -0,0 +1,18 @@
+import { parts } from '../globals/parts.js';
+import { paints } from '../globals/paints.js';
+import { trousers } from '../globals/trousers.js';
+import { skin } from '../globals/skin.js';
+
+import { box } from '../geometry/box.js';
+
+export function pedestrianModel(index) {
+  const model = parts.body.slice();
+  model[1] = /* alloc */ [model[1][0], model[1][1], model[1][2], paints[index % paints.length]];
+  model.push(
+    /* alloc */ [box(-0.16, -0.02, -0.07, 0.07), 0.08, 0.9, trousers],
+    /* alloc */ [box(0.02, 0.16, -0.07, 0.07), 0.08, 0.9, trousers],
+    /* alloc */ [box(-0.3, -0.2, -0.05, 0.05), 0.76, 1.42, skin],
+    /* alloc */ [box(0.2, 0.3, -0.05, 0.05), 0.76, 1.42, skin],
+  );
+  return model;
+}

package/src/vehicles/tramModel.js

@@ -0,0 +1,9 @@
+import { routeColor } from '../traffic/routeColor.js';
+import { carriage } from './carriage.js';
+
+export function tramModel(index, properties) {
+  const color = routeColor(properties), parts = /* alloc */ [];
+  let car;
+  for (car = 0; car < 5; car++) parts.push(...carriage((car - 2) * 6.5, 6, color));
+  return parts;
+}

package/src/walk/blocked.js

@@ -0,0 +1,6 @@
+import { hit } from '../picking/hit.js';
+
+export function blocked(east, north, feet) {
+  const length = Math.hypot(east, north);
+  return length > 1e-6 && hit(this.layer, feet[0], feet[1], feet[2], east / length, -north / length, length + 0.3, this.hitData);
+}