zero2geospatial3d-sdk 0.1.0__py3-none-any.whl

zero2geospatial3d/web/src/core/nsga2.js

@@ -0,0 +1,181 @@
+// @ts-check
+// NSGA-II (Deb, Pratap, Agarwal and Meyarivan 2002, "A fast and elitist
+// multiobjective genetic algorithm: NSGA-II", IEEE Trans. Evol. Comput.
+// 6(2):182-197, doi:10.1109/4235.996017) with constraint domination,
+// simulated binary crossover and polynomial mutation. All objectives are
+// minimised. Seeded, so a run can be repeated exactly.
+
+/** mulberry32: small, fast, seedable PRNG returning [0, 1). */
+export function makeRng(seed = 1) {
+  let a = seed >>> 0;
+  return function rng() {
+    a = (a + 0x6d2b79f5) >>> 0;
+    let t = a;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+/** a dominates b (constraint domination: feasibility first). */
+export function dominates(a, b) {
+  if (a.violation > 0 || b.violation > 0) return a.violation < b.violation;
+  let better = false;
+  for (let i = 0; i < a.objectives.length; i++) {
+    if (a.objectives[i] > b.objectives[i]) return false;
+    if (a.objectives[i] < b.objectives[i]) better = true;
+  }
+  return better;
+}
+
+/** Fast non-dominated sort: array of fronts (arrays of indices); sets .rank. */
+export function nonDominatedSort(pop) {
+  const n = pop.length;
+  const dominatedBy = Array.from({ length: n }, () => []);
+  const count = new Array(n).fill(0);
+  const fronts = [[]];
+  for (let p = 0; p < n; p++) {
+    for (let q = 0; q < n; q++) {
+      if (p === q) continue;
+      if (dominates(pop[p], pop[q])) dominatedBy[p].push(q);
+      else if (dominates(pop[q], pop[p])) count[p]++;
+    }
+    if (count[p] === 0) { pop[p].rank = 0; fronts[0].push(p); }
+  }
+  let i = 0;
+  while (fronts[i].length) {
+    const next = [];
+    for (const p of fronts[i]) {
+      for (const q of dominatedBy[p]) {
+        if (--count[q] === 0) { pop[q].rank = i + 1; next.push(q); }
+      }
+    }
+    i++;
+    fronts.push(next);
+  }
+  fronts.pop();
+  return fronts;
+}
+
+/** Crowding distance within one front; sets .crowding. */
+export function crowdingDistance(pop, front) {
+  for (const i of front) pop[i].crowding = 0;
+  if (front.length <= 2) { for (const i of front) pop[i].crowding = Infinity; return; }
+  const m = pop[front[0]].objectives.length;
+  for (let k = 0; k < m; k++) {
+    const sorted = [...front].sort((a, b) => pop[a].objectives[k] - pop[b].objectives[k]);
+    const lo = pop[sorted[0]].objectives[k];
+    const hi = pop[sorted[sorted.length - 1]].objectives[k];
+    pop[sorted[0]].crowding = Infinity;
+    pop[sorted[sorted.length - 1]].crowding = Infinity;
+    if (hi - lo <= 0) continue;
+    for (let j = 1; j < sorted.length - 1; j++) {
+      pop[sorted[j]].crowding += (pop[sorted[j + 1]].objectives[k] - pop[sorted[j - 1]].objectives[k]) / (hi - lo);
+    }
+  }
+}
+
+function better(a, b) {
+  if (a.rank !== b.rank) return a.rank < b.rank;
+  return a.crowding > b.crowding;
+}
+
+function sbx(rng, x1, x2, lo, hi, eta) {
+  if (rng() > 0.5 || Math.abs(x1 - x2) < 1e-12) return [x1, x2];
+  const u = rng();
+  const beta = u <= 0.5 ? Math.pow(2 * u, 1 / (eta + 1)) : Math.pow(1 / (2 * (1 - u)), 1 / (eta + 1));
+  const c1 = 0.5 * ((1 + beta) * x1 + (1 - beta) * x2);
+  const c2 = 0.5 * ((1 - beta) * x1 + (1 + beta) * x2);
+  return [Math.min(hi, Math.max(lo, c1)), Math.min(hi, Math.max(lo, c2))];
+}
+
+function polyMutate(rng, x, lo, hi, eta) {
+  const span = hi - lo;
+  if (span <= 0) return x;
+  const u = rng();
+  const delta = u < 0.5 ? Math.pow(2 * u, 1 / (eta + 1)) - 1 : 1 - Math.pow(2 * (1 - u), 1 / (eta + 1));
+  return Math.min(hi, Math.max(lo, x + delta * span));
+}
+
+/**
+ * Run NSGA-II.
+ * @param {object} problem
+ * @param {number[]} problem.lower
+ * @param {number[]} problem.upper
+ * @param {boolean} [problem.integer] round every variable
+ * @param {(x: number[]) => Promise<{ objectives: number[], violation?: number }> | { objectives: number[], violation?: number }} problem.evaluate
+ * @param {number[][]} [problem.seeds] starting solutions (e.g. the current design)
+ * @param {object} [opts]
+ * @returns {Promise<{ population: any[], front: any[], evaluations: number, history: any[] }>}
+ */
+export async function nsga2(problem, { populationSize = 24, generations = 20, seed = 1, etaC = 15, etaM = 20, crossoverProb = 0.9, onGeneration = null, shouldStop = null } = {}) {
+  const rng = makeRng(seed);
+  const n = problem.lower.length;
+  const pm = 1 / Math.max(1, n);
+  const round = (x) => (problem.integer ? x.map((v, i) => Math.min(problem.upper[i], Math.max(problem.lower[i], Math.round(v)))) : x);
+  const cache = new Map();
+  let evaluations = 0;
+  const evaluate = async (x) => {
+    const key = x.join(',');
+    if (cache.has(key)) return cache.get(key);
+    const r = await problem.evaluate(x);
+    evaluations++;
+    const ind = { x, objectives: r.objectives, violation: Math.max(0, r.violation || 0), extra: r.extra };
+    cache.set(key, ind);
+    return { ...ind };
+  };
+  let pop = [];
+  for (const s of problem.seeds || []) if (pop.length < populationSize) pop.push(await evaluate(round(s)));
+  while (pop.length < populationSize) {
+    const x = problem.lower.map((lo, i) => lo + rng() * (problem.upper[i] - lo));
+    pop.push(await evaluate(round(x)));
+  }
+  const history = [];
+  const rankAll = (p) => { const fronts = nonDominatedSort(p); for (const f of fronts) crowdingDistance(p, f); return fronts; };
+  rankAll(pop);
+  for (let g = 0; g < generations; g++) {
+    if (shouldStop && shouldStop()) break;
+    const tournament = () => { const a = pop[Math.floor(rng() * pop.length)]; const b = pop[Math.floor(rng() * pop.length)]; return better(a, b) ? a : b; };
+    const children = [];
+    while (children.length < populationSize) {
+      const p1 = tournament().x;
+      const p2 = tournament().x;
+      const c1 = [...p1];
+      const c2 = [...p2];
+      if (rng() < crossoverProb) {
+        for (let i = 0; i < n; i++) [c1[i], c2[i]] = sbx(rng, p1[i], p2[i], problem.lower[i], problem.upper[i], etaC);
+      }
+      for (let i = 0; i < n; i++) {
+        if (rng() < pm) c1[i] = polyMutate(rng, c1[i], problem.lower[i], problem.upper[i], etaM);
+        if (rng() < pm) c2[i] = polyMutate(rng, c2[i], problem.lower[i], problem.upper[i], etaM);
+      }
+      children.push(await evaluate(round(c1)));
+      if (children.length < populationSize) children.push(await evaluate(round(c2)));
+    }
+    // Copies of a parent (no crossover, no mutation) would crowd the front
+    // with identical points; keep one of each unless that leaves too few.
+    const seen = new Set();
+    const unique = [];
+    const dupes = [];
+    for (const ind of pop.concat(children)) {
+      const key = ind.x.join(',');
+      if (seen.has(key)) dupes.push(ind); else { seen.add(key); unique.push(ind); }
+    }
+    const merged = unique.length >= populationSize ? unique : unique.concat(dupes.slice(0, populationSize - unique.length));
+    const fronts = rankAll(merged);
+    const next = [];
+    for (const f of fronts) {
+      if (next.length + f.length <= populationSize) { for (const i of f) next.push(merged[i]); continue; }
+      const sorted = [...f].sort((a, b) => merged[b].crowding - merged[a].crowding);
+      for (const i of sorted.slice(0, populationSize - next.length)) next.push(merged[i]);
+      break;
+    }
+    pop = next;
+    rankAll(pop);
+    const front = pop.filter((p) => p.rank === 0 && p.violation === 0);
+    history.push({ generation: g + 1, evaluations, frontSize: front.length });
+    if (onGeneration) await onGeneration({ generation: g + 1, generations, population: pop, front, evaluations });
+  }
+  const front = pop.filter((p) => p.rank === 0);
+  return { population: pop, front, evaluations, history };
+}

zero2geospatial3d/web/src/core/party_walls.js

@@ -0,0 +1,60 @@
+// @ts-check
+// Walls built against another building (party walls) have no windows and see
+// no sky: a point just in front of such a wall lies inside the other
+// building's footprint, between its bottom and its roof. Above a lower
+// neighbour the same wall is open again. A grid of footprint boxes keeps the
+// test to the few buildings near each point.
+
+function inside(x, y, ring) {
+  let odd = false;
+  for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+    const [xi, yi] = ring[i], [xj, yj] = ring[j];
+    if ((yi > y) !== (yj > y) && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi) odd = !odd;
+  }
+  return odd;
+}
+
+/**
+ * @param {{ id: number, rings: number[][][], bottom: number, top: number }[]} buildings
+ *   outer rings in local metres, absolute bottom and roof elevations
+ * @param {number} [cell] size of the index cells (m)
+ */
+export function coverIndex(buildings, cell = 25) {
+  const cells = new Map();
+  const key = (cx, cy) => `${cx},${cy}`;
+  buildings.forEach((b, k) => {
+    let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+    for (const ring of b.rings) for (const [x, y] of ring) { minX = Math.min(minX, x); maxX = Math.max(maxX, x); minY = Math.min(minY, y); maxY = Math.max(maxY, y); }
+    if (!Number.isFinite(minX)) return;
+    for (let cx = Math.floor(minX / cell); cx <= Math.floor(maxX / cell); cx++) {
+      for (let cy = Math.floor(minY / cell); cy <= Math.floor(maxY / cell); cy++) {
+        const list = cells.get(key(cx, cy));
+        if (list) list.push(k); else cells.set(key(cx, cy), [k]);
+      }
+    }
+  });
+  return { buildings, cells, cell, key };
+}
+
+/**
+ * Height spans [bottom, top] of the buildings (other than `ownId`) whose
+ * footprint holds the point; empty when the point is in the open.
+ * @returns {number[][]}
+ */
+export function coverAt(index, x, y, ownId) {
+  const list = index.cells.get(index.key(Math.floor(x / index.cell), Math.floor(y / index.cell)));
+  if (!list) return [];
+  const out = [];
+  for (const k of list) {
+    const b = index.buildings[k];
+    if (b.id === ownId) continue;
+    if (b.rings.some((ring) => inside(x, y, ring))) out.push([b.bottom, b.top]);
+  }
+  return out;
+}
+
+/** Whether a wall point at absolute height z, with these spans in front of it, is open to the air. */
+export function isOpen(z, spans) {
+  for (const [bottom, top] of spans) if (z >= bottom && z < top) return false;
+  return true;
+}

zero2geospatial3d/web/src/core/road_sources.js

@@ -0,0 +1,127 @@
+// @ts-check
+// Road line sources shared by the noise (acoustics.js) and traffic
+// dispersion (dispersion.js) models: given polylines sampled into points that
+// carry their share of road length times relative traffic, or, without
+// roads, street centrelines found between the buildings.
+
+/** Relative traffic of the streets found when no roads are given: a
+ * residential street, as for OSM highway=residential (osm_tags.py). */
+export const STREET_TRAFFIC = 0.4;
+
+/**
+ * Relative traffic of road polyline q: 1 without weights, 0 for a road
+ * without traffic, never negative.
+ * @param {ArrayLike<number>|null} weights
+ * @param {number} q
+ */
+export function roadWeight(weights, q) {
+  const w = weights ? Number(weights[q]) : 1;
+  return Number.isFinite(w) ? Math.max(0, w) : 1;
+}
+
+/**
+ * Points along road polylines, about `step` metres apart. Each point's
+ * `length` is the road length it stands for times the road's traffic.
+ * `given` is true when at least one usable polyline was passed, even if
+ * all of them carry no traffic (those roads stay silent; no fallback).
+ * @param {Array<Array<[number, number]>>|null|undefined} roads
+ * @param {ArrayLike<number>|null} weights relative traffic per polyline (default 1)
+ * @param {number} step metres between samples
+ * @returns {{ sources: Array<{ x: number, y: number, length: number }>, given: boolean }}
+ */
+export function sampleRoadLines(roads, weights, step) {
+  /** @type {Array<{ x: number, y: number, length: number }>} */
+  const sources = [];
+  let given = false;
+  if (!Array.isArray(roads)) return { sources, given };
+  for (let q = 0; q < roads.length; q++) {
+    const poly = roads[q];
+    if (!Array.isArray(poly) || poly.length < 2) continue;
+    given = true;
+    const w = roadWeight(weights, q);
+    if (w === 0) continue;
+    for (let p = 0; p < poly.length - 1; p++) {
+      const [x1, y1] = poly[p];
+      const [x2, y2] = poly[p + 1];
+      const len = Math.hypot(x2 - x1, y2 - y1);
+      if (!(len > 0)) continue;
+      const count = Math.max(1, Math.round(len / step));
+      const segLen = len / count;
+      for (let k = 0; k < count; k++) {
+        const t = (k + 0.5) / count;
+        sources.push({ x: x1 + t * (x2 - x1), y: y1 + t * (y2 - y1), length: segLen * w });
+      }
+    }
+  }
+  return { sources, given };
+}
+
+/**
+ * Street centrelines when no roads are given: the ridge of the distance to
+ * the nearest solid building (the open cells farthest from both sides of a
+ * street), for streets up to 2 * maxHalfWidth wide. One source per ridge
+ * cell, `cell` metres of residential street (STREET_TRAFFIC), so a street
+ * counts once and not once per lane of cells. Empty without buildings.
+ * @param {Float32Array} heights obstacle height per cell (0 = open)
+ * @param {Float32Array|null} porosity tree porosity per cell (> 0 = not solid)
+ * @param {number} cols
+ * @param {number} rows
+ * @param {number} cell metres per cell
+ * @param {number} minX x of the first column's centre
+ * @param {number} maxY y of the first row's centre
+ * @param {number} [maxHalfWidth] metres from a facade to the street centre
+ * @returns {Array<{ x: number, y: number, length: number }>}
+ */
+export function streetCentrelines(heights, porosity, cols, rows, cell, minX, maxY, maxHalfWidth = 25) {
+  const n = cols * rows;
+  const INF = 1e9;
+  const dist = new Float32Array(n);
+  let hasSolid = false;
+  for (let i = 0; i < n; i++) {
+    if (heights[i] > 0 && !(porosity && porosity[i] > 0)) { dist[i] = 0; hasSolid = true; } else dist[i] = INF;
+  }
+  if (!hasSolid) return [];
+  // Two-pass chamfer distance (metres).
+  const a = cell, b = cell * Math.SQRT2;
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      const i = r * cols + c;
+      let v = dist[i];
+      if (c > 0) v = Math.min(v, dist[i - 1] + a);
+      if (r > 0) {
+        v = Math.min(v, dist[i - cols] + a);
+        if (c > 0) v = Math.min(v, dist[i - cols - 1] + b);
+        if (c < cols - 1) v = Math.min(v, dist[i - cols + 1] + b);
+      }
+      dist[i] = v;
+    }
+  }
+  for (let r = rows - 1; r >= 0; r--) {
+    for (let c = cols - 1; c >= 0; c--) {
+      const i = r * cols + c;
+      let v = dist[i];
+      if (c < cols - 1) v = Math.min(v, dist[i + 1] + a);
+      if (r < rows - 1) {
+        v = Math.min(v, dist[i + cols] + a);
+        if (c < cols - 1) v = Math.min(v, dist[i + cols + 1] + b);
+        if (c > 0) v = Math.min(v, dist[i + cols - 1] + b);
+      }
+      dist[i] = v;
+    }
+  }
+  /** @type {Array<{ x: number, y: number, length: number }>} */
+  const sources = [];
+  for (let r = 1; r < rows - 1; r++) {
+    for (let c = 1; c < cols - 1; c++) {
+      const i = r * cols + c;
+      const d = dist[i];
+      if (d < cell || d > maxHalfWidth) continue;
+      // A ridge across x or across y. Strict on one side only, so the
+      // two-cell ridge of an even-width street counts once.
+      const ridgeX = d >= dist[i - 1] && d > dist[i + 1];
+      const ridgeY = d >= dist[i - cols] && d > dist[i + cols];
+      if (ridgeX || ridgeY) sources.push({ x: minX + c * cell, y: maxY - r * cell, length: cell * STREET_TRAFFIC });
+    }
+  }
+  return sources;
+}

