#!/usr/bin/env python3
"""Teren za prikaze: visinski modeli i ortofoto, ponovljivo, s predmemorijom.

AI građanski koncept; podaci su orijentacijski, nisu geodetska podloga.

Koraci (--koraci, zarezom odvojeni; zadano: svi):
  dem       regionalni model površine Copernicus GLO-30 (DSM, oko 30 m)
  dmr       regionalni model reljefa DGU INSPIRE Visine (DTM, 20 m), ista mreža
  blizu     bliski modeli u lokalnom ENU, korak 5 m (bilinearno iz gornjih)
  ortofoto  bliski mozaik (DGU DOF 2024, WMS za anonimne korisnike) i
            regionalni mozaik (EOX Sentinel-2 cloudless 2016)
  reljef    sjenčani reljef za vizualnu provjeru
  kontrola  kontrolne kote i usporedba dvaju modela
  manifest  manifest.json (datoteka, izvor, licenca, atribucija, datum, sha256)

Primjeri:
  python scripts/viz/teren.py --cache ~/.cache/viz-teren
  python scripts/viz/teren.py --proba --cache /tmp/x --izlaz /tmp/y   # mali isječak

Sirove datoteke (GeoTIFF, WMS odgovori) ostaju u predmemoriji izvan repoa.
Licence i doslovni citati uvjeta: research/viz/teren/IZVORI.md.
"""
from __future__ import annotations

import argparse
import datetime as dt
import hashlib
import json
import math
import os
import re
import struct
import sys
import time
import zlib
from pathlib import Path
from urllib.parse import urlencode, urlparse

import numpy as np
import requests
from PIL import Image
from pyproj import Transformer
from scipy.ndimage import map_coordinates

Image.MAX_IMAGE_PIXELS = None

# --- zajedničke konvencije (research/viz/README.md, scripts/viz/gradi_site.py) ---
LAT0, LON0 = 45.8187, 16.0185
KX = math.cos(math.radians(LAT0)) * 111320.0  # m po stupnju dužine
KY = 110574.0  # m po stupnju širine (konstanta iz README-a)
REGIJA = (15.90, 45.78, 16.08, 45.92)  # lon_min, lat_min, lon_max, lat_max
BLIZU_POLA = 2000.0  # m, bliski visinski model: ±2 km
BLIZU_KORAK = 5.0
ORTO_POLA = 1500.0  # m, bliski ortofoto: ±1,5 km
ORTO_PX = 0.5  # m/px
UA = "viz-research/1.0 (pretraga slobodno licenciranih slika i otvorenih geopodataka)"
REPO = Path(__file__).resolve().parents[2]
IZLAZ = REPO / "research" / "viz" / "teren"

NAPOMENA_DSM = (
    "Model POVRŠINE (DSM): uključuje krošnje i zgrade, nije golo tlo. "
    "Rezolucija oko 30 m; u šumi i među zgradama kota je iznad tla."
)
NAPOMENA_DTM = (
    "Model RELJEFA (DTM): golo tlo bez krošnji i zgrada. Mreža 20 m, izvorni DMR "
    "iz fotogrametrije; sitni oblici (nasipi, usjeci, zidovi) nisu prikazani."
)

IZVORI = {
    "glo30": {
        "naziv": "Copernicus DEM GLO-30 Public (COG na AWS Open Data)",
        "url": "https://copernicus-dem-30m.s3.amazonaws.com/readme.html",
        "licenca": "Licence for Copernicus DEM instance COP-DEM-GLO-30-F Global 30m Full, Free & Open",
        "licenca_url": "https://docs.sentinel-hub.com/api/latest/static/files/data/dem/resources/license/License-COPDEM-30.pdf",
        "atribucija": (
            "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. 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."
        ),
    },
    "dgu_dmr": {
        "naziv": "DGU, Visine INSPIRE (EL-COV, DTM 20 m), ATOM usluga preuzimanja",
        "url": "https://geoportal.dgu.hr/services/atom/el-cov/xml",
        "licenca": "Otvorena dozvola (NN 67/2017, Prilog I.)",
        "licenca_url": "https://data.gov.hr/otvorena-dozvola",
        "atribucija": (
            "Sadrži informacije tijela javne vlasti u skladu s Otvorenom dozvolom "
            "(https://data.gov.hr/otvorena-dozvola). Izvor: Državna geodetska uprava, Visine INSPIRE "
            "(https://geoportal.dgu.hr/services/atom/el-cov/xml). Izmijenjeno: isječak, preuzorkovanje, "
            "zapis u 16-bitni PNG."
        ),
    },
    "dgu_dof": {
        "naziv": "DGU, Digitalni ortofoto 2024. – WMS za anonimne korisnike",
        "url": "https://geoportal.dgu.hr/services/inspire/orthophoto_2024/wms?service=WMS&request=GetCapabilities",
        "licenca": "Otvorena dozvola (NN 67/2017, Prilog I.)",
        "licenca_url": "https://data.gov.hr/otvorena-dozvola",
        "atribucija": (
            "Sadrži informacije tijela javne vlasti u skladu s Otvorenom dozvolom "
            "(https://data.gov.hr/otvorena-dozvola). Izvor: Državna geodetska uprava, Digitalni ortofoto "
            "2024. (https://geoportal.dgu.hr/services/inspire/orthophoto_2024/wms). Izmijenjeno: mozaik, "
            "preslikavanje u lokalnu mrežu, JPEG. Vodeni žig usluge nije uklanjan."
        ),
    },
    "eox_s2": {
        "naziv": "EOX Sentinel-2 cloudless 2016 (sloj s2cloudless)",
        "url": "https://tiles.maps.eox.at/wmts/1.0.0/WMTSCapabilities.xml",
        "licenca": "Creative Commons Attribution 4.0 International (CC BY 4.0)",
        "licenca_url": "https://creativecommons.org/licenses/by/4.0/",
        "atribucija": (
            "EOxCloudless https://cloudless.eox.at by EOX IT Services GmbH (Contains modified "
            "Copernicus Sentinel data 2016), CC BY 4.0. Izmijenjeno: isječak."
        ),
    },
    "izvedeno": {
        "naziv": "Izvedeno ovom obradom iz gornjih izvora",
        "url": "scripts/viz/teren.py, scripts/viz/vidljivost.py",
        "licenca": "kao izvorni podaci (Copernicus WorldDEM-30 licenca; Otvorena dozvola; CC BY 4.0)",
        "licenca_url": "",
        "atribucija": "vidi IZVORI.md; atribucije izvora vrijede i za izvedene slike",
    },
}


