#!/usr/bin/env python3
"""Pogledi s visine očiju (1,6 m nad podom) na sadržaje parka i prostore ispod parka (S01 do S10).

AI građanski koncept · PRIJEDLOG · nije projekt. Render na modelu, nije fotografija ni dokaz.

Scena se gradi kao u ref.py (`koncept.izgradi`, program v1.0). Model koncepta nema unutrašnjosti zatvorenih
prostora ispod parka (samo prazninu nad prometom), pa ovaj pokretač za poglede iznutra dodaje SHEMATSKU opremu
iz programa (research/viz/sadrzaji/pogledi_sadrzaji.json, „sobe”): pod na koti iz programa, strop na kota poda +
svijetla visina, otvore stropa ispod svjetlarnika iz programa s oknom do ploče parka, zidove po obrisu prostora,
staklenu stijenu prema susjednim prostorima s popisa „staklo”, ostakljena pročelja prema susjednim prostorima s
popisa „izlozi”, svjetleći strop i trake rasvjete te siluete ljudi. Ništa od toga nije oblikovanje.

    python scripts/viz/pokretaci/sadrzaji.py --izlaz <rad> --predmemorija <pred> --sirina 960 --uzorci 32 [--samo S01,S04]
    python scripts/viz/pokretaci/sadrzaji.py --izlaz <rad> --predmemorija <pred> --sirina 1600 --uzorci 96 --objavi
"""
from __future__ import annotations

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

import numpy as np

sys.path.insert(0, str(Path(__file__).resolve().parent))
import zakrpe  # noqa: E402

KORIJEN = zakrpe.KORIJEN
import kamera as KAM  # noqa: E402
import koncept as KON  # noqa: E402
import koordinate as K  # noqa: E402
import montaza as M  # noqa: E402
import scena as SC  # noqa: E402

PROGRAM = KORIJEN / "research" / "viz" / "program.json"
CFG = KORIJEN / "research" / "viz" / "sadrzaji" / "pogledi_sadrzaji.json"
OBJAVA = KORIJEN / "dist" / "assets" / "viz" / "pogledi"
KADA = "2026-06-21 17:30"
OKO_M = 1.6
OZNAKA = "AI građanski koncept · PRIJEDLOG · nije projekt · render na modelu, nije fotografija"
DGU = ("DGU Visine INSPIRE i Digitalni ortofoto 2024. (Otvorena dozvola, https://data.gov.hr/otvorena-dozvola; "
       "izmijenjeno)")
OSM = "© OpenStreetMap contributors (ODbL)"
EOX = "EOxCloudless 2016 (Contains modified Copernicus Sentinel data 2016), CC BY 4.0"
COP = "Copernicus WorldDEM-30 (visine dalekih stabala, M32)"


def lin(c):
    return KON.lin(c)


# --- shematska oprema iznutra -------------------------------------------------------------------------------------
def z_poda(spec):
    """Funkcija kote poda (x, y) -> z iz zapisa sobe: broj ili {"os": "y", "tocke": [[y, z], ...]}."""
    if isinstance(spec, (int, float)):
        return lambda x, y: np.full(np.shape(np.atleast_1d(x)), float(spec))
    t = np.asarray(spec["tocke"], dtype=float)
    os_ = 1 if spec.get("os", "y") == "y" else 0
    return lambda x, y: np.interp(np.atleast_1d(y if os_ else x), t[:, 0], t[:, 1])


def _mesh_ravno(sp, pol, zf, boja, dolje=False):
    """Trokutasta ploha nad poligonom; z = zf(x, y) po vrhu; normala gore (ili dolje)."""
    from shapely.geometry.polygon import orient

    pol = orient(pol, 1.0)
    pr = [np.asarray(pol.exterior.coords)[:-1]] + [np.asarray(r.coords)[:-1] for r in pol.interiors]
    svi = np.concatenate(pr)
    zz = zf(svi[:, 0], svi[:, 1])
    tri = SC.Scena._trokuti(pr)
    if not tri:
        return
    # orijentacija trokuta: normala z prema zadanome
    t0 = [svi[i] for i in tri[0]]
    nz = (t0[1][0] - t0[0][0]) * (t0[2][1] - t0[0][1]) - (t0[1][1] - t0[0][1]) * (t0[2][0] - t0[0][0])
    obrni = (nz > 0) == dolje
    sp.dodaj([(x, y, z) for (x, y), z in zip(svi, zz)], [tuple(t[::-1]) if obrni else tuple(t) for t in tri], boja)


