#!/usr/bin/env python3
"""Fotomontaža koncepta na stvarnu fotografiju (kampanja "prikazi i tlocrti").

Status: AI građanski koncept · PRIJEDLOG · nije projekt. Montaža nije dokaz položaja, visine,
statike ni izvedivosti: geometrija dolazi iz modela (scripts/viz/scena.py, koncept.py), a
zakloni, sjena i boja su obrada slike s približnim pravilima. Opis: research/viz/model/MONTAZA.md.

Modul ne treba Blender. Radi nad datotekama koje daje scena.renderiraj (ista kamera kao fotografija):
    <osnova>_koncept.png       RGBA koncept na prozirnoj podlozi, sjena na terenu (hvatač sjene)
    <osnova>_pokrivenost.npz   udio sloja po pikselu (ključ "koncept" = tijelo koncepta bez sjene)
    <osnova>_dubina.npz        daljina_m od kamere (inf = nebo)
    <osnova>_maska.png         indeks sloja (0 nebo, 1-7 postojeće, 10 koncept)
    <osnova>.png               render cijele scene (za usklađenje boje i ispunu iz modela; neobvezno)
    <osnova>_postojece_maska.png  maska scene POSTOJEĆEG stanja iz iste kamere (neobvezno; za uklanjanje)

Primjer:
    import montaza as M
    p = M.ucitaj_prolaze("predmemorija/P01/p01")
    slika, info = M.uklopi("foto.jpg", p["koncept"], p["pokrivenost"], p["dubina"], maska=p["maska"],
                           slika_modela=p["slika"], postojece_maska=p["postojece_maska"], sirina=1600)
    M.spremi(M.traka(slika, M.navod_fotografije({"izvor": "grad", "godina": 2020}), podloge=M.PODLOGE_MODELA),
             "izlaz/P01_vizija.jpg")

CLI:  python scripts/viz/montaza.py uklopi | maske | zamuti | bez-exif   (vidi --help)
"""
from __future__ import annotations

import json
import math
import sys
from pathlib import Path

import numpy as np

OZNAKA = "AI građanski koncept · PRIJEDLOG · nije projekt"
OZNAKA_DANAS = "DANAS · fotografija bez montaže · usporedba uz AI građanski koncept · PRIJEDLOG · nije projekt"
OZNAKA_VIZIJA = "VIZIJA: " + OZNAKA
NAVOD_GRAD = ("Fotografija: Grad Zagreb, natječajna dokumentacija; montaža: AI građanski koncept, "
              "nije projekt ni stav Grada")
PODLOGE_MODELA = ("Geometrija modela: DGU Visine INSPIRE (Otvorena dozvola, izmijenjeno) · "
                  "© OpenStreetMap contributors (ODbL)")
PODLOGE_MODELA_ISPUNA = ("Geometrija i ispuna iz modela: DGU Visine INSPIRE i DOF 2024. (Otvorena dozvola, "
                         "izmijenjeno) · © OpenStreetMap contributors (ODbL)")

# indeksi slojeva u maski (scena.SLOJEVI); ovdje ponovljeni da modul ne uvozi Blender
NEBO, TEREN_BLIZU, TEREN_REGIJA, VODE, ZGRADE, DRVECE, STADION, TEREN_DALEKO, KONCEPT = 0, 1, 2, 3, 4, 5, 6, 7, 10
TLO = (TEREN_BLIZU, TEREN_REGIJA, VODE, TEREN_DALEKO)

ZADANO = {
    "sirina": 1600,              # širina izlaza (px); visina prema omjeru fotografije
    "meki_rub_px": 0.8,          # dodatno zaglađivanje ruba alfe (sigma, px izlaza)
    "sjena_jakost": 0.85,        # množitelj alfe hvatača sjene
    "sjena_ton": (0.96, 0.99, 1.06),  # boja sjene (osvjetljenje nebom); normira se na srednju vrijednost 1
    "vidljivost_km": None,       # izmaglica po dubini s bojom obzora iz fotografije; None = bez
    "uskladi": True,             # crna/bijela točka, toplina i zasićenje prema referentnim područjima
    "uskladi_jakost": 1.0,       # 0 = bez, 1 = puno usklađenje
    "zrno": True,                # zrno prema šumu fotografije u ravnim područjima
    "zamucenje": "auto",         # sigma zamućenja koncepta (px) ili "auto" prema oštrini fotografije
    "nebo_prag": None,           # prag svjetline neba (0..1); None = prilagodljivo
    "prednji_plan": {            # zakloni iz fotografije (pogled s tla: uključiti; iz zraka: obično isključiti)
        "vegetacija": False,     # zelene i tamne krošnje, debla, živice
        "tanko": False,          # tanke tamne strukture na nebu (grane, stupovi, žice)
        "tanko_px": 9,           # najveća debljina tanke strukture (px izlaza)
        "tamno_percentil": 30,   # "tamno" = ispod ovog percentila svjetline slike (i teksturirano)
        "samo_iznad_neba": False,  # "tanko" i "vegetacija" samo gdje je iza fotografije nebo
        "presjek_zeleno": True,  # uz koncept_bez_zaklona: zelena teksturirana ploha je zaklon (vrba, četinjače);
                                 # isključiti gdje se iza krošnje modela na snimci vidi travnjak (P01)
        "presjek_tamno": True,   # uz koncept_bez_zaklona: tamna teksturirana ploha (gusta krošnja) je zaklon
    },
    "poligoni_zaklon": [],       # [[x, y], ...] u pikselima fotografije: uvijek ispred koncepta
    "poligoni_ukloni": [],       # dijelovi postojećeg stanja koje treba ukloniti i ispuniti (nisu zaklon)
    "poligoni_podrucje": [],     # ako zadano, zaklon iz fotografije vrijedi samo unutar ovih poligona
    "poligoni_pozadina": [],     # postojeće što koncept zamjenjuje: ovdje "tamno" i "tanko" nisu zaklon (zeleno jest)
    "poligoni_voda": [],         # vodena ploha na fotografiji za odraz (inače vode iz maske modela)
    "poligoni_bez_izvora": [],   # dijelovi fotografije koji se ne smiju klonirati u ispunu (prepoznatljive građevine)
    "poligoni_presjek": [],      # uz koncept_bez_zaklona: ako zadano, zaklon iz fotografije samo unutar poligona
    "poligoni_krosnje": [],      # stvarne gole krošnje ispred koncepta kojih model nema (ili su u modelu niže):
                                 # unutar poligona tamne grane s fotografije zaklanjaju koncept (samo "grane", bez
                                 # zelenog i tamnog, jer je iza grana na snimci često travnjak ili teren)
    "poligoni_bez_zaklona": [],  # koncept je unutar poligona potpuno vidljiv (nijedan zaklon iz modela ni fotografije):
                                 # npr. tamno vozilo na mjestu proceduralne krošnje ispred zida
    "poligoni_tlo": [],          # tlo programa koje model ne crta (prirodno tlo, perivoj): stari sadržaj snimke
                                 # (teren, ograda) zamjenjuje se travnjakom, grane s fotografije ostaju ispred
    "tlo_boja": (0.30, 0.31, 0.22),  # sRGB osunčanog travnjaka za poligoni_tlo (PRETPOSTAVKA, prigušena trava)
    "tlo_lokalno_px": 0,         # > 0: svjetlina travnjaka prema lokalnom prosjeku (sigma u px izlaza 2400) umjesto
                                 # 80. percentila poligona; za plohu različitih materijala (crvena staza uz travu,
                                 # P03-zamjena), gdje bi tamna podloga dala tamnu mrlju; velike sjene se gube
    "crna_tocka": "auto",        # meka donja granica tona koncepta (sRGB); "auto" = 2. percentil svjetline fotografije
                                 # na području usklađenja (otvor krova bez nje pada na 0 i čita se kao rupa)
    "odraz": None,              # {"jakost": 0.5, "zatamni": 0.8}: zrcalni odraz koncepta u vodi oko linije obale
    "sjena_zamucenje_px": 0.0,   # meka sjena (oblačno); uz sjena_jakost oko 0,2
    "ukloni_slojeve": [STADION, ZGRADE],  # slojevi postojećeg modela koji nestaju gdje ih koncept ne pokriva
    "ukloni_prosiri_px": 3,
    "ispuna_iz_modela": True,    # na tlu: niske frekvencije iz okoline + detalj iz rendera modela
    "zaklon_modela": True,       # False kad je prolaz koncepta renderiran bez zaklona postojećih zgrada i drveća
                                 # (koncept_zaklon=False): tada tijelo dolazi iz alfe, ne iz maske pokrivenosti
    "zamuti": [],                # pravokutnici [x0, y0, x1, y1] u pikselima fotografije (osobe, pločice)
}


# ---------------------------------------------------------------------------
# Učitavanje, spremanje, boja
# ---------------------------------------------------------------------------

def _img():
    from PIL import Image

    return Image


def u_linearno(s):
    s = np.clip(s, 0.0, 1.0)
    return np.where(s <= 0.04045, s / 12.92, ((s + 0.055) / 1.055) ** 2.4).astype(np.float32)


def u_srgb(l):
    l = np.clip(l, 0.0, 1.0)
    return np.where(l <= 0.0031308, l * 12.92, 1.055 * np.power(l, 1 / 2.4) - 0.055).astype(np.float32)


def svjetlina(rgb):
    return (0.2126 * rgb[..., 0] + 0.7152 * rgb[..., 1] + 0.0722 * rgb[..., 2]).astype(np.float32)


