zero2geospatial3d-sdk 0.1.0__py3-none-any.whl

zero2geospatial3d/microclimate.py

@@ -0,0 +1,388 @@
+"""Microclimate screening: surface energy balance, foliar canopy shading,
+evapotranspirative canopy cooling advection and 24-hour diurnal comfort.
+
+ENVI-met-inspired screening physics ported from the 02Geo3D QGIS plugin
+(``web/src/core/microclimate.js``). Grids are ``(rows, cols)`` numpy arrays,
+row 0 is north, column 0 is west.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Any, Callable, Mapping, Optional, Sequence, Union
+
+import numpy as np
+
+from .comfort import mean_radiant_temperature, pet, sky_temperature, utci
+from .solar import day_of_year, solar_position
+from .weather import Weather, conditions_at
+
+__all__ = [
+    "SURFACE_MATERIALS",
+    "canopy_cooling_grid",
+    "canopy_transmittance",
+    "diurnal_point_profile",
+    "surface_temperature",
+]
+
+SIGMA = 5.67e-8
+
+#: Urban surface materials: albedo, longwave emissivity, Bowen ratio,
+#: roughness length z0 (m) and a display colour.
+SURFACE_MATERIALS: dict[str, dict[str, Any]] = {
+    "asphalt": {
+        "label": "Asphalt / dark pavement",
+        "albedo": 0.12,
+        "emissivity": 0.95,
+        "bowen": 8.0,
+        "roughness": 0.01,
+        "color": "#3b3d42",
+    },
+    "concrete": {
+        "label": "Concrete / stone",
+        "albedo": 0.28,
+        "emissivity": 0.92,
+        "bowen": 5.0,
+        "roughness": 0.015,
+        "color": "#a6acb5",
+    },
+    "brick": {
+        "label": "Brick / pavers",
+        "albedo": 0.25,
+        "emissivity": 0.93,
+        "bowen": 4.0,
+        "roughness": 0.02,
+        "color": "#b86b52",
+    },
+    "soil": {
+        "label": "Bare soil / gravel",
+        "albedo": 0.22,
+        "emissivity": 0.94,
+        "bowen": 2.0,
+        "roughness": 0.03,
+        "color": "#b59975",
+    },
+    "grass": {
+        "label": "Grass / vegetated ground",
+        "albedo": 0.22,
+        "emissivity": 0.97,
+        "bowen": 0.5,
+        "roughness": 0.05,
+        "color": "#6fbf73",
+    },
+    "cool_pavement": {
+        "label": "Cool pavement (high albedo)",
+        "albedo": 0.55,
+        "emissivity": 0.95,
+        "bowen": 5.0,
+        "roughness": 0.01,
+        "color": "#d8dee9",
+    },
+    "green_roof": {
+        "label": "Green / cool roof",
+        "albedo": 0.45,
+        "emissivity": 0.96,
+        "bowen": 0.6,
+        "roughness": 0.06,
+        "color": "#7fc97f",
+    },
+    "water": {
+        "label": "Water surface",
+        "albedo": 0.08,
+        "emissivity": 0.98,
+        "bowen": 0.25,
+        "roughness": 0.001,
+        "color": "#2b83ba",
+    },
+}
+
+Material = Union[str, Mapping[str, Any]]
+
+
+def _material(material: Material) -> Mapping[str, Any]:
+    if isinstance(material, Mapping):
+        return material
+    return SURFACE_MATERIALS.get(str(material), SURFACE_MATERIALS["concrete"])
+
+
+def _finite(x: Any) -> bool:
+    try:
+        return x is not None and math.isfinite(float(x))
+    except (TypeError, ValueError):
+        return False
+
+
+def _prop(mat: Mapping[str, Any], key: str, default: float) -> float:
+    v = mat.get(key)
+    return float(v) if v is not None and _finite(v) else default
+
+
+def canopy_transmittance(lai: float = 3.0, extinction: float = 0.6) -> float:
+    """Beer-Lambert shortwave transmittance through a canopy of leaf area index ``lai``."""
+    return math.exp(-extinction * max(0.0, lai))
+
+
+def surface_temperature(
+    air_temp: float,
+    sky_temp: float,
+    svf: float = 1.0,
+    sunlit: float = 1.0,
+    dni: float = 0.0,
+    dhi: float = 0.0,
+    ghi: float = 0.0,
+    elevation_deg: float = 45.0,
+    wind_speed: Optional[float] = 2.0,
+    material: Material = "concrete",
+    tree_shade: float = 0.0,
+    lai: float = 3.0,
+) -> float:
+    """Steady-state ground/roof surface temperature (C) from an energy balance.
+
+    Absorbed short-wave plus net long-wave to the sky is split into
+    convective (Bowen-ratio partitioned) and linearised radiative exchange.
+    The excess over air temperature is clamped to -12..+35 K.
+
+    Args:
+        air_temp: air temperature, C.
+        sky_temp: effective sky temperature, C.
+        svf: sky view factor (0..1).
+        sunlit: direct-sun fraction (0..1).
+        dni: direct normal irradiance, W/m2.
+        dhi: diffuse horizontal irradiance, W/m2.
+        ghi: global horizontal irradiance, W/m2 (unused; kept for API parity).
+        elevation_deg: sun elevation, degrees.
+        wind_speed: near-surface wind speed, m/s (clamped 0.2..15; None -> 2).
+        material: key of :data:`SURFACE_MATERIALS` or a property mapping.
+        tree_shade: canopy shading fraction (0..1).
+        lai: leaf area index of shading trees.
+    """
+    del ghi
+    mat = _material(material)
+    albedo = _prop(mat, "albedo", 0.28)
+    emissivity = _prop(mat, "emissivity", 0.92)
+    bowen = _prop(mat, "bowen", 5.0)
+
+    sw_direct = (
+        dni * math.sin(math.radians(elevation_deg)) * max(0.0, min(1.0, float(sunlit)))
+        if elevation_deg > 0
+        else 0.0
+    )
+    shade = max(0.0, min(1.0, float(tree_shade)))
+    if shade > 0:
+        tau = canopy_transmittance(lai)
+        sw_direct *= 1 - shade * (1 - tau)
+
+    s = max(0.0, min(1.0, float(svf)))
+    sw_absorbed = (1 - albedo) * (sw_direct + s * dhi)
+
+    t_sky_k = sky_temp + 273.15
+    t_air_k = air_temp + 273.15
+    lw_net = emissivity * s * SIGMA * (t_sky_k**4 - t_air_k**4)
+    q_rad = sw_absorbed + lw_net
+
+    ws = max(0.2, min(15.0, float(wind_speed) if _finite(wind_speed) else 2.0))  # type: ignore[arg-type]
+    hc = 5.8 + 4.1 * ws
+    hr = 4 * emissivity * SIGMA * t_air_k**3
+    # q_rad = H + LE + hr dT with H = hc dT and LE = H / Bowen: evaporation
+    # raises the convective conductance only. A surface losing heat does not evaporate.
+    h_turb = hc * (1 + bowen) / bowen if q_rad > 0 else hc
+    delta_t = q_rad / (h_turb + hr)
+    return float(air_temp + max(-12.0, min(35.0, delta_t)))
+
+
+def canopy_cooling_grid(
+    heights: np.ndarray,
+    cell: float,
+    porosity: Optional[np.ndarray] = None,
+    green_mask: Optional[np.ndarray] = None,
+    wind_from_deg: float = 270.0,
+    wind_speed: float = 2.0,
+    air_temp: float = 30.0,
+    rh: float = 45.0,
+    lai: float = 3.0,
+    svf: Optional[np.ndarray] = None,
+) -> np.ndarray:
+    """Evapotranspirative cooling potential advected downwind, plus canyon heating.
+
+    Args:
+        heights: ``(rows, cols)`` obstacle height above ground (0 = open).
+        cell: cell size, metres.
+        porosity: optical porosity per cell (trees > 0); None = all solid.
+        green_mask: vegetated ground fraction 0..1 (grass/lawn).
+        wind_from_deg: meteorological direction the wind comes from (0 = N, 90 = E).
+        wind_speed: ambient wind speed, m/s.
+        air_temp: ambient air temperature, C.
+        rh: relative humidity, %.
+        lai: tree leaf area index.
+        svf: sky view factor grid; cells below 0.5 get up to +1.5 K canyon heating.
+
+    Returns:
+        ``(rows, cols)`` air temperature change dTa (K; negative = cooling,
+        NaN inside solid buildings).
+    """
+    h = np.asarray(heights, dtype=float)
+    rows, cols = h.shape
+    por = None if porosity is None else np.asarray(porosity, dtype=float).reshape(rows, cols)
+    tree = por > 0 if por is not None else np.zeros_like(h, dtype=bool)
+    solid = (h > 0) & ~tree
+
+    vpd_norm = max(0.1, min(1.0, 1 - max(0.0, min(100.0, rh)) / 100))
+    temp_excess = max(0.0, min(1.5, (max(15.0, air_temp) - 10) / 15))
+    vpd_factor = vpd_norm * temp_excess
+
+    tree_cool = np.where(tree, -2.5 * vpd_factor * min(1.0, max(0.0, lai / 3.0)), 0.0)
+    if green_mask is not None:
+        g = np.asarray(green_mask, dtype=float).reshape(rows, cols)
+        grass_cool = np.where(g > 0, -1.0 * vpd_factor * np.clip(g, 0, 1), 0.0)
+    else:
+        grass_cool = np.zeros_like(h)
+    source = np.where(solid, 0.0, np.minimum(tree_cool, grass_cool))
+
+    # Unit step pointing upwind: +col is east, -row is north.
+    from_rad = math.radians(wind_from_deg)
+    dc = math.sin(from_rad)
+    dr = -math.cos(from_rad)
+    decay = max(25.0, min(60.0, 35 + wind_speed * 2.5))
+    max_steps = int(math.ceil(120 / cell))
+
+    rr, cc = np.mgrid[0:rows, 0:cols]
+    best = np.zeros_like(h)
+    alive = ~solid
+    for s in range(1, max_steps + 1):
+        # JS Math.round rounds halves up: floor(x + 0.5).
+        uc = np.floor(cc + s * dc + 0.5).astype(int)
+        ur = np.floor(rr + s * dr + 0.5).astype(int)
+        inside = (uc >= 0) & (uc < cols) & (ur >= 0) & (ur < rows)
+        alive &= inside
+        if not alive.any():
+            break
+        ucc = np.clip(uc, 0, cols - 1)
+        urc = np.clip(ur, 0, rows - 1)
+        alive &= ~solid[urc, ucc]
+        up = source[urc, ucc]
+        adv = np.where(alive & (up < 0), up * math.exp(-s * cell / decay), 0.0)
+        best = np.minimum(best, adv)
+
+    cooling = np.minimum(source, best)
+    uhi = np.zeros_like(h)
+    if svf is not None:
+        sv = np.asarray(svf, dtype=float).reshape(rows, cols)
+        with np.errstate(invalid="ignore"):
+            low = np.isfinite(sv) & (sv < 0.5)
+        uhi = np.where(low, 1.5 * ((0.5 - np.where(low, sv, 0.5)) / 0.5), 0.0)
+    out = cooling + uhi
+    out[solid] = np.nan
+    return out
+
+
+SunByHour = Union[Sequence[float], Callable[[int], float], None]
+
+
+def diurnal_point_profile(
+    lat: float,
+    lon: float,
+    utc_offset: float,
+    month: int,
+    day: int,
+    weather: Optional[Weather] = None,
+    air_temp_mean: float = 28.0,
+    air_temp_amp: float = 6.0,
+    rh_mean: float = 50.0,
+    wind_speed: float = 2.0,
+    svf: float = 0.7,
+    sun_by_hour: SunByHour = None,
+    material: Material = "concrete",
+    tree_crown: bool = False,
+    lai: float = 3.0,
+) -> list[dict[str, float]]:
+    """24-hour air, surface, mean radiant temperature, UTCI and PET at one spot.
+
+    Uses EPW conditions when ``weather`` is given, otherwise a sinusoidal
+    temperature wave peaking at 15:00 with a synthetic clear sky.
+
+    Args:
+        sun_by_hour: sunlit fraction per hour (24 values or ``f(hour)``);
+            default: sunlit whenever the sun is up.
+
+    Returns:
+        24 dicts with keys ``hour, air_temp, surface_temp, mrt, utci, pet, sunlit``.
+    """
+    mat = _material(material)
+    doy = day_of_year(2025, month, day)
+    profile: list[dict[str, float]] = []
+    for h in range(24):
+        pos = solar_position(doy, h + 0.5, lat, lon, utc_offset)
+        elevation_deg = math.degrees(pos.elevation)
+        air_temp, rh, ws = air_temp_mean, rh_mean, wind_speed
+        dni = dhi = ghi = 0.0
+        ir: Optional[float] = None
+        if weather is not None:
+            cond = conditions_at(weather, month, day, h + 1)
+            if _finite(cond["air_temp"]):
+                air_temp = float(cond["air_temp"])  # type: ignore[arg-type]
+            if _finite(cond["rh"]):
+                rh = float(cond["rh"])  # type: ignore[arg-type]
+            if _finite(cond["wind_speed"]):
+                ws = float(cond["wind_speed"])  # type: ignore[arg-type]
+            dni = float(cond["dni"] or 0.0)
+            dhi = float(cond["dhi"] or 0.0)
+            ghi = float(cond["ghi"] or 0.0)
+            if _finite(cond["ir"]):
+                ir = float(cond["ir"])  # type: ignore[arg-type]
+        else:
+            wave = math.cos((h - 15) * math.pi / 12)
+            air_temp = air_temp_mean + air_temp_amp * wave
+            rh = max(20.0, min(95.0, rh_mean - 15 * wave))
+            if elevation_deg > 0:
+                sin_el = math.sin(pos.elevation)
+                dni = 950 * math.exp(-0.13 / max(0.01, sin_el))
+                dhi = 120 * sin_el
+                ghi = dni * sin_el + dhi
+
+        sunlit = 1.0 if elevation_deg > 0 else 0.0
+        if sun_by_hour is not None:
+            if callable(sun_by_hour):
+                sunlit = float(sun_by_hour(h))
+            elif h < len(sun_by_hour) and _finite(sun_by_hour[h]):
+                sunlit = float(sun_by_hour[h])
+
+        sky = sky_temperature(air_temp, ir)
+        surf = surface_temperature(
+            air_temp,
+            sky,
+            svf=svf,
+            sunlit=sunlit,
+            dni=dni,
+            dhi=dhi,
+            ghi=ghi,
+            elevation_deg=elevation_deg,
+            wind_speed=ws,
+            material=mat,
+            tree_shade=1.0 if tree_crown else 0.0,
+            lai=lai,
+        )
+        mrt = mean_radiant_temperature(
+            air_temp,
+            sky,
+            svf,
+            sunlit,
+            dni,
+            dhi,
+            ghi,
+            elevation_deg,
+            albedo=_prop(mat, "albedo", 0.2),
+            ground_temp=surf,
+            wall_temp=air_temp,
+        )
+        profile.append(
+            {
+                "hour": h,
+                "air_temp": air_temp,
+                "surface_temp": surf,
+                "mrt": mrt,
+                "utci": float(utci(air_temp, mrt, ws, rh)),
+                "pet": pet(air_temp, mrt, ws, rh),
+                "sunlit": sunlit,
+            }
+        )
+    return profile

zero2geospatial3d/morphology.py

@@ -0,0 +1,283 @@
+"""Urban morphology and heat-island indicators from a building-height grid.
+
+Heights are metres above ground per cell (0 = open), as a ``(rows, cols)``
+array with row 0 at the north.
+
+* ``lambda_p`` plan area fraction, ``lambda_f`` frontal area index (wind)
+* ``H`` area-weighted mean height, ``H/W`` canyon aspect ratio
+* ``zd``, ``z0`` displacement height and roughness length, Macdonald,
+  Griffiths and Hall (1998), Atmos. Environ. 32(11):1857-1864,
+  doi:10.1016/S1352-2310(97)00403-2 (A = 4.43, beta = 1, Cd = 1.2)
+* LCZ: approximate Local Climate Zone (built types 1-6, 8, 9) from the
+  property ranges of Stewart and Oke (2012), BAMS 93(12):1879-1900,
+  doi:10.1175/BAMS-D-11-00019.1.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import Optional
+
+import numpy as np
+
+__all__ = [
+    "LCZ_COLORS",
+    "LCZ_LABELS",
+    "BlockIndicators",
+    "block_indicators",
+    "classify_lcz",
+    "distance_to_built",
+    "macdonald",
+]
+
+KAPPA = 0.4
+
+LCZ_LABELS: dict[int, str] = {
+    1: "LCZ 1 Compact high-rise",
+    2: "LCZ 2 Compact midrise",
+    3: "LCZ 3 Compact low-rise",
+    4: "LCZ 4 Open high-rise",
+    5: "LCZ 5 Open midrise",
+    6: "LCZ 6 Open low-rise",
+    8: "LCZ 8 Large low-rise",
+    9: "LCZ 9 Sparsely built",
+    0: "Open land (LCZ A-G)",
+}
+LCZ_COLORS: dict[int, str] = {
+    1: "#8c0000",
+    2: "#d10000",
+    3: "#ff0000",
+    4: "#bf4d00",
+    5: "#ff6600",
+    6: "#ff9955",
+    8: "#bcbcbc",
+    9: "#ffccaa",
+    0: "#6fbf73",
+}
+
+
+def _as2d(heights: np.ndarray, cols: Optional[int], rows: Optional[int]) -> np.ndarray:
+    h = np.asarray(heights, dtype=float)
+    if h.ndim == 1:
+        if cols is None or rows is None:
+            raise ValueError("cols and rows are required for a flat heights array")
+        h = h.reshape(rows, cols)
+    return h
+
+
+def distance_to_built(
+    heights: np.ndarray,
+    cols: Optional[int] = None,
+    rows: Optional[int] = None,
+    cell: float = 1.0,
+) -> np.ndarray:
+    """Two-pass chamfer distance (metres) from every cell to the nearest built cell.
+
+    ``heights`` may be ``(rows, cols)`` or flat with ``cols``/``rows`` given.
+    Returns a ``(rows, cols)`` array; 1e9 when nothing is built.
+    """
+    h = _as2d(heights, cols, rows)
+    nr, nc = h.shape
+    d = np.where(h > 0, 0.0, 1e9)
+    a = cell
+    b = cell * math.sqrt(2)
+    idx = np.arange(nc) * a
+    for r in range(nr):
+        w = d[r].copy()
+        if r > 0:
+            up = d[r - 1]
+            w = np.minimum(w, up + a)
+            w[1:] = np.minimum(w[1:], up[:-1] + b)
+            w[:-1] = np.minimum(w[:-1], up[1:] + b)
+        # v[c] = min(w[c], v[c-1] + a) == min_j<=c (w[j] + a (c - j))
+        d[r] = np.minimum.accumulate(w - idx) + idx
+    for r in range(nr - 1, -1, -1):
+        w = d[r].copy()
+        if r < nr - 1:
+            dn = d[r + 1]
+            w = np.minimum(w, dn + a)
+            w[:-1] = np.minimum(w[:-1], dn[1:] + b)
+            w[1:] = np.minimum(w[1:], dn[:-1] + b)
+        rev = w[::-1]
+        d[r] = (np.minimum.accumulate(rev - idx) + idx)[::-1]
+    return d
+
+
+def macdonald(
+    lambda_p: float,
+    lambda_f: float,
+    mean_height: float,
+    A: float = 4.43,
+    beta: float = 1.0,
+    Cd: float = 1.2,
+) -> tuple[float, float]:
+    """Macdonald et al. (1998) displacement height and roughness length.
+
+    Returns:
+        ``(zd, z0)`` in metres.
+    """
+    if not (mean_height > 0) or not (lambda_p > 0):
+        return 0.0, 0.03
+    lp = min(0.95, lambda_p)
+    zd_h = 1 + A ** (-lp) * (lp - 1)
+    lf = max(1e-4, lambda_f)
+    z0_h = (1 - zd_h) * math.exp(-((0.5 * beta * (Cd / (KAPPA * KAPPA)) * (1 - zd_h) * lf) ** -0.5))
+    return zd_h * mean_height, max(0.01, z0_h * mean_height)
+
+
+def classify_lcz(lambda_p: float, mean_height: float, mean_footprint: float = 0.0) -> int:
+    """Approximate built LCZ from plan fraction, mean height and mean footprint (m2)."""
+    if not (lambda_p >= 0.1):
+        return 9 if lambda_p > 0.02 else 0
+    tall = "high" if mean_height >= 25 else "mid" if mean_height >= 10 else "low"
+    if tall == "low" and mean_footprint >= 1500 and lambda_p >= 0.3:
+        return 8
+    if lambda_p < 0.2:
+        return 9 if tall == "low" else 5 if tall == "mid" else 4
+    if lambda_p >= 0.4:
+        return 1 if tall == "high" else 2 if tall == "mid" else 3
+    return 4 if tall == "high" else 5 if tall == "mid" else 6
+
+
+@dataclass
+class BlockIndicators:
+    """Morphology per block; every array is ``(block_rows, block_cols)``."""
+
+    cols: int
+    rows: int
+    cell: float
+    lambda_p: np.ndarray
+    lambda_f: np.ndarray
+    mean_height: np.ndarray
+    max_height: np.ndarray
+    height_std: np.ndarray
+    hw: np.ndarray
+    zd: np.ndarray
+    z0: np.ndarray
+    svf: np.ndarray
+    lcz: np.ndarray
+    volume_density: np.ndarray
+
+
+def block_indicators(
+    heights: np.ndarray,
+    cell: float,
+    block_cells: int,
+    wind_from_deg: float = 270.0,
+    svf: Optional[np.ndarray] = None,
+    feature_ids: Optional[np.ndarray] = None,
+    cols: Optional[int] = None,
+    rows: Optional[int] = None,
+) -> BlockIndicators:
+    """Indicators per block of ``block_cells`` x ``block_cells`` grid cells.
+
+    Args:
+        heights: building height above ground per cell.
+        cell: cell size in metres.
+        block_cells: cells per block side.
+        wind_from_deg: wind direction (from), for ``lambda_f``.
+        svf: optional sky view factor per cell (block mean reported).
+        feature_ids: building id per cell (0 = none), for the mean footprint.
+    """
+    h = _as2d(heights, cols, rows)
+    nr, nc = h.shape
+    bc = math.ceil(nc / block_cells)
+    br = math.ceil(nr / block_cells)
+    nb = bc * br
+    to_rad = math.radians((wind_from_deg + 180) % 360)
+    ux = math.sin(to_rad)
+    uy = math.cos(to_rad)
+    dist = distance_to_built(h, cell=cell)
+    rr, cc = np.mgrid[0:nr, 0:nc]
+    block = ((rr // block_cells) * bc + (cc // block_cells)).ravel()
+    built = (h > 0).ravel()
+    hv = h.ravel()
+
+    # Windward faces: upwind neighbour lower than this cell.
+    frontal = np.zeros_like(h)
+    if ux > 0:
+        nb_x = np.pad(h, ((0, 0), (1, 0)), constant_values=np.nan)[:, :-1]
+    else:
+        nb_x = np.pad(h, ((0, 0), (0, 1)), constant_values=np.nan)[:, 1:]
+    if uy > 0:
+        nb_y = np.pad(h, ((0, 1), (0, 0)), constant_values=np.nan)[1:, :]
+    else:
+        nb_y = np.pad(h, ((1, 0), (0, 0)), constant_values=np.nan)[:-1, :]
+    with np.errstate(invalid="ignore"):
+        fx = np.where(np.isfinite(nb_x), np.maximum(0, h - nb_x), 0.0) * cell * abs(ux)
+        fy = np.where(np.isfinite(nb_y), np.maximum(0, h - nb_y), 0.0) * cell * abs(uy)
+    frontal = np.where(h > 0, fx + fy, 0.0).ravel()
+
+    def bsum(w: np.ndarray) -> np.ndarray:
+        return np.bincount(block, weights=w, minlength=nb)
+
+    n = np.bincount(block, minlength=nb).astype(float)
+    n_built = bsum(built.astype(float))
+    h_sum = bsum(np.where(built, hv, 0.0))
+    h2_sum = bsum(np.where(built, hv * hv, 0.0))
+    h_max = np.zeros(nb)
+    np.maximum.at(h_max, block[built], hv[built])
+    fr = bsum(frontal)
+    open_ = ~built
+    open_d = bsum(np.where(open_, dist.ravel(), 0.0))
+    open_n = bsum(open_.astype(float))
+    if svf is not None:
+        sv = np.asarray(svf, dtype=float).ravel()
+        fin = np.isfinite(sv)
+        svf_sum = bsum(np.where(fin, sv, 0.0))
+        svf_n = bsum(fin.astype(float))
+    else:
+        svf_sum = np.zeros(nb)
+        svf_n = np.zeros(nb)
+
+    mean_fp = np.zeros(nb)
+    if feature_ids is not None:
+        ids = np.asarray(feature_ids).ravel().astype(np.int64)
+        pos = ids > 0
+        uniq, counts = np.unique(ids[pos], return_counts=True)
+        fp_of = dict(zip(uniq.tolist(), (counts * cell * cell).tolist()))
+        pairs = np.unique(np.stack([block[built & pos], ids[built & pos]], 1), axis=0)
+        for k in range(nb):
+            sel = pairs[pairs[:, 0] == k, 1] if pairs.size else np.zeros(0, dtype=np.int64)
+            if sel.size:
+                mean_fp[k] = sum(fp_of.get(int(i), 0.0) for i in sel) / sel.size
+
+    plan = n * cell * cell
+    with np.errstate(invalid="ignore", divide="ignore"):
+        lp = np.where(n > 0, n_built / np.maximum(n, 1), 0.0)
+        H = np.where(n_built > 0, h_sum / np.maximum(n_built, 1), 0.0)
+        hstd = np.where(
+            n_built > 0, np.sqrt(np.maximum(0, h2_sum / np.maximum(n_built, 1) - H * H)), 0.0
+        )
+        lf = np.where(plan > 0, fr / np.maximum(plan, 1e-300), 0.0)
+        vd = np.where(plan > 0, h_sum * cell * cell / np.maximum(plan, 1e-300), 0.0)
+        W = np.where(open_n > 0, 2 * open_d / np.maximum(open_n, 1), 0.0)
+        hw = np.where((W > 0) & (H > 0), H / np.where(W > 0, W, 1), np.where(H > 0, 3.0, 0.0))
+        svf_b = np.where(svf_n > 0, svf_sum / np.maximum(svf_n, 1), np.nan)
+    zd = np.zeros(nb)
+    z0 = np.zeros(nb)
+    lcz = np.zeros(nb, dtype=np.uint8)
+    for k in range(nb):
+        zd[k], z0[k] = macdonald(float(lp[k]), float(lf[k]), float(H[k]))
+        lcz[k] = classify_lcz(float(lp[k]), float(H[k]), float(mean_fp[k]))
+
+    def shp(a: np.ndarray) -> np.ndarray:
+        return a.reshape(br, bc)
+
+    return BlockIndicators(
+        cols=bc,
+        rows=br,
+        cell=cell * block_cells,
+        lambda_p=shp(lp),
+        lambda_f=shp(lf),
+        mean_height=shp(H),
+        max_height=shp(h_max),
+        height_std=shp(hstd),
+        hw=shp(hw),
+        zd=shp(zd),
+        z0=shp(z0),
+        svf=shp(svf_b),
+        lcz=shp(lcz),
+        volume_density=shp(vd),
+    )