def _poligoni(g, min_m2=0.5):
    return KON._poligoni(g, min_m2)


def gradi_sobe(s, cfg, log):
    """Gradi sve sobe iz cfg["sobe"]; vraća rječnik id prostora -> (geom, zf, visina) i popis pretpostavki."""
    import shapely
    from shapely.geometry import LineString, Point
    from shapely.geometry.polygon import orient
    from shapely.ops import unary_union

    P, pv, o = s.program, s.povrsina, s.ok
    deb = float(o["debljina_pokrova_m"])
    po_id = {q["id"]: q for q in P.prostori}
    nize = [q for q in P.prostori if q["razina"] < P.i_park]
    svj = [q for q in pv.svj]
    pod, strop, zid, staklo, okvir, izlog, svjetlo, fas = (KON.Spremnik() for _ in range(8))
    B_POD, B_ZID, B_OKV = lin((196, 190, 178)), lin((226, 222, 214)), KON.C["bijelo"]
    sobe = {}
    ljudi = []
    oci = [p["oko_n"] for p in cfg["pogledi"]]
    pretp = []
    for soba in cfg["sobe"]:
        pretp += soba.get("pretpostavke") or []
        dio = {}
        for pid, sp_ in soba["prostori"].items():
            q = po_id[pid]
            dio[pid] = (q["geom"].buffer(0), z_poda(sp_["pod"]), sp_.get("visina"))
        sobe.update(dio)
        if soba.get("samo_pod"):
            for pid, (g, zf, _) in dio.items():
                for pol in _poligoni(g, 1.0):
                    _mesh_ravno(pod, pol, zf, lin((170, 168, 160)))
                    ring = np.asarray(orient(pol, 1.0).exterior.coords)
                    for a, b in zip(ring[:-1], ring[1:]):
                        z0 = float(s.tlo_n(*((a + b) / 2)))
                        zp = float(zf(*((a + b) / 2))[0])
                        pod.zid(a, b, z0 - 0.2, z0 - 0.2, zp, zp, lin((170, 168, 160)))
            continue
        U = unary_union([g for g, _, _ in dio.values()]).buffer(0.05).buffer(-0.05)
        svj_u = unary_union([q["geom"] for q in svj if q["geom"].intersects(U)]) if svj else None

        def kome(x, y, dio=dio):
            pt = Point(x, y)
            for pid, (g, zf, h) in dio.items():
                if g.buffer(0.3).contains(pt):
                    return pid, zf, h
            return None

        for pid, (g, zf, h) in dio.items():
            for pol in _poligoni(g, 1.0):
                _mesh_ravno(pod, pol, lambda x, y, zf=zf: zf(x, y) + 0.02, B_POD)
            gs = g.difference(svj_u.buffer(0.02)) if svj_u is not None else g
            for pol in _poligoni(gs, 0.5):
                _mesh_ravno(strop, pol, lambda x, y, zf=zf, h=h: zf(x, y) + h, KON.C["beton"], dolje=True)
            # trake rasvjete uzduž dulje stranice, svakih oko 4,5 m, izvan svjetlarnika
            for pol in _poligoni(g, 4.0):
                ok_ = KON._Okvir(pol)
                n = max(int(round(ok_.W / 4.5)), 1)
                for i in range(n):
                    b_ = ok_.W * (i + 0.5) / n
                    l = LineString([ok_.t(0.8, b_), ok_.t(ok_.L - 0.8, b_)]).buffer(0.16, cap_style=2)
                    l = l.intersection(pol.buffer(-0.6))
                    if svj_u is not None:
                        l = l.difference(svj_u.buffer(0.4))
                    for pl in _poligoni(l, 0.05):
                        _mesh_ravno(svjetlo, pl, lambda x, y, zf=zf, h=h: zf(x, y) + h - 0.06, (1, 1, 1), dolje=True)
            # ljudi
            gg = g.buffer(-1.2)
            if not gg.is_empty:
                rng = np.random.default_rng(zlib.crc32(pid.encode()))
                n = int(np.clip(g.area / 55.0, 3, 40))
                x0, y0, x1, y1 = gg.bounds
                px, py = rng.uniform(x0, x1, n * 20), rng.uniform(y0, y1, n * 20)
                u = np.nonzero(shapely.contains_xy(gg, px, py))[0][:n]
                for k in u:
                    if any(np.hypot(px[k] - e[0], py[k] - e[1]) < 5.0 for e in oci):
                        continue
                    ljudi.append((px[k], py[k], float(zf(px[k], py[k])[0]) + 0.02))
        # okna svjetlarnika: od stropa do donjeg ruba ploče parka
        if svj_u is not None:
            for pol in _poligoni(svj_u.intersection(U.buffer(0.5)), 0.5):
                pol = orient(pol, 1.0)
                ring = np.asarray(pol.exterior.coords)[:-1]
                zs = pv.z_vrha(ring[:, 0], ring[:, 1]) - deb
                for k in range(len(ring)):
                    k2 = (k + 1) % len(ring)
                    a, b = ring[k], ring[k2]
                    w = kome(*((a + b) / 2))
                    if w is None:
                        continue
                    _, zf, h = w
                    za, zb = float(zf(*a)[0]) + h, float(zf(*b)[0]) + h
                    strop.zid(b, a, zb, za, max(zs[k2], zb + 0.3), max(zs[k], za + 0.3), lin((236, 234, 228)))
        # zidovi po obrisu sobe; vrsta prema susjedu 0,6 m izvan obrisa
        stk, izl = set(soba.get("staklo") or []), set(soba.get("izlozi") or [])
        for pol in _poligoni(U, 1.0):
            pol = orient(pol, 1.0)
            for prsten in [pol.exterior] + list(pol.interiors):
                c = np.asarray(prsten.coords)
                for a0, b0 in zip(c[:-1], c[1:]):
                    L = float(np.hypot(*(b0 - a0)))
                    if L < 0.05:
                        continue
                    k = max(int(math.ceil(L / 2.5)), 1)
                    for j in range(k):
                        a = a0 + (b0 - a0) * j / k
                        b = a0 + (b0 - a0) * (j + 1) / k
                        m = (a + b) / 2
                        d = (b - a) / max(np.hypot(*(b - a)), 1e-9)
                        nrm = np.array([d[1], -d[0]])
                        w = kome(*(m - 0.6 * nrm))
                        if w is None:
                            continue
                        _, zf, h = w
                        za, zb = float(zf(*a)[0]), float(zf(*b)[0])
                        out = Point(*(m + 0.6 * nrm))
                        sus = [q for q in nize if q["id"] not in sobe and q["geom"].contains(out)]
                        sid = {q["id"] for q in sus}
                        if sid & stk:
                            # staklena stijena s prečkama; iznad stropa puna greda do ploče parka
                            staklo.zid(a, b, za, zb, za + h, zb + h, (1, 1, 1))
                            staklo.zid(b, a, zb, za, zb + h, za + h, (1, 1, 1))
                            okvir.kutija(a, d, nrm, 0.06, 0.08, za, za + h, B_OKV)
                            gore = max(float(np.atleast_1d(pv.z_vrha(m[0], m[1]))[0]) - deb, max(za, zb) + h + 0.2)
                            fas.zid(a, b, za + h, zb + h, gore, gore, KON.C["beton"])
                            fas.zid(b, a, zb + h, za + h, gore, gore, KON.C["beton"])
                        elif sid & izl:
                            hi = min(h - 0.6, 3.2)
                            izlog.zid(b, a, zb + 0.05, za + 0.05, zb + hi, za + hi, (1, 1, 1))
                            zid.zid(b, a, zb + hi, za + hi, zb + h, za + h, B_ZID)
                            okvir.kutija(a, d, nrm, 0.05, 0.06, za, za + hi, lin((60, 62, 66)))
                        else:
                            zid.zid(b, a, zb, za, zb + h, za + h, B_ZID)
    # objekti
    s._objekt("s_pod", pod, "park")
    s._objekt("s_strop", strop, "procelja", "podgled")
    s._objekt("s_zid", zid, "procelja")
    s._objekt("s_greda", fas, "procelja")
    s._objekt("s_staklo", staklo, "staklo", "staklo")
    s._objekt("s_okvir", okvir, "staklo")
    mi = s.materijal("s_izlog", lin((58, 54, 48)), hrapavost=0.15)
    b = mi.node_tree.nodes.get("Principled BSDF")
    b.inputs["Emission Color"].default_value = (1.0, 0.86, 0.66, 1)
    b.inputs["Emission Strength"].default_value = 1.6
    s._objekt("s_izlog", izlog, "staklo", mi)
    ms = s.materijal("s_rasvjeta", (1, 1, 1), hrapavost=0.5)
    b = ms.node_tree.nodes.get("Principled BSDF")
    b.inputs["Emission Color"].default_value = (1.0, 0.95, 0.86, 1)
    b.inputs["Emission Strength"].default_value = 30.0
    s._objekt("s_rasvjeta", svjetlo, "procelja", ms)
    if ljudi:
        L_ = np.asarray(ljudi)
        rng = np.random.default_rng(20261115)
        xm, ym = SC.m_iz_n(L_[:, 0], L_[:, 1])
        vis = np.clip(rng.normal(o["covjek_m"], 0.07, len(L_)), 1.15, 1.95)
        vis[rng.random(len(L_)) < 0.08] *= 0.72
        kut = rng.uniform(0, 2 * math.pi, len(L_))
        izb = rng.integers(0, 3, len(L_))
        for i in range(3):
            u = izb == i
            if u.any():
                s._instanciraj(f"s_covjek_{i}", s._mreza_covjeka(i), xm[u], ym[u], L_[u, 2], vis[u], kut[u], "zivot")
    # okna svjetlarnika iz koncept.py (dno na podu prostora ispod) presijecala bi sobe: uklanjaju se
    ob = s.bpy.data.objects.get("svjetlarnici_unutra")
    if ob is not None:
        s.bpy.data.objects.remove(ob, do_unlink=True)
    # beton oko praznine nad prometom: ukloniti plohe uz staklene stijene
    rez = []
    for soba in cfg["sobe"]:
        for pid in soba.get("staklo") or []:
            q = po_id.get(pid)
            if q is None:
                continue
            for sid in soba["prostori"]:
                g = po_id[sid]["geom"]
                ln = g.boundary.intersection(q["geom"].buffer(0.8))
                if not ln.is_empty:
                    zf, h = sobe[sid][1], sobe[sid][2] or 5.0
                    c = np.asarray(g.exterior.coords)
                    zz = zf(c[:, 0], c[:, 1])
                    rez.append((ln.buffer(1.2), float(zz.min()) - 0.5, float(zz.max()) + h + 0.3))
    if rez:
        imena = ("zidovi", "zidovi_zeleni", "zidovi_pod_pokrovom", "podgled_grede", "procelja_staklo", "ograde",
                 "elementi", "elementi_staklo_tamno")
        for geom, z0, z1 in rez:
            ukloni_plohe(s, imena, geom, z0, z1)
    for g, zf, _ in sobe.values():
        c = np.asarray(g.exterior.coords)
        spusti_teren(s, g.buffer(2.5), float(np.min(zf(c[:, 0], c[:, 1]))) - 0.05)
    log("sobe:", len(sobe), "prostora, ljudi", len(ljudi))
    return sobe, pretp