def log(*a):
    print("[teren]", *a, flush=True)


# ---------------------------------------------------------------- mreža
_zadnji: dict[str, float] = {}


def dohvati(url: str, put: Path, timeout: int = 300, params: dict | None = None) -> Path:
    """Preuzmi u predmemoriju ako već ne postoji; najviše 1 zahtjev u sekundi po poslužitelju."""
    put = Path(put)
    if put.exists() and put.stat().st_size > 0:
        return put
    put.parent.mkdir(parents=True, exist_ok=True)
    host = urlparse(url).netloc
    cekaj = 1.05 - (time.time() - _zadnji.get(host, 0.0))
    if cekaj > 0:
        time.sleep(cekaj)
    puni = url + ("&" if "?" in url else "?") + urlencode(params) if params else url
    for pokusaj in range(3):
        try:
            r = requests.get(puni, headers={"User-Agent": UA}, timeout=timeout)
            _zadnji[host] = time.time()
            if r.status_code == 200:
                break
            log(f"HTTP {r.status_code} za {host}, pokušaj {pokusaj + 1}")
        except requests.RequestException as e:  # prekid veze: pričekaj i ponovi
            log(f"greška veze ({host}): {e.__class__.__name__}, pokušaj {pokusaj + 1}")
            r = None
        time.sleep(3 + 3 * pokusaj)
    if r is None or r.status_code != 200:
        raise RuntimeError(f"Preuzimanje nije uspjelo: {puni}")
    tmp = put.with_suffix(put.suffix + ".dio")
    tmp.write_bytes(r.content)
    tmp.rename(put)
    log(f"preuzeto {put.name} ({len(r.content) / 1e6:.1f} MB) s {host}")
    return put


def sha256(put: Path) -> str:
    h = hashlib.sha256()
    with open(put, "rb") as f:
        for dio in iter(lambda: f.read(1 << 20), b""):
            h.update(dio)
    return h.hexdigest()


# ---------------------------------------------------------------- GeoTIFF (minimalni čitač)
_TIP = {1: "B", 2: "c", 3: "H", 4: "I", 6: "b", 8: "h", 9: "i", 11: "f", 12: "d"}


