#!/usr/bin/env python3
"""Blender scena POSTOJEĆEG STANJA na stvarnom terenu (kampanja "prikazi i tlocrti").

Status: AI građanski koncept, model za provjeru. Render nije dokaz; visine zgrada i tribina su
procjene, drveće je proceduralno, teren ima izvornu mrežu 20 m. Namijenjeno pogledima iz zraka
(iznad oko 60 m nad tlom); za poglede s tla scena daje geometriju, masku, dubinu i prolaz koncepta
za fotomontažu, ne gotovu sliku. Opis: research/viz/model/README.md.

Sustav scene: ENU-M iz scripts/viz/koordinate.py (x istok, y sjever, z = m n. v., pravi metri).
Svi ulazni podaci su u ENU-N i prevode se pri gradnji.

Primjer (Python s modulom bpy):

    import scena, kamera
    obuhvat = [[-430, -20], [258, 210], [258, 270], [-430, 40]]            # poligon u ENU-N
    s = scena.izgradi_scenu(slojevi=[x for x in scena.SVI_SLOJEVI if x != "stadion"],
                            izrez=[obuhvat], izrez_iznimke=["way/29574143"], izrez_tlo=(0.20, 0.27, 0.10))
    s.dodaj_mrezu("podij", vrhovi_enu_m, plohe, sloj="koncept", boja=(0.35, 0.5, 0.25))   # vlastiti objekti
    scena.postavi_sunce(s, "2026-06-21 16:00")
    scena.postavi_kameru(s, kamera.pogled_na((-45, 7, 125), azimut_od_cilja_deg=200, udaljenost_m=700, kota_oka=330))
    scena.renderiraj(s, "izlaz/pogled.png", uzorci=96, prolazi=("slika", "dubina", "maska", "pokrivenost", "koncept"))

CLI:  python scripts/viz/scena.py mjerilo | pregled | pogled | validacija | daleko   (vidi --help)
"""
from __future__ import annotations

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

import numpy as np

try:
    from . import kamera as KAM
    from . import koordinate as K
    from . import sunce as SUN
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 sunce as SUN

KORIJEN = Path(__file__).resolve().parents[2]
VIZ = KORIJEN / "research" / "viz"
TEREN = VIZ / "teren"
MODEL = VIZ / "model"
DALEKO = MODEL / "daleko"
# Daleki pojas (pozadina prema jugu i istoku, greben Medvednice do 46,02° N): lon_min, lat_min, lon_max, lat_max.
# Zapadni rub određuju izvorne pločice DGU-a (RH_ELEV_106/107; zapadnije od 15,705° E treba još jedna pločica).
DALEKO_OKVIR = (15.71, 45.56, 16.40, 46.02)

# indeks sloja = vrijednost u maski objekata (0 = nebo)
SLOJEVI = {"teren_blizu": 1, "teren_regija": 2, "vode": 3, "zgrade": 4, "drvece": 5, "stadion": 6,
           "teren_daleko": 7, "koncept": 10}
SVI_SLOJEVI = ("teren_blizu", "teren_regija", "teren_daleko", "vode", "zgrade", "drvece", "stadion")
SLOJEVI_TERENA = ("teren_blizu", "teren_regija", "teren_daleko", "vode")

OZNAKA_POSTOJECE = "AI građanski koncept · postojeće stanje, model za provjeru · render nije dokaz"
OZNAKA_KONCEPT = "AI građanski koncept · PRIJEDLOG · render nije dokaz"
PODLOGE_KRATKO = ("Podloge: DGU Visine INSPIRE i DOF 2024. (Otvorena dozvola, izmijenjeno; žig usluge nije uklanjan) · "
                  "EOxCloudless 2016 (CC BY 4.0) · © OpenStreetMap contributors (ODbL)")

# Navodi iz research/viz/teren/IZVORI.md ("Atribucije koje moraju stajati uz slike i rendere")
ATRIBUCIJE = {
    "teren_blizu": [
        "Sadrži informacije tijela javne vlasti u skladu s Otvorenom dozvolom (https://data.gov.hr/otvorena-dozvola). "
        "Izvor: Državna geodetska uprava, Visine INSPIRE / Digitalni ortofoto 2024. (https://geoportal.dgu.hr). "
        "Izmijenjeno: isječak, preslikavanje, tekstura u prikazu AI građanskog koncepta. Vodeni žig usluge nije uklanjan.",
    ],
    "teren_regija": [
        "Sadrži informacije tijela javne vlasti u skladu s Otvorenom dozvolom (https://data.gov.hr/otvorena-dozvola). "
        "Izvor: Državna geodetska uprava, Visine INSPIRE (https://geoportal.dgu.hr). Izmijenjeno: isječak, preuzorkovanje.",
        "EOxCloudless https://cloudless.eox.at by EOX IT Services GmbH (Contains modified Copernicus Sentinel data 2016), "
        "CC BY 4.0. Izmijenjeno: isječak, usklađena boja, tekstura u prikazu.",
    ],
    "teren_daleko": [
        "Sadrži informacije tijela javne vlasti u skladu s Otvorenom dozvolom (https://data.gov.hr/otvorena-dozvola). "
        "Izvor: Državna geodetska uprava, Visine INSPIRE (https://geoportal.dgu.hr). Izmijenjeno: isječak, preuzorkovanje.",
        "EOxCloudless https://cloudless.eox.at by EOX IT Services GmbH (Contains modified Copernicus Sentinel data 2016), "
        "CC BY 4.0. Izmijenjeno: isječak, usklađena boja, tekstura u prikazu.",
    ],
    "osm": ["© OpenStreetMap contributors (ODbL), https://www.openstreetmap.org/copyright"],
    "ograda": ["Nijedna oznaka ne znači da DGU, Copernicus, ESA, EOX ili OpenStreetMap podržavaju koncept."],
}

# Visine tribina današnjeg stadiona iznad igrališta (m): niži rub uz igralište i gornji stražnji rub.
# Status: PRETPOSTAVKA. site.json ima samo zadanih 20 m niske pouzdanosti; ove vrijednosti su usklađene
# s obrisima tribina na dvjema službenim snimkama iz zraka (research/viz/model/validacija_kamere.json,
# "obrisi"); nisu mjerene i mogu odstupati nekoliko metara.
VISINE_TRIBINA = {"sjever": (2.0, 27.0), "zapad": (2.0, 24.0), "istok": (2.0, 21.0), "jug": (1.5, 9.0)}

# Ispravci visina pojedinih zgrada iz site.json (m iznad tla). Status: PRETPOSTAVKA iz položaja vrha na
# službenoj snimci iz zraka 2020. (kritika, krug 1); nije mjereno.
ISPRAVCI_VISINA = {"way/95498878": 17.0}  # Vidikovac u parku: OSM daje 3 kata (9,6 m), snimka upućuje na oko 17 m

# Godišnje doba krošnji: (boje rampe, udio prozirnosti). PRETPOSTAVKA, samo izgled.
SEZONE = {
    "ljeto": ([(0.058, 0.125, 0.026), (0.098, 0.200, 0.035), (0.130, 0.210, 0.068), (0.180, 0.280, 0.058)], 0.0),
    "jesen": ([(0.210, 0.120, 0.030), (0.330, 0.200, 0.040), (0.160, 0.170, 0.045), (0.420, 0.270, 0.050)], 0.10),
    "zima": ([(0.090, 0.072, 0.058), (0.120, 0.098, 0.078), (0.105, 0.090, 0.075), (0.150, 0.125, 0.100)], 0.62),
}


def sezona_za_datum(mjesec, dan=15):
    """Godišnje doba krošnji iz datuma: ljeto 15.4.-10.10., jesen do 20.11., inače zima (gole krošnje)."""
    k = mjesec * 100 + dan
    if 415 <= k <= 1010:
        return "ljeto"
    if 1010 < k <= 1120:
        return "jesen"
    return "zima"

ZADANO = {
    "korak_blizu_m": 5.0,        # mreža bliskog terena (izvor 20 m, raster 5 m)
    "korak_regija_m": 30.0,      # mreža regionalnog terena
    "pola_blizu_n": 1500.0,      # polovina stranice bliske plohe u ENU-N (doseg ortofota)
    "prijelaz_teksture_m": 120.0,
    "zakrivljenost": True,       # spuštanje dalekog terena zbog zakrivljenosti Zemlje i refrakcije
    "razmak_sume_m": 7.0,
    "razmak_drvoreda_m": 9.0,
    "stabla_iz_ortofota": True,
    "krovovi_iz_ortofota": True,
    "pojacanje_ortofota": 1.0,
    "podjela_krosnje": 2,        # podjela grudica krošnje (1 = 80 trokuta po grudici, 2 = 320)
    "prorjeda_daleko": 1,        # svaki n-ti čvor dalekog rastera (3")
    "izrez_krosnje": True,       # izrez uklanja i stabla čija krošnja zadire u poligon (ne samo deblo)
    "nadreza_podataka": 2,       # dubina i maska se renderiraju u n-strukoj rezoluciji (zaglađeni rubovi)
    "ekspozicija": -4.9,
    "pogled": "AgX",
    "izgled": "AgX - Medium High Contrast",
}


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


# ---------------------------------------------------------------------------
# Teren (bez Blendera)
# ---------------------------------------------------------------------------

class Teren:
    """Visine golog tla iz DGU modela reljefa: bliski raster (ENU-N, 5 m), regionalni (1") i,
    ako postoji research/viz/model/daleko/, daleki (3")."""

    def __init__(self):
        from PIL import Image

        self.meta_b = json.loads((TEREN / "dmr_blizu_dgu20_5m.json").read_text(encoding="utf-8"))["mreza"]
        self.meta_r = json.loads((TEREN / "dmr_regija_dgu20.json").read_text(encoding="utf-8"))["mreza"]
        self.b = np.asarray(Image.open(TEREN / "dmr_blizu_dgu20_5m.png"), dtype=np.float64) / 10.0
        self.r = np.asarray(Image.open(TEREN / "dmr_regija_dgu20.png"), dtype=np.float64) / 10.0
        m = self.meta_b
        self.bx0, self.by1, self.bk = m["x_min"], m["y_max"], m["korak_m"]
        self.b_pola = m["x_max"]
        r = self.meta_r
        self.r_lon0, self.r_lat1, self.r_k = r["lon_min"], r["lat_max"], r["korak_stupnjevi"]
        # okvir regionalnog rastera u ENU-N
        self.rx = ((r["lon_min"] - K.LON0) * K.N_KX, (r["lon_max"] - K.LON0) * K.N_KX)
        self.ry = ((r["lat_min"] - K.LAT0) * K.N_KY, (r["lat_max"] - K.LAT0) * K.N_KY)
        self.d = None
        if (DALEKO / "dmr_daleko_dgu20_3s.png").exists():
            self.meta_d = json.loads((DALEKO / "dmr_daleko_dgu20_3s.json").read_text(encoding="utf-8"))["mreza"]
            self.d = np.asarray(Image.open(DALEKO / "dmr_daleko_dgu20_3s.png"), dtype=np.float64) / 10.0
            d = self.meta_d
            self.d_lon0, self.d_lat1, self.d_k = d["lon_min"], d["lat_max"], d["korak_stupnjevi"]
            self.dx = ((d["lon_min"] - K.LON0) * K.N_KX, (d["lon_max"] - K.LON0) * K.N_KX)
            self.dy = ((d["lat_min"] - K.LAT0) * K.N_KY, (d["lat_max"] - K.LAT0) * K.N_KY)

    @staticmethod
    def _bilinearno(a, c, r):
        h, w = a.shape
        c = np.clip(c, 0, w - 1.000001)
        r = np.clip(r, 0, h - 1.000001)
        c0, r0 = np.floor(c).astype(int), np.floor(r).astype(int)
        fc, fr = c - c0, r - r0
        return (a[r0, c0] * (1 - fc) * (1 - fr) + a[r0, c0 + 1] * fc * (1 - fr)
                + a[r0 + 1, c0] * (1 - fc) * fr + a[r0 + 1, c0 + 1] * fc * fr)

    def kota_n(self, x, y):
        """Kota tla (m n. v.) za točke u ENU-N. Unutar ±1500 m bliski raster, izvan ±2000 m
        regionalni, između linearni prijelaz (isti izvor, pa je razlika mala). Izvan okvira regionalnog
        rastera daleki raster (ako postoji), s prijelazom u pojasu 200 m unutar ruba regionalnog."""
        x = np.asarray(x, dtype=np.float64)
        y = np.asarray(y, dtype=np.float64)
        zb = self._bilinearno(self.b, (x - self.bx0) / self.bk, (self.by1 - y) / self.bk)
        lon = K.LON0 + x / K.N_KX
        lat = K.LAT0 + y / K.N_KY
        zr = self._bilinearno(self.r, (lon - self.r_lon0) / self.r_k, (self.r_lat1 - lat) / self.r_k)
        d = np.maximum(np.abs(x), np.abs(y))
        w = np.clip((d - 1500.0) / (self.b_pola - 1500.0), 0.0, 1.0)
        z = zb * (1 - w) + zr * w
        if self.d is not None:
            unutra = np.minimum(np.minimum(x - self.rx[0], self.rx[1] - x), np.minimum(y - self.ry[0], self.ry[1] - y))
            wd = np.clip(1.0 - unutra / 200.0, 0.0, 1.0)
            if np.any(wd > 0):
                zd = self._bilinearno(self.d, (lon - self.d_lon0) / self.d_k, (self.d_lat1 - lat) / self.d_k)
                z = z * (1 - wd) + zd * wd
        return z

    def kota_m(self, x, y):
        """Kota tla (m n. v.) za točke u ENU-M."""
        xn, yn = K.n_iz_m(np.asarray(x, dtype=np.float64), np.asarray(y, dtype=np.float64))
        return self.kota_n(xn, yn)