def ukloni_plohe(s, imena, geom_n, z0=-1e9, z1=1e9):
    """Briše plohe objekata čije je središte (ENU-N) unutar geom_n i između kota z0 i z1."""
    import bmesh
    import shapely

    for ime in imena:
        ob = s.bpy.data.objects.get(ime)
        if ob is None:
            continue
        me = ob.data
        n = len(me.polygons)
        if not n:
            continue
        c = np.empty(n * 3, dtype=np.float64)
        me.polygons.foreach_get("center", c)
        c = c.reshape(-1, 3)
        mw = np.asarray(ob.matrix_world)
        c = c @ mw[:3, :3].T + mw[:3, 3]
        xn, yn = K.n_iz_m(c[:, 0], c[:, 1])
        shapely.prepare(geom_n)
        u = shapely.contains_xy(geom_n, np.asarray(xn, float), np.asarray(yn, float)) & (c[:, 2] > z0) & (c[:, 2] < z1)
        if not u.any():
            continue
        bm = bmesh.new()
        bm.from_mesh(me)
        bm.faces.ensure_lookup_table()
        bmesh.ops.delete(bm, geom=[bm.faces[i] for i in np.nonzero(u)[0]], context="FACES")
        bm.to_mesh(me)
        bm.free()
        ob.data.update()


