sreda-ml / sreda_ml_example.py
Azatyt's picture
Sreda ML 0.6.1: model, card, licence and example
b6f453a verified
Raw History Blame Contribute Delete
10.8 kB
"""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)")