@tileflow/maps 0.1.0-alpha.16 → 0.1.0-alpha.18

package/assets/streets/build-trees.mjs

@@ -33,144 +33,6 @@ function face(m, a, b, c, outward) {
 
 // Small irregular lobes, with a continuous normal field and a faceted silhouette. The
 // variation is in the authored mesh, so it never shimmers or changes while the camera moves.
-function crown(m, centre, radii, seed, far, farSides = 6) {
-  const sides = far ? farSides : 7;
-  const rings = far ? 2 : 4;
-  const top = vertex(m, add(centre, [0, radii[1], 0]), [0, 1, 0], 1.07);
-  const rows = [];
-  for (let r = 1; r < rings; r++) {
-    const latitude = (r / rings) * Math.PI;
-    const row = [];
-    for (let s = 0; s < sides; s++) {
-      const angle = (s / sides) * tau + seed * 0.7 + (r % 2) * 0.1;
-      const ripple = 1 + 0.065 * Math.sin(angle * 3 + seed) + 0.035 * Math.cos(angle * 5 - seed);
-      const n = [
-        Math.sin(latitude) * Math.cos(angle),
-        Math.cos(latitude),
-        Math.sin(latitude) * Math.sin(angle),
-      ];
-      row.push(
-        vertex(
-          m,
-          add(
-            centre,
-            n.map((v, i) => v * radii[i] * (i === 1 ? 1 : ripple)),
-          ),
-          n.map((v, i) => v / radii[i]),
-          0.94 + 0.07 * n[1] + 0.025 * Math.sin(s * 2 + seed),
-        ),
-      );
-    }
-    rows.push(row);
-  }
-  const bottom = vertex(m, add(centre, [0, -radii[1], 0]), [0, -1, 0], 0.86);
-  for (let s = 0; s < sides; s++) {
-    const n = (s + 1) % sides;
-    face(m, top, rows[0][s], rows[0][n], [0, 1, 0]);
-    for (let r = 0; r + 1 < rows.length; r++) {
-      const out = sub(m.positions.slice(rows[r][s] * 3, rows[r][s] * 3 + 3), centre);
-      face(m, rows[r][s], rows[r + 1][s], rows[r + 1][n], out);
-      face(m, rows[r][s], rows[r + 1][n], rows[r][n], out);
-    }
-    face(m, bottom, rows.at(-1)[n], rows.at(-1)[s], [0, -1, 0]);
-  }
-}
-
-// Open foliage is a curved, two-sided blade with a raised midrib and drooping
-// flanks. An ovate outline tapers to its tips, without a vertical, coin-like bevel.
-function leafBlade(m, centre, radii, seed, far, tilt, shade) {
-  const yaw = Math.atan2(centre[0], centre[2]) + Math.sin(seed * golden) * 0.22;
-  const turn = ([x, y, z]) => {
-    const yy = y * Math.cos(tilt) - z * Math.sin(tilt);
-    const zz = y * Math.sin(tilt) + z * Math.cos(tilt);
-    return [x * Math.cos(yaw) + zz * Math.sin(yaw), yy, -x * Math.sin(yaw) + zz * Math.cos(yaw)];
-  };
-  const stations = far ? [-1, 0, 1] : [-1, -0.8, -0.45, 0, 0.45, 0.8, 1];
-  const width = radii[2],
-    length = radii[0];
-  const rows = stations.map((t) => {
-    const reach = Math.sqrt(1 - t * t) * (1 - t * 0.18);
-    return (Math.abs(t) === 1 ? [0] : [-1, 0, 1]).map((s) => {
-      const x = width * (s * reach + 0.08 * (1 - t * t));
-      const z = length * t;
-      const y =
-        radii[1] * (1 - t * t) -
-        length * (0.28 * t * t - 0.08 * t) -
-        width * (0.28 * s * s * reach - 0.1 * s * t);
-      return vertex(
-        m,
-        add(centre, turn([x, y, z])),
-        turn([0.56 * s - 0.1 * t, 1, 0.65 * t - 0.08 - 0.1 * s]),
-        shade * (1.02 - Math.abs(s) * 0.025),
-      );
-    });
-  });
-  const outward = turn([0, 1, 0]);
-  for (let row = 0; row + 1 < rows.length; row++) {
-    const a = rows[row],
-      b = rows[row + 1];
-    for (let flank = 0; flank < 2; flank++) {
-      if (a.length === 1) face(m, a[0], b[flank], b[flank + 1], outward);
-      else if (b.length === 1) face(m, a[flank], b[0], a[flank + 1], outward);
-      else {
-        face(m, a[flank], b[flank], b[flank + 1], outward);
-        face(m, a[flank], b[flank + 1], a[flank + 1], outward);
-      }
-    }
-  }
-}
-
-// Rounded ovoid crowns have smooth normals and an irregular low-poly silhouette.
-function foliage(m, centre, radii, seed, far, {thin = false, tilt = 0, shade = 1} = {}) {
-  if (thin) return leafBlade(m, centre, radii, seed, far, tilt, shade);
-  const sides = far ? 8 : 10;
-  const rings = far ? 2 : 6;
-  const yaw = seed * golden;
-  const turn = ([x, y, z]) => {
-    const yy = y * Math.cos(tilt) - z * Math.sin(tilt);
-    const zz = y * Math.sin(tilt) + z * Math.cos(tilt);
-    return [x * Math.cos(yaw) + zz * Math.sin(yaw), yy, -x * Math.sin(yaw) + zz * Math.cos(yaw)];
-  };
-  const point = (n) => add(centre, turn(n.map((v, axis) => v * radii[axis])));
-  const top = vertex(m, point([0.08, 1, 0]), turn([0, 1, 0]), shade * 1.04);
-  const bottom = vertex(m, point([-0.06, -1, 0.04]), turn([0, -1, 0]), shade * 0.94);
-  const rows = [];
-  for (let row = 1; row < rings; row++) {
-    const latitude = (row * Math.PI) / rings;
-    const y = Math.cos(latitude);
-    const reach = Math.pow(Math.sin(latitude), 0.78);
-    rows.push(
-      Array.from({length: sides}, (_, side) => {
-        const angle = (side * tau) / sides + seed * 0.32;
-        const ripple = 1 + 0.07 * Math.sin(angle * 3 + seed) + 0.035 * Math.cos(angle * 5 - seed);
-        const width = reach * ripple * (1 - y * 0.08);
-        const x = Math.cos(angle) * width + y * 0.08;
-        const z = Math.sin(angle) * width;
-        const n = [
-          (Math.cos(angle) * reach) / radii[0],
-          y / radii[1],
-          (Math.sin(angle) * reach) / radii[2],
-        ];
-        return vertex(m, point([x, y, z]), turn(n), shade * (0.98 + y * 0.04));
-      }),
-    );
-  }
-  for (let side = 0; side < sides; side++) {
-    const next = (side + 1) % sides;
-    face(m, top, rows[0][side], rows[0][next], turn([0, 1, 0]));
-    for (let row = 0; row + 1 < rows.length; row++) {
-      const outward = turn([
-        Math.cos((side * tau) / sides + seed * 0.32),
-        0,
-        Math.sin((side * tau) / sides + seed * 0.32),
-      ]);
-      face(m, rows[row][side], rows[row + 1][side], rows[row + 1][next], outward);
-      face(m, rows[row][side], rows[row + 1][next], rows[row][next], outward);
-    }
-    face(m, bottom, rows.at(-1)[next], rows.at(-1)[side], turn([0, -1, 0]));
-  }
-}
-
 function branch(m, from, to, base, tip, sides) {
   const axis = unit(sub(to, from));
   const u = unit(cross(axis, Math.abs(axis[1]) > 0.9 ? [1, 0, 0] : [0, 1, 0]));
@@ -196,135 +58,6 @@ function branch(m, from, to, base, tip, sides) {
 
 // Compact, upright and open trees have different branching architectures, not the
 // same set of spheres stretched along an axis. Lobes carry a stable material shade.
-const broadleaf = {
-  round: [
-    [-1.5, 6.9, 0.45, 2.25, 2.5, 2.0, -0.22, 1.05],
-    [1.8, 6.15, 0.45, 2.05, 2.15, 1.8, 0.25, 0.82],
-    [0.1, 7.7, -1.0, 2.0, 2.55, 1.85, 0.12, 1.13],
-  ],
-  tall: [
-    [-0.55, 9.15, -0.25, 2.15, 3.3, 2.0, -0.1, 1.14],
-    [1.8, 6.05, 0.5, 1.6, 1.75, 1.45, 0.32, 0.78],
-    [-1.7, 5.45, 0.8, 1.45, 1.65, 1.4, -0.32, 0.91],
-  ],
-  open: [
-    [-0.7, 8.1, -0.4, 1.3, 0.23, 1.05, 0.12, 1.13],
-    [0.95, 7.9, -0.65, 1.45, 0.22, 1.15, 0.25, 1.08],
-    [-2.0, 7.0, 0.65, 1.5, 0.22, 1.1, 0.55, 0.95],
-    [0.1, 7.7, 1.15, 1.5, 0.24, 1.2, 0.38, 1.18],
-    [2.0, 7.1, 0.3, 1.45, 0.2, 1.05, 0.6, 1.04],
-    [-0.35, 7.3, -1.65, 1.35, 0.23, 1.15, 0.42, 1.0],
-    [-1.85, 6.0, -0.65, 1.25, 0.24, 1.0, 0.85, 0.79],
-    [1.65, 6.1, 1.0, 1.35, 0.22, 1.1, 0.9, 0.86],
-    [-0.4, 6.6, 1.8, 1.2, 0.2, 1.0, 0.75, 0.93],
-    [0.6, 6.2, -1.5, 1.3, 0.24, 1.0, 0.8, 0.75],
-  ],
-  conifer: [
-    [-0.25, 10.1, 0.05, 1.05, 0.4, 0.95, 0.2, 1.14],
-    [1.1, 8.8, -0.4, 1.5, 0.35, 1.15, -0.35, 1.06],
-    [-1.35, 8.4, 0.25, 1.55, 0.35, 1.2, 0.45, 1.1],
-    [0.1, 7.75, 1.4, 1.5, 0.3, 1.25, -0.3, 1.0],
-    [-0.55, 7.35, -1.4, 1.55, 0.35, 1.25, 0.35, 0.98],
-    [1.75, 6.4, 0.25, 1.65, 0.35, 1.25, -0.5, 0.88],
-    [-1.85, 5.9, -0.25, 1.65, 0.35, 1.3, 0.45, 0.91],
-    [0.35, 5.2, 1.65, 1.75, 0.3, 1.3, -0.6, 0.82],
-    [-0.25, 4.8, -1.4, 1.65, 0.35, 1.2, 0.5, 0.8],
-    [0, 6.7, 0.05, 1.25, 0.35, 1.1, -0.2, 0.95],
-  ],
-};
-
-function deciduous(form, far) {
-  const bark = mesh('bark');
-  const thin = form === 'open' || form === 'conifer';
-  const leaves = mesh(thin ? 'fronds' : 'leaves');
-  const upright = form === 'tall' || form === 'conifer';
-  const foot = [0, 0, 0];
-  const waist = [0.08, 0.9, -0.02];
-  const fork = [upright ? -0.18 : 0.16, upright ? 3.5 : 3.2, -0.08];
-  const trunkSides = far ? 3 : 6;
-  branch(bark, foot, waist, upright ? 0.47 : 0.55, 0.33, trunkSides);
-  branch(bark, waist, fork, 0.33, 0.26, trunkSides);
-  const limbs = thin
-    ? [
-        [-1.0, 7.3, 0.15],
-        [1.1, 6.65, -0.25],
-        [0.25, 5.0, 0.7],
-      ]
-    : broadleaf[form].map((lobe) => lobe.slice(0, 3));
-  for (const [i, end] of limbs.entries()) {
-    const elbow = add(fork, mul(sub(end, fork), 0.52));
-    elbow[0] += i === 1 ? 0.18 : -0.15;
-    if (far) branch(bark, fork, end, 0.21, 0.055, 3);
-    else {
-      branch(bark, fork, elbow, 0.24 - i * 0.035, 0.14, 4);
-      branch(bark, elbow, end, 0.14, 0.045, 4);
-    }
-  }
-  for (const [i, lobe] of broadleaf[form].entries()) {
-    const centre = lobe.slice(0, 3);
-    if (thin && !far) {
-      const limb = limbs[i % limbs.length];
-      const start = add(
-        fork,
-        mul(sub(limb, fork), Math.min(1, (centre[1] - fork[1]) / (limb[1] - fork[1]))),
-      );
-      branch(bark, start, centre, 0.1, 0.025, 3);
-    }
-    foliage(leaves, centre, lobe.slice(3, 6), i + form.length, far, {
-      thin,
-      tilt: lobe[6],
-      shade: lobe[7],
-    });
-  }
-  return [bark, leaves];
-}
-
-function evergreen(form, far) {
-  const bark = mesh('bark');
-  const leaves = mesh('leaves');
-  const column = form === 'columnar';
-  branch(bark, [0, 0, 0], [0, 8, 0], column ? 0.17 : 0.23, 0.06, far ? 4 : 6);
-  const tiers = far ? 3 : column ? 5 : 6;
-  for (let i = 0; i < tiers; i++) {
-    const t = i / (tiers - 1);
-    const radius = column ? 1.35 - t * 0.65 : 3.2 - t * 2.4;
-    const y = (column ? 3.5 : 3) + t * (column ? 7.4 : 7);
-    if (column)
-      crown(
-        leaves,
-        [0.12 * Math.sin(i * 2), y, 0.1 * Math.cos(i)],
-        [radius, 2.1 - t * 0.7, radius],
-        i + 2,
-        far,
-      );
-    else {
-      const sides = far ? 6 : 9;
-      const top = vertex(leaves, [0, y + 2.6, 0], [0, 1, 0], 1.06);
-      const bottom = vertex(leaves, [0, y - 0.25, 0], [0, -1, 0], 0.86);
-      const ring = Array.from({length: sides}, (_, s) => {
-        const a = (s * tau) / sides + i * golden;
-        const r = radius * (1 + 0.07 * Math.sin(s * 3 + i));
-        return vertex(
-          leaves,
-          [Math.cos(a) * r, y + 0.12 * Math.sin(s * 2), Math.sin(a) * r],
-          [Math.cos(a), 0.45, Math.sin(a)],
-          0.94 + 0.03 * Math.sin(s),
-        );
-      });
-      for (let s = 0; s < sides; s++) {
-        const n = (s + 1) % sides;
-        face(leaves, top, ring[s], ring[n], [
-          Math.cos((s * tau) / sides + i * golden),
-          1,
-          Math.sin((s * tau) / sides + i * golden),
-        ]);
-        face(leaves, bottom, ring[n], ring[s], [0, -1, 0]);
-      }
-    }
-  }
-  return [bark, leaves];
-}
-
 function palm(form, far) {
   const fan = form === 'palm-fan';
   const stem = mesh('stem');
@@ -506,16 +239,177 @@ function topView(parts, dark) {
   return `<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 64 64">\n<!-- Generated by build-trees.mjs. Original Tileflow crown artwork. -->\n${triangles.map((t) => t.path).join('\n')}\n</svg>\n`;
 }
 
+const profiles = {
+  round: {
+    r: [3.5, 3.55, 3.2],
+    y: 6.55,
+    power: 0.83,
+    lobes: 0.1,
+    taper: 0.08,
+    lean: 0.16,
+    phase: 0.4,
+  },
+  open: {
+    r: [4.2, 2.65, 3.65],
+    y: 6.35,
+    power: 0.78,
+    lobes: 0.13,
+    taper: 0.09,
+    lean: -0.18,
+    phase: 1.2,
+  },
+  tall: {
+    r: [2.6, 4.4, 2.35],
+    y: 7.2,
+    power: 0.94,
+    lobes: 0.075,
+    taper: 0.16,
+    lean: 0.28,
+    phase: 2.3,
+  },
+  conifer: {
+    r: [3.0, 4.75, 2.8],
+    y: 6.35,
+    power: 0.74,
+    lobes: 0.035,
+    taper: 0.6,
+    lean: -0.1,
+    phase: 0.8,
+  },
+  columnar: {
+    r: [1.35, 5.5, 1.2],
+    y: 6.2,
+    power: 1.04,
+    lobes: 0.035,
+    taper: 0.22,
+    lean: 0.13,
+    phase: 1.6,
+  },
+};
+const crownVolumes = {
+  round: [
+    {c: [-1.3, -0.25, 0.15], r: [2.3, 2.5, 2.2]},
+    {c: [1.4, -0.4, 0], r: [2.2, 2.35, 2.1]},
+    {c: [0.1, 1.5, -0.3], r: [2.4, 2.7, 2.3]},
+  ],
+  open: [
+    {c: [-1.75, -0.25, 0.2], r: [2.65, 2.1, 2.45]},
+    {c: [1.65, -0.2, 0.1], r: [2.6, 2.3, 2.4]},
+    {c: [-0.1, 0.7, -0.45], r: [2.9, 2.5, 2.6]},
+  ],
+  tall: [
+    {c: [-0.15, 1.25, -0.15], r: [2.25, 3.35, 2.05]},
+    {c: [-1.0, -1.4, 0.2], r: [1.8, 2.1, 1.7]},
+    {c: [1.1, -0.85, 0.1], r: [1.8, 2.35, 1.75]},
+  ],
+};
+// Restore depth to the compact crowns; their original lobes were laid out
+// mainly side to side, leaving a flat, elongated footprint from above.
+const crownDepth = {round: 1.45, open: 1.52, tall: 1.3};
+function blendedRadius(direction, volumes) {
+  const hits = volumes.map(({c, r}) => {
+    let a = 0,
+      b = 0,
+      d = -1;
+    for (let i = 0; i < 3; i++) {
+      a += (direction[i] / r[i]) ** 2;
+      b -= (2 * direction[i] * c[i]) / r[i] ** 2;
+      d += (c[i] / r[i]) ** 2;
+    }
+    return (-b + Math.sqrt(Math.max(0, b * b - 4 * a * d))) / (2 * a);
+  });
+  // A smooth union keeps the lobes readable in one continuous canopy skin.
+  return hits.reduce((a, b) => Math.max(a, b) + 0.2 * Math.log1p(Math.exp(-Math.abs(a - b) / 0.2)));
+}
+
+function compactCrown(m, p, form, far) {
+  const sides = far ? 12 : 20,
+    rings = far ? 5 : 10;
+  const point = (latitude, angle) => {
+    const up = Math.cos(latitude),
+      reach = Math.max(0, Math.sin(latitude));
+    if (crownVolumes[form]) {
+      const direction = [reach * Math.cos(angle), up, reach * Math.sin(angle)];
+      const radius = blendedRadius(direction, crownVolumes[form]);
+      return [
+        direction[0] * radius,
+        p.y + direction[1] * radius,
+        direction[2] * radius * crownDepth[form],
+      ];
+    }
+    const lobes =
+      1 +
+      p.lobes * Math.cos(3 * angle + p.phase) * reach * reach +
+      0.025 * Math.sin(2 * angle + p.phase) * reach;
+    const tier = form === 'conifer' ? 0.88 * (1 + 0.055 * Math.cos(latitude * 6)) : 1;
+    const radius = Math.pow(reach, p.power) * (1 - p.taper * up) * lobes * tier;
+    return [
+      p.r[0] * radius * Math.cos(angle) + p.lean * up,
+      p.y + p.r[1] * up,
+      p.r[2] * radius * Math.sin(angle) + 0.08 * up,
+    ];
+  };
+  const normal = (latitude, angle) => {
+    const e = 0.0001;
+    const around = sub(point(latitude, angle + e), point(latitude, angle - e));
+    const down = sub(point(latitude + e, angle), point(latitude - e, angle));
+    return unit(cross(around, down));
+  };
+  const top = vertex(m, point(0, 0), [0, 1, 0], 1.015);
+  const bottom = vertex(m, point(Math.PI, 0), [0, -1, 0], 0.985);
+  const rows = [];
+  for (let row = 1; row < rings; row++) {
+    const latitude = (row / rings) * Math.PI;
+    rows.push(
+      Array.from({length: sides}, (_, side) => {
+        const angle = (side / sides) * tau;
+        return vertex(
+          m,
+          point(latitude, angle),
+          normal(latitude, angle),
+          1 + 0.015 * Math.cos(latitude),
+        );
+      }),
+    );
+  }
+  for (let side = 0; side < sides; side++) {
+    const next = (side + 1) % sides;
+    face(m, top, rows[0][side], rows[0][next], [0, 1, 0]);
+    for (let row = 0; row < rows.length - 1; row++) {
+      const outward = normal(((row + 1.5) / rings) * Math.PI, ((side + 0.5) / sides) * tau);
+      face(m, rows[row][side], rows[row + 1][side], rows[row + 1][next], outward);
+      face(m, rows[row][side], rows[row + 1][next], rows[row][next], outward);
+    }
+    face(m, bottom, rows.at(-1)[next], rows.at(-1)[side], [0, -1, 0]);
+  }
+}
+
+function compactTree(form, far) {
+  const p = profiles[form],
+    bark = mesh('bark'),
+    leaves = mesh('leaves');
+  const slim = form === 'columnar' || form === 'conifer';
+  const crownBottom = p.y - p.r[1],
+    fork = Math.max(1.5, crownBottom + (slim ? 0.35 : -0.65));
+  const sides = far ? 3 : 8;
+  branch(bark, [0, 0, 0], [0, fork, 0], slim ? 0.28 : 0.48, slim ? 0.16 : 0.3, sides);
+  if (slim) branch(bark, [0, fork, 0], [0, p.y, 0], 0.16, 0.06, sides);
+  else
+    for (const [sign, z] of [
+      [-1, -0.18],
+      [1, 0.15],
+    ]) {
+      branch(bark, [0, fork, 0], [sign * p.r[0] * 0.46, crownBottom + 1.25, z], 0.24, 0.1, sides);
+    }
+  compactCrown(leaves, p, form, far);
+  return [bark, leaves];
+}
+
 export function buildStreetsTrees() {
   const files = new Map();
   const catalogue = [];
   for (const form of ['round', 'open', 'tall', 'conifer', 'columnar', 'palm-feather', 'palm-fan']) {
-    const build = (far) =>
-      form.startsWith('palm')
-        ? palm(form, far)
-        : form in broadleaf
-          ? deciduous(form, far)
-          : evergreen(form, far);
+    const build = (far) => (form.startsWith('palm') ? palm(form, far) : compactTree(form, far));
     const near = build(false),
       far = build(true);
     const id = `streets-tree-${form}`;

package/assets/streets/climate/NOTICE.txt

@@ -0,0 +1,9 @@
+Historical Köppen–Geiger climate classification, 1991–2020.
+Beck et al. (2023), https://doi.org/10.1038/s41597-023-02549-6
+Source: https://www.gloh2o.org/koppen/
+Archive: https://ndownloader.figshare.com/files/61012822
+Archive MD5: 7fc2f5a15d4f5fe0ce59c9a9b502aa09
+License: Creative Commons Attribution 4.0 International.
+https://creativecommons.org/licenses/by/4.0/
+Adaptation: historical classes mapped to a crop-colour proxy, spatially smoothed,
+reprojected to Web Mercator and tiled. No real-time vegetation is inferred.

package/assets/streets/climate/build.py

@@ -0,0 +1,47 @@
+"""Rebuild the embedded, historical climate colour image (requires Pillow and NumPy)."""
+from pathlib import Path
+from PIL import Image, ImageFilter
+import hashlib, json, base64, io
+import numpy as np
+ROOT = Path(__file__).resolve().parent
+SOURCE = ROOT / 'koppen-geiger-1991-2020.tif'
+DRY = np.array([239, 241, 230], dtype=float)  # Existing global crop colour.
+WET = np.array([202, 235, 215], dtype=float)
+# 0=no-data; 1..30 are the published Beck et al. climate classes.
+# Summer-dry and arid climates retain the current neutral crop palette.
+WEIGHTS = [0, 1, 1, .45, 0, 0, 0, 0, 0, .06, .15,
+           .65, .7, .5, 1, 1, .9, .1, .15, .2, .15,
+           .65, .85, .65, .35, 1, 1, .8, .5, .15, 0]
+recipe = dict(sourceSha256=hashlib.sha256(SOURCE.read_bytes()).hexdigest(),
+              dry=DRY.tolist(), wet=WET.tolist(), weights=WEIGHTS,
+              blurDegrees=.25, maxzoom=4, tileSize=256, period='1991–2020')
+digest = hashlib.sha256(json.dumps(recipe, sort_keys=True).encode()).hexdigest()[:24]
+classes = np.asarray(Image.open(SOURCE))
+assert classes.shape == (1800, 3600) and classes.max() <= 30
+valid = classes > 0
+signal = np.take(WEIGHTS, classes)
+# Normalize the blur by valid land so coastlines do not artificially dry out.
+blur = lambda a: np.asarray(Image.fromarray(np.uint8(np.round(a * 255))).filter(
+    ImageFilter.GaussianBlur(2.5)), dtype=float) / 255
+smoothed = np.divide(blur(signal), blur(valid), out=np.zeros_like(signal),
+                     where=blur(valid) > .01).clip(0, 1)
+colour = np.uint8(np.round(DRY + smoothed[..., None] * (WET - DRY)))
+# Project the global 0.1 degree grid to Web Mercator before making XYZ tiles.
+size = 4096
+latitude = np.degrees(np.arctan(np.sinh(np.pi * (1 - 2 * (np.arange(size) + .5) / size))))
+row = (90 - latitude) * 10 - .5
+low = np.floor(row).astype(int).clip(0, 1798)
+fraction = (row - low).clip(0, 1)
+projected = np.uint8(np.round(colour[low] * (1 - fraction[:, None, None]) +
+                             colour[low + 1] * fraction[:, None, None]))
+world = Image.fromarray(projected).resize((size, size), Image.Resampling.BILINEAR)
+buffer = io.BytesIO()
+world.save(buffer, format='PNG', optimize=True)
+uri = 'data:image/png;base64,' + base64.b64encode(buffer.getvalue()).decode()
+output = ROOT / '../../../src/official/streets-climate-image.ts'
+output.write_text('// Generated by assets/streets/climate/build.py. See its NOTICE.txt.\nexport const streetsClimateImage = ' + json.dumps(uri) + ';\n')
+(ROOT / 'recipe.json').write_text(json.dumps(recipe, indent=2)+'\n')
+# Keep generated sources reproducible under the package formatter.
+import subprocess
+subprocess.run(['pnpm', 'exec', 'prettier', '--write', str(output.resolve()), str(ROOT / 'recipe.json')], cwd=ROOT.parents[4], check=True)
+print(json.dumps({'imageBytes':len(buffer.getvalue()), 'sourceSha256':recipe['sourceSha256']}))

package/assets/streets/climate/recipe.json

@@ -0,0 +1,13 @@
+{
+  "sourceSha256": "59b749fe6711e72c720ff903044eb0efb4373524ee434740ed7384a0284c155b",
+  "dry": [239.0, 241.0, 230.0],
+  "wet": [202.0, 235.0, 215.0],
+  "weights": [
+    0, 1, 1, 0.45, 0, 0, 0, 0, 0, 0.06, 0.15, 0.65, 0.7, 0.5, 1, 1, 0.9, 0.1, 0.15, 0.2, 0.15, 0.65,
+    0.85, 0.65, 0.35, 1, 1, 0.8, 0.5, 0.15, 0
+  ],
+  "blurDegrees": 0.25,
+  "maxzoom": 4,
+  "tileSize": 256,
+  "period": "1991\u20132020"
+}