"""Sreda ML: pedestrian-level wind speed from building footprints and heights. Reference preprocessing and inference for the ONNX model in this repository. It builds the model inputs exactly as the Sreda web app does, runs the model and returns K = <|U|> / U_in at 1.75 m above ground on a 0.75 m grid. Requirements: numpy, onnxruntime. python sreda_ml_example.py model.onnx Coordinates: scene metres, x to the east, y to the north. Wind direction: where the wind blows from, degrees clockwise from north. Buildings: dicts with "footprint" (list of [x, y] vertices, any orientation, not closed) and "height" in metres above flat ground. """ import math import sys import numpy as np STEP = 0.75 # model grid, m WIN, NW = 150.0, 200 # prediction window: metres and cells FR, FC = 288, 352 # model frame: rows across the wind x columns along the wind UP, SIDE = 96.0, 33.0 # frame margins around the window: upwind and on each side, m (downwind: 18 m) ROW0, COL0 = 44, 128 # window position inside the frame, cells DMAX = 50.0 # wall distances beyond 50 m are not resolved SPACING, KMAX, MARGIN, TAPER = 120.0, 4, 20.0, 40 # mosaic for larger sites, as in the Sreda app CTX_S0, CTX_T0, CTX_STEP, CTX_ALONG, CTX_ACROSS, CTX_SUB = -435.0, -300.0, 6.0, 88, 100, 4 # Inflow speed at 1.75 m per unit wind speed at 10 m: log profile with roughness length z0 = 0.5 m (0.494). U_IN_PED = math.log((1.75 + 0.5) / 0.5) / math.log((10 + 0.5) / 0.5) def wind_axes(from_deg): """Unit vectors in scene coordinates: along the flow (ax) and across it (ay, ax turned by +90 degrees).""" phi = math.radians(from_deg) fa = math.atan2(-math.cos(phi), -math.sin(phi)) return (math.cos(fa), math.sin(fa)), (-math.sin(fa), math.cos(fa)) def _ground(buildings): return [b for b in buildings if len(b["footprint"]) >= 3 and float(b.get("base", 0.0)) <= 0.01 and float(b["height"]) > 0] def raster(buildings, origin, from_deg, s0, t0, ns, nt, step=STEP, heights_only=False): """Building top height H and signed distance to the nearest wall (inside a building: minus the depth below its outline), on cell centres s0 + (i + 0.5) * step along the wind and t0 + (j + 0.5) * step across it, in metres from origin. Returns float32 arrays [nt, ns]; distances further than DMAX stay DMAX.""" ax, ay = wind_axes(from_deg) H = np.zeros((nt, ns), np.float32) dist = np.full((nt, ns), DMAX, np.float32) depth = np.zeros((nt, ns), np.float32) reach = 0.0 if heights_only else DMAX for b in _ground(buildings): p = np.asarray(b["footprint"], np.float64) top = float(b.get("base", 0.0)) + float(b["height"]) dx, dy = p[:, 0] - origin[0], p[:, 1] - origin[1] sa, ta = dx * ax[0] + dy * ax[1], dx * ay[0] + dy * ay[1] # vertex a sc, tc = np.roll(sa, 1), np.roll(ta, 1) # previous vertex c: edge c -> a smin, smax, tmin, tmax = sa.min(), sa.max(), ta.min(), ta.max() i0 = max(0, math.floor((smin - reach - s0) / step)) i1 = min(ns - 1, math.ceil((smax + reach - s0) / step)) j0 = max(0, math.floor((tmin - reach - t0) / step)) j1 = min(nt - 1, math.ceil((tmax + reach - t0) / step)) if i0 > i1 or j0 > j1: continue S = s0 + (np.arange(i0, i1 + 1) + 0.5) * step # [ni] T = t0 + (np.arange(j0, j1 + 1) + 0.5) * step # [nj] # Inside: even-odd rule along each row (edge crossings of the line t = const left of the cell centre). tt = T[:, None] cross = (ta[None, :] > tt) != (tc[None, :] > tt) # [nj, m] den = np.where(cross, tc - ta, 1.0) xs = np.where(cross, sa + (tt - ta) * (sc - sa) / den, np.inf) count = (xs[:, None, :] <= S[None, :, None]).sum(-1) # [nj, ni] box = (S[None, :] >= smin) & (S[None, :] <= smax) & (tt >= tmin) & (tt <= tmax) inside = box & (count % 2 == 1) h = H[j0:j1 + 1, i0:i1 + 1] h[inside & (top > h)] = top if heights_only: continue # Exact distance to the outline: nearest point on each edge. ex, ey = sa - sc, ta - tc ll = ex * ex + ey * ey px, py = S[None, :, None], T[:, None, None] u = np.where(ll > 0, ((px - sc) * ex + (py - tc) * ey) / np.where(ll > 0, ll, 1.0), 0.0) u = np.clip(u, 0.0, 1.0) qx, qy = sc + u * ex - px, tc + u * ey - py d = np.sqrt((qx * qx + qy * qy).min(-1)) # [nj, ni] dep = depth[j0:j1 + 1, i0:i1 + 1] dep[inside & (d > dep)] = d[inside & (d > dep)] dis = dist[j0:j1 + 1, i0:i1 + 1] out = ~inside & (d < dis) dis[out] = d[out] sdf = np.where(H > 0, -depth, dist).astype(np.float32) return H, sdf def frame_channels(H, sdf, r0=0, c0=0): """Model frame [3, FR, FC] cut at (r0, c0): building mask, height / 30 m, wall distance / 10 m clipped to [-2, 5].""" h = H[r0:r0 + FR, c0:c0 + FC].astype(np.float64) d = sdf[r0:r0 + FR, c0:c0 + FC].astype(np.float64) return np.stack([(h > 0).astype(np.float64), h / 30, np.minimum(5, np.maximum(-2, d / 10))]).astype(np.float32) def context(buildings, origin, from_deg, cs, ct): """Context around the window centre (cs, ct) on a 6 m grid: 100 rows (+-300 m across) x 88 columns (435 m upwind to 93 m downwind). Channels: built fraction, mean height of the built part / 30 m, maximum height / 30 m, pooled 4 x 4 from a 1.5 m raster.""" k = CTX_SUB H, _ = raster(buildings, origin, from_deg, CTX_S0 + cs, CTX_T0 + ct, CTX_ALONG * k, CTX_ACROSS * k, step=CTX_STEP / k, heights_only=True) b = H.reshape(CTX_ACROSS, k, CTX_ALONG, k).transpose(0, 2, 1, 3).reshape(CTX_ACROSS, CTX_ALONG, k * k) b = b.astype(np.float64) n = (b > 0).sum(-1) mean = np.where(n > 0, np.where(b > 0, b, 0).sum(-1) / np.maximum(n, 1), 0) / 30 return np.stack([n / (k * k), mean, b.max(-1) / 30]).astype(np.float32) def _row(a, b): """Windows along one axis: the fewest (up to KMAX) that cover [a, b] with a margin; centres on a 60 m grid.""" if not math.isfinite(a): return 0.0, 1, False a, b = a - MARGIN, b + MARGIN half = SPACING / 2 for n in range(1, KMAX + 1): if (n - 1) * SPACING + WIN < b - a: continue ideal = (a + b) / 2 - (n - 1) * SPACING / 2 for p0 in sorted([math.floor(ideal / half) * half, math.ceil(ideal / half) * half], key=lambda x: abs(x - ideal)): if p0 - WIN / 2 <= a and p0 + (n - 1) * SPACING + WIN / 2 >= b: return p0, n, False return _round_half_up(((a + b) / 2 - (KMAX - 1) * SPACING / 2) / half) * half, KMAX, True def _round_half_up(x): return math.floor(x + 0.5) def _taper(i): return np.minimum(1.0, np.minimum((i + 0.5) / TAPER, (NW - i - 0.5) / TAPER)) def predict(session, buildings, origin=(0.0, 0.0), from_deg=270.0): """K over the site: windows of 150 m on a 120 m grid around the buildings, frame and mirror averaged, windows blended with weights falling towards their edges. Returns dict with K [nt, ns] (NaN outside windows), solid mask, the grid origin in wind axes (s0, t0) and cell-centre coordinates x, y in scene metres.""" ax, ay = wind_axes(from_deg) g = _ground(buildings) st = [((x - origin[0]) * ax[0] + (y - origin[1]) * ax[1], (x - origin[0]) * ay[0] + (y - origin[1]) * ay[1]) for b in g for x, y in b["footprint"]] smin = min((s for s, _ in st), default=math.inf); smax = max((s for s, _ in st), default=-math.inf) tmin = min((t for _, t in st), default=math.inf); tmax = max((t for _, t in st), default=-math.inf) ps, ns_, clip_s = _row(smin, smax) pt, nt_, clip_t = _row(tmin, tmax) step_c = int(SPACING / STEP) out_s0, out_t0 = ps - WIN / 2, pt - WIN / 2 out_ns, out_nt = (ns_ - 1) * step_c + NW, (nt_ - 1) * step_c + NW in_ns, in_nt = (ns_ - 1) * step_c + FC, (nt_ - 1) * step_c + FR H, sdf = raster(g, origin, from_deg, out_s0 - UP, out_t0 - SIDE, in_ns, in_nt) w1 = _taper(np.arange(NW)) w = w1[:, None] * w1[None, :] num = np.zeros((out_nt, out_ns)); den = np.zeros((out_nt, out_ns)) for kt in range(nt_): for ks in range(ns_): r0, c0 = kt * step_c, ks * step_c f = frame_channels(H, sdf, r0, c0) c = context(g, origin, from_deg, out_s0 + ks * SPACING + WIN / 2, out_t0 + kt * SPACING + WIN / 2) frames = np.ascontiguousarray(np.stack([f, f[:, ::-1, :]])) ctx = np.ascontiguousarray(np.stack([c, c[:, ::-1, :]])) k = session.run(["k_ped"], {"frames": frames, "ctx": ctx})[0] k = (0.5 * (k[0].astype(np.float64) + k[1][::-1, :].astype(np.float64))).astype(np.float32) num[r0:r0 + NW, c0:c0 + NW] += w * k[ROW0:ROW0 + NW, COL0:COL0 + NW] den[r0:r0 + NW, c0:c0 + NW] += w K = np.where(den > 0, num / np.where(den > 0, den, 1), np.nan).astype(np.float32) solid = H[ROW0:ROW0 + out_nt, COL0:COL0 + out_ns] > 0 s = out_s0 + (np.arange(out_ns) + 0.5) * STEP t = out_t0 + (np.arange(out_nt) + 0.5) * STEP S, T = np.meshgrid(s, t) return {"K": K, "solid": solid, "s0": out_s0, "t0": out_t0, "windows": ns_ * nt_, "clipped": clip_s or clip_t, "x": origin[0] + S * ax[0] + T * ay[0], "y": origin[1] + S * ax[1] + T * ay[1]} def demo_buildings(): box = lambda x0, x1, y0, y1, h: {"footprint": [[x0, y0], [x1, y0], [x1, y1], [x0, y1]], "height": h} blocks = [box(i * 40 - 12, i * 40 + 12, j * 45 - 15, j * 45 + 15, 12 + 6 * ((i + j + 10) % 4)) for i in range(-3, 4) for j in range(-2, 3)] return blocks + [box(-300, -260, -20, 20, 60)] if __name__ == "__main__": import onnxruntime as ort if len(sys.argv) < 2: raise SystemExit("python sreda_ml_example.py model.onnx [wind_from_deg] [U10 m/s]") sess = ort.InferenceSession(sys.argv[1], providers=["CPUExecutionProvider"]) wind_from = float(sys.argv[2]) if len(sys.argv) > 2 else 270.0 u10 = float(sys.argv[3]) if len(sys.argv) > 3 else 5.0 r = predict(sess, demo_buildings(), (0.0, 0.0), wind_from) K = np.where(r["solid"], np.nan, r["K"]) speed = K * U_IN_PED * u10 print(f"windows {r['windows']}, grid {K.shape[0]} x {K.shape[1]} cells of {STEP} m") print(f"K at 1.75 m: min {np.nanmin(K):.3f}, mean {np.nanmean(K):.3f}, max {np.nanmax(K):.3f}") print(f"speed at 1.75 m for U10 = {u10} m/s: mean {np.nanmean(speed):.2f} m/s, max {np.nanmax(speed):.2f} m/s") np.savez_compressed("sreda_ml_demo.npz", K=r["K"], solid=r["solid"], x=r["x"], y=r["y"]) print("saved sreda_ml_demo.npz (K, solid, x, y)")