zero2geospatial3d/web/src/core/solar.js

@@ -0,0 +1,112 @@
+// @ts-check
+// Solar geometry (NOAA "General Solar Position Calculations"), sun-path
+// sampling for one day, and sky sampling for sky view / diffuse light.
+//
+// Scene axes: +x east, +y up, -z north. Azimuth is clockwise from north.
+
+const DEG = Math.PI / 180;
+
+/** Day of year (1..366) for a calendar date. */
+export function dayOfYear(year, month, day) {
+  const start = Date.UTC(year, 0, 1);
+  return Math.floor((Date.UTC(year, month - 1, day) - start) / 86400000) + 1;
+}
+
+export function isLeap(year) {
+  return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+}
+
+/**
+ * Sun position.
+ * @param {number} doy day of year (1-based)
+ * @param {number} hour local clock time in hours (0..24, fractional)
+ * @param {number} lat latitude, degrees north
+ * @param {number} lon longitude, degrees east
+ * @param {number} utcOffset time zone of the clock, hours east of UTC
+ * @param {number} [daysInYear]
+ * @returns {{ elevation: number, azimuth: number, declination: number, eqTime: number }}
+ *   elevation and azimuth in radians (azimuth clockwise from north), eqTime minutes
+ */
+export function solarPosition(doy, hour, lat, lon, utcOffset, daysInYear = 365) {
+  // The fractional year is defined on UTC time.
+  const g = (2 * Math.PI / daysInYear) * (doy - 1 + (hour - utcOffset - 12) / 24);
+  const eqTime = 229.18 * (0.000075 + 0.001868 * Math.cos(g) - 0.032077 * Math.sin(g)
+    - 0.014615 * Math.cos(2 * g) - 0.040849 * Math.sin(2 * g));
+  const decl = 0.006918 - 0.399912 * Math.cos(g) + 0.070257 * Math.sin(g)
+    - 0.006758 * Math.cos(2 * g) + 0.000907 * Math.sin(2 * g)
+    - 0.002697 * Math.cos(3 * g) + 0.00148 * Math.sin(3 * g);
+  const trueSolarMinutes = hour * 60 + eqTime + 4 * lon - 60 * utcOffset;
+  const ha = (trueSolarMinutes / 4 - 180) * DEG;
+  const phi = lat * DEG;
+  const sinEl = Math.sin(phi) * Math.sin(decl) + Math.cos(phi) * Math.cos(decl) * Math.cos(ha);
+  const elevation = Math.asin(Math.max(-1, Math.min(1, sinEl)));
+  let azimuth = Math.atan2(-Math.sin(ha) * Math.cos(decl),
+    Math.cos(phi) * Math.sin(decl) - Math.sin(phi) * Math.cos(decl) * Math.cos(ha));
+  if (azimuth < 0) azimuth += 2 * Math.PI;
+  return { elevation, azimuth, declination: decl, eqTime };
+}
+
+/** Unit vector towards the sun in scene axes. */
+export function sunVector(elevation, azimuth) {
+  const c = Math.cos(elevation);
+  return [Math.sin(azimuth) * c, Math.sin(elevation), -Math.cos(azimuth) * c];
+}
+
+/** Clock hours of sunrise and sunset (elevation crosses 0), or null for polar day/night. */
+export function sunriseSunset(doy, lat, lon, utcOffset) {
+  const above = (h) => solarPosition(doy, h, lat, lon, utcOffset).elevation > 0;
+  const step = 0.25;
+  let rise = null;
+  let set = null;
+  for (let h = 0; h < 24; h += step) {
+    const a = above(h);
+    const b = above(h + step);
+    if (!a && b && rise === null) rise = bisect(above, h, h + step, false);
+    if (a && !b) set = bisect(above, h, h + step, true);
+  }
+  return { sunrise: rise, sunset: set };
+}
+
+function bisect(above, lo, hi, startAbove) {
+  for (let i = 0; i < 30; i++) {
+    const mid = (lo + hi) / 2;
+    if (above(mid) === startAbove) lo = mid; else hi = mid;
+  }
+  return (lo + hi) / 2;
+}
+
+/**
+ * Sun directions through one day, every stepMinutes between startHour and
+ * endHour while the sun is above minElevationDeg. Each sample is weighted
+ * with its duration in hours, so the weights of unobstructed samples sum to
+ * sun hours.
+ */
+export function sunPath(doy, lat, lon, utcOffset, { startHour = 0, endHour = 24, stepMinutes = 10, minElevationDeg = 0.5 } = {}) {
+  const out = [];
+  const step = stepMinutes / 60;
+  for (let h = startHour + step / 2; h < endHour; h += step) {
+    const p = solarPosition(doy, h, lat, lon, utcOffset);
+    if (p.elevation < minElevationDeg * DEG) continue;
+    out.push({ dir: sunVector(p.elevation, p.azimuth), weight: step, hour: h, elevation: p.elevation, azimuth: p.azimuth });
+  }
+  return out;
+}
+
+/**
+ * Quasi-uniform directions over the upper hemisphere (Fibonacci lattice),
+ * each standing for an equal solid angle 2*pi/n. With the shader's cosine
+ * factor max(0, n.d) and weight 2/n, the sum is the sky view factor of a
+ * surface with normal n: 1 for an open horizontal surface, 0.5 for an open
+ * wall.
+ */
+export function skyHemisphere(n = 192) {
+  const out = [];
+  const golden = Math.PI * (3 - Math.sqrt(5));
+  for (let i = 0; i < n; i++) {
+    const y = 1 - (i + 0.5) / n; // uniform in cos(zenith) = uniform solid angle
+    const r = Math.sqrt(Math.max(0, 1 - y * y));
+    const a = i * golden;
+    out.push({ dir: [Math.cos(a) * r, y, Math.sin(a) * r], weight: 2 / n });
+  }
+  return out;
+}