def gradi_daleko(predmemorija, izlaz=None, okvir=DALEKO_OKVIR, m_po_px=30.0):
    """Priprema dalekog pojasa (research/viz/model/daleko/): DGU reljef na mreži 3" i satelitski mozaik
    Sentinel-2 2016. za okvir `okvir`. Isti izvori i licence kao research/viz/teren/ (IZVORI.md); preuzima
    funkcijama iz scripts/viz/teren.py u zadanu predmemoriju izvan repoa. Ne treba Blender."""
    import datetime as dt

    from PIL import Image

    import teren as T  # scripts/viz/teren.py (preuzimanje i čitanje izvora)

    izlaz = Path(izlaz) if izlaz else DALEKO
    izlaz.mkdir(parents=True, exist_ok=True)
    cache = Path(predmemorija)
    n_lon = int(round((okvir[2] - okvir[0]) * 1200)) + 1
    n_lat = int(round((okvir[3] - okvir[1]) * 1200)) + 1
    LO, LA = np.meshgrid(okvir[0] + np.arange(n_lon) / 1200, okvir[3] - np.arange(n_lat) / 1200)
    pl = T.dgu_plocice(cache, okvir)
    h = T.dgu_uzorak(pl, LO, LA)
    # na šavovima pločica bilinearno očitanje daje pojedinačne preniske ćelije (0-92 m; najniže tlo u okviru
    # je oko 93 m n. v.): tretiraju se kao praznina i popunjavaju iz susjeda
    nisko = int((h < 92.0).sum())
    h[h < 92.0] = np.nan
    h, popunjeno = T.popuni_supljine(h, najvise_krugova=12)
    if np.isnan(h).any():
        raise RuntimeError(f"daleki reljef ima {int(np.isnan(h).sum())} praznih ćelija; suzi okvir")
    meta = {
        "mreza": {"vrsta": "geografska, pravilna u stupnjevima; vrijednost vrijedi za središte piksela",
                  "lon_min": okvir[0], "lat_min": okvir[1], "lon_max": okvir[2], "lat_max": okvir[3],
                  "korak_stupnjevi": 1 / 1200,
                  "korak_m_priblizno": {"istok": round(T.KX_TOCNO / 1200, 1), "sjever": round(T.KY_TOCNO / 1200, 1)},
                  "stupaca": n_lon, "redova": n_lat,
                  "piksel_u_lonlat": "lon = lon_min + stupac/1200; lat = lat_max - red/1200"},
        "crs_polozaj": "EPSG:4326 (WGS 84), stupnjevi",
        "popunjene_praznine": f"{popunjeno} ćelija na šavu izvornih pločica popunjeno iz susjednih ćelija "
                              f"(od toga {nisko} s očitanjem ispod 92 m n. v., što je artefakt šava)",
        "opis": "Daleki pojas modela reljefa za pozadinu prikaza: DGU Visine INSPIRE (DTM 20 m), bilinearno "
                "preuzorkovan na mrežu 3\"; dopunjuje research/viz/teren/dmr_regija_dgu20.png izvan njegova okvira",
        "tip_modela": "DTM", "napomena": T.NAPOMENA_DTM,
        "izvorne_plocice": [g["ime"] for g in pl], "izvorni_crs": "EPSG:3045 (ETRS89 / UTM 33N), korak 19,995 m",
        "izvor": T.IZVORI["dgu_dmr"]["naziv"], "izvor_url": T.IZVORI["dgu_dmr"]["url"],
        "licenca": T.IZVORI["dgu_dmr"]["licenca"], "licenca_url": T.IZVORI["dgu_dmr"]["licenca_url"],
        "atribucija": T.IZVORI["dgu_dmr"]["atribucija"],
        "obrada": "scripts/viz/scena.py daleko (funkcije preuzimanja iz scripts/viz/teren.py)",
        **T.DATUM_DGU,
    }
    T.spremi_visine(izlaz / "dmr_daleko_dgu20_3s.png", h, meta)
    w = int(round((okvir[2] - okvir[0]) * T.KX_TOCNO / m_po_px))
    v = int(round((okvir[3] - okvir[1]) * T.KY_TOCNO / m_po_px))
    par = {"SERVICE": "WMS", "VERSION": "1.1.1", "REQUEST": "GetMap", "LAYERS": "s2cloudless", "STYLES": "",
           "SRS": "EPSG:4326", "BBOX": ",".join(f"{c:.5f}" for c in okvir), "WIDTH": w, "HEIGHT": v,
           "FORMAT": "image/jpeg"}
    sirovo = T.dohvati(T.EOX_WMS, cache / "eox" / f"s2cloudless2016_{'_'.join(f'{c:.3f}' for c in okvir)}_{w}x{v}.jpg",
                       params=par)
    put = izlaz / "ortofoto_daleko.jpg"
    Image.open(sirovo).convert("RGB").save(put, quality=88, optimize=True)
    meta_o = {
        "datoteka": put.name,
        "opis": "Satelitski mozaik bez oblaka (Sentinel-2, 2016.) za daleki pojas pozadine prikaza",
        "mreza": {"vrsta": "geografska (plate carrée), pravilna u stupnjevima; piksel je površina",
                  "lon_min": okvir[0], "lat_min": okvir[1], "lon_max": okvir[2], "lat_max": okvir[3],
                  "dimenzije_px": [w, v], "m_po_px_priblizno": m_po_px},
        "crs_polozaj": "EPSG:4326",
        "izvor": T.IZVORI["eox_s2"]["naziv"], "izvor_url": T.IZVORI["eox_s2"]["url"], "usluga": T.EOX_WMS,
        "licenca": T.IZVORI["eox_s2"]["licenca"], "licenca_url": T.IZVORI["eox_s2"]["licenca_url"],
        "atribucija": T.IZVORI["eox_s2"]["atribucija"],
        "napomena": "Snimke iz 2016.: novija gradnja nije vidljiva. Preuzorkovano na oko 30 m po pikselu.",
        "velicina_MB": round(put.stat().st_size / 1e6, 2),
        "datum_preuzimanja": dt.date.fromtimestamp(sirovo.stat().st_mtime).isoformat(),
        "status": "POTVRĐENO kao zapis izvora",
    }
    put.with_suffix(".json").write_text(json.dumps(meta_o, ensure_ascii=False, indent=1) + "\n", encoding="utf-8")
    return {"reljef": str(izlaz / "dmr_daleko_dgu20_3s.png"), "mozaik": str(put), "mreza": [n_lon, n_lat],
            "raspon_m": [float(np.nanmin(h)), float(np.nanmax(h))], "mozaik_px": [w, v]}


def m_iz_n(x, y):
    """ENU-N -> ENU-M za polja (numpy)."""
    xm, ym = K.m_iz_n(np.asarray(x, dtype=np.float64), np.asarray(y, dtype=np.float64))
    return np.asarray(xm), np.asarray(ym)


def pad_zakrivljenosti(xm, ym):
    return KAM.pad_zbog_zakrivljenosti(np.hypot(xm, ym))


def provjera_mjerila():
    """Zahtjev 1: duljina igrališta i razmak bušotina u ENU-M."""
    site = json.loads((VIZ / "site.json").read_text(encoding="utf-8"))
    p = np.array(site["stadion_maksimir"]["igraliste"]["poligon"][:4])
    xm, ym = m_iz_n(p[:, 0], p[:, 1])
    str_n = [float(np.hypot(*(p[(i + 1) % 4] - p[i]))) for i in range(4)]
    str_m = [float(math.hypot(xm[(i + 1) % 4] - xm[i], ym[(i + 1) % 4] - ym[i])) for i in range(4)]
    from pyproj import Proj

    b = {"B1": (462283.70, 5075575.82), "B3": (462643.57, 5075671.49), "B4": (462435.39, 5075191.13)}
    bm = {k: K.m_iz_htrs(*v) for k, v in b.items()}
    # mjerilo projekcije HTRS96/TM na lokaciji (na srednjem meridijanu 16,5° E iznosi 0,9999; ovdje je veće)
    k_lok = float(Proj("EPSG:3765").get_factors(K.LON0, K.LAT0).meridional_scale)
    bus = []
    for a, c in (("B1", "B3"), ("B1", "B4"), ("B3", "B4")):
        d_h = math.dist(b[a], b[c])
        bus.append({"par": f"{a}-{c}", "htrs96_tm_m": round(d_h, 3), "enu_m_m": round(math.dist(bm[a], bm[c]), 3),
                    "stvarno_m": round(d_h / k_lok, 3), "razlika_mm": round((math.dist(bm[a], bm[c]) - d_h / k_lok) * 1000, 1)})
    return {
        "igraliste_osm": {
            "stranice_enu_n_m": [round(v, 2) for v in str_n],
            "stranice_enu_m_m": [round(v, 2) for v in str_m],
            "napomena": "OSM poligon igrališta (way/29574648) u ENU-M je oko 104,5 x 67,1 m prema uobičajenih 105 x 68 m "
                        "(razlika 0,5-1,4 %, u granicama točnosti crtanja OSM-a); u ENU-N bi bio 104,0 x 66,9 m. "
                        "Travnata ploha na ortofotu 2024. je veća (oko 109,6 x 71,6 m).",
        },
        "busotine_gel_33_2025": bus,
        "mjerilo_htrs96_tm_na_lokaciji": round(k_lok, 6),
        "napomena": "stvarna duljina = duljina u HTRS96/TM podijeljena mjerilom projekcije na lokaciji (pyproj); mjerilo 0,9999 "
                    "vrijedi samo na srednjem meridijanu (16,5° E) i dalo bi prividnu razliku od 6–9 mm",
        "status": "PRETPOSTAVKA-IZRAČUN",
    }


# ---------------------------------------------------------------------------
# Scena
# ---------------------------------------------------------------------------

