#!/usr/bin/env python3
"""3D model KONCEPTA iz program.json za Blender scenu postojećeg stanja (kampanja "prikazi i tlocrti").

Status: AI građanski koncept · PRIJEDLOG · nije projekt. Render nije dokaz statike, kapaciteta,
položaja ni izvedivosti. Sve što program ne zadaje uzima se iz ZADANO_KONCEPT i vrijedi kao
PRETPOSTAVKA (popis i obrazloženje: research/viz/model/KONCEPT.md).

Ulaz je bilo koji valjani program.json (format: research/viz/README.md). Modul ne pretpostavlja
id-jeve ni broj razina: razinu parka prepoznaje po kategorijama, kosine po nazivu i kontrolnim
kotama, rubove po geometriji i orijentaciji. Podaci programa su u ENU-N; mreže se grade u ENU-M
(scripts/viz/koordinate.py).

Primjer (Python s modulom bpy):

    import koncept, scena, kamera
    s = koncept.izgradi("research/viz/program.json")
    scena.postavi_sunce(s, "2026-06-21 17:30")
    scena.postavi_kameru(s, koncept.pogledi(s, sirina_px=1920)["zrak_jug"])
    scena.renderiraj(s, "izlaz/zrak_jug.jpg", uzorci=96)          # + _maska.png, _podslojevi.png, _dubina.npz
    koncept.rastavljeni_prikaz("research/viz/program.json", "izlaz/rastavljeno.png")

CLI:  python scripts/viz/koncept.py visine | mjere | pogled | probni | rastavljeni | presjek  (vidi --help)
"""
from __future__ import annotations

import json
import math
import re
import sys
import time
import unicodedata
from pathlib import Path

import numpy as np

try:
    from . import kamera as KAM
    from . import koordinate as K
    from . import scena as SC
except ImportError:  # pokretanje kao skripta iz scripts/viz
    sys.path.insert(0, str(Path(__file__).resolve().parent))
    import kamera as KAM
    import koordinate as K
    import scena as SC

OZNAKA = "AI građanski koncept · PRIJEDLOG · nije projekt"
OZNAKA_RENDER = "AI građanski koncept · PRIJEDLOG · nije projekt · render nije dokaz"

# Podslojevi koncepta u maski objekata. Datoteka <ime>_maska.png nosi 10 za sve podslojeve (kao sloj
# "koncept" u scena.py), a <ime>_podslojevi.png izvorne vrijednosti.
PODSLOJEVI = {"park": 10, "stadion": 11, "procelja": 12, "staklo": 13, "zivot": 14, "drvece_koncepta": 15}

# Zadane vrijednosti. Sve su PRETPOSTAVKA osim gdje je naveden izvor; program ih nadjačava kad nosi podatak.
ZADANO_KONCEPT = {
    "korak_m": 1.5,                 # mreža plohe parka
    "tekstura_m": 0.25,             # veličina piksela teksture plohe parka
    "sjeme": 20261114,
    "debljina_pokrova_m": 1.2,      # ploča pokrova nad cestom (program_alat.KONSTRUKCIJA_M)
    "visina_portala_m": 6.0,        # svijetli otvor portala ceste i tramvaja
    "visina_kolnog_ulaza_m": 4.5,
    "visina_ulaza_m": 3.2,
    "sirina_kolnog_ulaza_m": 7.0,
    "sirina_ulaza_m": 4.0,
    "kat_procelja_m": 4.2,          # visina kata južnih pročelja (staklo 3,2 + ploča 1,0)
    "terase": True,                 # M19: južni rub viši od kata kao terase, uvučene prema unutra (krug 3)
    "uvlacenje_terase_m": 3.0,      # dubina terase po katu (svaki viši kat toliko dalje od ruba programa)
    "najvise_terasa": 3,
    "terase_azimut": (135.0, 225.0),  # azimut vanjske normale ruba s terasama (jug; M19 broji isto)
    "terase_nagib": 0.03,           # terase samo gdje je vrh ruba približno vodoravan (zaglađeno na ±6 m)
    "terasa_najmanja_duljina_m": 10.0,
    "prizemlje_terasa_m": 2.7,      # najmanja visina prizemlja ispod najniže terase (uz najvišu točku tla niza)
    "zardinjera_m": (0.6, 1.0),     # visina i širina zelene žardinjere na rubu terase
    "ograda_m": 1.1,
    "kota_igralista": 118.5,        # odluka M1 (118 do 119), ako program nema prostor kategorije igraliste
    "red_tribine_m": 0.85,
    "vijenac_krova_m": 4.0,         # visina vanjskog vijenca krova ako se ne može izvesti iz pročelja
    "vrh_krova_mnv": 166.5,         # vrh krova stadiona ako ga program ne zadaje (kanon README, PRETPOSTAVKA)
    "dubina_lamele_m": 1.1,
    "debljina_lamele_m": 0.30,
    "visina_paviljona_m": 3.5,
    "visina_zatvorenog_m": 4.5,     # zatvoren prostor nižih razina izvan parka, bez zadane visine
    "razmak_stabala_m": 11.0,
    "visina_stabala_m": (6.0, 13.0),  # mlada stabla na ploči; pokrov nad cestom niža
    "covjek_m": 1.75,
    "m2_po_covjeku": 160.0,
    "najvise_ljudi": 700,
    "tramvaj_m": (32.0, 2.3, 3.4),  # ZET niskopodni, zaokruženo
    "autobus_m": (12.0, 2.55, 3.1),
    "najvise_tramvaja": 6,
    "najvise_autobusa": 8,
    "prag_spoja_m": 0.9,            # susjedni prostori s manjom razlikom kota čine neprekinutu plohu
    "prag_spoja_ravnih_m": 0.45,    # samo uz vodu; ostale razlike do prag_spoja_m su blagi spoj (krug 2)
    "svjetlo_pod_pokrovom": 6.0,    # jakost rasvjete podgleda pokrova (da se cesta nazire)
    "drvece": True, "ljudi": True, "vozila": True, "prizemlje": True, "elementi": True,
    "unutrasnjost": False,          # kutije prostora nižih razina na stvarnim kotama (za presječnu perspektivu)
    # izgled (15.11.2026., završna obrada): mlada stabla s deblom, granama i rahlom krošnjom umjesto
    # nakupine kugli; zimi (krošnje scene prozirne) gola stabla ili ranoproljetni pupovi. PRETPOSTAVKA, samo izgled.
    "mlada_stabla": True,
    "zima_stabala": "golo",         # "golo" (deblo i grane) ili "pupovi" (rijetko svijetlo zelenilo)
    "opna_hrapavost": 0.38,         # tamno staklo pročelja stadiona: zamućen odraz (bez mrlja od odraza okoline)
    "svjetlo_zdjele": 100.0,        # ispuna zdjele stadiona (približno W/m², samo igralište i tribine; 0 = isključeno)
    "spusti_teren_u_stadionu": True,
    "boja_tla_u_obuhvatu": True,    # ortofoto se u obuhvatu koncepta prekriva bojom travnjaka (izrez_tlo u scena.py)
}

ZATVORENE = {"sport_zatvoreni", "zdravlje", "kultura", "javne_sluzbe", "komercijala", "ugostiteljstvo", "garaza",
             "promet_tramvaj", "promet_bus", "topli_put", "tehnika", "logistika"}
PROMETNE = {"promet_cesta", "promet_tramvaj", "promet_bus"}
# širina kolnika po razredu ceste iz OSM-a (site.json), samo orijentacijski; pješačke i biciklističke staze nisu ulice
RAZREDI_ULICA = {"primary": 8.0, "secondary": 7.0, "tertiary": 6.0, "residential": 5.0, "unclassified": 5.0,
                 "living_street": 4.0, "service": 3.0, "secondary_link": 6.0, "tertiary_link": 5.0}
PARKOVNE = {"park_zelenilo", "staza", "svjetlarnik", "sport_otvoreni"}
TVRDO_TLO = {"trg_predvorje", "staza", "promet_cesta", "promet_tramvaj", "promet_bus", "sport_otvoreni", "voda"}
PRIORITET = {"voda": 0, "kultura": 1, "sport_otvoreni": 2, "tribine": 3, "ugostiteljstvo": 4, "staza": 6,
             "trg_predvorje": 7, "park_zelenilo": 9}

# Boje kategorija za rastavljeni prikaz (iste kao u tlocrtima; scripts/viz/program_alat.py). Zamjenska
# tablica vrijedi ako se alat ne može uvesti.
try:
    try:
        from . import program_alat as PA
    except ImportError:
        import program_alat as PA
    BOJE_KAT = {k: v[0] for k, v in PA.BOJE.items()}
    NAZIVI_KAT = dict(PA.NAZIVI_KAT)
except Exception:  # noqa: BLE001
    BOJE_KAT = {"stadion": "#c9d7f2", "igraliste": "#a8d99a", "tribine": "#9db4e6", "sport_zatvoreni": "#ffd08a",
                "sport_otvoreni": "#d6ec9c", "zdravlje": "#f7b6c4", "kultura": "#d9bdf0", "javne_sluzbe": "#b9e3e8",
                "komercijala": "#f9e08c", "ugostiteljstvo": "#f6c19a", "garaza": "#cfcfcf",
                "promet_tramvaj": "#9fc5f8", "promet_bus": "#b7d3c0", "promet_cesta": "#b8b8c4",
                "topli_put": "#ff9d7a", "trg_predvorje": "#efe6d2", "tehnika": "#d5d0c8", "logistika": "#c9c2b0",
                "park_zelenilo": "#cdeac0", "staza": "#eadfc8", "svjetlarnik": "#d6f3fb", "voda": "#a9dcf5",
                "dvoriste": "#e7f3dc", "postojece": "#e2e2e2"}
    NAZIVI_KAT = {k: k.replace("_", " ") for k in BOJE_KAT}

# Boje materijala (sRGB 0..255). Ilustracija, ne specifikacija materijala.
RGB = {
    # krug 3: manje zasićeno (montaža na fotografiji: koncept je bio prečist i prezasićen)
    "trava": (88, 106, 62), "livada": (110, 116, 72), "igraliste_djecje": (184, 172, 148),
    "staza": (196, 187, 166), "aleja": (206, 200, 188), "trg": (186, 182, 174), "kamen": (168, 163, 153),
    "beton": (176, 174, 168), "beton_tamni": (120, 120, 118), "zid_zeleni": (66, 86, 52), "pokos": (84, 102, 62),
    "tartan": (160, 92, 74), "umjetna_trava": (78, 116, 82), "pijesak": (206, 192, 156), "sportska_podloga": (98, 120, 138),
    "kosarka": (180, 124, 86), "tenis": (148, 104, 86), "skate": (168, 168, 164), "guma": (172, 112, 92), "voda": (60, 88, 100),
    "asfalt": (72, 72, 74), "nogostup": (150, 148, 142), "tracnica": (40, 40, 42), "bijelo": (240, 240, 236),
    "plava": (34, 80, 160), "plava_tamna": (16, 42, 104), "sjedala": (40, 84, 160), "krov": (228, 228, 222),
    "staklo_tamno": (26, 34, 44), "portal": (10, 10, 12), "ulaz": (30, 40, 52), "tramvaj": (20, 86, 178),
    "autobus": (232, 232, 228), "drvo": (176, 136, 92), "igraliste": (64, 122, 58),
}


def _log(*a):
    print("[koncept]", *a, flush=True)


def norm(s) -> str:
    s = str(s).lower().replace("đ", "d")
    s = "".join(c for c in unicodedata.normalize("NFKD", s) if not unicodedata.combining(c))
    return re.sub(r"[^a-z0-9]+", "_", s).strip("_")


def lin(c):
    """sRGB (0..255 ili '#rrggbb') -> linearni RGB 0..1."""
    if isinstance(c, str):
        c = tuple(int(c.lstrip("#")[i:i + 2], 16) for i in (0, 2, 4))
    a = np.asarray(c, dtype=np.float64) / 255.0
    return tuple(float(v) for v in np.where(a <= 0.04045, a / 12.92, ((a + 0.055) / 1.055) ** 2.4))


def _broj(v):
    return isinstance(v, (int, float)) and not isinstance(v, bool) and math.isfinite(v)


def _tocke(v):
    if not isinstance(v, list):
        return None
    out = []
    for p in v:
        if not (isinstance(p, (list, tuple)) and len(p) >= 2 and _broj(p[0]) and _broj(p[1])):
            return None
        out.append((float(p[0]), float(p[1])))
    return out


def _poligon(vanjski, rupe=None):
    """Tolerantno sastavlja shapely poligon (ili None)."""
    from shapely.geometry import Polygon

    t = _tocke(vanjski)
    if not t or len(set(t)) < 3:
        return None
    r = [x for x in (_tocke(h) for h in (rupe or [])) if x and len(set(x)) >= 3]
    try:
        g = Polygon(t, r)
        if not g.is_valid:
            g = g.buffer(0)
        return g if (not g.is_empty and g.area > 0.5) else None
    except Exception:  # noqa: BLE001
        return None


def _poligoni(g, min_m2=0.5):
    """Rastavlja geometriju na poligone."""
    if g is None or g.is_empty:
        return []
    if g.geom_type == "Polygon":
        return [g] if g.area >= min_m2 else []
    if hasattr(g, "geoms"):
        return [q for p in g.geoms for q in _poligoni(p, min_m2)]
    return []


# ---------------------------------------------------------------------------
# Program
# ---------------------------------------------------------------------------

class Program:
    """Tolerantno učitan program.json. Geometrija se drži u ENU-N (shapely)."""

    def __init__(self, put):
        from shapely.geometry import LineString, Point

        self.put = Path(put)
        p = json.loads(self.put.read_text(encoding="utf-8"))
        self.p = p
        self.meta = p.get("meta") or {}
        self.metricki = "ENU-M" in str(self.meta.get("koordinate", ""))
        pret = (lambda t: [list(K.n_iz_m(a, b)) for a, b in t]) if self.metricki else (lambda t: t)

        def pol(v, rupe=None):
            t = _tocke(v)
            if t is None:
                return None
            return _poligon([list(q) for q in pret(t)], [[list(q) for q in pret(_tocke(h) or [])] for h in (rupe or [])])

        self.razine, po_id = [], {}
        for i, r in enumerate(p.get("razine") or []):
            if not isinstance(r, dict):
                continue
            z = {"i": len(self.razine), "id": str(r.get("id", f"razina{i}")), "naziv": str(r.get("naziv", "")),
                 "kota": float(r["kota_poda_mnv"]) if _broj(r.get("kota_poda_mnv")) else None,
                 "visina": float(r["svijetla_visina_m"]) if _broj(r.get("svijetla_visina_m")) else None,
                 "geom": pol(r.get("obris")), "opis": str(r.get("opis") or "")}
            self.razine.append(z)
            po_id.setdefault(z["id"], z)
        self.prostori = []
        for i, s in enumerate(p.get("prostori") or []):
            if not isinstance(s, dict):
                continue
            raz = po_id.get(str(s.get("razina")))
            g = pol(s.get("poligon"), s.get("rupe"))
            if g is None or raz is None:
                continue
            pod = float(s["kota_poda_mnv"]) if _broj(s.get("kota_poda_mnv")) else raz["kota"]
            self.prostori.append({
                "i": len(self.prostori), "id": str(s.get("id", f"prostor{i}")), "razina": raz["i"],
                "naziv": str(s.get("naziv") or ""), "kat": str(s.get("kategorija") or ""), "geom": g, "pod": pod,
                "visina": float(s["svijetla_visina_m"]) if _broj(s.get("svijetla_visina_m")) else None,
                "napomena": str(s.get("napomena") or ""), "sportovi": [str(x) for x in (s.get("sportovi") or [])],
                "tekst": norm(f"{s.get('id', '')} {s.get('naziv', '')}"),
                "tekst_sve": norm(f"{s.get('naziv', '')} {s.get('napomena', '')} {' '.join(map(str, s.get('sportovi') or []))}")})
        self.veze = []
        for i, v in enumerate(p.get("veze") or []):
            if not isinstance(v, dict):
                continue
            g = None
            l = _tocke(v.get("linija")) if v.get("linija") is not None else None
            if l and len(l) >= 2:
                g = LineString(pret(l))
            elif v.get("tocka") is not None and _tocke([v.get("tocka")]):
                g = Point(pret(_tocke([v.get("tocka")]))[0])
            if g is None:
                continue
            self.veze.append({"id": str(v.get("id", f"veza{i}")), "tip": str(v.get("tip") or ""), "geom": g,
                              "razine": [po_id[str(x)]["i"] for x in (v.get("razine") or []) if str(x) in po_id],
                              "sirina": float(v["sirina_m"]) if _broj(v.get("sirina_m")) else None,
                              "napomena": str(v.get("napomena") or "")})
        k = [(float(q["x"]), float(q["y"]), float(q["z"])) for q in (p.get("kote_terena") or [])
             if isinstance(q, dict) and all(_broj(q.get(c)) for c in "xyz")]
        self.kote = np.asarray(k, dtype=np.float64).reshape(-1, 3)
        if self.metricki and len(self.kote):
            xn, yn = K.n_iz_m(self.kote[:, 0], self.kote[:, 1])
            self.kote[:, 0], self.kote[:, 1] = xn, yn
        self.stadion = self._stadion(p.get("stadion"), pol)
        self.i_park = self._razina_parka()

    def _stadion(self, st, pol):
        if not isinstance(st, dict):
            return None
        vanj = pol(st.get("vanjski_obris"))
        if vanj is None:
            return None
        out = {"vanjski": vanj, "igraliste": pol(st.get("igraliste")), "tribine": [], "krov": None, "procelje": None}
        sr = _tocke([st.get("sredina")]) if st.get("sredina") is not None else None
        c = sr[0] if sr else (vanj.centroid.x, vanj.centroid.y)
        out["sredina"] = tuple(K.n_iz_m(*c)) if self.metricki and sr else tuple(c)
        for t in st.get("tribine") or []:
            if not isinstance(t, dict):
                continue
            a, b = pol(t.get("unutarnji_obris")), pol(t.get("vanjski_obris"))
            if a is None or b is None or not (_broj(t.get("kota_dna_mnv")) and _broj(t.get("kota_vrha_mnv"))):
                continue
            out["tribine"].append({"naziv": str(t.get("naziv") or ""), "unut": a, "vanj": b,
                                   "dno": float(t["kota_dna_mnv"]), "vrh": float(t["kota_vrha_mnv"])})
        out["tribine"].sort(key=lambda t: t["dno"])
        kr = st.get("krov")
        if isinstance(kr, dict):
            a, b = pol(kr.get("unutarnji_rub")), pol(kr.get("vanjski_rub"))
            if a is not None and b is not None:
                out["krov"] = {"unut": a, "vanj": b,
                               "rub": float(kr["kota_ruba_mnv"]) if _broj(kr.get("kota_ruba_mnv")) else None,
                               "vrh": float(kr["kota_vrha_mnv"]) if _broj(kr.get("kota_vrha_mnv")) else None}
        pr = st.get("procelje")
        if isinstance(pr, dict):
            out["procelje"] = {"dno": float(pr["kota_dna_mnv"]) if _broj(pr.get("kota_dna_mnv")) else None,
                               "vrh": float(pr["kota_vrha_mnv"]) if _broj(pr.get("kota_vrha_mnv")) else None,
                               "razmak": float(pr["razmak_lamela_m"]) if _broj(pr.get("razmak_lamela_m")) else 3.0}
        # jedinstveni navijački sjever (program: stadion.sjever, jedna ploha bez srednjeg prstena)
        sj = st.get("sjever")
        if isinstance(sj, dict) and sj.get("obris") and sj.get("profil"):
            prof = np.asarray(sj["profil"], dtype=np.float64)
            out["sjever"] = {"obris": pol(sj["obris"]), "profil_d": prof[:, 0], "profil_z": prof[:, 1],
                             "naziv": str(sj.get("naziv") or "")}
        # raspon d (od prvog reda) svake tribine iz njezina profila; redoslijed kao u out["tribine"] (po dnu)
        sir = sorted([t for t in (st.get("tribine") or []) if isinstance(t, dict) and t.get("profil")],
                     key=lambda t: float(t.get("kota_dna_mnv") or 0))
        if len(sir) == len(out["tribine"]):
            d0s = [float(t["profil"][0][0]) for t in sir]
            for i, t in enumerate(out["tribine"]):
                t["d0"] = d0s[i]
                t["d1"] = d0s[i + 1] if i + 1 < len(d0s) else float(sir[i]["profil"][-1][0]) + 0.8
        return out

    def _razina_parka(self):
        """Razina parka = razina s najvećom površinom parkovnih kategorija (bez pretpostavke o id-ju)."""
        zbroj = {}
        for s in self.prostori:
            if s["kat"] in PARKOVNE:
                zbroj[s["razina"]] = zbroj.get(s["razina"], 0.0) + s["geom"].area
        if not zbroj:
            return max((r["i"] for r in self.razine), default=0)
        return max(zbroj, key=zbroj.get)

    def prostori_razine(self, i):
        return [s for s in self.prostori if s["razina"] == i]

    def kota_igralista(self, zadano):
        z = [s["pod"] for s in self.prostori if s["kat"] == "igraliste" and s["pod"] is not None]
        return float(min(z)) if z else float(zadano)


# ---------------------------------------------------------------------------
# Ploha parka i brežuljka (bez Blendera)
# ---------------------------------------------------------------------------

class Povrsina:
    """Projektirana ploha razine parka: kote po ćelijama, spojevi susjednih prostora, zidovi i otvori.

    tlo(x, y) vraća kotu današnjeg tla u ENU-N. Sve koordinate ovdje su ENU-N.
    """

    def __init__(self, program: Program, tlo, opcije=None, site=None):
        from shapely.ops import unary_union

        self.P = program
        self.o = {**ZADANO_KONCEPT, **(opcije or {})}
        self.tlo = tlo
        self.site = site or {}
        self.g = float(self.o["korak_m"])
        self.nalazi = {"pretpostavke": [], "upozorenja": []}
        st = program.stadion
        self.stadion_geom = st["vanjski"] if st else None
        self.kota_podija = (st["procelje"]["dno"] if st and st["procelje"] and st["procelje"]["dno"] is not None
                            else program.razine[program.i_park]["kota"]) if program.razine else None
        t0 = time.time()
        self._prostori_plohe()
        self.F = unary_union([s["geom"] for s in self.pl] + [s["geom"] for s in self.svj]) if self.pl else None
        self._mreza()
        self._kote_celija()
        self._spojevi()
        self._polja()
        self._praznine()
        self.vrijeme_s = round(time.time() - t0, 2)

    # --- izbor prostora ---------------------------------------------------
    def _prostori_plohe(self):
        from shapely.geometry import MultiPolygon
        from shapely.ops import unary_union
        from shapely.strtree import STRtree

        P = self.P
        park = P.prostori_razine(P.i_park)
        self.svj = [dict(s) for s in park if s["kat"] == "svjetlarnik"]
        svj_u = unary_union([s["geom"] for s in self.svj]) if self.svj else None
        kand = []
        for s in park:
            if s["kat"] == "svjetlarnik":
                continue
            g = s["geom"]
            if self.stadion_geom is not None:
                if s["kat"] in ("tribine", "stadion", "igraliste") and \
                        g.intersection(self.stadion_geom).area > 0.6 * g.area:
                    continue  # gradi ga graditelj stadiona
                g = g.difference(self.stadion_geom)
            if svj_u is not None:
                g = g.difference(svj_u)
            if g.is_empty or g.area < 1.0:
                continue
            kand.append({**s, "geom": g})
        # preklapanja na istoj razini: prednost ima kategorija višeg prioriteta, zatim manji prostor
        kand.sort(key=lambda s: (PRIORITET.get(s["kat"], 5), s["geom"].area))
        gotovo = []
        for s in kand:
            g = s["geom"]
            if gotovo:
                tree = STRtree([q["geom"] for q in gotovo])
                for j in tree.query(g, predicate="intersects"):
                    h = gotovo[int(j)]["geom"]
                    if g.intersection(h).area > 0.05:
                        g = g.difference(h)
            dijelovi = _poligoni(g, 1.0)
            if not dijelovi:
                continue
            s["geom"] = dijelovi[0] if len(dijelovi) == 1 else MultiPolygon(dijelovi)
            gotovo.append(s)
        # uske pukotine između prostora (do oko 1,2 m) pripajaju se susjedu, da ne nastanu prorezi do tla
        dijelovi = [q["geom"] for q in gotovo] + [q["geom"] for q in self.svj]
        if self.stadion_geom is not None:
            dijelovi.append(self.stadion_geom)
        if gotovo:
            U = unary_union(dijelovi)
            puk = U.buffer(0.6, join_style=2).buffer(-0.6, join_style=2).difference(U)
            if not puk.is_empty and puk.area > 0.01:
                for s in sorted(gotovo, key=lambda q: -q["geom"].area):
                    if puk.is_empty:
                        break
                    dod = s["geom"].buffer(0.65, join_style=2).intersection(puk)
                    if not dod.is_empty and dod.area > 0.005:
                        novi = _poligoni(s["geom"].union(dod.buffer(0.01)), 1.0)
                        if novi:
                            s["geom"] = novi[0] if len(novi) == 1 else MultiPolygon(novi)
                            puk = puk.difference(dod.buffer(0.02))
        for k, s in enumerate(gotovo):
            s["k"] = k
        self.pl = gotovo

    # --- mreža ćelija ------------------------------------------------------
    def _mreza(self):
        import shapely

        g = self.g
        geomi = [s["geom"] for s in self.pl] + [s["geom"] for s in self.svj]
        if self.stadion_geom is not None:
            geomi.append(self.stadion_geom)
        b = np.array([q.bounds for q in geomi])
        rub = 4 * g
        self.x0 = math.floor((b[:, 0].min() - rub) / g) * g
        self.y0 = math.floor((b[:, 1].min() - rub) / g) * g
        self.nx = int(math.ceil((b[:, 2].max() + rub - self.x0) / g))
        self.ny = int(math.ceil((b[:, 3].max() + rub - self.y0) / g))
        self.cx = self.x0 + (np.arange(self.nx) + 0.5) * g
        self.cy = self.y0 + (np.arange(self.ny) + 0.5) * g
        L = np.full((self.ny, self.nx), -1, dtype=np.int32)  # -1 izvan, -2 svjetlarnik, -3 stadion, >=0 prostor

        def upisi(geom, vrijednost):
            x0, y0, x1, y1 = geom.bounds
            j0, j1 = max(int((x0 - self.x0) / g), 0), min(int((x1 - self.x0) / g) + 1, self.nx)
            i0, i1 = max(int((y0 - self.y0) / g), 0), min(int((y1 - self.y0) / g) + 1, self.ny)
            if j1 <= j0 or i1 <= i0:
                return
            X, Y = np.meshgrid(self.cx[j0:j1], self.cy[i0:i1])
            shapely.prepare(geom)
            m = shapely.contains_xy(geom, X, Y)
            L[i0:i1, j0:j1][m] = vrijednost

        if self.stadion_geom is not None:
            upisi(self.stadion_geom, -3)
        for s in self.svj:
            upisi(s["geom"], -2)
        for s in sorted(self.pl, key=lambda q: -q["geom"].area):
            upisi(s["geom"], s["k"])
        self.L = L
        X, Y = np.meshgrid(self.cx, self.cy)
        self.T = np.asarray(self.tlo(X, Y), dtype=np.float64)

    def celija(self, x, y):
        j = np.clip(((np.asarray(x) - self.x0) / self.g).astype(int), 0, self.nx - 1)
        i = np.clip(((np.asarray(y) - self.y0) / self.g).astype(int), 0, self.ny - 1)
        return i, j

    # --- kote po ćelijama ----------------------------------------------------
    def _razvrstaj(self, s, kote):
        """Ravna ploha ili kosina. Kosina: naziv govori o nagibu ili kontrolne kote uz prostor ne
        odgovaraju koti poda. Kontrolne kote koje se sve slažu znače ravnu plohu bez obzira na naziv."""
        if s["kat"] in ZATVORENE and s.get("pod_zadan"):
            s["terase"] = False
            return False  # zatvoren prostor sa zadanom kotom poda nikad nije kosina (paviljon, dvorana)
        ime = norm(s["naziv"])
        po_imenu = bool(re.search(r"kosin|padin|ramp|nagib|spust|pokos|uspon|silaz|serpentin|stepen", ime)) or \
            bool(re.search(r"teras", ime) and re.search(r"\d+ ?(do|-|–) ?\d+", s["naziv"]))
        zz = kote[s["kote_03"], 2] if len(s["kote_03"]) else np.array([])
        zu = kote[s["kote_unutra"], 2] if len(s["kote_unutra"]) else np.array([])
        s["terase"] = False
        if po_imenu:
            # kote koje se sve slažu znače ravnu plohu bez obzira na naziv
            if len(zz) >= 3 and float(np.ptp(zz)) < 0.3:
                return False
            s["terase"] = bool(re.search(r"teras|stepen", ime))
            return True
        # kote na samom rubu ravne plohe opisuju i susjeda (vrh ili dno zida), pa odlučuju samo kote unutar plohe
        return len(zu) >= 2 and float(np.ptp(zu)) >= 0.8

    def _kote_celija(self):
        import shapely
        from scipy import ndimage
        from scipy.interpolate import RBFInterpolator
        from scipy.spatial import cKDTree
        from shapely.strtree import STRtree

        P, g, L, T = self.P, self.g, self.L, self.T
        kote = P.kote
        kt_tocke = shapely.points(kote[:, :2]) if len(kote) else np.array([])
        prazno = np.array([], dtype=int)
        for s in self.pl:
            s["pod_zadan"] = s["pod"] is not None
            if s["pod"] is None:
                s["pod"] = self.kota_podija if self.kota_podija is not None else float(np.nanmean(T))
            s["kote_idx"], s["kote_03"], s["kote_unutra"] = prazno, prazno, prazno
            if len(kote):
                x0, y0, x1, y1 = s["geom"].bounds
                u = (kote[:, 0] > x0 - 2) & (kote[:, 0] < x1 + 2) & (kote[:, 1] > y0 - 2) & (kote[:, 1] < y1 + 2)
                idx = np.nonzero(u)[0]
                if len(idx):
                    d = shapely.distance(s["geom"], kt_tocke[idx])
                    s["kote_idx"], s["kote_03"] = idx[d <= 0.6], idx[d <= 0.3]
                    ru = shapely.distance(s["geom"].boundary, kt_tocke[idx])
                    s["kote_unutra"] = idx[(d <= 0.0) & (ru > 0.75)]
            s["kosina"] = self._razvrstaj(s, kote)
        H = np.full(L.shape, np.nan)
        for s in self.pl:
            if not s["kosina"]:
                H[L == s["k"]] = s["pod"]
        kos = [s for s in self.pl if s["kosina"]]
        # susjedstvo svih prostora plohe (dodir do 0,3 m)
        sus = {s["k"]: set() for s in self.pl}
        if self.pl:
            tree = STRtree([s["geom"] for s in self.pl])
            a, b = tree.query([s["geom"] for s in self.pl], predicate="dwithin", distance=0.3)
            for i, j in zip(a, b):
                if i != j:
                    sus[int(i)].add(int(j))
        # kontrolne kote kosine: bez rubnih kota susjedne ravne plohe ondje gdje druge kote pokazuju lom
        for s in kos:
            idx = s["kote_idx"]
            zadrzi = np.ones(len(idx), bool)
            for q in sus[s["k"]]:
                b_ = self.pl[q]
                if b_["kosina"] or not len(idx):
                    continue
                zajed = np.isin(idx, b_["kote_idx"])
                if zajed.any():
                    dz = np.abs(kote[idx[zajed], 2] - b_["pod"])
                    if (dz > 0.6).any():
                        zadrzi[np.nonzero(zajed)[0][dz <= 0.3]] = False
            s["cp"] = idx[zadrzi]
            s["cp_stablo"] = cKDTree(kote[s["cp"], :2]) if len(s["cp"]) >= 2 else None

        def procjena(s, p):
            """Kota kosine u točki procijenjena samo iz njezinih kontrolnih kota (ili None)."""
            if s["cp_stablo"] is None:
                return None
            d, ii = s["cp_stablo"].query(p, k=min(3, len(s["cp"])))
            w = 1.0 / (np.atleast_1d(d) + 0.5) ** 2
            return float(np.sum(w * kote[s["cp"][np.atleast_1d(ii)], 2]) / np.sum(w))

        rod = {s["k"]: s["k"] for s in kos}

        def nadji(a):
            while rod[a] != a:
                rod[a] = rod[rod[a]]
                a = rod[a]
            return a

        for s in kos:
            for q in sus[s["k"]]:
                if self.pl[q]["kosina"]:
                    rod[nadji(s["k"])] = nadji(q)
        skupine = {}
        for s in kos:
            skupine.setdefault(nadji(s["k"]), []).append(s)
        self.prekinuti = set()
        izvan = L == -1
        for clanovi in skupine.values():
            ids = {s["k"] for s in clanovi}
            tx, ty, tz = [], [], []
            for s in clanovi:
                for i in s["cp"]:
                    tx.append(kote[i, 0]); ty.append(kote[i, 1]); tz.append(kote[i, 2])
            cp_stablo = cKDTree(np.column_stack([tx, ty])) if tx else None
            for s in clanovi:
                for p, n in self._uzorci_ruba(s["geom"], 3.0):
                    q = p + 1.2 * n
                    i, j = self.celija(q[0], q[1])
                    l = int(L[i, j])
                    if l in ids or l == -2:
                        continue
                    if cp_stablo is not None and cp_stablo.query(p)[0] < 1.5:
                        continue  # kontrolna kota ima prednost
                    ze = procjena(s, p)
                    if l >= 0:
                        z = self.pl[l]["pod"]
                        if ze is not None and abs(ze - z) > 0.8:
                            continue
                    elif l == -3:
                        z = self.kota_podija
                        if z is None or (ze is not None and abs(ze - z) > 0.8):
                            continue
                    else:
                        zt = float(self.tlo(p[0], p[1]))
                        if ze is not None and ze - zt > 0.8:
                            continue  # rub kosine ovdje završava zidom iznad tla
                        z = zt - 0.3
                    tx.append(p[0]); ty.append(p[1]); tz.append(z)
            maska = np.isin(L, list(ids))
            if not maska.any():
                continue
            ii, jj = np.nonzero(maska)
            if len(tx) < 3:
                H[maska] = np.mean(tz) if tx else np.mean([s["pod"] for s in clanovi])
                continue
            sve = np.column_stack([tx, ty])
            _, jed = np.unique(np.round(sve / 0.5), axis=0, return_index=True)
            pts, zz = sve[jed], np.asarray(tz)[jed]
            try:
                f = RBFInterpolator(pts, zz, kernel="linear", degree=1, neighbors=min(len(pts), 64), smoothing=0.3)
                v = f(np.column_stack([self.cx[jj], self.cy[ii]]))
            except Exception as e:  # noqa: BLE001
                self.nalazi["upozorenja"].append(f"interpolacija kosine {[s['id'] for s in clanovi][:3]}: {e}")
                v = np.full(len(ii), float(np.mean(zz)))
            H[ii, jj] = np.clip(v, zz.min() - 0.3, zz.max() + 0.3)
        # terase: kosina se lomi u stepenice
        for s in self.pl:
            if s["terase"]:
                m = L == s["k"]
                if m.any():
                    v = H[m]
                    raspon = float(v.max() - v.min())
                    if raspon > 1.5:
                        korak = min(max(raspon / 4.0, 1.0), 3.5)
                        H[m] = v.min() + np.round((v - v.min()) / korak) * korak
        # ništa ispod današnjeg tla: ravne plohe prate tlo gdje je tlo više; kosine smiju zaroniti samo uz rub
        unutra = L >= 0
        daleko_od_ruba = ndimage.binary_erosion(~izvan, iterations=3)
        ravno = np.zeros(L.shape, bool)
        for s in self.pl:
            if not s["kosina"]:
                ravno |= L == s["k"]
        H = np.where(unutra & (ravno | daleko_od_ruba), np.maximum(H, T + 0.12), H)
        H = np.where(unutra & ~ravno & ~daleko_od_ruba, np.maximum(H, T - 0.3), H)
        self.H = H

    @staticmethod
    def _uzorci_ruba(geom, korak):
        """Točke na rubu poligona s vanjskom normalom (ENU-N)."""
        from shapely.geometry.polygon import orient

        for pol in _poligoni(geom, 0.0):
            pol = orient(pol, 1.0)
            for prsten in [pol.exterior] + list(pol.interiors):
                c = np.asarray(prsten.coords)
                for a, b in zip(c[:-1], c[1:]):
                    d = b - a
                    l = float(np.hypot(*d))
                    if l < 1e-6:
                        continue
                    n = np.array([d[1], -d[0]]) / l  # desno od smjera = van (vanjski prsten CCW, rupe CW)
                    k = max(int(round(l / korak)), 1)
                    for t in (np.arange(k) + 0.5) / k:
                        yield a + d * t, n

    # --- spojevi susjednih prostora ------------------------------------------
    def _spojevi(self):
        """Par susjednih prostora je spojen (neprekinuta ploha) ako je medijan razlike kota na dodiru malen."""
        L, H, T = self.L, self.H, self.T
        Hs = np.where(L >= 0, H, np.where(L == -1, T - 0.3, np.nan))
        a_sve, b_sve, d_sve = [], [], []
        for (sa, sb) in (((slice(None), slice(None, -1)), (slice(None), slice(1, None))),
                         ((slice(None, -1), slice(None)), (slice(1, None), slice(None)))):
            a, b = L[sa], L[sb]
            m = (a != b) & (a >= -1) & (b >= -1)
            a_sve.append(np.minimum(a[m], b[m])); b_sve.append(np.maximum(a[m], b[m]))
            d_sve.append(np.abs(Hs[sa][m] - Hs[sb][m]))
        a, b, d = np.concatenate(a_sve), np.concatenate(b_sve), np.concatenate(d_sve)
        kljuc = (a.astype(np.int64) + 2) * 100000 + (b.astype(np.int64) + 2)
        red = np.argsort(kljuc)
        kljuc, a, b, d = kljuc[red], a[red], b[red], d[red]
        poc = np.nonzero(np.r_[True, kljuc[1:] != kljuc[:-1]])[0]
        kraj = np.r_[poc[1:], len(kljuc)]
        self.spoj = {}
        self.susjedi = {}
        for p0, p1 in zip(poc, kraj):
            ia, ib = int(a[p0]), int(b[p0])
            med = float(np.median(d[p0:p1]))
            # razlika do prag_spoja_m izvodi se kao blagi spoj (rampa širine jedne ćelije), ne kao zid; strožiji
            # prag vrijedi samo za rub vode (bazen, jezero), koji ostaje stuba
            uz_vodu = ia >= 0 and any(i >= 0 and self.pl[i]["kat"] == "voda" for i in (ia, ib))
            prag = self.o["prag_spoja_ravnih_m"] if uz_vodu else self.o["prag_spoja_m"]
            spojeno = med <= prag
            if (ia, ib) in self.prekinuti or (ib, ia) in self.prekinuti:
                spojeno = False
            self.spoj[(ia, ib)] = spojeno
            if spojeno:
                self.susjedi.setdefault(ia, set()).add(ib)
                self.susjedi.setdefault(ib, set()).add(ia)

    # --- polje kote po prostoru ------------------------------------------------
    def _polja(self):
        from scipy import ndimage

        L, H, T, g = self.L, self.H, self.T, self.g
        for s in self.pl:
            k = s["k"]
            sus = self.susjedi.get(k, set())
            ii, jj = np.nonzero(L == k)
            if not len(ii):
                s["polje"] = None
                s["z_stalno"] = float(s["pod"])
                continue
            vrijednosti = H[ii, jj]
            stalno = float(np.ptp(vrijednosti)) < 0.02 and all(
                (q >= 0 and not self.pl[q]["kosina"] and abs(self.pl[q]["pod"] - vrijednosti[0]) < 0.02
                 and float(np.ptp(H[L == q])) < 0.02) for q in sus)
            if stalno and -1 not in sus:
                s["polje"] = None
                s["z_stalno"] = float(vrijednosti[0])
                continue
            i0, i1 = max(ii.min() - 3, 0), min(ii.max() + 4, self.ny)
            j0, j1 = max(jj.min() - 3, 0), min(jj.max() + 4, self.nx)
            Lw, Hw, Tw = L[i0:i1, j0:j1], H[i0:i1, j0:j1], T[i0:i1, j0:j1]
            valj = np.isin(Lw, [k] + [q for q in sus if q >= 0])
            G = np.where(valj, Hw, np.nan)
            if not valj.all():
                idx = ndimage.distance_transform_edt(~valj, return_distances=False, return_indices=True)
                G = G[idx[0], idx[1]]
            if -1 in sus:
                # ćelije izvan plohe: gdje rub leži na tlu, tlo − 0,3; gdje rub završava zidom, nastavak plohe.
                # Prijelaz je postupan da kota ruba ne skače od ćelije do ćelije (pila na kosom rubu).
                van = Lw == -1
                w = np.clip((G - (Tw - 0.3)) / 1.5, 0.0, 1.0)
                G = np.where(van, (Tw - 0.3) + w * (G - (Tw - 0.3)), G)
            s["polje"] = (i0, j0, G.astype(np.float64))
            s["z_stalno"] = None
        # zbirno polje vrha (za podgled pokrova i mjerenja)
        valj = L >= 0
        if valj.any():
            idx = ndimage.distance_transform_edt(~valj, return_distances=False, return_indices=True)
            self.Hvrh = np.where(valj, H, H[idx[0], idx[1]])
        else:
            self.Hvrh = np.full(L.shape, np.nan)

    def _bilinearno(self, G, i0, j0, x, y):
        from scipy import ndimage

        x, y = np.asarray(x, dtype=np.float64), np.asarray(y, dtype=np.float64)
        oblik = x.shape
        fi = (y.reshape(-1) - self.y0) / self.g - 0.5 - i0
        fj = (x.reshape(-1) - self.x0) / self.g - 0.5 - j0
        return ndimage.map_coordinates(G, [fi, fj], order=1, mode="nearest").reshape(oblik)

    def z_prostora(self, s, x, y):
        """Kota plohe prostora `s` u točkama (ENU-N)."""
        x = np.asarray(x, dtype=np.float64)
        if s["polje"] is None:
            return np.full(x.shape, s["z_stalno"])
        i0, j0, G = s["polje"]
        return self._bilinearno(G, i0, j0, x, y)

    def z_vrha(self, x, y):
        return self._bilinearno(self.Hvrh, 0, 0, x, y)

    def kota(self, x, y):
        """Kota vidljive plohe koncepta u točkama (ENU-N): ploha parka gdje postoji, inače današnje tlo."""
        x, y = np.atleast_1d(np.asarray(x, float)), np.atleast_1d(np.asarray(y, float))
        z = np.asarray(self.tlo(x, y), dtype=np.float64).copy()
        i, j = self.celija(x, y)
        l = self.L[i, j]
        for k in np.unique(l[l >= 0]):
            m = l == k
            z[m] = np.maximum(self.z_prostora(self.pl[int(k)], x[m], y[m]), z[m])
        return z

    # --- prostor pod pokrovom (cesta, tramvaj, hala) -----------------------------
    def _praznine(self):
        from shapely.ops import unary_union

        P = self.P
        self.V = None
        if self.F is None:
            return
        dijelovi = []
        for s in P.prostori:
            if s["razina"] >= P.i_park or s["kat"] not in PROMETNE:
                continue
            g = s["geom"].intersection(self.F)
            if g.is_empty or g.area < 20:
                continue
            c = g.representative_point()
            vrh = float(self.z_vrha(c.x, c.y))
            if vrh - float(self.tlo(c.x, c.y)) < 3.5:
                continue
            dijelovi.append(g)
        if dijelovi:
            V = unary_union(dijelovi).buffer(0.3).buffer(-0.3)
            self.V = V if not V.is_empty else None

    # --- zidovi ---------------------------------------------------------------------
    def zidovi(self, korak=2.5):
        """Okomiti rubovi plohe: dijelovi (ENU-N) s kotama vrha i dna, vrstom i orijentacijom.

        Vraća rječnik polja: p0, p1 (N x 2), zt0, zt1, zb0, zb1, az (azimut vanjske normale), vanjski (bool),
        praznina (bool: iza zida je prostor pod pokrovom), prostor (indeks), drugi (indeks ili -1/-2/-3).
        """
        import shapely
        from shapely.geometry.polygon import orient

        P0, P1, NN, KK = [], [], [], []
        for s in self.pl:
            for pol in _poligoni(s["geom"], 0.0):
                pol = orient(pol, 1.0)
                for prsten in [pol.exterior] + list(pol.interiors):
                    c = np.asarray(prsten.coords)
                    for a, b in zip(c[:-1], c[1:]):
                        d = b - a
                        l = float(np.hypot(*d))
                        if l < 0.02:
                            continue
                        n = np.array([d[1], -d[0]]) / l
                        k = max(int(math.ceil(l / korak)), 1)
                        t = np.linspace(0, 1, k + 1)
                        pts = a[None, :] + d[None, :] * t[:, None]
                        P0.append(pts[:-1]); P1.append(pts[1:])
                        NN.append(np.repeat(n[None, :], k, axis=0)); KK.append(np.full(k, s["k"]))
        if not P0:
            return None
        p0, p1, nn, kk = np.concatenate(P0), np.concatenate(P1), np.concatenate(NN), np.concatenate(KK)
        mid = (p0 + p1) / 2
        q = mid + 0.45 * nn
        # s druge strane: točan upit po poligonima (raster je pregrub uz rub)
        from shapely.strtree import STRtree

        tree = STRtree([s["geom"] for s in self.pl])
        qi, gi = tree.query(shapely.points(q), predicate="within")
        drugi = np.full(len(q), -1, dtype=np.int64)
        drugi[qi] = gi
        isti = drugi == kk
        if self.stadion_geom is not None:
            shapely.prepare(self.stadion_geom)
            drugi[(drugi == -1) & shapely.contains_xy(self.stadion_geom, q[:, 0], q[:, 1])] = -3
        for sv in self.svj:
            shapely.prepare(sv["geom"])
            drugi[(drugi == -1) & shapely.contains_xy(sv["geom"], q[:, 0], q[:, 1])] = -2
        zt0, zt1 = np.zeros(len(q)), np.zeros(len(q))
        zb0, zb1 = np.zeros(len(q)), np.zeros(len(q))
        for s in self.pl:
            m = kk == s["k"]
            if m.any():
                zt0[m] = self.z_prostora(s, p0[m, 0], p0[m, 1])
                zt1[m] = self.z_prostora(s, p1[m, 0], p1[m, 1])
            m = drugi == s["k"]
            if m.any():
                zb0[m] = self.z_prostora(s, p0[m, 0], p0[m, 1])
                zb1[m] = self.z_prostora(s, p1[m, 0], p1[m, 1])
        van = drugi == -1
        zb0[van] = self.tlo(p0[van, 0], p0[van, 1]) - 0.6
        zb1[van] = self.tlo(p1[van, 0], p1[van, 1]) - 0.6
        st = drugi == -3
        zb0[st] = zb1[st] = self.kota_podija if self.kota_podija is not None else 0.0
        sv = drugi == -2
        zb0[sv], zb1[sv] = zt0[sv], zt1[sv]
        treba = (~isti) & (np.maximum(zt0 - zb0, zt1 - zb1) > 0.03)
        az = (np.degrees(np.arctan2(nn[:, 0], nn[:, 1])) % 360.0)
        praz = np.zeros(len(q), bool)
        if self.V is not None:
            shapely.prepare(self.V)
            u = mid - 2.5 * nn
            praz = shapely.contains_xy(self.V, u[:, 0], u[:, 1])
        m = treba
        return {"p0": p0[m], "p1": p1[m], "n": nn[m], "zt0": zt0[m], "zt1": zt1[m], "zb0": zb0[m], "zb1": zb1[m],
                "az": az[m], "vanjski": van[m], "praznina": praz[m] & van[m], "prostor": kk[m], "drugi": drugi[m]}

    # --- mreža plohe -------------------------------------------------------------------
    def mreza_podrucja(self, geom, z_fn):
        """Mreža ćelija odrezana točno po poligonu. Vraća (xy N x 2 u ENU-N, z, petlje, duljine)."""
        import shapely
        from shapely.geometry.polygon import orient

        g = self.g
        lica, duljine = [], []
        x0, y0, x1, y1 = geom.bounds
        j0, j1 = int(math.floor((x0 - self.x0) / g)), int(math.ceil((x1 - self.x0) / g))
        i0, i1 = int(math.floor((y0 - self.y0) / g)), int(math.ceil((y1 - self.y0) / g))
        if j1 <= j0 or i1 <= i0:
            return None
        J, I = np.meshgrid(np.arange(j0, j1), np.arange(i0, i1))
        xa, ya = self.x0 + J.ravel() * g, self.y0 + I.ravel() * g
        kutije = shapely.box(xa, ya, xa + g, ya + g)
        shapely.prepare(geom)
        unutra = shapely.contains(geom, kutije)
        sijece = shapely.intersects(geom, kutije) & ~unutra
        xy = []
        if unutra.any():
            a, b = xa[unutra], ya[unutra]
            kv = np.stack([np.stack([a, b], 1), np.stack([a + g, b], 1), np.stack([a + g, b + g], 1),
                           np.stack([a, b + g], 1)], axis=1)  # n x 4 x 2
            xy.append(kv.reshape(-1, 2))
            duljine.append(np.full(len(a), 4, dtype=np.int32))
        if sijece.any():
            dij = shapely.intersection(geom, kutije[sijece])
            for d in dij:
                for pol in _poligoni(d, 0.002):
                    c = np.asarray(orient(pol, 1.0).exterior.coords)[:-1]
                    if len(c) >= 3:
                        xy.append(c)
                        duljine.append(np.array([len(c)], dtype=np.int32))
        if not xy:
            return None
        xy = np.concatenate(xy)
        duljine = np.concatenate(duljine)
        kljuc = np.round(xy * 1000.0).astype(np.int64)
        _, prvi, obrnuto = np.unique(kljuc, axis=0, return_index=True, return_inverse=True)
        vrhovi = xy[prvi]
        z = np.asarray(z_fn(vrhovi[:, 0], vrhovi[:, 1]), dtype=np.float64)
        return vrhovi, z, obrnuto.reshape(-1).astype(np.int32), duljine

    # --- pregled za provjeru bez Blendera ---------------------------------------------------
    def slika_visina(self, put):
        """Sprema sliku kota plohe (boja = kota iznad tla) za brzu provjeru bez rendera."""
        from PIL import Image

        d = np.where(self.L >= 0, self.H - self.T, np.nan)
        v = np.clip(np.nan_to_num(d, nan=0.0) / 18.0, 0, 1)
        rgb = np.stack([60 + 195 * v, 200 - 120 * np.abs(v - 0.5) * 2, 240 - 200 * v], -1)
        rgb[self.L == -1] = (245, 245, 245)
        rgb[self.L == -2] = (120, 220, 250)
        rgb[self.L == -3] = (40, 60, 160)
        im = Image.fromarray(rgb[::-1].astype(np.uint8)).resize((self.nx * 3, self.ny * 3), Image.NEAREST)
        im.save(put)
        return put