def spusti_teren(s, geom_n, z_najvise):
    """Spušta mrežu bliskog terena pod sobom ispod njezina najnižeg poda (samo prikaz: teren ne probija pod)."""
    import shapely

    ob = s.bpy.data.objects.get("teren_blizu")
    if ob is None:
        return
    me = ob.data
    co = np.empty(len(me.vertices) * 3, dtype=np.float32)
    me.vertices.foreach_get("co", co)
    co = co.reshape(-1, 3)
    xn, yn = K.n_iz_m(co[:, 0].astype(float), co[:, 1].astype(float))
    shapely.prepare(geom_n)
    u = shapely.contains_xy(geom_n, np.asarray(xn, float), np.asarray(yn, float))
    co[u, 2] = np.minimum(co[u, 2], z_najvise)
    me.vertices.foreach_set("co", co.ravel())
    me.update()


def tramvaj(s, prostor_id, x_n, y_n):
    """Tramvaj 32 m (zadano u koncept.py) na kolosijeku iz site.json najbližem točki, unutar prostora."""
    from shapely.geometry import LineString, Point

    o = s.ok
    D, S_, V_ = o["tramvaj_m"]
    pr = [LineString(p["linija"]) for p in (s.site.get("tramvaj") or {}).get("pruge") or [] if len(p.get("linija") or []) >= 2]
    g = next(q["geom"] for q in s.program.prostori if q["id"] == prostor_id)
    pt = Point(x_n, y_n)
    kand = [l for l in pr if l.intersects(g)]
    if not kand:
        return None
    l = min(kand, key=lambda l: l.distance(pt))
    s0 = l.project(pt)
    sp = KON.Spremnik(metricki=True)
    modula, zglob = 5, 0.25
    lm = (D - (modula - 1) * zglob) / modula
    for k in range(modula):
        s_ = s0 + (k - (modula - 1) / 2) * (lm + zglob)
        a, b, m = l.interpolate(s_ - lm / 2), l.interpolate(s_ + lm / 2), l.interpolate(s_)
        z0 = float(s.tlo_n(m.x, m.y)) + 0.2
        s._vozilo(sp, (m.x, m.y), (b.x - a.x, b.y - a.y), lm, S_, V_, KON.C["tramvaj"], KON.C["tramvaj"],
                  lin((200, 204, 210)), z0)
    s._objekt(f"s_tramvaj_{prostor_id}", sp, "zivot")
    return round(l.distance(pt), 1)