def ucitaj_sliku(put):
    """Fotografija -> (V x Š x 3) float32 sRGB 0..1; okret prema EXIF orijentaciji. EXIF se ne prenosi dalje."""
    from PIL import ImageOps

    im = ImageOps.exif_transpose(_img().open(put)).convert("RGB")
    return np.asarray(im, dtype=np.float32) / 255.0


def promijeni_velicinu(a, sirina, visina, nacin="lanczos"):
    """Polje (V x Š [x K]) na novu veličinu; nacin "lanczos", "bilinear" ili "najblize"."""
    Image = _img()
    a = np.asarray(a)
    if a.shape[1] == sirina and a.shape[0] == visina:
        return a.astype(np.float32) if a.dtype != np.uint8 or nacin != "najblize" else a
    if nacin == "najblize":
        r = (np.arange(visina) + 0.5) * a.shape[0] / visina
        c = (np.arange(sirina) + 0.5) * a.shape[1] / sirina
        return a[np.clip(r.astype(int), 0, a.shape[0] - 1)][:, np.clip(c.astype(int), 0, a.shape[1] - 1)]
    res = {"lanczos": Image.LANCZOS, "bilinear": Image.BILINEAR}[nacin]
    if a.ndim == 2:
        return np.asarray(Image.fromarray(a.astype(np.float32), "F").resize((sirina, visina), res), dtype=np.float32)
    kanali = [np.asarray(Image.fromarray(a[..., i].astype(np.float32), "F").resize((sirina, visina), res),
                         dtype=np.float32) for i in range(a.shape[2])]
    return np.stack(kanali, -1)


def spremi(slika, put, kvaliteta=90):
    """Sprema sliku bez EXIF-a, XMP-a i ICC profila (nova slika iz piksela). slika: PIL ili polje 0..1."""
    Image = _img()
    put = Path(put)
    put.parent.mkdir(parents=True, exist_ok=True)
    if not isinstance(slika, np.ndarray):
        slika = np.asarray(slika.convert("RGB"), dtype=np.float32) / 255.0
    a = np.clip(np.rint(np.asarray(slika, dtype=np.float32) * 255.0), 0, 255).astype(np.uint8)
    cista = Image.fromarray(a[..., :3], "RGB")
    if put.suffix.lower() in (".jpg", ".jpeg"):
        cista.save(put, quality=kvaliteta, optimize=True, progressive=True, subsampling=0)
    else:
        cista.save(put, optimize=True)
    return put


def bez_exif(ulaz, izlaz, kvaliteta=92):
    """Prepisuje sliku bez metapodataka (EXIF, GPS, XMP, ICC). Vraća broj uklonjenih EXIF polja."""
    im = _img().open(ulaz)
    n = len(im.getexif())
    spremi(ucitaj_sliku(ulaz), izlaz, kvaliteta)
    return n


def ima_exif(put):
    im = _img().open(put)
    return bool(len(im.getexif())) or any(k in im.info for k in ("exif", "xmp", "icc_profile", "XML:com.adobe.xmp"))


def ucitaj_prolaze(osnova):
    """Datoteke prolaza iz scena.renderiraj za zadanu osnovu imena (bez nastavka). Što ne postoji je None."""
    Image = _img()
    o = str(osnova)
    out = {"koncept": None, "pokrivenost": None, "dubina": None, "maska": None, "slika": None,
           "postojece_maska": None, "podslojevi": None}
    if Path(o + "_koncept.png").exists():
        out["koncept"] = np.asarray(Image.open(o + "_koncept.png").convert("RGBA"), dtype=np.float32) / 255.0
    if Path(o + "_pokrivenost.npz").exists():
        z = np.load(o + "_pokrivenost.npz")
        out["pokrivenost"] = {k: z[k].astype(np.float32) / 255.0 for k in z.files}
    if Path(o + "_dubina.npz").exists():
        z = np.load(o + "_dubina.npz")
        out["dubina"] = z["daljina_m"].astype(np.float32)
    for kljuc, ime in (("maska", "_maska.png"), ("postojece_maska", "_postojece_maska.png"),
                       ("podslojevi", "_podslojevi.png")):
        if Path(o + ime).exists():
            out[kljuc] = np.asarray(Image.open(o + ime), dtype=np.uint8)
    for nast in (".png", ".jpg"):
        if Path(o + nast).exists():
            out["slika"] = np.asarray(Image.open(o + nast).convert("RGB"), dtype=np.float32) / 255.0
            break
    return out


# ---------------------------------------------------------------------------
# Morfologija i poligoni
# ---------------------------------------------------------------------------

def _nd():
    from scipy import ndimage

    return ndimage


def _disk(r):
    r = max(1, int(round(r)))
    y, x = np.mgrid[-r:r + 1, -r:r + 1]
    return (x * x + y * y) <= r * r + 0.5


def prosiri(m, r):
    if r < 1:
        return m
    if r > 8:
        # veliki polumjer: udaljenostna transformacija (binary_dilation s diskom 2r+1 troši previše memorije pri 2400 px)
        m = np.asarray(m, bool)
        return _nd().distance_transform_edt(~m) <= r + 0.5 if m.any() else m.copy()
    return _nd().binary_dilation(m, _disk(r))


def zatvori(m, r):
    """Morfološko zatvaranje (popunjava rupe i procjepe do polumjera r)."""
    return suzi(prosiri(m, r), r) | np.asarray(m, bool)


def suzi(m, r):
    if r < 1:
        return m
    if r > 8:
        m = np.asarray(m, bool)
        return _nd().distance_transform_edt(m) > r + 0.5 if m.any() else m.copy()
    return _nd().binary_erosion(m, _disk(r))


def zagladi(m, sigma):
    m = m.astype(np.float32)
    return _nd().gaussian_filter(m, sigma) if sigma and sigma > 0 else m


def maska_poligona(poligoni, sirina, visina, mjerilo=1.0):
    """Popis poligona [[x, y], ...] (pikseli fotografije, pomnoženi s `mjerilo`) -> bool maska."""
    Image = _img()
    from PIL import ImageDraw

    im = Image.new("L", (sirina, visina), 0)
    d = ImageDraw.Draw(im)
    for p in poligoni or []:
        if len(p) >= 3:
            d.polygon([(float(x) * mjerilo, float(y) * mjerilo) for x, y in p], fill=255)
    return np.asarray(im) > 127


def push_pull(slika, poznato, razina_min=2):
    """Ispuna nepoznatih piksela iz okoline (piramida težinskih srednjih vrijednosti, bez vanjskih alata).
    slika V x Š x K, poznato V x Š bool. Vraća sliku u kojoj su nepoznati pikseli glatko ispunjeni."""
    w = poznato.astype(np.float32)
    a = slika.astype(np.float32) * w[..., None]
    piramida = []
    while min(w.shape) > razina_min:
        piramida.append((a, w))
        H, W = w.shape
        h2, w2 = (H + 1) // 2, (W + 1) // 2
        ap = np.zeros((h2 * 2, w2 * 2, a.shape[2]), np.float32)
        wp = np.zeros((h2 * 2, w2 * 2), np.float32)
        ap[:H, :W], wp[:H, :W] = a, w
        a = ap.reshape(h2, 2, w2, 2, -1).sum((1, 3))
        w = wp.reshape(h2, 2, w2, 2).sum((1, 3))
        nz = w > 0
        a[nz] /= w[nz][:, None]
        w = np.minimum(w, 1.0)
        a *= w[..., None]
    # na najgrubljoj razini: srednja vrijednost poznatih
    tot = w.sum()
    sred = (a.reshape(-1, a.shape[2]).sum(0) / tot) if tot > 0 else np.zeros(a.shape[2], np.float32)
    boja = np.where(w[..., None] > 0, a / np.maximum(w[..., None], 1e-6), sred)
    for a_f, w_f in reversed(piramida):
        H, W = w_f.shape
        gore = promijeni_velicinu(boja, W, H, "bilinear")
        poz = np.where(w_f[..., None] > 0, a_f / np.maximum(w_f[..., None], 1e-6), gore)
        boja = poz * np.minimum(w_f, 1.0)[..., None] + gore * (1.0 - np.minimum(w_f, 1.0))[..., None]
    return boja