# ---------------------------------------------------------------------------
# Tekstura ploha (Pillow)
# ---------------------------------------------------------------------------

class Tekstura:
    """Slika boja ploha u ENU-N (sjever gore). Boje su ilustracija, ne specifikacija materijala."""

    def __init__(self, okvir, r, podloga):
        from PIL import Image

        self.x0, self.y0, x1, y1 = okvir
        self.r = float(r)
        self.w = int(math.ceil((x1 - self.x0) / r))
        self.h = int(math.ceil((y1 - self.y0) / r))
        self.im = Image.new("RGB", (self.w, self.h), podloga)
        self.zeleno = Image.new("L", (self.w, self.h), 255)  # gdje se dodaje prirodna neujednačenost boje

    def px(self, tocke):
        t = np.asarray(tocke, dtype=np.float64).reshape(-1, 2)
        return [((x - self.x0) / self.r, self.h - (y - self.y0) / self.r) for x, y in t]

    def uv(self, x, y):
        return np.stack([(np.asarray(x) - self.x0) / (self.w * self.r),
                         (np.asarray(y) - self.y0) / (self.h * self.r)], axis=-1)

    def ispuni(self, geom, boja, zeleno=False):
        from PIL import Image, ImageDraw

        for pol in _poligoni(geom, 0.0):
            p = self.px(pol.exterior.coords)
            xs, ys = [q[0] for q in p], [q[1] for q in p]
            bx0, by0 = max(int(min(xs)) - 1, 0), max(int(min(ys)) - 1, 0)
            bx1, by1 = min(int(max(xs)) + 2, self.w), min(int(max(ys)) + 2, self.h)
            if bx1 <= bx0 or by1 <= by0:
                continue
            m = Image.new("L", (bx1 - bx0, by1 - by0), 0)
            d = ImageDraw.Draw(m)
            d.polygon([(a - bx0, b - by0) for a, b in p], fill=255)
            for r_ in pol.interiors:
                d.polygon([(a - bx0, b - by0) for a, b in self.px(r_.coords)], fill=0)
            self.im.paste(tuple(boja), (bx0, by0), m)
            self.zeleno.paste(255 if zeleno else 0, (bx0, by0), m)

    def linija(self, tocke, boja, sirina_m=0.15, zatvori=False):
        from PIL import ImageDraw

        p = self.px(tocke)
        if zatvori:
            p = p + [p[0]]
        ImageDraw.Draw(self.im).line(p, fill=tuple(boja), width=max(1, int(round(sirina_m / self.r))))

    def krug(self, c, polumjer, boja, sirina_m=0.15, puni=False):
        k = np.linspace(0, 2 * math.pi, 49)
        t = np.stack([c[0] + polumjer * np.cos(k), c[1] + polumjer * np.sin(k)], 1)
        if puni:
            from shapely.geometry import Polygon

            self.ispuni(Polygon(t), boja)
        else:
            self.linija(t, boja, sirina_m)

    def neujednacenost(self, sjeme, jakost=0.16, zasicenost=0.80, suho=0.30, zrno=0.07, tvrdo=0.05):
        """Proceduralna neujednačenost (krug 3, realističnost): travnjak dobiva mrlje svjetline na više mjerila,
        suhe i svjetlije mrlje, zrno od oko 0,3 m i manju zasićenost; tvrde plohe (staze, trgovi, igrališta)
        blagu promjenu svjetline. Sve iz sjemena, bez vanjskih tekstura."""
        from PIL import Image
        from scipy import ndimage

        rng = np.random.default_rng(sjeme)
        mala = (max(self.w // 4, 8), max(self.h // 4, 8))

        def sum_(sigme):
            s = np.zeros((mala[1], mala[0]), dtype=np.float32)
            for sigma, tezina in sigme:
                a = ndimage.gaussian_filter(rng.standard_normal(s.shape).astype(np.float32), sigma)
                s += tezina * a / (a.std() + 1e-9)
            s = np.clip(s / 2.2, -1, 1)
            return np.asarray(Image.fromarray(((s + 1) * 127.5).astype(np.uint8)).resize((self.w, self.h), Image.BICUBIC),
                              dtype=np.float32) / 127.5 - 1.0

        s = sum_(((1.2, 0.35), (5.0, 0.35), (22.0, 0.30)))
        s_suho = sum_(((3.0, 0.5), (12.0, 0.5)))
        fino = ndimage.gaussian_filter(rng.standard_normal((self.h, self.w)).astype(np.float32), 0.7)
        fino /= fino.std() + 1e-9
        m = (np.asarray(self.zeleno, dtype=np.float32) / 255.0)[..., None]
        a = np.asarray(self.im, dtype=np.float32)
        lum = (a @ np.array([0.30, 0.59, 0.11], dtype=np.float32))[..., None]
        zel = lum + (a - lum) * zasicenost
        # suhe mrlje: prema slamnatoj boji, mekan prag
        su = np.clip((s_suho - 0.25) / 0.45, 0.0, 1.0)[..., None] * suho
        zel = zel * (1.0 - su) + np.array([138.0, 132.0, 92.0], dtype=np.float32) * su * (lum / 95.0)
        f = (1.0 + jakost * s + zrno * fino)[..., None]
        zel = zel * f * np.array([1.0, 1.0, 0.98], dtype=np.float32)
        tv = a * (1.0 + tvrdo * s[..., None] + 0.5 * tvrdo * fino[..., None])
        a = zel * m + tv * (1.0 - m)
        self.im = Image.fromarray(np.clip(a, 0, 255).astype(np.uint8))

    def spremi(self, put):
        self.im.save(put, compress_level=1)
        return put


class _Okvir:
    """Lokalni pravokutni sustav najmanjeg opisanog pravokutnika poligona: u uzduž dulje stranice."""

    def __init__(self, geom):
        r = geom.minimum_rotated_rectangle
        c = np.asarray(r.exterior.coords)[:4]
        a, b = c[1] - c[0], c[3] - c[0]
        if np.hypot(*a) < np.hypot(*b):
            c = c[[1, 2, 3, 0]]
            a, b = c[1] - c[0], c[3] - c[0]
        self.o = c[0]
        self.L, self.W = float(np.hypot(*a)), float(np.hypot(*b))
        self.u, self.v = a / max(self.L, 1e-9), b / max(self.W, 1e-9)

    def t(self, a, b):
        """Lokalne (a uzduž, b poprijeko) u ENU-N."""
        a, b = np.asarray(a, dtype=np.float64), np.asarray(b, dtype=np.float64)
        return np.stack([self.o[0] + a * self.u[0] + b * self.v[0], self.o[1] + a * self.u[1] + b * self.v[1]], -1)

    def pravokutnik(self, a0, b0, a1, b1):
        return self.t([a0, a1, a1, a0], [b0, b0, b1, b1])

    def ovalna(self, a0, b0, a1, b1, n=24):
        """Zaobljeni pravokutnik (dva pravca i dva polukruga) kao popis točaka."""
        R = (b1 - b0) / 2.0
        cy = (b0 + b1) / 2.0
        k1 = np.linspace(-math.pi / 2, math.pi / 2, n)
        k2 = np.linspace(math.pi / 2, 3 * math.pi / 2, n)
        a = np.r_[(a1 - R) + R * np.cos(k1), (a0 + R) + R * np.cos(k2)]
        b = np.r_[cy + R * np.sin(k1), cy + R * np.sin(k2)]
        return self.t(a, b)


def _vrsta_sporta(s):
    # krug 3: najprije popis sportova iz programa (opis prostora može spominjati susjedne terene)
    sp_ = s.get("sportovi") or []
    t = norm(" ".join(str(x) for x in sp_)) if sp_ else s["tekst_sve"]
    for kljuc, uzorak in (("atletika", r"atlet|staza_400|trkalis"), ("pijesak", r"pijes|beach"), ("kosarka", r"kosark|3x3|basket"),
                          ("hokej", r"hokej"), ("skate", r"skate|bmx|pump"), ("tenis", r"tenis|padel"),
                          ("vjezbaliste", r"vjezbal|fitnes|street_workout|kalisten"), ("nogomet", r"nogomet|ragbi|rukomet|futsal"),
                          ("bocanje", r"boc")):
        if re.search(uzorak, t):
            return kljuc
    return "opce"


def _crtaj_sport(T: Tekstura, s):
    from shapely.geometry import Polygon

    g = s["geom"]
    v = _vrsta_sporta(s)
    o = _Okvir(g)
    bijelo = RGB["bijelo"]
    if v == "atletika" and o.L > 60 and o.W > 30:
        T.ispuni(g, RGB["tartan"])
        sirina = min(9.76, o.W * 0.12)
        rub = 1.0
        T.ispuni(Polygon(o.ovalna(rub, rub, o.L - rub, o.W - rub)).intersection(g), RGB["tartan"])
        T.ispuni(Polygon(o.ovalna(rub + sirina, rub + sirina, o.L - rub - sirina, o.W - rub - sirina)).intersection(g),
                 RGB["igraliste"], zeleno=True)
        for k in range(9):
            d = rub + sirina * k / 8.0
            T.linija(o.ovalna(d, d, o.L - d, o.W - d), bijelo, 0.12, zatvori=True)
        # travnato polje u sredini
        R = (o.W - 2 * (rub + sirina)) / 2
        T.linija(o.pravokutnik(rub + sirina + R * 0.75, rub + sirina + 3, o.L - rub - sirina - R * 0.75, o.W - rub - sirina - 3),
                 bijelo, 0.12, zatvori=True)
        T.linija(o.t([o.L / 2, o.L / 2], [rub + sirina + 3, o.W - rub - sirina - 3]), bijelo, 0.12)
        return
    boje = {"pijesak": "pijesak", "kosarka": "kosarka", "hokej": "umjetna_trava", "skate": "skate", "tenis": "tenis",
            "vjezbaliste": "guma", "nogomet": "igraliste", "bocanje": "pijesak", "opce": "sportska_podloga", "atletika": "tartan"}
    if v in ("nogomet", "hokej") and o.L > 60 and o.W > 35:
        _crtaj_nogometno(T, g, umjetna="umjetn" in s["tekst_sve"])   # pruge košnje vrlo blago, linije igrališta
        return
    T.ispuni(g, RGB[boje[v]])
    if v in ("skate",):
        rng = np.random.default_rng(int(abs(g.centroid.x * 7 + g.centroid.y * 13)))
        for _ in range(int(max(4, g.area / 220))):
            a, b = rng.uniform(2, max(o.L - 8, 3)), rng.uniform(2, max(o.W - 6, 3))
            p = Polygon(o.pravokutnik(a, b, a + rng.uniform(3, 8), b + rng.uniform(2, 5))).intersection(g)
            ton = int(rng.integers(-22, 22))
            T.ispuni(p, tuple(int(np.clip(c + ton, 0, 255)) for c in RGB["skate"]))
        return
    if v == "vjezbaliste":
        return
    # tereni: jedno veliko polje ili više manjih u nizu
    velicina = {"pijesak": (16.0, 8.0), "kosarka": (15.0, 11.0), "tenis": (23.77, 10.97), "bocanje": (27.5, 4.0)}.get(v)
    if velicina and o.L > velicina[0] * 1.4 + 4:
        duz, pop = velicina
        if o.W >= duz + 2:  # tereni poprijeko okvira
            n = max(int((o.L - 2) // (pop + 3)), 1)
            korak = o.L / n
            for i in range(n):
                a0 = i * korak + (korak - pop) / 2
                b0 = (o.W - duz) / 2
                T.linija(o.pravokutnik(a0, b0, a0 + pop, b0 + duz), bijelo, 0.1, zatvori=True)
                T.linija(o.t([a0, a0 + pop], [o.W / 2, o.W / 2]), bijelo, 0.1)
        else:
            n = max(int((o.L - 2) // (duz + 3)), 1)
            korak = o.L / n
            pop = min(pop, o.W - 2)
            for i in range(n):
                a0 = i * korak + (korak - duz) / 2
                b0 = (o.W - pop) / 2
                T.linija(o.pravokutnik(a0, b0, a0 + duz, b0 + pop), bijelo, 0.1, zatvori=True)
                T.linija(o.t([a0 + duz / 2, a0 + duz / 2], [b0, b0 + pop]), bijelo, 0.1)
        return
    rub = min(2.0, o.W * 0.08)
    T.linija(o.pravokutnik(rub, rub, o.L - rub, o.W - rub), bijelo, 0.12, zatvori=True)
    T.linija(o.t([o.L / 2, o.L / 2], [rub, o.W - rub]), bijelo, 0.12)
    if min(o.L, o.W) > 30:
        T.krug(o.t(o.L / 2, o.W / 2), min(9.15, o.W / 6), bijelo, 0.12)
        for a0, a1 in ((rub, rub + min(16.5, o.L * 0.16)), (o.L - rub - min(16.5, o.L * 0.16), o.L - rub)):
            pol = min(20.16, o.W * 0.3)
            T.linija(o.pravokutnik(a0, o.W / 2 - pol, a1, o.W / 2 + pol), bijelo, 0.12, zatvori=True)


def _crtaj_nogometno(T: Tekstura, geom, umjetna=False):
    """Travnjak s prugama košnje i linijama igrališta 105 x 68 m (ili manjeg, ako poligon nije toliki)."""
    from shapely.geometry import Polygon

    o = _Okvir(geom)
    t1, t2 = ((74, 112, 76), (77, 117, 79)) if umjetna else ((72, 110, 62), (76, 116, 65))   # pruge vrlo blago (krug 3)
    n = max(int(round(o.L / 5.8)), 2)
    for i in range(n):
        T.ispuni(Polygon(o.pravokutnik(o.L * i / n, 0, o.L * (i + 1) / n, o.W)).intersection(geom), t1 if i % 2 else t2)
    D, S = min(105.0, o.L - 2.0), min(68.0, o.W - 2.0)
    a0, b0 = (o.L - D) / 2, (o.W - S) / 2
    b = RGB["bijelo"]
    T.linija(o.pravokutnik(a0, b0, a0 + D, b0 + S), b, 0.12, zatvori=True)
    T.linija(o.t([o.L / 2, o.L / 2], [b0, b0 + S]), b, 0.12)
    T.krug(o.t(o.L / 2, o.W / 2), 9.15, b, 0.12)
    for strana in (0, 1):
        for dub, pol in ((16.5, 20.16), (5.5, 9.16)):
            x0 = a0 if strana == 0 else a0 + D - dub
            T.linija(o.pravokutnik(x0, o.W / 2 - pol, x0 + dub, o.W / 2 + pol), b, 0.12, zatvori=True)


# ---------------------------------------------------------------------------
# Spremnik mreže
# ---------------------------------------------------------------------------

class Spremnik:
    """Skuplja vrhove, plohe i boje ploha. Koordinate su ENU-N (pretvaraju se pri izradi objekta) ili,
    uz metricki=True, već ENU-M."""

    def __init__(self, metricki=False):
        self.co, self.plohe, self.boje = [], [], []
        self.metricki = metricki

    def __len__(self):
        return len(self.plohe)

    def dodaj(self, vrhovi, plohe, boja):
        b = len(self.co)
        self.co.extend((float(x), float(y), float(z)) for x, y, z in vrhovi)
        for p in plohe:
            self.plohe.append(tuple(b + i for i in p))
            self.boje.append(boja)

    def kvad(self, a, b, c, d, boja):
        self.dodaj((a, b, c, d), ((0, 1, 2, 3),), boja)

    def zid(self, p0, p1, z00, z01, z10, z11, boja):
        """Okomiti četverokut između točaka p0 i p1: dno (z00, z01), vrh (z10, z11)."""
        if max(z10 - z00, z11 - z01) <= 0.005:
            return
        self.kvad((p0[0], p0[1], z00), (p1[0], p1[1], z01), (p1[0], p1[1], max(z11, z01)), (p0[0], p0[1], max(z10, z00)), boja)

    def kutija(self, sred, u, v, pol_u, pol_v, z0, z1, boja, boja_vrha=None, dno=False):
        """Uspravna kutija: središte (x, y), jedinični vektori u i v, polovine stranica, kote dna i vrha."""
        c = np.asarray(sred, dtype=np.float64)
        u, v = np.asarray(u) * pol_u, np.asarray(v) * pol_v
        k = [c - u - v, c + u - v, c + u + v, c - u + v]
        vr = [(q[0], q[1], z0) for q in k] + [(q[0], q[1], z1) for q in k]
        self.dodaj(vr, ((0, 1, 5, 4), (1, 2, 6, 5), (2, 3, 7, 6), (3, 0, 4, 7)), boja)
        self.dodaj(vr[4:], ((0, 1, 2, 3),), boja_vrha or boja)
        if dno:
            self.dodaj(vr[:4], ((3, 2, 1, 0),), boja)

    def prizma(self, pol, z_dno, z_vrh, boja_zida, boja_krova, trokuti):
        """Uspravna prizma nad shapely poligonom; z_dno je broj ili funkcija (x, y) -> kota."""
        prstenovi = [np.asarray(pol.exterior.coords)[:-1]] + [np.asarray(r.coords)[:-1] for r in pol.interiors]
        svi = np.concatenate(prstenovi)
        zd = np.full(len(svi), z_dno) if not callable(z_dno) else np.asarray(z_dno(svi[:, 0], svi[:, 1]))
        b = len(self.co)
        self.co.extend((float(x), float(y), float(z_vrh)) for x, y in svi)
        self.co.extend((float(x), float(y), float(z)) for (x, y), z in zip(svi, zd))
        n = len(svi)
        for t in trokuti(prstenovi):
            self.plohe.append(tuple(b + i for i in t))
            self.boje.append(boja_krova)
        poc = 0
        for pr in prstenovi:
            m = len(pr)
            for i in range(m):
                a, c = poc + i, poc + (i + 1) % m
                self.plohe.append((b + n + a, b + n + c, b + c, b + a))
                self.boje.append(boja_zida)
            poc += m

    def trake(self, prstenovi, boje):
        """Trake četverokuta između uzastopnih zatvorenih prstenova (K x 3). boje[i]: boja ili K boja."""
        K_ = len(prstenovi[0])
        b = len(self.co)
        for pr in prstenovi:
            self.co.extend((float(x), float(y), float(z)) for x, y, z in pr)
        for i in range(len(prstenovi) - 1):
            bo = boje[i]
            po_stupcu = isinstance(bo, (list, np.ndarray)) and len(bo) == K_ and not _broj(bo[0])
            for k in range(K_):
                k2 = (k + 1) % K_
                self.plohe.append((b + i * K_ + k, b + (i + 1) * K_ + k, b + (i + 1) * K_ + k2, b + i * K_ + k2))
                self.boje.append(tuple(bo[k]) if po_stupcu else bo)


def _polumjeri(pol, c, kut):
    """Udaljenost od središta c do vanjskog ruba poligona u smjerovima kut (matematički kut, rad)."""
    P = np.asarray(pol.exterior.coords)
    A, B = P[:-1] - np.asarray(c), P[1:] - np.asarray(c)
    E = B - A
    d = np.stack([np.cos(kut), np.sin(kut)], 1)
    cr = d[:, 0, None] * E[None, :, 1] - d[:, 1, None] * E[None, :, 0]
    cr = np.where(np.abs(cr) < 1e-12, np.nan, cr)
    t = (A[None, :, 0] * E[None, :, 1] - A[None, :, 1] * E[None, :, 0]) / cr
    s = (A[None, :, 0] * d[:, 1, None] - A[None, :, 1] * d[:, 0, None]) / cr
    ok = (s >= -1e-9) & (s <= 1 + 1e-9) & (t > 0)
    t = np.where(ok, t, -np.inf)
    r = t.max(axis=1)
    lose = ~np.isfinite(r)
    if lose.any() and (~lose).any():
        r[lose] = np.interp(np.nonzero(lose)[0], np.nonzero(~lose)[0], r[~lose], period=len(r))
    elif lose.all():
        r[:] = math.sqrt(pol.area / math.pi)
    return r


def _sjever_zrake(st, c, kut):
    """Jedinstveni sjever (program stadion.sjever) po zrakama iz središta stadiona.

    Na kutovima na kojima zraka ulazi u obris sjevera kroz prednji rub donje tribine (±1,5 m) redovi svih
    prstenova slijede profil sjevera: polumjer r0 + d·k (k = rastezanje donje tribine po metru profila),
    kota iz profila (d, z). Vraća masku kutova, r0, k, dmax po kutu i profil; None kad sjevera nema.
    PRETPOSTAVKA-IZRAČUN: ploha je stepenasta po redovima modela, ne po redovima programa."""
    sj = st.get("sjever")
    if not sj or not st["tribine"] or sj.get("obris") is None:
        return None
    from shapely.geometry import LineString

    pol = sj["obris"]
    d0 = st["tribine"][0]
    r0 = _polumjeri(d0["unut"], c, kut)
    r1 = _polumjeri(d0["vanj"], c, kut)
    sir = float(d0.get("d1", 21.0) - d0.get("d0", 0.0)) or 21.0
    kk = np.maximum(r1 - r0, 0.5) / sir
    maska = np.zeros(len(kut), bool)
    dmax = np.zeros(len(kut))
    pd, pz = sj["profil_d"], sj["profil_z"]
    for i, a in enumerate(kut):
        smj = np.array([math.cos(a), math.sin(a)])
        g = pol.intersection(LineString([tuple(c), tuple(np.asarray(c) + smj * 600.0)]))
        if g.is_empty:
            continue
        t = [float(np.hypot(*(np.asarray(q) - c))) for s in getattr(g, "geoms", [g]) if s.geom_type == "LineString"
             for q in s.coords]
        if not t:
            continue
        if abs(min(t) - r0[i]) < 1.5:
            maska[i] = True
            dmax[i] = float(np.clip((max(t) - r0[i]) / kk[i], 0.0, pd[-1]))
    if not maska.any():
        return None
    return {"maska": maska, "r0": r0, "k": kk, "dmax": dmax, "pd": pd, "pz": pz}


# ---------------------------------------------------------------------------
# Scena koncepta (Blender)
# ---------------------------------------------------------------------------

SLOJEVI_SCENE = ("teren_blizu", "teren_regija", "teren_daleko", "vode", "zgrade", "drvece")
C = {k: lin(v) for k, v in RGB.items()}


def _kutovi_nositelja(c, s_):
    """Kutovi nositeljskog kvadrata za instanciranje preko ploha: R(kut)·(p,p), (−p,p), (−p,−p), (p,−p),
    gdje su c = p·cos(kut), s_ = p·sin(kut). Redoslijed je obrnut od kazaljke, pa normala gleda gore, a
    površina je (2p)², što s use_instance_faces_scale daje mjerilo 2p."""
    kx = np.stack([c - s_, -c - s_, -c + s_, c + s_], axis=1)
    ky = np.stack([s_ + c, -s_ + c, -s_ - c, s_ - c], axis=1)
    return kx, ky


def obuhvat_programa(P: Program):
    """Obuhvat novog sadržaja (ENU-N) i područja u kojima postojeće ostaje.

    Novo: prostori razine parka i viših razina, obris stadiona i prostori nižih razina, osim kategorija
    postojece, dvoriste, park_zelenilo i voda na nižim razinama (prirodno tlo: postojeća stabla ostaju).
    Zadržano: prostori kategorije postojece (npr. bazen Svetice)."""
    from shapely.ops import unary_union

    novo = []
    for s in P.prostori:
        if s["kat"] == "postojece":
            continue
        if s["razina"] < P.i_park and s["kat"] in ("dvoriste", "park_zelenilo", "voda"):
            continue
        novo.append(s["geom"])
    if P.stadion:
        novo.append(P.stadion["vanjski"])
    zadrz = [s["geom"] for s in P.prostori if s["kat"] == "postojece"]
    novo = unary_union(novo).buffer(0.5).buffer(-0.5) if novo else None
    return novo, (unary_union(zadrz) if zadrz else None)


def _vremena_gradnje(s):
    v = getattr(s, "vrijeme_gradnje_s", None)
    return v if isinstance(v, dict) else s.statistika.setdefault("vrijeme_gradnje_s", {})


class ScenaKoncepta(SC.Scena):
    """Scena postojećeg stanja s dodanim modelom koncepta. Sloj postojećeg stadiona je uvijek isključen;
    zgrade i stabla koje novi sadržaj prekriva izostavljaju se pri gradnji (scena.py se ne mijenja)."""

    def __init__(self, program, slojevi=SLOJEVI_SCENE, sjeme=20261113, predmemorija=None, opcije=None, **postavke):
        import inspect

        self.program = program if isinstance(program, Program) else Program(program)
        self.ok = {**ZADANO_KONCEPT, **(opcije or {})}
        nepoznato = set(opcije or {}) - set(ZADANO_KONCEPT)
        if nepoznato:
            raise ValueError(f"nepoznate opcije koncepta: {sorted(nepoznato)}")
        slojevi = tuple(s for s in slojevi if s != "stadion")
        self.novo, self.zadrzano = obuhvat_programa(self.program)
        # scena.py od 14.11.2026. sama izostavlja postojeće zgrade i stabla u izrezu; starija inačica to ne zna,
        # pa se tada isto radi ovdje (filtriranjem podloge i položaja stabala)
        par = inspect.signature(SC.Scena.__init__).parameters
        self._izrez_u_sceni = "izrez" in par and self.novo is not None
        kw = {}
        if self._izrez_u_sceni:
            kw["izrez"] = [{"poligon": [list(q) for q in pol.exterior.coords],
                            "rupe": [[list(q) for q in r.coords] for r in pol.interiors]} for pol in _poligoni(self.novo, 1.0)]
            kw["izrez_iznimke"] = [[list(q) for q in pol.exterior.coords] for pol in _poligoni(self.zadrzano, 1.0)]
            if "izrez_tlo" in par and self.ok["boja_tla_u_obuhvatu"]:
                kw["izrez_tlo"] = lin(RGB["trava"])
        super().__init__(slojevi=slojevi, sjeme=sjeme, predmemorija=predmemorija, **kw, **postavke)
        self.rng = np.random.default_rng(int(self.ok["sjeme"]))
        self._oblici = None
        self._mati = {}
        t0 = time.time()
        self.povrsina = Povrsina(self.program, self.tlo_n, self.ok, self.site)
        self.kstat = {"program": {"datoteka": self.program.put.name, "naziv": self.program.meta.get("naziv"),
                                  "verzija": self.program.meta.get("verzija"), "datum": self.program.meta.get("datum")},
                      "razina_parka": self.program.razine[self.program.i_park]["id"],
                      "vrijeme_s": {"ploha_izracun": round(time.time() - t0, 2)}, "broj": {}, "pretpostavke": [],
                      "upozorenja": list(self.povrsina.nalazi["upozorenja"])}
        self.statistika["koncept"] = self.kstat
        if not self._izrez_u_sceni:
            self._priprema_postojeceg()

    # --- tlo i postojeće --------------------------------------------------------
    def tlo_n(self, x, y):
        """Kota današnjeg tla u sceni (ENU-N), s istim spuštanjem zbog zakrivljenosti kao mreža terena."""
        x, y = np.asarray(x, dtype=np.float64), np.asarray(y, dtype=np.float64)
        z = self.teren.kota_n(x, y)
        if self.p["zakrivljenost"]:
            xm, ym = SC.m_iz_n(x, y)
            z = z - SC.pad_zakrivljenosti(xm, ym)
        return z

    def _priprema_postojeceg(self):
        """Zamjena za izrez starije inačice scena.py: izostavlja zgrade i priprema područje bez stabala."""
        import shapely

        uklonjeno, ostaju = [], []
        self._bez_stabala = None
        if self.novo is None:
            return
        shapely.prepare(self.novo)
        for z in self.site["zgrade"]:
            g = _poligon(z.get("poligon"), z.get("rupe"))
            if g is None or not self.novo.intersects(g):
                ostaju.append(z)
            elif self.zadrzano is not None and g.intersection(self.zadrzano).area > 0.3 * g.area:
                ostaju.append(z)
            elif g.intersection(self.novo).area > 0.5 * g.area or self.novo.contains(g.representative_point()):
                uklonjeno.append(z.get("id"))
            else:
                ostaju.append(z)
        self.site["zgrade"] = ostaju
        bez = self.novo.buffer(2.0)
        if self.zadrzano is not None:
            bez = bez.difference(self.zadrzano.buffer(1.0))
        self._bez_stabala = bez
        shapely.prepare(self._bez_stabala)
        self.kstat["broj"]["uklonjeno_zgrada"] = len(uklonjeno)

    def polozaji_stabala(self):
        import shapely

        x, y, h, sk, imena, ws = super().polozaji_stabala()
        if getattr(self, "_bez_stabala", None) is None:
            return x, y, h, sk, imena, ws
        u = ~shapely.contains_xy(self._bez_stabala, x, y)
        self.kstat["broj"]["uklonjeno_stabala"] = int((~u).sum())
        return x[u], y[u], h[u], sk[u], imena, ws[u]

    def _oblici_stabala(self):
        if self._oblici is None:
            self._oblici = super()._oblici_stabala()
        return self._oblici

    # boje rampe krošnje mladih stabala koncepta (linearni RGB) po godišnjem dobu; PRETPOSTAVKA, samo izgled
    BOJE_MLADIH = {
        "ljeto": [(0.070, 0.140, 0.032), (0.100, 0.190, 0.042), (0.125, 0.215, 0.060), (0.165, 0.260, 0.062)],
        "jesen": [(0.200, 0.140, 0.035), (0.300, 0.200, 0.045), (0.150, 0.165, 0.050), (0.360, 0.250, 0.055)],
        "pupovi": [(0.170, 0.240, 0.070), (0.210, 0.285, 0.085), (0.190, 0.265, 0.095), (0.250, 0.320, 0.100)],
    }

    def _oblici_mladih(self):
        """Mlada stabla koncepta (jedinična visina, deblo u ishodištu): vidljivo deblo i 4 do 6 glavnih grana s
        grančicama; ljetna krošnja od 10 do 16 malih nepravilnih grudica uz vrhove grana, s procjepima (rahlo);
        gola inačica ima samo deblo i grane te sitne grudice pupova (vidljive samo uz zima_stabala=pupovi).
        Zamjenjuje nakupinu kugli zajedničku sa scenom (krug 4: "brokule" ljeti, smeđe kugle u ožujku)."""
        if getattr(self, "_oblici_ml", None) is not None:
            return self._oblici_ml
        import bmesh
        from mathutils import Matrix, Vector, noise

        bpy = self.bpy
        rng = np.random.default_rng(int(self.ok["sjeme"]) + 57)
        mat = self._materijal_mladih()
        kora = self.materijal("kora_mladih", (0.145, 0.125, 0.105), hrapavost=0.95)
        # (naziv, širina krošnje / visina, početak krošnje, broj glavnih grana)
        opisi = [("mlado_jasen", 0.56, 0.40, 5), ("mlado_lipa", 0.50, 0.36, 6), ("mlado_javor", 0.62, 0.42, 5),
                 ("mlado_grab", 0.42, 0.33, 4)]

        def stozac(bm, a, b, r0, r1, seg=5):
            a, b = Vector(a), Vector(b)
            d = b - a
            L = d.length
            if L < 1e-6:
                return []
            q = Vector((0, 0, 1)).rotation_difference(d.normalized())
            M_ = Matrix.Translation((a + b) / 2) @ q.to_matrix().to_4x4()
            v = bmesh.ops.create_cone(bm, cap_ends=False, segments=seg, radius1=r0, radius2=r1, depth=L, matrix=M_)["verts"]
            return v

        def grudica(bm, c, r, pomak, jakost=0.38):
            v = bmesh.ops.create_icosphere(bm, subdivisions=2, radius=1.0)["verts"]
            for x in v:
                n = 1.0 + jakost * noise.noise(x.co * 2.3 + pomak) + 0.14 * noise.noise(x.co * 5.7 - pomak)
                x.co = Vector((x.co.x * r[0] * n, x.co.y * r[1] * n, x.co.z * r[2] * n)) + Vector(c)
            return v

        oblici = []
        for naziv, sir, poc, ngr in opisi:
            mreze = {}
            # isti kostur (deblo i grane) za ljetnu i golu inačicu
            r_ = np.random.default_rng(rng.integers(1 << 30))
            vrh_debla = 0.80
            grane = []
            for i in range(ngr):
                az = 2 * math.pi * i / ngr + r_.uniform(-0.45, 0.45)
                z0 = poc + (vrh_debla - poc) * (i + r_.uniform(0.1, 0.9)) / ngr * 0.85
                el = math.radians(r_.uniform(38, 62))
                L = r_.uniform(0.75, 1.0) * sir * 0.5 / max(math.cos(el), 0.3)
                L = min(L, (0.97 - z0) / max(math.sin(el), 0.2))
                kraj = (math.cos(az) * math.cos(el) * L, math.sin(az) * math.cos(el) * L, z0 + math.sin(el) * L)
                grane.append(((0.0, 0.0, z0), kraj, az))
            for inacica in ("lisce", "golo"):
                bm = bmesh.new()
                tonovi = {}

                def oznaci(v, ind, ton=1.0):
                    for f in {f for x in v for f in x.link_faces}:
                        f.material_index = ind
                        f.smooth = ind == 0
                    bm.verts.index_update()
                    for x in v:
                        tonovi[x.index] = ton

                oznaci(stozac(bm, (0, 0, -0.02), (0, 0, vrh_debla), 0.017, 0.007, seg=6), 1)
                gr = np.random.default_rng(len(naziv) * 7 + ngr)
                for (a0, k_, az) in grane:
                    oznaci(stozac(bm, a0, k_, 0.0075, 0.0025), 1)
                    # dvije grančice sa srednjeg dijela grane
                    for t in (0.45, 0.7):
                        p_ = Vector(a0).lerp(Vector(k_), t)
                        az2 = az + gr.choice([-1, 1]) * gr.uniform(0.5, 1.0)
                        l2 = 0.35 * (Vector(k_) - Vector(a0)).length
                        k2 = p_ + Vector((math.cos(az2) * l2 * 0.7, math.sin(az2) * l2 * 0.7, l2 * 0.7))
                        oznaci(stozac(bm, p_, k2, 0.0035, 0.0012, seg=4), 1)
                    if inacica == "lisce":
                        # 2 do 3 grudice uz vrh grane, razmaknute; veličine različite (rahla, nepravilna krošnja)
                        for j in range(int(gr.integers(3, 5))):
                            t = gr.uniform(0.5, 1.05)
                            c = Vector(a0).lerp(Vector(k_), t) + Vector(gr.uniform(-0.05, 0.05, 3))
                            q = gr.uniform(0.085, 0.135) * sir / 0.5
                            ton = gr.uniform(0.82, 1.12)
                            oznaci(grudica(bm, c, (q, q * gr.uniform(0.8, 1.15), q * 0.85), Vector((j * 3.1, len(naziv), az))), 0, ton)
                    else:
                        for j in range(3):
                            t = gr.uniform(0.7, 1.0)
                            c = Vector(a0).lerp(Vector(k_), t)
                            q = 0.03 * sir / 0.5
                            oznaci(grudica(bm, c, (q, q, q), Vector((j, 1.0, az)), jakost=0.5), 0, 1.0)
                if inacica == "lisce":
                    # vršna grudica nad deblom
                    q = 0.10 * sir / 0.5
                    oznaci(grudica(bm, (0, 0, vrh_debla + 0.02), (q * 0.9, q * 0.9, q * 1.2), Vector((9.0, 2.0, 1.0))), 0, 1.05)
                zmax = max(v.co.z for v in bm.verts)
                for v in bm.verts:
                    v.co.z /= zmax
                me = bpy.data.meshes.new(f"stablo_{naziv}_{inacica}")
                bm.to_mesh(me)
                bm.free()
                a = me.color_attributes.new(name="boja", type="FLOAT_COLOR", domain="POINT")
                co = np.empty(len(me.vertices) * 3, np.float32)
                me.vertices.foreach_get("co", co)
                co = co.reshape(-1, 3)
                tt = np.clip((co[:, 2] - poc) / max(1 - poc, 1e-6), 0, 1)
                sj = (0.74 + 0.26 * tt) * np.array([tonovi.get(i, 1.0) for i in range(len(co))], dtype=np.float32)
                a.data.foreach_set("color", np.stack([sj, sj, sj, np.ones_like(sj)], axis=1).astype(np.float32).ravel())
                me.materials.append(mat)
                me.materials.append(kora)
                mreze[inacica] = me
            oblici.append({"naziv": naziv, "mreza": mreze["lisce"], "golo": mreze["golo"], "sirina": sir})
        self._oblici_ml = oblici
        return oblici

    def _materijal_mladih(self):
        """Krošnja mladih stabala koncepta: vlastita rampa boja po godišnjem dobu (BOJE_MLADIH), propusnost
        svjetla i udio prozirnosti (pupovi). Ne dijeli se sa scenom."""
        if getattr(self, "_cv_mladih", None) is not None:
            return self._cv_mladih["mat"]
        bpy = self.bpy
        m = bpy.data.materials.new("krosnja_mladih")
        m.use_nodes = True
        nt = m.node_tree
        b = nt.nodes["Principled BSDF"]
        b.inputs["Roughness"].default_value = 0.8
        if "Specular IOR Level" in b.inputs:
            b.inputs["Specular IOR Level"].default_value = 0.15
        oi = nt.nodes.new("ShaderNodeObjectInfo")
        rampa = nt.nodes.new("ShaderNodeValToRGB")
        el = rampa.color_ramp.elements
        el[0].position, el[1].position = 0.0, 1.0
        el.new(0.5)
        el.new(0.8)
        for e, bj in zip(sorted(el, key=lambda e: e.position), self.BOJE_MLADIH["ljeto"]):
            e.color = (*bj, 1.0)
        nt.links.new(oi.outputs["Random"], rampa.inputs["Fac"])
        vc = nt.nodes.new("ShaderNodeVertexColor")
        vc.layer_name = "boja"
        mno = nt.nodes.new("ShaderNodeMix")
        mno.data_type = "RGBA"
        mno.blend_type = "MULTIPLY"
        mno.inputs["Factor"].default_value = 1.0
        nt.links.new(rampa.outputs["Color"], mno.inputs["A"])
        nt.links.new(vc.outputs["Color"], mno.inputs["B"])
        nt.links.new(mno.outputs["Result"], b.inputs["Base Color"])
        tr = nt.nodes.new("ShaderNodeBsdfTranslucent")
        nt.links.new(mno.outputs["Result"], tr.inputs["Color"])
        mj = nt.nodes.new("ShaderNodeMixShader")
        mj.inputs["Fac"].default_value = 0.35
        nt.links.new(b.outputs["BSDF"], mj.inputs[1])
        nt.links.new(tr.outputs["BSDF"], mj.inputs[2])
        pr = nt.nodes.new("ShaderNodeBsdfTransparent")
        mp = nt.nodes.new("ShaderNodeMixShader")
        mp.inputs["Fac"].default_value = 0.0
        nt.links.new(mj.outputs["Shader"], mp.inputs[1])
        nt.links.new(pr.outputs["BSDF"], mp.inputs[2])
        izl = next(n for n in nt.nodes if n.type == "OUTPUT_MATERIAL")
        nt.links.new(mp.outputs["Shader"], izl.inputs["Surface"])
        self._cv_mladih = {"mat": m, "rampa": rampa, "prozirnost": mp}
        return m

    def _sezona_mladih(self, sezona):
        """Ljeto i jesen: lisnata krošnja; zima (krošnje scene prozirne više od pola, npr. ožujak na snimci):
        gola stabla (deblo i grane) ili, uz zima_stabala=pupovi, rijetko svijetlo ranoproljetno zelenilo."""
        cv = getattr(self, "_cv_mladih", None)
        obj = getattr(self, "_ob_mladih", None)
        if cv is None or not obj:
            return
        proz = float(SC.SEZONE.get(sezona, SC.SEZONE["ljeto"])[1])
        golo = proz >= 0.5
        boje = self.BOJE_MLADIH["jesen" if sezona == "jesen" else ("pupovi" if golo else "ljeto")]
        for e, bj in zip(sorted(cv["rampa"].color_ramp.elements, key=lambda e: e.position), boje):
            e.color = (*bj, 1.0)
        pupovi = self.ok.get("zima_stabala") == "pupovi"
        cv["prozirnost"].inputs["Fac"].default_value = (0.25 if pupovi else 1.0) if golo else 0.0
        for ob, ob_ in obj:
            ob.data = ob_["golo"] if golo else ob_["mreza"]

    def provjeri_instance(self, tolerancija=0.01):
        """Provjera instanci (stabla, ljudi): os z svake instance gleda gore, mjerilo je jednoliko i jednako
        zadanoj veličini (stranica nositeljskog kvadrata) ±tolerancija. Vraća sažetak po skupu."""
        bpy = self.bpy
        dg = bpy.context.evaluated_depsgraph_get()
        skup = {}
        for inst in dg.object_instances:
            if not inst.is_instance or inst.parent is None or not inst.parent.name.startswith("nositelj_"):
                continue
            m = np.array(inst.matrix_world)
            os_ = np.linalg.norm(m[:3, :3], axis=0)
            zos = m[:3, 2] / max(os_[2], 1e-9)
            ime = inst.parent.name
            vrsta = "ljudi" if "covjek" in ime else ("stabla_koncepta" if "koncepta" in ime else "stabla_scene")
            d = skup.setdefault(vrsta, {"instanci": 0, "naopako_ili_nagnuto": 0, "nejednoliko": 0, "mjerila": []})
            d["instanci"] += 1
            d["naopako_ili_nagnuto"] += int(zos[2] < 0.999)
            d["nejednoliko"] += int(np.ptp(os_) > tolerancija * os_.mean())
            d["mjerila"].append(float(os_[2]))
        out = {}
        for vrsta, d in skup.items():
            v = np.array(d["mjerila"])
            out[vrsta] = {"instanci": d["instanci"], "naopako_ili_nagnuto": d["naopako_ili_nagnuto"],
                          "nejednoliko": d["nejednoliko"],
                          "mjerilo_p5_p50_p95_m": [round(float(np.percentile(v, p)), 2) for p in (5, 50, 95)]}
        # usporedba sa zadanim veličinama (sortirano, jer redoslijed instanci nije zajamčen)
        vel = {k: np.concatenate(v) for k, v in getattr(self, "_velicine_l", {}).items()}
        zad = {"stabla_koncepta": vel.get("stabla_koncepta"), "ljudi": vel.get("ljudi"),
               "stabla_scene": np.asarray(self.stabla["visina_m"]) if getattr(self, "stabla", None) else None}
        for vrsta, z in zad.items():
            if vrsta in out and z is not None and len(z) == out[vrsta]["instanci"]:
                v = np.sort(np.array(skup[vrsta]["mjerila"]))
                rel = np.abs(v - np.sort(z)) / np.maximum(np.sort(z), 1e-6)
                out[vrsta]["odstupanje_od_zadanog_najvise"] = round(float(rel.max()), 4)
                out[vrsta]["mjerilo_jednako_zadanom"] = bool(rel.max() <= tolerancija)
        dobro = all(d["naopako_ili_nagnuto"] == 0 and d["nejednoliko"] == 0 and d.get("mjerilo_jednako_zadanom", True)
                    for d in out.values())
        out["prolazi"] = dobro
        self.kstat["provjera_instanci"] = out
        if not dobro:
            self.kstat["upozorenja"].append(f"provjera instanci ne prolazi: {out}")
        return out

    # --- godišnje doba -----------------------------------------------------------------
    SEZONA_TRAVE = {"ljeto": (1.0, 1.0), "jesen": (0.86, 0.97), "zima": (0.66, 0.92)}   # zasićenost, svjetlina

    def postavi_sezonu(self, sezona):
        """Kao scena.Scena.postavi_sezonu (krošnje scene i koncepta dijele materijal), uz blago prigušenu
        travu i penjačice koncepta zimi i ujesen (krug 3), da se u montaži na snimci iz ožujka ne pojavi
        ljetni park. PRETPOSTAVKA, samo izgled."""
        sezona = super().postavi_sezonu(sezona)
        self._sezona_mladih(sezona)
        z_, v_ = self.SEZONA_TRAVE.get(sezona, (1.0, 1.0))
        for hs in getattr(self, "_hs_trave", []):
            hs.inputs["Saturation"].default_value = z_
            hs.inputs["Value"].default_value = v_
        return sezona

    def _sezonski_cvor(self, m):
        """Čvor zasićenosti i svjetline ispred osnovne boje materijala (za postavi_sezonu)."""
        nt = m.node_tree
        b = nt.nodes["Principled BSDF"]
        lnk = next((l for l in nt.links if l.to_node == b and l.to_socket.name == "Base Color"), None)
        if lnk is None:
            return None
        hs = nt.nodes.new("ShaderNodeHueSaturation")
        nt.links.new(lnk.from_socket, hs.inputs["Color"])
        nt.links.new(hs.outputs["Color"], b.inputs["Base Color"])
        if not hasattr(self, "_hs_trave"):
            self._hs_trave = []
        self._hs_trave.append(hs)
        z_, v_ = self.SEZONA_TRAVE.get(getattr(self, "sezona", "ljeto"), (1.0, 1.0))
        hs.inputs["Saturation"].default_value, hs.inputs["Value"].default_value = z_, v_
        return hs

    # --- kamera ----------------------------------------------------------------------
    def postavi_kameru(self, kam=None, **kw):
        """Kao scena.Scena.postavi_kameru, uz provjeru da oko nije u objektu ni pod terenom (krug 3, M-6):
        lepeza od 26 zraka; pogreška ako je najbliži pogodak bliži od `najblize_m` ili ako većina zraka
        pogađa stražnju stranu plohe (oko unutar zatvorene mreže ili ispod terena)."""
        kam = super().postavi_kameru(kam, **kw)
        self.provjeri_kameru()
        return kam

    def provjeri_kameru(self, najblize_m=1.0, udio_straga=0.5):
        """Lepeza od 26 zraka iz oka kamere (skriveni nositelji instanci se preskaču). Pogreška ako je najbliži
        pogodak bliži od `najblize_m`, ako zraka ravno gore pogađa stražnju stranu bilo koje mreže osim stakla
        i instanci (oko pod terenom, u nasipu, pod plohom ili u zgradi scene ili koncepta), ako zraka ravno dolje
        ne pogađa ništa ili ako stražnju stranu pogađa više od `udio_straga` pogodaka. Staklo svjetlarnika ili
        okna dizala iznad oka (stražnja strana) nije pogreška."""
        import mathutils

        bpy = self.bpy
        cam = self.scene.camera
        if cam is None:
            return None
        bpy.context.view_layer.update()
        dg = bpy.context.evaluated_depsgraph_get()
        o_ = cam.matrix_world.translation.copy()

        def zraka(v):
            poc, prijedeno = o_.copy(), 0.0
            for _ in range(8):
                ok, loc, nrm, _, ob, _ = self.scene.ray_cast(dg, poc, v, distance=5000.0)
                if not ok:
                    return None
                prijedeno += (loc - poc).length
                if ob is not None and ob.name.startswith("nositelj_"):
                    poc = loc + v * 0.01
                    prijedeno += 0.01
                    continue
                return prijedeno, float(nrm.dot(v)) > 0.0, ob.name if ob is not None else None
            return None

        smjerovi = [(x, y, z_) for x in (-1, 0, 1) for y in (-1, 0, 1) for z_ in (-1, 0, 1) if (x, y, z_) != (0, 0, 0)]
        najb, straga, pogodaka, najb_ob, dolje, gore = 1e9, 0, 0, None, None, None
        for sm in smjerovi:
            v = mathutils.Vector(sm).normalized()
            r = zraka(v)
            if r is None:
                continue
            pogodaka += 1
            if r[0] < najb:
                najb, najb_ob = r[0], r[2]
            straga += int(r[1])
            if sm == (0, 0, -1):
                dolje = r
            if sm == (0, 0, 1):
                gore = r
        nalaz = {"najblizi_pogodak_m": round(float(najb), 2), "objekt": najb_ob, "zraka": len(smjerovi),
                 "pogodaka": pogodaka, "straznja_strana": straga,
                 "dolje": "nista" if dolje is None else ("straznja strana" if dolje[1] else "lice"),
                 "gore": None if gore is None else {"objekt": gore[2], "straznja_strana": bool(gore[1])}}
        # krug 4 (M-1): zraka ravno gore koja pogađa stražnju stranu bilo čega osim stakla (svjetlarnik, okno
        # dizala, pročelje) i instanci znači oko pod terenom ili plohom ili u zatvorenoj mreži (zgrada scene,
        # zgrada koncepta); prije se gledalo samo teren i plohu parka, pa je oko u zgradi scene prolazilo
        u_objektu = gore is not None and gore[1] and not any(t in str(gore[2]) for t in ("staklo", "dizala", "stablo", "covjek_"))
        nalaz["oko_u_objektu"] = bool(u_objektu)
        self.kstat["provjera_kamere"] = nalaz
        if najb < najblize_m or u_objektu or dolje is None or (pogodaka >= 6 and straga > udio_straga * pogodaka):
            raise RuntimeError(f"kamera je u objektu, pod terenom ili preblizu prepreci (oko "
                               f"{tuple(round(c, 1) for c in o_)} ENU-M): {nalaz}")
        return nalaz

    # --- gradnja ---------------------------------------------------------------------
    def izgradi(self):
        super().izgradi()
        koraci = [("teksture", self._teksture), ("ploha", self._gradi_plohu), ("zidovi", self._gradi_zidove),
                  ("pokrov", self._gradi_prazninu), ("svjetlarnici", self._gradi_svjetlarnike),
                  ("prizemlje", self._gradi_prizemlje), ("stadion", self._gradi_stadion_koncepta),
                  ("elementi", self._gradi_elemente), ("drvece", self._gradi_drvece_koncepta),
                  ("ljudi", self._gradi_ljude), ("vozila", self._gradi_vozila), ("teren", self._spusti_teren)]
        t_sve = time.time()
        for ime, f in koraci:
            t0 = time.time()
            f()
            self.kstat["vrijeme_s"][ime] = round(time.time() - t0, 2)
        t0 = time.time()
        self.provjeri_instance()
        self.kstat["vrijeme_s"]["provjera_instanci"] = round(time.time() - t0, 2)
        self.kstat["vrijeme_s"]["koncept_ukupno"] = round(time.time() - t_sve + self.kstat["vrijeme_s"]["ploha_izracun"], 2)
        self.statistika["slojevi"]["koncept"] = dict(self.kstat["broj"])
        _log(f"koncept: {self.kstat['vrijeme_s']}")
        return self

    # --- materijali ---------------------------------------------------------------------
    def _mat(self, vrsta):
        bpy = self.bpy
        if vrsta in self._mati:
            return self._mati[vrsta]
        if vrsta == "boja":
            m = self.materijal("k_boja", atribut_boje="boja", hrapavost=0.85)
            self._dodaj_sum(m, jakost=0.09, mjerilo=0.18)      # beton, kamen, zeleni zidovi: blagi tonovi
        elif vrsta == "sjaj":
            # staklena pročelja i opna: odraz neba, bez plastičnog sjaja
            m = self.materijal("k_sjaj", atribut_boje="boja", hrapavost=0.07)
            m.node_tree.nodes["Principled BSDF"].inputs["Specular IOR Level"].default_value = 0.65
        elif vrsta == "opna":
            # tamna staklena opna stadiona iza lamela: odraz zamućen (oštar odraz atletske staze i krošnji davao je
            # crvenkaste mrlje, P02 14.11.2026.); PRETPOSTAVKA, samo izgled
            m = self.materijal("k_opna", atribut_boje="boja", hrapavost=float(self.ok.get("opna_hrapavost", 0.38)))
            m.node_tree.nodes["Principled BSDF"].inputs["Specular IOR Level"].default_value = 0.5
        elif vrsta == "penjacice":
            # zeleno lice zida (penjačice): sitne mrlje lišća, tamnije i svjetlije, i reljef
            m = self.materijal("k_penjacice", atribut_boje="boja", hrapavost=0.9)
            self._dodaj_sum(m, jakost=0.30, mjerilo=1.6)
            self._dodaj_sum(m, jakost=0.12, mjerilo=0.12)
            nt = m.node_tree
            nz = nt.nodes.new("ShaderNodeTexNoise")
            nz.inputs["Scale"].default_value = 3.0
            nz.inputs["Detail"].default_value = 4.0
            tc = nt.nodes.new("ShaderNodeTexCoord")
            nt.links.new(tc.outputs["Object"], nz.inputs["Vector"])
            bump = nt.nodes.new("ShaderNodeBump")
            bump.inputs["Strength"].default_value = 0.6
            nt.links.new(nz.outputs["Fac"], bump.inputs["Height"])
            nt.links.new(bump.outputs["Normal"], nt.nodes["Principled BSDF"].inputs["Normal"])
            self._sezonski_cvor(m)
        elif vrsta == "lamele":
            # M25: plave lamele, mat-metalne (eloksirani aluminij), blagi tonovi
            m = self.materijal("k_lamele", atribut_boje="boja", hrapavost=0.42, metal=0.35)
            m.node_tree.nodes["Principled BSDF"].inputs["Specular IOR Level"].default_value = 0.4
            self._dodaj_sum(m, jakost=0.05, mjerilo=0.35)
        elif vrsta == "krov":
            # M25: bijeli prstenasti krov kao membrana: mat, blagi tonovi
            m = self.materijal("k_krov", C["krov"], hrapavost=0.62)
            m.node_tree.nodes["Principled BSDF"].inputs["Specular IOR Level"].default_value = 0.3
            self._dodaj_sum(m, jakost=0.04, mjerilo=0.08)
        elif vrsta == "voda":
            m = self.materijal("k_voda", C["voda"], hrapavost=0.05)
            m.node_tree.nodes["Principled BSDF"].inputs["Specular IOR Level"].default_value = 0.9
        elif vrsta == "staklo":
            m = bpy.data.materials.new("k_staklo")
            m.use_nodes = True
            nt = m.node_tree
            b = nt.nodes["Principled BSDF"]
            b.inputs["Base Color"].default_value = (0.03, 0.04, 0.05, 1)
            b.inputs["Roughness"].default_value = 0.02
            b.inputs["Specular IOR Level"].default_value = 1.0
            tr = nt.nodes.new("ShaderNodeBsdfTransparent")
            tr.inputs["Color"].default_value = (0.86, 0.92, 0.93, 1)
            # fizikalni Fresnel stakla (IOR 1,5); staklo je tanka ploča, pa i sa stražnje strane (odozdo)
            # vrijedi IOR 1,5: Fresnel čvor bi ondje računao izlaz iz stakla (1/1,5) i totalnu refleksiju
            # iznad 42°, pa bi staklo svjetlarnika odozdo bilo gotovo crno
            lw = nt.nodes.new("ShaderNodeFresnel")
            geo = nt.nodes.new("ShaderNodeNewGeometry")
            mu = nt.nodes.new("ShaderNodeMath")
            mu.operation = "MULTIPLY"
            mu.inputs[1].default_value = 1.0 / 1.5 - 1.5
            ad = nt.nodes.new("ShaderNodeMath")
            ad.operation = "ADD"
            ad.inputs[1].default_value = 1.5
            nt.links.new(geo.outputs["Backfacing"], mu.inputs[0])
            nt.links.new(mu.outputs[0], ad.inputs[0])
            nt.links.new(ad.outputs[0], lw.inputs["IOR"])
            mj = nt.nodes.new("ShaderNodeMixShader")
            mr = nt.nodes.new("ShaderNodeMapRange")
            mr.inputs["To Min"].default_value, mr.inputs["To Max"].default_value = 0.0, 1.0
            nt.links.new(lw.outputs["Fac"], mr.inputs["Value"])
            nt.links.new(mr.outputs["Result"], mj.inputs["Fac"])
            nt.links.new(tr.outputs[0], mj.inputs[1])
            nt.links.new(b.outputs[0], mj.inputs[2])
            izl = next(n for n in nt.nodes if n.type == "OUTPUT_MATERIAL")
            nt.links.new(mj.outputs[0], izl.inputs["Surface"])
        elif vrsta == "podgled":
            m = self.materijal("k_podgled", C["beton"], hrapavost=0.9)
            b = m.node_tree.nodes["Principled BSDF"]
            b.inputs["Emission Color"].default_value = (1.0, 0.92, 0.80, 1)
            b.inputs["Emission Strength"].default_value = float(self.ok["svjetlo_pod_pokrovom"])
        elif vrsta == "odjeca":
            m = bpy.data.materials.new("k_odjeca")
            m.use_nodes = True
            nt = m.node_tree
            b = nt.nodes["Principled BSDF"]
            b.inputs["Roughness"].default_value = 0.9
            oi = nt.nodes.new("ShaderNodeObjectInfo")
            r = nt.nodes.new("ShaderNodeValToRGB")
            r.color_ramp.interpolation = "CONSTANT"
            boje = [(160, 72, 62), (52, 72, 120), (214, 212, 206), (62, 62, 66), (186, 156, 82), (78, 116, 90),
                    (128, 96, 124), (44, 84, 150), (112, 78, 60), (196, 138, 84)]   # krug 3: manje zasićeno
            el = r.color_ramp.elements
            el[0].position, el[0].color = 0.0, (*lin(boje[0]), 1)
            el[1].position, el[1].color = 1.0 / len(boje), (*lin(boje[1]), 1)
            for i, c in enumerate(boje[2:], start=2):
                e = el.new(i / len(boje))
                e.color = (*lin(c), 1)
            nt.links.new(oi.outputs["Random"], r.inputs["Fac"])
            nt.links.new(r.outputs["Color"], b.inputs["Base Color"])
        else:
            raise KeyError(vrsta)
        self._mati[vrsta] = m
        return m

    def _dodaj_sum(self, m, jakost=0.08, mjerilo=0.15):
        """Proceduralni šum svjetline (koordinate objekta u metrima) pomnožen s osnovnom bojom materijala:
        blagi tonovi bez vanjskih tekstura (krug 3)."""
        nt = m.node_tree
        b = nt.nodes["Principled BSDF"]
        lnk = next((l for l in nt.links if l.to_node == b and l.to_socket.name == "Base Color"), None)
        tc = nt.nodes.new("ShaderNodeTexCoord")
        nz = nt.nodes.new("ShaderNodeTexNoise")
        nz.inputs["Scale"].default_value = mjerilo
        nz.inputs["Detail"].default_value = 6.0
        nz.inputs["Roughness"].default_value = 0.62
        nt.links.new(tc.outputs["Object"], nz.inputs["Vector"])
        mr = nt.nodes.new("ShaderNodeMapRange")
        mr.inputs["From Min"].default_value, mr.inputs["From Max"].default_value = 0.3, 0.7
        mr.inputs["To Min"].default_value, mr.inputs["To Max"].default_value = 1.0 - jakost, 1.0 + 0.6 * jakost
        nt.links.new(nz.outputs["Fac"], mr.inputs["Value"])
        mx = nt.nodes.new("ShaderNodeMix")
        mx.data_type = "RGBA"
        mx.blend_type = "MULTIPLY"
        mx.inputs["Factor"].default_value = 1.0
        if lnk is not None:
            nt.links.new(lnk.from_socket, mx.inputs["A"])
        else:
            mx.inputs["A"].default_value = b.inputs["Base Color"].default_value
        nt.links.new(mr.outputs["Result"], mx.inputs["B"])
        nt.links.new(mx.outputs["Result"], b.inputs["Base Color"])
        return m

    def _mat_tekstura(self, naziv, put):
        bpy = self.bpy
        m = bpy.data.materials.new(naziv)
        m.use_nodes = True
        nt = m.node_tree
        b = nt.nodes["Principled BSDF"]
        b.inputs["Roughness"].default_value = 0.93
        b.inputs["Specular IOR Level"].default_value = 0.12
        t = nt.nodes.new("ShaderNodeTexImage")
        t.image = self._slika(put)
        t.extension = "EXTEND"
        uv = nt.nodes.new("ShaderNodeUVMap")
        uv.uv_map = "uv"
        nt.links.new(uv.outputs["UV"], t.inputs["Vector"])
        nt.links.new(t.outputs["Color"], b.inputs["Base Color"])
        return m

    def _objekt(self, naziv, sp: Spremnik, podsloj, materijal="boja", glatko=False):
        if not len(sp):
            return None
        co = np.asarray(sp.co, dtype=np.float64)
        if not sp.metricki:
            xm, ym = SC.m_iz_n(co[:, 0], co[:, 1])
            co = np.column_stack([xm, ym, co[:, 2]])
        mat = self._mat(materijal) if isinstance(materijal, str) else materijal
        ob = self.dodaj_mrezu(naziv, co, sp.plohe, sloj="koncept", boje_ploha=sp.boje, materijal=mat, glatko=glatko)
        ob["podsloj"] = PODSLOJEVI[podsloj]
        self.kstat["broj"][f"ploha_{naziv}"] = len(sp)
        return ob

    def _objekt_polja(self, naziv, dijelovi, podsloj, materijal, tekstura=None, obrni=False, glatko=True):
        """Objekt iz popisa (xy ENU-N, z, petlje, duljine) s UV koordinatama teksture."""
        if not dijelovi:
            return None
        xy, zz, pet, dul = [], [], [], []
        baza = 0
        for v, z, p, d in dijelovi:
            if obrni:
                poc = np.r_[0, np.cumsum(d)[:-1]]
                p = np.concatenate([p[a:a + n][::-1] for a, n in zip(poc, d)])
            xy.append(v); zz.append(z); pet.append(p + baza); dul.append(d)
            baza += len(v)
        xy, zz, pet, dul = np.concatenate(xy), np.concatenate(zz), np.concatenate(pet), np.concatenate(dul)
        xm, ym = SC.m_iz_n(xy[:, 0], xy[:, 1])
        uv = tekstura.uv(xy[:, 0], xy[:, 1])[pet] if tekstura is not None else None
        ob = self._mreza(naziv, np.column_stack([xm, ym, zz]), pet, dul, "koncept", materijal=materijal, uv=uv, glatko=glatko)
        ob["podsloj"] = PODSLOJEVI[podsloj]
        self.kstat["broj"][f"ploha_{naziv}"] = int(len(dul))
        return ob

    # --- teksture --------------------------------------------------------------------------
    def _teksture(self):
        from shapely.geometry import box

        pv, P = self.povrsina, self.program
        r = float(self.ok["tekstura_m"])
        T = Tekstura((pv.x0, pv.y0, pv.x0 + pv.nx * pv.g, pv.y0 + pv.ny * pv.g), r, RGB["trava"])
        for s in sorted(pv.pl, key=lambda q: -PRIORITET.get(q["kat"], 5)):
            g, kat, ime = s["geom"], s["kat"], norm(s["naziv"])
            if kat == "park_zelenilo":
                if re.search(r"djecj|igralist", ime):
                    T.ispuni(g, RGB["igraliste_djecje"])
                elif re.search(r"livad", s["tekst_sve"]):
                    T.ispuni(g, RGB["livada"], zeleno=True)
                else:
                    T.ispuni(g, RGB["trava"], zeleno=True)
            elif kat == "staza":
                T.ispuni(g, RGB["aleja"] if "alej" in ime else RGB["staza"])
            elif kat == "trg_predvorje":
                T.ispuni(g, RGB["trg"])
            elif kat == "sport_otvoreni":
                _crtaj_sport(T, s)
            elif kat == "voda":
                T.ispuni(g, RGB["voda"])
            elif kat == "kultura":
                T.ispuni(g, RGB["kamen"])
            else:
                T.ispuni(g, RGB["beton"])
        for s in pv.pl:  # rubovi staza i trgova
            if s["kat"] in ("staza", "trg_predvorje"):
                for pol in _poligoni(s["geom"], 0.0):
                    T.linija(np.asarray(pol.exterior.coords), (150, 144, 130), r)
        # stepenice terasa: strme ćelije u boji potpornog zida
        for s in pv.pl:
            if s["terase"]:
                Hs = np.where(pv.L == s["k"], pv.H, np.nan)
                gy, gx = np.gradient(Hs, pv.g)
                ii, jj = np.nonzero(np.hypot(gx, gy) > 0.45)
                for i, j in zip(ii, jj):
                    T.ispuni(box(pv.x0 + j * pv.g, pv.y0 + i * pv.g, pv.x0 + (j + 1) * pv.g, pv.y0 + (i + 1) * pv.g), RGB["kamen"])
        st = P.stadion
        if st and st["tribine"]:
            T.ispuni(st["tribine"][0]["unut"], (78, 120, 70))
            if st["igraliste"] is not None:
                _crtaj_nogometno(T, st["igraliste"])
        T.neujednacenost(int(self.ok["sjeme"]))
        self.tex_park = T
        self.mat_park = self._mat_tekstura("k_park", T.spremi(self._tmp("koncept_park.png")))
        self._sezonski_cvor(self.mat_park)
        self.kstat["broj"]["tekstura_park_px"] = [T.w, T.h]

    # --- ploha parka -------------------------------------------------------------------------
    def _gradi_plohu(self):
        pv = self.povrsina
        dij, voda = [], []
        ter = self._plan_terasa()
        pas = ter["pas"] if ter is not None else None
        for s in pv.pl:
            g = s["geom"]
            if pas is not None and g.intersects(pas):
                g = g.difference(pas)   # pojas terasa (krug 3): park počinje iza najvišeg kata
                if g.is_empty:
                    continue
            r = pv.mreza_podrucja(g, lambda x, y, s=s: pv.z_prostora(s, x, y))
            if r is not None:
                (voda if s["kat"] == "voda" else dij).append(r)
        self._objekt_polja("park_ploha", dij, "park", self.mat_park, self.tex_park)
        self._objekt_polja("park_voda", voda, "park", self._mat("voda"), None)
        self.kstat["broj"]["prostora_plohe"] = len(pv.pl)
        self.kstat["broj"]["kosina"] = sum(1 for s in pv.pl if s["kosina"])

    # --- zidovi, pročelja, portali ------------------------------------------------------------
    def _oznaci_portale(self, z, h, portal, hp):
        import shapely
        from scipy.spatial import cKDTree
        from shapely.geometry import LineString

        P, o = self.program, self.ok
        mid = (z["p0"] + z["p1"]) / 2
        visok = np.nonzero(h >= 2.6)[0]
        if not len(visok):
            return []
        stablo = cKDTree(mid[visok])
        tocke = shapely.points(mid[visok])
        nn = z["n"][visok]
        popis = []

        def oznaci(sidro, polumjer, vrsta, visina, samo_praznina=False):
            """sidro: indeks u `visok`; označava dijelove istog zida unutar polumjera."""
            for j in stablo.query_ball_point(mid[visok][sidro], max(polumjer, 1.3)):
                if float(nn[j] @ nn[sidro]) < 0.6:
                    continue
                i = visok[j]
                if samo_praznina and not z["praznina"][i]:
                    continue
                if portal[i] == 0 or vrsta < portal[i]:
                    portal[i] = vrsta
                    hp[i] = min(visina, h[i] - 1.0)

        for v in P.veze:
            if v["tip"] not in ("kolni_ulaz", "ulaz"):
                continue
            kolni = v["tip"] == "kolni_ulaz"
            sir = v["sirina"] or (o["sirina_kolnog_ulaza_m"] if kolni else o["sirina_ulaza_m"])
            g = v["geom"]
            sidra, uz_zid = [], False
            if g.geom_type == "LineString":
                d = shapely.distance(g, tocke)
                blizu = np.nonzero(d < 1.3)[0]
                if len(blizu) * 2.5 >= 0.5 * sir and len(blizu) >= 2:
                    sidra, uz_zid = list(blizu), True       # linija leži uz zid: portal je dug koliko i linija
                elif len(blizu):
                    sidra = [int(blizu[np.argmin(d[blizu])])]
                else:
                    c = np.asarray(g.coords)
                    dd, jj = stablo.query(c)
                    if dd.min() <= 15.0:
                        sidra = [int(jj[np.argmin(dd)])]
            else:
                dd, jj = stablo.query([g.x, g.y])
                if dd <= 15.0:
                    sidra = [int(jj)]
            if not sidra:
                continue
            prazno = bool(z["praznina"][visok[sidra[0]]])
            if kolni and (sir >= 15 or prazno):
                vrsta, vis = 1, o["visina_portala_m"]
            elif kolni:
                vrsta, vis = 2, o["visina_kolnog_ulaza_m"]
            else:
                vrsta, vis = 3, o["visina_ulaza_m"]
            for sd in sidra:
                oznaci(sd, 1.3 if uz_zid else sir / 2.0, vrsta, vis)
            popis.append({"veza": v["id"], "vrsta": ("cesta", "kolni ulaz", "ulaz")[vrsta - 1], "sirina_m": round(sir, 1)})
        # portali ceste i tramvaja koje program ne navodi: gdje os ceste ili kolosijek iz site.json ulazi pod pokrov
        kand = np.nonzero(z["praznina"][visok] & (h[visok] >= 4.0))[0]
        if len(kand):
            seg = shapely.linestrings(np.stack([z["p0"][visok[kand]], z["p1"][visok[kand]]], axis=1))
            linije = []
            try:
                linije.append((LineString(self.site["izvedeno"]["os_maksimirske"]["linija"]), 11.0, "os ceste"))
            except Exception:  # noqa: BLE001
                pass
            for pr in (self.site.get("tramvaj") or {}).get("pruge") or []:
                if len(pr.get("linija") or []) >= 2:
                    linije.append((LineString(pr["linija"]), 3.5, "kolosijek"))
            novih = 0
            for l, pol, _ in linije:
                for j in np.nonzero(shapely.intersects(l, seg))[0]:
                    if portal[visok[kand[j]]] == 0:
                        novih += 1
                    oznaci(int(kand[j]), pol, 1, o["visina_portala_m"], samo_praznina=True)
            if novih:
                popis.append({"veza": None, "vrsta": "cesta ili tramvaj (iz site.json)", "broj_presjeka": novih})
        return popis

    def _rub(self):
        """Dijelovi ruba plohe s visinama i oznakama portala (izračun jednom po sceni)."""
        if not hasattr(self, "_rub_c"):
            z = self.povrsina.zidovi()
            if z is None:
                self._rub_c = None
            else:
                n = len(z["az"])
                h = np.maximum(z["zt0"] - z["zb0"], z["zt1"] - z["zb1"])
                portal, hp = np.zeros(n, dtype=np.int8), np.zeros(n)
                popis = self._oznaci_portale(z, h, portal, hp)
                self._rub_c = (z, h, portal, hp, popis)
        return self._rub_c

    def _plan_terasa(self):
        """M19, južni rub: vanjski rub prema jugu (azimut normale `terase_azimut`) viši od kata, s približno
        vodoravnim vrhom (nagib do `terase_nagib`), gradi se kao terase koje se uvlače PREMA UNUTRA: prizemlje
        stoji na rubu razine parka iz programa, svaki viši kat je `uvlacenje_terase_m` dalje od ruba, a park
        počinje iza najvišeg kata. Katovi su vodoravni (kota iz najnižeg vrha niza ruba). Kosi rub ostaje pokos
        ili zeleni zid. Pojas terasa izrezuje se iz plohe parka. Broj katova se smanjuje gdje bi pojas zahvatio
        sadržaj parka (igrališta, vodu, svjetlarnike, stadion, dizala, stube) ili izašao iz plohe.
        PRETPOSTAVKA modela: program zadaje rub i kotu parka, ne terase."""
        if hasattr(self, "_ter_c"):
            return self._ter_c
        import shapely
        from shapely.geometry import LineString, Polygon
        from shapely.ops import unary_union

        self._ter_c = None
        r = self._rub()
        o = self.ok
        if r is None:
            return None
        z, h, portal, hp, _ = r
        pv = self.povrsina
        kat, d, kmax = float(o["kat_procelja_m"]), float(o["uvlacenje_terase_m"]), int(o["najvise_terasa"])
        az0, az1 = (float(v) for v in o["terase_azimut"])
        nag_max = float(o["terase_nagib"])
        az = z["az"]
        n = len(az)
        p0a, p1a = z["p0"], z["p1"]
        dulj = np.hypot(*(p1a - p0a).T)
        van = z["vanjski"]
        # susjedi duž vanjskog ruba (kraj jednog dijela = početak sljedećeg)
        kljuc = lambda p: (int(round(p[0] * 50)), int(round(p[1] * 50)))  # noqa: E731
        poc = {kljuc(p0a[i]): i for i in np.nonzero(van)[0]}
        kraj = {kljuc(p1a[i]): i for i in np.nonzero(van)[0]}
        nx0, nx1 = np.full(n, -1), np.full(n, -1)
        for i in np.nonzero(van)[0]:
            j = kraj.get(kljuc(p0a[i]))
            if j is not None and j != i:
                nx0[i] = j
            j = poc.get(kljuc(p1a[i]))
            if j is not None and j != i:
                nx1[i] = j
        # nagib vrha ruba, zaglađen duž ruba na ±6 m (pojedini dijelovi su kratki, do 2,5 m)
        nagib = np.full(n, np.nan)
        for i in np.nonzero(van)[0]:
            s_, zz = [-dulj[i] / 2.0, dulj[i] / 2.0], [z["zt0"][i], z["zt1"][i]]
            for smjer, nx, kraj_z in ((1.0, nx1, "zt1"), (-1.0, nx0, "zt0")):
                s_cur, j = dulj[i] / 2.0, nx[i]
                while s_cur < 6.0 and j >= 0 and j != i:
                    s_cur += dulj[j]
                    s_.append(smjer * s_cur)
                    zz.append(z[kraj_z][j])
                    j = nx[j]
            nagib[i] = abs(float(np.polyfit(np.asarray(s_), np.asarray(zz), 1)[0]))
        juzno = (az >= az0) & (az <= az1)
        vodoravno = np.nan_to_num(nagib, nan=1.0) <= nag_max
        # rub nad prazninom (garaža, terminal) dobiva terase kao i ostali južni rub; samo rub pokrova nad
        # Maksimirskom (do 40 m od osi ceste) ostaje rub pokrova s portalima (M19)
        praz_ok = ~z["praznina"]
        try:
            os_ = LineString(self.site["izvedeno"]["os_maksimirske"]["linija"])
            praz_ok = praz_ok | (shapely.distance(os_, shapely.points((p0a + p1a) / 2)) > 40.0)
        except Exception:  # noqa: BLE001
            pass
        kand = van & praz_ok & (portal == 0) & juzno & (h >= kat + 1.0)
        A = kand & vodoravno
        self._ter_c = {"kat": np.zeros(n, dtype=np.int32), "razina": np.full(n, np.nan), "nagib": nagib,
                       "juzno": juzno, "vodoravno": vodoravno, "d": d, "visina_kata": kat, "pas": None,
                       "m0": z["n"].copy(), "m1": z["n"].copy(), "sus0": np.full(n, -1), "sus1": np.full(n, -1),
                       "z_unutra": np.zeros((n, 2))}
        kos_jug = float(dulj[kand & ~vodoravno].sum())
        if not o["terase"] or not A.any():
            self.kstat["terase"] = {"duljina_m": 0, "kosi_juzni_rub_bez_terasa_m": round(kos_jug)}
            return self._ter_c
        # nizovi uzastopnih dijelova A; novi niz kad vrh odstupi više od 0,8 m od najnižeg vrha niza
        nizovi, vidjeno = [], np.zeros(n, bool)
        pocetci = [i for i in np.nonzero(A)[0] if not (nx0[i] >= 0 and A[nx0[i]])]
        pocetci += [i for i in np.nonzero(A)[0] if i not in set(pocetci)]   # zatvoreni krugovi
        for i0 in pocetci:
            if vidjeno[i0]:
                continue
            niz, i = [], i0
            while i >= 0 and A[i] and not vidjeno[i]:
                vrhovi = [min(z["zt0"][j], z["zt1"][j]) for j in niz] + [min(z["zt0"][i], z["zt1"][i])]
                vrhovi_max = [max(z["zt0"][j], z["zt1"][j]) for j in niz] + [max(z["zt0"][i], z["zt1"][i])]
                if niz and max(vrhovi_max) - min(vrhovi) > 0.8:
                    nizovi.append(niz)
                    niz = []
                vidjeno[i] = True
                niz.append(i)
                i = nx1[i]
            if niz:
                nizovi.append(niz)
        # miter na spojevima unutar niza i prema susjednom južnom dijelu
        def miter(a, b):
            c = 1.0 + float(a @ b)
            if c < 0.3:
                return a
            v = (a + b) / c
            l = float(np.hypot(*v))
            return v if l <= 2.0 else v * (2.0 / l)

        m0, m1 = z["n"].copy(), z["n"].copy()
        for i in np.nonzero(A)[0]:
            if nx0[i] >= 0 and kand[nx0[i]]:
                m0[i] = miter(z["n"][i], z["n"][nx0[i]])
            if nx1[i] >= 0 and kand[nx1[i]]:
                m1[i] = miter(z["n"][i], z["n"][nx1[i]])
        # dopušteno tlo pojasa: travnjak, staze i trgovi parka; zabranjeno: ostali sadržaji, stadion, veze
        dopusteno = unary_union([s["geom"] for s in pv.pl if s["kat"] in ("park_zelenilo", "staza", "trg_predvorje")])
        zab = [s["geom"].buffer(1.0) for s in pv.pl if s["kat"] not in ("park_zelenilo", "staza", "trg_predvorje")]
        zab += [sv["geom"].buffer(1.5) for sv in pv.svj]
        P = self.program
        if P.stadion:
            zab.append(P.stadion["vanjski"].buffer(3.0))
        # ulazi na rubu su portali (prekidaju niz), pa ne ulaze u zabranu
        zab += [v["geom"].buffer(3.0) for v in P.veze if v["tip"] in ("dizalo", "stubiste", "pokretne_stube")]
        # krug 4 (M-3): ni preko osi ulica ni uličnih parkirališta (OSM, site.json; samo orijentacijski) — ondje
        # rub ostaje zeleni zid dok program ne odluči o rubu razine parka nad tim ulicama
        from shapely.geometry import LineString as _L

        for c_ in (self.site or {}).get("ceste", []):
            if c_.get("razred") in RAZREDI_ULICA:
                try:
                    zab.append(_L(c_["linija"]).buffer(1.0))
                except Exception:  # noqa: BLE001
                    pass
        for pk_ in (self.site or {}).get("parkiralista", []):
            g_ = _poligon(pk_.get("poligon"), pk_.get("rupe"))
            if g_ is not None:
                zab.append(g_.buffer(0.5))
        zab = unary_union(zab) if zab else None
        # krug 4 (V3): prostori nižih razina s volumenom (pod do pod + svijetla visina; promet uvijek, uz visinu
        # profila) — terasa sa svojom pločom ne smije ući u taj volumen
        nizi = self._volumeni_nizih()
        from shapely.strtree import STRtree

        nizi_st = STRtree([q["geom"] for q in nizi]) if nizi else None
        ploca = max(kat - 3.2, 0.5)

        def u_volumenu(q_, kota):
            """Prostori nižih razina čiji volumen siječe terasu na `kota` (s pločom) nad tlocrtom q_."""
            if nizi_st is None or q_.is_empty:
                return []
            out_ = []
            for ii in nizi_st.query(q_, predicate="intersects"):
                v_ = nizi[int(ii)]
                if v_["pod"] < kota and v_["vrh"] > kota - ploca + 0.05:
                    a_ = float(v_["geom"].intersection(q_).area)
                    if a_ > 0.5:
                        out_.append((v_["id"], a_))
            return out_
        if zab is not None:
            shapely.prepare(zab)
        shapely.prepare(dopusteno)
        K_, zr_, zin = self._ter_c["kat"], self._ter_c["razina"], self._ter_c["z_unutra"]
        pas, odbijeno, trake, nizi_razlog, nizi_sukobi = [], {"kratko": 0.0, "nisko": 0.0, "sadrzaj": 0.0}, [], set(), {}
        for niz in nizovi:
            Ln = float(dulj[niz].sum())
            if Ln < float(o["terasa_najmanja_duljina_m"]):
                odbijeno["kratko"] += Ln
                continue
            zr = float(min(min(z["zt0"][j], z["zt1"][j]) for j in niz))
            tlo_max = float(max(max(z["zb0"][j], z["zb1"][j]) for j in niz)) + 0.6
            k = min(kmax, int(math.floor((zr - tlo_max - float(o["prizemlje_terasa_m"])) / kat)))
            if k < 1:
                odbijeno["nisko"] += Ln
                continue
            # po dijelu ruba: najviše katova koje pojas tog dijela dopušta (sadržaj parka, ploha, kota iza)
            def pojas(j, k, k0=0):
                q = Polygon([p0a[j] - k0 * d * m0[j], p1a[j] - k0 * d * m1[j], p1a[j] - k * d * m1[j], p0a[j] - k * d * m0[j]])
                return q if q.is_valid else q.buffer(0)

            kj = {}
            for j in niz:
                k_ = k
                while k_ >= 1:
                    q = pojas(j, k_)
                    izvan = q.difference(dopusteno.buffer(0.3)).area
                    zu = max(float(pv.kota(*(p0a[j] - k_ * d * m0[j]))[0]), float(pv.kota(*(p1a[j] - k_ * d * m1[j]))[0]))
                    # traka s_ (od ruba) leži na koti zr − (k_ − s_)·kat
                    sv_ = [u_volumenu(pojas(j, s_ + 1, s_), zr - (k_ - s_) * kat) for s_ in range(k_)]
                    sukob_v = any(sv_)
                    if k_ == 1 and sukob_v:
                        for id_, a_ in sv_[0]:
                            r_ = nizi_sukobi.setdefault(id_, [0.0, 0.0])
                            r_[0] += float(dulj[j])
                            r_[1] += a_
                    if izvan <= 0.05 * max(q.area, 1e-6) and (zab is None or not zab.intersects(q)) and zu - zr <= 1.0 \
                            and not sukob_v:
                        break
                    if sukob_v:
                        nizi_razlog.add(int(j))
                    k_ -= 1
                kj[j] = k_
            # kratki komadi istog broja katova (do 8 m) spuštaju se na manji susjedni, da rub ne skače
            for _ in range(6):
                promjena = False
                poz = 0
                while poz < len(niz):
                    kraj_ = poz
                    while kraj_ + 1 < len(niz) and kj[niz[kraj_ + 1]] == kj[niz[poz]]:
                        kraj_ += 1
                    Lk = float(sum(dulj[j] for j in niz[poz:kraj_ + 1]))
                    if kj[niz[poz]] > 0 and Lk < 8.0:
                        sus_k = [kj[niz[poz - 1]]] if poz > 0 else [0]
                        sus_k += [kj[niz[kraj_ + 1]]] if kraj_ + 1 < len(niz) else [0]
                        novo = min(sus_k)
                        if novo < kj[niz[poz]]:
                            for j in niz[poz:kraj_ + 1]:
                                kj[j] = novo
                            promjena = True
                    poz = kraj_ + 1
                if not promjena:
                    break
            # dijelovi niza s terasama kraći od najmanje duljine ostaju zid
            poz = 0
            while poz < len(niz):
                kraj_ = poz
                while kraj_ + 1 < len(niz) and (kj[niz[kraj_ + 1]] > 0) == (kj[niz[poz]] > 0):
                    kraj_ += 1
                Lk = float(sum(dulj[j] for j in niz[poz:kraj_ + 1]))
                if kj[niz[poz]] > 0 and Lk < float(o["terasa_najmanja_duljina_m"]):
                    for j in niz[poz:kraj_ + 1]:
                        kj[j] = 0
                poz = kraj_ + 1
            bez = float(sum(dulj[j] for j in niz if kj[j] == 0))
            if bez > 0:
                odbijeno["sadrzaj"] += bez
            for j in niz:
                if kj[j] < 1:
                    continue
                k_ = kj[j]
                pas.append(pojas(j, k_))
                K_[j], zr_[j] = k_, zr
                for s_ in range(k_):
                    trake.append({"j": int(j), "kat": k_ - s_, "kota": zr - (k_ - s_) * kat, "geom": pojas(j, s_ + 1, s_)})
                zin[j] = [max(float(pv.kota(*(p0a[j] - k_ * d * m0[j]))[0]), zr), max(float(pv.kota(*(p1a[j] - k_ * d * m1[j]))[0]), zr)]
        sus0 = np.where((nx0 >= 0) & kand[np.maximum(nx0, 0)], nx0, -1)
        sus1 = np.where((nx1 >= 0) & kand[np.maximum(nx1, 0)], nx1, -1)
        self._ter_c.update({"m0": m0, "m1": m1, "sus0": sus0, "sus1": sus1, "pas": unary_union(pas) if pas else None,
                            "trake": trake, "ploca": ploca})
        odbijeno["prostori_nizih_razina"] = float(sum(dulj[j] for j in nizi_razlog if K_[j] == 0))
        self.kstat["terase"] = {
            "duljina_m": round(float(dulj[K_ > 0].sum())), "nizova": len(nizovi), "najvise_kata": int(K_.max()),
            "dubina_m": round(float(K_.max() * d), 1),
            "izvan_obuhvata_m2": 0.0,
            "juzni_vanjski_rub_ukupno_m": round(float(dulj[van & juzno].sum())),
            "kosi_juzni_rub_bez_terasa_m": round(kos_jug),
            "odbijeno_m": {k_: round(v) for k_, v in odbijeno.items()},
            "bez_terase_zbog_prostora_nizih_razina": {id_: {"rub_m": round(v[0], 1), "m2": round(v[1], 1)}
                                                       for id_, v in sorted(nizi_sukobi.items(), key=lambda t: -t[1][0])},
            "definicija": "duljina vanjskog ruba (azimut normale 135–225°) na kojem su terase; isto broji M19 (jug)",
            "status": "PRETPOSTAVKA modela: terase se uvlače unutar ruba razine parka, prizemlje na rubu programa"}
        if pas:
            obuhvat = unary_union([s["geom"] for s in pv.pl])
            self.kstat["terase"]["izvan_obuhvata_m2"] = round(float(unary_union(pas).difference(obuhvat.buffer(0.05)).area), 1)
        return self._ter_c

    def _volumeni_nizih(self):
        """Prostori nižih razina (ispod razine parka) kao volumeni: pod do pod + svijetla visina iz programa; bez
        nje prometni prostori uzimaju visinu profila (portal, autobus 4,5 m), ostali svijetlu visinu razine, a
        zatvoreni bez ičega `visina_zatvorenog_m`. Otvoreni prostori bez visine (dvorište) nemaju strop i
        preskaču se. Služi terasama (V3) i mjeri u izmjeri."""
        if not hasattr(self, "_vol_niz"):
            P, o = self.program, self.ok
            out = []
            for q in P.prostori:
                if q["razina"] >= P.i_park or q["pod"] is None:
                    continue
                h_ = q["visina"]
                if h_ is None and q["kat"] in PROMETNE:
                    h_ = float(o["visina_portala_m"] if q["kat"] != "promet_bus" else 4.5)
                if h_ is None:
                    h_ = P.razine[q["razina"]]["visina"]
                if h_ is None and q["kat"] in ZATVORENE:
                    h_ = float(o["visina_zatvorenog_m"])
                if h_ is None:
                    continue
                out.append({"id": q["id"], "kat": q["kat"], "geom": q["geom"], "pod": float(q["pod"]),
                            "vrh": float(q["pod"]) + float(h_)})
            self._vol_niz = out
        return self._vol_niz

    def _iza_ruba(self, tocka):
        """Kategorija najvišeg prostora nižih razina iza ruba (za vrstu pročelja terase)."""
        import shapely

        P = self.program
        if not hasattr(self, "_niz_stablo"):
            from shapely.strtree import STRtree

            self._niz = [q for q in P.prostori if q["razina"] < P.i_park and q["pod"] is not None]
            self._niz_stablo = STRtree([q["geom"] for q in self._niz]) if self._niz else None
        if self._niz_stablo is None:
            return None
        idx = self._niz_stablo.query(shapely.points(tocka), predicate="intersects")
        if not len(idx):
            return None
        return max((self._niz[int(j)] for j in idx), key=lambda q: q["pod"])["kat"]

    def _gradi_terase(self, ter, sp, st, og):
        """Stepenasti južni rub prema unutra: prizemlje na rubu programa, viši katovi uvučeni, vodoravni katovi.
        Pročelje svakog kata (staklo dvorane, garaža s otvorima ili staklo i stupovi), bijeli vijenac,
        popločena terasa sa zelenom žardinjerom na vanjskom rubu, bočne plohe na krajevima niza."""
        z = self._rub()[0]
        o = self.ok
        kat, d = ter["visina_kata"], ter["d"]
        zh, zd = float(o["zardinjera_m"][0]), float(o["zardinjera_m"][1])
        trava, zel = C["trava"], C["zid_zeleni"]

        def prednja(a, b, lo0, lo1, hi0, hi1, vrsta, s_dulj):
            """Pročelje jednog kata od lo do hi (po krajevima), vijenac 0,8 m na vrhu."""
            v0, v1 = max(hi0 - 0.8, lo0), max(hi1 - 0.8, lo1)
            sp.zid(a, b, v0, v1, hi0, hi1, C["bijelo"])
            if vrsta == "garaza":
                s0, s1 = min(lo0 + 1.2, v0), min(lo1 + 1.2, v1)
                sp.zid(a, b, lo0, lo1, s0, s1, C["beton"])
                st.zid(a, b, s0, s1, v0, v1, C["portal"])
            elif vrsta == "dvorana":
                st.zid(a, b, lo0, lo1, v0, v1, C["staklo_tamno"])
            else:
                f = min(0.6 / max(s_dulj, 0.1), 0.5)
                q = a + (b - a) * f
                sp.zid(a, q, lo0, lo0 + (lo1 - lo0) * f, v0, v0 + (v1 - v0) * f, C["beton"])
                st.zid(q, b, lo0 + (lo1 - lo0) * f, lo1, v0 + (v1 - v0) * f, v1, C["staklo_tamno"])

        def razina(i, t):
            """Kota plohe na udaljenosti t od ruba dijela i (terasa, park iza terasa ili vrh ruba)."""
            K_ = int(ter["kat"][i])
            if K_ <= 0:
                return float(max(z["zt0"][i], z["zt1"][i]))
            s_ = int(t // d)
            if s_ >= K_:
                return float(max(ter["z_unutra"][i]))
            return float(ter["razina"][i] - (K_ - s_) * kat)

        for i in np.nonzero(ter["kat"] > 0)[0]:
            K_ = int(ter["kat"][i])
            zr = float(ter["razina"][i])
            p0, p1, n = z["p0"][i], z["p1"][i], z["n"][i]
            m0, m1 = ter["m0"][i], ter["m1"][i]
            zb0, zb1 = z["zb0"][i], z["zb1"][i]
            zi0, zi1 = ter["z_unutra"][i]
            dulj = float(np.hypot(*(p1 - p0)))
            iza = self._iza_ruba(tuple(((p0 + p1) / 2) - (K_ * d + 3.0) * n))
            vrsta = "dvorana" if iza in ("sport_zatvoreni", "kultura", "komercijala", "ugostiteljstvo", "zdravlje") else \
                ("garaza" if iza in ("garaza", "logistika", "tehnika") else "ostalo")
            L = lambda k: zr - k * kat  # noqa: E731  razina terase k (1 = najviša)
            tocke = lambda t: (p0 - t * m0, p1 - t * m1)  # noqa: E731
            for k in range(K_ + 1):
                a, b = tocke((K_ - k) * d)      # pročelje k: najniže (k = K_) na rubu, najviše (k = 0) najdublje
                hi0, hi1 = (zi0, zi1) if k == 0 else (L(k), L(k))
                lo0, lo1 = (zb0, zb1) if k == K_ else (L(k + 1), L(k + 1))
                if max(hi0 - lo0, hi1 - lo1) > 0.05:
                    prednja(a, b, lo0, lo1, hi0, hi1, vrsta, dulj)
                if k == 0:
                    og.zid(a, b, zi0, zi1, zi0 + o["ograda_m"], zi1 + o["ograda_m"], C["bijelo"])
                    continue
                # terasa k od pročelja k (vanjski rub) do pročelja k−1 (unutarnji rub), na koti L(k)
                a_, b_ = tocke((K_ - k + 1) * d)
                hk = L(k)
                sp.kvad((a_[0], a_[1], hk), (a[0], a[1], hk), (b[0], b[1], hk), (b_[0], b_[1], hk), C["kamen"])
                w = min(zd, 0.45 * d) / d
                ua, ub = a + (a_ - a) * w, b + (b_ - b) * w
                sp.zid(a, b, hk, hk, hk + zh, hk + zh, zel)
                sp.zid(ub, ua, hk, hk, hk + zh, hk + zh, zel)
                sp.kvad((a[0], a[1], hk + zh), (b[0], b[1], hk + zh), (ub[0], ub[1], hk + zh), (ua[0], ua[1], hk + zh), trava)
            # bočne plohe na krajevima: od vlastite razine do razine susjeda (ako je viša)
            for kraj, p, m, sus in ((0, p0, m0, ter["sus0"][i]), (1, p1, m1, ter["sus1"][i])):
                for s_ in range(K_):
                    t0, t1 = s_ * d, (s_ + 1) * d
                    vl = float(zr - (K_ - s_) * kat)
                    if sus >= 0 and ter["kat"][sus] > 0:
                        sv = razina(int(sus), t0 + 0.5 * d)
                    else:
                        zt_ = z["zt0"][i] if kraj == 0 else z["zt1"][i]
                        zi_ = zi0 if kraj == 0 else zi1
                        sv = float(zt_ + (zi_ - zt_) * (t0 + 0.5 * d) / (K_ * d))
                    if sv - vl <= 0.05:
                        continue
                    a_, b_ = p - t0 * m, p - t1 * m
                    if kraj == 0:
                        sp.zid(a_, b_, vl, vl, sv, sv, C["beton"])
                    else:
                        sp.zid(b_, a_, vl, vl, sv, sv, C["beton"])

    def _gradi_zidove(self):
        pv, o = self.povrsina, self.ok
        r = self._rub()
        if r is None:
            return
        z, h, portal, hp, popis = r
        n = len(z["az"])
        self._zidovi = {**z, "h": h, "portal": portal}
        sp, st, og = Spremnik(), Spremnik(), Spremnik()
        zs = Spremnik()   # zelena lica zidova (penjačice; krug 3: vlastiti materijal sa šumom i reljefom)
        ter = self._plan_terasa()
        if ter is not None and ter["pas"] is not None:
            self._gradi_terase(ter, sp, st, og)
            import shapely

            unutar_pasa = ter["pas"].buffer(-0.3)
            shapely.prepare(unutar_pasa)
            sred = (z["p0"] + z["p1"]) / 2
            u_pasu = shapely.contains_xy(unutar_pasa, sred[:, 0], sred[:, 1]) & (ter["kat"] == 0)
        else:
            u_pasu = np.zeros(n, bool)
        rng = np.random.default_rng(int(o["sjeme"]) + 11)
        kat = float(o["kat_procelja_m"])
        broj = {"pokos": 0, "procelje": 0, "zeleni_zid": 0, "rub_pokrova": 0, "potporni": 0, "otvor": 0, "portal_slika": 0}
        for i in range(n):
            p0, p1 = z["p0"][i], z["p1"][i]
            zb0, zb1, zt0, zt1 = z["zb0"][i], z["zb1"][i], z["zt0"][i], z["zt1"][i]
            hi, az, van = h[i], z["az"][i], bool(z["vanjski"][i])

            def traka(a, b, boja, s=sp, f0=0.0, f1=1.0):
                """Traka zida između visina a i b iznad dna (b=None: do vrha), na dijelu f0..f1 duljine."""
                q0, q1 = p0 + (p1 - p0) * f0, p0 + (p1 - p0) * f1
                ba, bb = zb0 + (zb1 - zb0) * f0, zb0 + (zb1 - zb0) * f1
                ta, tb = zt0 + (zt1 - zt0) * f0, zt0 + (zt1 - zt0) * f1
                z10 = ta if b is None else min(ba + b, ta)
                z11 = tb if b is None else min(bb + b, tb)
                s.zid(q0, q1, min(ba + a, z10), min(bb + a, z11), z10, z11, boja)

            ton = 1.0 + 0.10 * (rng.random() - 0.5)
            zeleni = tuple(c * ton for c in C["zid_zeleni"])
            duljina = float(np.hypot(*(p1 - p0)))
            stup = min(0.45 / max(duljina, 0.1), 0.5)   # udio duljine koji zauzima stup pročelja
            if u_pasu[i]:
                continue   # unutarnji rub koji je pojas terasa izrezao iz plohe
            if hi < 0.9:
                traka(0.0, None, tuple(c * ton for c in C["pokos"]))
                broj["pokos"] += 1
                continue
            # pročelje s katovima samo na južnom rubu s približno vodoravnim vrhom (M19, krug 3);
            # kosi rub ostaje zeleni zid
            juzno = bool(ter["juzno"][i] and ter["vodoravno"][i]) if ter is not None else \
                (o["terase_azimut"][0] <= az <= o["terase_azimut"][1] and abs(zt1 - zt0) <= o["terase_nagib"] * max(duljina, 1.0))
            if portal[i] and z["praznina"][i] and van:
                traka(hp[i], hp[i] + 0.9, C["bijelo"])
                traka(hp[i] + 0.9, None, C["beton"])
                broj["otvor"] += 1
            elif portal[i]:
                traka(0.0, hp[i], C["portal"] if portal[i] in (1, 2) else C["ulaz"], s=st)
                traka(hp[i], hp[i] + 0.4, C["bijelo"])
                traka(hp[i] + 0.4, None, C["beton"])
                broj["portal_slika"] += 1
            elif ter is not None and ter["kat"][i] > 0:
                broj["terasa"] = broj.get("terasa", 0) + 1   # izgrađeno u _gradi_terase (i ograda)
                continue
            elif hi >= 3.0 and juzno:
                traka(0.0, 0.5, C["beton_tamni"])
                a = 0.5
                while a + kat <= hi - 0.3 + 1e-6:
                    traka(a, a + kat - 1.0, C["beton"], f1=stup)
                    traka(a, a + kat - 1.0, C["staklo_tamno"], s=st, f0=stup)
                    traka(a + kat - 1.0, a + kat, C["bijelo"])
                    a += kat
                traka(a, None, C["beton"])
                broj["procelje"] += 1
            elif van and z["praznina"][i]:
                vrh = max(hi - 1.0, 0.0)
                traka(0.0, min(1.0, vrh), C["kamen"])
                if i % 4 == 0:
                    traka(1.0, vrh, C["beton"], f1=min(0.7 / max(duljina, 0.1), 1.0))
                    traka(1.0, vrh, zeleni, s=zs, f0=min(0.7 / max(duljina, 0.1), 1.0))
                else:
                    traka(1.0, vrh, zeleni, s=zs)
                traka(vrh, None, C["bijelo"])
                broj["rub_pokrova"] += 1
            elif van:
                traka(0.0, max(hi - 0.5, 0.0), zeleni, s=zs)
                traka(max(hi - 0.5, 0.0), None, C["beton"])
                broj["zeleni_zid"] += 1
            else:
                traka(0.0, None, tuple(c * ton for c in C["beton"]))
                broj["potporni"] += 1
            if van and z["praznina"][i]:
                # unutarnja strana ruba pokrova (u tunelu) je beton, 0,3 m od vanjske; do podgleda i 0,4 m u ploču
                deb = float(o["debljina_pokrova_m"])
                nn_ = z["n"][i] * 0.3
                dno = hp[i] if portal[i] else 0.0
                vr0, vr1 = zt0 - deb + 0.4, zt1 - deb + 0.4
                if min(vr0 - zb0, vr1 - zb1) > dno + 0.2:
                    sp.zid(p1 - nn_, p0 - nn_, zb1 + dno, zb0 + dno, vr1, vr0, C["beton"])
            if hi >= 1.5:
                og.zid(p0, p1, zt0, zt1, zt0 + o["ograda_m"], zt1 + o["ograda_m"], C["bijelo"])
        self._objekt("zidovi", sp, "procelja")
        self._objekt("zidovi_zeleni", zs, "procelja", "penjacice")
        self._objekt("procelja_staklo", st, "procelja", "sjaj")
        self._objekt("ograde", og, "staklo", "staklo")
        self.kstat["broj"]["dijelova_zida"] = broj
        self.kstat["portali"] = popis

    # --- prostor pod pokrovom: podgled, pod, unutarnji zidovi -----------------------------------
    def _gradi_prazninu(self):
        import shapely
        from shapely.geometry.polygon import orient
        from shapely.ops import unary_union

        pv, o = self.povrsina, self.ok
        V = pv.V
        self._dijelovi_tla = []
        if V is None:
            return
        deb = float(o["debljina_pokrova_m"])
        svj = unary_union([s["geom"] for s in pv.svj]).buffer(0.02) if pv.svj else None
        g = V.difference(svj) if svj is not None else V
        # krug 4 (V3): pojas terasa izrezan i iz podgleda (podgled na koti parka − ploča lebdio bi nad terasom)
        ter = self._plan_terasa()
        if ter is not None and ter["pas"] is not None:
            g = g.difference(ter["pas"].buffer(0.05))
        # podgled po prostoru plohe (ploča prati svoj prostor), a između prostora različite kote okomita greda:
        # jedinstveno polje kota preko stepenastog ruba (rampa uz pokrov) davalo je pilu na rubu podgleda
        dijelovi_p, pokriveno = [], []
        shapely.prepare(g)
        for s in pv.pl:
            if not g.intersects(s["geom"]):
                continue
            gs = g.intersection(s["geom"])
            if gs.is_empty or gs.area < 0.5:
                continue
            r = pv.mreza_podrucja(gs, lambda x, y, s=s: pv.z_prostora(s, x, y) - deb)
            if r is not None:
                dijelovi_p.append(r)
                pokriveno.append(gs)
        ostatak = g.difference(unary_union(pokriveno).buffer(0.01)) if pokriveno else g
        if not ostatak.is_empty and ostatak.area > 0.5:
            r = pv.mreza_podrucja(ostatak, lambda x, y: pv.z_vrha(x, y) - deb)
            if r is not None:
                dijelovi_p.append(r)
        if dijelovi_p:
            self._objekt_polja("podgled_pokrova", dijelovi_p, "procelja", self._mat("podgled"), None, obrni=True, glatko=False)
        zg = getattr(self, "_zidovi", None)
        if zg is not None and len(zg["az"]):
            gr = Spremnik()
            mid = (zg["p0"] + zg["p1"]) / 2
            u = (zg["drugi"] >= 0) & shapely.contains_xy(g, mid[:, 0], mid[:, 1])
            for i in np.nonzero(u)[0]:
                gr.zid(zg["p0"][i], zg["p1"][i], zg["zb0"][i] - deb, zg["zb1"][i] - deb, zg["zt0"][i] - deb, zg["zt1"][i] - deb,
                       C["beton"])
            self._objekt("podgled_grede", gr, "procelja")
        r = pv.mreza_podrucja(V, lambda x, y: self.tlo_n(x, y) + 0.10)
        if r is not None:
            self._dijelovi_tla.append(r)
        sp = Spremnik()
        Fb = pv.F.boundary
        for pol in _poligoni(V, 0.0):
            pol = orient(pol, 1.0)
            for prsten in [pol.exterior] + list(pol.interiors):
                c = np.asarray(prsten.coords)
                for a, b in zip(c[:-1], c[1:]):
                    l = float(np.hypot(*(b - a)))
                    if l < 0.05:
                        continue
                    # gusto (0,75 m) i 0,4 m u ploču iznad podgleda: vrh zida prati podgled bez zubaca
                    k = max(int(math.ceil(l / 0.75)), 1)
                    t = np.linspace(0, 1, k + 1)
                    pts = a[None, :] + (b - a)[None, :] * t[:, None]
                    mids = (pts[:-1] + pts[1:]) / 2
                    d = shapely.distance(Fb, shapely.points(mids))
                    zv = pv.z_vrha(pts[:, 0], pts[:, 1])
                    # vrh zida do 0,3 m ispod plohe parka: uvijek iznad ruba podgleda (podgled ga zaklanja), pa
                    # spoj nema procjepa ni zubaca ni kad strop uz rub strmo pada (rampa, kosina)
                    zt = np.maximum(zv, pv.kota(pts[:, 0], pts[:, 1])) - 0.3
                    zb = self.tlo_n(pts[:, 0], pts[:, 1]) - 0.3
                    for j in range(k):
                        if d[j] < 1.0:
                            continue
                        sp.zid(pts[j], pts[j + 1], zb[j], zb[j + 1], zt[j], zt[j + 1], C["beton"])
        self._objekt("zidovi_pod_pokrovom", sp, "procelja")
        self.kstat["broj"]["pod_pokrovom_m2"] = round(float(V.area) * 1.0069)

    # --- svjetlarnici ----------------------------------------------------------------------------
    def _gradi_svjetlarnike(self):
        from shapely.geometry.polygon import orient

        pv, o, P = self.povrsina, self.ok, self.program
        deb = float(o["debljina_pokrova_m"])
        staklo, okvir, unutra = Spremnik(), Spremnik(), Spremnik()
        boje_unutra = {"sport_zatvoreni": C["drvo"], "garaza": C["beton_tamni"], "topli_put": lin((222, 204, 176)),
                       "promet_cesta": C["asfalt"], "promet_tramvaj": C["asfalt"], "promet_bus": C["asfalt"]}
        nad_cestom = 0
        for sv in pv.svj:
            for pol in _poligoni(sv["geom"], 1.0):
                pol = orient(pol, 1.0)
                ring = np.asarray(pol.exterior.coords)[:-1]
                m = len(ring)
                zs = pv.z_vrha(ring[:, 0], ring[:, 1])
                zp = zs   # dno okna = podgled susjednog prostora
                nad = pv.V is not None and pol.intersection(pv.V).area > 0.5 * pol.area
                nad_cestom += int(nad)
                lanterna = sv["pod"] is not None and sv["pod"] > float(zs.max()) + 0.6
                zg = np.full(m, sv["pod"]) if lanterna else zs + 0.4
                staklo.dodaj([(x, y, zz) for (x, y), zz in zip(ring, zg)], [tuple(range(m))], (1, 1, 1))
                for k in range(m):
                    k2 = (k + 1) % m
                    (staklo if lanterna else okvir).zid(ring[k], ring[k2], zs[k], zs[k2], zg[k], zg[k2], C["bijelo"])
                    okvir.zid(ring[k2], ring[k], zp[k2] - deb, zp[k] - deb, zs[k2], zs[k], C["bijelo"])
                # prečke stakla na pravokutnim svjetlarnicima
                ok_ = _Okvir(pol)
                if pol.area > 0.9 * ok_.L * ok_.W and ok_.L > 4:
                    nb = max(int(round(ok_.L / 3.0)), 1)
                    for i in range(nb + 1):
                        a = ok_.L * i / nb
                        q = ok_.pravokutnik(max(a - 0.07, 0), 0.0, min(a + 0.07, ok_.L), ok_.W)
                        zq = (np.full(4, sv["pod"]) if lanterna else pv.z_vrha(q[:, 0], q[:, 1]) + 0.4) + 0.04
                        okvir.dodaj([(x, y, zz) for (x, y), zz in zip(q, zq)], [(0, 1, 2, 3)], C["bijelo"])
                if not nad:
                    c = pol.representative_point()
                    ispod = [s for s in P.prostori if s["razina"] < P.i_park and s["pod"] is not None and s["geom"].contains(c)]
                    if ispod:
                        s0 = max(ispod, key=lambda s: s["pod"])
                        zf = max(s0["pod"], float(zg.min()) - 9.0)
                        boja = boje_unutra.get(s0["kat"], C["beton"])
                    else:
                        zf, boja = float(zg.min()) - 5.0, C["beton"]
                    unutra.dodaj([(x, y, zf) for x, y in ring], [tuple(range(m))], boja)
                    for k in range(m):
                        k2 = (k + 1) % m
                        unutra.zid(ring[k2], ring[k], zf, zf, zs[k2] - deb, zs[k] - deb, lin((214, 212, 206)))
        self._objekt("svjetlarnici_staklo", staklo, "staklo", "staklo")
        self._objekt("svjetlarnici_okvir", okvir, "staklo")
        self._objekt("svjetlarnici_unutra", unutra, "procelja")
        self.kstat["broj"]["svjetlarnika"] = len(pv.svj)
        self.kstat["broj"]["svjetlarnika_nad_prometom"] = nad_cestom

    # --- prizemlje: pod ispod pokrova, tvrde plohe na tlu, zatvoreni prostori izvan parka -----------
    def _gradi_prizemlje(self):
        from shapely.geometry import LineString
        from shapely.ops import unary_union

        pv, P, o = self.povrsina, self.program, self.ok
        if not o["prizemlje"] and not self._dijelovi_tla:
            return
        zauzeto = [pv.F] if pv.F is not None else []
        if P.stadion:
            zauzeto.append(P.stadion["vanjski"])
        zauzeto = unary_union(zauzeto).buffer(0.05) if zauzeto else None
        plohe, kutije = [], []
        if o["prizemlje"]:
            for s in P.prostori:
                if s["razina"] >= P.i_park:
                    continue
                g = s["geom"].difference(zauzeto) if zauzeto is not None else s["geom"]
                if s["kat"] in TVRDO_TLO and g.area > 20:
                    plohe.append((s, g))
                elif s["kat"] in (ZATVORENE | {"stadion"}) and g.area > 40:
                    kutije.append((s, g))
        pod = [s for s in P.prostori if s["razina"] < P.i_park and s["kat"] in PROMETNE]
        if not plohe and not self._dijelovi_tla and not kutije:
            return
        geomi = [g for _, g in plohe] + ([pv.V] if pv.V is not None else [])
        if geomi:
            b = np.array([q.bounds for q in geomi])
            r = max(float(o["tekstura_m"]), 0.25)
            T = Tekstura((b[:, 0].min() - 2, b[:, 1].min() - 2, b[:, 2].max() + 2, b[:, 3].max() + 2), r, RGB["asfalt"])
            T.zeleno.paste(0, (0, 0, T.w, T.h))

            def boja_prometa(s):
                if re.search(r"nogostup|pjesa|bicikl|peron|predvorj", s["tekst_sve"]):
                    return RGB["nogostup"]
                return (88, 88, 90) if s["kat"] == "promet_tramvaj" else RGB["asfalt"]

            for s in sorted(pod, key=lambda q: -q["geom"].area):
                T.ispuni(s["geom"], boja_prometa(s))
            for s, g in plohe:
                if s["kat"] == "trg_predvorje":
                    T.ispuni(g, RGB["trg"])
                elif s["kat"] == "staza":
                    T.ispuni(g, RGB["staza"])
                elif s["kat"] == "sport_otvoreni":
                    _crtaj_sport(T, {**s, "geom": g})
                elif s["kat"] == "voda":
                    T.ispuni(g, RGB["voda"])
                else:
                    T.ispuni(g, boja_prometa(s))
            for pr in (self.site.get("tramvaj") or {}).get("pruge") or []:
                l = pr.get("linija") or []
                if len(l) >= 2:
                    ls = LineString(l)
                    for pomak in (-0.5, 0.5):
                        try:
                            q = ls.parallel_offset(abs(pomak), "left" if pomak < 0 else "right")
                            for dio in ([q] if q.geom_type == "LineString" else list(q.geoms)):
                                T.linija(np.asarray(dio.coords), RGB["tracnica"], 0.25)
                        except Exception:  # noqa: BLE001
                            pass
            self.tex_tlo = T
            mat = self._mat_tekstura("k_tlo", T.spremi(self._tmp("koncept_tlo.png")))
            dij = list(self._dijelovi_tla)
            for s, g in plohe:
                rr = pv.mreza_podrucja(g, lambda x, y: self.tlo_n(x, y) + 0.2)
                if rr is not None:
                    dij.append(rr)
            self._objekt_polja("prizemlje_plohe", dij, "park", mat, T, glatko=True)
        sp, st = Spremnik(), Spremnik()
        for s, g in kutije:
            for pol in _poligoni(g, 40.0):
                pol = pol.simplify(0.2)
                vrh = (s["pod"] if s["pod"] is not None else float(self.tlo_n(pol.centroid.x, pol.centroid.y))) + \
                    (s["visina"] or o["visina_zatvorenog_m"]) + 0.4
                tlo = float(self.tlo_n(pol.centroid.x, pol.centroid.y))
                if vrh - tlo < 2.0:
                    continue
                sp.prizma(pol, lambda x, y: self.tlo_n(x, y) - 0.5, vrh, lin((206, 204, 198)), lin((150, 150, 148)), self._trokuti)
        self._objekt("zatvoreno_izvan_parka", sp, "procelja")
        self.kstat["broj"]["tvrdih_ploha_na_tlu"] = len(plohe)
        self.kstat["broj"]["zatvorenih_izvan_parka"] = len(kutije)
        if o["unutrasnjost"]:
            self._gradi_unutrasnjost()

    def _gradi_unutrasnjost(self):
        """Kutije prostora nižih razina na stvarnim kotama, u bojama kategorija (za presječnu perspektivu)."""
        P, o = self.program, self.ok
        sp = Spremnik()
        for s in P.prostori:
            if s["razina"] >= P.i_park or s["pod"] is None:
                continue
            raz = P.razine[s["razina"]]
            h = s["visina"] or raz["visina"] or (o["visina_zatvorenog_m"] if s["kat"] in ZATVORENE else 0.3)
            b = lin(BOJE_KAT.get(s["kat"], "#cccccc"))
            for pol in _poligoni(s["geom"], 4.0):
                sp.prizma(pol.buffer(-0.25).simplify(0.2) if pol.area > 30 else pol, s["pod"] + 0.05, s["pod"] + h - 0.3,
                          b, tuple(c * 0.9 for c in b), self._trokuti) if not pol.buffer(-0.25).is_empty and \
                    pol.buffer(-0.25).geom_type == "Polygon" else None
        self._objekt("unutrasnjost", sp, "procelja")

    # --- stadion -----------------------------------------------------------------------------------
    def _svjetlo_zdjele(self, c, z_igr, kr):
        """Ispuna unutrašnjosti zdjele (završna obrada 15.11.2026.): render ima samo 2 difuzna odbijanja, pa je
        dio igrališta i tribina u sjeni krova bio crn (otvor krova izvana kao crna ploha). Pravokutno svjetlo u
        otvoru krova, usmjereno dolje, bez sjena, svijetli SAMO igralište i tribine (light linking): ne mijenja
        svjetlo ni sjene izvan zdjele. Jakost `svjetlo_zdjele` je približna ozračenost (W/m²) ispod otvora.
        PRETPOSTAVKA, samo izgled: zamjenjuje odbijeno svjetlo neba, nije izvor svjetla na stadionu."""
        E = float(self.ok.get("svjetlo_zdjele", 0.0) or 0.0)
        bpy = self.bpy
        prim = [bpy.data.objects.get(n) for n in ("stadion_tribine", "stadion_igraliste")]
        prim = [o_ for o_ in prim if o_ is not None]
        if E <= 0 or not prim or not kr:
            return
        from shapely.geometry import Polygon

        unut = kr["unut"] if not isinstance(kr["unut"], (list, tuple)) else Polygon(kr["unut"])
        x0, y0, x1, y1 = unut.bounds
        z_rub = kr["rub"] if kr.get("rub") is not None else (kr["vrh"] - 8.0)
        xm, ym = SC.m_iz_n(np.array([(x0 + x1) / 2]), np.array([(y0 + y1) / 2]))
        sx, sy = (x1 - x0) * 1.15, (y1 - y0) * 1.15
        L = bpy.data.lights.new("svjetlo_zdjele", type="AREA")
        L.shape = "RECTANGLE"
        L.size, L.size_y = float(sx), float(sy)
        L.energy = float(E * sx * sy)
        if hasattr(L, "use_shadow"):
            L.use_shadow = False
        if hasattr(L, "cycles") and hasattr(L.cycles, "cast_shadow"):
            L.cycles.cast_shadow = False
        ob = bpy.data.objects.new("svjetlo_zdjele", L)
        ob.location = (float(xm[0]), float(ym[0]), float(z_rub) - 1.0)
        self.zbirka("koncept").objects.link(ob)
        ob.visible_camera = False
        ob.visible_glossy = False
        zb = bpy.data.collections.new("primatelji_zdjele")
        for o_ in prim:
            zb.objects.link(o_)
        ob.light_linking.receiver_collection = zb
        self.kstat["pretpostavke"].append(
            f"ispuna zdjele stadiona: svjetlo bez sjena samo na igralištu i tribinama, oko {E:g} W/m² (samo izgled)")

    def _gradi_stadion_koncepta(self):
        P, o = self.program, self.ok
        st = P.stadion
        if not st:
            return
        c = np.asarray(st["sredina"], dtype=np.float64)
        K_ = 240
        kut = np.linspace(0, 2 * math.pi, K_, endpoint=False)
        smjer = np.stack([np.cos(kut), np.sin(kut)], 1)

        def prsten(r, z):
            r = np.broadcast_to(np.asarray(r, dtype=np.float64), (K_,))
            z = np.broadcast_to(np.asarray(z, dtype=np.float64), (K_,))
            return np.column_stack([c[0] + r * smjer[:, 0], c[1] + r * smjer[:, 1], z])

        pr = st["procelje"] or {}
        z_dna = pr.get("dno") if pr.get("dno") is not None else (self.povrsina.kota_podija or 0.0)
        z_igr = P.kota_igralista(o["kota_igralista"])
        r_van = _polumjeri(st["vanjski"], c, kut)
        sp, tamno = Spremnik(), Spremnik()
        prolaz = (np.arange(K_) % 16) == 0
        opis = {"kota_igralista": z_igr, "tribine": []}
        # igralište i pojas oko njega (tekstura parka nosi travnjak i linije)
        if st["tribine"]:
            apron = st["tribine"][0]["unut"]
            rr = self.povrsina.mreza_podrucja(apron, lambda x, y: np.full(np.shape(x), z_igr))
            if rr is not None:
                ob = self._objekt_polja("stadion_igraliste", [rr], "stadion", self.mat_park, self.tex_park, glatko=False)
        najvisi = z_dna
        _sj = _sjever_zrake(st, c, kut)
        _m = _sj["maska"] if _sj is not None else np.zeros(K_, bool)

        def _rn(d):
            return _sj["r0"] + np.minimum(d, _sj["dmax"]) * _sj["k"] if _sj is not None else 0.0

        def _zn(d):
            return np.interp(np.minimum(d, _sj["dmax"]), _sj["pd"], _sj["pz"]) if _sj is not None else 0.0

        def _w(a, b):
            return np.where(_m, b, a) if _sj is not None else a

        for it, t in enumerate(st["tribine"]):
            r0, r1 = _polumjeri(t["unut"], c, kut), _polumjeri(t["vanj"], c, kut)
            r1 = np.maximum(r1, r0 + 0.5)
            n = int(np.clip(round(float(np.mean(r1 - r0)) / o["red_tribine_m"]), 2, 70))
            dz = (t["vrh"] - t["dno"]) / n
            da, db = float(t.get("d0", 0.0)), float(t.get("d1", 21.0))
            zadnja = it == len(st["tribine"]) - 1
            if zadnja and _sj is not None:
                db = float(_sj["pd"][-1])
            if it == 0:
                sp.trake([prsten(_w(r0, _rn(da)), z_igr), prsten(_w(r0, _rn(da)), _w(t["dno"], _zn(da)))], [C["plava_tamna"]])
            else:
                sp.trake([prsten(_w(r0, _rn(da)), _w(t["dno"] - 1.3, _zn(da))), prsten(_w(r0, _rn(da)), _w(t["dno"], _zn(da)))],
                         [C["bijelo"]])
                sp.trake([prsten(_w(r1, _rn(da)), _w(t["vrh"] - 1.3, _zn(da))), prsten(_w(r0, _rn(da)), _w(t["dno"] - 1.3, _zn(da)))],
                         [C["beton_tamni"]])
            prstenovi, boje = [], []
            for j in range(n):
                ra, rb = r0 + (r1 - r0) * j / n, r0 + (r1 - r0) * (j + 1) / n
                h = t["dno"] + dz * j
                dj, dj1 = da + (db - da) * j / n, da + (db - da) * (j + 1) / n
                ton = 1.0 + 0.06 * ((j % 2) - 0.5)
                sjed = [C["beton"] if p else tuple(v * ton for v in C["sjedala"]) for p in prolaz]
                hh = _w(h, _zn(dj))
                prstenovi += [prsten(_w(ra, _rn(dj)), hh), prsten(_w(rb, _rn(dj1)), hh)]
                boje += [sjed, C["plava_tamna"]]
            prstenovi.append(prsten(_w(r1, _rn(db)), _w(t["vrh"] + 1.1, _zn(db) + (1.1 if zadnja else 0.0))))
            sp.trake(prstenovi, boje[:len(prstenovi) - 1])
            najvisi = max(najvisi, t["vrh"])
            opis["tribine"].append({"naziv": t["naziv"], "redova": n, "dno": t["dno"], "vrh": t["vrh"]})
            if it == 0:  # obodni hodnik u razini podija; na sjeveru ga nema (kosa ploha kroz razine)
                sp.trake([prsten(_w(r1, _rn(db)), _w(t["vrh"], _zn(db))),
                          prsten(_w(np.maximum(r_van - 1.0, r1 + 0.2), _rn(db)), _w(z_dna, _zn(db)))], [C["trg"]])
        if _sj is not None:
            opis["sjever"] = {"izvor": "program.json stadion.sjever", "kutova": int(_m.sum()),
                              "od_mnv": float(_sj["pz"][0]), "do_mnv": float(_sj["pz"][-1]),
                              "napomena": "jedna kosa ploha bez srednjeg prstena; stepenasta po redovima modela"}
        # krov: bijeli prsten; kota_ruba = unutarnji rub nad igralištem, kota_vrha = vanjski vijenac (PRETPOSTAVKA)
        kr = st["krov"]
        z_vrh_proc = pr.get("vrh")
        z_podgled_van = None
        if (not kr or kr["vrh"] is None) and st["tribine"]:
            # program ne zadaje krov: zadani prsten od unutarnjeg ruba tribina do vanjskog obrisa (PRETPOSTAVKA)
            kr = {"unut": st["tribine"][0]["unut"].buffer(-2.0) if not st["tribine"][0]["unut"].buffer(-2.0).is_empty
                  else st["tribine"][0]["unut"], "vanj": st["vanjski"],
                  "vrh": (kr or {}).get("vrh") or float(o["vrh_krova_mnv"]), "rub": (kr or {}).get("rub")}
            self.kstat["pretpostavke"].append(f"krov stadiona nije u programu: zadani prsten, vrh {kr['vrh']:.1f} m n. v.")
        if kr and kr["vrh"] is not None:
            ru, rv = _polumjeri(kr["unut"], c, kut), _polumjeri(kr["vanj"], c, kut)
            z_vrh = kr["vrh"]
            z_rub = kr["rub"] if kr["rub"] is not None else z_vrh - 8.0
            vij = float(np.clip(z_vrh - z_vrh_proc, 2.0, 7.0)) if z_vrh_proc is not None else float(o["vijenac_krova_m"])
            z_podgled_van = z_vrh - vij
            krov = Spremnik()
            krov.trake([prsten(ru, z_rub), prsten(ru, z_rub + 0.9), prsten(rv, z_vrh), prsten(rv, z_podgled_van),
                        prsten(ru, z_rub)], [(1, 1, 1)] * 4)
            ob = self._objekt("stadion_krov", krov, "stadion", "krov")
            opis["krov"] = {"unutarnji_rub": z_rub, "vrh": z_vrh, "vijenac_m": round(vij, 1)}
            self.kstat["pretpostavke"].append("krov stadiona: kota_ruba je unutarnji rub nad igralištem, kota_vrha vanjski vijenac")
        # pročelje: tamna staklena opna, topla stakla u podnožju, okomite plave lamele
        z_vrh_l = z_vrh_proc if z_vrh_proc is not None else (z_podgled_van or najvisi + 6.0)
        z_opne = z_podgled_van if z_podgled_van is not None else z_vrh_l
        r_opne = np.maximum(r_van - 1.0, 1.0)
        tamno.trake([prsten(r_opne, z_dna), prsten(r_opne, min(z_dna + 4.5, z_opne))], [lin((150, 122, 88))])
        tamno.trake([prsten(r_opne, min(z_dna + 4.5, z_opne)), prsten(r_opne, z_opne)], [C["staklo_tamno"]])
        self._objekt("stadion_tribine", sp, "stadion")
        self._objekt("stadion_opna", tamno, "stadion", "opna")
        lam = Spremnik(metricki=True)
        obris = np.asarray(st["vanjski"].exterior.coords)
        xm, ym = SC.m_iz_n(obris[:, 0], obris[:, 1])
        pm = np.column_stack([xm, ym])
        from shapely.geometry import Polygon

        if Polygon(pm).exterior.is_ccw is False:
            pm = pm[::-1]
        seg = np.hypot(*(pm[1:] - pm[:-1]).T)
        s_uk = np.r_[0, np.cumsum(seg)]
        razmak = max(float(pr.get("razmak") or 3.0), 0.8)
        n_l = max(int(round(s_uk[-1] / razmak)), 8)
        dub, deb = float(o["dubina_lamele_m"]), float(o["debljina_lamele_m"])
        rng = np.random.default_rng(int(o["sjeme"]) + 21)
        for k in range(n_l):
            s_ = s_uk[-1] * k / n_l
            i = min(int(np.searchsorted(s_uk, s_, side="right")) - 1, len(seg) - 1)
            t_ = (pm[i + 1] - pm[i]) / max(seg[i], 1e-9)
            p = pm[i] + t_ * (s_ - s_uk[i])
            nrm = np.array([t_[1], -t_[0]])
            ton = 1.0 + 0.12 * (rng.random() - 0.5)
            lam.kutija(p + nrm * (0.2 - dub / 2), t_, nrm, deb / 2, dub / 2, z_dna + 0.05, z_vrh_l,
                       tuple(v * ton for v in C["plava"]))
        self._objekt("stadion_lamele", lam, "stadion", "lamele")
        self._svjetlo_zdjele(c, z_igr, kr)
        opis["procelje"] = {"dno": z_dna, "vrh_lamela": z_vrh_l, "lamela": n_l, "razmak_m": round(s_uk[-1] / n_l, 2)}
        self.kstat["stadion"] = opis

    # --- elementi na parku ----------------------------------------------------------------------------
    def _gradi_elemente(self):
        from shapely.geometry import Point

        pv, P, o = self.povrsina, self.program, self.ok
        if not o["elementi"]:
            return
        sp, st, stk = Spremnik(), Spremnik(), Spremnik()
        rng = np.random.default_rng(int(o["sjeme"]) + 31)
        broj = {"paviljona": 0, "spomenika": 0, "stela": 0, "tribina": 0, "dizala": 0, "stubista": 0, "okna_u_svjetlarniku": 0}
        sportski = [s for s in pv.pl if s["kat"] == "sport_otvoreni"]
        ter = self._plan_terasa()
        pas_t = ter["pas"].buffer(0.5) if ter is not None and ter["pas"] is not None else None
        for s in pv.pl:
            g, kat = s["geom"], s["kat"]
            zf = lambda x, y, s=s: pv.z_prostora(s, x, y)  # noqa: E731
            if kat in ZATVORENE - {"kultura"} or (kat == "kultura" and s["visina"]):
                h = s["visina"] or o["visina_paviljona_m"]
                for pol in _poligoni(g, 6.0):
                    z0 = float(np.min(zf(*np.asarray(pol.exterior.coords).T)))
                    st.prizma(pol.simplify(0.1), z0, z0 + h, C["staklo_tamno"], C["staklo_tamno"], self._trokuti)
                    krov = pol.buffer(0.9, join_style=2).simplify(0.1)
                    sp.prizma(krov, z0 + h, z0 + h + 0.35, C["bijelo"], C["bijelo"], self._trokuti)
                    broj["paviljona"] += 1
            elif kat == "kultura":
                for pol in _poligoni(g, 2.0):
                    cc = pol.centroid
                    z0 = float(zf(cc.x, cc.y))
                    ok_ = _Okvir(pol)
                    sp.prizma(pol.buffer(-0.3) if pol.buffer(-0.3).geom_type == "Polygon" and not pol.buffer(-0.3).is_empty
                              else pol, z0, z0 + 0.4, C["kamen"], C["kamen"], self._trokuti)
                    n = int(np.clip(pol.area / 40.0, 1, 7))
                    for i in range(n):
                        a = ok_.L * (i + 0.5) / n
                        q = ok_.t(a, ok_.W / 2 + rng.uniform(-0.15, 0.15) * ok_.W)
                        vis = rng.uniform(2.2, 4.6)
                        sp.kutija(q, ok_.u, ok_.v, 0.3, 0.3, z0 + 0.4, z0 + 0.4 + vis, lin((120, 96, 70)))
                    broj["spomenika"] += 1
            elif kat == "staza" and "alej" in norm(s["naziv"]):
                for pol in _poligoni(g, 20.0):
                    unut = pol.buffer(-0.9)
                    for dio in _poligoni(unut, 5.0):
                        rub = dio.exterior
                        m = int(min(rub.length // 8.0, 120))
                        for i in range(m):
                            pt = rub.interpolate(rub.length * (i + 0.5) / m)
                            p2 = rub.interpolate(min(rub.length * (i + 0.5) / m + 0.5, rub.length))
                            t_ = np.array([p2.x - pt.x, p2.y - pt.y])
                            if np.hypot(*t_) < 1e-6:
                                continue
                            t_ /= np.hypot(*t_)
                            if pas_t is not None and pas_t.contains(pt):
                                continue
                            z0 = float(zf(pt.x, pt.y))
                            sp.kutija((pt.x, pt.y), t_, np.array([t_[1], -t_[0]]), 0.3, 0.07, z0, z0 + 1.6, C["kamen"])
                            broj["stela"] += 1
            elif kat == "tribine":
                for pol in _poligoni(g, 30.0):
                    ok_ = _Okvir(pol)
                    cc = np.array([pol.centroid.x, pol.centroid.y])
                    cilj = min(sportski, key=lambda q: q["geom"].distance(pol))["geom"].centroid if sportski else None
                    naprijed = 1.0
                    if cilj is not None:
                        naprijed = 1.0 if float(np.dot(np.array([cilj.x, cilj.y]) - cc, ok_.v)) < 0 else -1.0
                    z0 = float(zf(cc[0], cc[1]))
                    redova = int(np.clip(ok_.W / o["red_tribine_m"], 2, 30))
                    for j in range(redova):
                        b0 = ok_.W * j / redova
                        b1 = ok_.W * (j + 1) / redova
                        if naprijed < 0:
                            b0, b1 = ok_.W - b1, ok_.W - b0
                        q = ok_.pravokutnik(0, b0, ok_.L, b1)
                        h = z0 + 0.4 + 0.42 * j
                        sp.dodaj([(x, y, h) for x, y in q], [(0, 1, 2, 3)], C["sjedala"])
                        r_ = ok_.t([0, ok_.L], [b1 if naprijed > 0 else b0] * 2)
                        sp.zid(r_[0], r_[1], h, h, h + 0.42, h + 0.42, C["beton"])
                    vrh = z0 + 0.4 + 0.42 * redova
                    q = ok_.pravokutnik(0, 0, ok_.L, ok_.W)
                    for k in range(4):
                        sp.zid(q[k], q[(k + 1) % 4], z0, z0, z0 + 0.4, z0 + 0.4, C["beton"])
                    b_iza = ok_.W if naprijed > 0 else 0.0
                    r_ = ok_.t([0, ok_.L], [b_iza, b_iza])
                    sp.zid(r_[0], r_[1], z0, z0, vrh + 1.0, vrh + 1.0, C["beton"])
                    if re.search(r"natkriv|krov", s["tekst_sve"]):
                        qk = ok_.pravokutnik(-1.0, -1.5, ok_.L + 1.0, ok_.W + 1.5)
                        sp.dodaj([(x, y, vrh + 4.0) for x, y in qk] + [(x, y, vrh + 4.3) for x, y in qk],
                                 [(3, 2, 1, 0), (4, 5, 6, 7), (0, 1, 5, 4), (1, 2, 6, 5), (2, 3, 7, 6), (3, 0, 4, 7)], C["bijelo"])
                    broj["tribina"] += 1
        # dizala, stubišta i pokretne stube koje izlaze na park ili stoje uz vanjski rub (krug 3: u svjetlarniku
        # kao stakleno okno; izostavlja se samo ono što ulazi u svijetli profil ceste ili tramvaja)
        from shapely.geometry import box as _box

        ip = P.i_park
        profil = self._profil_prometa()
        tlocrti, izost = [], []

        def u_profilu(fp, z_dno=None):
            """Presjek tlocrta s profilom (m²) i popis prostora; z_dno: donji rub elementa nad profilom."""
            if profil is None:
                return 0.0, []
            pogodak = []
            for q in profil:
                a_ = q["geom"].intersection(fp).area
                if a_ > 0.05 and (z_dno is None or z_dno < q["pod"] + q["profil_m"]):
                    pogodak.append((q["id"], a_))
            return sum(a_ for _, a_ in pogodak), [i_ for i_, _ in pogodak]

        for v in P.veze:
            if v["tip"] not in ("dizalo", "stubiste", "pokretne_stube") or ip not in v["razine"]:
                continue
            g = v["geom"]
            if g.geom_type == "Point":
                if self.program.stadion and self.program.stadion["vanjski"].contains(g):
                    continue
                pol = 1.3 if v["tip"] == "dizalo" else (float(v["sirina"]) / 2 if v["sirina"] else 1.8)
                pol_v = pol if v["tip"] == "dizalo" else 3.0
                # program daje samo točku: tlocrt (pretpostavka modela) smije se okrenuti i pomaknuti dok točka
                # ostaje u njemu; izostavlja se samo ako nijedan smještaj ne izbjegne profil prometa
                cx, cy, fp, a_, ids = g.x, g.y, None, 0.0, []
                for pu, pv_ in ((pol, pol_v), (pol_v, pol)):
                    for dx in (0.0, pu - 0.4, -(pu - 0.4)):
                        for dy in (0.0, pv_ - 0.4, -(pv_ - 0.4)):
                            f_ = _box(g.x + dx - pu, g.y + dy - pv_, g.x + dx + pu, g.y + dy + pv_)
                            b_, i_ = u_profilu(f_)
                            if fp is None or b_ < a_:
                                cx, cy, fp, a_, ids, pol_x, pol_y = g.x + dx, g.y + dy, f_, b_, i_, pu, pv_
                            if b_ <= 0.05:
                                break
                        if a_ <= 0.05:
                            break
                    if a_ <= 0.05:
                        break
                if a_ > 0.05:
                    izost.append({"id": v["id"], "tip": v["tip"], "presjek_m2": round(a_, 1), "prostori": ids,
                                  "razlog": "točka veze je u svijetlom profilu ceste ili tramvaja (nijedan smještaj tlocrta "
                                            "s točkom programa ne izbjegava prostor prometa)"})
                    continue
                if (cx, cy) != (g.x, g.y) or pol_x != pol:
                    self.kstat.setdefault("pomaknute_veze", []).append(
                        {"id": v["id"], "pomak_m": [round(cx - g.x, 2), round(cy - g.y, 2)], "okrenuto": pol_x != pol})
                pol, pol_v = pol_x, pol_y
                unutra = pv.F is not None and pv.F.contains(g)
                u_svj = False
                if unutra:
                    i_, j_ = pv.celija(g.x, g.y)
                    u_svj = int(pv.L[i_, j_]) == -2
                # na plohi: kota plohe (pv.kota daje tlo izvan ćelija prostora, npr. uz svjetlarnik)
                zt = float(max(pv.kota(g.x, g.y)[0], pv.z_vrha(g.x, g.y))) if unutra else float(pv.kota(g.x, g.y)[0])
                ztlo = float(self.tlo_n(g.x, g.y))
                do_ruba = pv.F.boundary.distance(g) if pv.F is not None else 1e9
                staklo_okna = False
                if u_svj:
                    # stakleno okno kroz svjetlarnik: od poda prostora ispod (najviši pod pod tlocrtom) do iznad plohe
                    podovi = [q["pod"] for q in P.prostori if q["razina"] < ip and q["pod"] is not None
                              and q["geom"].intersects(fp)]
                    kote_r = [P.razine[i]["kota"] for i in range(len(P.razine))
                              if P.razine[i]["id"] in v["razine"] and P.razine[i]["kota"] is not None and i < ip]
                    z0 = max(podovi) if podovi else (min(kote_r) if kote_r else ztlo)
                    z1 = zt + (3.2 if v["tip"] == "dizalo" else 2.8)
                    staklo_okna = True
                else:
                    u_praznini = pv.V is not None and pv.V.distance(g) < 3.0
                    if pv.F is not None and do_ruba < (4.0 if unutra else 10.0) and (not unutra or zt - ztlo > 3.0) \
                            and not u_praznini:
                        # toranj dizala ili stubišta uz rub plohe: od današnjeg tla do iznad ruba plohe
                        from shapely.ops import nearest_points

                        blizu = nearest_points(pv.F.boundary, g)[0]
                        vrh = max(float(pv.z_vrha(blizu.x, blizu.y)), zt)
                        z0, z1 = ztlo - 0.3, vrh + 3.0
                    elif unutra:
                        z0, z1 = zt, zt + (3.2 if v["tip"] == "dizalo" else 2.8)
                    else:
                        continue
                if v["tip"] == "dizalo" or staklo_okna:
                    stk.kutija((cx, cy), (1, 0), (0, 1), pol, pol_v, z0, z1, C["bijelo"])
                    for sx_, sy_ in ((-1, -1), (1, -1), (1, 1), (-1, 1)):   # bijeli stupići okvira
                        sp.kutija((cx + sx_ * (pol - 0.08), cy + sy_ * (pol_v - 0.08)), (1, 0), (0, 1), 0.08, 0.08,
                                  z0, z1, C["bijelo"])
                else:
                    sp.kutija((cx, cy), (1, 0), (0, 1), pol, pol_v, z0, z1, C["beton"])
                sp.kutija((cx, cy), (1, 0), (0, 1), pol + 0.25, pol_v + 0.25, z1, z1 + 0.25, C["bijelo"])
                tlocrti.append(fp)
                broj["okna_u_svjetlarniku" if staklo_okna else ("dizala" if v["tip"] == "dizalo" else "stubista")] += 1
            else:
                cc = np.asarray(g.coords)
                za, zb = float(pv.kota(*cc[0])[0]), float(pv.kota(*cc[-1])[0])
                if abs(za - zb) < 1.0 and pv.F is not None and pv.F.boundary.distance(g) < 6.0:
                    # stube izvan plohe koje vode na njezin rub: gornji kraj je kraj bliži rubu plohe
                    from shapely.geometry import Point as _T
                    from shapely.ops import nearest_points

                    da, db = (pv.F.boundary.distance(_T(q)) for q in (cc[0], cc[-1]))
                    blizu = nearest_points(pv.F.boundary, _T(cc[0] if da < db else cc[-1]))[0]
                    vrh = float(pv.z_vrha(blizu.x, blizu.y))
                    if da < db:
                        za, zb = vrh, float(self.tlo_n(*cc[-1]))
                    else:
                        za, zb = float(self.tlo_n(*cc[0])), vrh
                if abs(za - zb) < 1.0 or g.length < 2.0:
                    continue
                sir = v["sirina"] or 4.0
                n = int(np.clip(math.ceil(abs(zb - za) / 0.17), 4, 160))
                zmin = min(za, zb) - 0.4
                koraci, sukob = [], None
                for j in range(n):
                    a, b = g.interpolate(j / n, normalized=True), g.interpolate((j + 1) / n, normalized=True)
                    t_ = np.array([b.x - a.x, b.y - a.y])
                    l = float(np.hypot(*t_))
                    if l < 1e-6:
                        continue
                    t_ /= l
                    hh = za + (zb - za) * (j + 1 if zb > za else j) / n
                    sred = ((a.x + b.x) / 2, (a.y + b.y) / 2)
                    from shapely.geometry import LineString as _L

                    fp = _L([(a.x, a.y), (b.x, b.y)]).buffer(sir / 2, cap_style=2)   # gazište jedne stube
                    a_, ids = u_profilu(fp, z_dno=hh - 0.5)
                    if a_ > 0.05:
                        sukob = (a_, ids, hh)
                        break
                    nad_prazninom = pv.V is not None and pv.V.intersects(fp)
                    koraci.append((sred, t_, l, hh - 0.5 if nad_prazninom else zmin, hh))
                if sukob is not None:
                    izost.append({"id": v["id"], "tip": v["tip"], "presjek_m2": round(sukob[0], 1), "prostori": sukob[1],
                                  "razlog": f"stube se spuštaju u svijetli profil (gazište {sukob[2]:.1f} m n. v. nad prometom)"})
                    continue
                for sred, t_, l, z_d, hh in koraci:
                    sp.kutija(sred, t_, np.array([t_[1], -t_[0]]), l / 2, sir / 2, z_d, hh, C["kamen"])
                tlocrti.append(g.buffer(sir / 2, cap_style=2))
                broj["stubista"] += 1
        for r_ in izost:
            self.kstat["upozorenja"].append(f"{r_['tip']} {r_['id']} izostavljeno: {r_['razlog']} ({', '.join(r_['prostori'])})")
        self.kstat["izostavljene_veze"] = izost
        from shapely.ops import unary_union

        self._tlocrti_veza = unary_union(tlocrti) if tlocrti else None
        self._objekt("elementi", sp, "procelja")
        self._objekt("elementi_staklo_tamno", st, "procelja", "sjaj")
        self._objekt("dizala", stk, "staklo", "staklo")
        self.kstat["broj"]["elementi"] = broj

    def _profil_prometa(self):
        """Prostori prometa ispod parka koje okno, toranj ili stube ne smiju zahvatiti (svijetli profil):
        kolnici, kolosijeci, autobusni i servisni prostori; bez nogostupa, biciklarnica i perona s čekaonicom.
        Visina profila: svijetla visina prostora iz programa, a bez nje visina portala (autobusi 4,5 m)."""
        if not hasattr(self, "_profil_c"):
            P, o = self.program, self.ok
            self._profil_c = [
                {"id": q["id"], "geom": q["geom"], "pod": float(q["pod"]),
                 "profil_m": float(q["visina"] or (o["visina_portala_m"] if q["kat"] != "promet_bus" else 4.5))}
                for q in P.prostori if q["kat"] in PROMETNE and q["razina"] < P.i_park and q["pod"] is not None
                and not re.search(r"nogostup|biciklarn|cekaonic|peron_stajalist", norm(q["naziv"]))] or None
        return self._profil_c

    # --- drveće koncepta ----------------------------------------------------------------------------------
    def _instanciraj(self, naziv, mreza, xm, ym, z, velicina, kut, podsloj):
        bpy = self.bpy
        n = len(xm)
        pol = np.asarray(velicina) / 2.0
        c, s_ = np.cos(kut) * pol, np.sin(kut) * pol
        # kutovi kvadrata R(kut)·(±p, ±p) obrnuto od kazaljke: normala gore, površina = velicina² (mjerilo instance)
        kx, ky = _kutovi_nositelja(c, s_)
        kx, ky = kx + np.asarray(xm)[:, None], ky + np.asarray(ym)[:, None]
        co = np.stack([kx, ky, np.repeat(np.asarray(z)[:, None], 4, axis=1)], axis=-1).reshape(-1, 3)
        vrsta = {"drvece_koncepta": "stabla_koncepta", "zivot": "ljudi"}.get(podsloj, podsloj)
        if not hasattr(self, "_velicine_l"):
            self._velicine_l = {}
        self._velicine_l.setdefault(vrsta, []).append(np.asarray(velicina, dtype=np.float64))
        nos = self._mreza(f"nositelj_{naziv}", co, np.arange(4 * n, dtype=np.int32), np.full(n, 4, np.int32), "koncept", boja=(0, 0, 0))
        nos.instance_type = "FACES"
        nos.use_instance_faces_scale = True
        nos.show_instancer_for_render = False
        nos.show_instancer_for_viewport = False
        nos["podsloj"] = PODSLOJEVI[podsloj]
        ob = bpy.data.objects.new(naziv, mreza)
        self.zbirka("koncept").objects.link(ob)
        ob.pass_index = SC.SLOJEVI["koncept"]
        ob["podsloj"] = PODSLOJEVI[podsloj]
        ob.parent = nos
        return ob

    def _gradi_drvece_koncepta(self):
        import shapely
        from shapely.ops import unary_union

        pv, o, P = self.povrsina, self.ok, self.program
        if not o["drvece"]:
            return
        rng = np.random.default_rng(int(o["sjeme"]) + 41)
        zabrana = [s["geom"].buffer(2.0) for s in pv.pl if s["kat"] != "park_zelenilo"] + [s["geom"].buffer(2.5) for s in pv.svj]
        if P.stadion:
            zabrana.append(P.stadion["vanjski"].buffer(6.0))
        # krug 3: ne u kućicama i oknima dizala i stubišta (deblo 2,5 m od tlocrta) ni u pojasu terasa
        if getattr(self, "_tlocrti_veza", None) is not None:
            zabrana.append(self._tlocrti_veza.buffer(2.5))
        ter = self._plan_terasa()
        if ter is not None and ter["pas"] is not None:
            zabrana.append(ter["pas"].buffer(1.5))
        zabrana = unary_union(zabrana) if zabrana else None
        X, Y, Z, Hh = [], [], [], []
        for s in pv.pl:
            if s["kat"] != "park_zelenilo":
                continue
            t = s["tekst_sve"]
            if re.search(r"bez_stabala|djecj|igralist", t):
                continue
            razmak = float(o["razmak_stabala_m"])
            hmin, hmax = o["visina_stabala_m"]
            if re.search(r"pokrov", t):
                razmak, hmax = razmak * 1.25, hmin + 0.6 * (hmax - hmin)
            if re.search(r"livad|krov", t):
                razmak *= 1.9
            g = s["geom"].buffer(-2.5)
            if zabrana is not None:
                g = g.difference(zabrana)
            if g.is_empty or g.area < 20:
                continue
            x0, y0, x1, y1 = g.bounds
            gx, gy = np.meshgrid(np.arange(x0, x1, razmak), np.arange(y0, y1, razmak * 0.866))
            gx = gx + (np.arange(gx.shape[0])[:, None] % 2) * razmak / 2
            px = (gx + rng.uniform(-0.38, 0.38, gx.shape) * razmak).ravel()
            py = (gy + rng.uniform(-0.38, 0.38, gy.shape) * razmak).ravel()
            shapely.prepare(g)
            u = shapely.contains_xy(g, px, py) & (rng.random(len(px)) < 0.85)
            if not u.any():
                continue
            px, py = px[u], py[u]
            zz = pv.z_prostora(s, px, py)
            tl = self.tlo_n(px, py)
            dobro = zz > tl - 0.2
            # dno stabla: najniža točka plohe u krugu 1 m oko debla (na kosini stablo ne lebdi)
            dno = np.maximum(zz, tl)
            for dx, dy in ((1.0, 0.0), (-1.0, 0.0), (0.0, 1.0), (0.0, -1.0)):
                dno = np.minimum(dno, np.maximum(pv.z_prostora(s, px + dx, py + dy), self.tlo_n(px + dx, py + dy)))
            X.append(px[dobro]); Y.append(py[dobro]); Z.append(dno[dobro])
            Hh.append(rng.uniform(hmin, hmax, int(dobro.sum())))
        if not X:
            return
        x, y, z, h = np.concatenate(X), np.concatenate(Y), np.concatenate(Z), np.concatenate(Hh)
        self._stabla_koncepta_n = np.column_stack([x, y, h])
        xm, ym = SC.m_iz_n(x, y)
        mlada = bool(o.get("mlada_stabla", True))
        oblici = self._oblici_mladih() if mlada else self._oblici_stabala()
        vjer = [0.30, 0.30, 0.22, 0.18] if mlada else [0.22, 0.34, 0.24, 0.14, 0.04, 0.02]
        izbor = rng.choice(len(oblici), size=len(x), p=vjer)
        kut = rng.uniform(0, 2 * math.pi, len(x))
        self._ob_mladih = []
        for i, ob in enumerate(oblici):
            u = izbor == i
            if u.any():
                inst = self._instanciraj(f"stablo_koncepta_{ob['naziv']}", ob["mreza"], xm[u], ym[u], z[u] - 0.05, h[u], kut[u],
                                         "drvece_koncepta")
                if mlada:
                    self._ob_mladih.append((inst, ob))
        if mlada:
            self._sezona_mladih(getattr(self, "sezona", "ljeto"))
        self.kstat["broj"]["stabala_koncepta"] = int(len(x))

    # --- ljudi -------------------------------------------------------------------------------------------------
    def _mreza_covjeka(self, i):
        import bmesh
        from mathutils import Matrix

        bpy = self.bpy
        bm = bmesh.new()

        def kutija(sx, sy, sz, c, mat):
            prije = set(bm.faces)
            bmesh.ops.create_cube(bm, size=1.0, matrix=Matrix.Translation(c) @ Matrix.Diagonal((sx, sy, sz, 1.0)))
            for f in set(bm.faces) - prije:
                f.material_index = mat

        korak = (0.0, 0.07, -0.05)[i % 3]
        sir = (1.0, 0.9, 1.08)[i % 3]
        kutija(0.085 * sir, 0.10, 0.47, (-0.055 * sir, korak, 0.235), 1)
        kutija(0.085 * sir, 0.10, 0.47, (0.055 * sir, -korak, 0.235), 1)
        kutija(0.27 * sir, 0.14, 0.37, (0, 0, 0.655), 0)
        kutija(0.06, 0.08, 0.33, (-0.165 * sir, -korak * 0.6, 0.66), 0)
        kutija(0.06, 0.08, 0.33, (0.165 * sir, korak * 0.6, 0.66), 0)
        prije = set(bm.faces)
        bmesh.ops.create_icosphere(bm, subdivisions=1, radius=0.066, matrix=Matrix.Translation((0, 0, 0.925)))
        for f in set(bm.faces) - prije:
            f.material_index = 2
        me = bpy.data.meshes.new(f"covjek_{i}")
        bm.to_mesh(me)
        bm.free()
        me.materials.append(self._mat("odjeca"))
        me.materials.append(self.materijal("k_hlace", lin((44, 48, 60)), hrapavost=0.9))
        me.materials.append(self.materijal("k_koza", lin((206, 160, 130)), hrapavost=0.8))
        return me

    def _gradi_ljude(self):
        import shapely

        pv, o = self.povrsina, self.ok
        if not o["ljudi"]:
            return
        rng = np.random.default_rng(int(o["sjeme"]) + 51)
        plohe = [s for s in pv.pl if s["kat"] in ("staza", "trg_predvorje")]
        if not plohe:
            return
        uk = sum(s["geom"].area for s in plohe)
        cilj = min(int(uk / o["m2_po_covjeku"]), int(o["najvise_ljudi"]))
        # krug 3: ne unutar 1 m od kućica i okana dizala i stubišta ni u pojasu terasa
        from shapely.ops import unary_union

        zab = [x for x in (getattr(self, "_tlocrti_veza", None),) if x is not None]
        ter = self._plan_terasa()
        if ter is not None and ter["pas"] is not None:
            zab.append(ter["pas"])
        zab = unary_union(zab).buffer(1.0) if zab else None
        X, Y, Z = [], [], []
        for s in plohe:
            n = int(round(cilj * s["geom"].area / uk))
            g = s["geom"].buffer(-0.6)
            if zab is not None:
                g = g.difference(zab)
            if n <= 0 or g.is_empty:
                continue
            x0, y0, x1, y1 = g.bounds
            px, py = rng.uniform(x0, x1, n * 12), rng.uniform(y0, y1, n * 12)
            shapely.prepare(g)
            u = np.nonzero(shapely.contains_xy(g, px, py))[0][:n]
            px, py = px[u], py[u]
            par = rng.random(len(px)) < 0.4   # dio ljudi hoda u paru
            kutp = rng.uniform(0, 2 * math.pi, int(par.sum()))
            px2, py2 = px[par] + 0.62 * np.cos(kutp), py[par] + 0.62 * np.sin(kutp)
            u2 = shapely.contains_xy(g, px2, py2)
            px, py = np.r_[px, px2[u2]], np.r_[py, py2[u2]]
            zz = pv.z_prostora(s, px, py)
            tl = self.tlo_n(px, py)
            X.append(px); Y.append(py); Z.append(np.maximum(zz, tl))
        if not X:
            return
        x, y, z = np.concatenate(X), np.concatenate(Y), np.concatenate(Z)
        self._ljudi_n = np.column_stack([x, y, z])
        xm, ym = SC.m_iz_n(x, y)
        vis = np.clip(rng.normal(o["covjek_m"], 0.07, len(x)), 1.15, 1.95)
        vis[rng.random(len(x)) < 0.08] *= 0.72  # djeca
        kut = rng.uniform(0, 2 * math.pi, len(x))
        izbor = rng.integers(0, 3, len(x))
        for i in range(3):
            u = izbor == i
            if u.any():
                self._instanciraj(f"covjek_{i}", self._mreza_covjeka(i), xm[u], ym[u], z[u] + 0.01, vis[u], kut[u], "zivot")
        self.kstat["broj"]["ljudi"] = int(len(x))

    # --- vozila ---------------------------------------------------------------------------------------------------
    def _vozilo(self, sp, sred_n, smjer_n, duljina, sirina, visina, donja, gornja, krov, z0):
        xm, ym = K.m_iz_n(float(sred_n[0]), float(sred_n[1]))
        t_ = np.asarray(smjer_n, dtype=np.float64)
        t_ = t_ / max(np.hypot(*t_), 1e-9)
        nrm = np.array([t_[1], -t_[0]])
        c = (xm, ym)
        if not hasattr(self, "_vozila_n"):
            self._vozila_n = []
        self._vozila_n.append((float(sred_n[0]), float(sred_n[1]), 0.5 * duljina))
        sp.kutija(c, t_, nrm, duljina / 2 - 0.25, sirina / 2 - 0.12, z0 - 0.1, z0 + 0.30, C["portal"])  # podvozje
        sp.kutija(c, t_, nrm, duljina / 2, sirina / 2, z0 + 0.30, z0 + 0.34 * visina, donja)
        sp.kutija(c, t_, nrm, duljina / 2 - 0.03, sirina / 2 - 0.03, z0 + 0.34 * visina, z0 + 0.70 * visina, C["staklo_tamno"])
        sp.kutija(c, t_, nrm, duljina / 2, sirina / 2, z0 + 0.70 * visina, z0 + visina, gornja, boja_vrha=krov)

    def _gradi_vozila(self):
        from shapely.geometry import LineString, Point

        pv, P, o = self.povrsina, self.program, self.ok
        if not o["vozila"]:
            return
        sp = Spremnik(metricki=True)
        D, S, Vv = o["tramvaj_m"]
        modula, zglob = 5, 0.25
        lm = (D - (modula - 1) * zglob) / modula
        pruge = [LineString(p["linija"]) for p in (self.site.get("tramvaj") or {}).get("pruge") or [] if len(p.get("linija") or []) >= 2]
        mjesta = []   # (linija, s_sredine)
        z = getattr(self, "_zidovi", None)
        V = pv.V
        if z is not None and pruge:
            otvori = np.nonzero((z["portal"] > 0) & z["praznina"] & z["vanjski"])[0]
            import shapely

            if len(otvori):
                seg = shapely.linestrings(np.stack([z["p0"][otvori], z["p1"][otvori]], axis=1))
                for li, l in enumerate(pruge):
                    hit = np.nonzero(shapely.intersects(l, seg))[0]
                    for j in hit[:1]:
                        pt = l.intersection(seg[j])
                        pt = pt if pt.geom_type == "Point" else pt.representative_point()
                        s0 = l.project(pt)
                        van = z["n"][otvori[j]]
                        for znak in (1, -1):
                            s1 = s0 + znak * (D / 2 + 9.0)
                            if 0 < s1 - D / 2 and s1 + D / 2 < l.length:
                                q = l.interpolate(s1)
                                if float(np.dot([q.x - pt.x, q.y - pt.y], van)) > 0:
                                    mjesta.append((l, s1, "pred portalom"))
        if V is not None:
            tram_prostori = [s["geom"] for s in P.prostori if s["razina"] < P.i_park and s["kat"] == "promet_tramvaj"]
            for l in pruge:
                for g in tram_prostori:
                    dio = l.intersection(g.intersection(V))
                    for d in ([dio] if dio.geom_type == "LineString" else list(getattr(dio, "geoms", []))):
                        if d.geom_type == "LineString" and d.length >= D + 6:
                            mjesta.append((l, l.project(d.interpolate(0.5, normalized=True)), "pod parkom"))
        # bez preklapanja, najviše zadani broj; pola pred portalima, pola pod parkom
        izabrano = []
        for vrsta in ("pred portalom", "pod parkom"):
            for l, s1, v_ in mjesta:
                if v_ != vrsta or len([1 for q in izabrano if q[2] == vrsta]) >= math.ceil(o["najvise_tramvaja"] / 2):
                    continue
                p = l.interpolate(s1)
                if all(p.distance(q[0].interpolate(q[1])) > D * 0.8 for q in izabrano):
                    izabrano.append((l, s1, v_))
        for l, s1, _ in izabrano:
            for k in range(modula):
                s_ = s1 + (k - (modula - 1) / 2) * (lm + zglob)
                a, b, m = l.interpolate(s_ - lm / 2), l.interpolate(s_ + lm / 2), l.interpolate(s_)
                z0 = float(self.tlo_n(m.x, m.y)) + 0.2
                self._vozilo(sp, (m.x, m.y), (b.x - a.x, b.y - a.y), lm, S, Vv, C["tramvaj"], C["tramvaj"], lin((200, 204, 210)), z0)
        Db, Sb, Vb = o["autobus_m"]
        buseva = 0
        for s in P.prostori:
            if s["razina"] >= P.i_park or s["kat"] != "promet_bus" or buseva >= o["najvise_autobusa"]:
                continue
            ok_ = _Okvir(s["geom"])
            n = int(min(max(s["geom"].area // 450, 1), 3, o["najvise_autobusa"] - buseva))
            for i in range(n):
                q = ok_.t(ok_.L * (i + 0.5) / n, ok_.W * 0.5)
                if not s["geom"].contains(Point(q)):
                    continue
                kut_ = ok_.v if ok_.W > Db + 2 else ok_.u
                z0 = float(self.tlo_n(q[0], q[1])) + 0.2
                self._vozilo(sp, q, kut_, Db, Sb, Vb, C["autobus"], C["tramvaj"], lin((225, 225, 225)), z0)
                buseva += 1
        self._objekt("vozila", sp, "zivot", "sjaj" if False else "boja")
        self.kstat["broj"]["tramvaja"] = len(izabrano)
        self.kstat["broj"]["autobusa"] = buseva

    # --- teren unutar stadiona ---------------------------------------------------------------------------------------
    def _spusti_teren(self):
        """Model reljefa ne razlučuje današnje ukopano igralište; unutar novog stadiona mreža terena se
        spušta ispod kote igrališta da ne probija travnjak i donju tribinu (samo prikaz, ne iskop)."""
        import shapely
        from shapely.geometry import Polygon

        st = self.program.stadion
        ob = self.bpy.data.objects.get("teren_blizu")
        if not self.ok["spusti_teren_u_stadionu"] or not st or ob is None:
            return
        unut = st["vanjski"].buffer(-5.0)
        if unut.is_empty:
            return
        z_igr = self.program.kota_igralista(self.ok["kota_igralista"])
        gm = Polygon(K.poligon_m_iz_n(list(unut.exterior.coords)))
        me = ob.data
        co = np.empty(len(me.vertices) * 3, dtype=np.float32)
        me.vertices.foreach_get("co", co)
        co = co.reshape(-1, 3)
        shapely.prepare(gm)
        u = shapely.contains_xy(gm, co[:, 0].astype(np.float64), co[:, 1].astype(np.float64))
        prije = co[u, 2].copy()
        co[u, 2] = np.minimum(co[u, 2], z_igr - 0.6)
        me.vertices.foreach_set("co", co.ravel())
        me.update()
        self.kstat["teren_u_stadionu"] = {"vrhova": int(u.sum()), "najvece_spustanje_m": round(float((prije - co[u, 2]).max()), 2) if u.any() else 0.0}

    # --- render s podslojevima -------------------------------------------------------------------------------------------
    def _prolaz_podslojeva(self):
        """Dodatni prolaz podataka (jedan uzorak po pikselu) u kojem objekti koncepta nose indeks podsloja."""
        bpy, sc = self.bpy, self.scene
        kon = SC.SLOJEVI["koncept"]
        promijenjeni = [ob for ob in sc.objects if ob.pass_index == kon and "podsloj" in ob.keys()]
        for ob in promijenjeni:
            ob.pass_index = int(ob["podsloj"])
        exr = self._tmp("podslojevi.exr")
        try:
            bpy.context.view_layer.material_override = self._materijal_podataka()
            sc.cycles.samples = 1
            sc.cycles.use_adaptive_sampling = False
            sc.cycles.pixel_filter_type = "BOX"
            sc.cycles.filter_width = 0.01
            sc.render.film_transparent = True
            sc.render.image_settings.file_format = "OPEN_EXR"
            sc.render.image_settings.color_depth = "32"
            sc.render.image_settings.color_mode = "RGBA"
            sc.render.resolution_percentage = 100
            sc.render.filepath = str(exr)
            bpy.ops.render.render(write_still=True)
            d = self._ucitaj_exr(exr)
        finally:
            for ob in promijenjeni:
                ob.pass_index = kon
            bpy.context.view_layer.material_override = None
            sc.render.film_transparent = False
            sc.render.image_settings.color_mode = "RGB"
            Path(exr).unlink(missing_ok=True)
        return np.where(d[..., 3] < 0.5, 0, np.rint(d[..., 1])).astype(np.uint8)

    def renderiraj(self, put, uzorci=96, prolazi=("slika", "dubina", "maska"), podslojevi=True, **kw):
        """Kao scena.Scena.renderiraj; uz prolaz "maska" nastaje i <ime>_podslojevi.png (park 10, stadion 11,
        pročelja i zidovi 12, staklo 13, ljudi i vozila 14, drveće koncepta 15; ostali slojevi kao u maski)."""
        from PIL import Image

        kw.setdefault("oznaka", OZNAKA_RENDER)
        r = super().renderiraj(put, uzorci=uzorci, prolazi=prolazi, **kw)
        m = r.get("maska")
        if m is None or "maska" not in prolazi or not podslojevi:
            return r
        t0 = time.time()
        osnova = Path(put).with_suffix("")
        idx = self._prolaz_podslojeva()
        kon = SC.SLOJEVI["koncept"]
        pod = np.where(m == kon, np.where(idx >= kon, idx, kon), m).astype(np.uint8)
        Image.fromarray(pod, "L").save(str(osnova) + "_podslojevi.png", optimize=True)
        pop = r["popratno"]
        pop["podslojevi_koncepta"] = {"datoteka": Path(str(osnova) + "_podslojevi.png").name,
                                      "legenda": {str(v): k for k, v in PODSLOJEVI.items()},
                                      "udio_piksela": {k: round(float((pod == v).mean()), 4) for k, v in PODSLOJEVI.items()}}
        Path(str(osnova) + ".json").write_text(json.dumps(pop, ensure_ascii=False, indent=1), encoding="utf-8")
        r["podslojevi"] = pod
        r.setdefault("vrijeme_s", {})["podslojevi_s"] = round(time.time() - t0, 1)
        return r


# ---------------------------------------------------------------------------
# API
# ---------------------------------------------------------------------------

def izgradi(program_put, slojevi_scene=SLOJEVI_SCENE, sjeme=20261113, predmemorija=None, postavke_scene=None, **opcije):
    """Gradi scenu postojećeg stanja (bez sloja stadiona) i u nju model koncepta iz program.json.

    slojevi_scene   podskup scena.SVI_SLOJEVI; "stadion" se uvijek izostavlja
    opcije          ključevi iz ZADANO_KONCEPT (npr. drvece=False, ljudi=False, korak_m=2.0)
    Vraća ScenaKoncepta: na nju idu scena.postavi_kameru, scena.postavi_sunce i scena.renderiraj.
    """
    t0 = time.time()
    s = ScenaKoncepta(program_put, slojevi=slojevi_scene, sjeme=sjeme, predmemorija=predmemorija, opcije=opcije,
                      **(postavke_scene or {}))
    s.izgradi()
    _vremena_gradnje(s)["ukupno"] = round(time.time() - t0, 2)
    return s


def _provjera_pogleda(s):
    """Vraća f(p, cilj, daljina) -> bool: stajalište (ENU-N) nije u zgradi, prepreci koncepta ni pod krošnjom,
    a pravac prema cilju u prvih `daljina` metara ne siječe postojeću zgradu niti prolazi kroz krošnju."""
    import shapely
    from shapely.geometry import LineString, Point
    from shapely.ops import unary_union

    izost = set((s.statistika.get("izrez") or {}).get("izostavljene_zgrade_id") or [])
    zg = [g for g in (_poligon(z.get("poligon"), z.get("rupe")) for z in s.site.get("zgrade", []) if z.get("id") not in izost)
          if g is not None]
    zg = [g if g.is_valid else g.buffer(0) for g in zg]
    from shapely.strtree import STRtree

    stablo_zg = STRtree(zg) if zg else None
    pv, P = s.povrsina, s.program
    prepreke = [v["geom"] for v in P.veze if v["tip"] in ("dizalo", "stubiste", "pokretne_stube")]
    if P.stadion:
        prepreke.append(P.stadion["vanjski"])
    prepreke = unary_union(prepreke) if prepreke else None
    T = []
    st = getattr(s, "stabla", None)
    if isinstance(st, dict) and len(st.get("x_n", [])):
        T.append(np.column_stack([st["x_n"], st["y_n"], st["polumjer_m"]]))
    sk = getattr(s, "_stabla_koncepta_n", None)
    if sk is not None and len(sk):
        T.append(np.column_stack([sk[:, 0], sk[:, 1], 0.35 * sk[:, 2]]))
    vz = getattr(s, "_vozila_n", None)
    vz = np.asarray(vz, dtype=np.float64) if vz else np.zeros((0, 3))
    if len(vz):
        T.append(vz)
    T = np.concatenate(T) if T else np.zeros((0, 3))

    def f(p, cilj, daljina=55.0):
        p = np.asarray(p, dtype=np.float64)
        smjer = np.asarray(cilj, dtype=np.float64) - p
        smjer = smjer / max(float(np.hypot(*smjer)), 1e-9)
        kraj = p + smjer * daljina
        tp, crta = Point(p), LineString([p, kraj])
        if stablo_zg is not None:
            if len(stablo_zg.query(tp.buffer(5.0), predicate="intersects")) or \
                    len(stablo_zg.query(crta, predicate="intersects")):
                return False
        if prepreke is not None and prepreke.distance(tp) < 6.0:
            return False
        if len(vz) and (np.hypot(vz[:, 0] - p[0], vz[:, 1] - p[1]) - vz[:, 2] < 14.0).any():
            return False  # vozilo ne smije zauzeti prvi plan
        if pv.F is not None and pv.F.buffer(-0.5).contains(tp):
            return False  # stajalište s tla, ne na plohi
        if len(T):
            v = T[:, :2] - p
            t = np.clip(v @ smjer, 0.0, daljina)
            dd = np.hypot(*(v - t[:, None] * smjer).T)
            if (dd < T[:, 2] + 0.8).any():
                return False
        return True

    return f


def _zrake_pogleda(s, raspon_deg=38.0, n=7, daleko=400.0):
    """Vraća f(x_m, y_m, z_oka, azimut) -> (najbliža, medijan, udio < 15 m) daljina pogodaka lepeze zraka (ENU-M),
    vodoravno i 7° iznad vodoravnog, u rasponu ±raspon_deg oko azimuta. Pogađa sve objekte scene i koncepta."""
    bpy = s.bpy
    bpy.context.view_layer.update()
    dg = bpy.context.evaluated_depsgraph_get()

    def f(xm, ym, z, az):
        d = []
        for a in np.radians(np.linspace(az - raspon_deg, az + raspon_deg, n)):
            for el in np.radians((1.5, 7.0)):
                v = (math.sin(a) * math.cos(el), math.cos(a) * math.cos(el), math.sin(el))
                ok, loc, *_ = s.scene.ray_cast(dg, (float(xm), float(ym), float(z)), v, distance=daleko)
                d.append(math.dist(loc, (xm, ym, z)) if ok else daleko)
        d = np.asarray(d)
        return float(d.min()), float(np.median(d)), float((d < 15.0).mean())

    return f


PROBNI = ("zrak_jug", "zrak_sjeverozapad", "visina_sjever", "visina_jug", "visina_zapad")


def pogledi(s, sirina_px=1920, omjer=16 / 9):
    """Kamere izvedene iz programa i podloge: dvije iz zraka (oko 280–400 m n. v.), tri s visine (78–135 m
    iznad tla: sjeverno lice pokrova iz povijesnog parka, južni rub s terasama, zapadna kosina prema Sveticama)
    i tri s tla (za montažu; scena s tla nije gotova slika). Naredba probni radi poglede iz PROBNI."""
    P, pv = s.program, s.povrsina
    st = P.stadion
    if st:
        cn = np.asarray(st["sredina"], dtype=np.float64)
    else:
        cn = np.asarray([pv.F.centroid.x, pv.F.centroid.y])
    cx, cy = K.m_iz_n(float(cn[0]), float(cn[1]))
    zp = pv.kota_podija if pv.kota_podija is not None else float(pv.kota(cn[0], cn[1])[0])
    opce = dict(sirina_px=sirina_px, omjer=omjer)
    out = {
        "zrak_jug": KAM.pogled_na((cx, cy - 60.0, zp), azimut_od_cilja_deg=176.0, udaljenost_m=840.0, kota_oka=400.0,
                                  f35_mm=24.0, naziv="zrak_jug", **opce),
        "zrak_sjeverozapad": KAM.pogled_na((cx - 40.0, cy, zp), azimut_od_cilja_deg=304.0, udaljenost_m=640.0,
                                           kota_oka=310.0, f35_mm=24.0, naziv="zrak_sjeverozapad", **opce),
    }

    # s visine (krug 3): 78–135 m iznad današnjeg tla, cilj na rubu koncepta
    from shapely.geometry import LineString, Point

    try:
        os_ = LineString(s.site["izvedeno"]["os_maksimirske"]["linija"])
        c_os = os_.interpolate(os_.project(Point(cn)))
        cilj_s = (float(c_os.x), float(c_os.y))
    except Exception:  # noqa: BLE001
        cilj_s = (float(cn[0]), float(pv.F.bounds[3]) - 20.0) if pv.F is not None else (float(cn[0]), float(cn[1]))
    ter = s._plan_terasa() if hasattr(s, "_plan_terasa") else None
    az_j = 192.0
    if ter is not None and ter["pas"] is not None:
        dio = max(_poligoni(ter["pas"], 1.0), key=lambda q: q.area)
        cilj_j = (dio.centroid.x, dio.centroid.y)
        zr_ = s._rub()[0]
        sred_ = (zr_["p0"] + zr_["p1"]) / 2
        uz = [j for j in np.nonzero(ter["kat"] > 0)[0] if dio.distance(Point(*sred_[j])) < 0.6]
        if uz:
            az_j = float(np.median(zr_["az"][uz]))
    elif pv.F is not None:
        cilj_j = (float(cn[0]), float(pv.F.bounds[1]) + 40.0)
    else:
        cilj_j = (float(cn[0]), float(cn[1]) - 150.0)
    cilj_z = (float(pv.F.bounds[0]) + 50.0, float(cn[1])) if pv.F is not None else (float(cn[0]) - 200.0, float(cn[1]))
    for naziv, cilj, az_, dalj, vis in (("visina_sjever", cilj_s, 352.0, 230.0, 135.0), ("visina_jug", cilj_j, az_j, 230.0, 100.0),
                                        ("visina_zapad", cilj_z, 262.0, 320.0, 78.0)):
        tx_, ty_ = K.m_iz_n(float(cilj[0]), float(cilj[1]))
        zc = float(pv.kota(cilj[0], cilj[1])[0])
        a_ = math.radians(az_)
        tl_ = float(s.tlo_n(cilj[0] + dalj * math.sin(a_), cilj[1] + dalj * math.cos(a_)))
        out[naziv] = KAM.pogled_na((tx_, ty_, zc), azimut_od_cilja_deg=az_, udaljenost_m=dalj, kota_oka=tl_ + vis,
                                   f35_mm=26.0, naziv=naziv, **opce)

    def s_tla(naziv, xn, yn, cilj_n, cilj_z, f35=22.0, iznad=None):
        xm, ym = K.m_iz_n(float(xn), float(yn))
        tx, ty = K.m_iz_n(float(cilj_n[0]), float(cilj_n[1]))
        z = (float(pv.kota(xn, yn)[0]) if iznad is None else iznad) + 1.7
        az = math.degrees(math.atan2(tx - xm, ty - ym)) % 360.0
        nag = math.degrees(math.atan2(cilj_z - z, math.hypot(tx - xm, ty - ym)))
        return KAM.iz_polozaja(x=xm, y=ym, kota_oka=z, azimut_deg=az, nagib_deg=nag, f35_mm=f35, naziv=naziv,
                               izvor="stajalište s tla, oko 1,7 m iznad plohe", **opce)

    slobodno = _provjera_pogleda(s)
    zrake = _zrake_pogleda(s)

    def najbolje(kandidati, cilj_n, daljina=55.0, iznad=None):
        """Prvi kandidat (redoslijed = poželjnost) koji prolazi tlocrtnu provjeru i provjeru zrakama; inače
        kandidat s najvećom slobodnom daljinom. kandidati: (x, y) u ENU-N."""
        najbolji, ocj = None, -1.0
        kandidati = [np.asarray(p, dtype=np.float64) for p in kandidati]
        prolaze = [slobodno(p, cilj_n, daljina=daljina) for p in kandidati]
        # zrake su skupe (oko 0,3 s po stajalištu): najprije stajališta koja prolaze tlocrtnu provjeru
        redom = [p for p, ok in zip(kandidati, prolaze) if ok][:16] + [p for p, ok in zip(kandidati, prolaze) if not ok][:8]
        for p in redom:
            z = (float(s.tlo_n(p[0], p[1])) if iznad is None else iznad(p)) + 1.7
            xm, ym = K.m_iz_n(float(p[0]), float(p[1]))
            tx, ty = K.m_iz_n(float(cilj_n[0]), float(cilj_n[1]))
            az = math.degrees(math.atan2(tx - xm, ty - ym))
            najbliza, sred, blizu = zrake(xm, ym, z, az)
            if najbliza >= 7.0 and sred >= 16.0 and blizu <= 0.25:
                return p
            o_ = min(sred, 120.0) + (40.0 if najbliza >= 7.0 else 0.0) - 60.0 * blizu
            if o_ > ocj:
                najbolji, ocj = p, o_
        return najbolji

    try:
        u = np.asarray(s.site["park_maksimir"]["glavni_ulaz"]["sredina"], dtype=np.float64)
    except Exception:  # noqa: BLE001
        u = None
    if u is not None:
        d = (u - cn) / max(np.hypot(*(u - cn)), 1e-9)
        bok = np.array([d[1], -d[0]])
        # stajalište pred ulazom u park (na današnjem tlu), s pogledom prema stadionu bez zida, zgrade, vozila ili krošnje
        # u prvom planu
        kand_u = [u + d * natrag + bok * u_stranu for natrag in (22.0, 30.0, 16.0, 38.0, 46.0, 12.0)
                  for u_stranu in (0.0, 8.0, -8.0, 16.0, -16.0, 24.0, -24.0)]
        p = najbolje(kand_u, cn)
        out["tlo_ulaz"] = s_tla("tlo_ulaz", p[0], p[1], cn, zp + 22.0, f35=22.0, iznad=float(s.tlo_n(p[0], p[1])))
    if pv.F is not None:
        x0, y0, x1, y1 = pv.F.bounds
        kand_s = [np.array([x0 - natrag, cn[1] + pomak]) for natrag in (42.0, 50.0, 34.0, 60.0)
                  for pomak in (20.0, 0.0, 40.0, -20.0, 60.0)]
        p = najbolje(kand_s, cn, daljina=70.0)
        out["tlo_svetice"] = s_tla("tlo_svetice", p[0], p[1], cn, zp + 38.0, f35=24.0, iznad=float(s.tlo_n(p[0], p[1])))
    lj = getattr(s, "_ljudi_n", None)
    kand = lj if lj is not None and len(lj) else None
    if kand is None and pv.pl:
        kand = np.array([[q.x, q.y, float(pv.kota(q.x, q.y)[0])] for q in
                         (s_["geom"].representative_point() for s_ in pv.pl if s_["kat"] in ("staza", "trg_predvorje"))])
    if kand is not None and len(kand):
        # stajalište na stazi ili trgu parka, zapadno od stadiona, oko 110 m od pročelja
        r_st = 0.0
        if st:
            c_ = np.asarray(st["vanjski"].exterior.coords)
            r_st = float(np.mean(np.hypot(c_[:, 0] - cn[0], c_[:, 1] - cn[1])))
        cilj_d = (r_st + 110.0) if st else 185.0
        d = np.hypot(kand[:, 0] - cn[0], kand[:, 1] - cn[1])
        smjer = np.degrees(np.arctan2(kand[:, 0] - cn[0], kand[:, 1] - cn[1])) % 360.0
        ocjena = np.abs(d - cilj_d) + 1.2 * np.abs(((smjer - 262.0 + 180) % 360) - 180) + 30.0 * np.abs(kand[:, 2] - zp)
        red = np.argsort(ocjena)[:40]
        zz = {tuple(np.round(kand[i, :2], 3)): float(kand[i, 2]) for i in red}
        p = najbolje([kand[i, :2] + np.array([0.9, -0.9]) for i in red], cn, daljina=45.0,
                     iznad=lambda q: zz.get(tuple(np.round(q - np.array([0.9, -0.9]), 3)), float(pv.kota(q[0], q[1])[0])))
        out["park_stadion"] = s_tla("park_stadion", p[0], p[1], cn, zp + 16.0, f35=24.0,
                                    iznad=zz.get(tuple(np.round(p - np.array([0.9, -0.9]), 3)), float(pv.kota(p[0], p[1])[0])))
    return out


KANON = {"podij_mnv": 128.5, "park_zapadni_kraj_pokrova_mnv": 127.1, "park_uz_sjevernu_tribinu_mnv": 128.2,
         "park_istocni_kraj_pokrova_mnv": 128.2, "vrh_krova_mnv": 166.5, "duljina_pokrova_m": 720.0}


def _svijetli_profil(s, os_, sa, sb, korak=4.0, pomaci=(-9.0, -5.0, -2.0, 0.0, 2.0, 5.0, 9.0)):
    """Zrake od kolnika (tlo + 0,3 m) prema gore duž osi Maksimirske pod pokrovom. Pogodak ispod
    kolnik + visina_portala_m koji nije podgled ni vozilo je prepreka u svijetlom profilu."""
    import shapely

    bpy, pv, o = s.bpy, s.povrsina, s.ok
    dg = bpy.context.evaluated_depsgraph_get()
    hp = float(o["visina_portala_m"])
    shapely.prepare(pv.V)
    prepreke, nisko, najniza, uzoraka = [], [], None, 0
    for sx in np.arange(sa + 2.0, sb - 2.0, korak):
        a, b = os_.interpolate(sx - 1.0), os_.interpolate(sx + 1.0)
        t_ = np.array([b.x - a.x, b.y - a.y]) / max(math.hypot(b.x - a.x, b.y - a.y), 1e-9)
        nrm = np.array([t_[1], -t_[0]])
        c = os_.interpolate(sx)
        for k in pomaci:
            xn, yn = c.x + nrm[0] * k, c.y + nrm[1] * k
            if not shapely.contains_xy(pv.V, xn, yn):
                continue
            z0 = float(s.tlo_n(xn, yn)) + 0.3
            xm, ym = K.m_iz_n(xn, yn)
            ok, loc, _, _, ob, _ = s.scene.ray_cast(dg, (xm, ym, z0), (0.0, 0.0, 1.0), distance=60.0)
            uzoraka += 1
            # vozila i ljudi nisu prepreka profila; zraka se nastavlja iznad njih
            while ok and ob is not None and (ob.name.startswith("vozila") or ob.name.startswith("covjek")):
                ok, loc, _, _, ob, _ = s.scene.ray_cast(dg, (xm, ym, loc[2] + 0.05), (0.0, 0.0, 1.0), distance=60.0)
            if not ok:
                continue
            h = float(loc[2]) - (z0 - 0.3)
            if ob.name.startswith("podgled_pokrova"):
                najniza = h if najniza is None else min(najniza, h)
                if h < hp - 0.01:
                    nisko.append(round(float(sx), 1))
            elif h < hp:
                prepreke.append({"stacionaza_m": round(float(sx), 1), "pomak_m": k, "objekt": ob.name,
                                 "visina_nad_kolnikom_m": round(h, 2)})
    po_objektu = {}
    for p in prepreke:
        po_objektu[p["objekt"]] = po_objektu.get(p["objekt"], 0) + 1
    return {"visina_portala_m": hp, "zraka": uzoraka, "najmanja_visina_podgleda_m": None if najniza is None else round(najniza, 2),
            "prepreka": len(prepreke), "po_objektu": po_objektu, "prve": prepreke[:12], "prolazi": not prepreke,
            "podgled_nizi_od_portala_zraka": len(nisko),
            "podgled_nizi_od_portala_stacionaze_m": [min(nisko), max(nisko)] if nisko else None,
            "napomena": "prepreka = sve osim podgleda, vozila i ljudi ispod kolnik + visina_portala_m; nizak podgled "
                        "znači da program drži park premalo iznad ceste za pretpostavljeni portal (OTVORENO)"}


def _mjera_m19(s, prag_zida_m=3.0):
    """M19 po smjeru vanjskog ruba razine parka (bez ruba pokrova nad cestom i bez portala): duljina,
    duljina zida višeg od prag_zida_m, udio i najveća visina. Smjer po azimutu vanjske normale."""
    z = getattr(s, "_zidovi", None)
    if not z:
        return None
    duz = np.hypot(*(z["p1"] - z["p0"]).T)
    ter = getattr(s, "_ter_c", None)
    van = z["vanjski"] & ~z["praznina"] & (z["portal"] == 0)
    az = z["az"]
    smjerovi = {"sjever (prema povijesnom parku)": (az >= 315) | (az < 45), "istok": (az >= 45) & (az < 135),
                "jug (terase)": (az >= 135) & (az < 225), "zapad (prema Sveticama)": (az >= 225) & (az < 315)}
    out = {"prag_zida_m": prag_zida_m, "smjer": {}, "upozorenja": []}
    for ime, m in smjerovi.items():
        m_smjer = m
        m = m & van
        L = float(duz[m].sum())
        mz = m & (z["h"] > prag_zida_m)
        Lz = float(duz[mz].sum())
        out["smjer"][ime] = {"rub_m": round(L), "zid_m": round(Lz), "udio_zida": round(Lz / L, 2) if L else 0.0,
                             "najvisi_zid_m": round(float(z["h"][m].max()), 1) if m.any() else 0.0}
        if ter is not None:
            # ista mjera kao kstat["terase"]["duljina_m"]: sav vanjski rub tog smjera na kojem su terase
            out["smjer"][ime]["od_toga_terase_m"] = round(float(duz[m_smjer & (ter["kat"] > 0)].sum()))
        if (ime.startswith("zapad") or ime.startswith("sjever")) and L > 20 and Lz / L > 0.25:
            out["upozorenja"].append(f"M19: rub {ime} je {round(100 * Lz / L)} % zid viši od {prag_zida_m} m "
                                     f"(najviše {out['smjer'][ime]['najvisi_zid_m']} m); M19 traži zelenu kosinu")
    if out["upozorenja"]:
        s.kstat["upozorenja"].extend(out["upozorenja"])
    return out


def _pod_ispod_tla(s, prag_m=0.5, korak=3.0, najvise=20):
    """Prostori čiji je pod niži od najviše točke današnjeg tla u svom poligonu više od prag_m (program
    ukopava ono što koncept ne smije; OTVORENO za autore programa)."""
    import shapely

    P = s.program
    nalaz = []
    for q in P.prostori:
        if q["pod"] is None or q["kat"] in ("postojece", "dvoriste", "igraliste", "tribine", "stadion"):
            continue
        g = q["geom"]
        x0, y0, x1, y1 = g.bounds
        X, Y = np.meshgrid(np.arange(x0 + korak / 2, x1, korak), np.arange(y0 + korak / 2, y1, korak))
        shapely.prepare(g)
        u = shapely.contains_xy(g, X, Y)
        if not u.any():
            c = g.representative_point()
            X, Y, u = np.array([[c.x]]), np.array([[c.y]]), np.array([[True]])
        t = np.asarray(s.tlo_n(X[u], Y[u]))
        d = float(q["pod"]) - float(t.max())
        if d < -prag_m:
            nalaz.append({"id": q["id"], "razina": P.razine[q["razina"]]["id"], "kat": q["kat"], "pod_mnv": round(q["pod"], 2),
                          "tlo_najvise_mnv": round(float(t.max()), 2), "tlo_medijan_mnv": round(float(np.median(t)), 2),
                          "pod_minus_tlo_m": round(d, 2)})
    nalaz.sort(key=lambda r: r["pod_minus_tlo_m"])
    return {"prag_m": prag_m, "status": "OTVORENO (program); model ne iskopava", "prostora": len(nalaz), "najvece": nalaz[:najvise]}


def izmjeri(s):
    """Mjeri na mrežama izgrađene scene (zraka okomito na plohu parka, vrhovi krova) i uspoređuje s
    kanonskim kotama iz research/viz/README.md. Status: PRETPOSTAVKA-IZRAČUN."""
    from shapely.geometry import LineString

    bpy, pv, P = s.bpy, s.povrsina, s.program
    bpy.context.view_layer.update()
    park = bpy.data.objects.get("park_ploha")
    dg = bpy.context.evaluated_depsgraph_get()

    def zraka(xn, yn):
        xm, ym = K.m_iz_n(float(xn), float(yn))
        if park is None:
            return None
        ok, loc, _, _ = park.ray_cast((xm, ym, 600.0), (0.0, 0.0, -1.0), depsgraph=dg)
        return float(loc[2]) if ok else None

    def medijan(tocke):
        v = [z for z in (zraka(x, y) for x, y in tocke) if z is not None]
        return (round(float(np.median(v)), 2), round(float(min(v)), 2), round(float(max(v)), 2), len(v)) if v else None

    out = {"status": "PRETPOSTAVKA-IZRAČUN; mjereno na mrežama scene, nije geodetski podatak", "izmjereno": {}, "kanon": dict(KANON)}
    m = out["izmjereno"]
    st = P.stadion
    if st:
        rub = st["vanjski"].buffer(5.0).exterior
        r = medijan([(q.x, q.y) for q in (rub.interpolate(i / 24.0, normalized=True) for i in range(24))])
        if r:
            m["podij_mnv"] = {"medijan": r[0], "min": r[1], "max": r[2], "tocaka": r[3], "gdje": "5 m izvan obrisa stadiona"}
        kr = bpy.data.objects.get("stadion_krov")
        if kr is not None:
            z = np.empty(len(kr.data.vertices) * 3, dtype=np.float32)
            kr.data.vertices.foreach_get("co", z)
            m["vrh_krova_mnv"] = round(float(z.reshape(-1, 3)[:, 2].max()), 2)
            m["unutarnji_rub_krova_mnv"] = round(float(z.reshape(-1, 3)[:, 2].min()), 2)
        ig = bpy.data.objects.get("stadion_igraliste")
        if ig is not None:
            z = np.empty(len(ig.data.vertices) * 3, dtype=np.float32)
            ig.data.vertices.foreach_get("co", z)
            m["igraliste_mnv"] = round(float(np.median(z.reshape(-1, 3)[:, 2])), 2)
    try:
        os_ = LineString(s.site["izvedeno"]["os_maksimirske"]["linija"])
    except Exception:  # noqa: BLE001
        os_ = None
    podrucje = pv.V if pv.V is not None else pv.F
    if os_ is not None and podrucje is not None:
        dio = os_.intersection(podrucje)
        dijelovi = [dio] if dio.geom_type == "LineString" else [d for d in getattr(dio, "geoms", []) if d.geom_type == "LineString"]
        if dijelovi:
            sa = min(os_.project(type(os_.interpolate(0))(d.coords[0])) for d in dijelovi)
            sb = max(os_.project(type(os_.interpolate(0))(d.coords[-1])) for d in dijelovi)
            tocke = [os_.interpolate(t) for t in np.linspace(sa, sb, 200)]
            xm, ym = K.m_iz_n(np.array([q.x for q in tocke]), np.array([q.y for q in tocke]))
            m["duljina_pokrova_m"] = round(float(np.hypot(np.diff(xm), np.diff(ym)).sum()), 1)
            m["pokrov_stacionaza_enu_n_m"] = [round(sa, 1), round(sb, 1)]

            def poprijeko(sx):
                a, b = os_.interpolate(sx - 1.0), os_.interpolate(sx + 1.0)
                t_ = np.array([b.x - a.x, b.y - a.y]) / max(math.hypot(b.x - a.x, b.y - a.y), 1e-9)
                nrm = np.array([t_[1], -t_[0]])
                c = os_.interpolate(sx)
                return [(c.x + nrm[0] * k, c.y + nrm[1] * k) for k in (-13, -11, -9, 9, 11, 13)]

            for kljuc, sx in (("park_zapadni_kraj_pokrova_mnv", sa + 15.0), ("park_istocni_kraj_pokrova_mnv", sb - 15.0)):
                r = medijan(poprijeko(sx))
                if r:
                    m[kljuc] = {"medijan": r[0], "min": r[1], "max": r[2], "tocaka": r[3], "gdje": "15 m od kraja pokrova, uz os ceste"}
            if st:
                from shapely.geometry import Point

                # uz sjevernu tribinu: stacionaže na koje se projicira obris stadiona
                c = np.asarray(st["vanjski"].exterior.coords)
                sts = [os_.project(Point(q)) for q in c]
                med = [r[0] for r in (medijan(poprijeko(sx)) for sx in np.linspace(min(sts), max(sts), 9)) if r]
                if med:
                    m["park_uz_sjevernu_tribinu_mnv"] = {
                        "medijan": round(float(max(med)), 2), "min": round(float(min(med)), 2), "max": round(float(max(med)), 2),
                        "tocaka": len(med), "gdje": "uz os ceste duž projekcije stadiona; uspoređuje se najviša kota (istočni kraj tribine)"}
        # svijetli profil ceste pod pokrovom: zrake od kolnika prema gore; ništa osim podgleda (i vozila) ispod
        # kolnik + visina_portala_m
        if dijelovi and pv.V is not None:
            out["svijetli_profil"] = _svijetli_profil(s, os_, sa, sb)
    out["rub_m19"] = _mjera_m19(s)
    out["pod_ispod_tla"] = _pod_ispod_tla(s)
    # kote plohe po prostoru razine parka (zrake odozgo na mrežu plohe) uz kotu iz programa (krug 3)
    import shapely

    kp = {}
    for q in pv.pl:
        g = q["geom"]
        x0, y0, x1, y1 = g.bounds
        k_ = max(math.sqrt(g.area / 60.0), 1.0)
        X, Y = np.meshgrid(np.arange(x0 + k_ / 2, x1, k_), np.arange(y0 + k_ / 2, y1, k_))
        u = shapely.contains_xy(g, X, Y)
        tocke = list(zip(X[u], Y[u])) or [(g.representative_point().x, g.representative_point().y)]
        r = medijan(tocke)
        if r:
            kp[q["id"]] = {"program_mnv": None if q.get("pod") is None else round(float(q["pod"]), 2), "medijan": r[0],
                           "min": r[1], "max": r[2], "tocaka": r[3], "kategorija": q["kat"]}
    out["kote_prostora_parka"] = kp
    if s.kstat.get("terase"):
        out["terase"] = s.kstat["terase"]
    if s.kstat.get("izostavljene_veze") is not None:
        out["izostavljene_veze"] = s.kstat["izostavljene_veze"]
    # stabla i ljudi u kućicama ili oknima dizala i stubišta (krug 3, M-5): treba biti 0
    tl_ = getattr(s, "_tlocrti_veza", None)
    if tl_ is not None:
        shapely.prepare(tl_)
        out["u_kucicama_veza"] = {}
        for ime_, niz_ in (("stabla", getattr(s, "_stabla_koncepta_n", None)), ("ljudi", getattr(s, "_ljudi_n", None))):
            if niz_ is not None and len(niz_):
                out["u_kucicama_veza"][ime_] = int(shapely.contains_xy(tl_.buffer(1.0), niz_[:, 0], niz_[:, 1]).sum())
    # pojas terasa i ceste iz site.json (os ulice s odmakom pola širine; samo orijentacijski, OSM)
    ter_ = getattr(s, "_ter_c", None)
    if ter_ is not None and ter_.get("pas") is not None:
        from shapely.geometry import LineString as _L

        sir_ = RAZREDI_ULICA
        presjek = []
        for c_ in s.site.get("ceste", []):
            if c_.get("razred") not in sir_:
                continue   # pješačke, biciklističke i staze u parku ne broje se kao ulice
            try:
                g_ = _L(c_["linija"]).buffer(sir_[c_["razred"]] / 2.0 + 1.0)
            except Exception:  # noqa: BLE001
                continue
            a_ = float(g_.intersection(ter_["pas"]).area)
            os_m = float(_L(c_["linija"]).intersection(ter_["pas"]).length)
            if a_ > 0.5 or os_m > 0.0:
                presjek.append({"ulica": c_.get("naziv") or c_.get("id"), "razred": c_["razred"], "m2": round(a_, 1),
                                "os_kroz_terase_m": round(os_m, 1)})
        for tr_ in (s.site.get("tramvaj") or {}).get("pruge", []):
            try:
                a_ = float(_L(tr_["linija"]).buffer(2.0).intersection(ter_["pas"]).area)
            except Exception:  # noqa: BLE001
                continue
            if a_ > 0.5:
                presjek.append({"ulica": "tračnice", "m2": round(a_, 1)})
        for pk_ in s.site.get("parkiralista", []):
            g_ = _poligon(pk_.get("poligon"), pk_.get("rupe"))
            if g_ is not None and g_.intersection(ter_["pas"]).area > 0.5:
                presjek.append({"ulica": "parkiralište", "m2": round(float(g_.intersection(ter_["pas"]).area), 1)})
        out["terase_na_ulicama_osm"] = presjek
        # krug 4 (V3): terase nad prostorima nižih razina (volumen pod do pod + svijetla visina siječe terasu s
        # pločom: treba biti 0) i prostori ispod terasa koji ostaju ispod ploče (podatak)
        nizi_ = s._volumeni_nizih()
        ploca_ = float(ter_.get("ploca", 1.0))
        sukobi_, ispod_ = {}, {}
        for tr_ in ter_.get("trake", []):
            for v_ in nizi_:
                if not v_["geom"].intersects(tr_["geom"]):
                    continue
                a_ = float(v_["geom"].intersection(tr_["geom"]).area)
                if a_ <= 0.5:
                    continue
                cilj_ = sukobi_ if (v_["pod"] < tr_["kota"] and v_["vrh"] > tr_["kota"] - ploca_ + 0.05) else ispod_
                r_ = cilj_.setdefault(v_["id"], {"m2": 0.0, "kategorija": v_["kat"], "volumen_mnv": [round(v_["pod"], 2), round(v_["vrh"], 2)],
                                                 "kota_terase_mnv": round(tr_["kota"], 2)})
                r_["m2"] = round(r_["m2"] + a_, 1)
        out["terase_nad_prostorima_nizih_razina"] = {
            "u_volumenu": sukobi_, "ispod_ploce": ispod_, "ploca_m": ploca_,
            "pravilo": "terasa s pločom ne smije ući u volumen prostora niže razine (pod do pod + svijetla visina; promet uz visinu profila)"}
        # zrake odozgo na svaku traku terase (sredina dubine, 3 točke): pogađa li zraka kotu trake
        from mathutils import Vector as mathutils_vec

        z_r = s._rub()[0]
        d_ = float(ter_["d"])
        bpy.context.view_layer.update()
        dg2 = bpy.context.evaluated_depsgraph_get()
        preskoci = ("stablo", "covjek_", "nositelj_", "vozila")
        uk_, kriva_ = 0, []
        for tr_ in ter_.get("trake", []):
            j_ = tr_["j"]
            sx_ = int(ter_["kat"][j_]) - tr_["kat"]          # indeks trake od ruba
            for f_ in (0.25, 0.5, 0.75):
                m_ = ter_["m0"][j_] + (ter_["m1"][j_] - ter_["m0"][j_]) * f_
                q_ = z_r["p0"][j_] + (z_r["p1"][j_] - z_r["p0"][j_]) * f_ - (sx_ + 0.6) * d_ * m_
                xm_, ym_ = K.m_iz_n(float(q_[0]), float(q_[1]))
                poc_ = mathutils_vec((xm_, ym_, tr_["kota"] + 40.0))
                hit_ = None
                for _ in range(6):
                    ok_, loc_, _n, _i, ob_, _m = s.scene.ray_cast(dg2, poc_, mathutils_vec((0.0, 0.0, -1.0)), distance=200.0)
                    if not ok_:
                        break
                    if ob_ is not None and ob_.name.startswith(preskoci):
                        poc_ = loc_ + mathutils_vec((0.0, 0.0, -0.01))
                        continue
                    hit_ = (float(loc_[2]), ob_.name if ob_ is not None else None)
                    break
                uk_ += 1
                if hit_ is None or abs(hit_[0] - tr_["kota"]) > 0.15:
                    kriva_.append({"x": round(float(q_[0]), 1), "y": round(float(q_[1]), 1), "kota": round(tr_["kota"], 2),
                                   "pogodak": None if hit_ is None else round(hit_[0], 2), "objekt": None if hit_ is None else hit_[1]})
        out["zrake_na_terase"] = {"zraka": uk_, "ne_na_koti": len(kriva_), "primjeri": kriva_[:12]}
    if s.kstat.get("teren_u_stadionu"):
        out["teren_spusten_u_stadionu"] = s.kstat["teren_u_stadionu"]
    if s.kstat.get("provjera_instanci"):
        out["provjera_instanci"] = s.kstat["provjera_instanci"]
    razlike = {}
    for k, v in KANON.items():
        if k in m:
            x = m[k]["medijan"] if isinstance(m[k], dict) else m[k]
            razlike[k] = round(x - v, 2)
    out["razlika_od_kanona"] = razlike
    return out


def _font(v, podebljano=False):
    return SC._font(v, podebljano)


def rastavljeni_prikaz(program_put, izlaz, sirina_px=1600, visina_px=None, razmak_m=None, uzorci=40,
                       smjer_kamere_deg=212.0, visina_kamere_deg=24.0, predmemorija=None):
    """Rastavljeni prikaz po razinama: svaka razina je ploča sa svojim prostorima istisnutima na svijetlu
    visinu, u bojama kategorija, razmaknuta po visini; ortografska kamera. Natpisi, legenda i oznaka dodaju
    se naknadno (Pillow). Razmak između razina nije u mjerilu. Vraća rječnik s putanjom i mjerenim vremenom."""
    from PIL import Image, ImageDraw
    from shapely.ops import unary_union

    t0 = time.time()
    P = Program(program_put)
    s = SC.Scena(slojevi=(), predmemorija=predmemorija)
    bpy = s.bpy
    sc = s.scene
    sp = Spremnik()
    siva = lin((214, 214, 212))
    a_, e_ = math.radians((smjer_kamere_deg + 180.0) % 360.0), math.radians(visina_kamere_deg)
    f = np.array([math.sin(a_) * math.cos(e_), math.cos(a_) * math.cos(e_), -math.sin(e_)])
    R = np.array([math.cos(a_), -math.sin(a_), 0.0])
    U = np.cross(R, f)
    kote = [r["kota"] for r in P.razine if r["kota"] is not None]
    k0 = min(kote) if kote else 0.0

    def visina_prostora(q, r):
        if q["visina"]:
            return q["visina"]
        if q["kat"] in ZATVORENE:
            return r["visina"] or 4.0
        return 3.0 if q["kat"] in ("stadion", "tribine") else 0.5

    # ploča razine = prostori razine prošireni za 2 m (obris razine može biti grub pa bi sve prekrio)
    slojevi_r = []
    for r in P.razine:
        pr = P.prostori_razine(r["i"])
        if not pr:
            continue
        g = unary_union([q["geom"] for q in pr]).buffer(2.0, join_style=2).simplify(0.3)
        kota = r["kota"] if r["kota"] is not None else k0
        dno = min([q["pod"] for q in pr if q["pod"] is not None] + [kota]) - 0.1
        vrh = max((q["pod"] if q["pod"] is not None else kota) + visina_prostora(q, r) for q in pr)
        c = np.concatenate([np.asarray(pol.exterior.coords) for pol in _poligoni(g, 1.0)])
        cm = np.column_stack([*SC.m_iz_n(c[:, 0], c[:, 1])])
        u_tlocrt = cm @ U[:2]
        r_tlocrt = cm @ R[:2]
        slojevi_r.append({"r": r, "pr": pr, "g": g, "dno": dno, "vrh": vrh, "u": (u_tlocrt.min(), u_tlocrt.max()),
                          "rr": (r_tlocrt.min(), r_tlocrt.max()), "kota": kota})
    # pomak po visini (krug 3): iz projicirane dubine tlocrta po stupcima slike. Za svaku razinu ovojnica
    # donjeg i gornjeg ruba na zaslonu (u = tlocrt·U + z·U_z) po stupcu (r); gornja razina mora u svakom
    # zajedničkom stupcu biti cijela iznad donje (uz razmak), pa se ploče ne preklapaju ni kad su kote bliske.
    korak_r = 4.0
    for sl in slojevi_r:
        r_ = sl["r"]
        tock = []
        for q in sl["pr"]:
            pod = q["pod"] if q["pod"] is not None else sl["kota"]
            for pol in _poligoni(q["geom"], 1.0):
                c = np.asarray(pol.exterior.segmentize(2.0).coords)
                tock.append((c, pod + visina_prostora(q, r_)))
        for pol in _poligoni(sl["g"], 1.0):
            tock.append((np.asarray(pol.exterior.segmentize(2.0).coords), sl["dno"]))
        rr_, ub_, ut_ = [], [], []
        for c, vrh_ in tock:
            cm = np.column_stack([*SC.m_iz_n(c[:, 0], c[:, 1])])
            rr_.append(cm @ R[:2])
            u_pl = cm @ U[:2]
            ub_.append(u_pl + (sl["dno"] - 1.2) * U[2])
            ut_.append(u_pl + vrh_ * U[2])
        rr_, ub_, ut_ = np.concatenate(rr_), np.concatenate(ub_), np.concatenate(ut_)
        st_ = np.floor(rr_ / korak_r).astype(np.int64)
        sl["ovoj"] = {}
        for s_, b_, t_ in zip(st_, ub_, ut_):
            for d_s in (-1, 0, 1):   # ovojnica se širi na susjedne stupce (rub ploče)
                o_ = sl["ovoj"].setdefault(int(s_) + d_s, [np.inf, -np.inf])
                o_[0], o_[1] = min(o_[0], b_), max(o_[1], t_)
    # koridor natpisa: lijevo od najlijevijeg dijela razine nema druge razine u istim redcima, pa vodoravna
    # crta natpisa iz lijevog stupca ne prelazi tuđu ploču (razine bliskih kota tada se razmiču i po visini)
    c_min_sve = min(min(sl["ovoj"]) for sl in slojevi_r if sl["ovoj"]) - 2
    for sl in slojevi_r:
        if not sl["ovoj"]:
            continue
        cm_ = min(sl["ovoj"])
        lijevi = [sl["ovoj"][c] for c in range(cm_, cm_ + 4) if c in sl["ovoj"]]
        b_c, t_c = min(v[0] for v in lijevi), max(v[1] for v in lijevi)
        for c in range(c_min_sve, cm_):
            o_ = sl["ovoj"].setdefault(c, [np.inf, -np.inf])
            o_[0], o_[1] = min(o_[0], b_c), max(o_[1], t_c)
    razmak_zaslon = (float(razmak_m) if razmak_m else 9.0) * U[2]
    for i, sl in enumerate(slojevi_r):
        if i == 0:
            sl["dz"] = -sl["dno"]
            continue
        prije = slojevi_r[i - 1]
        treba = prije["dz"] + prije["dno"] - sl["dno"] + 3.0   # redoslijed po visini
        for j in range(i):
            d_ = slojevi_r[j]
            for s_, (b_, _) in sl["ovoj"].items():
                if s_ in d_["ovoj"]:
                    treba = max(treba, (d_["ovoj"][s_][1] + d_["dz"] * U[2] + razmak_zaslon - b_) / U[2])
        sl["dz"] = treba
    sidra, kategorije = [], {}
    # jedna mreža po (razina, kategorija): prolaz podataka tada daje vidljive piksele razine (za crte natpisa)
    # i vidljive kategorije (legenda samo za ono što se vidi)
    skupine = {}
    redni_kat = {}
    for li, sl in enumerate(slojevi_r):
        r, dz = sl["r"], sl["dz"]
        plo = skupine.setdefault((li, ""), Spremnik())
        for pol in _poligoni(sl["g"], 1.0):
            plo.prizma(pol, sl["dno"] + dz - 1.2, sl["dno"] + dz, tuple(c * 0.8 for c in siva), siva, s._trokuti)
        for q in sl["pr"]:
            pod = q["pod"] if q["pod"] is not None else sl["kota"]
            h = visina_prostora(q, r)
            boja = lin(BOJE_KAT.get(q["kat"], "#cccccc"))
            kategorije[q["kat"]] = kategorije.get(q["kat"], 0.0) + q["geom"].area
            redni_kat.setdefault(q["kat"], len(redni_kat) + 1)
            sk = skupine.setdefault((li, q["kat"]), Spremnik())
            for pol in _poligoni(q["geom"], 1.0):
                sk.prizma(pol, pod + dz, pod + dz + h, tuple(c * 0.74 for c in boja), boja, s._trokuti)
        sidra.append((r, sl["g"], sl["dno"] + dz, li))
    razmak = float(np.mean(np.diff([sl["dz"] + sl["dno"] for sl in slojevi_r]))) if len(slojevi_r) > 1 else 0.0
    mat = s.materijal("rastavljeno", atribut_boje="boja", hrapavost=0.9)
    sve_co, objekti = [], []
    for (li, kat_), sk in skupine.items():
        if not len(sk):
            continue
        co = np.asarray(sk.co, dtype=np.float64)
        xm, ym = SC.m_iz_n(co[:, 0], co[:, 1])
        co = np.column_stack([xm, ym, co[:, 2]])
        sve_co.append(co)
        ob = s.dodaj_mrezu(f"rastavljeno_{li}_{kat_ or 'ploca'}", co, sk.plohe, sloj="koncept", boje_ploha=sk.boje, materijal=mat)
        objekti.append((ob, li + 1, redni_kat.get(kat_, 0)))
    co = np.concatenate(sve_co)
    # svjetlo i pozadina
    nt = sc.world.node_tree
    for l in list(nt.links):
        if l.to_node == s._bg:
            nt.links.remove(l)
    s._bg.inputs[0].default_value = (1, 1, 1, 1)
    s._bg.inputs["Strength"].default_value = 0.62
    sun = bpy.data.lights.new("sunce", "SUN")
    sun.energy = 1.5
    sun.angle = math.radians(6.0)
    so = bpy.data.objects.new("sunce", sun)
    sc.collection.objects.link(so)
    so.rotation_euler = (math.radians(48.0), 0.0, math.radians(smjer_kamere_deg - 180.0 + 55.0))
    sc.view_settings.view_transform = "Standard"
    try:
        sc.view_settings.look = "None"
    except TypeError:
        pass
    sc.view_settings.exposure = 0.0
    # ortografska kamera
    pr_r, pr_u = co @ R, co @ U
    sr = np.array([(co[:, 0].min() + co[:, 0].max()) / 2, (co[:, 1].min() + co[:, 1].max()) / 2, (co[:, 2].min() + co[:, 2].max()) / 2])
    podrucje = (0.27, 0.985, 0.085, 0.925)   # udio platna: lijevo, desno, dolje, gore (ostatak su natpisi i legenda)
    W = int(sirina_px)
    if visina_px is None:  # visina lista prema obliku složenog modela
        omjer = (pr_u.max() - pr_u.min()) / max(pr_r.max() - pr_r.min(), 1e-6)
        visina_px = W * float(np.clip(omjer * (podrucje[1] - podrucje[0]) / (podrucje[3] - podrucje[2]), 0.62, 1.6))
    Hh = int(visina_px)
    S = max((pr_r.max() - pr_r.min()) / (podrucje[1] - podrucje[0]),
            (pr_u.max() - pr_u.min()) / ((podrucje[3] - podrucje[2]) * Hh / W))
    sred_r, sred_u = (pr_r.max() + pr_r.min()) / 2, (pr_u.max() + pr_u.min()) / 2
    cam_r = sred_r - ((podrucje[0] + podrucje[1]) / 2 - 0.5) * S
    cam_u = sred_u - ((podrucje[2] + podrucje[3]) / 2 - 0.5) * S * Hh / W
    polozaj = R * cam_r + U * cam_u + f * (float(sr @ f) - 3000.0)
    import mathutils

    cd = bpy.data.cameras.new("orto")
    cd.type = "ORTHO"
    cd.ortho_scale = S
    cd.clip_start, cd.clip_end = 1.0, 20000.0
    cd.sensor_fit = "HORIZONTAL"
    cam = bpy.data.objects.new("orto", cd)
    sc.collection.objects.link(cam)
    cam.matrix_world = mathutils.Matrix(((R[0], U[0], -f[0], polozaj[0]), (R[1], U[1], -f[1], polozaj[1]),
                                         (R[2], U[2], -f[2], polozaj[2]), (0, 0, 0, 1)))
    sc.camera = cam
    sc.render.resolution_x, sc.render.resolution_y, sc.render.resolution_percentage = W, Hh, 100
    sc.render.film_transparent = True
    sc.cycles.samples = int(uzorci)
    sc.cycles.use_adaptive_sampling = True
    sc.render.image_settings.file_format = "PNG"
    sc.render.image_settings.color_mode = "RGBA"
    sc.render.image_settings.color_depth = "8"
    tmp = s._tmp("rastavljeno.png")
    sc.render.filepath = str(tmp)
    bpy.ops.render.render(write_still=True)
    t_render = time.time() - t0
    # prolazi podataka (1 uzorak): vidljiva razina i vidljiva kategorija po pikselu
    karte = {}
    for kljuc_, stupac in (("razina", 1), ("kat", 2)):
        for ob, ri, ki in objekti:
            ob.pass_index = ri if kljuc_ == "razina" else ki
        exr = s._tmp(f"rastavljeno_{kljuc_}.exr")
        try:
            bpy.context.view_layer.material_override = s._materijal_podataka()
            sc.cycles.samples = 1
            sc.cycles.use_adaptive_sampling = False
            sc.cycles.pixel_filter_type = "BOX"
            sc.cycles.filter_width = 0.01
            sc.render.image_settings.file_format = "OPEN_EXR"
            sc.render.image_settings.color_depth = "32"
            sc.render.filepath = str(exr)
            bpy.ops.render.render(write_still=True)
            dd = s._ucitaj_exr(exr)
            karte[kljuc_] = np.where(dd[..., 3] < 0.5, 0, np.rint(dd[..., 1])).astype(np.int32)
        finally:
            bpy.context.view_layer.material_override = None
            Path(exr).unlink(missing_ok=True)

    # list se reže po stvarnom obrisu rendera (alfa): bez praznog pojasa iznad i ispod modela
    r_im = Image.open(tmp).convert("RGBA")
    a_ = np.asarray(r_im)[..., 3]
    redovi = np.nonzero(a_.max(axis=1) > 8)[0]
    y0_m, y1_m = (int(redovi[0]), int(redovi[-1]) + 1) if len(redovi) else (0, Hh)
    v2_ = max(11, W // 110)
    v3_ = max(10, W // 135)
    gore = int(W * 0.018) + int(max(15, W // 62) * 1.45) + int(v2_ * 1.5) + int(v3_ * 3.0)
    n_kat = len([i for i in redni_kat.values() if int((karte["kat"] == i).sum()) >= 30])
    dolje = int(v2_ * 2.1) + (n_kat // 4 + 1) * int(v3_ * 1.75) + int(v3_ * 3.0)
    pomak_y = gore - y0_m
    H_rend = Hh
    Hh = (y1_m - y0_m) + gore + dolje

    def px(p):
        d = np.asarray(p, dtype=np.float64) - polozaj
        return (W * (0.5 + float(d @ R) / S), H_rend * 0.5 - float(d @ U) / S * W + pomak_y)

    slika = Image.new("RGB", (W, Hh), (255, 255, 255))
    slika.paste(r_im, (0, pomak_y), r_im)
    d = ImageDraw.Draw(slika)
    v1, v2, v3 = max(15, W // 62), max(11, W // 110), max(10, W // 135)
    f1, f2, f2b, f3 = _font(v1, True), _font(v2), _font(v2, True), _font(v3)
    rub = int(W * 0.018)
    d.text((rub, rub), "Rastavljeni prikaz po razinama", font=f1, fill=(20, 24, 30))
    d.text((rub, rub + int(v1 * 1.45)), str(P.meta.get("naziv") or P.put.name)[:110], font=f2, fill=(70, 74, 80))
    d.text((rub, rub + int(v1 * 1.45) + int(v2 * 1.5)),
           "Razmak između razina nije u mjerilu; visine prostora su svijetle visine iz programa ili zadane.", font=f3, fill=(110, 114, 120))
    # natpisi razina (krug 3): lijevi stupac i vodoravna crta do prvog piksela modela u tom retku, koji
    # pripada toj razini; crta tako prolazi samo kroz pozadinu i ne prelazi tuđu ploču
    kr = karte["razina"][y0_m:y1_m]
    ima = kr > 0
    prvi_x = np.where(ima.any(axis=1), ima.argmax(axis=1), -1)
    prvi_r = np.where(prvi_x >= 0, kr[np.arange(kr.shape[0]), np.maximum(prvi_x, 0)], 0)
    zauzeto_y, natpisi = [], []
    korak_n = v2 * 2.9
    for r, g, zr, li in sorted(sidra, key=lambda q: -q[2]):
        kota_t = "–" if r["kota"] is None else f"{r['kota']:.1f}".replace(".", ",")
        naziv = r["naziv"] or r["id"]
        while len(naziv) > 12 and d.textlength(naziv, font=f2b) > W * 0.25:
            naziv = naziv[:-2].rstrip() + "…"
        tx = rub + max(d.textlength(naziv, font=f2b), d.textlength(f"kota poda {kota_t} m n. v.", font=f3)) + 8
        redovi_li = np.nonzero((prvi_r == li + 1) & (prvi_x > tx + 12))[0]
        vid = kr == li + 1
        ax = ay = None
        if len(redovi_li):
            sred_y = float(np.median(np.nonzero(vid)[0])) if vid.any() else float(redovi_li.mean())
            for yy in sorted(redovi_li, key=lambda q: abs(q - sred_y)):
                if all(abs(yy + gore - z_) >= korak_n for z_ in zauzeto_y):
                    ax, ay = float(prvi_x[yy]) + 2.0, float(yy) + gore
                    break
        if ax is None and vid.sum() >= 20:   # zamjena: najlijeviji vidljivi piksel razine (crta može biti kosa)
            yy, xx = np.nonzero(vid)
            lijevo = xx <= np.percentile(xx, 1.0)
            ax, ay = float(xx[lijevo].mean()) + 2.0, float(np.median(yy[lijevo])) + gore
        ty = (ay if ay is not None else gore + 40.0) - v2 * 0.9
        for z_ in sorted(zauzeto_y):
            if abs(ty + v2 * 0.9 - z_) < korak_n:
                ty = z_ + korak_n - v2 * 0.9
        zauzeto_y.append(ty + v2 * 0.9)
        d.text((rub, ty), naziv, font=f2b, fill=(20, 24, 30))
        d.text((rub, ty + int(v2 * 1.3)), f"kota poda {kota_t} m n. v.", font=f3, fill=(70, 74, 80))
        if ax is not None:
            d.line([(tx, ty + v2 * 0.9), (max(ax - 6, tx + 4), ay), (ax, ay)], fill=(120, 124, 130), width=1)
            d.ellipse([ax - 2.5, ay - 2.5, ax + 2.5, ay + 2.5], fill=(120, 124, 130))
            natpisi.append({"razina": r["id"], "crta_vodoravna": abs(ty + v2 * 0.9 - ay) < 1.0})
    # legenda: samo kategorije vidljive na slici (najmanje 30 piksela), redom po broju piksela
    vid_kat = {k: int((karte["kat"] == i).sum()) for k, i in redni_kat.items()}
    red = sorted([k for k in kategorije if vid_kat.get(k, 0) >= 30], key=lambda k: -vid_kat[k])
    stupaca = 4
    kv = int(v3 * 1.1)
    y_l = Hh - int(v2 * 2.1) - (len(red) // stupaca + 1) * int(v3 * 1.75) - int(v3 * 0.8)
    sir = (W - 2 * rub) / stupaca
    for i, k in enumerate(red):
        x = rub + (i % stupaca) * sir
        y = y_l + (i // stupaca) * int(v3 * 1.75)
        d.rectangle([x, y, x + kv, y + kv], fill=BOJE_KAT.get(k, "#cccccc"), outline=(110, 110, 110))
        d.text((x + kv + 6, y - 1), NAZIVI_KAT.get(k, k), font=f3, fill=(40, 44, 50))
    # oznaka
    vis_t = int(v2 * 2.1)
    d.rectangle([0, Hh - vis_t, W, Hh], fill=(18, 22, 28))
    d.text((rub, Hh - vis_t + int(v2 * 0.45)), OZNAKA + " · shema iz programa po razinama, render nije dokaz", font=f2b, fill=(255, 255, 255))
    izlaz = Path(izlaz)
    izlaz.parent.mkdir(parents=True, exist_ok=True)
    if izlaz.suffix.lower() in (".jpg", ".jpeg"):
        slika.save(izlaz, quality=92, optimize=True)
    else:
        slika.save(izlaz, optimize=True)
    pop = {"status": "AI građanski koncept, PRIJEDLOG; shema, nije projekt", "oznaka": OZNAKA, "datum": time.strftime("%Y-%m-%d"),
           "program": {"datoteka": P.put.name, "naziv": P.meta.get("naziv"), "verzija": P.meta.get("verzija")},
           "razmak_razina_m": round(razmak, 1), "razina": len(P.razine), "prostora": len(P.prostori),
           "kamera": {"vrsta": "ortografska", "smjer_od_modela_deg": smjer_kamere_deg, "visina_deg": visina_kamere_deg,
                      "sirina_kadra_m": round(float(S), 1)},
           "vrijeme_s": {"gradnja_i_render": round(t_render, 1), "ukupno": round(time.time() - t0, 1)},
           "legenda": {k: NAZIVI_KAT.get(k, k) for k in red},
           "kategorije_nevidljive_u_kadru": sorted(k for k in kategorije if k not in red),
           "natpisi": natpisi, "pomak_razina_m": {sl["r"]["id"]: round(float(sl["dz"] + sl["dno"]), 1) for sl in slojevi_r}}
    izlaz.with_suffix(".json").write_text(json.dumps(pop, ensure_ascii=False, indent=1), encoding="utf-8")
    _log(f"rastavljeni prikaz {izlaz.name}: {pop['vrijeme_s']}")
    return {"put": str(izlaz), "popratno": pop}


def _odrezi_istok(s, x_rez_m, sred_y_m, pojas_m=1450.0):
    """Rez sjever-jug u sjenčanju: u svim materijalima scene ploha je prozirna istočno od ravnine x = x_rez_m
    (ENU-M), u pojasu ±pojas_m oko presjeka (daleki teren ostaje cijel). Rez je točan (po pikselu), ne mijenja
    mreže i vrijedi i za instancirana stabla. Prozirni dijelovi ne bacaju sjenu. Prolazi maske i dubine rade s
    materijalom podataka i reza ne vide, pa se uz presjek renderira samo slika. Vraća broj izmijenjenih materijala."""
    bpy = s.bpy
    broj = 0
    for mat in list(bpy.data.materials):
        if not mat.use_nodes or mat.node_tree is None:
            continue
        nt = mat.node_tree
        izl = [n for n in nt.nodes if n.type == "OUTPUT_MATERIAL"]
        izl = [n for n in izl if n.is_active_output] or izl
        if not izl or not izl[0].inputs["Surface"].is_linked:
            continue
        out = izl[0]
        izvor = out.inputs["Surface"].links[0].from_socket
        geo = nt.nodes.new("ShaderNodeNewGeometry")
        sep = nt.nodes.new("ShaderNodeSeparateXYZ")
        nt.links.new(geo.outputs["Position"], sep.inputs[0])

        def mat_op(op, a, b=None):
            n = nt.nodes.new("ShaderNodeMath")
            n.operation = op
            for i, v in enumerate((a, b)):
                if v is None:
                    continue
                if isinstance(v, (int, float)):
                    n.inputs[i].default_value = float(v)
                else:
                    nt.links.new(v, n.inputs[i])
            return n.outputs[0]

        istok = mat_op("GREATER_THAN", sep.outputs["X"], float(x_rez_m))
        uz_y = mat_op("LESS_THAN", mat_op("ABSOLUTE", mat_op("SUBTRACT", sep.outputs["Y"], float(sred_y_m))), float(pojas_m))
        uz_x = mat_op("LESS_THAN", mat_op("SUBTRACT", sep.outputs["X"], float(x_rez_m)), float(pojas_m))
        fac = mat_op("MULTIPLY", mat_op("MULTIPLY", istok, uz_y), uz_x)
        tr = nt.nodes.new("ShaderNodeBsdfTransparent")
        mix = nt.nodes.new("ShaderNodeMixShader")
        nt.links.new(fac, mix.inputs[0])
        nt.links.new(izvor, mix.inputs[1])
        nt.links.new(tr.outputs[0], mix.inputs[2])
        nt.links.new(mix.outputs[0], out.inputs["Surface"])
        broj += 1
    s.scene.cycles.transparent_max_bounces = 128
    return broj


def presjecna_perspektiva(program_put, izlaz, sirina_px=1600, uzorci=64, kada="2026-06-21 11:00", udaljenost_m=300.0,
                          kota_oka=176.0, azimut_od_cilja_deg=96.0, predmemorija=None,
                          slojevi_scene=("teren_blizu", "teren_regija", "teren_daleko", "zgrade", "drvece"), **opcije):
    """Presječna perspektiva: model i podloga odrezani okomitom ravninom sjever-jug kroz središte stadiona (i
    Maksimirsku); istočni dio je uklonjen, pogled je s istoka-jugoistoka iz zraka. Prostori nižih razina su kutije u
    bojama kategorija (opcija unutrasnjost), presjek tla je tamna ploha do 8 m ispod najniže kote tla na rezu, na svijetloj podlozi makete. Vraća (scena, rezultat)."""
    opcije.setdefault("unutrasnjost", True)
    s = izgradi(program_put, slojevi_scene=slojevi_scene, predmemorija=predmemorija, **opcije)
    P, pv = s.program, s.povrsina
    cn = P.stadion["sredina"] if P.stadion else (pv.F.centroid.x, pv.F.centroid.y)
    cx, cy = K.m_iz_n(float(cn[0]), float(cn[1]))
    t0 = time.time()
    obrisano = {"materijala_s_rezom": _odrezi_istok(s, float(cx), float(cy))}
    # presjek tla: okomita tamna ploha od današnjeg tla do 100 m n. v. duž ravnine reza
    ys = np.arange(cy - 1400.0, cy + 1400.0, 2.0)
    xn, yn = K.n_iz_m(np.full(len(ys), float(cx)), ys)
    zt = np.asarray(s.tlo_n(xn, yn), dtype=np.float64)
    vrh = [(float(cx) - 0.05, float(y), float(z)) for y, z in zip(ys, zt)]
    z_baze = float(np.floor(zt.min())) - 8.0
    dno = [(float(cx) - 0.05, float(y), z_baze) for y in ys]
    n = len(ys)
    plohe = [(i, i + 1, n + i + 1, n + i) for i in range(n - 1)]
    s.dodaj_mrezu("presjek_tla", vrh + dno, plohe, sloj="koncept", boja=lin((58, 46, 36)))
    # podloga makete istočno od reza (inače se kroz uklonjeni dio vidi daleka ravna podloga)
    x0_, x1_, y0_, y1_ = float(cx) - 0.05, float(cx) + 1400.0, float(cy) - 1400.0, float(cy) + 1400.0
    s.dodaj_mrezu("presjek_podloga", [(x0_, y0_, z_baze), (x1_, y0_, z_baze), (x1_, y1_, z_baze), (x0_, y1_, z_baze)],
                  [(0, 1, 2, 3)], sloj="koncept", boja=lin((196, 194, 188)))
    kam = KAM.pogled_na((float(cx) - 10.0, float(cy) + 70.0, 124.0), azimut_od_cilja_deg=azimut_od_cilja_deg,
                        udaljenost_m=udaljenost_m, kota_oka=kota_oka, f35_mm=24.0, sirina_px=sirina_px, omjer=16 / 9,
                        naziv="presjek_sjever_jug")
    s.postavi_kameru(kam)
    s.scene.camera.data.shift_y = 0.05   # rez u donjoj trećini kadra, bez velike plohe podloge
    s.postavi_sunce(kada)
    r = s.renderiraj(izlaz, uzorci=uzorci, prolazi=("slika",),
                     oznaka=OZNAKA_RENDER + " · perspektiva reza kroz stadion, nije presjek pokrova (vidi poprecni_presjek)",
                     dodatno={"presjek": {"ravnina": "okomita, sjever-jug, kroz središte stadiona", "x_enu_m": round(float(cx), 1),
                                          "rez": obrisano, "rez_s": round(time.time() - t0, 1),
                                          "napomena": "rez u sjenčanju (prozirno istočno od ravnine); presječene plohe nisu "
                                                      "zatvorene; prostori nižih razina su kutije u bojama kategorija; "
                                                      "presjek tla je shema"}})
    return s, r


def _svg_u_png(svg_put, png_put, sirina, visina):
    """SVG u PNG preko Chromiuma (Playwright iz Node.js); bez Playwrighta preko PyMuPDF-a."""
    import subprocess

    js = ("const {chromium}=require('playwright');(async()=>{const b=await chromium.launch();"
          f"const p=await b.newPage({{viewport:{{width:{int(sirina)},height:{int(visina)}}},deviceScaleFactor:1}});"
          f"await p.goto('file://{Path(svg_put).resolve()}');"
          f"await p.screenshot({{path:'{Path(png_put).resolve()}',clip:{{x:0,y:0,width:{int(sirina)},height:{int(visina)}}}}});"
          "await b.close();})().catch(e=>{console.error(e);process.exit(1)});")
    try:
        subprocess.run(["node", "-e", js], check=True, capture_output=True, timeout=120)
        return "chromium"
    except Exception:  # noqa: BLE001
        import fitz

        d = fitz.open(str(svg_put))
        d[0].get_pixmap(dpi=72).save(str(png_put))
        return "pymupdf"


def poprecni_presjek(program_put, izlaz, x_n=None, sirina_px=1800, opcije=None):
    """Poprečni presjek kroz Maksimirsku (vektorska shema, SVG + PNG), bez Blendera: rez sjever-jug kroz
    središte stadiona i kroz zapadni i istočni dio pokrova (35 m od krajeva). Crta današnje tlo, plohu parka,
    pokrov s podgledom, cestu na današnjoj koti sa svijetlim profilom portala, prostore nižih razina u bojama
    kategorija te stadion (tribine, igralište, krov, pročelje) i ispisuje kote izmjerene na plohi modela.
    Visine nisu uvećane (1 : 1). x_n: popis vlastitih položaja reza (ENU-N). Vraća rječnik s putanjama i kotama."""
    from shapely.geometry import LineString
    from xml.sax.saxutils import escape

    P = Program(program_put)
    o = {**ZADANO_KONCEPT, **(opcije or {})}
    site = json.loads((SC.VIZ / "site.json").read_text(encoding="utf-8"))
    teren = SC.Teren()
    pv = Povrsina(P, teren.kota_n, o, site)
    st = P.stadion
    deb, hp = float(o["debljina_pokrova_m"]), float(o["visina_portala_m"])
    try:
        os_ = LineString(site["izvedeno"]["os_maksimirske"]["linija"])
    except Exception:  # noqa: BLE001
        os_ = None
    rezovi = []
    if x_n:
        rezovi = [(float(x), f"x = {float(x):.0f} m") for x in x_n]
    else:
        if st:
            rezovi.append((float(st["sredina"][0]), "kroz središte stadiona"))
        if pv.V is not None:
            x0, _, x1, _ = pv.V.bounds
            rezovi = [(x0 + 35.0, "zapadni dio pokrova")] + rezovi + [(x1 - 35.0, "istočni dio pokrova")]
    if not rezovi:
        raise ValueError("program nema ni stadion ni pokrov nad prometom: nema poprečnog presjeka")

    def y_osi(x):
        if os_ is None:
            return None
        pr = os_.intersection(LineString([(x, -5000), (x, 5000)]))
        if pr.is_empty:
            return None
        return float(np.mean([g.y for g in getattr(pr, "geoms", [pr])]))

    paneli = []
    for x, opis in rezovi:
        yo = y_osi(x)
        if st and opis == "kroz središte stadiona":
            _, sy0, _, sy1 = st["vanjski"].bounds
            ya, yb = sy0 - 45.0, max(sy1, yo or sy1) + 70.0
        else:
            yc = yo if yo is not None else (pv.V.bounds[1] + pv.V.bounds[3]) / 2
            ya, yb = yc - 60.0, yc + 45.0
        ys = np.arange(ya, yb + 0.01, 0.5)
        xs = np.full(len(ys), x)
        tlo = np.asarray(teren.kota_n(xs, ys), dtype=np.float64)
        i, j = pv.celija(xs, ys)
        L = pv.L[i, j]
        park = np.full(len(ys), np.nan)
        for k in np.unique(L[L >= 0]):
            m = L == k
            park[m] = pv.z_prostora(pv.pl[int(k)], xs[m], ys[m])
        svj = L == -2
        zv = np.where(np.isnan(park), pv.z_vrha(xs, ys), park)
        import shapely

        pod_pokrovom = shapely.contains_xy(pv.V, xs, ys) if pv.V is not None else np.zeros(len(ys), bool)
        linija = LineString([(x, ya), (x, yb)])
        nize = []
        for q in P.prostori:
            if q["razina"] >= P.i_park or q["pod"] is None:
                continue
            pr = q["geom"].intersection(linija)
            for g in getattr(pr, "geoms", [pr]):
                if g.is_empty or g.geom_type != "LineString" or g.length < 1.0:
                    continue
                yy = [c[1] for c in g.coords]
                h = q["visina"] or (P.razine[q["razina"]]["visina"] or o["visina_zatvorenog_m"] if q["kat"] in ZATVORENE else 0.3)
                nize.append({"y0": min(yy), "y1": max(yy), "z0": q["pod"], "z1": q["pod"] + h, "kat": q["kat"], "id": q["id"]})
        stad = None
        if st and st["vanjski"].intersects(linija):
            stad = {"trib": [], "krov": [], "igr": None, "obris": None}
            pr = st["vanjski"].intersection(linija)
            yy = [c[1] for g in getattr(pr, "geoms", [pr]) for c in g.coords]
            stad["obris"] = (min(yy), max(yy))
            for tr in st["tribine"]:
                prsten = tr["vanj"].difference(tr["unut"]).intersection(linija)
                for g in getattr(prsten, "geoms", [prsten]):
                    if g.is_empty or g.geom_type != "LineString":
                        continue
                    a, b = g.coords[0][1], g.coords[-1][1]
                    sred = st["sredina"][1]
                    # tribina se diže od unutarnjeg ruba (bliže sredini) prema vanjskom
                    blize, dalje = (a, b) if abs(a - sred) < abs(b - sred) else (b, a)
                    stad["trib"].append((blize, dalje, tr["dno"], tr["vrh"]))
            sjv = st.get("sjever")
            if sjv is not None and sjv["obris"] is not None:
                from shapely.geometry import Point as _Pt
                stad["trib"] = [t_ for t_ in stad["trib"] if not sjv["obris"].contains(_Pt(x, (t_[0] + t_[1]) / 2))]
                prs = sjv["obris"].intersection(linija)
                for g in getattr(prs, "geoms", [prs]):
                    if g.is_empty or g.geom_type != "LineString" or g.length < 5.0:
                        continue
                    a, b = g.coords[0][1], g.coords[-1][1]
                    blize, dalje = (a, b) if abs(a - st["sredina"][1]) < abs(b - st["sredina"][1]) else (b, a)
                    kk = abs(dalje - blize) / float(sjv["profil_d"][-1])
                    sg = 1.0 if dalje > blize else -1.0
                    stad["sjever"] = {"y": [blize + sg * d * kk for d in sjv["profil_d"]], "z": list(sjv["profil_z"]),
                                      "naziv": sjv["naziv"]}
            z_igr = P.kota_igralista(o["kota_igralista"])
            if st["igraliste"] is not None:
                pr = st["igraliste"].intersection(linija)
                yy = [c[1] for g in getattr(pr, "geoms", [pr]) for c in g.coords] if not pr.is_empty else []
                if yy:
                    stad["igr"] = (min(yy), max(yy), z_igr)
            kr = st["krov"]
            vrh_k = (kr["vrh"] if kr and kr["vrh"] else o["vrh_krova_mnv"])
            rub_k = (kr["rub"] if kr and kr["rub"] else vrh_k - 10.0)
            if kr:
                prsten = kr["vanj"].difference(kr["unut"]).intersection(linija)
                for g in getattr(prsten, "geoms", [prsten]):
                    if g.is_empty or g.geom_type != "LineString":
                        continue
                    a, b = g.coords[0][1], g.coords[-1][1]
                    blize, dalje = (a, b) if abs(a - st["sredina"][1]) < abs(b - st["sredina"][1]) else (b, a)
                    stad["krov"].append((blize, dalje, rub_k, vrh_k))
            stad["vrh_krova"] = vrh_k
        paneli.append({"x": x, "opis": opis, "ys": ys, "tlo": tlo, "park": park, "svj": svj, "zv": zv, "pod": pod_pokrovom,
                       "nize": nize, "stad": stad, "y_osi": yo})

    # kote po panelu (izmjereno na plohi modela)
    for pn in paneli:
        k = {}
        ys, yo = pn["ys"], pn["y_osi"]
        if yo is not None and pn["pod"].any():
            iy = int(np.argmin(np.abs(ys - yo)))
            if pn["pod"][iy]:
                k["kolnik"] = (yo, float(pn["tlo"][iy]))
                from shapely.geometry import Point as _Pt
                kp_ = [q for q in P.prostori if q["kat"] == "promet_cesta" and q["geom"].contains(_Pt(pn["x"], yo))]
                pn["kolnik_program"] = (kp_[0]["pod"], kp_[0]["id"]) if kp_ else None
                # podgled: na osi ili najbliže osi gdje nad cestom nije svjetlarnik (krug 3, M-3)
                ok_ = np.nonzero(pn["pod"] & ~pn["svj"] & ~np.isnan(pn["park"]))[0]
                if len(ok_):
                    ip_ = int(ok_[np.argmin(np.abs(ys[ok_] - yo))])
                    k["podgled"] = (float(ys[ip_]), float(pn["zv"][ip_] - deb))
                blizu = np.nonzero(~np.isnan(pn["park"]) & pn["pod"] & (np.abs(ys - yo) <= 12.0))[0]
                if len(blizu):
                    ib = int(blizu[np.argmin(np.abs(ys[blizu] - yo))])
                    k["park nad cestom"] = (float(ys[ib]), float(pn["park"][ib]))
        if pn["stad"]:
            a, b = pn["stad"]["obris"]
            for yy in (a - 5.0, b + 5.0):
                iy = int(np.argmin(np.abs(ys - yy)))
                if not np.isnan(pn["park"][iy]):
                    k.setdefault("podij", (yy, float(pn["park"][iy])))
            if pn["stad"]["igr"]:
                ia, ib, zi = pn["stad"]["igr"]
                k["igralište"] = ((ia + ib) / 2, zi)
            k["vrh krova"] = (pn["stad"]["krov"][0][1] if pn["stad"]["krov"] else b, pn["stad"]["vrh_krova"])
        pn["kote"] = k

    # crtanje: zajedničko mjerilo (1 : 1), stadion gore, pokrovi ispod jedan do drugoga
    rub = 70.0
    W = float(sirina_px)
    sirine = [pn["ys"][-1] - pn["ys"][0] for pn in paneli]
    gornji = [pn for pn in paneli if pn["stad"]] or paneli[:1]
    donji = [pn for pn in paneli if pn not in gornji]
    def mjerilo_reda(red_):
        dulj = sum(pn["ys"][-1] - pn["ys"][0] for pn in red_)
        return min((W - 2 * rub - 70 * (len(red_) - 1)) / max(dulj, 1.0), 9.0)

    def zr(pn):
        v = np.concatenate([pn["tlo"], pn["park"][~np.isnan(pn["park"])]])
        lo = float(np.nanmin(v)) - 3.0
        hi = float(np.nanmax(v)) + 4.0
        if pn["stad"]:
            hi = max(hi, pn["stad"]["vrh_krova"] + 4.0)
            if pn["stad"]["igr"]:
                lo = min(lo, pn["stad"]["igr"][2] - 3.0)
        for q in pn["nize"]:
            lo = min(lo, q["z0"] - 1.0)
        return math.floor(lo), math.ceil(hi)

    svg = []
    y_cur = 96.0
    redovi = [gornji] + ([donji] if donji else [])
    raspored = []
    for red_ in redovi:
        x_cur = rub
        h_red = 0.0
        s_m = mjerilo_reda(red_)
        for pn in red_:
            pn["s_m"] = s_m
            z0, z1 = zr(pn)
            w = (pn["ys"][-1] - pn["ys"][0]) * s_m
            h = (z1 - z0) * s_m
            raspored.append((pn, x_cur, y_cur + 34, w, h, z0, z1))
            x_cur += w + 70
            h_red = max(h_red, h)
        y_cur += h_red + 34 + 70
    kat_upotrijebljene = {}
    kutije = []   # zauzeti okviri natpisa (krug 3, M-3)

    def okvir(x, y, tekst, vel, sidro):
        w_ = 0.62 * vel * len(tekst)
        x0_ = x - w_ if sidro == "end" else (x - w_ / 2 if sidro == "middle" else x)
        return (x0_, y - vel, x0_ + w_, y + 3)

    def sijece(a, b):
        return a[0] < b[2] and b[0] < a[2] and a[1] < b[3] and b[1] < a[3]

    def T(x, y, tekst, vel=13, deb_=False, boja="#1c2026", sidro="start"):
        svg.append(f'<text x="{x:.1f}" y="{y:.1f}" font-size="{vel}" font-weight="{"bold" if deb_ else "normal"}" '
                   f'fill="{boja}" text-anchor="{sidro}">{escape(tekst)}</text>')

    def put(pts):
        return " ".join(f"{a:.1f},{b:.1f}" for a, b in pts)

    T(rub, 40, "Poprečni presjek kroz Maksimirsku: cesta, pokrov, park i stadion", 22, True)
    T(rub, 66, f"{P.meta.get('naziv') or P.put.name} · shema iz programa po razinama · visine nisu uvećane (1 : 1) · "
               f"pogled s istoka, jug lijevo, sjever desno", 13, False, "#50555c")
    for pn, X0, Y0, w, h, z0, z1 in raspored:
        ys = pn["ys"]
        s_m = pn["s_m"]
        sx = lambda y, X0=X0, ys=ys: X0 + (y - ys[0]) * s_m  # noqa: E731
        sy = lambda z, Y0=Y0, z1=z1: Y0 + (z1 - z) * s_m      # noqa: E731
        T(X0, Y0 - 12, f"Rez {pn['opis']} (x = {pn['x']:.0f} m, ENU-N)", 14, True)
        svg.append(f'<rect x="{X0:.1f}" y="{Y0:.1f}" width="{w:.1f}" height="{h:.1f}" fill="#f6f7f8" stroke="#c9ccd0" stroke-width="0.8"/>')
        # mreža kota
        for zz in range(int(math.ceil(z0 / 5.0) * 5), int(z1) + 1, 5):
            svg.append(f'<line x1="{X0:.1f}" y1="{sy(zz):.1f}" x2="{X0 + w:.1f}" y2="{sy(zz):.1f}" stroke="#e1e3e6" stroke-width="0.6"/>')
            T(X0 - 6, sy(zz) + 4, f"{zz}", 10, False, "#80858c", "end")
        # prostori nižih razina
        for q in sorted(pn["nize"], key=lambda q: q["z0"]):
            boja = BOJE_KAT.get(q["kat"], "#cccccc")
            kat_upotrijebljene[q["kat"]] = boja
            svg.append(f'<rect x="{sx(q["y0"]):.1f}" y="{sy(q["z1"]):.1f}" width="{(q["y1"] - q["y0"]) * s_m:.1f}" '
                       f'height="{max((q["z1"] - q["z0"]) * s_m, 1.0):.1f}" fill="{boja}" fill-opacity="0.75" stroke="#8a8f96" stroke-width="0.4"/>')
        # današnje tlo (crtkano) i tlo u presjeku
        pts = [(sx(y), sy(z)) for y, z in zip(ys, pn["tlo"])]
        svg.append(f'<polygon points="{put(pts + [(sx(ys[-1]), sy(z0)), (sx(ys[0]), sy(z0))])}" fill="#d9cfbf" fill-opacity="0.55" stroke="none"/>')
        # pokrov: ploča između podgleda i plohe parka, cesta i svijetli profil
        pod = pn["pod"] & ~np.isnan(pn["park"])
        for a, b in _nizovi(pod):
            gornja = [(sx(ys[i]), sy(pn["park"][i])) for i in range(a, b)]
            donja = [(sx(ys[i]), sy(pn["zv"][i] - deb)) for i in range(b - 1, a - 1, -1)]
            svg.append(f'<polygon points="{put(gornja + donja)}" fill="#8d8f93" stroke="#4a4d52" stroke-width="0.8"/>')
            xs_ = [q[0] for q in gornja + donja]
            ys_ = [q[1] for q in gornja + donja]
            kutije.append((min(xs_), min(ys_), max(xs_), max(ys_)))   # ploča pokrova: natpisi je zaobilaze
        for a, b in _nizovi(pn["pod"]):
            # svijetli profil (pretpostavljeni portal) nad kolnikom
            yy0, yy1 = ys[a], ys[b - 1]
            zk = float(np.median(pn["tlo"][a:b]))
            svg.append(f'<rect x="{sx(yy0) + 2:.1f}" y="{sy(zk + hp):.1f}" width="{(yy1 - yy0) * s_m - 4:.1f}" height="{hp * s_m:.1f}" '
                       f'fill="none" stroke="#2f6fb5" stroke-width="0.9" stroke-dasharray="4 3"/>')
            tp = f"profil {hp:.1f} m".replace(".", ",")
            T(sx(yy0) + 4, sy(zk + hp) + 13, tp, 10, False, "#2f6fb5")
            kutije.append(okvir(sx(yy0) + 4, sy(zk + hp) + 13, tp, 10, "start"))
        # ploha parka
        ima = ~np.isnan(pn["park"])
        for a, b in _nizovi(ima):
            pts = [(sx(ys[i]), sy(pn["park"][i])) for i in range(a, b)]
            svg.append(f'<polyline points="{put(pts)}" fill="none" stroke="#3d7a2a" stroke-width="2.4"/>')
        for a, b in _nizovi(pn["svj"]):
            zz = pn["zv"][a:b] + 0.4
            svg.append(f'<line x1="{sx(ys[a]):.1f}" y1="{sy(float(np.max(zz))):.1f}" x2="{sx(ys[b - 1]):.1f}" y2="{sy(float(np.max(zz))):.1f}" '
                       f'stroke="#5cc3e6" stroke-width="3"/>')
        # stadion
        sd = pn["stad"]
        if sd:
            if sd["igr"]:
                ia, ib, zi = sd["igr"]
                svg.append(f'<line x1="{sx(ia):.1f}" y1="{sy(zi):.1f}" x2="{sx(ib):.1f}" y2="{sy(zi):.1f}" stroke="#3f8f3a" stroke-width="3"/>')
            for a, b, zd, zg in sd["trib"]:
                svg.append(f'<polygon points="{put([(sx(a), sy(zd)), (sx(b), sy(zg)), (sx(b), sy(zd))])}" fill="#2459b8" fill-opacity="0.85" stroke="#173b7a" stroke-width="0.6"/>')
            if sd.get("sjever"):
                sy_, sz_ = sd["sjever"]["y"], sd["sjever"]["z"]
                gor = [(sx(y_), sy(z_)) for y_, z_ in zip(sy_, sz_)]
                dol = [(sx(y_), sy(z_ - 1.2)) for y_, z_ in zip(sy_[::-1], sz_[::-1])]
                svg.append(f'<polygon points="{put(gor + dol)}" fill="#2459b8" fill-opacity="0.9" stroke="#173b7a" stroke-width="0.8"/>')
                for xx_, yy_ in gor[::4]:
                    kutije.append((xx_ - 4, yy_ - 4, xx_ + 4, yy_ + 10))
                tn_ = (f"sjeverna tribina: jedna kosa ploha bez srednjeg prstena, {sz_[0]:.1f} do {sz_[-1]:.1f}, ".replace(".", ",")
                       + f"{len(sz_)} redova (program: stadion.sjever)")
                im_ = len(gor) // 2
                xt_, yt_ = gor[im_][0] - 10, gor[im_][1] - 26
                svg.append(f'<line x1="{gor[im_][0]:.1f}" y1="{gor[im_][1] - 2:.1f}" x2="{xt_ + 4:.1f}" y2="{yt_ + 4:.1f}" stroke="#173b7a" stroke-width="0.7"/>')
                T(xt_, yt_, tn_, 11, True, "#173b7a", "end")
                kutije.append(okvir(xt_, yt_, tn_, 11, "end"))
            for a, b, zr_, zv_ in sd["krov"]:
                svg.append(f'<line x1="{sx(a):.1f}" y1="{sy(zr_):.1f}" x2="{sx(b):.1f}" y2="{sy(zv_):.1f}" stroke="#9aa0a8" stroke-width="4"/>')
                for f_ in np.linspace(0.0, 1.0, 24):   # crta krova: natpisi je zaobilaze
                    xx_, yy_ = sx(a + (b - a) * f_), sy(zr_ + (zv_ - zr_) * f_)
                    kutije.append((xx_ - 3, yy_ - 3, xx_ + 3, yy_ + 3))
            podij = P.stadion["procelje"]["dno"] if P.stadion["procelje"] and P.stadion["procelje"]["dno"] else pv.kota_podija
            for yy in sd["obris"]:
                svg.append(f'<line x1="{sx(yy):.1f}" y1="{sy(podij or z0):.1f}" x2="{sx(yy):.1f}" y2="{sy(sd["vrh_krova"]):.1f}" '
                           f'stroke="#1e4fa8" stroke-width="2.2"/>')
        # današnje tlo
        svg.append(f'<polyline points="{put(pts if False else [(sx(y), sy(z)) for y, z in zip(ys, pn["tlo"])])}" fill="none" '
                   f'stroke="#6b5a45" stroke-width="1.1" stroke-dasharray="5 3"/>')
        # os ceste
        if pn["y_osi"] is not None and ys[0] <= pn["y_osi"] <= ys[-1]:
            T(sx(pn["y_osi"]), Y0 + h + 15, "os Maksimirske", 10, False, "#50555c", "middle")
        # kote pokrova (park nad cestom, podgled, kolnik): stupac natpisa desno od pokrova, poredan po visini,
        # s crtom do oznake; ostale kote na prvom mjestu bez presijecanja (krug 3, M-3)
        pokrov_k = {k_: v_ for k_, v_ in pn["kote"].items() if k_ in ("park nad cestom", "podgled", "kolnik")}
        if pokrov_k:
            desno = max(yy for yy, _ in pokrov_k.values())
            for a, b in _nizovi(pn["pod"]):
                if ys[a] - 1.0 <= (pn["y_osi"] if pn["y_osi"] is not None else desno) <= ys[b - 1] + 1.0:
                    desno = max(desno, ys[b - 1])
            x_lab = sx(desno) + 16
            zadnji = -1e9
            for ime, (yy, zz) in sorted(pokrov_k.items(), key=lambda q: -q[1][1]):
                X, Y = sx(yy), sy(zz)
                ty_ = max(Y + 4, zadnji + 15)
                zadnji = ty_
                tekst = f"{ime} {zz:.2f}".replace(".", ",")
                if ime == "kolnik":
                    tekst += (" (model" + (f"; program {pn['kolnik_program'][0]:.1f})"
                                                  if pn.get("kolnik_program") else ")")).replace(".", ",")
                if ime == "podgled":
                    svg.append(f'<polygon points="{put([(X, Y), (X - 4, Y + 6), (X + 4, Y + 6)])}" fill="#c0392b"/>')
                else:
                    svg.append(f'<polygon points="{put([(X, Y), (X - 4, Y - 6), (X + 4, Y - 6)])}" fill="#c0392b"/>')
                svg.append(f'<polyline points="{put([(X, Y), (x_lab - 10, ty_ - 4), (x_lab - 3, ty_ - 4)])}" fill="none" '
                           f'stroke="#a12a1e" stroke-width="0.6"/>')
                T(x_lab, ty_, tekst, 11, True, "#a12a1e")
                kutije.append(okvir(x_lab, ty_, tekst, 11, "start"))
        for ime, (yy, zz) in sorted(pn["kote"].items(), key=lambda q: q[1][1]):
            if ime in pokrov_k:
                continue
            X, Y = sx(yy), sy(zz)
            tekst = f"{ime} {zz:.2f}".replace(".", ",")
            ispod = ime in ("podgled", "kolnik")
            kand = []
            for pomak in range(0, 8):
                gore_ = [(X + 7, Y - 6 - 15 * pomak, "start"), (X - 7, Y - 6 - 15 * pomak, "end")]
                dolje_ = [(X + 7, Y + 16 + 15 * pomak, "start"), (X - 7, Y + 16 + 15 * pomak, "end")]
                kand += (dolje_ + gore_) if ispod else (gore_ + dolje_)
            izbor = kand[-1]
            for tx_, ty_, sid in kand:
                ok_ = okvir(tx_, ty_, tekst, 11, sid)
                if X0 <= ok_[0] and ok_[2] <= X0 + w and Y0 <= ok_[1] and ok_[3] <= Y0 + h \
                        and not any(sijece(ok_, k_) for k_ in kutije):
                    izbor = (tx_, ty_, sid)
                    break
            tx_, ty_, sid = izbor
            kutije.append(okvir(tx_, ty_, tekst, 11, sid))
            if ime == "podgled":
                svg.append(f'<polygon points="{put([(X, Y), (X - 4, Y + 6), (X + 4, Y + 6)])}" fill="#c0392b"/>')
            else:
                svg.append(f'<polygon points="{put([(X, Y), (X - 4, Y - 6), (X + 4, Y - 6)])}" fill="#c0392b"/>')
            if abs(ty_ - (Y - 6)) > 1 and abs(ty_ - (Y + 16)) > 1:   # natpis odmaknut: tanka crta do oznake
                svg.append(f'<line x1="{X:.1f}" y1="{Y:.1f}" x2="{tx_:.1f}" y2="{ty_ - 4:.1f}" stroke="#a12a1e" stroke-width="0.6"/>')
            T(tx_, ty_, tekst, 11, True, "#a12a1e", sid)
        T(X0, Y0 + h + 15, "jug", 10, False, "#50555c")
        T(X0 + w, Y0 + h + 13, "sjever", 10, False, "#50555c", "end")
        mj = 50 if s_m < 5 else 20
        svg.append(f'<line x1="{X0 + w - mj * s_m - 8:.1f}" y1="{Y0 + h + 22:.1f}" x2="{X0 + w - 8:.1f}" y2="{Y0 + h + 22:.1f}" '
                   f'stroke="#1c2026" stroke-width="2"/>')
        T(X0 + w - mj * s_m - 14, Y0 + h + 26, f"{mj} m (vodoravno i okomito)", 10, False, "#30353b", "end")
    # mjerilo i legenda
    yl = y_cur - 20
    leg = [("#2f6fb5", "svijetli profil ceste, visina portala (PRETPOSTAVKA)"), ("#3d7a2a", "ploha parka (model iz programa)"), ("#6b5a45", "današnje tlo (crtkano; reljef scene)"),
           ("#8d8f93", "pokrov: ploča od podgleda do parka"), ("#5cc3e6", "svjetlarnik"),
           ("#2459b8", "tribine stadiona (sjever: jedna kosa ploha iz stadion.sjever)"), ("#ffffff", "nosiva konstrukcija tribina nije zadana (shema)"), ("#9aa0a8", "krov stadiona"), ("#c0392b", "kota izmjerena na plohi modela (m n. v.)")]
    leg += [(b, NAZIVI_KAT.get(k, k)) for k, b in sorted(kat_upotrijebljene.items())]
    st_ = 4
    sir = (W - 2 * rub) / st_
    H = int(yl + 22 + math.ceil(len(leg) / st_) * 20 + 62)
    for n_, (b, tekst) in enumerate(leg):
        lx, ly = rub + (n_ % st_) * sir, yl + 22 + (n_ // st_) * 20
        svg.append(f'<rect x="{lx:.1f}" y="{ly - 10:.1f}" width="12" height="12" fill="{b}" stroke="#8a8f96" stroke-width="0.5"/>')
        T(lx + 18, ly, tekst, 11, False, "#30353b")
    _imena = {"podij_mnv": "podij", "park_zapadni_kraj_pokrova_mnv": "park, zapadni kraj pokrova",
              "park_uz_sjevernu_tribinu_mnv": "park uz sjevernu tribinu (najviša točka uz istočni kraj tribine)",
              "park_istocni_kraj_pokrova_mnv": "park, istočni kraj pokrova", "vrh_krova_mnv": "vrh krova"}
    kan = " · ".join(f"{_imena.get(k, k)} {v}".replace(".", ",") for k, v in KANON.items() if k != "duljina_pokrova_m")
    T(rub, H - 46, f"Kanonske kote (research/viz/README.md): {kan}; na rezu kroz središte stadiona program drži park 127,9 "
                   f"(POKROV-06). Cesta danas oko 119,5.", 11, False, "#50555c")
    svg.append(f'<rect x="0" y="{H - 30}" width="{W:.0f}" height="30" fill="#12161c"/>')
    T(rub, H - 10, OZNAKA + " · shema iz programa, nije izvedbeni presjek · PRETPOSTAVKA-IZRAČUN", 13, True, "#ffffff")
    tijelo = "\n".join(svg)
    dok = (f'<svg xmlns="http://www.w3.org/2000/svg" width="{W:.0f}" height="{H}" viewBox="0 0 {W:.0f} {H}" '
           f'font-family="DejaVu Sans, sans-serif"><rect width="100%" height="100%" fill="#ffffff"/>\n{tijelo}\n</svg>\n')
    izlaz = Path(izlaz)
    izlaz.parent.mkdir(parents=True, exist_ok=True)
    svg_put = izlaz.with_suffix(".svg")
    svg_put.write_text(dok, encoding="utf-8")
    alat = _svg_u_png(svg_put, izlaz.with_suffix(".png"), W, H)
    kote = {pn["opis"]: {k: round(v[1], 2) for k, v in pn["kote"].items()} for pn in paneli}
    pop = {"status": "AI građanski koncept, PRIJEDLOG; shema iz programa, PRETPOSTAVKA-IZRAČUN", "oznaka": OZNAKA,
           "program": {"datoteka": P.put.name, "naziv": P.meta.get("naziv"), "verzija": P.meta.get("verzija")},
           "rezovi_x_enu_n": [round(pn["x"], 1) for pn in paneli], "kote_mnv": kote, "kanon": dict(KANON),
           "pretpostavke": {"debljina_pokrova_m": deb, "visina_portala_m": hp},
           "png": izlaz.with_suffix(".png").name, "svg": svg_put.name, "pretvorba": alat}
    izlaz.with_suffix(".json").write_text(json.dumps(pop, ensure_ascii=False, indent=1), encoding="utf-8")
    pop["_paneli"] = paneli
    pop["_visina"] = H
    return pop


def _nizovi(maska):
    """Uzastopni nizovi True u 1D maski: popis (početak, kraj)."""
    m = np.r_[False, np.asarray(maska, bool), False]
    d = np.diff(m.astype(np.int8))
    return list(zip(np.nonzero(d == 1)[0], np.nonzero(d == -1)[0]))


# ---------------------------------------------------------------------------
# CLI
# ---------------------------------------------------------------------------

def _opcije_iz_teksta(popis):
    out = {}
    for t in popis or []:
        k, _, v = t.partition("=")
        if k not in ZADANO_KONCEPT:
            raise SystemExit(f"nepoznata opcija {k}; dopušteno: {sorted(ZADANO_KONCEPT)}")
        z = ZADANO_KONCEPT[k]
        out[k] = (v.lower() in ("1", "da", "true")) if isinstance(z, bool) else (int(v) if isinstance(z, int) else float(v))
    return out


def main(argv=None):
    import argparse

    ap = argparse.ArgumentParser(description="3D model koncepta iz program.json: probni pogledi, mjere, rastavljeni prikaz")
    ap.add_argument("naredba", choices=["visine", "mjere", "pogled", "probni", "rastavljeni", "presjek", "poprecni"])
    ap.add_argument("--program", default=str(SC.VIZ / "program.json"))
    ap.add_argument("--izlaz", required=True, help="mapa (pogled, probni, mjere) ili datoteka (visine, rastavljeni, presjek)")
    ap.add_argument("--pogled", default="zrak_jug", help="zrak_jug, zrak_sjeverozapad, visina_sjever, visina_jug, visina_zapad, "
                                                         "tlo_ulaz, tlo_svetice, park_stadion ili svi")
    ap.add_argument("--sirina", type=int, default=960)
    ap.add_argument("--uzorci", type=int, default=48)
    ap.add_argument("--kada", default="2026-06-21 17:30", help="lokalno vrijeme za Sunce")
    ap.add_argument("--sezona", default=None, choices=["ljeto", "jesen", "zima", "datum"],
                    help="krošnje scene i koncepta (isti materijal); datum = iz --kada; zadano ljeto")
    ap.add_argument("--bez", default="", help="slojevi scene koje treba isključiti, zarezom (npr. teren_regija,drvece)")
    ap.add_argument("--opcija", action="append", help="ključ=vrijednost iz ZADANO_KONCEPT, npr. ljudi=ne ili korak_m=2")
    ap.add_argument("--predmemorija", default=None)
    ap.add_argument("--oznaka-datoteke", default="", help="dodatak imenu izlaznih datoteka")
    ap.add_argument("--kamera", default=None,
                    help="vlastita kamera uz naredbu pogled: x,y,kota_oka,azimut,nagib,f35 (x i y u ENU-N); ime iz --pogled")
    a = ap.parse_args(argv)
    izlaz = Path(a.izlaz)
    opcije = _opcije_iz_teksta(a.opcija)
    if a.naredba == "visine":
        pv = Povrsina(Program(a.program), SC.Teren().kota_n, opcije)
        izlaz.parent.mkdir(parents=True, exist_ok=True)
        pv.slika_visina(izlaz)
        print(json.dumps({"prostora_plohe": len(pv.pl), "kosina": sum(1 for q in pv.pl if q["kosina"]),
                          "svjetlarnika": len(pv.svj), "vrijeme_s": pv.vrijeme_s}, ensure_ascii=False))
        return 0
    if a.naredba == "rastavljeni":
        rastavljeni_prikaz(a.program, izlaz, sirina_px=a.sirina, uzorci=a.uzorci, predmemorija=a.predmemorija)
        return 0
    if a.naredba == "poprecni":
        print(json.dumps(poprecni_presjek(a.program, izlaz, sirina_px=max(a.sirina, 1600), opcije=opcije)["kote_mnv"],
                         ensure_ascii=False, indent=1))
        return 0
    if a.naredba == "presjek":
        presjecna_perspektiva(a.program, izlaz, sirina_px=a.sirina, uzorci=a.uzorci, predmemorija=a.predmemorija, **opcije)
        return 0
    bez = set(filter(None, a.bez.split(",")))
    slojevi = tuple(x for x in SLOJEVI_SCENE if x not in bez)
    if a.naredba == "mjere":
        slojevi = ("teren_blizu",)
        opcije = {**opcije, "drvece": False, "ljudi": False, "vozila": False}
    s = izgradi(a.program, slojevi_scene=slojevi, predmemorija=a.predmemorija, **opcije)
    izlaz.mkdir(parents=True, exist_ok=True)
    dod = a.oznaka_datoteke
    mj = izmjeri(s)
    (izlaz / f"mjere{dod}.json").write_text(json.dumps({"mjere": mj, "koncept": s.kstat, "gradnja_s": _vremena_gradnje(s)},
                                                       ensure_ascii=False, indent=1, default=str), encoding="utf-8")
    print(json.dumps(mj, ensure_ascii=False, indent=1))
    if a.naredba == "mjere":
        return 0
    kam = pogledi(s, sirina_px=a.sirina)
    if a.kamera:
        x, y, kota, az, nag, f35 = (float(v) for v in a.kamera.split(","))
        xm, ym = K.m_iz_n(x, y)
        kam[a.pogled] = KAM.iz_polozaja(x=xm, y=ym, kota_oka=kota, azimut_deg=az, nagib_deg=nag, f35_mm=f35,
                                        sirina_px=a.sirina, omjer=16 / 9, naziv=a.pogled, izvor="zadano u naredbi")
    imena = [x for x in PROBNI if x in kam] if a.naredba == "probni" else (list(kam) if a.pogled == "svi" else [a.pogled])
    s.postavi_sunce(a.kada, sezona=a.sezona)
    pogreske = []
    for ime in imena:
        if ime not in kam:
            print(f"pogled {ime} nije dostupan za ovaj program; dostupno: {sorted(kam)}")
            continue
        try:
            s.postavi_kameru(kam[ime])
        except RuntimeError as e:   # kamera u objektu ili pod terenom: pogreška, ostali pogledi se rade
            print(f"POGREŠKA pogled {ime}: {e}")
            pogreske.append(ime)
            continue
        s.renderiraj(izlaz / f"{ime}{dod}.jpg", uzorci=a.uzorci, dodatno={"mjere": mj})
    if a.naredba == "probni":
        rastavljeni_prikaz(a.program, izlaz / f"rastavljeno{dod}.png", sirina_px=max(a.sirina, 1600), uzorci=a.uzorci,
                           predmemorija=a.predmemorija)
    return 3 if pogreske else 0


if __name__ == "__main__":
    sys.exit(main())
