#!/usr/bin/env python3
"""Vlastiti pokretač za rendere iz daljine i visine (P09, P10, P11, P12, P15).

AI građanski koncept · PRIJEDLOG · nije projekt. Render nije dokaz.
Gradi scenu koncepta jednom (scripts/viz/koncept.py), za svaku snimku postavlja kameru, Sunce (21.6. 17:30),
renderira sliku, dubinu i masku, mjeri doglednicu u modelu i piše sliku s trakom ispod (montaza.traka),
bez EXIF-a. Ne mijenja ostale skripte u scripts/viz/.

    python scripts/viz/pokretaci/daljina.py --snimke P15a,P12t --sirina 960 --uzorci 48 --izlaz <mapa> --predmemorija <mapa>
"""
from __future__ import annotations

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

import numpy as np

KORIJEN = Path(__file__).resolve().parents[3]
sys.path.insert(0, str(KORIJEN / "scripts" / "viz"))
import kamera as KAM  # noqa: E402
import koordinate as K  # noqa: E402
import montaza as M  # noqa: E402

PROGRAM = KORIJEN / "research" / "viz" / "program.json"
SUNCE = ("2026-06-21 17:30", "ljeto")
V_KM = 50.0  # vidljivost za zračnu perspektivu (PRETPOSTAVKA: ljetna izmaglica kasnog poslijepodneva)

# stadion iz programa (ENU-N): središte i kote
STAD_N = (-60.29, -36.91)
Z_PODIJ, Z_KROV = 128.5, 166.5

# lat, lon iz research/viz/pogledi.json
P09 = (45.82208, 16.02761)
P10 = (45.85272, 15.98805)
P11 = (45.88742, 15.93302)
P12 = (45.8993, 15.94738)

# Snimke: vrsta "stajaliste" (lat, lon, visina iznad tla; smjer zadan ili prema cilju) ili "pogled_na"
SNIMKE = {
    "P15a": dict(pogled="P15", vrsta="pogled_na", cilj_n=(-110.0, -170.0), cilj_z=125.0, az_od_cilja=222.0,
                 udaljenost=1000.0, iznad_tla=350.0, f35=35.0, opis="s jugozapada, oko 350 m iznad tla"),
    "P15b": dict(pogled="P15", vrsta="pogled_na", cilj_n=(-90.0, -170.0), cilj_z=125.0, az_od_cilja=140.0,
                 udaljenost=1000.0, iznad_tla=350.0, f35=35.0, opis="s jugoistoka, oko 350 m iznad tla"),
    "P12w": dict(pogled="P12", vrsta="stajaliste", latlon=P12, iznad_tla=60.0, azimut=148.5, nagib=-5.0, f35=35.0),
    "P12t": dict(pogled="P12", vrsta="stajaliste", latlon=P12, iznad_tla=60.0, cilj=True, cilj_z=140.0, f35=300.0),
    "P11w": dict(pogled="P11", vrsta="stajaliste", latlon=P11, iznad_tla=1.7, azimut=139.1, nagib=-4.0, f35=28.0),
    "P11t": dict(pogled="P11", vrsta="stajaliste", latlon=P11, iznad_tla=1.7, cilj=True, cilj_z=140.0, f35=300.0),
    "P10w": dict(pogled="P10", vrsta="stajaliste", latlon=P10, iznad_tla=1.7, azimut=148.4, nagib=-1.5, f35=35.0),
    "P10t": dict(pogled="P10", vrsta="stajaliste", latlon=P10, iznad_tla=1.7, cilj=True, cilj_z=140.0, f35=200.0),
    "P09a": dict(pogled="P09", vrsta="stajaliste", latlon=P09, iznad_tla=1.7, azimut=244.0, nagib=1.0, f35=50.0),
    "P09b": dict(pogled="P09", vrsta="stajaliste", latlon=P09, iznad_tla=1.7, cilj=True, cilj_z=150.0, f35=85.0),
}


def log(*a):
    print("[daljina]", time.strftime("%H:%M:%S"), *a, flush=True)


