#!/usr/bin/env python3
"""Vidljivost: doglednica između dviju točaka i pregled stajališta s kojih se vidi stadion.

AI građanski koncept; izračun je orijentacijski i NIJE dokaz vidljivosti na terenu.

Modeli (research/viz/teren, izrađuje scripts/viz/teren.py):
  dsm  Copernicus GLO-30, model POVRŠINE (krošnje i zgrade), oko 30 m
  dmr  DGU Visine INSPIRE, model RELJEFA (golo tlo), 20 m, na istoj mreži

Zakrivljenost Zemlje i standardna refrakcija: prepreka na udaljenosti s od promatrača, na
doglednici duljine D, prividno je viša za s·(D−s)·(1−k)/(2R); k = 0,13, R = 6 371 000 m.

Tri scenarija za svako stajalište:
  dmr       oko 1,6 m iznad golog tla, zapreka je samo reljef (nužan uvjet)
  dsm_tlo   oko 1,6 m iznad golog tla, zapreke su krošnje i zgrade iz DSM-a (strogo)
  dsm_povrs oko 1,6 m iznad površine DSM-a (kao da se stoji u razini krošnji ili krova)
Zapreke unutar 200 m od cilja se ne broje: ondje su današnji stadion i drveće koje koncept mijenja.

Primjeri:
  python scripts/viz/vidljivost.py dogled --od 45.8993,15.94738 --do 45.8188,16.0179,166.5
  python scripts/viz/vidljivost.py dogled --od 45.85117,15.99015 --do 45.8188,16.0179,128.5 --model dsm --profil 30
  python scripts/viz/vidljivost.py vidikovci
"""
from __future__ import annotations

import argparse
import datetime as dt
import json
import math
import sys
from pathlib import Path

import numpy as np
from PIL import Image, ImageDraw, ImageFont
from pyproj import Geod
from scipy.ndimage import map_coordinates

sys.path.insert(0, str(Path(__file__).resolve().parent))
import teren  # noqa: E402  (zajedničke konstante i čitanje rastera)

R_ZEMLJE = 6371000.0
K_REFR = 0.13
OKO = 1.6
R_CILJ = 200.0  # m; zapreke bliže cilju od ovoga se ne broje
GEOD = Geod(ellps="WGS84")
CILJ = {"naziv": "Stadion (središte)", "lat": 45.8188, "lon": 16.0179,
        "krov": 166.5, "podij": 128.5}
IZVOR_OSM = "OpenStreetMap (ODbL), Overpass zrcalo overpass.private.coffee, stanje baze 28.7.2026., upit 13.11.2026."
# Obvezni navodi licence COP-DEM-GLO-30-F, čl. 6 (b) i 6 (c); idu uz svaku izvedenu sliku i datoteku.
COPERNICUS_OZNAKA = ("produced using Copernicus WorldDEM-30 © DLR e.V. 2010-2014 and © Airbus Defence and Space GmbH 2014-2018 "
                     "provided under COPERNICUS by the European Union and ESA; all rights reserved")
COPERNICUS_ODGOVORNOST = ("The organisations in charge of the Copernicus programme by law or by delegation do not incur any liability "
                          "for any use of the Copernicus WorldDEM-30.")
IZVOR_NOM = "OpenStreetMap (ODbL), Nominatim, upit 13.11.2026."