class Scena:
    """Drži Blender scenu, zbirke po slojevima, teren, kameru, Sunce i mjerenja."""

    def __init__(self, slojevi=SVI_SLOJEVI, sjeme=20261113, predmemorija=None, izrez=None, izrez_iznimke=(),
                 izrez_tlo=None, izrez_sustav="ENU-N", **postavke):
        import atexit
        import tempfile

        import bpy

        self.bpy = bpy
        nepoznato = set(slojevi) - set(SLOJEVI)
        if nepoznato:
            raise ValueError(f"nepoznati slojevi: {sorted(nepoznato)}; dopušteno {sorted(SLOJEVI)}")
        self.slojevi = tuple(slojevi)
        self.sjeme = int(sjeme)
        nepoznato = set(postavke) - set(ZADANO) - {"visine_tribina"}
        if nepoznato:
            raise ValueError(f"nepoznate postavke: {sorted(nepoznato)}; dopušteno {sorted(ZADANO)}")
        self.p = {**ZADANO, **postavke}
        # privremene datoteke: vlastita mapa po procesu (u zadanoj predmemoriji ili u mapi sustava), briše se na kraju
        if predmemorija:
            Path(predmemorija).mkdir(parents=True, exist_ok=True)
        self.predmemorija = Path(tempfile.mkdtemp(prefix="scena_", dir=str(predmemorija) if predmemorija else None))
        atexit.register(self.zatvori)
        self.teren = Teren()
        if "teren_daleko" in self.slojevi and self.teren.d is None:
            _log("daleki pojas nije pripremljen (research/viz/model/daleko/); sloj teren_daleko se izostavlja")
            self.slojevi = tuple(x for x in self.slojevi if x != "teren_daleko")
        self.site = json.loads((VIZ / "site.json").read_text(encoding="utf-8"))
        self.statistika = {"slojevi": {}}
        self.vrijeme_gradnje_s = {}
        self.sezona = "ljeto"
        self._postavi_izrez(izrez, izrez_iznimke, izrez_tlo, izrez_sustav)
        self.kamera = None
        self.sunce = None
        self._slike = {}
        bpy.ops.wm.read_factory_settings(use_empty=True)
        self.scene = bpy.context.scene
        self.zbirke = {}
        self._postavi_render()
        self._nebo()

    # --- osnovno ----------------------------------------------------------
    def _postavi_render(self):
        sc = self.scene
        sc.render.engine = "CYCLES"
        sc.cycles.device = "CPU"
        sc.cycles.use_denoising = False  # modul bpy u ovoj okolini nema ugrađen denoiser
        sc.cycles.use_adaptive_sampling = True
        sc.cycles.adaptive_threshold = 0.02
        sc.cycles.max_bounces = 4
        sc.cycles.diffuse_bounces = 2
        sc.cycles.glossy_bounces = 2
        sc.cycles.transmission_bounces = 2
        sc.cycles.transparent_max_bounces = 4
        sc.cycles.caustics_reflective = False
        sc.cycles.caustics_refractive = False
        sc.cycles.sample_clamp_indirect = 8.0
        sc.render.use_persistent_data = True
        sc.render.threads_mode = "AUTO"
        sc.view_settings.view_transform = self.p["pogled"]
        try:
            sc.view_settings.look = self.p["izgled"]
        except TypeError:
            pass
        sc.view_settings.exposure = self.p["ekspozicija"]
        sc.unit_settings.system = "METRIC"

    def zatvori(self):
        """Briše privremene datoteke ovog procesa. Poziva se sama na kraju procesa."""
        import shutil

        if self.predmemorija and self.predmemorija.exists():
            shutil.rmtree(self.predmemorija, ignore_errors=True)

    # --- izrez obuhvata koncepta ----------------------------------------------
    @staticmethod
    def _prsten_u_n(prsten, sustav):
        """Prsten poligona ([[x, y], ...]) u ENU-N; `sustav` je "ENU-N" ili "ENU-M"."""
        if sustav == "ENU-N":
            return [[float(q[0]), float(q[1])] for q in prsten]
        if sustav != "ENU-M":
            raise ValueError(f"nepoznat sustav {sustav}; dopušteno ENU-N i ENU-M")
        a = np.asarray(prsten, dtype=np.float64)
        xn, yn = K.n_iz_m(a[:, 0], a[:, 1])
        return [[float(x), float(y)] for x, y in zip(np.asarray(xn), np.asarray(yn))]

    def _postavi_izrez(self, izrez, iznimke, tlo, sustav="ENU-N"):
        """izrez     popis poligona ([[x, y], ...] ili {"poligon": [...], "rupe": [...]}) u sustavu `sustav`:
                     unutar njih se ne grade zgrade, stabla ni vodene plohe postojećeg stanja (koncept ih zamjenjuje)
        iznimke   OSM id-jevi zgrada (npr. "way/29574143") ili poligoni (isti sustav) unutar kojih postojeće ostaje
        tlo       None = tekstura terena ostaje; boja (linearni RGB 0..1) = ortofoto se u izrezu prekriva
                  tom bojom (zamjena teksture tla; postojeći stadion, vozila i žig u izrezu se ne prikazuju)
        sustav    "ENU-N" (kao site.json i program.json; zadano) ili "ENU-M" (kao scena); interno se drži ENU-N"""
        from shapely.geometry import Polygon
        from shapely.ops import unary_union

        self.izrez_sustav = sustav

        def geom(e):
            if isinstance(e, dict):
                g = Polygon(self._prsten_u_n(e["poligon"], sustav),
                            [self._prsten_u_n(r, sustav) for r in (e.get("rupe") or []) if len(r) >= 4])
            else:
                g = Polygon(self._prsten_u_n(e, sustav))
            return g if g.is_valid else g.buffer(0)

        self.izrez = unary_union([geom(e) for e in izrez]) if izrez else None
        self.izrez_iznimke_id = {e for e in iznimke if isinstance(e, str)}
        pol = [geom(e) for e in iznimke if not isinstance(e, str)]
        self.izrez_iznimke = unary_union(pol) if pol else None
        self.izrez_tlo = tlo
        if self.izrez is not None:
            self.statistika["izrez"] = {
                "zadano_u_sustavu": sustav,
                "povrsina_enu_n_m2": round(float(self.izrez.area), 0), "iznimke_id": sorted(self.izrez_iznimke_id),
                "iznimke_poligona": len(pol), "tlo": (None if tlo is None else [round(float(v), 4) for v in tlo]),
                "izostavljeno": {}}

    def _u_izrezu(self, geom, udio=0.5):
        """Je li postojeći objekt (shapely geometrija u ENU-N) u izrezu: unutarnja točka u izrezu ili više od
        `udio` površine; iznimke (poligoni) ga vraćaju."""
        if self.izrez is None:
            return False
        try:
            t = geom.representative_point()
            unutra = self.izrez.contains(t) or (geom.area > 0 and geom.intersection(self.izrez).area > udio * geom.area)
        except Exception:
            return False
        if unutra and self.izrez_iznimke is not None and self.izrez_iznimke.contains(t):
            return False
        return bool(unutra)

    def u_izrezu(self, x, y, sustav="ENU-M"):
        """Jesu li točke (polja x, y u sustavu `sustav`) unutar izreza, bez poligona iznimaka. Bez izreza sve False."""
        from shapely import contains_xy

        x = np.atleast_1d(np.asarray(x, dtype=np.float64))
        y = np.atleast_1d(np.asarray(y, dtype=np.float64))
        g = self._izrez_za_stabla()
        if g is None or g.is_empty:
            return np.zeros(len(x), bool)
        if sustav == "ENU-M":
            x, y = (np.asarray(a) for a in K.n_iz_m(x, y))
        elif sustav != "ENU-N":
            raise ValueError(f"nepoznat sustav {sustav}; dopušteno ENU-N i ENU-M")
        return contains_xy(g, x, y)

    def _izrez_za_stabla(self):
        """Geometrija izreza umanjena za poligone iznimaka (stabla u iznimkama ostaju)."""
        if self.izrez is None:
            return None
        return self.izrez if self.izrez_iznimke is None else self.izrez.difference(self.izrez_iznimke)

    def prekrij_teren(self, poligoni, boja=(0.16, 0.24, 0.07), rupe=None, sum=0.05, sustav="ENU-N"):
        """Zamjena teksture bliskog terena unutar poligona (`sustav`: "ENU-N" ili "ENU-M") jednom bojom
        (linearni RGB 0..1) uz blagi šum. Radi i prije i poslije gradnje, i više puta zaredom (različite boje
        za različite plohe). Ortofoto se ne mijenja u repou: izmijenjena kopija nastaje u privremenoj mapi
        procesa. Vraća put do kopije."""
        from PIL import Image, ImageDraw

        Image.MAX_IMAGE_PIXELS = None
        poligoni_n = [self._prsten_u_n(q, sustav) for q in poligoni]
        rupe = [self._prsten_u_n(q, sustav) for q in (rupe or [])]
        izvor = getattr(self, "_orto_put", TEREN / "ortofoto_blizu.jpg")
        im = Image.open(izvor).convert("RGB")
        W, H = im.size
        pn = self.p["pola_blizu_n"]
        px = lambda q: [((x + pn) / (2 * pn) * W, (pn - y) / (2 * pn) * H) for x, y in q]
        m = Image.new("L", (W, H), 0)
        c = ImageDraw.Draw(m)
        for q in poligoni_n:
            c.polygon(px(q), fill=255)
        for q in rupe or []:
            c.polygon(px(q), fill=0)
        okvir = m.getbbox()
        if okvir is None:
            return izvor
        srgb = [float(v * 12.92 if v <= 0.0031308 else 1.055 * v ** (1 / 2.4) - 0.055) for v in boja]
        w, h = okvir[2] - okvir[0], okvir[3] - okvir[1]
        rng = np.random.default_rng(self.sjeme + 9)
        # šum u dvije oktave (2 m i 16 m), da ploha nije jednolična
        fino = rng.normal(0, 1, (h // 4 + 2, w // 4 + 2))
        grubo = rng.normal(0, 1, (h // 32 + 2, w // 32 + 2))
        f = np.asarray(Image.fromarray(fino.astype(np.float32), "F").resize((w, h), Image.BILINEAR))
        g = np.asarray(Image.fromarray(grubo.astype(np.float32), "F").resize((w, h), Image.BICUBIC))
        ton = 1.0 + sum * (0.6 * f + 0.8 * g)
        ploha = np.clip(np.array(srgb)[None, None, :] * ton[..., None], 0, 1)
        isj = Image.fromarray((ploha * 255).astype(np.uint8), "RGB")
        im.paste(isj, okvir[:2], m.crop(okvir))
        self._orto_broj = getattr(self, "_orto_broj", 0) + 1
        put = self._tmp(f"ortofoto_prekriven_{self._orto_broj}.jpg")
        im.save(put, quality=93)
        self._orto_put = put
        # ako je materijal već izgrađen, zamijeni sliku u čvoru
        cvor = getattr(self, "_cvor_ortofota", None)
        if cvor is not None:
            cvor.image = self._slika(put)
        self.statistika.setdefault("prekriveno_tlo", []).append(
            {"poligona": len(poligoni_n), "boja_linearno": [round(float(v), 4) for v in boja]})
        return put

    def zbirka(self, sloj):
        if sloj not in self.zbirke:
            c = self.bpy.data.collections.new(sloj)
            self.scene.collection.children.link(c)
            self.zbirke[sloj] = c
        return self.zbirke[sloj]

    def dodaj_objekt(self, objekt, sloj="koncept"):
        """Uključuje postojeći Blender objekt u sloj (zbirka + indeks za masku)."""
        if sloj not in SLOJEVI:
            raise ValueError(f"nepoznat sloj {sloj}")
        for c in list(objekt.users_collection):
            c.objects.unlink(objekt)
        self.zbirka(sloj).objects.link(objekt)
        objekt.pass_index = SLOJEVI[sloj]
        return objekt

    def materijal(self, naziv, boja=(0.7, 0.7, 0.7), hrapavost=0.9, metal=0.0, atribut_boje=None):
        """Jednostavan materijal (Principled BSDF). `atribut_boje`: ime atributa boje na mreži."""
        bpy = self.bpy
        if naziv in bpy.data.materials:
            return bpy.data.materials[naziv]
        m = bpy.data.materials.new(naziv)
        m.use_nodes = True
        b = m.node_tree.nodes["Principled BSDF"]
        b.inputs["Base Color"].default_value = (*boja[:3], 1.0)
        b.inputs["Roughness"].default_value = hrapavost
        b.inputs["Metallic"].default_value = metal
        if "Specular IOR Level" in b.inputs:
            b.inputs["Specular IOR Level"].default_value = 0.25
        if atribut_boje:
            a = m.node_tree.nodes.new("ShaderNodeVertexColor")
            a.layer_name = atribut_boje
            m.node_tree.links.new(a.outputs["Color"], b.inputs["Base Color"])
        return m

    def dodaj_mrezu(self, naziv, vrhovi, plohe, sloj="koncept", boja=None, materijal=None, uv=None,
                    boje_ploha=None, glatko=False, sjena=True):
        """Mreža iz vrhova (N x 3, ENU-M, z = m n. v.) i ploha (popis popisa indeksa).

        boje_ploha  neobvezno N_ploha x 3 (linearni RGB 0..1) -> atribut "boja"
        uv          neobvezno popis UV po kutu plohe (redom kao plohe)
        """
        bpy = self.bpy
        vrhovi = np.asarray(vrhovi, dtype=np.float32).reshape(-1, 3)
        duljine = np.fromiter((len(p) for p in plohe), dtype=np.int32, count=len(plohe))
        petlje = np.fromiter((i for p in plohe for i in p), dtype=np.int32, count=int(duljine.sum()))
        return self._mreza(naziv, vrhovi, petlje, duljine, sloj, boja=boja, materijal=materijal, uv=uv,
                           boje_ploha=boje_ploha, glatko=glatko, sjena=sjena)

    def _mreza(self, naziv, co, petlje, duljine, sloj, boja=None, materijal=None, uv=None, uv2=None,
               boje_ploha=None, boje_kutova=None, glatko=False, sjena=True, povezi=True):
        bpy = self.bpy
        me = bpy.data.meshes.new(naziv)
        me.vertices.add(len(co))
        me.vertices.foreach_set("co", np.asarray(co, dtype=np.float32).ravel())
        me.loops.add(len(petlje))
        me.loops.foreach_set("vertex_index", np.asarray(petlje, dtype=np.int32))
        me.polygons.add(len(duljine))
        poc = np.zeros(len(duljine), dtype=np.int32)
        poc[1:] = np.cumsum(duljine)[:-1]
        me.polygons.foreach_set("loop_start", poc)
        me.polygons.foreach_set("loop_total", np.asarray(duljine, dtype=np.int32))
        if glatko:
            me.polygons.foreach_set("use_smooth", np.ones(len(duljine), dtype=bool))
        me.update(calc_edges=True)
        if uv is not None:
            l = me.uv_layers.new(name="uv")
            l.data.foreach_set("uv", np.asarray(uv, dtype=np.float32).ravel())
        if uv2 is not None:
            l = me.uv_layers.new(name="uv2")
            l.data.foreach_set("uv", np.asarray(uv2, dtype=np.float32).ravel())
        if boje_ploha is not None:
            bp = np.asarray(boje_ploha, dtype=np.float32).reshape(-1, 3)
            boje_kutova = np.repeat(bp, duljine, axis=0)
        if boje_kutova is not None:
            bk = np.asarray(boje_kutova, dtype=np.float32).reshape(-1, 3)
            a = me.color_attributes.new(name="boja", type="FLOAT_COLOR", domain="CORNER")
            a.data.foreach_set("color", np.concatenate([bk, np.ones((len(bk), 1), np.float32)], axis=1).ravel())
        ob = bpy.data.objects.new(naziv, me)
        if materijal is None:
            if boje_ploha is not None or boje_kutova is not None:
                materijal = self.materijal(f"mat_{naziv}", atribut_boje="boja")
            else:
                materijal = self.materijal(f"mat_{naziv}", boja or (0.7, 0.7, 0.7))
        me.materials.append(materijal)
        if not sjena:
            ob.visible_shadow = False
        if povezi:
            self.zbirka(sloj).objects.link(ob)
            ob.pass_index = SLOJEVI[sloj]
        return ob

    def _slika(self, put, prostor="sRGB"):
        put = str(put)
        if put not in self._slike:
            im = self.bpy.data.images.load(put)
            im.colorspace_settings.name = prostor
            self._slike[put] = im
        return self._slike[put]

    # --- nebo i Sunce -----------------------------------------------------
    def _nebo(self):
        bpy = self.bpy
        w = bpy.data.worlds.new("nebo")
        w.use_nodes = True
        self.scene.world = w
        nt = w.node_tree
        self._sky = nt.nodes.new("ShaderNodeTexSky")
        self._sky.sky_type = "MULTIPLE_SCATTERING"
        self._bg = nt.nodes["Background"]
        nt.links.new(self._sky.outputs[0], self._bg.inputs[0])
        self._bg.inputs["Strength"].default_value = 1.0
        self.postavi_sunce("2026-06-21 15:00")

    def postavi_sunce(self, kada=None, *, visina_deg=None, azimut_deg=None, jakost=1.0, aerosol=1.0, ozon=1.0,
                      sezona=None):
        """Sunce iz datuma i sata (lokalno vrijeme Europe/Zagreb) ili izravno iz visine i azimuta.
        Azimut: 0 = sjever, 90 = istok. U Blenderu 5.3 `sun_rotation` neba ima isti smisao (izmjereno
        sjenom stupa: rotacija 0 -> Sunce na sjeveru, 90 -> na istoku).

        sezona  "ljeto" | "jesen" | "zima" | "datum" (iz datuma u `kada`) | None (ne mijenja; zadano ljeto).
        Ograničenje: visina Sunca se steže na najmanje 0,5°, pa sumrak i noć nisu podržani."""
        if kada is not None:
            s = SUN.polozaj_sunca(kada)
        else:
            s = {"visina_deg": float(visina_deg), "azimut_deg": float(azimut_deg) % 360.0, "lokalno": None,
                 "status": "zadano izravno"}
        if sezona == "datum":
            import re as _re

            m = _re.match(r"\s*(\d{4})-(\d{2})-(\d{2})", str(kada or ""))
            sezona = sezona_za_datum(int(m.group(2)), int(m.group(3))) if m else None
        if sezona:
            self.postavi_sezonu(sezona)
        if s["visina_deg"] < 0.5:
            _log(f"visina Sunca {s['visina_deg']:.2f}° je ispod 0,5°: steže se na 0,5° (sumrak i noć nisu podržani)")
            s = {**s, "visina_stegnuta_na_deg": 0.5}
        self._sky.sun_elevation = math.radians(max(s["visina_deg"], 0.5))
        self._sky.sun_rotation = math.radians(s["azimut_deg"])
        self._sky.altitude = 120.0
        self._sky.aerosol_density = aerosol
        self._sky.ozone_density = ozon
        self._bg.inputs["Strength"].default_value = jakost
        self.sunce = {k: (round(v, 3) if isinstance(v, float) else v) for k, v in s.items()}
        self.sunce["jakost_neba"] = jakost
        self.sunce["sezona_krosnji"] = self.sezona
        return self.sunce

    def postavi_sezonu(self, sezona):
        """Boja i gustoća listopadnih krošnji: "ljeto", "jesen" ili "zima" (gole krošnje, djelomično prozirne).
        PRETPOSTAVKA, samo izgled; četinjače ostaju zelene."""
        if sezona not in SEZONE:
            raise ValueError(f"nepoznata sezona {sezona}; dopušteno {sorted(SEZONE)}")
        self.sezona = sezona
        if self.sunce is not None:
            self.sunce["sezona_krosnji"] = sezona
        cv = getattr(self, "_cvorovi_krosnje", None)
        if cv:
            boje, proz = SEZONE[sezona]
            for e, b in zip(cv["rampa"].color_ramp.elements, boje):
                e.color = (*b, 1.0)
            cv["prozirnost"].inputs["Fac"].default_value = proz
            self.scene.cycles.transparent_max_bounces = 4 if proz == 0 else 12
        return sezona

    def postavi_kameru(self, kam=None, **kw):
        """Kamera: objekt kamera.Kamera, rječnik (Kamera.u_rjecnik) ili argumenti za kamera.iz_polozaja
        (lat, lon ili x, y; kota_oka ili visina_iznad_tla; azimut_deg, nagib_deg, f35_mm, sirina_px, omjer)."""
        if kam is None:
            if "visina_iznad_tla" in kw and "tlo" not in kw:
                kw["tlo"] = self.teren.kota_m
            kam = KAM.iz_polozaja(**kw)
        elif isinstance(kam, dict):
            kam = KAM.Kamera.iz_rjecnika(kam)
        self.kamera = kam
        kam.u_blender(self.scene, daleko=3000000.0)
        return kam

    def kota_tla(self, x_m, y_m):
        """Kota tla modela (m n. v.) u točki ENU-M, bez popravka za zakrivljenost."""
        return self.teren.kota_m(x_m, y_m)

    # --- gradnja slojeva --------------------------------------------------
    def izgradi(self):
        graditelji = {
            "teren_blizu": self._gradi_teren_blizu, "teren_regija": self._gradi_teren_regija,
            "teren_daleko": self._gradi_teren_daleko,
            "vode": self._gradi_vode, "zgrade": self._gradi_zgrade, "stadion": self._gradi_stadion,
            "drvece": self._gradi_drvece,
        }
        if self.izrez is not None and self.izrez_tlo is not None and "teren_blizu" in self.slojevi:
            t0 = time.time()
            g = self._izrez_za_stabla()
            dijelovi = [g] if g.geom_type == "Polygon" else list(g.geoms)
            self.prekrij_teren([list(d.exterior.coords) for d in dijelovi], boja=self.izrez_tlo,
                               rupe=[list(r.coords) for d in dijelovi for r in d.interiors])
            self.vrijeme_gradnje_s["prekrivanje_tla"] = round(time.time() - t0, 2)
        for sloj in SVI_SLOJEVI:
            if sloj in self.slojevi:
                t0 = time.time()
                graditelji[sloj]()
                self.vrijeme_gradnje_s[sloj] = round(time.time() - t0, 2)
                _log(f"sloj {sloj}: {self.statistika['slojevi'].get(sloj)} ({self.vrijeme_gradnje_s[sloj]} s)")
        self._podloga_daleko()
        self.postavi_sezonu(self.sezona)
        if "drvece" in self.slojevi:
            t0 = time.time()
            self.provjeri_drvece()
            self.vrijeme_gradnje_s["provjera_drveca"] = round(time.time() - t0, 2)
        return self

    def provjeri_drvece(self, tolerancija=0.01):
        """Samoprovjera instanci drveća: os z svake instance gleda gore, mjerilo je jednoliko i jednako
        zadanoj visini stabla ±tolerancija. Rezultat ide u statistika["provjera_drveca"]; pogreška prekida."""
        dg = self.bpy.context.evaluated_depsgraph_get()
        mjerila, naopako, nejednoliko = [], 0, 0
        for inst in dg.object_instances:
            if not inst.is_instance or inst.parent is None or not inst.parent.name.startswith("nositelj_"):
                continue
            if inst.parent.name not in self.zbirka("drvece").objects:
                continue
            m = np.array(inst.matrix_world)
            os_ = np.linalg.norm(m[:3, :3], axis=0)
            naopako += int(m[2, 2] / max(os_[2], 1e-9) < 0.999)
            nejednoliko += int(np.ptp(os_) > tolerancija * os_.mean())
            mjerila.append(float(os_[2]))
        zadano = np.sort(np.asarray(self.stabla["visina_m"], dtype=np.float64)) if getattr(self, "stabla", None) else None
        v = np.sort(np.array(mjerila))
        out = {"instanci": int(len(v)), "naopako_ili_nagnuto": naopako, "nejednoliko": nejednoliko}
        if zadano is not None and len(zadano) == len(v) and len(v):
            rel = np.abs(v - zadano) / np.maximum(zadano, 1e-6)
            out["odstupanje_od_zadanog_najvise"] = round(float(rel.max()), 4)
            out["prolazi"] = bool(naopako == 0 and nejednoliko == 0 and rel.max() <= tolerancija)
        else:
            out["prolazi"] = False
            out["napomena"] = f"broj instanci {len(v)} ≠ broj stabala {0 if zadano is None else len(zadano)}"
        self.statistika["provjera_drveca"] = out
        _log(f"provjera drveća: {out}")
        if not out["prolazi"]:
            raise RuntimeError(f"samoprovjera instanci drveća ne prolazi: {out}")
        return out

    # teren ---------------------------------------------------------------
    def _materijal_terena(self, vrsta):
        """vrsta: "blizu" (ortofoto, na rubu prijelaz u satelitski mozaik), "regija" ili "daleko" (mozaik)."""
        bpy = self.bpy
        m = bpy.data.materials.new(f"teren_{vrsta}")
        m.use_nodes = True
        nt = m.node_tree
        b = nt.nodes["Principled BSDF"]
        b.inputs["Roughness"].default_value = 1.0
        if "Specular IOR Level" in b.inputs:
            b.inputs["Specular IOR Level"].default_value = 0.0
        reg = nt.nodes.new("ShaderNodeTexImage")
        reg.image = self._slika(self._uskladjeni_mozaik("daleko" if vrsta == "daleko" else "regija"))
        reg.extension = "EXTEND"
        uvr = nt.nodes.new("ShaderNodeUVMap")
        uvr.uv_map = "uv2" if vrsta == "blizu" else "uv"
        nt.links.new(uvr.outputs["UV"], reg.inputs["Vector"])
        if vrsta != "blizu":
            nt.links.new(reg.outputs["Color"], b.inputs["Base Color"])
            return m
        ort = nt.nodes.new("ShaderNodeTexImage")
        ort.image = self._slika(getattr(self, "_orto_put", TEREN / "ortofoto_blizu.jpg"))
        ort.extension = "EXTEND"
        self._cvor_ortofota = ort
        uvo = nt.nodes.new("ShaderNodeUVMap")
        uvo.uv_map = "uv"
        nt.links.new(uvo.outputs["UV"], ort.inputs["Vector"])
        poj = nt.nodes.new("ShaderNodeMix")
        poj.data_type = "RGBA"
        poj.blend_type = "MULTIPLY"
        poj.inputs["Factor"].default_value = 1.0
        k = self.p["pojacanje_ortofota"]
        poj.inputs["B"].default_value = (k, k, k, 1.0)
        nt.links.new(ort.outputs["Color"], poj.inputs["A"])
        # faktor prijelaza: 0 na rubu bliske plohe, 1 na udaljenosti prijelaz_teksture_m od ruba
        sep = nt.nodes.new("ShaderNodeSeparateXYZ")
        nt.links.new(uvo.outputs["UV"], sep.inputs[0])

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

        du = mat("MINIMUM", sep.outputs["X"], mat("SUBTRACT", 1.0, sep.outputs["X"]))
        dv = mat("MINIMUM", sep.outputs["Y"], mat("SUBTRACT", 1.0, sep.outputs["Y"]))
        d = mat("MINIMUM", du, dv)
        sirina = self.p["prijelaz_teksture_m"] / (2 * self.p["pola_blizu_n"])
        f = nt.nodes.new("ShaderNodeMapRange")
        f.interpolation_type = "SMOOTHSTEP"
        f.inputs["From Min"].default_value = 0.0
        f.inputs["From Max"].default_value = sirina
        nt.links.new(d, f.inputs["Value"])
        mj = nt.nodes.new("ShaderNodeMix")
        mj.data_type = "RGBA"
        nt.links.new(f.outputs["Result"], mj.inputs["Factor"])
        nt.links.new(reg.outputs["Color"], mj.inputs["A"])
        nt.links.new(poj.outputs["Result"], mj.inputs["B"])
        nt.links.new(mj.outputs["Result"], b.inputs["Base Color"])
        return m

    def uskladjenje_boje(self):
        """Krivulja po kanalu (256 vrijednosti, sRGB) kojom se satelitski mozaik (2016.) dovodi na raspodjelu
        tonova ortofota (2024.) na zajedničkoj površini ±1500 m, oboje na oko 10 m po pikselu: kvantilno
        preslikavanje od 0,5. do 99,5. percentila, iznad toga blagi nastavak s gornjom granicom. Zamjenjuje
        ranije ravno množenje (2,05; 2,25; 2,80), koje je svijetla naselja u daljini pregorijevalo."""
        if hasattr(self, "_lut"):
            return self._lut
        from PIL import Image

        Image.MAX_IMAGE_PIXELS = None
        im = Image.open(TEREN / "ortofoto_blizu.jpg")
        im.draft("RGB", (1500, 1500))
        o = np.asarray(im.convert("RGB").resize((300, 300), Image.BOX), dtype=np.float64)
        r = Image.open(TEREN / "ortofoto_regija.jpg").convert("RGB")
        mr = json.loads((TEREN / "ortofoto_regija.json").read_text(encoding="utf-8"))["mreza"]
        W, H = r.size
        pn = self.p["pola_blizu_n"]
        lon = [K.LON0 - pn / K.N_KX, K.LON0 + pn / K.N_KX]
        lat = [K.LAT0 - pn / K.N_KY, K.LAT0 + pn / K.N_KY]
        okvir = ((lon[0] - mr["lon_min"]) / (mr["lon_max"] - mr["lon_min"]) * W,
                 (mr["lat_max"] - lat[1]) / (mr["lat_max"] - mr["lat_min"]) * H,
                 (lon[1] - mr["lon_min"]) / (mr["lon_max"] - mr["lon_min"]) * W,
                 (mr["lat_max"] - lat[0]) / (mr["lat_max"] - mr["lat_min"]) * H)
        sat = np.asarray(r.crop(tuple(int(round(v)) for v in okvir)), dtype=np.float64)
        kv = np.linspace(0.005, 0.995, 100)
        lut = np.zeros((3, 256))
        v = np.arange(256, dtype=np.float64)
        for c in range(3):
            sv = np.quantile(sat[..., c], kv) + np.arange(len(kv)) * 1e-6
            ov = np.quantile(o[..., c], kv)
            l = np.interp(v, sv, ov)
            l = np.where(v < sv[0], ov[0] * v / max(sv[0], 1.0), l)
            l = np.where(v > sv[-1], ov[-1] + 0.35 * (v - sv[-1]), l)
            l = np.convolve(np.pad(l, 4, mode="edge"), np.ones(9) / 9, mode="valid")
            lut[c] = np.clip(np.maximum.accumulate(l), 0, 240)
        self._lut = lut
        lin = lambda a: np.where(a <= 0.04045, a / 12.92, ((a + 0.055) / 1.055) ** 2.4)
        prije = lin(sat.reshape(-1, 3) / 255).mean(0)
        poslije = lin(np.stack([lut[c][sat[..., c].astype(int)] for c in range(3)], -1).reshape(-1, 3) / 255).mean(0)
        self.statistika["uskladjenje_boje"] = {
            "metoda": "kvantilno preslikavanje po kanalu (sRGB), 0,5.-99,5. percentil, gornja granica 240/255",
            "srednja_linearno_mozaik": [round(float(x), 4) for x in prije],
            "srednja_linearno_ortofoto": [round(float(x), 4) for x in lin(o.reshape(-1, 3) / 255).mean(0)],
            "srednja_linearno_uskladjeno": [round(float(x), 4) for x in poslije],
            "krivulja_uzorci_ulaz_izlaz": {str(i): [int(round(lut[c][i])) for c in range(3)] for i in (32, 64, 96, 128, 192, 255)},
        }
        return lut

    def _uskladjeni_mozaik(self, vrsta):
        """Satelitski mozaik ("regija" ili "daleko") s usklađenom bojom; kopija u privremenoj mapi procesa."""
        if not hasattr(self, "_mozaici"):
            self._mozaici = {}
        if vrsta in self._mozaici:
            return self._mozaici[vrsta]
        from PIL import Image

        lut = self.uskladjenje_boje()
        izvor = (DALEKO / "ortofoto_daleko.jpg") if vrsta == "daleko" else (TEREN / "ortofoto_regija.jpg")
        a = np.asarray(Image.open(izvor).convert("RGB"))
        b = np.stack([lut[c][a[..., c]] for c in range(3)], -1)
        put = self._tmp(f"mozaik_{vrsta}.png")
        Image.fromarray(np.rint(b).astype(np.uint8), "RGB").save(put)
        self._mozaici[vrsta] = put
        lin = lambda x: np.where(x <= 0.04045, x / 12.92, ((x + 0.055) / 1.055) ** 2.4)
        self._boja_daljine = tuple(float(x) for x in lin(b.reshape(-1, 3) / 255).mean(0))
        return put

    def _gradi_teren_blizu(self):
        pn, k = self.p["pola_blizu_n"], self.p["korak_blizu_m"]
        n = int(round(2 * pn / k)) + 1
        xs = np.linspace(-pn, pn, n)
        X, Y = np.meshgrid(xs, xs)
        Z = self.teren.kota_n(X, Y)
        if "teren_regija" in self.slojevi:
            # rub prati gruba (regionalna) mreža: između njezinih čvorova kota se linearno interpolira,
            # pa na spoju nema pukotine ni preklopa
            kr = self.p["korak_regija_m"]
            grubo = np.arange(-pn, pn + 0.001, kr)
            for red in (0, n - 1):
                Z[red, :] = np.interp(xs, grubo, self.teren.kota_n(grubo, np.full_like(grubo, xs[red])))
                Z[:, red] = np.interp(xs, grubo, self.teren.kota_n(np.full_like(grubo, xs[red]), grubo))
        xm, ym = m_iz_n(X, Y)
        if self.p["zakrivljenost"]:
            Z = Z - pad_zakrivljenosti(xm, ym)
        co = np.stack([xm, ym, Z], axis=-1).reshape(-1, 3)
        i = np.arange(n * n).reshape(n, n)
        q = np.stack([i[:-1, :-1], i[:-1, 1:], i[1:, 1:], i[1:, :-1]], axis=-1).reshape(-1, 4)
        petlje = q.ravel()
        uv = np.stack([(X + pn) / (2 * pn), (Y + pn) / (2 * pn)], axis=-1).reshape(-1, 2)[petlje]
        mr = self.teren.meta_r
        lon, lat = K.LON0 + X / K.N_KX, K.LAT0 + Y / K.N_KY
        uv2 = np.stack([(lon - mr["lon_min"]) / (mr["lon_max"] - mr["lon_min"]),
                        (lat - mr["lat_min"]) / (mr["lat_max"] - mr["lat_min"])], axis=-1).reshape(-1, 2)[petlje]
        self._dno = min(getattr(self, "_dno", 1e9), float(Z.min()))
        self._mreza("teren_blizu", co, petlje, np.full(len(q), 4, np.int32), "teren_blizu",
                    materijal=self._materijal_terena("blizu"), uv=uv, uv2=uv2, glatko=True)
        self.statistika["slojevi"]["teren_blizu"] = {"vrhova": int(n * n), "ploha": int(len(q)), "korak_m": k,
                                                     "stranica_m": round(float(xm.max() - xm.min()), 1)}

    def _gradi_teren_regija(self):
        t = self.teren
        k, pn = self.p["korak_regija_m"], self.p["pola_blizu_n"]
        xs = np.arange(math.ceil(t.rx[0] / k) * k, t.rx[1] + 1e-6, k)
        ys = np.arange(math.ceil(t.ry[0] / k) * k, t.ry[1] + 1e-6, k)
        X, Y = np.meshgrid(xs, ys)
        Z = t.kota_n(X, Y)
        xm, ym = m_iz_n(X, Y)
        if self.p["zakrivljenost"]:
            Z = Z - pad_zakrivljenosti(xm, ym)
        co = np.stack([xm, ym, Z], axis=-1).reshape(-1, 3)
        ny, nx = X.shape
        i = np.arange(nx * ny).reshape(ny, nx)
        q = np.stack([i[:-1, :-1], i[:-1, 1:], i[1:, 1:], i[1:, :-1]], axis=-1).reshape(-1, 4)
        if "teren_blizu" in self.slojevi:
            # izrez: bliska ploha ima prednost; plohe čije je središte unutar ±pola_blizu se ne grade
            cx = (X[:-1, :-1] + X[1:, 1:]).ravel() / 2
            cy = (Y[:-1, :-1] + Y[1:, 1:]).ravel() / 2
            q = q[~((np.abs(cx) < pn) & (np.abs(cy) < pn))]
        petlje = q.ravel()
        mr = t.meta_r
        lon, lat = K.LON0 + X / K.N_KX, K.LAT0 + Y / K.N_KY
        uv = np.stack([(lon - mr["lon_min"]) / (mr["lon_max"] - mr["lon_min"]),
                       (lat - mr["lat_min"]) / (mr["lat_max"] - mr["lat_min"])], axis=-1).reshape(-1, 2)[petlje]
        self._mreza("teren_regija", co, petlje, np.full(len(q), 4, np.int32), "teren_regija",
                    materijal=self._materijal_terena("regija"), uv=uv, glatko=True)
        self._okvir_regije_n = (float(xs[0]), float(xs[-1]), float(ys[0]), float(ys[-1]))
        self._dno = min(getattr(self, "_dno", 1e9), float(Z.min()))
        self.statistika["slojevi"]["teren_regija"] = {
            "vrhova": int(nx * ny), "ploha": int(len(q)), "korak_m": k,
            "okvir_enu_m": [round(float(v), 0) for v in (xm.min(), xm.max(), ym.min(), ym.max())],
            "izrez_bliske_plohe": "teren_blizu" in self.slojevi}

    def _gradi_teren_daleko(self):
        """Daleki pojas (research/viz/model/daleko/): mreža 3" do okvira DALEKO_OKVIR, s rupom na mjestu
        regionalne (ili bliske) plohe. Ćelije koje sijeku rub unutarnje plohe ostaju i podvlače se pod nju:
        njihovi vrhovi unutar unutarnje plohe spušteni su 25 m, pa nema ni pukotine ni dviju ploha na istoj visini."""
        t = self.teren
        md = t.meta_d
        pr = max(1, int(self.p["prorjeda_daleko"]))
        st = np.arange(0, md["stupaca"], pr)
        rd = np.arange(0, md["redova"], pr)
        LO, LA = np.meshgrid(md["lon_min"] + st * md["korak_stupnjevi"], md["lat_max"] - rd * md["korak_stupnjevi"])
        X, Y = (LO - K.LON0) * K.N_KX, (LA - K.LAT0) * K.N_KY
        Z = t.kota_n(X, Y)
        ny, nx = X.shape
        i = np.arange(nx * ny).reshape(ny, nx)
        q = np.stack([i[:-1, :-1], i[1:, :-1], i[1:, 1:], i[:-1, 1:]], axis=-1).reshape(-1, 4)
        okvir = None
        if "teren_regija" in self.slojevi:
            okvir = getattr(self, "_okvir_regije_n", None)
        elif "teren_blizu" in self.slojevi:
            pn = self.p["pola_blizu_n"]
            okvir = (-pn, pn, -pn, pn)
        if okvir is not None:
            u = (X > okvir[0] + 5) & (X < okvir[1] - 5) & (Y > okvir[2] + 5) & (Y < okvir[3] - 5)
            Z = np.where(u, Z - 25.0, Z)
            q = q[~u.ravel()[q].all(axis=1)]
        xm, ym = m_iz_n(X, Y)
        if self.p["zakrivljenost"]:
            Z = Z - pad_zakrivljenosti(xm, ym)
        co = np.stack([xm, ym, Z], axis=-1).reshape(-1, 3)
        petlje = q.ravel()
        uv = np.stack([(LO - md["lon_min"]) / (md["lon_max"] - md["lon_min"]),
                       (LA - md["lat_min"]) / (md["lat_max"] - md["lat_min"])], axis=-1).reshape(-1, 2)[petlje]
        self._mreza("teren_daleko", co, petlje, np.full(len(q), 4, np.int32), "teren_daleko",
                    materijal=self._materijal_terena("daleko"), uv=uv, glatko=True)
        self._dno = min(getattr(self, "_dno", 1e9), float(Z.min()))
        self.statistika["slojevi"]["teren_daleko"] = {
            "vrhova": int(nx * ny), "ploha": int(len(q)), "korak_lucnih_sekundi": 3 * pr,
            "okvir_lonlat": [md["lon_min"], md["lat_min"], md["lon_max"], md["lat_max"]],
            "okvir_enu_m": [round(float(v), 0) for v in (xm.min(), xm.max(), ym.min(), ym.max())],
            "rupa_za_unutarnju_plohu": okvir is not None}

    def _podloga_daleko(self):
        """Ravna ploha ispod najniže kote terena, do 1500 km: izvan dosega rastera nema podataka. Uz zračnu
        perspektivu se stapa s nebom na obzoru; rub plohe je s 300 m visine samo 0,01° ispod obzora, pa se
        tamniji dio neba ispod obzora ne vidi."""
        if not hasattr(self, "_dno"):
            return
        dno = self._dno - 3.0
        R = 1500000.0
        kut = np.linspace(0, 2 * math.pi, 65)[:-1]
        prsten = np.stack([R * np.cos(kut), R * np.sin(kut), np.full(64, dno)], axis=1)
        self.uskladjenje_boje()
        if not hasattr(self, "_boja_daljine"):
            self._uskladjeni_mozaik("daleko" if "teren_daleko" in self.slojevi else "regija")
        sloj = "teren_daleko" if "teren_daleko" in self.slojevi else ("teren_regija" if "teren_regija" in self.slojevi else "teren_blizu")
        self.dodaj_mrezu("podloga_daleko", prsten, [list(range(64))], sloj=sloj,
                         materijal=self.materijal("podloga_daleko", self._boja_daljine, hrapavost=1.0))
        self.statistika["slojevi"][sloj]["daleka_podloga_kota"] = round(dno, 1)

    # pomoćno za poligone ---------------------------------------------------
    def _prsten_m(self, tocke):
        p = np.asarray(tocke, dtype=np.float64)
        if len(p) > 1 and np.allclose(p[0], p[-1]):
            p = p[:-1]
        xm, ym = m_iz_n(p[:, 0], p[:, 1])
        return np.stack([xm, ym], axis=1), self.teren.kota_n(p[:, 0], p[:, 1])

    @staticmethod
    def _trokuti(prstenovi):
        """Triangulacija poligona s rupama (mathutils). Vraća indekse u spojenom popisu vrhova."""
        from mathutils import Vector
        from mathutils.geometry import tessellate_polygon

        return tessellate_polygon([[Vector((float(x), float(y), 0.0)) for x, y in pr] for pr in prstenovi])

    def _prizma(self, prstenovi_m, z_dno, z_vrh, spremnik, boja_zida, boja_krova, z_vrh_po_vrhu=None):
        """Dodaje uspravnu prizmu (zidovi + krov) u spremnik {co, plohe, boje}."""
        co, plohe, boje = spremnik["co"], spremnik["plohe"], spremnik["boje"]
        baza = len(co)
        svi = np.concatenate(prstenovi_m, axis=0)
        n = len(svi)
        zv = np.full(n, z_vrh) if z_vrh_po_vrhu is None else np.asarray(z_vrh_po_vrhu, dtype=np.float64)
        for (x, y), z in zip(svi, zv):
            co.append((x, y, z))
        for x, y in svi:
            co.append((x, y, z_dno))
        for a, b, c in self._trokuti(prstenovi_m):
            plohe.append((baza + a, baza + b, baza + c))
            boje.append(boja_krova)
        poc = 0
        for pr in prstenovi_m:
            m = len(pr)
            for i in range(m):
                a, b = poc + i, poc + (i + 1) % m
                plohe.append((baza + a, baza + b, baza + n + b, baza + n + a))
                boje.append(boja_zida)
            poc += m

    def _boja_iz_ortofota(self, poligon_n):
        """Srednja boja ortofota unutar okvira poligona (linearni RGB), za boju krova."""
        if not hasattr(self, "_orto_mali"):
            from PIL import Image

            Image.MAX_IMAGE_PIXELS = None
            im = Image.open(TEREN / "ortofoto_blizu.jpg")
            im.draft("RGB", (3000, 3000))
            a = np.asarray(im.resize((3000, 3000), Image.BOX), dtype=np.float32) / 255.0
            self._orto_mali = np.where(a <= 0.04045, a / 12.92, ((a + 0.055) / 1.055) ** 2.4)
        p = np.asarray(poligon_n)
        pn = self.p["pola_blizu_n"]
        x0, x1 = p[:, 0].min(), p[:, 0].max()
        y0, y1 = p[:, 1].min(), p[:, 1].max()
        if x0 < -pn or x1 > pn or y0 < -pn or y1 > pn:
            return None
        # uži okvir (srednjih 60 %) da se izbjegnu rubovi i sjene
        sx, sy = (x1 - x0) * 0.2, (y1 - y0) * 0.2
        c0, c1 = int((x0 + sx + pn)), int(math.ceil(x1 - sx + pn))
        r0, r1 = int((pn - (y1 - sy))), int(math.ceil(pn - (y0 + sy)))
        isj = self._orto_mali[max(r0, 0):max(r1, r0 + 1), max(c0, 0):max(c1, c0 + 1)]
        if isj.size == 0:
            return None
        return isj.reshape(-1, 3).mean(0)

    # zgrade ----------------------------------------------------------------
    def _gradi_zgrade(self):
        from shapely.geometry import Point, Polygon

        rng = np.random.default_rng(self.sjeme + 1)
        obris_stadiona = Polygon(self.site["stadion_maksimir"]["obris"]["poligon"])
        spremnik = {"co": [], "plohe": [], "boje": []}
        broj, preskoceno, izrezano = 0, 0, []
        self._zgrade_stadiona = []
        for z in self.site["zgrade"]:
            p = z["poligon"]
            if len(p) < 4:
                preskoceno += 1
                continue
            if obris_stadiona.contains(Point(np.mean(np.asarray(p)[:-1], axis=0))):
                self._zgrade_stadiona.append(z)  # ide u sloj "stadion"
                continue
            # slučajni ton se troši i za izrezane zgrade, da ostale zadrže istu boju s izrezom i bez njega
            ton = rng.random()
            if self.izrez is not None and z["id"] not in self.izrez_iznimke_id:
                g = Polygon(p)
                if self._u_izrezu(g if g.is_valid else g.buffer(0)):
                    izrezano.append(z["id"])
                    continue
            self._zgrada_u_spremnik(z, spremnik, ton)
            broj += 1
        ob = self.dodaj_mrezu("zgrade", spremnik["co"], spremnik["plohe"], sloj="zgrade", boje_ploha=spremnik["boje"])
        self.statistika["slojevi"]["zgrade"] = {"zgrada": broj, "ploha": len(spremnik["plohe"]),
                                                "premjesteno_u_sloj_stadion": len(self._zgrade_stadiona),
                                                "preskoceno": preskoceno}
        if self.izrez is not None:
            self.statistika["izrez"]["izostavljeno"]["zgrade"] = len(izrezano)
            self.statistika["izrez"]["izostavljene_zgrade_id"] = izrezano
        return ob

    def _zgrada_u_spremnik(self, z, spremnik, ton, visina=None):
        prstenovi, kote = [], []
        for pr in [z["poligon"]] + list(z.get("rupe") or []):
            xy, k = self._prsten_m(pr)
            if len(xy) >= 3:
                prstenovi.append(xy)
                kote.append(k)
        if not prstenovi:
            return
        tlo = np.concatenate(kote)
        h = float(visina if visina is not None else ISPRAVCI_VISINA.get(z["id"], z.get("visina_m") or 7.0))
        siva = 0.62 + 0.14 * float(ton)
        zid = (siva * 1.02, siva, siva * 0.96)
        krov = None
        if self.p["krovovi_iz_ortofota"]:
            b = self._boja_iz_ortofota(z["poligon"])
            if b is not None:
                # boja krova: pola iz ortofota, pola neutralna siva iste svjetline
                l = float(b.mean())
                krov = tuple(float(v) for v in 0.6 * b + 0.4 * l)
        if krov is None:
            krov = (0.33, 0.31, 0.30)
        self._prizma(prstenovi, float(tlo.min()) - 0.5, float(np.median(tlo)) + h, spremnik, zid, krov)

    # postojeći stadion -------------------------------------------------------
    def _gradi_stadion(self):
        from shapely.geometry import Point, Polygon

        rng = np.random.default_rng(self.sjeme + 2)
        st = self.site["stadion_maksimir"]
        igr = Polygon(st["igraliste"]["poligon"])
        z_igr = float(np.median(self.teren.kota_n(*np.asarray(st["igraliste"]["poligon"]).T)))
        spremnik = {"co": [], "plohe": [], "boje": []}
        opis = {}
        for t in st["tribine"]:
            nisko, visoko = self.p.get("visine_tribina", VISINE_TRIBINA).get(t["strana"], (2.0, 20.0))
            xy, kote = self._prsten_m(t["poligon"])
            p_n = np.asarray(t["poligon"][:-1] if t["poligon"][0] == t["poligon"][-1] else t["poligon"])
            d = np.array([igr.exterior.distance(Point(q)) for q in p_n])
            # kosa ploha gledališta: nizak rub uz igralište, visok stražnji rub
            f = np.clip((d - d.min()) / max(d.max() - d.min(), 1e-6), 0, 1)
            f = np.where(f > 0.6, 1.0, np.where(f < 0.25, 0.0, f))
            zv = z_igr + nisko + (visoko - nisko) * f
            self._prizma([xy], float(kote.min()) - 0.5, None, spremnik, (0.60, 0.62, 0.66), (0.20, 0.30, 0.55),
                         z_vrh_po_vrhu=zv)
            opis[t["strana"]] = {"rub_uz_igraliste_m": nisko, "straznji_rub_m": visoko}
        if not hasattr(self, "_zgrade_stadiona"):
            obris = Polygon(st["obris"]["poligon"])
            self._zgrade_stadiona = [z for z in self.site["zgrade"]
                                     if obris.contains(Point(np.mean(np.asarray(z["poligon"])[:-1], axis=0)))]
        tribine_id = {t["id"] for t in st["tribine"]}
        ostalo = 0
        for z in self._zgrade_stadiona:
            if z["id"] in tribine_id:
                continue
            # prateće zgrade unutar obrisa stadiona; zgrada koja pokriva igralište (natkrivanje u OSM-u) se ne gradi
            if Polygon(z["poligon"]).intersection(igr).area > 0.3 * igr.area:
                continue
            self._zgrada_u_spremnik(z, spremnik, rng.random())
            ostalo += 1
        self.dodaj_mrezu("stadion_postojeci", spremnik["co"], spremnik["plohe"], sloj="stadion",
                         boje_ploha=spremnik["boje"])
        self.statistika["slojevi"]["stadion"] = {"tribina": len(st["tribine"]), "pratecih_zgrada": ostalo,
                                                 "kota_igralista": round(z_igr, 1), "visine_tribina_m": opis,
                                                 "status_visina": "PRETPOSTAVKA (usklađeno s obrisima na snimkama, nije mjereno)"}

    # vode --------------------------------------------------------------------
    def _gradi_vode(self):
        from shapely.geometry import Polygon

        spremnik = {"co": [], "plohe": []}
        broj, izrezano = 0, 0
        for v in self.site["vode"]["povrsine"]:
            if self.izrez is not None and len(v["poligon"]) >= 4 and v.get("id") not in self.izrez_iznimke_id:
                g = Polygon(v["poligon"])
                if self._u_izrezu(g if g.is_valid else g.buffer(0)):
                    izrezano += 1
                    continue
            prstenovi, kote = [], []
            for pr in [v["poligon"]] + list(v.get("rupe") or []):
                xy, k = self._prsten_m(pr)
                if len(xy) >= 3:
                    prstenovi.append(xy)
                    kote.append(k)
            if not prstenovi:
                continue
            razina = float(np.percentile(np.concatenate(kote), 60)) + 0.35
            baza = len(spremnik["co"])
            for x, y in np.concatenate(prstenovi):
                spremnik["co"].append((x, y, razina))
            for a, b, c in self._trokuti(prstenovi):
                spremnik["plohe"].append((baza + a, baza + b, baza + c))
            broj += 1
        if self.izrez is not None:
            self.statistika["izrez"]["izostavljeno"]["vode"] = izrezano
        if not broj:
            return
        m = self.materijal("voda", (0.035, 0.07, 0.075), hrapavost=0.08)
        self.dodaj_mrezu("vode", spremnik["co"], spremnik["plohe"], sloj="vode", materijal=m)
        self.statistika["slojevi"]["vode"] = {"povrsina": broj, "napomena": "razina = 60. percentil kote ruba + 0,35 m"}

    # drveće --------------------------------------------------------------------
    def _oblici_stabala(self):
        """Nekoliko niskopoligonalnih oblika (jedinična visina 1, deblo u ishodištu). Sve proceduralno."""
        import bmesh
        from mathutils import Matrix, Vector, noise

        bpy = self.bpy
        rng = np.random.default_rng(self.sjeme + 3)
        mat = self._materijal_krosnje(listopadno=True)
        mat_cet = self._materijal_krosnje(listopadno=False)
        deblo = self.materijal("deblo", (0.11, 0.08, 0.06), hrapavost=1.0)
        # (naziv, omjer širine krošnje i visine, početak krošnje, broj grudica, stožasto)
        opisi = [("hrast", 0.78, 0.30, 26, False), ("lipa", 0.62, 0.28, 22, False), ("grab", 0.50, 0.24, 18, False),
                 ("siroko", 0.95, 0.36, 28, False), ("jablan", 0.26, 0.12, 12, False), ("cetinjaca", 0.36, 0.10, 0, True)]
        oblici = []
        for naziv, sir, poc, grud, stozac in opisi:
            bm = bmesh.new()
            tonovi = {}
            # deblo
            g = bmesh.ops.create_cone(bm, cap_ends=False, segments=6, radius1=0.022, radius2=0.014, depth=poc + 0.15,
                                      matrix=Matrix.Translation((0, 0, (poc + 0.15) / 2)))
            for f in bm.faces:
                f.material_index = 1
            if stozac:
                for i, (r, z0, z1) in enumerate([(sir / 2, poc, 0.62), (sir / 2 * 0.72, 0.40, 0.84), (sir / 2 * 0.42, 0.66, 1.0)]):
                    novi = bmesh.ops.create_cone(bm, cap_ends=True, segments=14, radius1=r, radius2=0.0, depth=z1 - z0,
                                                 matrix=Matrix.Translation((0, 0, (z0 + z1) / 2)))["verts"]
                    for f in {f for v in novi for f in v.link_faces}:
                        f.material_index = 0
                        f.smooth = True
            else:
                vis = 1.0 - poc
                sred = Vector((0, 0, poc + vis * 0.52))
                for i in range(grud):
                    if i == 0:
                        c = sred
                        r = (sir * 0.40, sir * 0.40, vis * 0.45)
                    else:
                        # grudice na ljusci oko središta krošnje; preklapaju se sa središnjom i međusobno
                        a = 2 * math.pi * (i * 0.618034) + rng.uniform(-0.25, 0.25)
                        vz = rng.uniform(-0.55, 0.95)
                        vr = math.sqrt(max(1 - vz * vz, 0.05))
                        k = rng.uniform(0.62, 0.92)
                        c = sred + Vector((math.cos(a) * vr * k * sir * 0.5, math.sin(a) * vr * k * sir * 0.5, vz * k * vis * 0.5))
                        q = rng.uniform(0.11, 0.19)
                        r = (sir * q, sir * q, vis * q * 0.95)
                    # Novi vrhovi se uzimaju iz povratne vrijednosti operatora (usporedba skupova bm.verts nije
                    # pouzdana kad mreža naraste). Podjela 2 = 80 trokuta po grudici, središnja 320; ranije su
                    # grudice bile ikosaedri s 20 ploha, pa je krošnja izbliza bila bridasta.
                    pod = int(self.p["podjela_krosnje"])
                    novi = bmesh.ops.create_icosphere(bm, subdivisions=pod + 1 if i == 0 else pod, radius=1.0)["verts"]
                    ton = 1.0 if i == 0 else rng.uniform(0.80, 1.15)
                    pomak = Vector((i * 3.1, len(naziv), 0))
                    for v in novi:
                        n = 1.0 + 0.24 * noise.noise(v.co * 2.6 + pomak) + 0.10 * noise.noise(v.co * 6.1 - pomak)
                        v.co = Vector((v.co.x * r[0] * n, v.co.y * r[1] * n, v.co.z * r[2] * n)) + c
                    for f in {f for v in novi for f in v.link_faces}:
                        f.material_index = 0
                        f.smooth = True
                    bm.verts.index_update()
                    for v in novi:
                        tonovi[v.index] = ton
            # krošnja ne smije prijeći jediničnu visinu
            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}")
            bm.to_mesh(me)
            bm.free()
            me.polygons.foreach_set("use_smooth", np.ones(len(me.polygons), dtype=bool))
            me.update()
            # atribut "boja": zatamnjenje donjeg i unutarnjeg dijela krošnje (jeftina zamjena za samosjenu)
            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)
            t = np.clip((co[:, 2] - poc) / max(1 - poc, 1e-6), 0, 1)
            rub = np.clip(np.hypot(co[:, 0], co[:, 1]) / (sir / 2), 0, 1)
            sj = 0.68 + 0.32 * np.clip(0.65 * t + 0.35 * rub, 0, 1)
            sj = sj * 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_cet if stozac else mat)
            me.materials.append(deblo)
            oblici.append({"naziv": naziv, "mreza": me, "sirina": sir, "trokuta": sum(len(p.vertices) - 2 for p in me.polygons)})
        return oblici

    def _materijal_krosnje(self, listopadno=True):
        bpy = self.bpy
        m = bpy.data.materials.new("krosnja" if listopadno else "krosnja_cetinjaca")
        m.use_nodes = True
        nt = m.node_tree
        b = nt.nodes["Principled BSDF"]
        b.inputs["Roughness"].default_value = 0.85
        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
        boje = SEZONE["ljeto"][0] if listopadno else [(0.030, 0.085, 0.030), (0.045, 0.110, 0.038), (0.055, 0.120, 0.045), (0.070, 0.140, 0.050)]
        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), boje):
            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"])
        # dio svjetla prolazi kroz krošnju: ublažava tvrde sjene među grudicama
        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.30
        nt.links.new(b.outputs["BSDF"], mj.inputs[1])
        nt.links.new(tr.outputs["BSDF"], mj.inputs[2])
        izl = next(n for n in nt.nodes if n.type == "OUTPUT_MATERIAL")
        # udio prozirnosti (gole krošnje zimi); 0 = bez učinka
        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])
        nt.links.new(mp.outputs["Shader"], izl.inputs["Surface"])
        if listopadno:
            self._cvorovi_krosnje = {"rampa": rampa, "prozirnost": mp}
        return m

    def polozaji_stabala(self):
        """Položaji (ENU-N), visine i skupine stabala. Determinističko za zadano sjeme.

        Skupine: suma (poligoni šume iz OSM-a, zbijena mreža s pomakom), drvored (linije iz OSM-a),
        stablo (točke iz OSM-a), ortofoto (krošnje prepoznate po boji na ortofotu izvan šume; PRETPOSTAVKA).
        """
        from shapely.geometry import LineString, Point, Polygon
        from shapely.ops import unary_union
        from shapely.prepared import prep

        rng = np.random.default_rng(self.sjeme + 4)
        site = self.site
        xs, ys, hs, sk, ws = [], [], [], [], []

        def poligon(e):
            try:
                g = Polygon(e["poligon"], [r for r in (e.get("rupe") or []) if len(r) >= 4])
                return g if g.is_valid else g.buffer(0)
            except Exception:
                return None

        vode = unary_union([g for g in (poligon(e) for e in site["vode"]["povrsine"]) if g is not None])
        zgrade = unary_union([g for g in (poligon(e) for e in site["zgrade"]) if g is not None]).buffer(1.5)
        tereni = unary_union([g for g in (poligon(e) for e in site["sportski_tereni"]) if g is not None])
        sume = [g for g in (poligon(e) for e in site["park_maksimir"]["granica_osm_cijela"] + site["zelenilo"]["sume"])
                if g is not None]
        suma_puna = unary_union(sume).difference(vode.buffer(2.0))
        suma = suma_puna.buffer(-3.0)  # krošnje rubnih stabala ne prelaze daleko preko ruba poligona
        # 1) šuma: mreža s pomakom
        r = self.p["razmak_sume_m"]
        x0, y0, x1, y1 = suma.bounds
        gx, gy = np.meshgrid(np.arange(x0, x1, r), np.arange(y0, y1, r * 0.866))
        gx = gx + (np.arange(gx.shape[0])[:, None] % 2) * r / 2
        px = (gx + rng.uniform(-0.35, 0.35, gx.shape) * r).ravel()
        py = (gy + rng.uniform(-0.35, 0.35, gy.shape) * r).ravel()
        ps = prep(suma)
        zg = prep(zgrade)
        u = np.fromiter((ps.contains(Point(a, b)) and not zg.contains(Point(a, b)) for a, b in zip(px, py)), bool, len(px))
        n = int(u.sum())
        xs.append(px[u]); ys.append(py[u]); hs.append(rng.normal(24.0, 3.5, n).clip(14, 33)); sk.append(np.full(n, 0))
        ws.append(np.full(n, np.inf))
        # 2) drvoredi
        dx, dy = [], []
        for d in site["zelenilo"]["drvoredi"]:
            l = LineString(d["linija"])
            for s in np.arange(self.p["razmak_drvoreda_m"] / 2, l.length, self.p["razmak_drvoreda_m"]):
                q = l.interpolate(float(s))
                dx.append(q.x); dy.append(q.y)
        n = len(dx)
        xs.append(np.array(dx)); ys.append(np.array(dy)); hs.append(rng.normal(14.0, 2.0, n).clip(8, 20)); sk.append(np.full(n, 1))
        ws.append(np.full(n, 10.0))
        # 3) pojedinačna stabla iz OSM-a
        st = np.asarray(site["zelenilo"]["stabla"], dtype=np.float64).reshape(-1, 2)
        n = len(st)
        xs.append(st[:, 0]); ys.append(st[:, 1]); hs.append(rng.normal(12.0, 3.0, n).clip(6, 20)); sk.append(np.full(n, 2))
        ws.append(np.full(n, 10.0))
        # 4) krošnje prepoznate na ortofotu (izvan šume, zgrada, voda i sportskih terena)
        if self.p["stabla_iz_ortofota"]:
            ox, oy, oh, ow = self._stabla_iz_ortofota(rng, prep(unary_union([suma_puna, zgrade, vode, tereni])),
                                                      np.concatenate(xs), np.concatenate(ys))
            xs.append(ox); ys.append(oy); hs.append(oh); sk.append(np.full(len(ox), 3)); ws.append(ow)
        return (np.concatenate(xs), np.concatenate(ys), np.concatenate(hs), np.concatenate(sk),
                ("suma", "drvored", "stablo", "ortofoto"), np.concatenate(ws))

    def _stabla_izvan_izreza(self, x, y, polumjer):
        """Maska stabala koja ostaju: deblo izvan izreza i (uz izrez_krosnje) krošnja ne zadire u izrez."""
        from shapely import contains_xy, distance, points

        g = self._izrez_za_stabla()
        if g is None or g.is_empty or not len(x):
            return np.ones(len(x), bool)
        u = contains_xy(g, x, y)
        if self.p["izrez_krosnje"]:
            # samo stabla u okviru izreza proširenom za najveći polumjer trebaju točnu udaljenost
            x0, y0, x1, y1 = g.bounds
            r = float(polumjer.max()) if len(polumjer) else 0.0
            blizu = (~u) & (x > x0 - r) & (x < x1 + r) & (y > y0 - r) & (y < y1 + r)
            if blizu.any():
                d = distance(g, points(x[blizu], y[blizu]))
                u[np.nonzero(blizu)[0][d < polumjer[blizu]]] = True
        return ~u

    def maska_krosnji(self, korak=2.0):
        """Gruba maska krošnji iz boje ortofota (mreža `korak` m, ENU-N). PRETPOSTAVKA: tamno zelena
        i neujednačena ploha je krošnja; svijetla i glatka zelena je travnjak. Ne razlikuje sjenu od krošnje
        savršeno i ne radi izvan lisne sezone snimke."""
        from PIL import Image
        from scipy import ndimage

        Image.MAX_IMAGE_PIXELS = None
        pn = self.p["pola_blizu_n"]
        n = int(2 * pn / korak)
        im = Image.open(TEREN / "ortofoto_blizu.jpg")
        puna = np.asarray(im.convert("RGB"), dtype=np.float32) / 255.0
        f = puna.shape[0] // n
        # srednja boja i hrapavost (st. dev. svjetline) po ćeliji
        a = puna[:n * f, :n * f].reshape(n, f, n, f, 3)
        sr = a.mean(axis=(1, 3))
        sv = a.mean(axis=4)
        hrap = sv.std(axis=(1, 3))
        r, g, b = sr[..., 0], sr[..., 1], sr[..., 2]
        # pragovi izmjereni na ortofotu 2024.: šuma g/r 1,33, g/b 1,04, svjetlina 0,33, hrapavost 0,03;
        # travnjak g/r 1,27, g/b 1,18, svjetlina 0,41-0,46, hrapavost 0,005
        zeleno = (g > r * 1.12) & (g >= b * 0.98) & (g < b * 1.13)
        svjetlina = sr.mean(-1)
        m = zeleno & (svjetlina < 0.42) & (hrap > 0.010)
        m = ndimage.binary_opening(m, iterations=1)
        m = ndimage.binary_closing(m, iterations=3)
        return m, korak

    def _stabla_iz_ortofota(self, rng, zabranjeno, zx, zy):
        from scipy import ndimage
        from scipy.spatial import cKDTree
        from shapely.geometry import Point

        m, korak = self.maska_krosnji()
        pn = self.p["pola_blizu_n"]
        # udaljenost do ruba krošnje -> veličina stabla; lokalni maksimumi = središta krošnji
        d = ndimage.distance_transform_edt(m) * korak
        mx = ndimage.maximum_filter(d, size=5)
        red, stup = np.nonzero((d == mx) & (d >= 2.0))
        x = -pn + (stup + 0.5) * korak + rng.uniform(-0.6, 0.6, len(stup))
        y = pn - (red + 0.5) * korak + rng.uniform(-0.6, 0.6, len(red))
        pol = d[red, stup]
        # velike plohe krošnji (zbijeno drveće): dopuni mrežom 8 m
        gx, gy = np.meshgrid(np.arange(-pn + 4, pn, 8.0), np.arange(-pn + 4, pn, 8.0))
        gx = (gx + rng.uniform(-2.5, 2.5, gx.shape)).ravel()
        gy = (gy + rng.uniform(-2.5, 2.5, gy.shape)).ravel()
        gi = np.clip(((pn - gy) / korak).astype(int), 0, m.shape[0] - 1)
        gj = np.clip(((gx + pn) / korak).astype(int), 0, m.shape[1] - 1)
        ug = d[gi, gj] >= 5.0
        x = np.concatenate([x, gx[ug]])
        y = np.concatenate([y, gy[ug]])
        pol = np.concatenate([pol, np.minimum(d[gi, gj][ug], 9.0)])
        # prorijedi: najmanji razmak 4,5 m međusobno i do stabala iz OSM-a
        red_ = np.argsort(-pol)
        x, y, pol = x[red_], y[red_], pol[red_]
        zadrzi = np.ones(len(x), bool)
        stablo = cKDTree(np.stack([x, y], 1))
        for i, j in stablo.query_pairs(4.5):
            if zadrzi[i] and zadrzi[j]:
                zadrzi[max(i, j)] = False
        if len(zx):
            du, _ = cKDTree(np.stack([zx, zy], 1)).query(np.stack([x, y], 1))
            zadrzi &= du > 4.0
        zadrzi &= np.fromiter((not zabranjeno.contains(Point(a, b)) for a, b in zip(x, y)), bool, len(x))
        x, y, pol = x[zadrzi], y[zadrzi], pol[zadrzi]
        h = np.clip(7.0 + 2.1 * pol + rng.normal(0, 1.5, len(pol)), 6.0, 26.0)
        return x, y, h, 2.0 * (pol + 1.5)  # najveća širina krošnje: do 1,5 m preko ruba prepoznate krošnje

    def _gradi_drvece(self):
        bpy = self.bpy
        rng = np.random.default_rng(self.sjeme + 5)
        x, y, h, sk, imena, najsira = self.polozaji_stabala()
        z = self.teren.kota_n(x, y)
        xm, ym = m_iz_n(x, y)
        if self.p["zakrivljenost"]:
            z = z - pad_zakrivljenosti(xm, ym)
        oblici = self._oblici_stabala()
        # izbor oblika po skupini (vjerojatnosti): hrast, lipa, grab, siroko, jablan, cetinjaca
        vjer = {0: [0.38, 0.22, 0.25, 0.10, 0.02, 0.03], 1: [0.15, 0.55, 0.15, 0.05, 0.10, 0.0],
                2: [0.25, 0.30, 0.15, 0.15, 0.05, 0.10], 3: [0.22, 0.26, 0.17, 0.17, 0.04, 0.14]}
        izbor = np.zeros(len(x), dtype=int)
        for s, p in vjer.items():
            u = sk == s
            izbor[u] = rng.choice(len(oblici), size=int(u.sum()), p=p)
        # krošnja ne smije biti šira od dopuštene (stabla prepoznata na ortofotu): po potrebi se stablo smanji
        sirine = np.array([o["sirina"] for o in oblici])[izbor]
        h = np.minimum(h, np.maximum(najsira / sirine, 5.0))
        kut = rng.uniform(0, 2 * math.pi, len(x))
        # izrez obuhvata koncepta: nakon svih slučajnih izbora, da ostala stabla ostanu ista s izrezom i bez njega
        ostaje = self._stabla_izvan_izreza(x, y, 0.5 * sirine * h * 1.3)  # 1,3: šum oblika grudica
        if self.izrez is not None:
            self.statistika["izrez"]["izostavljeno"]["stabla"] = int((~ostaje).sum())
        x, y, h, sk, z, xm, ym, izbor, kut = (a[ostaje] for a in (x, y, h, sk, z, xm, ym, izbor, kut))
        self.stabla = {"x_n": x, "y_n": y, "visina_m": h, "polumjer_m": 0.5 * sirine[ostaje] * h, "skupina": sk}
        ukupno_trokuta = 0
        for i, o in enumerate(oblici):
            u = izbor == i
            n = int(u.sum())
            if not n:
                continue
            # nositelj: jedan kvadrat po stablu; stranica = visina stabla -> mjerilo instance
            pol = h[u] / 2.0
            c, s_ = np.cos(kut[u]) * pol, np.sin(kut[u]) * pol
            kx = np.stack([c - s_, -c - s_, -c + s_, c + s_], axis=1) + xm[u][:, None]
            # kutovi R(kut)·(p,p), (−p,p), (−p,−p), (p,−p): obrnuto od kazaljke, normala gore, površina (2p)²
            ky = np.stack([s_ + c, -s_ + c, -s_ - c, s_ - c], axis=1) + ym[u][:, None]
            co = np.stack([kx, ky, np.repeat(z[u][:, None], 4, axis=1)], axis=-1).reshape(-1, 3)
            nos = self._mreza(f"nositelj_{o['naziv']}", co, np.arange(4 * n, dtype=np.int32), np.full(n, 4, np.int32),
                              "drvece", 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
            st = bpy.data.objects.new(f"stablo_{o['naziv']}", o["mreza"])
            self.zbirka("drvece").objects.link(st)
            st.pass_index = SLOJEVI["drvece"]
            st.parent = nos
            ukupno_trokuta += n * o["trokuta"]
            o["instanci"] = n
        po_skupini = {imena[s]: int((sk == s).sum()) for s in range(len(imena))}
        self.statistika["slojevi"]["drvece"] = {
            "instanci": int(len(x)), "po_skupini": po_skupini,
            "po_obliku": {o["naziv"]: o.get("instanci", 0) for o in oblici},
            "trokuta_po_obliku": {o["naziv"]: o["trokuta"] for o in oblici},
            "trokuta_instancirano": int(ukupno_trokuta), "sjeme": self.sjeme,
            "visine_m": {"suma": "24 ± 3,5", "drvored": "14 ± 2", "stablo": "12 ± 3", "ortofoto": "6–26 po širini krošnje"},
            "status": "PRETPOSTAVKA (proceduralno; visine i vrste nisu mjerene)"}

    # --- render -----------------------------------------------------------------
    def _ucitaj_exr(self, put):
        bpy = self.bpy
        im = bpy.data.images.load(str(put))
        w, h = im.size
        a = np.empty(w * h * 4, dtype=np.float32)
        im.pixels.foreach_get(a)
        bpy.data.images.remove(im)
        return a.reshape(h, w, 4)[::-1]

    def _materijal_podataka(self):
        bpy = self.bpy
        if "podaci" in bpy.data.materials:
            return bpy.data.materials["podaci"]
        m = bpy.data.materials.new("podaci")
        m.use_nodes = True
        n = m.node_tree
        n.nodes.clear()
        o = n.nodes.new("ShaderNodeOutputMaterial")
        e = n.nodes.new("ShaderNodeEmission")
        cd = n.nodes.new("ShaderNodeCameraData")
        oi = n.nodes.new("ShaderNodeObjectInfo")
        cb = n.nodes.new("ShaderNodeCombineColor")
        n.links.new(cd.outputs["View Z Depth"], cb.inputs[0])
        n.links.new(oi.outputs["Object Index"], cb.inputs[1])
        n.links.new(cd.outputs["View Distance"], cb.inputs[2])
        n.links.new(cb.outputs[0], e.inputs["Color"])
        n.links.new(e.outputs[0], o.inputs["Surface"])
        return m

    def boja_obzora_po_azimutu(self):
        """Boja neba neposredno iznad obzora (0,1°-1,7°) za svaki stupanj azimuta (360 x 3, linearno).
        Dvanaest malih rendera samog neba (80 x 3 px, vidni kut 40°) iz kamera s poznatom konvencijom; Sunčev
        disk se odsijeca. Rezultat se pamti dok se Sunce ne promijeni."""
        bpy = self.bpy
        kljuc = (round(self._sky.sun_elevation, 6), round(self._sky.sun_rotation, 6), self._sky.aerosol_density,
                 self._sky.ozone_density, self._bg.inputs["Strength"].default_value)
        if getattr(self, "_obzor_kljuc", None) == kljuc:
            return self._obzor_tablica
        zbroj = np.zeros((360, 3))
        tezina = np.zeros(360)
        sc = bpy.data.scenes.new("obzor")
        put = self._tmp("obzor.exr")
        try:
            sc.world = self.scene.world
            sc.render.engine = "CYCLES"
            sc.cycles.device = "CPU"
            sc.cycles.samples = 8
            sc.cycles.use_denoising = False
            sc.render.image_settings.file_format = "OPEN_EXR"
            sc.render.image_settings.color_depth = "32"
            sc.render.filepath = str(put)
            ob = None
            f = 40.0 / math.tan(math.radians(20.0))
            for az in range(0, 360, 30):
                k = KAM.Kamera(0.0, 0.0, 200.0, float(az), 0.9, f, 80, 3)
                ob = k.u_blender(sc, objekt=ob)
                bpy.ops.render.render(write_still=True, scene=sc.name)
                a = self._ucitaj_exr(put)[..., :3].astype(np.float64)
                for u in range(80):
                    z = k.zraka(u + 0.5, 1.5)
                    i = int(round(math.degrees(math.atan2(z[0], z[1])))) % 360
                    zbroj[i] += a[:, u].mean(0)
                    tezina[i] += 1.0
            podaci = ob.data
            bpy.data.objects.remove(ob)
            bpy.data.cameras.remove(podaci)
        finally:
            bpy.data.scenes.remove(sc)
            put.unlink(missing_ok=True)
        t = zbroj / np.maximum(tezina, 1e-9)[:, None]
        ima = tezina > 0
        for c in range(3):  # popuni stupnjeve bez uzorka i odsijeci Sunčev disk
            t[:, c] = np.interp(np.arange(360), np.nonzero(ima)[0], t[ima, c], period=360)
            t[:, c] = np.minimum(t[:, c], 1.6 * np.median(t[:, c]))
        jezgra = np.ones(7) / 7.0
        t = np.stack([np.convolve(np.concatenate([t[-3:, c], t[:, c], t[:3, c]]), jezgra, mode="valid") for c in range(3)], 1)
        self._obzor_kljuc, self._obzor_tablica = kljuc, t.astype(np.float32)
        return self._obzor_tablica

    def boja_magle(self):
        """Boja zračne perspektive po pikselu postavljene kamere (V x Š x 3, linearno): boja neba uz obzor u
        azimutu zrake kroz taj piksel. Zamjenjuje raniju jednu srednju boju za cijeli kadar, koja je uključivala
        i tamne retke neba ispod obzora, pa je daljina tonula u tamnu traku."""
        t = self.boja_obzora_po_azimutu()
        k = self.kamera
        d, g, nn = k.osi()
        u = (np.arange(k.sirina_px) + 0.5 - k.sirina_px / 2.0) / k.f_px
        v = (np.arange(k.visina_px) + 0.5 - k.visina_px / 2.0) / k.f_px
        zx = nn[0] + d[0] * u[None, :] - g[0] * v[:, None]
        zy = nn[1] + d[1] * u[None, :] - g[1] * v[:, None]
        az = np.degrees(np.arctan2(zx, zy)) % 360.0
        i0 = np.floor(az).astype(int) % 360
        fr = (az - np.floor(az))[..., None].astype(np.float32)
        return t[i0] * (1 - fr) + t[(i0 + 1) % 360] * fr

    def _tmp(self, ime):
        self.predmemorija.mkdir(parents=True, exist_ok=True)
        return self.predmemorija / f"_tmp_{ime}"

    def _ima_koncept(self):
        return any(o.pass_index == SLOJEVI["koncept"] for o in self.scene.objects)

    def _spremi_pogled(self, lin, put, alfa=None):
        """Linearna slika (V x Š x 3; uz `alfa` pomnožena alfom) -> PNG kroz pogled scene (AgX, ekspozicija)."""
        bpy = self.bpy
        sc = self.scene
        h, w = lin.shape[:2]
        im = bpy.data.images.new("izlaz", w, h, alpha=alfa is not None, float_buffer=True)
        im.colorspace_settings.name = "Linear Rec.709"
        a = np.ones((h, w, 1), np.float32) if alfa is None else alfa[..., None].astype(np.float32)
        im.pixels.foreach_set(np.concatenate([lin[::-1], a[::-1]], axis=2).astype(np.float32).ravel())
        sc.render.image_settings.file_format = "PNG"
        sc.render.image_settings.color_depth = "8"
        sc.render.image_settings.color_mode = "RGB" if alfa is None else "RGBA"
        im.save_render(str(put), scene=sc)
        bpy.data.images.remove(im)
        sc.render.image_settings.color_mode = "RGB"
        return put

    def _render_koncepta(self, uzorci, zaklon, exr):
        """Prolaz za fotomontažu: samo objekti sloja koncept na prozirnoj podlozi. Teren i vode su hvatači
        sjene (sjena koncepta na tlu ulazi u alfu). Postojeće zgrade, drveće i stadion:
          zaklon=True      zaklanjaju koncept (izrez u alfi, holdout) i ne bacaju sjenu u ovaj prolaz
          zaklon=False     skriveni su kameri i ne bacaju sjenu (zaklon se u montaži radi na fotografiji)
          zaklon="hvatac"  i oni su hvatači sjene: sjena koncepta pada i na njih, ali je rub zrnat ispod oko
                           200 uzoraka (instancirane krošnje)
        Sjene postojećih objekata se ne upisuju: na fotografiji već postoje."""
        bpy = self.bpy
        sc = self.scene
        stanje = []
        imena = {v: k for k, v in SLOJEVI.items()}
        zrake = ("visible_camera", "visible_shadow", "visible_diffuse", "visible_glossy", "visible_transmission")
        for ob in sc.objects:
            if ob.type != "MESH" or ob.pass_index == SLOJEVI["koncept"]:
                continue
            stanje.append((ob, ob.is_shadow_catcher, ob.is_holdout, {atr: getattr(ob, atr) for atr in zrake}))
            if zaklon == "hvatac" or imena.get(ob.pass_index) in SLOJEVI_TERENA:
                ob.is_shadow_catcher = True
            else:
                # postojeći objekt ne smije mijenjati svjetlo na hvataču: bez sjene, odbljeska i neizravnog svjetla
                for atr in zrake[1:]:
                    setattr(ob, atr, False)
                if zaklon:
                    ob.is_holdout = True
                else:
                    ob.visible_camera = False
        try:
            bpy.context.view_layer.material_override = None
            sc.cycles.samples = int(uzorci)
            sc.cycles.use_adaptive_sampling = True
            sc.cycles.pixel_filter_type = "BLACKMAN_HARRIS"
            sc.cycles.filter_width = 1.5
            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.filepath = str(exr)
            bpy.ops.render.render(write_still=True)
            a = self._ucitaj_exr(exr).copy()
        finally:
            for ob, sj, hold, vidljivost in stanje:
                ob.is_shadow_catcher = sj
                ob.is_holdout = hold
                for atr, v in vidljivost.items():
                    setattr(ob, atr, v)
            sc.render.film_transparent = False
            sc.render.image_settings.color_mode = "RGB"
            Path(exr).unlink(missing_ok=True)
        return a

    def renderiraj(self, put, uzorci=96, prolazi=("slika", "dubina", "maska"), vidljivost_km=70.0, traka=True,
                   oznaka=None, podloge=PODLOGE_KRATKO, kvaliteta_jpeg=92, dodatno=None, mjerenja=True,
                   koncept_zaklon=True, nadreza=None):
        """Render iz postavljene kamere.

        put             izlazna slika (.png ili .jpg); uz nju nastaju datoteke prolaza i <ime>.json
        prolazi         podskup ("slika", "dubina", "maska", "pokrivenost", "koncept"):
                          slika        <ime>.png|.jpg (s trakom oznake)
                          dubina       <ime>_dubina.npz (dubina_m uzduž osi, daljina_m od kamere; inf = nebo)
                          maska        <ime>_maska.png (indeks sloja po pikselu, većinski sloj)
                          pokrivenost  <ime>_pokrivenost.npz (udio 0..255 po sloju; zaglađeni rubovi) i, ako
                                       postoji sloj koncept, <ime>_koncept_pokrivenost.png
                          koncept      <ime>_koncept.png (RGBA): samo sloj koncept na prozirnoj podlozi, sa
                                       sjenom na postojećem stanju (hvatač sjene); za fotomontažu
        vidljivost_km   zračna perspektiva iz dubine: prijenos = exp(-3,912 * d / vidljivost); None isključuje
        traka           upisuje traku s oznakom i navodom podloga u donji rub slike
        mjerenja        True: datum i mjerena vremena idu u <ime>_mjerenje.json (popratni <ime>.json ih ne
                        nosi, pa se ne mijenja dok je slika ista)
        koncept_zaklon  u prolazu "koncept": True = postojeće zgrade i drveće zaklanjaju koncept (izrez u alfi);
                        False = skriveni su kameri (zaklon se u montaži radi ručno na fotografiji);
                        "hvatac" = i oni hvataju sjenu koncepta (zrnatije). Hvatač sjene je uvijek teren.
        nadreza         dubina i maska se renderiraju u n-strukoj rezoluciji (zadano postavka nadreza_podataka)
        Vraća rječnik s putanjama, mjerenim vremenima i sadržajem popratnog JSON-a.
        """
        bpy = self.bpy
        sc = self.scene
        if self.kamera is None:
            raise RuntimeError("najprije postavi_kameru")
        nepoznato = set(prolazi) - {"slika", "dubina", "maska", "pokrivenost", "koncept"}
        if nepoznato:
            raise ValueError(f"nepoznati prolazi: {sorted(nepoznato)}")
        put = Path(put)
        put.parent.mkdir(parents=True, exist_ok=True)
        osnova = put.with_suffix("")
        vrijeme = {}
        ima_koncept = self._ima_koncept()
        oznaka = oznaka or (OZNAKA_KONCEPT if ima_koncept else OZNAKA_POSTOJECE)
        sc.render.image_settings.file_format = "OPEN_EXR"
        sc.render.image_settings.color_depth = "32"
        sc.render.image_settings.color_mode = "RGB"
        sc.render.resolution_percentage = 100
        treba_podatke = bool({"dubina", "maska", "pokrivenost"} & set(prolazi)) or (vidljivost_km is not None)
        lin = None
        if "slika" in prolazi:
            t0 = time.time()
            bpy.context.view_layer.material_override = None
            sc.cycles.samples = int(uzorci)
            sc.cycles.use_adaptive_sampling = True
            sc.cycles.pixel_filter_type = "BLACKMAN_HARRIS"
            sc.cycles.filter_width = 1.5
            sc.render.film_transparent = False
            exr = self._tmp(f"{put.stem}_lin.exr")
            sc.render.filepath = str(exr)
            bpy.ops.render.render(write_still=True)
            lin = self._ucitaj_exr(exr)[..., :3].copy()
            exr.unlink(missing_ok=True)
            vrijeme["slika_s"] = round(time.time() - t0, 1)
        dubina = daljina = maska = prijenos = None
        pokr = {}
        n = max(1, int(nadreza or self.p["nadreza_podataka"]))
        if treba_podatke:
            t0 = time.time()
            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.color_mode = "RGBA"
            sc.render.resolution_percentage = 100 * n
            exr = self._tmp(f"{put.stem}_pod.exr")
            sc.render.filepath = str(exr)
            try:
                bpy.ops.render.render(write_still=True)
                d = self._ucitaj_exr(exr)
            finally:
                bpy.context.view_layer.material_override = None
                sc.render.film_transparent = False
                sc.render.image_settings.color_mode = "RGB"
                sc.render.resolution_percentage = 100
                exr.unlink(missing_ok=True)
            # n x n poduzoraka po pikselu: većinski sloj, pokrivenost po sloju, dubina većinskog sloja
            H, W = d.shape[0] // n, d.shape[1] // n
            d = d[:H * n, :W * n].reshape(H, n, W, n, 4).transpose(0, 2, 1, 3, 4).reshape(H, W, n * n, 4)
            nebo_s = d[..., 3] < 0.5
            idx_s = np.where(nebo_s, 0, np.rint(d[..., 1])).astype(np.uint8)
            vrijednosti = [0] + sorted(set(SLOJEVI.values()))
            pokr = {v: (idx_s == v).mean(axis=2).astype(np.float32) for v in vrijednosti}
            maska = np.array(vrijednosti, np.uint8)[np.stack([pokr[v] for v in vrijednosti], -1).argmax(-1)]
            isti = idx_s == maska[..., None]
            br = np.maximum(isti.sum(2), 1)
            dubina = np.where(maska == 0, np.inf, (d[..., 0] * isti).sum(2) / br).astype(np.float32)
            daljina = np.where(maska == 0, np.inf, (d[..., 2] * isti).sum(2) / br).astype(np.float32)
            if vidljivost_km is not None:
                prijenos = np.where(nebo_s, 1.0, np.exp(-3.912 * d[..., 2] / (vidljivost_km * 1000.0))).mean(2)
                prijenos = prijenos.astype(np.float32)[..., None]
            del d
            vrijeme["podaci_s"] = round(time.time() - t0, 1)
        izlaz = {"slika": None, "dubina": None, "maska": None, "pokrivenost": None, "koncept": None}
        magla = None
        boja_magle = None
        if vidljivost_km is not None and ("slika" in prolazi or "koncept" in prolazi):
            t0 = time.time()
            boja_magle = self.boja_magle()
            teren_px = maska != 0
            magla = {"model": "eksponencijalna (Koschmieder), prijenos = exp(-3,912 d / V)", "vidljivost_km": vidljivost_km,
                     "boja": "nebo uz obzor (0,1°-1,7°) u azimutu svakog piksela, tablica po stupnju azimuta",
                     "srednja_boja_linearno": ([round(float(v), 2) for v in boja_magle[teren_px].mean(0)]
                                               if teren_px.any() else None)}
            vrijeme["nebo_s"] = round(time.time() - t0, 1)
        if lin is not None:
            t0 = time.time()
            if boja_magle is not None:
                lin = lin * prijenos + boja_magle * (1.0 - prijenos)
            from PIL import Image

            png = self._spremi_pogled(lin, self._tmp(f"{put.stem}_pogled.png"))
            slika = Image.open(png).convert("RGB")
            png.unlink(missing_ok=True)
            if traka:
                slika = traka_oznake(slika, oznaka, podloge)
            if put.suffix.lower() in (".jpg", ".jpeg"):
                slika.save(put, quality=kvaliteta_jpeg, optimize=True)
            else:
                slika.save(put, optimize=True)
            izlaz["slika"] = str(put)
            vrijeme["obrada_s"] = round(time.time() - t0, 1)
        if "koncept" in prolazi and ima_koncept:
            t0 = time.time()
            k = self._render_koncepta(uzorci, koncept_zaklon, self._tmp(f"{put.stem}_kon.exr"))
            rgb, alfa = k[..., :3], np.clip(k[..., 3], 0.0, 1.0)
            if boja_magle is not None:
                rgb = rgb * prijenos + boja_magle * alfa[..., None] * (1.0 - prijenos)
            pk = Path(str(osnova) + "_koncept.png")
            self._spremi_pogled(rgb, pk, alfa=alfa)
            izlaz["koncept"] = str(pk)
            vrijeme["koncept_s"] = round(time.time() - t0, 1)
        if "dubina" in prolazi and dubina is not None:
            pd = Path(str(osnova) + "_dubina.npz")
            np.savez_compressed(pd, dubina_m=dubina, daljina_m=daljina)
            izlaz["dubina"] = str(pd)
        if "maska" in prolazi and maska is not None:
            from PIL import Image

            pm = Path(str(osnova) + "_maska.png")
            Image.fromarray(maska, "L").save(pm, optimize=True)
            izlaz["maska"] = str(pm)
        if "pokrivenost" in prolazi and pokr:
            from PIL import Image

            pp = Path(str(osnova) + "_pokrivenost.npz")
            np.savez_compressed(pp, **{("nebo" if v == 0 else next(k for k, x in SLOJEVI.items() if x == v)):
                                       np.rint(pokr[v] * 255).astype(np.uint8) for v in pokr})
            izlaz["pokrivenost"] = str(pp)
            if ima_koncept:
                Image.fromarray(np.rint(pokr[SLOJEVI["koncept"]] * 255).astype(np.uint8), "L").save(
                    Path(str(osnova) + "_koncept_pokrivenost.png"), optimize=True)
        atr = []
        for sl in self.slojevi:
            atr += ATRIBUCIJE.get(sl, [])
        atr += ATRIBUCIJE["osm"] + ATRIBUCIJE["ograda"]
        popratno = {
            "status": "AI građanski koncept; render nije dokaz statike, kapaciteta, položaja ni izvedivosti",
            "oznaka": oznaka,
            "koordinate": "ENU-M (scripts/viz/koordinate.py)",
            "kamera": self.kamera.u_rjecnik(),
            "sunce": self.sunce,
            "slojevi": list(self.slojevi),
            "maska_legenda": {"0": "nebo", **{str(v): k for k, v in SLOJEVI.items()}},
            "udio_piksela_po_sloju": (None if maska is None else
                                      {k: round(float((maska == v).mean()), 4) for k, v in {"nebo": 0, **SLOJEVI}.items()}),
            "prikaz": {"uzorci": int(uzorci), "pogled": sc.view_settings.view_transform, "izgled": sc.view_settings.look,
                       "ekspozicija": sc.view_settings.exposure, "nebo": "MULTIPLE_SCATTERING",
                       "zracna_perspektiva": magla, "denoiser": None,
                       "podaci": f"dubina i maska iz {n}x{n} poduzoraka po pikselu"},
            "postavke_scene": {k: v for k, v in self.p.items()},
            "statistika": self.statistika,
            "atribucije": list(dict.fromkeys(atr)),
            "napomena_zig": ("Ortofoto DGU-a nosi vodeni žig usluge (GEOPORTAL); nije uklanjan i vidi se na igralištu."
                             if "teren_blizu" in self.slojevi else None),
            "izlaz": {k: (Path(v).name if v else None) for k, v in izlaz.items()},
            "dubina_zapis": "npz: dubina_m (uzduž optičke osi) i daljina_m (od kamere), float32, inf = nebo",
        }
        if dodatno:
            popratno["dodatno"] = dodatno
        Path(str(osnova) + ".json").write_text(json.dumps(popratno, ensure_ascii=False, indent=1) + "\n", encoding="utf-8")
        if mjerenja:
            Path(str(osnova) + "_mjerenje.json").write_text(json.dumps(
                {"datum": time.strftime("%Y-%m-%d"), "vrijeme_rendera_s": vrijeme, "vrijeme_gradnje_s": self.vrijeme_gradnje_s},
                ensure_ascii=False, indent=1) + "\n", encoding="utf-8")
        _log(f"render {put.name}: {vrijeme}")
        return {"putanje": izlaz, "vrijeme_s": vrijeme, "popratno": popratno, "dubina": dubina, "daljina": daljina,
                "maska": maska, "pokrivenost": pokr}


# ---------------------------------------------------------------------------
# Traka s oznakom
# ---------------------------------------------------------------------------

def _font(velicina, podebljano=False):
    from PIL import ImageFont

    for p in ("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf" if podebljano else "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
              "DejaVuSans-Bold.ttf" if podebljano else "DejaVuSans.ttf"):
        try:
            return ImageFont.truetype(p, velicina)
        except OSError:
            continue
    raise RuntimeError("font DejaVu Sans nije dostupan (obvezan prema projektnim uputama)")


def traka_oznake(slika, oznaka=OZNAKA_POSTOJECE, podloge=PODLOGE_KRATKO):
    """Upisuje u donji rub slike (PIL.Image) traku s oznakom i kratkim navodom podloga. Vraća novu sliku."""
    from PIL import Image, ImageDraw

    slika = slika.convert("RGB")
    w, h = slika.size
    v1 = max(11, int(round(w * 0.0125)))
    v2 = max(9, int(round(w * 0.0085)))
    f1, f2 = _font(v1, True), _font(v2)
    rub = max(6, int(v1 * 0.6))
    crtez = ImageDraw.Draw(slika)
    # navod podloga se po potrebi lomi u dva reda
    redovi = [podloge]
    if crtez.textlength(podloge, font=f2) > w - 2 * rub:
        dijelovi = podloge.split(" · ")
        redovi, tek = [], ""
        for d in dijelovi:
            proba = (tek + " · " + d) if tek else d
            if crtez.textlength(proba, font=f2) > w - 2 * rub and tek:
                redovi.append(tek)
                tek = d
            else:
                tek = proba
        redovi.append(tek)
    visina = rub + v1 + int(v1 * 0.45) + len(redovi) * int(v2 * 1.35) + rub // 2
    pod = Image.new("RGB", (w, visina), (18, 22, 28))
    slika.paste(Image.blend(slika.crop((0, h - visina, w, h)), pod, 0.82), (0, h - visina))
    crtez = ImageDraw.Draw(slika)
    y = h - visina + rub // 2
    crtez.text((rub, y), oznaka, font=f1, fill=(255, 255, 255))
    y += v1 + int(v1 * 0.45)
    for r in redovi:
        crtez.text((rub, y), r, font=f2, fill=(205, 210, 216))
        y += int(v2 * 1.35)
    return slika


# ---------------------------------------------------------------------------
# Funkcije API-ja (isti poziv kao metode, radi čitljivosti u sljedećem koraku)
# ---------------------------------------------------------------------------

def izgradi_scenu(slojevi=SVI_SLOJEVI, sjeme=20261113, predmemorija=None, izrez=None, izrez_iznimke=(),
                  izrez_tlo=None, izrez_sustav="ENU-N", **postavke):
    """Gradi scenu postojećeg stanja.

    slojevi        podskup SVI_SLOJEVI; koncept dodaje vlastite objekte u sloj "koncept" i obično izostavlja
                   sloj "stadion"
    izrez          popis poligona (obuhvat koncepta): unutar njih se ne grade postojeće zgrade, stabla ni
                   vodene plohe; uz postavku izrez_krosnje (zadano) ni stabla čija krošnja zadire u poligon
    izrez_iznimke  OSM id-jevi zgrada ili poligoni unutar izreza u kojima postojeće ostaje (npr. bazen)
    izrez_tlo      boja (linearni RGB) kojom se u izrezu prekriva ortofoto; None ostavlja teksturu
    izrez_sustav   sustav poligona izreza i iznimaka: "ENU-N" (kao site.json i program.json; zadano) ili
                   "ENU-M" (kao scena)
    predmemorija   mapa u kojoj proces otvara vlastitu privremenu podmapu (briše se na kraju)
    postavke       vidi ZADANO
    """
    t0 = time.time()
    s = Scena(slojevi=slojevi, sjeme=sjeme, predmemorija=predmemorija, izrez=izrez, izrez_iznimke=izrez_iznimke,
              izrez_tlo=izrez_tlo, izrez_sustav=izrez_sustav, **postavke).izgradi()
    s.vrijeme_gradnje_s["ukupno"] = round(time.time() - t0, 2)
    return s


def postavi_kameru(scena, kam=None, **kw):
    return scena.postavi_kameru(kam, **kw)


def postavi_sunce(scena, kada=None, **kw):
    return scena.postavi_sunce(kada, **kw)


def renderiraj(scena, put, **kw):
    return scena.renderiraj(put, **kw)


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

POGLEDI = {
    # vlastite kamere za pregledne rendere (cilj: središte igrališta)
    "jug": dict(azimut_od_cilja_deg=178.0, udaljenost_m=760.0, kota_oka=330.0, f35_mm=24.0),
    "jugozapad": dict(azimut_od_cilja_deg=228.0, udaljenost_m=820.0, kota_oka=360.0, f35_mm=24.0),
    "sjeverozapad": dict(azimut_od_cilja_deg=300.0, udaljenost_m=420.0, kota_oka=250.0, f35_mm=24.0),
    # iz parka preko stadiona prema jugu i s jugozapada prema istoku: provjera pozadine i zračne perspektive
    "iz_parka": dict(azimut_od_cilja_deg=5.0, udaljenost_m=700.0, kota_oka=300.0, f35_mm=24.0),
    "prema_istoku": dict(azimut_od_cilja_deg=265.0, udaljenost_m=800.0, kota_oka=320.0, f35_mm=24.0),
}


def _cilj_stadion(teren):
    x, y = K.m_iz_n(-40.41, -1.01)
    return (float(x), float(y), float(teren.kota_m(x, y)) + 8.0)


def main(argv=None):
    import argparse

    ap = argparse.ArgumentParser(description="Scena postojećeg stanja: provjera mjerila, pregledni renderi, validacija kamere")
    ap.add_argument("naredba", choices=["mjerilo", "pregled", "pogled", "validacija", "daleko"])
    ap.add_argument("--izlaz", default=None, help="mapa ili datoteka izlaza")
    ap.add_argument("--pogled", default="jug", choices=sorted(POGLEDI))
    ap.add_argument("--sirina", type=int, default=1280)
    ap.add_argument("--uzorci", type=int, default=96)
    ap.add_argument("--kada", default="2026-06-21 15:00", help="lokalno vrijeme za Sunce")
    ap.add_argument("--bez", default="", help="slojevi koje treba isključiti, zarezom (npr. stadion,drvece)")
    ap.add_argument("--vidljivost-km", type=float, default=70.0)
    ap.add_argument("--predmemorija", default=None,
                    help="mapa izvan repoa: privremene datoteke procesa; za naredbu daleko i preuzeti izvori")
    ap.add_argument("--sezona", default=None, choices=["ljeto", "jesen", "zima", "datum"],
                    help="krošnje; zadano ljeto, u validaciji prema datumu snimke")
    a = ap.parse_args(argv)
    if a.naredba == "mjerilo":
        print(json.dumps(provjera_mjerila(), ensure_ascii=False, indent=1))
        return 0
    if a.naredba == "daleko":
        if not a.predmemorija:
            print("zadaj --predmemorija (mapa izvan repoa za preuzete izvore)")
            return 2
        print(json.dumps(gradi_daleko(a.predmemorija), ensure_ascii=False, indent=1))
        return 0
    slojevi = tuple(s for s in SVI_SLOJEVI if s not in set(filter(None, a.bez.split(","))))
    s = izgradi_scenu(slojevi=slojevi, predmemorija=a.predmemorija)
    if a.naredba in ("pregled", "pogled"):
        imena = ["jug", "jugozapad"] if a.naredba == "pregled" else [a.pogled]
        mapa = Path(a.izlaz) if a.izlaz else MODEL
        for ime in imena:
            k = KAM.pogled_na(_cilj_stadion(s.teren), sirina_px=a.sirina, omjer=16 / 9, naziv=f"pregled_{ime}", **POGLEDI[ime])
            s.postavi_kameru(k)
            s.postavi_sunce(a.kada, sezona=a.sezona)
            s.renderiraj(mapa / f"postojece_{ime}.jpg", uzorci=a.uzorci, vidljivost_km=a.vidljivost_km,
                         prolazi=("slika", "maska") if a.naredba == "pregled" else ("slika", "dubina", "maska"),
                         mjerenja=a.naredba != "pregled")
        return 0
    # validacija: render iz riješenih kamera (slike ostaju u predmemoriji; u repo idu samo brojevi)
    v = json.loads((MODEL / "validacija_kamere.json").read_text(encoding="utf-8"))
    mapa = Path(a.izlaz) if a.izlaz else (Path(a.predmemorija) if a.predmemorija else None)
    if mapa is None:
        print("zadaj --izlaz ili --predmemorija (mapa izvan repoa)")
        return 2
    for sn in v["snimke"]:
        k = KAM.Kamera.iz_rjecnika(sn["rijesena_kamera"]).u_mjerilu(a.sirina)
        s.postavi_kameru(k)
        s.postavi_sunce(sn.get("sunce_lokalno") or a.kada, sezona=a.sezona or "datum")
        s.renderiraj(mapa / f"validacija_{sn['naziv']}.png", uzorci=a.uzorci, vidljivost_km=a.vidljivost_km, traka=False)
    return 0


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