def sha256(put):
    return hashlib.sha256(Path(put).read_bytes()).hexdigest()


def tlo_scene(s, xm, ym):
    """Kota tla kako je u sceni (uz spuštanje zbog zakrivljenosti Zemlje)."""
    import scena as SC

    return float(s.teren.kota_m(xm, ym)) - float(SC.pad_zakrivljenosti(np.asarray(xm), np.asarray(ym)))


def napravi_kameru(s, sp, sirina, omjer=16 / 9):
    sp = dict(SNIMKE[sp] if isinstance(sp, str) else sp)
    if sp["vrsta"] == "pogled_na":
        cx, cy = K.m_iz_n(*sp["cilj_n"])
        tl = tlo_scene(s, cx, cy)
        a = math.radians(sp["az_od_cilja"])
        ex, ey = cx + sp["udaljenost"] * math.sin(a), cy + sp["udaljenost"] * math.cos(a)
        kota = tlo_scene(s, ex, ey) + sp["iznad_tla"]
        k = KAM.pogled_na((float(cx), float(cy), sp["cilj_z"]), azimut_od_cilja_deg=sp["az_od_cilja"],
                          udaljenost_m=sp["udaljenost"], kota_oka=kota, f35_mm=sp["f35"], sirina_px=sirina,
                          omjer=omjer, naziv=sp.get("ime", "kamera"))
        k.zakret_deg = sp.get("zakret", 0.0)
        return k, {"tlo_ispod_oka_mnv": round(kota - sp["iznad_tla"], 2), "iznad_tla_m": sp["iznad_tla"]}
    lat, lon = sp["latlon"]
    xm, ym = (float(v) for v in K.m_iz_lonlat(lon, lat))
    tl = tlo_scene(s, xm, ym)
    z = tl + sp["iznad_tla"]
    if sp.get("cilj"):
        tx, ty = K.m_iz_n(*sp.get("cilj_n", STAD_N))
        az = math.degrees(math.atan2(tx - xm, ty - ym)) % 360.0
        d = math.hypot(tx - xm, ty - ym)
        import scena as SC
        tz = sp["cilj_z"] - float(SC.pad_zakrivljenosti(np.asarray(tx), np.asarray(ty)))
        nag = math.degrees(math.atan2(tz - z, d)) + sp.get("nagib_pomak", 0.0)
        az += sp.get("azimut_pomak", 0.0)
    else:
        az, nag = sp["azimut"], sp["nagib"]
    k = KAM.iz_polozaja(x=xm, y=ym, kota_oka=z, azimut_deg=az, nagib_deg=nag, f35_mm=sp["f35"], sirina_px=sirina,
                        omjer=omjer, naziv=sp.get("ime", "kamera"), izvor="pogledi.json / daljina.py")
    return k, {"tlo_ispod_oka_mnv_u_modelu": round(tl, 2), "iznad_tla_m": sp["iznad_tla"],
               "tlo_dgu_bez_zakrivljenosti": round(float(s.teren.kota_m(xm, ym)), 2)}


REGIJA_TEKSTURA = KORIJEN / "research" / "viz" / "teren" / "ortofoto_regija.jpg"
REGIJA_OKVIR = (15.9, 45.78, 16.08, 45.92)  # lon_min, lat_min, lon_max, lat_max (ortofoto_regija.json)
KAMERE_SUME = {"P12": P12, "P11": P11}
R_PRSTEN = 6500.0  # m od ishodišta: doseg proceduralnih stabala i kuća u gradu
KAMERE_DSM = {"P11": (P11, 600.0), "P10": (P10, 1500.0)}  # stajališta s tla: stabla strogo prema DSM − DMR