# naziv, lat, lon, skupina, izvor koordinata, napomena o dostupnosti
STAJALISTA = [
    ("Sljeme, vrh", 45.8993, 15.94738, "Medvednica", "OSM čvor 26864710", "javni planinarski vrh"),
    ("Sljeme, vidikovac kod vrha", 45.8994, 15.94741, "Medvednica", "OSM čvor 1239878102 (tourism=viewpoint)", "javno"),
    ("Gornja postaja žičare", 45.89871, 15.94753, "Medvednica", "OSM put 294928511", "javno; visina terase nije poznata"),
    ("Tomislavov dom", 45.89807, 15.94494, "Medvednica", "OSM čvor 9149504759", "okolica javna"),
    ("Puntijarka, planinarski dom", 45.90359, 15.96905, "Medvednica", "OSM put 106365482", "javno"),
    ("Runolist, planinarski dom", 45.89724, 15.96149, "Medvednica", "OSM put 112535698", "javno"),
    ("Grofica, planinarski dom", 45.89976, 15.95511, "Medvednica", "OSM čvor 830667352", "javno"),
    ("Međupostaja žičare Brestovac", 45.89264, 15.95339, "Medvednica", "OSM put 738515927", "javno"),
    ("Vidikovac (OSM, smjer 135°)", 45.88347, 15.94902, "Medvednica", "OSM čvor 3738671496", "pristup nije provjeren"),
    ("Vidikovac (OSM, smjer 146°)", 45.88661, 15.96612, "Medvednica", "OSM čvor 13787015987", "pristup nije provjeren"),
    ("Vidikovac (OSM) iznad Bliznca", 45.89186, 15.96112, "Medvednica", "OSM čvor 12116637364", "pristup nije provjeren"),
    ("Vidikovac (OSM) ispod vrha", 45.89049, 15.94358, "Medvednica", "OSM čvor 3909421856", "pristup nije provjeren"),
    ("Vidikovac Grafičar", 45.88742, 15.93302, "Medvednica", "OSM čvor 4994460221", "javno"),
    ("Vidikovac (OSM) 45,881 N", 45.88103, 15.97038, "Medvednica", "OSM čvor 731423209", "pristup nije provjeren"),
    ("Vidikovac kod Strmopeći", 45.87766, 15.98026, "Medvednica", "OSM čvor 785928160", "pristup nije provjeren"),
    ("Medvedgrad", 45.86953, 15.94073, "Medvednica", "OSM put 105590473 (težište)", "javno; visina zidina nije uračunata"),
    ("Donja postaja žičare", 45.86097, 15.98249, "Podsljeme", "OSM put 744354768", "javno"),
    ("Remete, crkva", 45.85117, 15.99015, "Remete", "OSM put 148627694 (težište)", "javno"),
    ("Remete, groblje", 45.85272, 15.98805, "Remete", "OSM put 148627387 (težište)", "javno"),
    ("Gornji Bukovac (oznaka naselja)", 45.84446, 16.00890, "Bukovac", "OSM čvor 1736747786; " + IZVOR_NOM, "ulica; točka nije vidikovac"),
    ("Jazbina (oznaka četvrti)", 45.84704, 16.01715, "Jazbina", "OSM čvor 9214804685; " + IZVOR_NOM, "ulica; točka nije vidikovac"),
    ("Mirogoj, groblje", 45.83788, 15.98785, "Mirogoj", "OSM put 780197364 (težište)", "javno"),
    ("Groblje Markuševec", 45.87365, 16.01324, "Markuševec", "OSM put 104989806 (težište)", "javno"),
    ("Groblje Miroševac", 45.84472, 16.04257, "Dubrava", "OSM put 43563376 (težište)", "javno"),
    ("Ljetnikovac biskupa Haulika (park)", 45.82499, 16.02739, "Park Maksimir", "OSM put 110368320 (težište)", "javni park"),
    ("Park Maksimir, rub od Ravnica", 45.82208, 16.02761, "Park Maksimir", IZVOR_NOM + " (pješačka staza)", "javni park"),
    ("Ravnice, ulica uz Maksimirsku", 45.82059, 16.02871, "Ravnice", IZVOR_NOM, "javna ulica"),
    ("Glavni ulaz u park", 45.8195, 16.01479, "Park Maksimir", IZVOR_NOM, "javno"),
]
PODRUCJA = [  # naziv, lat, lon, polumjer (m) ili None za uvjet po koti
    ("Medvednica iznad 600 m", None, None, None),
    ("Remete (900 m oko crkve)", 45.85117, 15.99015, 900.0),
    ("Bukovac (900 m oko oznake Gornji Bukovac)", 45.84446, 16.00890, 900.0),
    ("Jazbina (900 m oko oznake četvrti)", 45.84704, 16.01715, 900.0),
]
KLASE = {
    0: "teren zaklanja (ni po golom tlu)",
    1: "samo po golom tlu: na doglednici su krošnje ili zgrade iz DSM-a",
    2: "s razine krošnji ili krova (DSM + 1,6 m); s tla nepouzdano",
    3: "s tla (oko 1,6 m iznad golog tla, uz krošnje i zgrade iz DSM-a)",
}
OGRADA = (
    "DSM ima oko 30 m i nosi krošnje i zgrade iz razdoblja 2010.–2015.; DMR ima 20 m i ne vidi "
    "nasipe, zidove ni ograde. Pod drvećem, među kućama i na rubu čistine zazor NIJE pouzdan: "
    "pojedino stablo ili zgrada između dviju ćelija može zakloniti ili otvoriti pogled. "
    "Cilj je jedna točka u središtu stadiona, a ne cijeli prsten krova. Svako stajalište treba "
    "potvrditi obilaskom i fotografijom."
)