def citaj_geotiff(put: Path) -> dict:
    """Klasični TIFF, 1 kanal float32/float64, pločice ili trake, bez kompresije ili DEFLATE,
    prediktor 1 ili 3. Dovoljno za Copernicus GLO-30 COG i DGU Visine GeoTIFF."""
    b = Path(put).read_bytes()
    bo = "<" if b[:2] == b"II" else ">"
    if struct.unpack(bo + "H", b[2:4])[0] != 42:
        raise ValueError("Nije klasični TIFF (BigTIFF nije podržan)")
    off = struct.unpack(bo + "I", b[4:8])[0]
    n = struct.unpack(bo + "H", b[off:off + 2])[0]
    t: dict[int, tuple | str] = {}
    for i in range(n):
        p = off + 2 + 12 * i
        tag, typ, cnt = struct.unpack(bo + "HHI", b[p:p + 8])
        if typ not in _TIP:
            continue
        vel = struct.calcsize(_TIP[typ]) * cnt
        poz = p + 8 if vel <= 4 else struct.unpack(bo + "I", b[p + 8:p + 12])[0]
        if typ == 2:
            t[tag] = b[poz:poz + cnt].split(b"\0")[0].decode("latin1")
        else:
            t[tag] = struct.unpack(bo + _TIP[typ] * cnt, b[poz:poz + vel])
    w, h = t[256][0], t[257][0]
    bits, fmt = t[258][0], t.get(339, (1,))[0]
    komp, pred = t.get(259, (1,))[0], t.get(317, (1,))[0]
    if fmt != 3 or bits not in (32, 64):
        raise ValueError(f"Nepodržan zapis uzorka: {bits} bita, format {fmt}")
    bps = bits // 8
    dtype = np.dtype(("<" if bo == "<" else ">") + f"f{bps}")

    def blok(o: int, c: int, bw: int, bh: int) -> np.ndarray:
        raw = b[o:o + c]
        if komp in (8, 32946):
            raw = zlib.decompress(raw)
        elif komp != 1:
            raise ValueError(f"Nepodržana kompresija {komp}")
        if pred == 3:  # prediktor za pomični zarez: razlike po bajtovima + razdvojene ravnine
            a = np.frombuffer(raw, np.uint8).reshape(bh, bw * bps)
            a = np.cumsum(a, axis=1, dtype=np.uint8)
            a = a.reshape(bh, bps, bw).transpose(0, 2, 1).copy()
            return a.view(f">f{bps}").reshape(bh, bw)
        if pred != 1:
            raise ValueError(f"Nepodržan prediktor {pred}")
        return np.frombuffer(raw, dtype).reshape(bh, bw)

    out = np.empty((h, w), np.float32)
    if 322 in t:
        tw, th = t[322][0], t[323][0]
        nx = -(-w // tw)
        for k, (o, c) in enumerate(zip(t[324], t[325])):
            r0, c0 = (k // nx) * th, (k % nx) * tw
            if r0 >= h:
                break
            d = blok(o, c, tw, th)
            out[r0:r0 + th, c0:c0 + tw] = d[: h - r0, : w - c0]
    else:
        rps = t.get(278, (h,))[0]
        for k, (o, c) in enumerate(zip(t[273], t[279])):
            r0 = k * rps
            bh = min(rps, h - r0)
            out[r0:r0 + bh] = blok(o, c, w, bh)
    sx, sy = t[33550][0], t[33550][1]
    ti, tj, _, tx, ty, _ = t[33922][:6]
    kljucevi = t.get(34735, ())
    geo = {kljucevi[i]: kljucevi[i + 3] for i in range(4, len(kljucevi), 4) if kljucevi[i + 1] == 0}
    pomak = 0.5 if geo.get(1025, 1) == 1 else 0.0  # PixelIsArea: vezna točka je kut piksela
    nodata = float(t[42113]) if 42113 in t else None
    return {
        "a": out, "w": w, "h": h, "sx": sx, "sy": sy,
        # koordinata SREDIŠTA piksela (0,0)
        "x0": tx + (pomak - ti) * sx, "y0": ty - (pomak - tj) * sy,
        "epsg": geo.get(3072) or geo.get(2048), "nodata": nodata, "raster_tip": geo.get(1025, 1),
    }


# ---------------------------------------------------------------- koordinate
def enu_u_lonlat(x, y):
    return LON0 + np.asarray(x) / KX, LAT0 + np.asarray(y) / KY


def lonlat_u_enu(lon, lat):
    return (np.asarray(lon) - LON0) * KX, (np.asarray(lat) - LAT0) * KY


# ---------------------------------------------------------------- GLO-30
def glo30_mozaik(cache: Path, bbox) -> dict:
    """Mozaik pločica 1° x 1° koje pokrivaju bbox; mreža 1" (središta piksela na cijelim sekundama)."""
    lon0, lat0, lon1, lat1 = bbox
    stupci = range(math.floor(lon0), math.floor(lon1 - 1e-9) + 1)
    redovi = range(math.floor(lat1 - 1e-9), math.floor(lat0) - 1, -1)  # od sjevera
    blokovi = []
    for la in redovi:
        red = []
        for lo in stupci:
            ime = f"Copernicus_DSM_COG_10_N{la:02d}_00_E{lo:03d}_00_DEM"
            put = dohvati(f"https://copernicus-dem-30m.s3.amazonaws.com/{ime}/{ime}.tif",
                          cache / "glo30" / f"{ime}.tif")
            g = citaj_geotiff(put)
            if g["w"] != 3600 or g["h"] != 3600 or abs(g["x0"] - lo) > 1e-9 or abs(g["y0"] - (la + 1)) > 1e-9:
                raise ValueError(f"Neočekivana geometrija pločice {ime}")
            red.append(g["a"])
        blokovi.append(np.hstack(red))
    a = np.vstack(blokovi)
    return {"a": a, "lon0": float(stupci[0]), "lat0": float(redovi[0] + 1), "korak": 1 / 3600}


def glo30_uzorak(m: dict, lon, lat) -> np.ndarray:
    c = (np.asarray(lon) - m["lon0"]) / m["korak"]
    r = (m["lat0"] - np.asarray(lat)) / m["korak"]
    return map_coordinates(m["a"], [r, c], order=1, mode="nearest")


# ---------------------------------------------------------------- DGU Visine (DTM 20 m)
def dgu_plocice(cache: Path, bbox) -> list[dict]:
    idx = dohvati("https://geoportal.dgu.hr/services/atom/INSPIRE_Elevation_Grid_Coverage_(EL-COV).gml",
                  cache / "dgu_dmr" / "elcov.gml").read_text(encoding="utf-8")
    lon0, lat0, lon1, lat1 = bbox
    van = []
    for m in re.findall(r"<wfs:member>(.*?)</wfs:member>", idx, re.S):
        w, e, s, n = (float(re.search(rf"<gmd:{k}><gco:Decimal>([^<]+)", m).group(1)) for k in (
            "westBoundLongitude", "eastBoundLongitude", "southBoundLatitude", "northBoundLatitude"))
        if w < lon1 and e > lon0 and s < lat1 and n > lat0:
            ime = re.search(r"RH_ELEV_\d+", m).group(0)
            put = dohvati(f"https://geoportal.dgu.hr/services/atom/{ime}.tif", cache / "dgu_dmr" / f"{ime}.tif")
            g = citaj_geotiff(put)
            g["ime"] = ime
            van.append(g)
    if not van:
        raise RuntimeError("Nijedna DGU pločica ne pokriva traženi okvir")
    return van


_TM33 = Transformer.from_crs(4326, 25833, always_xy=True)  # ETRS89 / UTM 33N (isto kao EPSG:3045, red E-N)


def dgu_uzorak(plocice: list[dict], lon, lat) -> np.ndarray:
    """Bilinearno očitanje; ćelije bez podatka (-9999) ne ulaze u težine. Pločice su zakrenuti
    pravokutnici koji se dodiruju bez preklopa, pa se na šavu zbrajaju doprinosi obiju strana."""
    lon, lat = np.asarray(lon, float), np.asarray(lat, float)
    e, n = _TM33.transform(lon, lat)
    zbroj = np.zeros(lon.shape, np.float64)
    tezina = np.zeros(lon.shape, np.float64)
    for g in plocice:
        c = (e - g["x0"]) / g["sx"]
        r = (g["y0"] - n) / g["sy"]
        unutra = (c >= 0) & (c <= g["w"] - 1) & (r >= 0) & (r <= g["h"] - 1)
        if not unutra.any():
            continue
        if "_valja" not in g:
            valja = np.ones(g["a"].shape, np.float32) if g["nodata"] is None else (g["a"] != g["nodata"]).astype(np.float32)
            g["_valja"], g["_a0"] = valja, g["a"] * valja
        koord = [r[unutra], c[unutra]]
        zbroj[unutra] += map_coordinates(g["_a0"], koord, order=1, mode="nearest")
        tezina[unutra] += map_coordinates(g["_valja"], koord, order=1, mode="nearest")
    with np.errstate(invalid="ignore", divide="ignore"):
        return np.where(tezina > 0.2, zbroj / tezina, np.nan).astype(np.float32)


def popuni_supljine(h: np.ndarray, najvise_krugova: int = 6) -> tuple[np.ndarray, int]:
    """Uske praznine na šavu pločica popuni srednjom vrijednošću valjanih susjeda; vrati i broj ćelija."""
    h = h.copy()
    ukupno = int(np.isnan(h).sum())
    for _ in range(najvise_krugova):
        prazno = np.isnan(h)
        if not prazno.any():
            break
        p = np.pad(h, 1, constant_values=np.nan)
        sus = np.stack([p[1 + i:p.shape[0] - 1 + i, 1 + j:p.shape[1] - 1 + j]
                        for i in (-1, 0, 1) for j in (-1, 0, 1) if (i, j) != (0, 0)])
        br = np.isfinite(sus).sum(0)
        sr = np.where(br > 0, np.nansum(sus, 0) / np.maximum(br, 1), np.nan)
        h[prazno] = sr[prazno]
    return h, ukupno - int(np.isnan(h).sum())


# ---------------------------------------------------------------- zapis
def spremi_visine(put: Path, h: np.ndarray, meta: dict):
    v = np.where(np.isfinite(h), np.clip(np.round(h * 10), 1, 65535), 0).astype(np.uint16)
    put.parent.mkdir(parents=True, exist_ok=True)
    Image.fromarray(v).save(put, optimize=True)
    meta = dict(meta)
    meta.update({
        "datoteka": put.name,
        "kodiranje": "PNG, 16 bita, 1 kanal; kota_m = vrijednost / 10; 0 = nema podatka; red 0 je sjeverni rub",
        "dimenzije_px": [int(h.shape[1]), int(h.shape[0])],
        "raspon_m": [round(float(np.nanmin(h)), 1), round(float(np.nanmax(h)), 1)],
        "datum_obrade": dt.date.today().isoformat(),
        "status": "POTVRĐENO kao zapis izvora; kote su orijentacijske, nisu geodetska izmjera",
    })
    put.with_suffix(".json").write_text(json.dumps(meta, ensure_ascii=False, indent=1) + "\n", encoding="utf-8")
    log(f"zapisano {put.name} {h.shape[1]}x{h.shape[0]} px, {meta['raspon_m']} m")


def ucitaj_visine(put: Path) -> np.ndarray:
    v = np.asarray(Image.open(put)).astype(np.float32)
    return np.where(v == 0, np.nan, v / 10.0)


def meta_regije(bbox, n_lon, n_lat) -> dict:
    return {
        "mreza": {
            "vrsta": "geografska, pravilna u stupnjevima; vrijednost vrijedi za središte piksela",
            "lon_min": bbox[0], "lat_min": bbox[1], "lon_max": bbox[2], "lat_max": bbox[3],
            "korak_stupnjevi": 1 / 3600,
            "korak_m_priblizno": {"istok": round(KX_TOCNO / 3600, 1), "sjever": round(KY_TOCNO / 3600, 1)},
            "stupaca": n_lon, "redova": n_lat,
            "piksel_u_lonlat": "lon = lon_min + stupac/3600; lat = lat_max - red/3600",
        },
        "crs_polozaj": "EPSG:4326 (WGS 84), stupnjevi",
    }


# točnije duljine stupnja na širini ishodišta (WGS 84), samo za opis rezolucije
_F = math.radians(LAT0)
KY_TOCNO = 111132.954 - 559.822 * math.cos(2 * _F) + 1.175 * math.cos(4 * _F)
KX_TOCNO = 111412.84 * math.cos(_F) - 93.5 * math.cos(3 * _F)

DATUM_GLO30 = {
    "visinski_datum": "EGM2008 (EPSG:3855); položajni WGS84-G1150 (EPSG:4326)",
    "visinski_datum_status": (
        "POTVRĐENO: Copernicus DEM Product Handbook, izd. 5.0 (29.11.2022.), tablica 1, str. 10. "
        "PRETPOSTAVKA: razlika prema hrvatskom HVRS71 je reda veličine decimetara i manja od točnosti "
        "modela; nije potvrđena iz izvora. Empirijska usporedba s DGU modelom: kontrolne_kote.json."
    ),
    "tocnost_prema_izvoru": (
        "apsolutna visinska < 4 m (90 % linearna pogreška), položajna < 6 m (90 % kružna pogreška); "
        "globalni prosjek, lokalna odstupanja su moguća (isti dokument, str. 10)"
    ),
}
DATUM_DGU = {
    "visinski_datum": "u metapodacima skupa naveden EPSG:5730 (EVRF2000)",
    "visinski_datum_status": (
        "OTVORENO: nije provjereno jesu li kote stvarno preračunate iz HVRS71 u EVRF2000 ili su "
        "samo tako označene. PRETPOSTAVKA: razlika je reda veličine decimetara."
    ),
}


# ---------------------------------------------------------------- koraci
def korak_dem(cache: Path, izlaz: Path, bbox) -> np.ndarray:
    m = glo30_mozaik(cache, bbox)
    n_lon = round((bbox[2] - bbox[0]) * 3600) + 1
    n_lat = round((bbox[3] - bbox[1]) * 3600) + 1
    lon = bbox[0] + np.arange(n_lon) / 3600
    lat = bbox[3] - np.arange(n_lat) / 3600
    LO, LA = np.meshgrid(lon, lat)
    h = glo30_uzorak(m, LO, LA)  # mreža je poravnata na 1", pa je ovo izravno očitanje bez zaglađivanja
    meta = meta_regije(bbox, n_lon, n_lat)
    meta.update({
        "opis": "Regionalni visinski model, Copernicus DEM GLO-30, izvorna mreža 1 lučna sekunda",
        "tip_modela": "DSM", "napomena": NAPOMENA_DSM,
        "izvor": IZVORI["glo30"]["naziv"], "izvor_url": IZVORI["glo30"]["url"],
        "licenca": IZVORI["glo30"]["licenca"], "licenca_url": IZVORI["glo30"]["licenca_url"],
        "atribucija": IZVORI["glo30"]["atribucija"],
        "razdoblje_snimanja": "TanDEM-X, 2010.–2015. (prema opisu proizvoda); stanje krošnji i zgrada je iz tog razdoblja",
        **DATUM_GLO30,
    })
    spremi_visine(izlaz / "dem_regija_glo30.png", h, meta)
    return h


def korak_dmr(cache: Path, izlaz: Path, bbox) -> np.ndarray:
    pl = dgu_plocice(cache, bbox)
    n_lon = round((bbox[2] - bbox[0]) * 3600) + 1
    n_lat = round((bbox[3] - bbox[1]) * 3600) + 1
    LO, LA = np.meshgrid(bbox[0] + np.arange(n_lon) / 3600, bbox[3] - np.arange(n_lat) / 3600)
    h, popunjeno = popuni_supljine(dgu_uzorak(pl, LO, LA))
    meta = meta_regije(bbox, n_lon, n_lat)
    meta.update({
        "popunjene_praznine": f"{popunjeno} ćelija na šavu izvornih pločica popunjeno iz susjednih ćelija",
        "opis": "Regionalni model reljefa, DGU Visine INSPIRE (DTM 20 m), bilinearno preuzorkovan na mrežu 1\" "
                "istu kao dem_regija_glo30.png",
        "tip_modela": "DTM", "napomena": NAPOMENA_DTM,
        "izvorne_plocice": [g["ime"] for g in pl], "izvorni_crs": "EPSG:3045 (ETRS89 / UTM 33N), korak 19,995 m",
        "izvor": IZVORI["dgu_dmr"]["naziv"], "izvor_url": IZVORI["dgu_dmr"]["url"],
        "licenca": IZVORI["dgu_dmr"]["licenca"], "licenca_url": IZVORI["dgu_dmr"]["licenca_url"],
        "atribucija": IZVORI["dgu_dmr"]["atribucija"],
        "datum_skupa": "beginLifespanVersion 2015-11-25 (GML indeks); ATOM zapis ažuriran 2021-11-15",
        **DATUM_DGU,
    })
    spremi_visine(izlaz / "dmr_regija_dgu20.png", h, meta)
    return h


def korak_blizu(cache: Path, izlaz: Path, pola: float, korak: float):
    n = int(round(2 * pola / korak)) + 1
    xs = -pola + np.arange(n) * korak
    ys = pola - np.arange(n) * korak
    X, Y = np.meshgrid(xs, ys)
    LO, LA = enu_u_lonlat(X, Y)
    okvir = (float(LO.min()) - 0.01, float(LA.min()) - 0.01, float(LO.max()) + 0.01, float(LA.max()) + 0.01)
    zaj = {
        "mreza": {
            "vrsta": "lokalni ENU u metrima (research/viz/README.md); vrijednost vrijedi za čvor mreže",
            "ishodiste": {"lat": LAT0, "lon": LON0},
            "x_min": -pola, "x_max": pola, "y_min": -pola, "y_max": pola, "korak_m": korak,
            "stupaca": n, "redova": n,
            "piksel_u_enu": f"x = {-pola} + stupac*{korak}; y = {pola} - red*{korak}",
            "enu_u_lonlat": f"lon = {LON0} + x/{KX:.3f}; lat = {LAT0} + y/{KY:.1f}",
        },
        "crs_polozaj": "lokalni ENU; veza s EPSG:4326 preko gornje formule (ista kao scripts/viz/gradi_site.py)",
        "napomena_mjerilo": (
            "Konstanta 110 574 m/° iz README-a je vrijednost za ekvator; na 45,82° N stupanj širine ima oko "
            f"{KY_TOCNO:.0f} m, a stupanj dužine oko {KX_TOCNO:.0f} m (README: {KX:.0f}). ENU 'metar' je zato "
            f"u smjeru sjevera {100 * (KY_TOCNO / KY - 1):.2f} % dulji, a u smjeru istoka "
            f"{100 * (KX_TOCNO / KX - 1):.2f} % dulji od stvarnog metra. Rasteri su vezani na lon/lat pa su "
            "međusobno i sa site.json usklađeni; mjere iz ENU-a treba čitati uz tu ogradu."
        ),
        "preuzorkovanje": "bilinearno; korak 5 m ne dodaje detalj koji izvor nema",
    }
    m = glo30_mozaik(cache, okvir)
    meta = dict(zaj)
    meta.update({
        "opis": "Bliski visinski model oko ishodišta, iz Copernicus GLO-30 (izvorno oko 30 m)",
        "tip_modela": "DSM", "napomena": NAPOMENA_DSM,
        "izvor": IZVORI["glo30"]["naziv"], "izvor_url": IZVORI["glo30"]["url"],
        "licenca": IZVORI["glo30"]["licenca"], "licenca_url": IZVORI["glo30"]["licenca_url"],
        "atribucija": IZVORI["glo30"]["atribucija"], **DATUM_GLO30,
    })
    spremi_visine(izlaz / "dem_blizu_glo30_5m.png", glo30_uzorak(m, LO, LA), meta)
    pl = dgu_plocice(cache, okvir)
    meta = dict(zaj)
    meta.update({
        "opis": "Bliski model reljefa oko ishodišta, iz DGU Visine INSPIRE (izvorno 20 m)",
        "tip_modela": "DTM", "napomena": NAPOMENA_DTM,
        "izvor": IZVORI["dgu_dmr"]["naziv"], "izvor_url": IZVORI["dgu_dmr"]["url"],
        "licenca": IZVORI["dgu_dmr"]["licenca"], "licenca_url": IZVORI["dgu_dmr"]["licenca_url"],
        "atribucija": IZVORI["dgu_dmr"]["atribucija"], **DATUM_DGU,
    })
    h, popunjeno = popuni_supljine(dgu_uzorak(pl, LO, LA))
    meta["popunjene_praznine"] = f"{popunjeno} ćelija popunjeno iz susjednih ćelija"
    spremi_visine(izlaz / "dmr_blizu_dgu20_5m.png", h, meta)


# ---------------------------------------------------------------- ortofoto
DGU_WMS = "https://geoportal.dgu.hr/services/inspire/orthophoto_2024/wms"
EOX_WMS = "https://tiles.maps.eox.at/wms"
_HTRS = Transformer.from_crs(4326, 3765, always_xy=True)  # HTRS96/TM


def korak_ortofoto_blizu(cache: Path, izlaz: Path, pola: float, px: float, max_px: int, kvaliteta: int,
                         max_mb: float = 15.0):
    """DGU DOF 2024 preko WMS-a za anonimne korisnike (EPSG:3765), preslikan u ENU mrežu.
    Odgovor usluge nosi vodeni žig 'GEOPORTAL' u sredini svakog zahtjeva; žig se ne uklanja."""
    n = int(round(2 * pola / px))
    xs = -pola + (np.arange(n) + 0.5) * px  # središta piksela
    ys = pola - (np.arange(n) + 0.5) * px
    kut_x, kut_y = np.array([-pola, pola, pola, -pola]), np.array([-pola, -pola, pola, pola])
    lo, la = enu_u_lonlat(kut_x, kut_y)
    e, nn = _HTRS.transform(lo, la)
    rub = 20.0
    e0, e1 = math.floor((e.min() - rub) / px) * px, math.ceil((e.max() + rub) / px) * px
    n0, n1 = math.floor((nn.min() - rub) / px) * px, math.ceil((nn.max() + rub) / px) * px
    W, H = int(round((e1 - e0) / px)), int(round((n1 - n0) / px))
    nx, ny = -(-W // max_px), -(-H // max_px)
    tw, th = -(-W // nx), -(-H // ny)
    moz = np.zeros((ny * th, nx * tw, 3), np.uint8)
    zahtjevi = []
    for j in range(ny):
        for i in range(nx):
            bb = (e0 + i * tw * px, n1 - (j + 1) * th * px, e0 + (i + 1) * tw * px, n1 - j * th * px)
            par = {"SERVICE": "WMS", "VERSION": "1.3.0", "REQUEST": "GetMap", "LAYERS": "OI.OrthoimageCoverage",
                   "STYLES": "", "CRS": "EPSG:3765", "BBOX": ",".join(f"{v:.2f}" for v in bb),
                   "WIDTH": tw, "HEIGHT": th, "FORMAT": "image/jpeg"}
            ime = f"dof2024_{bb[0]:.0f}_{bb[1]:.0f}_{tw}x{th}_{px}.jpg"
            put = dohvati(DGU_WMS, cache / "dgu_dof" / ime, params=par)
            try:
                im = Image.open(put).convert("RGB")
            except Exception as ex:  # usluga je vratila XML iznimku umjesto slike
                tekst = put.read_bytes()[:300]
                put.unlink()
                raise RuntimeError(f"WMS nije vratio sliku ({ex}): {tekst!r}")
            moz[j * th:(j + 1) * th, i * tw:(i + 1) * tw] = np.asarray(im)
            zahtjevi.append({"bbox_epsg3765": [round(v, 2) for v in bb], "px": [tw, th],
                             "zig_srediste_enu": [round(float(v), 0) for v in lonlat_u_enu(
                                 *Transformer.from_crs(3765, 4326, always_xy=True).transform(
                                     (bb[0] + bb[2]) / 2, (bb[1] + bb[3]) / 2))]})
    X, Y = np.meshgrid(xs, ys)
    LO, LA = enu_u_lonlat(X, Y)
    E, N = _HTRS.transform(LO, LA)
    c = (E - e0) / px - 0.5
    r = (n1 - N) / px - 0.5
    out = np.empty((n, n, 3), np.uint8)
    for k in range(3):
        out[..., k] = map_coordinates(moz[..., k], [r, c], order=1, mode="nearest")
    put = izlaz / "ortofoto_blizu.jpg"
    while True:
        Image.fromarray(out).save(put, quality=kvaliteta, optimize=True, subsampling=2)
        if put.stat().st_size <= max_mb * 1e6 or kvaliteta <= 60:
            break
        kvaliteta -= 4
    meta = {
        "datoteka": put.name,
        "opis": "Bliski ortofoto oko ishodišta: DGU Digitalni ortofoto 2024. (DOF5), preslikan u lokalni ENU",
        "mreza": {
            "vrsta": "lokalni ENU u metrima; piksel je površina, red 0 je sjeverni rub",
            "ishodiste": {"lat": LAT0, "lon": LON0},
            "x_min": -pola, "x_max": pola, "y_min": -pola, "y_max": pola, "m_po_px": px, "dimenzije_px": [n, n],
            "piksel_u_enu": f"x = {-pola} + (stupac+0,5)*{px}; y = {pola} - (red+0,5)*{px}",
            "enu_u_lonlat": f"lon = {LON0} + x/{KX:.3f}; lat = {LAT0} + y/{KY:.1f}",
            "kutovi_lonlat": {"jz": [float(lo[0]), float(la[0])], "si": [float(lo[2]), float(la[2])]},
        },
        "crs_izvora": "EPSG:3765 (HTRS96/TM); preslikano bilinearno u ENU",
        "napomena_mjerilo": "ENU 'metar' nije točan metar (vidi dem_blizu_glo30_5m.json, napomena_mjerilo)",
        "izvor": IZVORI["dgu_dof"]["naziv"], "izvor_url": IZVORI["dgu_dof"]["url"],
        "sloj": "OI.OrthoimageCoverage", "godina_snimanja": "2024. (prema opisu usluge; točan datum leta nije naveden)",
        "licenca": IZVORI["dgu_dof"]["licenca"], "licenca_url": IZVORI["dgu_dof"]["licenca_url"],
        "atribucija": IZVORI["dgu_dof"]["atribucija"],
        "vodeni_zig": (
            "Usluga za anonimne korisnike upisuje žig 'GEOPORTAL' u sredinu svakog odgovora. Žig je ostavljen "
            "kako je isporučen; nije uklanjan, prekrivan ni izrezivan."),
        "zahtjevi_wms": zahtjevi,
        "jpeg_kvaliteta": kvaliteta, "velicina_MB": round(put.stat().st_size / 1e6, 2),
        "datum_preuzimanja": dt.date.fromtimestamp(min(p.stat().st_mtime for p in (cache / "dgu_dof").glob("*.jpg"))).isoformat(),
        "status": "POTVRĐENO kao zapis izvora; ortofoto prikazuje stanje 2024., ne koncept",
    }
    put.with_suffix(".json").write_text(json.dumps(meta, ensure_ascii=False, indent=1) + "\n", encoding="utf-8")
    log(f"zapisano {put.name} {n}x{n} px, {meta['velicina_MB']} MB, q={kvaliteta}, zahtjeva: {len(zahtjevi)}")


def korak_ortofoto_regija(cache: Path, izlaz: Path, bbox, m_po_px: float = 10.0):
    w = int(round((bbox[2] - bbox[0]) * KX_TOCNO / m_po_px))
    h = int(round((bbox[3] - bbox[1]) * KY_TOCNO / m_po_px))
    par = {"SERVICE": "WMS", "VERSION": "1.1.1", "REQUEST": "GetMap", "LAYERS": "s2cloudless", "STYLES": "",
           "SRS": "EPSG:4326", "BBOX": ",".join(f"{v:.5f}" for v in bbox), "WIDTH": w, "HEIGHT": h,
           "FORMAT": "image/jpeg"}
    sirovo = dohvati(EOX_WMS, cache / "eox" / f"s2cloudless2016_{'_'.join(f'{v:.3f}' for v in bbox)}_{w}x{h}.jpg",
                     params=par)
    im = Image.open(sirovo).convert("RGB")
    put = izlaz / "ortofoto_regija.jpg"
    im.save(put, quality=90, optimize=True)
    meta = {
        "datoteka": put.name,
        "opis": "Regionalni satelitski mozaik bez oblaka (Sentinel-2, 2016.), isti okvir kao dem_regija_glo30.png",
        "mreza": {
            "vrsta": "geografska (plate carrée), pravilna u stupnjevima; piksel je površina",
            "lon_min": bbox[0], "lat_min": bbox[1], "lon_max": bbox[2], "lat_max": bbox[3],
            "dimenzije_px": [w, h], "m_po_px_priblizno": m_po_px,
        },
        "crs_polozaj": "EPSG:4326",
        "izvor": IZVORI["eox_s2"]["naziv"], "izvor_url": IZVORI["eox_s2"]["url"], "usluga": EOX_WMS,
        "licenca": IZVORI["eox_s2"]["licenca"], "licenca_url": IZVORI["eox_s2"]["licenca_url"],
        "atribucija": IZVORI["eox_s2"]["atribucija"],
        "napomena": "Snimke iz 2016.: novija gradnja nije vidljiva. Izvorna rezolucija Sentinel-2 je 10 m. "
                    "Noviji slojevi (2018.+) su CC BY-NC-SA 4.0 i zato nisu uzeti.",
        "velicina_MB": round(put.stat().st_size / 1e6, 2),
        "datum_preuzimanja": dt.date.fromtimestamp(sirovo.stat().st_mtime).isoformat(),
        "status": "POTVRĐENO kao zapis izvora",
    }
    put.with_suffix(".json").write_text(json.dumps(meta, ensure_ascii=False, indent=1) + "\n", encoding="utf-8")
    log(f"zapisano {put.name} {w}x{h} px, {meta['velicina_MB']} MB")


# ---------------------------------------------------------------- reljef i kontrola
def sjencanje(h: np.ndarray, dx: float, dy: float, azimut=315.0, visina=45.0, z=1.0) -> np.ndarray:
    h = np.where(np.isfinite(h), h, np.nanmean(h))
    gy, gx = np.gradient(h * z, dy, dx)  # red raste prema jugu
    gy = -gy
    az, al = math.radians(azimut), math.radians(visina)
    nagib = np.arctan(np.hypot(gx, gy))
    aspekt = np.arctan2(-gx, -gy)
    s = np.sin(al) * np.cos(nagib) + np.cos(al) * np.sin(nagib) * np.cos(az - aspekt)
    return np.clip(s, 0, 1)


def korak_reljef(izlaz: Path):
    for ime, dx, dy, z in (("dem_regija_glo30", KX_TOCNO / 3600, KY_TOCNO / 3600, 1.0),
                           ("dmr_regija_dgu20", KX_TOCNO / 3600, KY_TOCNO / 3600, 1.0),
                           ("dem_blizu_glo30_5m", BLIZU_KORAK, BLIZU_KORAK, 3.0),
                           ("dmr_blizu_dgu20_5m", BLIZU_KORAK, BLIZU_KORAK, 3.0)):
        p = izlaz / f"{ime}.png"
        if not p.exists():
            continue
        h = ucitaj_visine(p)
        s = sjencanje(h, dx, dy, z=z)
        t = (h - np.nanmin(h)) / max(1e-6, np.nanmax(h) - np.nanmin(h))
        t = np.where(np.isfinite(t), t, 0.0)
        rgb = np.stack([60 + 150 * t, 110 + 90 * (1 - np.abs(t - 0.35)), 70 + 60 * t], -1) * (0.35 + 0.65 * s[..., None])
        im = Image.fromarray(np.clip(rgb, 0, 255).astype(np.uint8))
        if "regija" in ime:  # ispravi omjer stranica (stupanj dužine je kraći)
            im = im.resize((im.width, int(round(im.height * KY_TOCNO / KX_TOCNO))), Image.BILINEAR)
        im.save(izlaz / f"reljef_{ime}.png", optimize=True)
        log(f"zapisano reljef_{ime}.png")


KONTROLNE = [
    # naziv, lat, lon, očekivano (m n. v.), izvor očekivane kote
    ("Sljeme, vrh", 45.8993, 15.94738, 1033.0, "OSM čvor 26864710, oznaka ele=1033 (ODbL)"),
    ("Gornja postaja žičare", 45.89871, 15.94753, 1030.0, "OSM put 294928511, oznaka ele=1030 (ODbL)"),
    ("Puntijarka", 45.90359, 15.96905, 957.0, "OSM put 106365482, oznaka ele=957 (ODbL)"),
    ("Medvedgrad", 45.86953, 15.94073, 593.0, "OSM put 105590473, oznaka ele=593 (ODbL)"),
    ("Remete, crkva", 45.85117, 15.99015, 255.0, "zadatak: oko 250–260 m; izvor te kote nije provjeren"),
    ("Maksimirska uz sjevernu tribinu", None, None, 120.0, "Program, pogl. 6.6, str. 49 (README, kanonske kote)", (0.0, 157.0)),
    ("Raskrižje Svetice (Maksimirska)", None, None, 118.5, "Program, pogl. 6.6, str. 49 (README, kanonske kote)", (-428.0, 100.0)),
    ("Nogometni teren, središte", None, None, 118.5, "odluka M1: oko 118–119 (README)", (-47.0, 10.0)),
    ("Bazen Svetice", None, None, 116.0, "odluka M7 (README)", (-202.0, -163.0)),
]


def korak_kontrola(cache: Path, izlaz: Path):
    okvir = REGIJA
    m = glo30_mozaik(cache, okvir)
    pl = dgu_plocice(cache, okvir)
    tocke = []
    for t in KONTROLNE:
        naziv, lat, lon, ocek, izv = t[:5]
        if lat is None:
            lo, la = enu_u_lonlat(*t[5])
            lon, lat = float(lo), float(la)
        dsm = float(glo30_uzorak(m, np.array([lon]), np.array([lat]))[0])
        dtm = float(dgu_uzorak(pl, np.array([lon]), np.array([lat]))[0])
        dx, dy = np.meshgrid(np.arange(-100, 101, 10.0), np.arange(-100, 101, 10.0))
        u = np.hypot(dx, dy) <= 100
        lo_k, la_k = lon + dx[u] / KX_TOCNO, lat + dy[u] / KY_TOCNO
        tocke.append({"naziv": naziv, "lat": round(lat, 5), "lon": round(lon, 5), "ocekivano_m": ocek,
                      "izvor_ocekivanog": izv, "dsm_glo30_m": round(dsm, 1), "dmr_dgu_m": round(dtm, 1),
                      "dsm_minus_ocekivano": round(dsm - ocek, 1), "dmr_minus_ocekivano": round(dtm - ocek, 1),
                      "dsm_najvise_u_krugu_100m": round(float(np.nanmax(glo30_uzorak(m, lo_k, la_k))), 1),
                      "dmr_najvise_u_krugu_100m": round(float(np.nanmax(dgu_uzorak(pl, lo_k, la_k))), 1)})
    out = {"opis": "Kontrolne kote: očekivana vrijednost naspram modela (bilinearno očitanje)",
           "datum": dt.date.today().isoformat(), "tocke": tocke}
    pa, pb = izlaz / "dem_regija_glo30.png", izlaz / "dmr_regija_dgu20.png"
    if pa.exists() and pb.exists():
        a, b = ucitaj_visine(pa), ucitaj_visine(pb)
        d = a - b
        gy, gx = np.gradient(b, KY_TOCNO / 3600, KX_TOCNO / 3600)
        ravno = (np.hypot(gx, gy) < 0.03) & np.isfinite(d)
        otvoreno = ravno & (np.abs(d - np.nanmedian(d[ravno])) < 2.0)
        out["usporedba_dsm_minus_dmr"] = {
            "sve_celije": {"medijan_m": round(float(np.nanmedian(d)), 2), "p05_m": round(float(np.nanpercentile(d, 5)), 2),
                           "p95_m": round(float(np.nanpercentile(d, 95)), 2)},
            "ravne_celije_nagib_ispod_3_posto": {"broj": int(ravno.sum()), "medijan_m": round(float(np.median(d[ravno])), 2)},
            "ravne_i_vjerojatno_otvorene": {"broj": int(otvoreno.sum()), "medijan_m": round(float(np.median(d[otvoreno])), 2),
                                            "st_dev_m": round(float(np.std(d[otvoreno])), 2)},
            "tumacenje": (
                "PRETPOSTAVKA-IZRAČUN: medijan na ravnim ćelijama miješa razliku visinskih datuma, pogrešku "
                "modela i ostatke zgrada i drveća; nije mjera razlike EGM2008 i HVRS71."),
        }
    (izlaz / "kontrolne_kote.json").write_text(json.dumps(out, ensure_ascii=False, indent=1) + "\n", encoding="utf-8")
    for t in tocke:
        log(f"{t['naziv']:34s} očekivano {t['ocekivano_m']:7.1f}  DSM {t['dsm_glo30_m']:7.1f} ({t['dsm_minus_ocekivano']:+.1f})"
            f"  DMR {t['dmr_dgu_m']:7.1f} ({t['dmr_minus_ocekivano']:+.1f})"
            f"  najviše u 100 m: DSM {t['dsm_najvise_u_krugu_100m']:.1f}, DMR {t['dmr_najvise_u_krugu_100m']:.1f}")
    if "usporedba_dsm_minus_dmr" in out:
        log("DSM − DMR:", json.dumps(out["usporedba_dsm_minus_dmr"], ensure_ascii=False)[:400])


# ---------------------------------------------------------------- manifest
PRIPADNOST = [  # uzorak imena -> ključevi izvora
    (r"^dem_.*glo30", ["glo30"]), (r"^dmr_.*dgu20", ["dgu_dmr"]),
    (r"^reljef_dem_", ["glo30"]), (r"^reljef_dmr_", ["dgu_dmr"]),
    (r"^ortofoto_blizu", ["dgu_dof"]), (r"^ortofoto_regija", ["eox_s2"]),
    (r"^kontrolne_kote", ["glo30", "dgu_dmr"]), (r"^vidljivost", ["glo30", "dgu_dmr"]),
    (r"^IZVORI\.md$", ["izvedeno"]),
]


def korak_manifest(izlaz: Path):
    stavke = []
    for p in sorted(izlaz.iterdir()):
        if not p.is_file() or p.name == "manifest.json":
            continue
        kljucevi = next((k for uz, k in PRIPADNOST if re.search(uz, p.name)), ["izvedeno"])
        stavke.append({
            "datoteka": p.name,
            "izvor": "; ".join(IZVORI[k]["naziv"] for k in kljucevi),
            "izvor_url": [IZVORI[k]["url"] for k in kljucevi],
            "licenca": "; ".join(IZVORI[k]["licenca"] for k in kljucevi),
            "atribucija": " | ".join(IZVORI[k]["atribucija"] for k in kljucevi),
            "datum": dt.date.fromtimestamp(p.stat().st_mtime).isoformat(),
            "velicina_bajtova": p.stat().st_size,
            "sha256": sha256(p),
        })
    out = {"opis": "Manifest mape research/viz/teren; izradila scripts/viz/teren.py (korak manifest)",
           "datum": dt.date.today().isoformat(), "datoteke": stavke}
    (izlaz / "manifest.json").write_text(json.dumps(out, ensure_ascii=False, indent=1) + "\n", encoding="utf-8")
    log(f"manifest: {len(stavke)} datoteka")


# ---------------------------------------------------------------- CLI
def main(argv=None):
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("--cache", default=os.environ.get("VIZ_CACHE", str(Path.home() / ".cache" / "viz-teren")),
                    help="mapa predmemorije izvan repoa (ili varijabla VIZ_CACHE)")
    ap.add_argument("--izlaz", default=str(IZLAZ))
    ap.add_argument("--koraci", default="dem,dmr,blizu,ortofoto,reljef,kontrola,manifest")
    ap.add_argument("--proba", action="store_true",
                    help="mali isječak (okvir oko stadiona, bliski ±500 m, ortofoto ±250 m) za provjeru ponovljivosti")
    ap.add_argument("--max-px", type=int, default=6200, help="najveća stranica jednog WMS zahtjeva")
    ap.add_argument("--kvaliteta", type=int, default=86, help="početna JPEG kvaliteta bliskog ortofota")
    a = ap.parse_args(argv)
    cache, izlaz = Path(a.cache).expanduser(), Path(a.izlaz).expanduser()
    izlaz.mkdir(parents=True, exist_ok=True)
    koraci = [k.strip() for k in a.koraci.split(",") if k.strip()]
    bbox = (16.00, 45.80, 16.04, 45.84) if a.proba else REGIJA
    pola_b, pola_o = (500.0, 250.0) if a.proba else (BLIZU_POLA, ORTO_POLA)
    if a.proba and izlaz == IZLAZ:
        sys.exit("--proba ne smije pisati u research/viz/teren; zadaj --izlaz")
    log(f"predmemorija: {cache}; izlaz: {izlaz}; koraci: {koraci}; okvir: {bbox}")
    if "dem" in koraci:
        korak_dem(cache, izlaz, bbox)
    if "dmr" in koraci:
        korak_dmr(cache, izlaz, bbox)
    if "blizu" in koraci:
        korak_blizu(cache, izlaz, pola_b, BLIZU_KORAK)
    if "ortofoto" in koraci:
        korak_ortofoto_blizu(cache, izlaz, pola_o, ORTO_PX, a.max_px, a.kvaliteta)
        korak_ortofoto_regija(cache, izlaz, bbox)
    if "reljef" in koraci:
        korak_reljef(izlaz)
    if "kontrola" in koraci and not a.proba:
        korak_kontrola(cache, izlaz)
    if "manifest" in koraci:
        korak_manifest(izlaz)


if __name__ == "__main__":
    main()