def _maska_zelenila(lon, lat):
    """Je li piksel satelitskog mozaika (Sentinel-2 2016, 10 m) zelenilo: ExG > 0,10 i svjetlina < 62/255.
    Ista podloga i licenca kao tekstura terena; pravilo boje je PRETPOSTAVKA (krošnje, ali i tamne livade)."""
    from PIL import Image

    if not hasattr(_maska_zelenila, "im"):
        _maska_zelenila.im = np.asarray(Image.open(REGIJA_TEKSTURA)).astype(np.float32)
    im = _maska_zelenila.im
    H, W, _ = im.shape
    c = np.clip(((lon - REGIJA_OKVIR[0]) / (REGIJA_OKVIR[2] - REGIJA_OKVIR[0]) * W).astype(int), 0, W - 1)
    r = np.clip(((REGIJA_OKVIR[3] - lat) / (REGIJA_OKVIR[3] - REGIJA_OKVIR[1]) * H).astype(int), 0, H - 1)
    v = im[r, c]
    exg = (2 * v[:, 1] - v[:, 0] - v[:, 2]) / (v.sum(1) + 1e-3)
    unutra = ((lon > REGIJA_OKVIR[0]) & (lon < REGIJA_OKVIR[2]) & (lat > REGIJA_OKVIR[1]) & (lat < REGIJA_OKVIR[3]))
    return unutra & (exg > 0.10) & (v.mean(1) < 62.0), v.mean(1)


def _krosnje_dsm(lon, lat):
    """Visina površine iznad golog tla (GLO-30 DSM − DGU DMR, 1"), bilinearno."""
    from PIL import Image
    from scipy.ndimage import map_coordinates

    if not hasattr(_krosnje_dsm, "r"):
        t = KORIJEN / "research" / "viz" / "teren"
        S = np.asarray(Image.open(t / "dem_regija_glo30.png")).astype(np.float32) / 10
        T = np.asarray(Image.open(t / "dmr_regija_dgu20.png")).astype(np.float32) / 10
        _krosnje_dsm.r = np.where((S > 0) & (T > 0), S - T, 0.0)
    red = (45.92 - lat) * 3600.0
    stup = (lon - 15.9) * 3600.0
    return map_coordinates(_krosnje_dsm.r, [red, stup], order=1, mode="nearest")


def _mat_slucajno(s, ime, stupnjevi, hrapavost):
    """Principled materijal čija boja ovisi o slučajnom broju instance (Object Info > Random)."""
    bpy = s.bpy
    m = bpy.data.materials.new(ime)
    m.use_nodes = True
    nt = m.node_tree
    b = nt.nodes["Principled BSDF"]
    b.inputs["Roughness"].default_value = hrapavost
    oi = nt.nodes.new("ShaderNodeObjectInfo")
    cr = nt.nodes.new("ShaderNodeValToRGB")
    el = cr.color_ramp.elements
    while len(el) > 1:
        el.remove(el[-1])
    el[0].position, el[0].color = stupnjevi[0][0], (*stupnjevi[0][1], 1.0)
    for pos, boja in stupnjevi[1:]:
        e = el.new(pos)
        e.color = (*boja, 1.0)
    nt.links.new(oi.outputs["Random"], cr.inputs["Fac"])
    nt.links.new(cr.outputs["Color"], b.inputs["Base Color"])
    return m