def ispuna_klonom(slika, rupa, izvor_smije, rub=4):
    """Ispuna rupe kopijom susjednog dijela iste fotografije (pomak lijevo, desno, gore ili dolje za širinu
    rupe), uz popravak spoja: razlika na rubu rupe razlije se push-pull ispunom, pa nema skoka svjetline.
    izvor_smije  bool maska piksela koji se smiju kopirati (npr. tlo bez koncepta i bez uklanjanja).
    Vraća (slika, broj ispunjenih dijelova, broj dijelova ispunjenih samo glatko)."""
    nd = _nd()
    H, W = rupa.shape
    out = slika.copy()
    lab, n = nd.label(rupa)
    klon = glatko = 0
    for i, sl in enumerate(nd.find_objects(lab)):
        y0, y1 = max(0, sl[0].start - rub), min(H, sl[0].stop + rub)
        x0, x1 = max(0, sl[1].start - rub), min(W, sl[1].stop + rub)
        komp = lab[y0:y1, x0:x1] == i + 1
        h, w = komp.shape
        prsten = ~rupa[y0:y1, x0:x1] & izvor_smije[y0:y1, x0:x1]
        najbolje = None
        pomaci = [(sx * (w + 2) * k, 0) for k in (1, 2, 3) for sx in (-1, 1)]
        pomaci += [(0, -(h + 2)), (-(w + 2), -(h + 2)), (w + 2, -(h + 2)), (0, h + 2), (-(w // 2 + 2), 0),
                   (w // 2 + 2, 0)]
        for dx, dy in pomaci:
            ys, xs = y0 + dy, x0 + dx
            if ys < 0 or xs < 0 or ys + h > H or xs + w > W:
                continue
            if izvor_smije[ys:ys + h, xs:xs + w][komp].mean() < 0.9:
                continue
            izv = slika[ys:ys + h, xs:xs + w]
            if prsten.sum() < 4:
                ocj = 0.0
            else:
                ocj = float(np.abs(slika[y0:y1, x0:x1][prsten] - izv[prsten]).mean())
            if najbolje is None or ocj < najbolje[0]:
                najbolje = (ocj, izv)
        if najbolje is None:
            glatko += 1
            continue
        izv = najbolje[1]
        razlika = np.zeros_like(izv)
        razlika[prsten] = slika[y0:y1, x0:x1][prsten] - izv[prsten]
        popravak = push_pull(razlika, prsten) if prsten.any() else razlika
        blok = out[y0:y1, x0:x1]
        blok[komp] = np.clip(izv + popravak, 0, 1)[komp]
        klon += 1
    return out, klon, glatko


# ---------------------------------------------------------------------------
# Maske iz fotografije
# ---------------------------------------------------------------------------

def _hsv(rgb):
    mx = rgb.max(-1)
    mn = rgb.min(-1)
    s = np.where(mx > 1e-6, (mx - mn) / np.maximum(mx, 1e-6), 0.0)
    return mx, s


def maska_neba(foto, prior=None, prag=None, zagladi_px=1.0):
    """Nebo na fotografiji (sRGB 0..1): svijetlo, glatko, plavkasto ili neutralno, povezano s gornjim rubom.
    prior  bool maska u kojoj nebo smije biti (npr. nebo i koncept u maski modela, proširene); None = svugdje.
    Vraća (meka maska 0..1, tvrda bool maska, podaci)."""
    nd = _nd()
    H, W = foto.shape[:2]
    v, s = _hsv(foto)
    y = svjetlina(foto)
    b_r = foto[..., 2] - foto[..., 0]
    gx = nd.sobel(y, 1)
    gy = nd.sobel(y, 0)
    grad = nd.uniform_filter(np.hypot(gx, gy), 5)
    gornji = y[: max(4, H // 12)]
    if prag is None:
        # prilagodljivo: svjetlina neba iz gornjeg dijela slike
        prag = float(np.clip(np.percentile(gornji, 20) * 0.72, 0.30, 0.85))
    kand = (y > prag) & (grad < 0.09) & ((b_r > -0.02) | (s < 0.12))
    # plavo nebo može biti tamnije od praga uz obzor ili u kutovima
    kand |= (b_r > 0.12) & (s > 0.15) & (grad < 0.06) & (y > prag * 0.6)
    if prior is not None:
        kand &= prior
    kand = nd.binary_opening(kand, _disk(1))
    lab, n = nd.label(kand)
    if n:
        vrh = np.unique(lab[: max(2, H // 50)])
        vrh = vrh[vrh > 0]
        # i komadi neba u rupama krošnji: dovoljno veliki i slični boji gornjeg neba
        velicine = nd.sum(np.ones_like(y), lab, index=np.arange(1, n + 1))
        sred_y = nd.mean(y, lab, index=np.arange(1, n + 1))
        ref = float(np.median(gornji))
        dodatni = [i + 1 for i in range(n) if velicine[i] >= 40 and abs(sred_y[i] - ref) < 0.10]
        zad = np.isin(lab, np.union1d(vrh, dodatni))
    else:
        zad = kand
    zad = nd.binary_closing(zad, _disk(1)) & (kand | zad)
    meka = zagladi(zad, zagladi_px)
    return meka, zad, {"prag_svjetline": round(prag, 3), "udio": round(float(zad.mean()), 4)}


def maska_vegetacije(foto, nebo, bez_tamnog=None, tamno_percentil=30):
    """Krošnje, debla, živice: zelenkasto (ExG i udio zelenog) ili tamno i teksturirano, izvan neba.
    bez_tamnog  bool maska u kojoj se "tamno i teksturirano" ne računa (npr. obris starog stadiona i zgrada iz
                modela: sjena ispod tribine nije krošnja); zeleno vrijedi i tamo."""
    nd = _nd()
    r, g, b = foto[..., 0], foto[..., 1], foto[..., 2]
    y = svjetlina(foto)
    exg = 2 * g - r - b
    udio_g = g / np.maximum(r + g + b, 1e-3)
    tekst = nd.uniform_filter(np.abs(nd.laplace(nd.gaussian_filter(y, 0.7))), 5)
    zeleno = (exg > 0.03) & (udio_g > 0.355) & (g > b)
    tamno = (y < np.percentile(y, tamno_percentil)) & (tekst > 0.012)
    if bez_tamnog is not None:
        tamno &= ~bez_tamnog
    m = (zeleno | tamno) & ~nebo
    m = nd.binary_opening(m, _disk(1))
    m = nd.binary_closing(m, _disk(2))
    return m


def maska_tankog(foto, nebo, debljina_px=9):
    """Tanke strukture na nebu (grane, stupovi, žice): nisu nebo, ali ih nebo okružuje (zatvaranje maske neba)."""
    nd = _nd()
    zatv = nd.binary_closing(nebo, _disk(max(1, debljina_px // 2)))
    t = zatv & ~nebo
    return nd.binary_opening(t, _disk(0.5)) | t


# ---------------------------------------------------------------------------
# Usklađenje s fotografijom
# ---------------------------------------------------------------------------

def _kroma(rgb):
    return rgb.max(-1) - rgb.min(-1)


def uskladi_boju(render, foto, podrucje, nebo_r=None, nebo_f=None, jakost=1.0):
    """Preslikavanje boje rendera prema fotografiji na zajedničkim područjima (isti pikseli).
    Crna i bijela točka iz svjetline (2. i 98. percentil), toplina iz omjera kanala na neutralnim pikselima
    i nebu, zasićenje iz omjera kromatičnosti. Vraća (funkcija f(rgb_srgb) -> rgb, parametri)."""
    ok = podrucje & np.isfinite(render).all(-1)
    if ok.sum() < 500:
        return (lambda x: x), {"primijenjeno": False, "razlog": "premalo zajedničkih piksela"}
    yr, yf = svjetlina(render)[ok], svjetlina(foto)[ok]
    r_lo, r_hi = np.percentile(yr, [2, 98])
    f_lo, f_hi = np.percentile(yf, [2, 98])
    # nagib je ograničen: kopno modela (ortofoto, ljeto) i fotografija (drugo doba godine) nisu isti materijal,
    # pa puno rastezanje kontrasta pregori svijetle plohe koncepta
    a = float(np.clip((f_hi - f_lo) / max(r_hi - r_lo, 1e-3), 0.8, 1.25))
    b = float(np.clip(f_lo - a * r_lo, -0.15, 0.15))
    # toplina: neutralni pikseli u oba (niska kromatičnost) i nebo
    neut = ok & (_kroma(render) < 0.10) & (_kroma(foto) < 0.12) & (svjetlina(foto) > 0.15)
    uzorci_r, uzorci_f = [], []
    if neut.sum() > 300:
        uzorci_r.append(render[neut] / np.maximum(svjetlina(render)[neut][:, None], 1e-3))
        uzorci_f.append(foto[neut] / np.maximum(svjetlina(foto)[neut][:, None], 1e-3))
    if nebo_r is not None and nebo_f is not None and nebo_r.sum() > 300 and nebo_f.sum() > 300:
        uzorci_r.append(render[nebo_r] / np.maximum(svjetlina(render)[nebo_r][:, None], 1e-3))
        uzorci_f.append(foto[nebo_f] / np.maximum(svjetlina(foto)[nebo_f][:, None], 1e-3))
    if uzorci_r:
        mr = np.median(np.concatenate(uzorci_r), 0)
        mf = np.median(np.concatenate(uzorci_f), 0)
        g = np.clip(mf / np.maximum(mr, 1e-3), 0.85, 1.18)
        g = g / svjetlina(g[None, :])[0]
    else:
        g = np.ones(3, np.float32)
    kr = np.median(_kroma(render[ok]))
    kf = np.median(_kroma(foto[ok]))
    sat = float(np.clip(kf / max(kr * a, 1e-3), 0.7, 1.3))
    t = float(np.clip(jakost, 0.0, 1.0))
    a_t, b_t = 1 + t * (a - 1), t * b
    g_t = 1 + t * (g - 1)
    s_t = 1 + t * (sat - 1)

    def f(x):
        y = (x * a_t + b_t) * g_t
        l = svjetlina(y)[..., None]
        y = l + (y - l) * s_t
        # meko rame iznad 0,82: svijetle plohe (krov, beton) ne pregaraju
        return np.clip(np.where(y > 0.82, 0.82 + 0.18 * np.tanh((y - 0.82) / 0.18), y), 0.0, 1.0)

    return f, {"primijenjeno": True, "crna_bijela_render": [round(float(r_lo), 3), round(float(r_hi), 3)],
               "crna_bijela_foto": [round(float(f_lo), 3), round(float(f_hi), 3)], "nagib": round(a_t, 3),
               "pomak": round(b_t, 3), "toplina_kanali": [round(float(v), 3) for v in g_t],
               "zasicenje": round(s_t, 3), "pikseli": int(ok.sum()), "neutralni_pikseli": int(neut.sum())}


def boja_obzora(foto_lin, nebo, stupci=24):
    """Boja neba neposredno iznad obzora (najniži pojas neba u svakom stupcu), po stupcima slike, linearno."""
    H, W = nebo.shape
    if nebo.sum() < 50:
        return None
    rows = np.arange(H)[:, None]
    najnizi = np.where(nebo, rows, -1).max(0)
    boje = np.zeros((W, 3), np.float32)
    ima = np.zeros(W, bool)
    for c in range(W):
        r = najnizi[c]
        if r < 0:
            continue
        r0 = max(0, r - max(3, H // 40))
        sel = nebo[r0:r + 1, c]
        if sel.sum():
            boje[c] = foto_lin[r0:r + 1, c][sel].mean(0)
            ima[c] = True
    if not ima.any():
        return None
    idx = np.arange(W)
    for k in range(3):
        boje[:, k] = np.interp(idx, idx[ima], boje[ima, k])
    return _nd().uniform_filter1d(boje, size=max(3, W // stupci), axis=0)


def ostrina(y, maska=None):
    """Omjer srednje |Laplace| i srednjeg |gradijenta| (neovisan o kontrastu); manje = mekše."""
    nd = _nd()
    lap = np.abs(nd.laplace(y))
    gr = np.hypot(nd.sobel(y, 0), nd.sobel(y, 1)) / 8.0
    if maska is not None and maska.sum() > 200:
        lap, gr = lap[maska], gr[maska]
    return float(np.mean(lap) / max(np.mean(gr), 1e-6))


def procijeni_zamucenje(foto, render, podrucje):
    """Sigma zamućenja rendera (px) tako da mu oštrina bude kao fotografijina na istom području."""
    nd = _nd()
    cilj = ostrina(svjetlina(foto), podrucje)
    yr = svjetlina(render)
    najbolje, raz = 0.0, 1e9
    for sg in (0.0, 0.3, 0.5, 0.7, 0.9, 1.2, 1.6, 2.0):
        o = ostrina(nd.gaussian_filter(yr, sg) if sg else yr, podrucje)
        if abs(o - cilj) < raz:
            najbolje, raz = sg, abs(o - cilj)
    return najbolje, round(cilj, 4)


def procijeni_zrno(foto, ravno):
    """Standardna devijacija šuma po kanalu (MAD visokih frekvencija) u ravnim područjima fotografije."""
    nd = _nd()
    if ravno.sum() < 300:
        return np.zeros(3, np.float32)
    out = []
    for k in range(3):
        hp = foto[..., k] - nd.gaussian_filter(foto[..., k], 1.2)
        v = hp[ravno]
        out.append(1.4826 * np.median(np.abs(v - np.median(v))))
    return np.asarray(out, np.float32)


# ---------------------------------------------------------------------------
# Uklapanje
# ---------------------------------------------------------------------------

def _postavke(kw):
    p = {**ZADANO, **{k: v for k, v in kw.items() if v is not None}}
    p["prednji_plan"] = {**ZADANO["prednji_plan"], **(kw.get("prednji_plan") or {})}
    nepoznato = set(kw) - set(ZADANO)
    if nepoznato:
        raise ValueError(f"nepoznate postavke montaže: {sorted(nepoznato)}; dopušteno {sorted(ZADANO)}")
    return p


def grane_fotografije(foto, W):
    """Tanke tamne crte (grane golih krošnji) iz morfološkog "black-hat" filtra: zatvaranje malim diskom minus
    slika. Široke plohe (cesta, sjena, krov, travnjak) ne daju odziv. Vraća 0..1."""
    nd = _nd()
    y_g = nd.gaussian_filter(svjetlina(foto), 0.6)
    r_gr = max(2, int(round(W / 800)))
    grana = np.clip((nd.grey_closing(y_g, footprint=_disk(r_gr)) - y_g - 0.025) / 0.05, 0, 1)
    grana *= np.clip((0.34 - y_g) / 0.10, 0, 1)  # grane su tamne; rubovi oznaka na cesti i vozila nisu
    return nd.gaussian_filter(grana, 0.5)


def travnjak_umjesto(foto, podrucje, boja_srgb, W, lokalno_px=0):
    """Travnjak na mjestu sadržaja snimke koji program uklanja na prirodnom tlu (stari teren, ograda): boja
    osunčanog travnjaka (PRETPOSTAVKA) puta svjetlina fotografije bez tankih svijetlih crta (linije terena,
    mreža ograde nestaju; sjene stabala, tekstura trave i gusto granje ispred ostaju). Vraća sRGB polje."""
    nd = _nd()
    y = svjetlina(u_linearno(foto))
    r = max(2, int(round(W / 600)))
    # samo bijele crte (linije terena) van: svijetlo, tanko i neutralno; otvaranje cijele slike bi gusto granje
    # pretvorilo u tamne mrlje
    y_ot = nd.grey_opening(y, footprint=_disk(r))
    crta = prosiri(((y - y_ot) > 0.03) & (_kroma(foto) < 0.14) & (svjetlina(foto) > 0.42), 1)
    y_o = nd.gaussian_filter(np.where(crta, y_ot, y), 0.5)
    ref = float(np.percentile(y_o[podrucje], 80)) if podrucje.any() else float(np.median(y_o))
    if lokalno_px and podrucje.any():
        # lokalni prosjek unutar poligona (normalizirana konvolucija): ostaje tekstura i male sjene, nestaje razlika
        # materijala; 0,9 = osunčani travnjak malo ispod lokalnog maksimuma
        s = float(lokalno_px) * W / 2400
        mf = podrucje.astype(np.float32)
        lok = nd.gaussian_filter(y_o * mf, s) / np.maximum(nd.gaussian_filter(mf, s), 1e-4)
        ref = np.maximum(lok / 0.9, 1e-4)
    mod = np.clip(y_o / np.maximum(ref, 1e-4), 0.03, 1.15)
    trava = u_linearno(np.asarray(boja_srgb, np.float32))[None, None, :] * mod[..., None]
    return np.clip(u_srgb(trava), 0, 1)


def uklopi(fotografija, koncept, pokrivenost=None, dubina=None, *, maska=None, slika_modela=None,
           postojece_maska=None, koncept_bez_zaklona=None, sjeme=20261114, **postavke):
    """Uklapa prolaz koncepta (RGBA, ista kamera) u fotografiju.

    fotografija      put ili polje sRGB 0..1 (izvornik; ne mijenja se)
    koncept          RGBA 0..1 iz <osnova>_koncept.png (tijelo koncepta i sjena na terenu)
    pokrivenost      rječnik udjela po sloju (ključ "koncept"); bez njega tijelo = alfa bez crnih piksela
    dubina           daljina od kamere (m; inf = nebo) za izmaglicu
    maska            maska slojeva scene s konceptom (za nebo, područja usklađenja i uklanjanje)
    slika_modela     render scene s konceptom (sRGB 0..1) za usklađenje boje i ispunu iz modela
    postojece_maska  maska scene postojećeg stanja iz iste kamere (za uklanjanje onoga što koncept zamjenjuje)
    koncept_bez_zaklona  RGBA prolaz koncepta iste kamere renderiran BEZ zaklona postojećim drvećem i zgradama
                     (koncept_zaklon=False). Uz njega zaklon iz modela vrijedi samo ondje gdje i fotografija na tom
                     mjestu pokazuje vegetaciju (presjek modela i fotografije); inače proceduralna krošnja modela
                     probija rupu u koncept kroz koju se vidi današnja cesta (P04, sjeverno lice pokrova).
    postavke         ključevi iz ZADANO (sirina, poligoni_*, prednji_plan, vidljivost_km, ...)
    Vraća (polje sRGB 0..1 bez trake, info).
    """
    p = _postavke(postavke)
    nd = _nd()
    rng = np.random.default_rng(int(sjeme))
    pol = ("poligoni_zaklon", "poligoni_ukloni", "poligoni_podrucje", "poligoni_pozadina", "poligoni_voda",
           "poligoni_bez_izvora", "poligoni_presjek", "poligoni_krosnje", "poligoni_bez_zaklona", "poligoni_tlo",
           "zamuti")
    info = {"postavke": {k: v for k, v in p.items() if k not in pol}, "poligoni": {k: p[k] for k in pol}}
    izv = ucitaj_sliku(fotografija) if not isinstance(fotografija, np.ndarray) else np.asarray(fotografija, np.float32)
    Hf, Wf = izv.shape[:2]
    W = int(p["sirina"] or Wf)
    H = int(round(Hf * W / Wf))
    mj = W / Wf  # mjerilo pikseli fotografije -> izlaz
    info["velicina"] = [W, H]
    foto = np.clip(promijeni_velicinu(izv, W, H, "lanczos"), 0, 1)
    if p["zamuti"]:
        foto = zamuti(foto, p["zamuti"], mjerilo=mj)

    # --- prolazi u veličini izlaza --------------------------------------
    k = np.asarray(koncept, np.float32)
    if abs(k.shape[1] / k.shape[0] - W / H) > 0.01:
        raise ValueError(f"omjer prolaza {k.shape[1]}x{k.shape[0]} ne odgovara fotografiji {Wf}x{Hf}")
    alfa = np.clip(promijeni_velicinu(k[..., 3], W, H, "bilinear"), 0, 1)
    rgb_pm = promijeni_velicinu(k[..., :3] * k[..., 3:4], W, H, "bilinear")
    k_rgb = np.clip(rgb_pm / np.maximum(alfa[..., None], 1e-4), 0, 1)
    tijelo_iz_alfe = alfa * np.clip((k_rgb.max(-1) - 0.015) / 0.03, 0, 1)  # sjena hvatača je crna
    if pokrivenost is not None and "koncept" in pokrivenost:
        tijelo = np.clip(promijeni_velicinu(pokrivenost["koncept"], W, H, "bilinear"), 0, 1)
        tijelo = np.minimum(tijelo, alfa)
        if not p["zaklon_modela"]:
            # maska pokrivenosti vidi postojeće krošnje ispred koncepta; prolaz koncepta ih nema
            tijelo = np.maximum(tijelo, tijelo_iz_alfe)
    else:
        tijelo = tijelo_iz_alfe
    sjena = np.clip((alfa - tijelo) / np.maximum(1.0 - tijelo, 1e-3), 0, 1) * (tijelo < 0.999)
    if pokrivenost is not None and all(k_ in pokrivenost for k_ in ("teren_blizu", "vode")):
        # sjena samo na tlu i vodi: na postojećim krošnjama i zgradama hvatač daje lažnu sjenu (prozirne
        # zimske krošnje kao zaklon), a te plohe na fotografiji već nose vlastito svjetlo
        tlo_udio = sum(pokrivenost[k_] for k_ in ("teren_blizu", "teren_regija", "vode", "teren_daleko")
                       if k_ in pokrivenost)
        sjena = sjena * np.clip(promijeni_velicinu(tlo_udio, W, H, "bilinear"), 0, 1)
    # gdje koncept stvarno mijenja fotografiju (alfa hvatača ima i slab šum na postojećim krošnjama)
    prisutno = (tijelo > 0.01) | (sjena > 0.05)
    msk = promijeni_velicinu(maska, W, H, "najblize") if maska is not None else None
    post = promijeni_velicinu(postojece_maska, W, H, "najblize") if postojece_maska is not None else None
    dub = promijeni_velicinu(np.where(np.isfinite(dubina), dubina, 1e7), W, H, "najblize") if dubina is not None else None
    rend = np.clip(promijeni_velicinu(slika_modela, W, H, "lanczos"), 0, 1) if slika_modela is not None else None

    # --- nebo i prednji plan iz fotografije -----------------------------
    prior = None
    if msk is not None:
        # nebo smije biti samo gdje model ima nebo (sa ili bez koncepta) i u konceptu uz takvo nebo; inače se svijetle
        # plohe prednjeg plana (vozila, beton parkirališta) ispod koncepta proglase nebom (P05, proba 14.11.)
        nebo_modela = (msk == NEBO) | ((post == NEBO) if post is not None else False)
        prior = prosiri(nebo_modela, max(2, W // 60)) | ((msk == KONCEPT) & prosiri(nebo_modela, max(4, W // 20)))
    nebo_meko, nebo, ni = maska_neba(foto, prior=prior, prag=p["nebo_prag"])
    info["nebo"] = ni
    pp = p["prednji_plan"]
    prednji = np.zeros((H, W), bool)
    if pp.get("vegetacija"):
        # gdje "tamno" nije zaklon: ručni poligoni pozadine; bez njih obris starog stadiona i zgrada iz modela
        # (s tla je obris modela pregrub: zahvaća i stabla ispred, pa ručni poligoni imaju prednost)
        staro = None
        if p["poligoni_pozadina"]:
            staro = maska_poligona(p["poligoni_pozadina"], W, H, mj)
        elif post is not None:
            staro = prosiri(np.isin(post, [STADION, ZGRADE]), max(2, W // 160))
        veg = maska_vegetacije(foto, nebo, bez_tamnog=staro, tamno_percentil=float(pp.get("tamno_percentil", 30)))
        prednji |= veg
        info["vegetacija_udio"] = round(float(veg.mean()), 4)
    if pp.get("tanko"):
        tan = maska_tankog(foto, nebo, int(pp.get("tanko_px", 9)))
        if p["poligoni_pozadina"]:
            tan &= ~maska_poligona(p["poligoni_pozadina"], W, H, mj)
        prednji |= tan
        info["tanko_udio"] = round(float(tan.mean()), 4)
    if pp.get("samo_iznad_neba") and msk is not None:
        # samo gdje bi bez koncepta iza bilo nebo (u sceni postojećeg stanja ili s konceptom)
        iza = (post == NEBO) if post is not None else (msk == NEBO)
        prednji &= prosiri(iza | (msk == KONCEPT), 2)
    if p["poligoni_podrucje"]:
        prednji &= maska_poligona(p["poligoni_podrucje"], W, H, mj)
    if koncept_bez_zaklona is not None:
        kb = np.asarray(koncept_bez_zaklona, np.float32)
        alfa_b = np.clip(promijeni_velicinu(kb[..., 3], W, H, "bilinear"), 0, 1)
        rgb_b = np.clip(promijeni_velicinu(kb[..., :3] * kb[..., 3:4], W, H, "bilinear")
                        / np.maximum(alfa_b[..., None], 1e-4), 0, 1)
        # tijelo bez zaklona: neprozirni koncept (alfa sjene hvatača je manja od 0,9) ili svijetla boja
        tijelo_b = np.maximum(alfa_b * np.clip((rgb_b.max(-1) - 0.015) / 0.03, 0, 1),
                              np.clip((alfa_b - 0.9) / 0.08, 0, 1))
        zaklon_m = (tijelo_b - tijelo) > 0.05
        if msk is not None:
            # samo zaklon postojećim DRVEĆEM modela; zgrade ispred koncepta ostaju pune (P01: kuće uz istočni rub)
            zaklon_m &= prosiri(msk == DRVECE, 3)
        # koncept je izravno iza (prozirne) krošnje samo gdje prolaz sa zaklonom ima alfu; gdje je iza krošnje zgrada,
        # alfa je 0 i ondje se koncept ne crta (P01: kuće ispred pomoćnog terena)
        zaklon_m &= zatvori(alfa > 0.02, max(3, int(round(W / 400))))
        if p["poligoni_presjek"]:
            zaklon_m &= maska_poligona(p["poligoni_presjek"], W, H, mj)
        # proširenje za 2 px: rub prozirne krošnje modela inače ostavlja svijetli prsten fotografije
        zaklon_m = zagladi(prosiri(zaklon_m, 2) & ~prosiri(np.isin(msk, [ZGRADE]) if msk is not None else
                                                           np.zeros_like(zaklon_m), 1), 1.0)
        # gole krošnje su prozirne: u području gdje model ima postojeće stablo ispred koncepta neprozirnost zaklona
        # računa se iz fotografije: grana je tamnija od lokalno najsvjetlije pozadine (koncept se vidi kroz krošnju);
        # zelena i teksturirana vegetacija (vrba, četinjače, grmlje) zaklanja potpuno. Cesta, nogostup i vozila na
        # mjestu proceduralne krošnje nisu zaklon (inače bi kroz koncept virila današnja cesta).
        y_f = svjetlina(foto)
        # tanke tamne crte (grane): široke plohe (cesta, sjena, krov) ne daju odziv, pa se ondje vidi koncept
        grana = grane_fotografije(foto, W)
        r_, g_, b_ = foto[..., 0], foto[..., 1], foto[..., 2]
        tekst = nd.uniform_filter(np.abs(nd.laplace(nd.gaussian_filter(y_f, 0.7))), 5)
        zeleno = ((2 * g_ - r_ - b_) > 0.04) & (g_ / np.maximum(r_ + g_ + b_, 1e-3) > 0.36) & (g_ > b_) & (tekst > 0.02)
        zeleno = nd.binary_opening(zeleno, _disk(1))
        # gusta krošnja (tamno i teksturirano, kao maska_vegetacije) zaklanja kao cjelina; glatka sjena na cesti ne
        tamno = (y_f < np.percentile(y_f, float(pp.get("tamno_percentil", 30)))) & (tekst > 0.012)
        tamno = nd.binary_closing(nd.binary_opening(tamno, _disk(1)), _disk(2))
        if not pp.get("presjek_tamno", True):
            tamno = np.zeros_like(tamno)
        if not pp.get("presjek_zeleno", True):
            zeleno = np.zeros_like(zeleno)
        neprozirno = np.maximum(grana, zagladi(zeleno | tamno, 1.0))
        tijelo_n = np.maximum(tijelo, tijelo_b * (1.0 - neprozirno))
        tijelo = tijelo * (1 - zaklon_m) + tijelo_n * zaklon_m
        k_rgb = k_rgb * (1 - zaklon_m[..., None]) + rgb_b * zaklon_m[..., None]
        popuni = (zaklon_m > 0.5) & (neprozirno < 0.5)
        ostaje = (zaklon_m > 0.5) & ~popuni
        prisutno = prisutno | (tijelo > 0.01)
        info["zaklon_presjek"] = {"zaklon_modela_px": int((zaklon_m > 0.5).sum()), "ostaje_zaklon_px": int(ostaje.sum()),
                                  "popunjeno_px": int(popuni.sum()),
                                  "pravilo": "u području zaklona iz modela neprozirnost iz fotografije: grane tamnije od "
                                             "pozadine i zelena teksturirana vegetacija zaklanjaju, ostalo pokazuje koncept"}
    if p["poligoni_krosnje"]:
        # stvarne gole krošnje ispred koncepta kojih model nema: grane s fotografije zaklanjaju (P04: stabla uz
        # Maksimirsku ispred pomoćnog terena; bez ovoga se teren crta preko vrhova krošnji i čita kao podignut)
        kr = maska_poligona(p["poligoni_krosnje"], W, H, mj)
        gr = grane_fotografije(foto, W) * kr
        prije = int((tijelo > 0.5).sum())
        tijelo = tijelo * (1.0 - gr)
        info["krosnje_s_fotografije"] = {"podrucje_px": int(kr.sum()), "zaklonjeno_px": prije - int((tijelo > 0.5).sum()),
                                         "pravilo": "unutar ručnog poligona tamne grane s fotografije zaklanjaju koncept"}
    ukl_rucno = maska_poligona(p["poligoni_ukloni"], W, H, mj)
    prednji &= ~ukl_rucno
    prednji |= maska_poligona(p["poligoni_zaklon"], W, H, mj)
    if p["poligoni_bez_zaklona"]:
        bz = maska_poligona(p["poligoni_bez_zaklona"], W, H, mj)
        prednji &= ~bz
        if koncept_bez_zaklona is not None:
            bzf = zagladi(bz, 1.0)
            tijelo = tijelo * (1 - bzf) + np.maximum(tijelo, tijelo_b) * bzf
            k_rgb = k_rgb * (1 - bzf[..., None]) + rgb_b * bzf[..., None]
            prisutno = prisutno | (tijelo > 0.01)
        info["bez_zaklona_px"] = int(bz.sum())
    prednji_meko = zagladi(prednji, 0.7)
    info["prednji_plan_udio"] = round(float(prednji.mean()), 4)

    # --- uklanjanje dijelova postojećeg stanja --------------------------
    ukloni = ukl_rucno.copy()
    if post is not None and msk is not None and p["ukloni_slojeve"]:
        bilo = np.isin(post, list(p["ukloni_slojeve"]))
        sad = np.isin(msk, [NEBO, *TLO])
        auto = bilo & sad
        auto = prosiri(auto, int(p["ukloni_prosiri_px"]))
        # što je zaklon iz fotografije ostaje (stablo ispred srušene zgrade)
        ukloni |= auto & ~prednji
        info["uklonjeno_iz_modela_px"] = int(auto.sum())
    ukloni &= ~(tijelo > 0.995)  # ispod punog koncepta ispuna nije potrebna
    ukloni_px = prosiri(ukloni, 1)
    info["uklonjeno_px"] = int(ukloni_px.sum())
    osnova = foto.copy()
    ispuna_info = {}
    if ukloni_px.any():
        nebo_iza = nebo_meko > 0.5
        if msk is not None:
            nebo_iza = (msk == NEBO) | ((msk == KONCEPT) & prosiri(nebo, 6))
        u_nebo = ukloni_px & nebo_iza
        u_tlo = ukloni_px & ~nebo_iza
        if u_nebo.any():
            pozn = nebo & ~ukloni_px
            if pozn.sum() > 50:
                osnova[u_nebo] = push_pull(foto, pozn)[u_nebo]
            ispuna_info["nebo_px"] = int(u_nebo.sum())
        if u_tlo.any():
            # poznato: tlo fotografije bez koncepta, bez onoga što se uklanja i bez starog stadiona iz modela
            pozn = ~nebo & ~ukloni_px & ~prisutno
            if post is not None:
                pozn &= ~prosiri(post == STADION, 2)
            nisko = push_pull(foto, pozn)
            if rend is not None and p["ispuna_iz_modela"]:
                detalj = rend - nd.gaussian_filter(rend, (6, 6, 0))
                nisko = np.clip(nisko + detalj, 0, 1)
            osnova[u_tlo] = nisko[u_tlo]
            # klon iz susjedstva iste fotografije gdje je moguće (tekstura šume, krovova); inače glatka ispuna
            smije = pozn & ~prisutno & ~prosiri(ukloni_px, 3)
            if p["poligoni_bez_izvora"]:
                # npr. Vidikovac u šumi uz glavu stupa (P01): klon ga je udvostručio
                smije &= ~maska_poligona(p["poligoni_bez_izvora"], W, H, mj)
            klonirano, n_klon, n_glatko = ispuna_klonom(osnova, u_tlo, smije)
            osnova[u_tlo] = klonirano[u_tlo]
            ispuna_info.update({"tlo_px": int(u_tlo.sum()), "dijelova_klonom": n_klon, "dijelova_glatko": n_glatko})
            if n_glatko and rend is not None and p["ispuna_iz_modela"]:
                ispuna_info["detalj_iz_modela"] = True
        # mekan prijelaz ispune
        t = zagladi(ukloni_px, 1.2)[..., None]
        osnova = foto * (1 - t) + osnova * t
    info["ispuna"] = ispuna_info
    if p["poligoni_tlo"]:
        # tlo programa koje model ne crta (P04: Istočni perivoj na prirodnom tlu između pomoćnog terena i
        # Maksimirske): stari teren i ograda postaju travnjak; tamne grane (ne plave: ograda) ostaju ispred
        tl = maska_poligona(p["poligoni_tlo"], W, H, mj) & ~(tijelo > 0.995)
        if tl.any():
            trava = travnjak_umjesto(osnova, tl, p["tlo_boja"], W, p["tlo_lokalno_px"])
            gr = grane_fotografije(foto, W)
            plavo = (foto[..., 2] > foto[..., 0] + 0.03) & (foto[..., 2] > foto[..., 1])
            ostaje = np.clip(gr * ~plavo, 0, 1)[..., None]
            t = zagladi(tl, 1.5)[..., None]
            novo = trava * (1 - ostaje) + osnova * ostaje
            osnova = osnova * (1 - t) + novo * t
        info["tlo_travnjak"] = {"px": int(tl.sum()), "boja_srgb": list(p["tlo_boja"]),
                                "pravilo": "travnjak (PRETPOSTAVKA boje) puta sjene s fotografije; grane ostaju"
                                + ("; svjetlina prema lokalnom prosjeku (sigma %s px na 2400)" % p["tlo_lokalno_px"]
                                   if p["tlo_lokalno_px"] else "")}

    # --- usklađenje rendera s fotografijom, zatim izmaglica ---------------
    # usklađenje se računa na renderu BEZ izmaglice i na kopnu blizu koncepta (gdje je i na fotografiji izmaglice
    # malo); izmaglica se dodaje konceptu nakon usklađenja. Ranije je render dobivao izmaglicu prije usklađenja, pa je
    # crna točka rendera rasla (0,16-0,18) i usklađenje je zatamnilo bliski koncept (P01, P04, proba 14.11.).
    foto_lin = u_linearno(osnova)
    hor = boja_obzora(u_linearno(foto), nebo)
    k_s = k_rgb
    if p["uskladi"] and rend is not None and msk is not None:
        zajed = (np.isin(msk, [*TLO, ZGRADE, DRVECE]) & ~prisutno & ~ukloni_px & ~prosiri(prednji, 2)
                 & ~nebo & ~(post == STADION if post is not None else False))
        zajed = suzi(zajed, 2)
        if dub is not None and (tijelo > 0.5).any():
            granica = max(1500.0, 3.0 * float(np.median(dub[tijelo > 0.5])))
            if (zajed & (dub < granica)).sum() > 5000:
                zajed &= dub < granica
                info["uskladjenje_do_m"] = round(granica)
        nr = suzi(msk == NEBO, 3) & nebo
        f, ui = uskladi_boju(rend, foto, zajed, nebo_r=nr, nebo_f=nr, jakost=p["uskladi_jakost"])
        k_s = f(k_s)
        info["uskladjenje"] = ui
    else:
        info["uskladjenje"] = {"primijenjeno": False}
    if p["crna_tocka"]:
        # meka donja granica: najtamniji ton koncepta ne pada ispod crne točke fotografije (otvor krova stadiona,
        # u renderu gotovo 0, inače se čita kao rupa ili crni poklopac). y + a*c*exp(-y/(a*c)) je monoton, 0 ide
        # na 0,6 c, a tonovi iznad 2 c se gotovo ne mijenjaju
        c = p["crna_tocka"]
        if c == "auto":
            c = (info["uskladjenje"].get("crna_bijela_foto") or [0.03])[0]
        c = float(np.clip(c, 0.0, 0.12))
        if c > 0:
            ac = 0.6 * c
            k_s = np.clip(k_s + ac * np.exp(-np.clip(k_s, 0, 1) / ac), 0, 1)
        info["crna_tocka"] = round(c, 3)
    if p["vidljivost_km"] and dub is not None:
        prij = np.exp(-3.912 * dub / (float(p["vidljivost_km"]) * 1000.0)).astype(np.float32)[..., None]
        hb = (hor[None, :, :] if hor is not None else np.full((1, 1, 3), np.median(foto_lin[nebo], 0)
                                                              if nebo.any() else 0.8, np.float32))
        k_s = u_srgb(u_linearno(k_s) * prij + hb * (1 - prij))
        info["izmaglica"] = {"vidljivost_km": p["vidljivost_km"], "boja_obzora": "nebo iznad obzora po stupcima "
                             "fotografije", "srednji_prijenos_koncepta": round(float(prij[..., 0][tijelo > 0.5].mean()), 3)
                             if (tijelo > 0.5).any() else None}

    # --- zamućenje i zrno ----------------------------------------------
    sg = p["zamucenje"]
    if sg == "auto":
        if rend is not None and msk is not None:
            podr = suzi(np.isin(msk, [*TLO, ZGRADE, DRVECE]) & ~prisutno & ~ukloni_px, 3)
            sg, cilj = procijeni_zamucenje(foto, rend, podr)
            info["ostrina_fotografije"] = cilj
        else:
            sg = 0.5
    sg = float(sg or 0.0)
    info["zamucenje_px"] = sg
    tijelo_m = tijelo
    if sg > 0:
        k_pm = nd.gaussian_filter(k_s * tijelo[..., None], (sg, sg, 0))
        tijelo_m = nd.gaussian_filter(tijelo, sg)
        k_s = np.clip(k_pm / np.maximum(tijelo_m[..., None], 1e-4), 0, 1)
    if p["meki_rub_px"]:
        tijelo_m = np.clip(nd.gaussian_filter(tijelo_m, float(p["meki_rub_px"])) * 0.5 + tijelo_m * 0.5, 0, 1)
    if p["zrno"]:
        ravno = suzi(nebo, 4) if nebo.sum() > 2000 else (np.hypot(nd.sobel(svjetlina(foto), 0),
                                                                   nd.sobel(svjetlina(foto), 1)) < 0.05)
        zr = procijeni_zrno(foto, ravno)
        sum_ = rng.normal(0, 1, (H, W, 1)).astype(np.float32)
        sum_ = nd.gaussian_filter(sum_, (0.5, 0.5, 0)) * 1.6
        k_s = np.clip(k_s + sum_ * zr[None, None, :] + rng.normal(0, 1, (H, W, 3)).astype(np.float32) * zr * 0.25, 0, 1)
        info["zrno_sigma"] = [round(float(v), 4) for v in zr]

    # --- slaganje (linearno) -------------------------------------------
    vidljivo = 1.0 - prednji_meko
    a_t = np.clip(tijelo_m * vidljivo, 0, 1)[..., None]
    if p["sjena_zamucenje_px"]:
        sjena = nd.gaussian_filter(sjena, float(p["sjena_zamucenje_px"]))
    a_s = np.clip(sjena * float(p["sjena_jakost"]) * vidljivo, 0, 1)[..., None]
    ton = np.asarray(p["sjena_ton"], np.float32)
    ton = ton / ton.mean()
    pod = foto_lin * (1.0 - a_s) + foto_lin * a_s * 0.0
    pod = pod * (1.0 + (ton[None, None, :] - 1.0) * np.clip(a_s * 2, 0, 1))
    k_lin2 = u_linearno(k_s)
    izlaz = pod * (1 - a_t) + k_lin2 * a_t
    if p["odraz"]:
        voda = (maska_poligona(p["poligoni_voda"], W, H, mj) if p["poligoni_voda"] else
                (msk == VODE if msk is not None else np.zeros((H, W), bool)))
        voda &= ~prednji
        if voda.any():
            od = {"jakost": 0.5, "zatamni": 0.8, **(p["odraz"] if isinstance(p["odraz"], dict) else {})}
            stupci = voda.any(0)
            r0 = np.where(stupci, voda.argmax(0), H)
            rr = np.arange(H)[:, None]
            rs = 2 * r0[None, :] - rr
            vrijedi = voda & (rs >= 0) & (rs < H)
            cc = np.broadcast_to(np.arange(W)[None, :], (H, W))
            rs_c = np.clip(rs, 0, H - 1)
            a_r = np.where(vrijedi, a_t[..., 0][rs_c, cc], 0.0)
            k_r = k_lin2[rs_c, cc] * float(od["zatamni"])
            a_r = nd.gaussian_filter(a_r, (1.5, 0.6)) * float(od["jakost"])
            k_r = nd.gaussian_filter(k_r, (1.5, 0.6, 0))
            izlaz = izlaz * (1 - a_r[..., None]) + k_r * a_r[..., None]
            info["odraz"] = {**od, "voda_px": int(voda.sum()), "izvor_vode": "poligoni" if p["poligoni_voda"] else
                             "maska modela"}
    rez = u_srgb(izlaz)
    info["udio_koncepta"] = round(float((a_t[..., 0] > 0.5).mean()), 4)
    info["udio_sjene"] = round(float((a_s[..., 0] > 0.15).mean()), 4)
    info["maske"] = {"nebo": nebo, "prednji": prednji, "ukloni": ukloni_px, "tijelo": a_t[..., 0], "sjena": a_s[..., 0]}
    return rez, info


def spremi_maske(info, put):
    """Pregled maski za provjeru okom: crveno = prednji plan (zaklon), plavo = nebo, žuto = uklonjeno,
    zeleno = tijelo koncepta, sivo = sjena."""
    m = info["maske"]
    H, W = m["nebo"].shape
    a = np.zeros((H, W, 3), np.float32)
    a[m["nebo"]] = (0.25, 0.45, 0.95)
    a[..., 1] = np.maximum(a[..., 1], m["tijelo"] * 0.8)
    a += m["sjena"][..., None] * 0.5
    a[m["prednji"]] = (0.95, 0.15, 0.10)
    a[m["ukloni"]] = (0.95, 0.85, 0.10)
    return spremi(np.clip(a, 0, 1), put)


# ---------------------------------------------------------------------------
# Privatnost
# ---------------------------------------------------------------------------

def zamuti(slika, pravokutnici, mjerilo=1.0, sigma=None):
    """Snažno zamućuje pravokutnike [x0, y0, x1, y1] (pikseli fotografije pomnoženi s `mjerilo`): pikselizacija
    pa Gaussovo zamućenje, tako da se lica i pločice ne mogu pročitati. slika: polje 0..1 ili PIL; vraća isto."""
    je_pil = not isinstance(slika, np.ndarray)
    a = (np.asarray(slika.convert("RGB"), np.float32) / 255.0) if je_pil else np.array(slika, np.float32, copy=True)
    H, W = a.shape[:2]
    nd = _nd()
    for r in pravokutnici or []:
        x0, y0, x1, y1 = (int(round(v * mjerilo)) for v in r)
        x0, x1 = sorted((max(0, x0), min(W, x1)))
        y0, y1 = sorted((max(0, y0), min(H, y1)))
        if x1 - x0 < 2 or y1 - y0 < 2:
            continue
        blok = a[y0:y1, x0:x1]
        n = int(np.clip(min(x1 - x0, y1 - y0) // 6, 2, 24))
        mala = promijeni_velicinu(blok, max(1, (x1 - x0) // n), max(1, (y1 - y0) // n), "bilinear")
        vel = promijeni_velicinu(mala, x1 - x0, y1 - y0, "najblize")
        s = sigma or max(2.0, n * 0.8)
        a[y0:y1, x0:x1] = nd.gaussian_filter(vel, (s, s, 0))
    if je_pil:
        return _img().fromarray(np.clip(np.rint(a * 255), 0, 255).astype(np.uint8), "RGB")
    return a


# ---------------------------------------------------------------------------
# Navodi i traka
# ---------------------------------------------------------------------------

def je_by_sa(licenca):
    return "BY-SA" in str(licenca or "").upper().replace(" ", "-")


def navod_fotografije(meta, danas=False):
    """Tekst navoda fotografije. meta: {"izvor": "grad", "godina"} za Gradove snimke (odluka M21) ili
    {"autor", "naslov", "licenca", "licenca_url", "izvor_url", "godina"} za slobodne fotografije.
    danas=True: navod za usporednu sliku bez montaže (izmjena je samo umanjenje i zamućenje).
    Vraća popis redaka (navod, licenca izlaza)."""
    zam = ", zamućene osobe i pločice" if meta.get("zamuceno") else ""
    izmjene = ("umanjeno" + zam) if danas else ("umanjeno, montaža AI građanskog koncepta, usklađenje boje" + zam)
    if meta.get("izvor") == "grad":
        god = f", snimka {meta['godina']}." if meta.get("godina") else "."
        return [NAVOD_GRAD + god + f" Izmijenjeno: {izmjene}."]
    dijelovi = [f"Fotografija: {meta.get('autor', 'nepoznat autor')}"]
    if meta.get("naslov"):
        dijelovi.append(f"„{meta['naslov']}”")
    if meta.get("godina"):
        dijelovi.append(str(meta["godina"]))
    lic = meta.get("licenca", "")
    if lic:
        dijelovi.append(lic + (f" ({meta['licenca_url']})" if meta.get("licenca_url") else ""))
    if meta.get("izvor_url"):
        dijelovi.append(meta["izvor_url"])
    redovi = [", ".join(dijelovi) + f". Izmijenjeno: {izmjene}."]
    if danas:
        redovi.append("Autor fotografije ne podržava koncept niti je sudjelovao u usporedbi.")
    elif je_by_sa(lic):
        redovi.append("Ova montaža dijeli se pod licencom CC BY-SA 4.0 (https://creativecommons.org/licenses/by-sa/4.0); "
                      "nije stav autora fotografije.")
    else:
        redovi.append("Autor fotografije ne podržava koncept niti je sudjelovao u montaži.")
    return redovi


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

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


def _prelomi(crtez, tekst, font, sirina):
    rijeci, redovi, tek = tekst.split(" "), [], ""
    for r in rijeci:
        proba = (tek + " " + r) if tek else r
        if crtez.textlength(proba, font=font) > sirina and tek:
            redovi.append(tek)
            tek = r
        else:
            tek = proba
    if tek:
        redovi.append(tek)
    return redovi


def traka(slika, navod, podloge=None, oznaka=OZNAKA, napomena=None):
    """Dodaje ispod slike traku (slika se ne prekriva): oznaka (podebljano), navod fotografije (redak ili popis),
    podloge modela i neobvezna napomena. slika: polje 0..1 ili PIL. Vraća polje 0..1."""
    Image = _img()
    from PIL import ImageDraw

    im = slika if not isinstance(slika, np.ndarray) else Image.fromarray(
        np.clip(np.rint(slika * 255), 0, 255).astype(np.uint8), "RGB")
    w, h = im.size
    v1 = max(12, int(round(w * 0.0135)))
    v2 = max(10, int(round(w * 0.0095)))
    f1, f2 = _font(v1, True), _font(v2)
    rub = max(8, int(v1 * 0.7))
    proba = ImageDraw.Draw(Image.new("RGB", (10, 10)))
    tekstovi = [navod] if isinstance(navod, str) else list(navod or [])
    if podloge:
        tekstovi.append(podloge)
    if napomena:
        tekstovi.append(napomena)
    redovi = []
    for t in tekstovi:
        redovi += _prelomi(proba, t, f2, w - 2 * rub)
    visina = rub + v1 + int(v1 * 0.5) + len(redovi) * int(v2 * 1.38) + rub // 2
    out = Image.new("RGB", (w, h + visina), (18, 22, 28))
    out.paste(im.convert("RGB"), (0, 0))
    d = ImageDraw.Draw(out)
    y = h + rub // 2 + 2
    d.text((rub, y), oznaka, font=f1, fill=(255, 255, 255))
    y += v1 + int(v1 * 0.5)
    for r in redovi:
        d.text((rub, y), r, font=f2, fill=(205, 210, 216))
        y += int(v2 * 1.38)
    return np.asarray(out, np.float32) / 255.0


def natpis(slika, tekst):
    """Mali natpis u gornjem lijevom kutu (DANAS / VIZIJA) na poluprozirnoj podlozi."""
    Image = _img()
    from PIL import ImageDraw

    im = Image.fromarray(np.clip(np.rint(slika * 255), 0, 255).astype(np.uint8), "RGB").convert("RGBA")
    w, _ = im.size
    v = max(14, int(round(w * 0.022)))
    f = _font(v, True)
    sloj = Image.new("RGBA", im.size, (0, 0, 0, 0))
    d = ImageDraw.Draw(sloj)
    pad = int(v * 0.45)
    tw = d.textlength(tekst, font=f)
    d.rectangle([pad, pad, pad * 3 + tw, pad * 3 + v], fill=(18, 22, 28, 190))
    d.text((pad * 2, pad * 2 - int(v * 0.1)), tekst, font=f, fill=(255, 255, 255, 255))
    return np.asarray(Image.alpha_composite(im, sloj).convert("RGB"), np.float32) / 255.0


def danas(fotografija, sirina, navod, zamuti_pravokutnici=(), podloge=None):
    """Fotografija umanjena na širinu montaže (s istim zamućenjem i navodom), bez montaže."""
    izv = ucitaj_sliku(fotografija) if not isinstance(fotografija, np.ndarray) else fotografija
    Hf, Wf = izv.shape[:2]
    H = int(round(Hf * sirina / Wf))
    a = np.clip(promijeni_velicinu(izv, sirina, H, "lanczos"), 0, 1)
    if zamuti_pravokutnici:
        a = zamuti(a, zamuti_pravokutnici, mjerilo=sirina / Wf)
    return a


def danas_vizija(danas_slika, vizija_slika, navod, podloge=None, napomena=None, raspored="auto"):
    """Zajednička slika: lijevo (ili gore) DANAS, desno (ili dolje) VIZIJA, jedna traka s oznakom i navodima.
    Ulazi su slike BEZ trake, iste veličine."""
    a = natpis(danas_slika, "DANAS")
    b = natpis(vizija_slika, "VIZIJA · PRIJEDLOG")
    H, W = a.shape[:2]
    if raspored == "auto":
        raspored = "uspravno" if W / H > 1.9 else "vodoravno"
    razmak = max(4, W // 200)
    if raspored == "vodoravno":
        par = np.ones((H, 2 * W + razmak, 3), np.float32) * (18 / 255)
        par[:, :W], par[:, W + razmak:] = a, b
    else:
        par = np.ones((2 * H + razmak, W, 3), np.float32) * (18 / 255)
        par[:H], par[H + razmak:] = a, b
    nav = [navod] if isinstance(navod, str) else list(navod)
    nav = [("Lijevo" if raspored == "vodoravno" else "Gore") + ": fotografija bez montaže; "
           + ("desno" if raspored == "vodoravno" else "dolje") + ": ista fotografija s montažom koncepta."] + nav
    return traka(par, nav, podloge=podloge, oznaka=OZNAKA, napomena=napomena)


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

def _pravokutnici(tekst):
    out = []
    for t in tekst or []:
        out.append([float(v) for v in t.split(",")])
    return out


def main(argv=None):
    import argparse

    ap = argparse.ArgumentParser(description="Fotomontaža koncepta na fotografiju (bez Blendera)")
    sub = ap.add_subparsers(dest="naredba", required=True)
    u = sub.add_parser("uklopi", help="uklopi prolaze rendera u fotografiju")
    u.add_argument("--foto", required=True)
    u.add_argument("--prolazi", required=True, help="osnova imena prolaza (bez nastavka)")
    u.add_argument("--izlaz", required=True, help="mapa izlaza")
    u.add_argument("--ime", default="montaza")
    u.add_argument("--postavke", default=None, help="JSON datoteka s postavkama (ključevi iz ZADANO)")
    u.add_argument("--navod", default=None, help="JSON datoteka s meta podacima fotografije (vidi navod_fotografije)")
    u.add_argument("--sirina", type=int, default=1600)
    m = sub.add_parser("maske", help="samo maske neba, vegetacije i tankih struktura za provjeru okom")
    m.add_argument("--foto", required=True)
    m.add_argument("--izlaz", required=True)
    m.add_argument("--sirina", type=int, default=1600)
    z = sub.add_parser("zamuti", help="zamuti pravokutnike (pikseli fotografije) i spremi bez EXIF-a")
    z.add_argument("--ulaz", required=True)
    z.add_argument("--izlaz", required=True)
    z.add_argument("--pravokutnik", action="append", help="x0,y0,x1,y1")
    e = sub.add_parser("bez-exif", help="prepiši sliku bez metapodataka")
    e.add_argument("--ulaz", required=True)
    e.add_argument("--izlaz", required=True)
    a = ap.parse_args(argv)
    if a.naredba == "bez-exif":
        print(json.dumps({"uklonjeno_exif_polja": bez_exif(a.ulaz, a.izlaz), "ima_exif": ima_exif(a.izlaz)}))
        return 0
    if a.naredba == "zamuti":
        spremi(zamuti(ucitaj_sliku(a.ulaz), _pravokutnici(a.pravokutnik)), a.izlaz)
        return 0
    if a.naredba == "maske":
        f = ucitaj_sliku(a.foto)
        H = int(round(f.shape[0] * a.sirina / f.shape[1]))
        f = promijeni_velicinu(f, a.sirina, H)
        _, nebo, ni = maska_neba(np.clip(f, 0, 1))
        veg = maska_vegetacije(f, nebo)
        tan = maska_tankog(f, nebo)
        v = f * 0.45
        v[nebo] = (0.25, 0.45, 0.95)
        v[veg] = (0.2, 0.8, 0.2)
        v[tan] = (0.95, 0.15, 0.1)
        spremi(v, a.izlaz)
        print(json.dumps({"nebo": ni, "vegetacija_udio": round(float(veg.mean()), 4),
                          "tanko_udio": round(float(tan.mean()), 4)}, ensure_ascii=False))
        return 0
    pr = ucitaj_prolaze(a.prolazi)
    post = json.loads(Path(a.postavke).read_text(encoding="utf-8")) if a.postavke else {}
    post.setdefault("sirina", a.sirina)
    meta = json.loads(Path(a.navod).read_text(encoding="utf-8")) if a.navod else {"autor": "nepoznat"}
    rez, info = uklopi(a.foto, pr["koncept"], pr["pokrivenost"], pr["dubina"], maska=pr["maska"],
                       slika_modela=pr["slika"], postojece_maska=pr["postojece_maska"], **post)
    nav = navod_fotografije(meta)
    izl = Path(a.izlaz)
    pod = PODLOGE_MODELA_ISPUNA if info["ispuna"].get("detalj_iz_modela") else PODLOGE_MODELA
    spremi(traka(rez, nav, podloge=pod), izl / f"{a.ime}_vizija.jpg")
    korijen = Path(__file__).resolve().parents[2]
    d = danas(a.foto, rez.shape[1], nav, post.get("zamuti"))
    spremi(danas_vizija(d, rez, nav, podloge=pod), izl / f"{a.ime}_danas_vizija.jpg")  # par: M31 za snimke Grada
    if meta.get("izvor") == "grad" and (izl.resolve() == korijen or korijen in izl.resolve().parents):
        print("snimka Grada: umanjena snimka bez montaže ne sprema se u repo (M21, M31)")
    else:
        spremi(traka(d, navod_fotografije(meta, danas=True), oznaka=OZNAKA_DANAS), izl / f"{a.ime}_danas.jpg")
    spremi_maske(info, izl / f"{a.ime}_maske.png")
    info.pop("maske")
    print(json.dumps(info, ensure_ascii=False, indent=1, default=str))
    return 0


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