# ---------------------------------------------------------------- modeli
class Model:
    def __init__(self, mapa: Path, ime: str):
        self.meta = json.loads((mapa / f"{ime}.json").read_text(encoding="utf-8"))
        self.h = teren.ucitaj_visine(mapa / f"{ime}.png")
        m = self.meta["mreza"]
        self.lon0, self.lat0, self.korak = m["lon_min"], m["lat_max"], m["korak_stupnjevi"]
        self.lon1, self.lat1 = m["lon_max"], m["lat_min"]

    def __call__(self, lon, lat) -> np.ndarray:
        c = (np.asarray(lon, float) - self.lon0) / self.korak
        r = (self.lat0 - np.asarray(lat, float)) / self.korak
        return map_coordinates(self.h, [r, c], order=1, mode="constant", cval=np.nan)

    def mreza(self):
        nr, nc = self.h.shape
        return np.meshgrid(self.lon0 + np.arange(nc) * self.korak, self.lat0 - np.arange(nr) * self.korak)


def ucitaj_modele(mapa: Path) -> tuple[Model, Model]:
    return Model(mapa, "dem_regija_glo30"), Model(mapa, "dmr_regija_dgu20")


# ---------------------------------------------------------------- doglednica
def dogled(povrsina, od, kota_oka: float, do, kota_cilja: float, k: float = K_REFR,
           korak: float = 10.0, r_cilj: float = R_CILJ) -> dict:
    """Najmanji zazor doglednice iznad zadane plohe (funkcija lon, lat -> kota).
    od, do = (lat, lon). Pozitivan zazor = slobodno; negativan = ploha je iznad doglednice."""
    az, _, D = GEOD.inv(od[1], od[0], do[1], do[0])
    n = max(2, int(D // korak))
    s = np.linspace(0.0, D, n + 1)[1:-1]
    lon, lat, _ = GEOD.fwd(np.full(s.shape, od[1]), np.full(s.shape, od[0]), np.full(s.shape, az), s)
    h = povrsina(lon, lat)
    izbocina = s * (D - s) * (1 - k) / (2 * R_ZEMLJE)
    linija = kota_oka + (kota_cilja - kota_oka) * s / D
    zazor = linija - (h + izbocina)
    broji = (s <= D - r_cilj) & np.isfinite(zazor)
    if not broji.any():
        return {"D": D, "azimut": az % 360, "zazor": float("inf"), "na_m": None, "s": s, "h": h,
                "linija": linija, "izbocina": izbocina, "zazor_profil": zazor}
    i = int(np.argmin(np.where(broji, zazor, np.inf)))
    # najniža kota oka s koje je doglednica slobodna (linearno po svakoj zapreci)
    u = s[broji] / D
    potrebna = float(np.max((h[broji] + izbocina[broji] - kota_cilja * u) / (1 - u)))
    return {"D": float(D), "azimut": float(az % 360), "zazor": float(zazor[i]), "na_m": float(s[i]),
            "kota_zapreke": float(h[i]), "potrebna_kota_oka": potrebna, "s": s, "h": h, "linija": linija,
            "izbocina": izbocina, "zazor_profil": zazor}


def scenariji(dsm: Model, dmr: Model, od, kota_cilja: float, cilj=CILJ, k: float = K_REFR) -> dict:
    do = (cilj["lat"], cilj["lon"])
    tlo = float(dmr([od[1]], [od[0]])[0])
    pov = float(dsm([od[1]], [od[0]])[0])

    def zapreke(lon, lat):  # krošnje i zgrade, ali nikad niže od golog tla
        return np.fmax(dsm(lon, lat), dmr(lon, lat))

    out = {}
    for ime, ploha, oko in (("dmr", dmr, tlo + OKO), ("dsm_tlo", zapreke, tlo + OKO),
                            ("dsm_povrs", zapreke, max(pov, tlo) + OKO)):
        d = dogled(ploha, od, oko, do, kota_cilja, k)
        out[ime] = {"zazor_m": round(d["zazor"], 1), "na_m_od_promatraca": None if d["na_m"] is None else round(d["na_m"]),
                    "kota_oka": round(oko, 1)}
        if ime != "dsm_povrs" and "potrebna_kota_oka" in d:
            out[ime]["potrebna_visina_oka_iznad_tla_m"] = round(max(0.0, d["potrebna_kota_oka"] - tlo), 1)
        out["_D"], out["_az"] = d["D"], d["azimut"]
    out["_tlo"], out["_pov"] = tlo, pov
    z, na = out["dmr"]["zazor_m"], out["dmr"]["na_m_od_promatraca"]
    out["_rubno"] = bool(na is not None and na <= 150 and -10.0 < z < 3.0)
    return out


def klasa(sc: dict) -> int:
    if sc["dmr"]["zazor_m"] < 0:
        return 0
    if sc["dsm_tlo"]["zazor_m"] >= 0:
        return 3
    if sc["dsm_povrs"]["zazor_m"] >= 0:
        return 2
    return 1


# ---------------------------------------------------------------- polje vidljivosti od cilja
def polje(dsm: Model, dmr: Model, kota_cilja: float, cilj=CILJ, k: float = K_REFR,
          ds: float = 15.0, n_az: int = 5400, r_cilj: float = R_CILJ) -> dict:
    """Za svaku ćeliju regionalne mreže: koliko visoko iznad tla (ili površine) mora biti oko da vidi cilj.
    Radijalni prelet od cilja; uzajamnost doglednice vrijedi jer se računa ista ravna zraka."""
    LO, LA = dsm.mreza()
    az_c, _, d_c = GEOD.inv(np.full(LO.shape, cilj["lon"]), np.full(LO.shape, cilj["lat"]), LO, LA)
    n_s = int(math.ceil(float(d_c.max()) / ds)) + 1
    s = ds * (np.arange(n_s) + 1.0)
    th = 360.0 * np.arange(n_az) / n_az
    S, TH = np.meshgrid(s, th)
    lon, lat, _ = GEOD.fwd(np.full(S.shape, cilj["lon"]), np.full(S.shape, cilj["lat"]), TH, S)
    pad = S ** 2 * (1 - k) / (2 * R_ZEMLJE)  # pad ispod tangentne ravnine u cilju
    tlo = dmr(lon, lat) - pad
    zap = np.fmax(dsm(lon, lat), dmr(lon, lat)) - pad

    def prag(ploha):  # najveći nagib zrake koju zapreke prije te točke još zaklanjaju
        nag = np.where((S >= r_cilj) & np.isfinite(ploha), (ploha - kota_cilja) / S, -np.inf)
        m = np.maximum.accumulate(nag, axis=1)
        return np.concatenate([np.full((n_az, 1), -np.inf), m[:, :-1]], axis=1)

    m_zap, m_tlo = prag(zap), prag(tlo)
    with np.errstate(invalid="ignore"):
        potrebno = {
            "dmr": kota_cilja + S * m_tlo - tlo,          # iznad golog tla, zapreka samo reljef
            "dsm_tlo": kota_cilja + S * m_zap - tlo,      # iznad golog tla, zapreke iz DSM-a
            "dsm_povrs": kota_cilja + S * m_zap - zap,    # iznad površine DSM-a
        }
    i_az = np.round((az_c % 360.0) / (360.0 / n_az)).astype(int) % n_az
    i_s = np.clip(np.round(d_c / ds).astype(int) - 1, 0, n_s - 1)
    out = {}
    for ime, p in potrebno.items():
        g = p[i_az, i_s]
        g = np.where(np.isnan(g), np.inf, g)
        out[ime] = np.where(d_c < ds, -np.inf, g)  # visina oka potrebna za pogled (m); <= 1,6 znači vidljivo
    kl = np.zeros(LO.shape, np.uint8)
    kl[out["dmr"] <= OKO] = 1
    kl[(out["dmr"] <= OKO) & (out["dsm_povrs"] <= OKO)] = 2
    kl[(out["dmr"] <= OKO) & (out["dsm_tlo"] <= OKO)] = 3
    return {"klasa": kl, "potrebno": out, "udaljenost": d_c, "azimut_od_cilja": az_c % 360.0}


# ---------------------------------------------------------------- crtanje
BOJE = {1: (235, 140, 30), 2: (245, 225, 60), 3: (40, 200, 90)}


def _font(v: int):
    try:
        return ImageFont.truetype("DejaVuSans.ttf", v)
    except OSError:
        return ImageFont.load_default()


def slika(dmr: Model, polja: dict, stajalista: list[dict], put: Path, cilj=CILJ):
    kx, ky = teren.KX_TOCNO / 3600, teren.KY_TOCNO / 3600
    sj = teren.sjencanje(dmr.h, kx, ky)
    nr, nc = dmr.h.shape
    mj = 1.65
    W, H = int(nc * mj), int(nr * mj * ky / kx)
    rub, vrh, dno = 14, 64, 166
    platno = Image.new("RGB", (2 * W + 3 * rub, H + vrh + dno), (255, 255, 255))
    d = ImageDraw.Draw(platno)
    f, fm, fv = _font(15), _font(12), _font(20)
    d.text((rub, 8), "Odakle se vidi stadion: izračun vidljivosti na visinskim modelima", font=fv, fill=(0, 0, 0))
    d.text((rub, 36), "AI građanski koncept · orijentacijski izračun, nije dokaz vidljivosti na terenu", font=f, fill=(150, 30, 30))

    def u_px(lon, lat):
        return ((lon - dmr.lon0) / dmr.korak * mj, (dmr.lat0 - lat) / dmr.korak * mj * ky / kx)

    for j, (kljuc, naslov) in enumerate((("krov", f"Vrh krova, {cilj['krov']} m n. v."), ("podij", f"Podij, {cilj['podij']} m n. v."))):
        kl = polja[kljuc]["klasa"]
        siva = 70 + 150 * sj
        rgb = np.stack([siva, siva, siva], -1)
        for v, b in BOJE.items():
            m = kl == v
            rgb[m] = 0.45 * rgb[m] + 0.55 * np.array(b)
        im = Image.fromarray(np.clip(rgb, 0, 255).astype(np.uint8)).resize((W, H), Image.BILINEAR)
        x0 = rub + j * (W + rub)
        platno.paste(im, (x0, vrh))
        d.rectangle([x0, vrh, x0 + W, vrh + H], outline=(0, 0, 0))
        d.text((x0 + 8, vrh + 6), naslov, font=f, fill=(255, 255, 255), stroke_width=2, stroke_fill=(0, 0, 0))
        cx, cy = u_px(cilj["lon"], cilj["lat"])
        d.ellipse([x0 + cx - 7, vrh + cy - 7, x0 + cx + 7, vrh + cy + 7], fill=(220, 20, 20), outline=(255, 255, 255), width=2)
        for i, sv in enumerate(stajalista, 1):
            px, py = u_px(sv["lon"], sv["lat"])
            b = BOJE.get(sv[f"klasa_{kljuc}"], (120, 120, 120))
            d.ellipse([x0 + px - 5, vrh + py - 5, x0 + px + 5, vrh + py + 5], fill=b, outline=(0, 0, 0))
            d.text((x0 + px + 6, vrh + py - 8), str(i), font=fm, fill=(255, 255, 255), stroke_width=2, stroke_fill=(0, 0, 0))
        # mjerilo 2 km
        duz = 2000 / kx * mj
        d.line([x0 + W - 20 - duz, vrh + H - 16, x0 + W - 20, vrh + H - 16], fill=(255, 255, 255), width=4)
        d.text((x0 + W - 20 - duz, vrh + H - 36), "2 km", font=fm, fill=(255, 255, 255), stroke_width=2, stroke_fill=(0, 0, 0))
    y = vrh + H + 10
    stavke = [((40, 200, 90), "s tla: oko 1,6 m iznad golog tla, uz krošnje i zgrade iz DSM-a"),
              ((245, 225, 60), "s razine krošnji ili krova (DSM + 1,6 m); s tla nepouzdano"),
              ((235, 140, 30), "samo po golom tlu: na doglednici su krošnje ili zgrade"),
              ((150, 150, 150), "sivo: reljef zaklanja cilj")]
    for i, (b, t) in enumerate(stavke):
        d.rectangle([rub, y + i * 22, rub + 26, y + i * 22 + 15], fill=b, outline=(0, 0, 0))
        d.text((rub + 34, y + i * 22 - 1), t, font=f, fill=(0, 0, 0))
    x2 = rub + W + rub
    d.text((x2, y), "Crvena točka: cilj (45,8188° N, 16,0179° E). Brojevi: stajališta iz vidljivost.json.", font=fm, fill=(0, 0, 0))
    d.text((x2, y + 18), "Zakrivljenost Zemlje i refrakcija k = 0,13. Zapreke do 200 m od cilja se ne broje.", font=fm, fill=(0, 0, 0))
    d.text((x2, y + 36), "DSM nosi krošnje i zgrade (2010.–2015.): pod drvećem zazor nije pouzdan.", font=fm, fill=(150, 30, 30))
    d.text((x2, y + 58), "Podaci: produced using Copernicus WorldDEM-30 © DLR e.V. 2010-2014 and © Airbus Defence and", font=fm, fill=(60, 60, 60))
    d.text((x2, y + 74), "Space GmbH 2014-2018 provided under COPERNICUS by the European Union and ESA; all rights reserved.", font=fm, fill=(60, 60, 60))
    d.text((x2, y + 90), COPERNICUS_ODGOVORNOST, font=fm, fill=(60, 60, 60))
    d.text((x2, y + 106), "DGU, Visine INSPIRE: sadrži informacije tijela javne vlasti u skladu s Otvorenom dozvolom.", font=fm, fill=(60, 60, 60))
    d.text((x2, y + 122), "Stajališta: © OpenStreetMap contributors (ODbL).", font=fm, fill=(60, 60, 60))
    platno.save(put, optimize=True)


# ---------------------------------------------------------------- načini rada
def nacin_dogled(a):
    dsm, dmr = ucitaj_modele(Path(a.modeli))
    od = tuple(float(v) for v in a.od.split(","))
    do = tuple(float(v) for v in a.do.split(","))
    if len(do) != 3:
        sys.exit("--do traži lat,lon,kota")
    tlo, pov = float(dmr([od[1]], [od[0]])[0]), float(dsm([od[1]], [od[0]])[0])
    if a.kota_oka is not None:
        oko = a.kota_oka
    else:
        oko = (max(pov, tlo) if a.model == "dsm-povrs" else tlo) + a.oko

    def zapreke(lon, lat):
        return np.fmax(dsm(lon, lat), dmr(lon, lat))

    ploha = dmr if a.model == "dmr" else zapreke
    d = dogled(ploha, od[:2], oko, do[:2], do[2], a.k, a.korak, a.r_cilj)
    print(f"Promatrač {od[0]:.5f} N, {od[1]:.5f} E: tlo (DMR) {tlo:.1f} m, površina (DSM) {pov:.1f} m, oko {oko:.1f} m n. v.")
    print(f"Cilj      {do[0]:.5f} N, {do[1]:.5f} E: {do[2]:.1f} m n. v.")
    print(f"Udaljenost {d['D']:.0f} m, azimut prema cilju {d['azimut']:.1f}°, kut visine "
          f"{math.degrees(math.atan2(do[2] - oko, d['D'])):+.2f}°; model: {a.model}; k = {a.k}")
    print(f"Pad zbog zakrivljenosti i refrakcije na cijeloj duljini: {d['D'] ** 2 * (1 - a.k) / (2 * R_ZEMLJE):.2f} m")
    if d["na_m"] is None:
        print("Nema uzoraka izvan zone cilja; zazor nije računat.")
    else:
        print(f"Najmanji zazor: {d['zazor']:+.1f} m na {d['na_m']:.0f} m od promatrača (kota plohe {d['kota_zapreke']:.1f} m) "
              f"-> {'SLOBODNO' if d['zazor'] >= 0 else 'ZAKLONJENO'} na ovom modelu")
        print(f"Najniža kota oka za slobodnu doglednicu: {d['potrebna_kota_oka']:.1f} m n. v. "
              f"({max(0.0, d['potrebna_kota_oka'] - tlo):.1f} m iznad golog tla)")
    print(OGRADA)
    if a.profil:
        print(f"\n{'s (m)':>8} {'ploha':>8} {'izbočina':>9} {'doglednica':>11} {'zazor':>8}")
        idx = np.unique(np.linspace(0, len(d["s"]) - 1, a.profil).astype(int))
        for i in idx:
            zvj = "  (zona cilja, ne broji se)" if d["s"][i] > d["D"] - a.r_cilj else ""
            print(f"{d['s'][i]:8.0f} {d['h'][i]:8.1f} {d['izbocina'][i]:9.2f} {d['linija'][i]:11.1f} {d['zazor_profil'][i]:+8.1f}{zvj}")


def nacin_vidikovci(a):
    mapa, izlaz = Path(a.modeli), Path(a.izlaz)
    dsm, dmr = ucitaj_modele(mapa)
    polja = {kljuc: polje(dsm, dmr, CILJ[kljuc]) for kljuc in ("krov", "podij")}
    stajalista = []
    for naziv, lat, lon, skupina, izvor, dostupnost in STAJALISTA:
        sv = {"naziv": naziv, "skupina": skupina, "lat": lat, "lon": lon, "izvor_koordinata": izvor,
              "dostupnost": dostupnost}
        for kljuc in ("krov", "podij"):
            sc = scenariji(dsm, dmr, (lat, lon), CILJ[kljuc])
            if kljuc == "krov":
                sv.update({"kota_tla_dmr": round(sc["_tlo"], 1), "kota_povrsine_dsm": round(sc["_pov"], 1),
                           "udaljenost_m": round(sc["_D"]), "azimut_prema_cilju": round(sc["_az"], 1),
                           "kut_visine_krova_st": round(math.degrees(math.atan2(CILJ["krov"] - sc["_tlo"] - OKO, sc["_D"])), 2)})
            sv[f"klasa_{kljuc}"] = klasa(sc)
            sv[f"ocjena_{kljuc}"] = KLASE[klasa(sc)]
            sv[f"rubno_{kljuc}"] = sc["_rubno"]
            sv[f"zazor_{kljuc}"] = {k: v for k, v in sc.items() if not k.startswith("_")}
        stajalista.append(sv)
    # područja: udjeli klasa i najbolje izračunate ćelije
    LO, LA = dsm.mreza()
    podrucja = []
    for naziv, lat, lon, r in PODRUCJA:
        if r is None:
            maska = dmr.h > 600.0
        else:
            _, _, dd = GEOD.inv(np.full(LO.shape, lon), np.full(LO.shape, lat), LO, LA)
            maska = dd <= r
        zapis = {"naziv": naziv, "broj_celija": int(maska.sum())}
        for kljuc in ("krov", "podij"):
            kl = polja[kljuc]["klasa"][maska]
            zapis[f"udio_klasa_{kljuc}_posto"] = {KLASE[v]: round(100.0 * float((kl == v).mean()), 1) for v in (3, 2, 1, 0)}
        # do 5 ćelija klase 3 za krov s najvećom rezervom, međusobno udaljenih barem 250 m
        rez = OKO - polja["krov"]["potrebno"]["dsm_tlo"]
        # samo ćelije na kojima se DSM i DMR slažu unutar 3 m (otvoreno tlo, bez krošnje i bez nesuglasja modela)
        slozno = np.abs(dsm.h - dmr.h) <= 3.0
        kand = np.argwhere(maska & slozno & (polja["krov"]["klasa"] == 3) & np.isfinite(rez) & (rez < 500))
        kand = sorted(kand.tolist(), key=lambda rc: -rez[rc[0], rc[1]])
        odabrane = []
        for rr, cc in kand:
            if all(GEOD.inv(LO[rr, cc], LA[rr, cc], o["lon"], o["lat"])[2] >= 250 for o in odabrane):
                odabrane.append({"lat": round(float(LA[rr, cc]), 5), "lon": round(float(LO[rr, cc]), 5),
                                 "kota_tla_dmr": round(float(dmr.h[rr, cc]), 1),
                                 "krosnja_ili_zgrada_m": round(float(dsm.h[rr, cc] - dmr.h[rr, cc]), 1),
                                 "udaljenost_m": round(float(polja["krov"]["udaljenost"][rr, cc])),
                                 "azimut_prema_cilju": round(float((polja["krov"]["azimut_od_cilja"][rr, cc] + 180) % 360), 1),
                                 "rezerva_visine_oka_m": round(float(rez[rr, cc]), 1),
                                 "vidi_podij_s_tla": bool(polja["podij"]["klasa"][rr, cc] == 3)})
            if len(odabrane) == 5:
                break
        zapis["izracunate_celije_krov_s_tla"] = odabrane
        zapis["napomena"] = ("Izračunate ćelije (DSM i DMR se slažu unutar 3 m) nisu provjerena javna stajališta; "
                             "dostupnost i stvarni pogled treba provjeriti na terenu.")
        podrucja.append(zapis)
    # raster klasa: vrijednost = klasa_krov + 4 * klasa_podij
    kod = (polja["krov"]["klasa"] + 4 * polja["podij"]["klasa"]).astype(np.uint8)
    Image.fromarray(kod).save(izlaz / "vidljivost_klase.png", optimize=True)
    slika(dmr, polja, stajalista, izlaz / "vidljivost.png")
    out = {
        "opis": "Vidljivost stadiona s javnih stajališta i po područjima; orijentacijski izračun",
        "status": "PRETPOSTAVKA-IZRAČUN; nije dokaz vidljivosti na terenu",
        "datum": dt.date.today().isoformat(),
        "cilj": {**CILJ, "napomena": "vrh krova 166,5 m n. v. je PRETPOSTAVKA iz montaže (docs/20); podij +128,5 odluka M2; "
                                     "cilj je jedna točka, ne prsten krova"},
        "metoda": {
            "modeli": {"dsm": dsm.meta["izvor"], "dmr": dmr.meta["izvor"]},
            "zakrivljenost_i_refrakcija": f"prividno izdizanje zapreke s*(D-s)*(1-k)/(2R), k = {K_REFR}, R = {R_ZEMLJE:.0f} m",
            "visina_oka_m": OKO, "zona_cilja_bez_zapreka_m": R_CILJ,
            "scenariji": {"dmr": "oko iznad golog tla, zapreka samo reljef",
                          "dsm_tlo": "oko iznad golog tla, zapreke krošnje i zgrade (max(DSM, DMR))",
                          "dsm_povrs": "oko iznad površine DSM-a, zapreke krošnje i zgrade"},
            "klase": {str(k): v for k, v in KLASE.items()},
            "polje": "radijalni prelet od cilja, korak 15 m, 5400 smjerova; vrijednost u najbližem uzorku",
            "raster_klasa": "vidljivost_klase.png, mreža kao dem_regija_glo30.png; vrijednost = klasa_krov + 4*klasa_podij",
            "zazor": "najmanja visina doglednice iznad plohe (m); negativno = zaklonjeno; na_m_od_promatraca = mjesto najmanjeg zazora",
            "potrebna_visina_oka_iznad_tla_m": "najmanja visina oka iznad golog tla s koje je doglednica slobodna (npr. terasa, toranj)",
            "rubno": "true ako je zazor po golom tlu između -10 i +3 m, a odlučuje se unutar 150 m od promatrača: "
                     "ishod ovisi o točnom mjestu stajanja i mikroreljefu koji modeli 20-30 m ne razlučuju",
            "tocka_naspram_polja": "tablica stajališta računa se točkasto (korak 10 m) i mjerodavnija je od polja; "
                                   "na rubnim mjestima polje i točka mogu dati različitu klasu",
        },
        "ograda": OGRADA,
        "izvor_stajalista": IZVOR_OSM,
        "navodi": [COPERNICUS_OZNAKA + ". " + COPERNICUS_ODGOVORNOST,
                   "Sadrži informacije tijela javne vlasti u skladu s Otvorenom dozvolom (https://data.gov.hr/otvorena-dozvola). Izvor: Državna geodetska uprava, Visine INSPIRE. Izmijenjeno.",
                   "© OpenStreetMap contributors (ODbL)"],
        "stajalista": stajalista,
        "podrucja": podrucja,
    }
    (izlaz / "vidljivost.json").write_text(json.dumps(out, ensure_ascii=False, indent=1) + "\n", encoding="utf-8")
    print(f"{'#':>2} {'stajalište':36s} {'tlo':>6} {'D (m)':>6} {'az':>5}  krov: {'dmr':>7} {'dsm_tlo':>8} {'dsm_pov':>8}  podij: {'dmr':>7} {'dsm_tlo':>8} {'dsm_pov':>8}")
    for i, sv in enumerate(stajalista, 1):
        zk, zp = sv["zazor_krov"], sv["zazor_podij"]
        print(f"{i:2d} {sv['naziv'][:36]:36s} {sv['kota_tla_dmr']:6.0f} {sv['udaljenost_m']:6d} {sv['azimut_prema_cilju']:5.0f}  "
              f"   K{sv['klasa_krov']} {zk['dmr']['zazor_m']:+7.1f} {zk['dsm_tlo']['zazor_m']:+8.1f} {zk['dsm_povrs']['zazor_m']:+8.1f}  "
              f"    K{sv['klasa_podij']} {zp['dmr']['zazor_m']:+7.1f} {zp['dsm_tlo']['zazor_m']:+8.1f} {zp['dsm_povrs']['zazor_m']:+8.1f}")
    for p in podrucja:
        print(p["naziv"], "| krov:", p["udio_klasa_krov_posto"])
    print("Zapisano:", izlaz / "vidljivost.json", izlaz / "vidljivost.png", izlaz / "vidljivost_klase.png")


def main(argv=None):
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    sub = ap.add_subparsers(dest="nacin", required=True)
    p = sub.add_parser("dogled", help="doglednica između dviju točaka, s profilom")
    p.add_argument("--od", required=True, help="promatrač: lat,lon")
    p.add_argument("--do", required=True, help="cilj: lat,lon,kota (m n. v.)")
    p.add_argument("--oko", type=float, default=OKO, help="visina oka iznad tla ili površine (m)")
    p.add_argument("--kota-oka", type=float, default=None, help="apsolutna kota oka (m n. v.); nadjačava --oko")
    p.add_argument("--model", choices=["dmr", "dsm", "dsm-povrs"], default="dsm",
                   help="dmr: samo reljef; dsm: oko nad tlom, zapreke iz DSM-a; dsm-povrs: oko nad površinom DSM-a")
    p.add_argument("--k", type=float, default=K_REFR)
    p.add_argument("--korak", type=float, default=10.0)
    p.add_argument("--r-cilj", type=float, default=R_CILJ, help="zona oko cilja u kojoj se zapreke ne broje (m)")
    p.add_argument("--profil", type=int, default=0, help="broj redaka profila za ispis")
    p.add_argument("--modeli", default=str(teren.IZLAZ))
    p.set_defaults(f=nacin_dogled)
    p = sub.add_parser("vidikovci", help="polje vidljivosti i tablica stajališta")
    p.add_argument("--modeli", default=str(teren.IZLAZ))
    p.add_argument("--izlaz", default=str(teren.IZLAZ))
    p.set_defaults(f=nacin_vidikovci)
    a = ap.parse_args(argv)
    a.f(a)


if __name__ == "__main__":
    main()