def dodaj_kuce(s, sjeme=20261116):
    """Proceduralne niske kuće izvan okvira zgrada scene (OSM, oko ±1,1 km), do 6,5 km od stadiona (R_PRSTEN), na pikselima
    izgrađenog satelitskog mozaika (nije zelenilo, ExG < 0,06, svjetlina 50-175, R > B + 4). Mreža 22 m, 60 %
    popunjenosti, tlocrt oko 11-15 x 9-12 m, visina zida 6-8 m s četverostrešnim krovom. PRETPOSTAVKA: pozadina
    za poglede izdaleka, ne prikaz stvarnih zgrada."""
    import bmesh
    import scena as SC

    bpy = s.bpy
    rng = np.random.default_rng(sjeme)
    site = json.loads((KORIJEN / "research" / "viz" / "site.json").read_text(encoding="utf-8"))["meta"]["okvir_enu"]
    g = np.arange(-R_PRSTEN, R_PRSTEN, 22.0)
    gx, gy = np.meshgrid(g, g)
    gx = gx.ravel() + rng.uniform(-8, 8, gx.size)
    gy = gy.ravel() + rng.uniform(-8, 8, gy.size)
    xn, yn = K.n_iz_m(gx, gy)
    izvan = ~((xn > site["x"][0] - 15) & (xn < site["x"][1] + 15) & (yn > site["y"][0] - 15) & (yn < site["y"][1] + 15))
    u = izvan & (np.hypot(gx, gy) < R_PRSTEN) & (rng.uniform(0, 1, gx.size) < 0.6)
    for lat_, lon_ in (P09, P10, P11, P12):  # ne uz samo stajalište (oko 80 m)
        ox, oy = (float(v) for v in K.m_iz_lonlat(lon_, lat_))
        u &= np.hypot(gx - ox, gy - oy) > 80.0
    gx, gy = gx[u], gy[u]
    lon, lat = K.lonlat_iz_m(gx, gy)
    lon, lat = np.asarray(lon), np.asarray(lat)
    zel, svj = _maska_zelenila(lon, lat)
    im = _maska_zelenila.im
    H, W, _ = im.shape
    c = np.clip(((lon - REGIJA_OKVIR[0]) / (REGIJA_OKVIR[2] - REGIJA_OKVIR[0]) * W).astype(int), 0, W - 1)
    r = np.clip(((REGIJA_OKVIR[3] - lat) / (REGIJA_OKVIR[3] - REGIJA_OKVIR[1]) * H).astype(int), 0, H - 1)
    v = im[r, c]
    exg = (2 * v[:, 1] - v[:, 0] - v[:, 2]) / (v.sum(1) + 1e-3)
    izgr = (~zel) & (exg < 0.06) & (svj > 50) & (svj < 175) & (v[:, 0] > v[:, 2] + 4)
    gx, gy = gx[izgr], gy[izgr]
    n = len(gx)
    # jedinična kuća: tlocrt 1 x 0,8, zid do 0,52, sljeme 0,78 (mjerilo = veličina 11-15 m)
    bm = bmesh.new()
    a, b, zw, zr = 0.5, 0.4, 0.52, 0.78
    dno = [bm.verts.new(p) for p in ((-a, -b, 0), (a, -b, 0), (a, b, 0), (-a, b, 0))]
    vrh = [bm.verts.new(p) for p in ((-a, -b, zw), (a, -b, zw), (a, b, zw), (-a, b, zw))]
    s1, s2 = bm.verts.new((-a + b, 0, zr)), bm.verts.new((a - b, 0, zr))
    for i in range(4):
        f = bm.faces.new((dno[i], dno[(i + 1) % 4], vrh[(i + 1) % 4], vrh[i]))
        f.material_index = 0
    for f in (bm.faces.new((vrh[0], vrh[1], s2, s1)), bm.faces.new((vrh[2], vrh[3], s1, s2)),
              bm.faces.new((vrh[1], vrh[2], s2)), bm.faces.new((vrh[3], vrh[0], s1))):
        f.material_index = 1
    me = bpy.data.meshes.new("kuca_daljina")
    bm.to_mesh(me)
    bm.free()
    me.materials.append(_mat_slucajno(s, "zid_kuce_daljina", [(0.0, (0.26, 0.245, 0.22)), (0.6, (0.42, 0.40, 0.36)),
                                                               (1.0, (0.50, 0.47, 0.41))], 0.9))
    me.materials.append(_mat_slucajno(s, "krov_kuce_daljina", [(0.0, (0.13, 0.065, 0.045)), (0.55, (0.24, 0.11, 0.07)),
                                                                (0.8, (0.20, 0.14, 0.11)), (1.0, (0.16, 0.16, 0.16))], 0.8))
    vel = rng.uniform(11.0, 15.0, n)
    kut = rng.uniform(0, 2 * math.pi, n)
    z = s.teren.kota_m(gx, gy) - SC.pad_zakrivljenosti(gx, gy) - 0.3
    pol = vel / 2.0
    cc, ss = np.cos(kut) * pol, np.sin(kut) * pol
    kx = np.stack([cc - ss, -cc - ss, -cc + ss, cc + ss], axis=1) + gx[:, None]
    ky = np.stack([ss + cc, -ss + cc, -ss - cc, ss - cc], axis=1) + gy[:, None]
    co = np.stack([kx, ky, np.repeat(z[:, None], 4, axis=1)], axis=-1).reshape(-1, 3)
    nos = s._mreza("nositelj_kuca_daljina", co, np.arange(4 * n, dtype=np.int32), np.full(n, 4, np.int32),
                   "zgrade", 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
    ob = bpy.data.objects.new("kuca_daljina", me)
    s.zbirka("zgrade").objects.link(ob)
    ob.pass_index = SC.SLOJEVI["zgrade"]
    ob.parent = nos
    stat = {"instanci": int(n), "pravilo": f"izvan okvira OSM zgrada scene, do {R_PRSTEN / 1000:.1f} km; piksel Sentinel-2 2016 izgrađen "
            "(nije zelenilo, ExG < 0,06, svjetlina 50-175, R > B + 4); mreža 22 m, 60 %",
            "velicina_m": "11-15 (zid 6-8 m)", "status": "PRETPOSTAVKA (proceduralna pozadina, nisu stvarne zgrade)"}
    log(f"dodane kuće izvan okvira zgrada: {stat}")
    return stat


def dodaj_sumu(s, sjeme=20261115):
    """Proceduralna stabla izvan ±1500 m (gdje scena nema stabala), samo na pikselima zelenila satelitskog
    mozaika: (a) Medvednica u klinu pogleda s Grafičara i Sljemena do 7 km, (b) prsten grada od 1,5 do 6,5 km oko
    stadiona. Oblici i materijal krošnji iz scene. PRETPOSTAVKA: položaj, vrsta i visina stabala nisu mjereni."""
    import scena as SC

    bpy = s.bpy
    rng = np.random.default_rng(sjeme)
    tocke = []
    # (a) Medvednica: klin azimuta 100-190° od svake kamere, do 7 km; razmak 7 m do 1 km, dalje 10 m
    for ime, (lat, lon) in KAMERE_SUME.items():
        cx, cy = (float(v) for v in K.m_iz_lonlat(lon, lat))
        for r0, r1, korak in ((0, 1000, 7.0), (1000, 7000, 10.0)):
            g = np.arange(-r1, r1, korak)
            gx, gy = np.meshgrid(cx + g, cy + g)
            gx, gy = gx.ravel(), gy.ravel()
            d = np.hypot(gx - cx, gy - cy)
            az = np.degrees(np.arctan2(gx - cx, gy - cy)) % 360
            u = (d >= max(r0, 35.0)) & (d < r1) & (az > 100) & (az < 190)
            tocke.append(np.stack([gx[u], gy[u], np.full(u.sum(), korak), np.full(u.sum(), 1.0)], 1))
    # (b) prsten grada: 1,5-6,5 km od ishodišta, razmak 9 m
    g = np.arange(-R_PRSTEN, R_PRSTEN, 9.0)
    gx, gy = np.meshgrid(g, g)
    gx, gy = gx.ravel(), gy.ravel()
    xn, yn = K.n_iz_m(gx, gy)
    u = (np.maximum(np.abs(xn), np.abs(yn)) > 1520) & (np.hypot(gx, gy) < R_PRSTEN)
    tocke.append(np.stack([gx[u], gy[u], np.full(u.sum(), 9.0), np.zeros(u.sum())], 1))
    t = np.concatenate(tocke)
    t[:, 0] += rng.uniform(-0.4, 0.4, len(t)) * t[:, 2]
    t[:, 1] += rng.uniform(-0.4, 0.4, len(t)) * t[:, 2]
    # bez dvostrukih točaka (klinovi se preklapaju): mreža 6 m
    kljuc = np.round(t[:, :2] / 6.0).astype(np.int64)
    _, jed = np.unique(kljuc[:, 0] * 10_000_000 + kljuc[:, 1], return_index=True)
    t = t[np.sort(jed)]
    lon, lat = K.lonlat_iz_m(t[:, 0], t[:, 1])
    zel, svj = _maska_zelenila(np.asarray(lon), np.asarray(lat))
    xn, yn = K.n_iz_m(t[:, 0], t[:, 1])
    zel &= np.maximum(np.abs(xn), np.abs(yn)) > 1520  # unutar ±1500 m stabla daje scena
    t = t[zel]
    # visina stabla iz modela površine (GLO-30 DSM − DGU DMR, 1") gdje postoji: stablo samo gdje je razlika
    # veća od 4 m; tako modelna stabla ne zatvaraju doglednice koje izračun vidljivosti
    # (research/viz/teren/vidljivost.json, isti modeli) nalazi slobodnima. Izvan okvira DSM-a: 22 ± 4 m na
    # Medvednici, 14 ± 4 m u gradu (PRETPOSTAVKA).
    lo, la = K.lonlat_iz_m(t[:, 0], t[:, 1])
    lo, la = np.asarray(lo), np.asarray(la)
    u_dsm = (lo > 15.9) & (lo < 16.08) & (la > 45.78) & (la < 45.92)
    vis_dsm = np.where(u_dsm, _krosnje_dsm(lo, la), np.nan)
    # na Medvednici dalje od 600 m od stajališta s tla (P11) šuma ostaje i gdje je DSM nizak (šum modela na
    # strminama); visina tada 20 ± 3 m
    planina = t[:, 3] > 0.5
    blizu = np.zeros(len(t), bool)
    for (lat_, lon_), r_ in KAMERE_DSM.values():
        ox, oy = (float(v) for v in K.m_iz_lonlat(lon_, lat_))
        blizu |= np.hypot(t[:, 0] - ox, t[:, 1] - oy) < r_
    gora = np.zeros(len(t), bool)  # stvarna šuma Medvednice: do 4,5 km od Sljemena ili Grafičara
    for lat_, lon_ in KAMERE_SUME.values():
        ox, oy = (float(v) for v in K.m_iz_lonlat(lon_, lat_))
        gora |= np.hypot(t[:, 0] - ox, t[:, 1] - oy) < 4500.0
    # strogo (samo uz DSM > 4 m) samo blizu stajališta s tla; drugdje boja mozaika odlučuje, a DSM samo visinu
    strogo = u_dsm & blizu
    zadrzi = ~strogo | (vis_dsm > 4.0)
    t, vis_dsm, u_dsm, planina, strogo = t[zadrzi], vis_dsm[zadrzi], u_dsm[zadrzi], planina[zadrzi], strogo[zadrzi]
    n = len(t)
    h = np.where(planina, rng.normal(20.0, 3.0, n), rng.normal(14.0, 4.0, n))
    iz_dsm = u_dsm & (strogo | (vis_dsm > 8.0))
    h = np.where(iz_dsm, vis_dsm + rng.normal(0, 1.5, n), h).clip(6.0, 32.0)
    u_dsm = iz_dsm
    z = s.teren.kota_m(t[:, 0], t[:, 1]) - SC.pad_zakrivljenosti(t[:, 0], t[:, 1]) - 0.6
    oblici = ["hrast", "lipa", "grab", "siroko", "jablan", "cetinjaca"]
    p_pl = [0.20, 0.10, 0.30, 0.18, 0.0, 0.22]   # bukva/grab/hrast i jela (PRETPOSTAVKA)
    p_gr = [0.25, 0.25, 0.20, 0.15, 0.08, 0.07]
    izbor = np.where(planina, rng.choice(6, n, p=p_pl), rng.choice(6, n, p=p_gr))
    kut = rng.uniform(0, 2 * math.pi, n)
    ukupno = 0
    for i, ime in enumerate(oblici):
        u = izbor == i
        m = int(u.sum())
        me = bpy.data.meshes.get(f"stablo_{ime}")
        if not m or me is None:
            continue
        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) + t[u, 0][:, None]
        ky = np.stack([s_ + c, -s_ + c, -s_ - c, s_ - c], axis=1) + t[u, 1][:, None]
        co = np.stack([kx, ky, np.repeat(z[u][:, None], 4, axis=1)], axis=-1).reshape(-1, 3)
        nos = s._mreza(f"nositelj_daljina_{ime}", co, np.arange(4 * m, dtype=np.int32), np.full(m, 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_daljina_{ime}", me)
        s.zbirka("drvece").objects.link(st)
        st.pass_index = SC.SLOJEVI["drvece"]
        st.parent = nos
        ukupno += m
    stat = {"instanci": int(ukupno), "medvednica": int(planina.sum()), "grad": int((~planina).sum()),
            "pravilo": "piksel Sentinel-2 2016 (EOxCloudless, 10 m): ExG > 0,10 i svjetlina < 62/255",
            "visine_m": "GLO-30 DSM − DGU DMR (> 4 m) ± 1,5 m, 6-32 m; izvan okvira DSM-a 22 ± 4 (Medvednica) i 14 ± 4 (grad)",
            "s_visinom_iz_dsm": int(u_dsm.sum()),
            "status": "PRETPOSTAVKA (proceduralno, izvan ±1500 m oko stadiona; položaji iz boje satelitskog mozaika)"}
    log(f"dodana stabla izvan ±1500 m: {stat}")
    return stat


def doglednice(s, k):
    """Zrake iz oka prema točkama novog stadiona (vrh krova, vijenac, podij na rubu) u modelu.
    Vraća popis {tocka, slobodno, prepreka_m_od_oka}."""
    import scena as SC

    bpy = s.bpy
    bpy.context.view_layer.update()
    dg = bpy.context.evaluated_depsgraph_get()
    oko = np.array([k.x, k.y, k.z])
    cx, cy = (float(v) for v in K.m_iz_n(*STAD_N))
    pad = float(SC.pad_zakrivljenosti(np.asarray(cx), np.asarray(cy)))
    v = np.array([cx, cy]) - oko[:2]
    v = v / np.linalg.norm(v)
    # točke na strani prema promatraču: vrh krova (vanjski vijenac), polovica visine pročelja, podij 8 m ispred pročelja
    tocke = {"krov_vrh": (cx - v[0] * 95, cy - v[1] * 95, Z_KROV - pad),
             "krov_sredina": (cx, cy, Z_KROV - pad),
             "procelje_sredina": (cx - v[0] * 110, cy - v[1] * 110, 148.0 - pad),
             "podij_rub": (cx - v[0] * 130, cy - v[1] * 130, Z_PODIJ + 0.5 - pad)}
    out = []
    for naziv, t in tocke.items():
        t = np.array(t)
        d = t - oko
        L = float(np.linalg.norm(d))
        smjer = d / L
        ok, loc, nrm, ind, ob, *_ = s.scene.ray_cast(dg, tuple(oko), tuple(smjer), distance=L)
        if ok:
            dist = math.dist(loc, oko)
            slobodno = dist > L - 25.0
            out.append({"tocka": naziv, "udaljenost_m": round(L), "pogodak_m_od_oka": round(dist, 1),
                        "objekt": getattr(ob, "name", None), "slobodno": bool(slobodno)})
        else:
            out.append({"tocka": naziv, "udaljenost_m": round(L), "pogodak_m_od_oka": None, "objekt": None,
                        "slobodno": True})
    return out


def mjere_maske(osnova):
    from PIL import Image

    p = Path(str(osnova) + "_podslojevi.png")
    if not p.exists():
        return None
    a = np.asarray(Image.open(p))
    out = {}
    for ime, val in (("park", 10), ("stadion", 11), ("procelja", 12), ("staklo", 13), ("zivot", 14), ("drvece_koncepta", 15),
                     ("zgrade", 4), ("drvece_scene", 5), ("nebo", 0)):
        m = a == val
        n = int(m.sum())
        rec = {"pikseli": n, "udio": round(n / a.size, 4)}
        if n and ime in ("stadion", "park"):
            ys, xs = np.nonzero(m)
            rec["okvir_px"] = [int(xs.min()), int(ys.min()), int(xs.max()), int(ys.max())]
        out[ime] = rec
    kon = (a >= 10).sum()
    out["koncept_ukupno"] = {"pikseli": int(kon), "udio": round(float(kon) / a.size, 4)}
    return out


def izradi(ids, sirina, uzorci, izlaz, predmemorija, v_km=V_KM, opcije=None, suma=True):
    import koncept as KON
    import scena as SC

    izlaz = Path(izlaz)
    izlaz.mkdir(parents=True, exist_ok=True)
    t0 = time.time()
    s = KON.izgradi(str(PROGRAM), predmemorija=predmemorija, **(opcije or {}))
    log(f"scena s konceptom: {time.time() - t0:.1f} s")
    suma = {"stabla": dodaj_sumu(s), "kuce": dodaj_kuce(s)} if suma else None
    sun = s.postavi_sunce(SUNCE[0], sezona=SUNCE[1])
    rez = {}
    for i in ids:
        sp = SNIMKE[i]
        k, info = napravi_kameru(s, sp, sirina, sp.get("omjer", 16 / 9))
        k.naziv = i
        try:
            s.postavi_kameru(k)
        except RuntimeError as e:
            log(f"{i}: kamera odbijena: {e}")
            rez[i] = {"pogreska": str(e)}
            continue
        dog = doglednice(s, k)
        put = izlaz / f"{i}_sirovo.png"
        t1 = time.time()
        r = s.renderiraj(put, uzorci=uzorci, prolazi=("slika", "dubina", "maska"), vidljivost_km=sp.get("v_km", v_km), traka=False,
                         mjerenja=True)
        mj = mjere_maske(put.with_suffix(""))
        rez[i] = {"kamera": k.u_rjecnik(), "kamera_info": info, "doglednice": dog, "maska": mj,
                  "vrijeme_s": round(time.time() - t1, 1), "sunce": sun, "vidljivost_km": sp.get("v_km", v_km), "suma_izvan": suma}
        (izlaz / f"{i}_info.json").write_text(json.dumps(rez[i], ensure_ascii=False, indent=1, default=str), "utf-8")
        log(f"{i}: {rez[i]['vrijeme_s']} s; stadion {mj and mj['stadion']}; doglednice "
            f"{[(d['tocka'], d['slobodno'], d['pogodak_m_od_oka']) for d in dog]}")
    return rez


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--snimke", required=True)
    ap.add_argument("--sirina", type=int, default=960)
    ap.add_argument("--uzorci", type=int, default=48)
    ap.add_argument("--izlaz", required=True)
    ap.add_argument("--predmemorija", required=True, help="mapa izvan repoa za preuzete podloge i međurezultate")
    ap.add_argument("--vidljivost-km", type=float, default=V_KM)
    ap.add_argument("--bez-sume", action="store_true")
    ap.add_argument("--spec", default=None, help="JSON datoteka s izmjenama SNIMKE")
    a = ap.parse_args()
    if a.spec:
        for k_, v_ in json.loads(Path(a.spec).read_text()).items():
            SNIMKE[k_] = {**SNIMKE.get(k_, {}), **v_}
            for kk in ("latlon", "cilj_n"):
                if kk in SNIMKE[k_]:
                    SNIMKE[k_][kk] = tuple(SNIMKE[k_][kk])
    Path(a.predmemorija).mkdir(parents=True, exist_ok=True)
    izradi(a.snimke.split(","), a.sirina, a.uzorci, a.izlaz, a.predmemorija, a.vidljivost_km, suma=not a.bez_sume)


if __name__ == "__main__":
    main()