# --- glavni tok -----------------------------------------------------------------------------------------------------
def podloge(maska):
    """Navod podloga prema slojevima koji su stvarno u kadru (indeksi iz scena.SLOJEVI)."""
    sl = SC.SLOJEVI
    udio = {k: float((maska == v).mean()) for k, v in sl.items()} if maska is not None else {}
    dijelovi = ["Podloge: research/viz/program.json v1.0 (AI sinteza, PRIJEDLOG)"]
    if any(udio.get(k, 0) > 0.0005 for k in ("teren_blizu", "teren_regija", "vode")) or udio.get("koncept", 0) > 0:
        dijelovi.append("reljef i ortofoto: " + DGU)
    if udio.get("zgrade", 0) > 0.0005 or udio.get("koncept", 0) > 0:
        dijelovi.append(OSM)
    if udio.get("teren_daleko", 0) > 0.0005:
        dijelovi.append(EOX)
    if udio.get("drvece", 0) > 0.0005:
        dijelovi.append(COP)
    return " · ".join(dijelovi), {k: round(v, 4) for k, v in udio.items() if v > 0}


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--izlaz", required=True)
    ap.add_argument("--predmemorija", default=None)
    ap.add_argument("--sirina", type=int, default=960)
    ap.add_argument("--uzorci", type=int, default=32)
    ap.add_argument("--samo", default=None)
    ap.add_argument("--objavi", action="store_true", help="piše S<nn>_vizija.jpg i S<nn>.json u dist/assets/viz/pogledi/")
    a = ap.parse_args()
    out = Path(a.izlaz)
    rad = out / "rad"
    rad.mkdir(parents=True, exist_ok=True)
    cfg = json.loads(CFG.read_text(encoding="utf-8"))
    sirovo = PROGRAM.read_bytes()
    pmeta = {"datoteka": "research/viz/program.json", "verzija": json.loads(sirovo)["meta"]["verzija"],
             "sha256": hashlib.sha256(sirovo).hexdigest()}
    pogledi = [p for p in cfg["pogledi"] if not a.samo or p["id"] in a.samo.split(",")]
    # vanjski pogledi prije gradnje soba (sobe uklanjaju okna svjetlarnika koja se vide odozgo)
    pogledi.sort(key=lambda p: p["vrsta"] != "vani")
    log = lambda *x: print("[sadrzaji]", *x, flush=True)  # noqa: E731
    t0 = time.time()
    s = KON.izgradi(str(PROGRAM), predmemorija=Path(a.predmemorija or rad / "tmp"))
    sun = s.postavi_sunce(KADA, sezona="ljeto")
    log("gradnja", round(time.time() - t0, 1), "s")
    sobe, pretp_sobe = None, []
    for p in pogledi:
        pid = p["id"]
        if p["vrsta"] == "unutra" and sobe is None:
            sobe, pretp_sobe = gradi_sobe(s, cfg, log)
        tram = None
        if p.get("tramvaj_u"):
            tram = tramvaj(s, *p["tramvaj_u"])
        xn, yn = p["oko_n"]
        if p["pod"] is not None:
            zpod, izvor_pod = float(p["pod"]), "kota poda iz programa"
        elif p["vrsta"] == "unutra":
            for soba in cfg["sobe"]:
                for sid, sp_ in soba["prostori"].items():
                    if sid in p["prostori"]:
                        zpod = float(z_poda(sp_["pod"])(xn, yn)[0])
                        izvor_pod = f"kota poda prostora {sid} iz programa (kosi pod, interpolirano)"
                        break
                else:
                    continue
                break
        else:
            zpod = float(s.povrsina.kota(xn, yn)[0])
            izvor_pod = "izmjerena ploha parka modela u točki oka"
        xm, ym = K.m_iz_n(xn, yn)
        k = KAM.iz_polozaja(x=xm, y=ym, kota_oka=zpod + OKO_M, azimut_deg=p["azimut"], nagib_deg=p["nagib"],
                            f35_mm=p["f35"], sirina_px=a.sirina, omjer=16 / 9, naziv=pid,
                            izvor="research/viz/sadrzaji/pogledi_sadrzaji.json")
        try:
            s.postavi_kameru(k)
        except RuntimeError as e:
            log(pid, "kamera odbijena:", e)
            continue
        t1 = time.time()
        s.renderiraj(rad / f"{pid}.png", uzorci=a.uzorci, prolazi=("slika", "maska"), vidljivost_km=40.0, traka=False)
        rp = json.loads((rad / f"{pid}.json").read_text(encoding="utf-8"))
        from PIL import Image

        maska = np.asarray(Image.open(rad / f"{pid}_maska.png"))
        pod_txt, udio = podloge(maska)
        slika = M.ucitaj_sliku(rad / f"{pid}.png")
        navod = [f"{pid} · {p['naziv']}. Kamera 1,6 m nad podom (kota {zpod:.1f} m n. v.). "
                 + ("Unutrašnjost je shematska (pod, strop, zidovi, staklo, rasvjeta iz programa), " if p["vrsta"] == "unutra"
                    else "Drveće, ljudi i spomen-mjesta su proceduralni i neispisani, ")
                 + f"ne prikazuje izgled izvedbe. Program v{pmeta['verzija']}, sha256 {pmeta['sha256'][:12]}."]
        t = M.traka(slika, navod, podloge=pod_txt, oznaka=OZNAKA)
        ime = f"{pid}_vizija.jpg"
        jpg = M.spremi(t, out / ime, kvaliteta=90)
        assert not M.ima_exif(jpg)
        ogr = ["Render modela koncepta, nije fotografija ni dokaz izgleda, visine, vidljivosti ni izvedivosti.",
               "Drveće, ljudi i vozila su proceduralni i niskopoligonalni; pročelja shematska; kamera nije provjerena fotografijom."]
        if p["vrsta"] == "unutra":
            ogr += ["Model koncepta nema unutrašnjosti zatvorenih prostora; pod, strop, zidovi, staklene stijene, ostakljena "
                    "pročelja susjednih prostora, okna svjetlarnika, rasvjeta i ljudi dodani su u pokretaču shematski iz "
                    "poligona, kota i svijetlih visina programa (scripts/viz/pokretaci/sadrzaji.py).",
                    "Stupovi nisu prikazani: program za ove prostore ne zadaje raster stupova.",
                    "Strop svijetli jednoliko (materijal podgleda iz koncept.py) uz trake rasvjete; jakost je izbor izgleda, "
                    "nije izračun rasvjete. Dnevno svjetlo kroz svjetlarnike nije izračun osvjetljenosti.",
                    "Pod ispod soba spušten je teren modela (samo prikaz, ništa se ne ukopava)."]
        else:
            ogr += ["Spomen-mjesta i ploče su neispisani volumeni: umjetnička djela biraju se javnim natječajem, imena se ne prikazuju."]
        pop = {"id": pid, "naziv": p["naziv"], "vrsta": "render na modelu, nije fotografija", "oznaka": OZNAKA,
               "status": "AI građanski koncept · PRIJEDLOG · nije projekt", "slika": ime,
               "prostori": p["prostori"], "sto_pokazuje": p["sto_pokazuje"],
               "kamera": {**k.u_rjecnik(), "enu_n": [xn, yn], "kota_poda": round(zpod, 2), "izvor_kote_poda": izvor_pod,
                          "visina_oka_m": OKO_M, "status": "PRETPOSTAVKA: zadana kamera modela, nije fotografija"},
               "sunce": {**(rp.get("sunce") or {}), "lokalno": KADA},
               "program": pmeta, "podloge": pod_txt, "udio_slojeva_u_kadru": udio,
               "atribucije_modela": rp.get("atribucije"), "podslojevi": rp.get("podslojevi_koncepta"),
               "render": {"sirina": a.sirina, "uzorci": a.uzorci, "vidljivost_km": 40.0},
               "tramvaj_dodan_m_od_tocke": tram,
               "pretpostavke": (pretp_sobe if p["vrsta"] == "unutra" else []) + [f"kota oka = {izvor_pod} + 1,6 m"],
               "ogranicenja": ogr, "za_objavu": False,
               "ponovljivost": f"python scripts/viz/pokretaci/sadrzaji.py --izlaz <rad> --predmemorija <pred> "
                               f"--sirina {a.sirina} --uzorci {a.uzorci} --samo {pid}"
                               + (" --objavi" if a.objavi else "")}
        (out / f"{pid}.json").write_text(json.dumps(pop, ensure_ascii=False, indent=1, default=str) + "\n", encoding="utf-8")
        if a.objavi:
            OBJAVA.mkdir(parents=True, exist_ok=True)
            (OBJAVA / ime).write_bytes(jpg.read_bytes() if hasattr(jpg, "read_bytes") else Path(jpg).read_bytes())
            (OBJAVA / f"{pid}.json").write_text(json.dumps(pop, ensure_ascii=False, indent=1, default=str) + "\n", encoding="utf-8")
        log(pid, round(time.time() - t1, 1), "s")


if __name__ == "__main__":
    main()
