#!/usr/bin/env python3
"""Postojeće stanje lokacije iz OpenStreetMapa u lokalnom ENU: research/viz/site.json i pregled PNG.

Status: orijentacijska podloga za tlocrte i 3D model građanskog koncepta. OSM geometrija NIJE geodetska
podloga; granice obuhvata i zona te širina koridora su PRETPOSTAVKA (vidi polja `status` i `metoda`).

Što radi:
  1. preuzima sirovi OSM XML preko javnog API-ja 0.6 (map poziv po pločicama, razmak >= 2 s) u predmemoriju
     izvan repoa; ako je predmemorija puna, ne zove mrežu;
  2. pretvara u lokalni ENU prema research/viz/README.md (ishodište 45,8187 N, 16,0185 E);
  3. razvrstava slojeve (zgrade, ceste, tračnice, željeznica, stadion, SRC, bazen, park, vode, zelenilo,
     staze, parkirališta, stajališta) i izvodi os Maksimirske sa stacionažom, izmjereni profil koridora,
     približni obuhvat i zone A-D te granicu parka prema Maksimirskoj;
  4. crta pregled s mjerilom i sjeverom te uspoređuje s orijentirima iz README-a i research/osm_fronta.json.

Uporaba:
  python scripts/viz/gradi_site.py --cache <mapa predmemorije>/osm [--bez-mreze]

Podaci: (c) OpenStreetMap contributors, ODbL 1.0 (https://www.openstreetmap.org/copyright).
"""
from __future__ import annotations

import argparse
import datetime
import glob
import json
import math
import os
import sys
import time
import xml.etree.ElementTree as ET

from shapely.geometry import LineString, MultiLineString, MultiPolygon, Point, Polygon, box
from shapely.ops import linemerge, polygonize, unary_union

REPO = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

# --- koordinatni sustav (research/viz/README.md) ---------------------------------------------------
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)
BBOX = (16.004, 45.810, 16.034, 45.827)  # zapad, jug, istok, sjever (okvir bliskog polja)
NX, NY = 3, 2  # pločice map poziva (svaka < 50.000 čvorova)
PARK_REL = '1147778'  # multipoligon "Park šuma Maksimir"
API = 'https://api.openstreetmap.org/api/0.6'
UA = 'osm-site-extract/1.0 (jednokratno istrazivacko preuzimanje podloge; python-requests)'
RAZMAK_S = 2.5
RAZINA_M = 3.2

# orijentiri iz README-a (za provjeru) i ranije mjerenje fronte
README_ORIJENTIRI = {
    'stadion': {'x': [-169, 75], 'y': [-124, 145]},
    'src_svetice': {'x': [-416, -162], 'y': [-403, 26]},
    'bazen': {'x': [-233, -171], 'y': [-223, -104]},
    'glavni_ulaz': {'x': [-231, -218], 'y': [99, 106]},
    'okretiste_linije_5': {'x': [-309, -236], 'y': [61, 101]},
    'raskrizje_svetice_x': -428, 'hondlova_x': 256, 'ravnice_x': 731,
    'os_maksimirske_od_sjeverne_tribine_m': 12,
}

ZADANE_VISINE = {  # m; PRETPOSTAVKA po vrsti zgrade kad nema oznake height ni building:levels
    'house': 7.0, 'detached': 7.0, 'semidetached_house': 7.0, 'residential': 7.0, 'terrace': 7.0,
    'apartments': 16.0, 'dormitory': 13.0,
    'garage': 3.0, 'garages': 3.0, 'shed': 3.0, 'hut': 3.0, 'kiosk': 3.0, 'roof': 3.5, 'shelter': 3.0,
    'greenhouse': 3.0, 'toilets': 3.0, 'gazebo': 3.0, 'service': 3.0, 'stable': 4.0, 'bakehouse': 4.0,
    'school': 10.0, 'kindergarten': 6.5, 'college': 13.0, 'university': 13.0, 'public': 10.0, 'civic': 10.0,
    'hospital': 13.0, 'office': 13.0, 'commercial': 10.0, 'retail': 6.5, 'industrial': 8.0, 'warehouse': 8.0,
    'church': 15.0, 'chapel': 8.0, 'grandstand': 20.0, 'sports_centre': 12.0, 'parking': 9.0,
    'triumphal_arch': 8.0, 'construction': 9.0, 'bridge': 3.0, 'yes': 9.0,
}
ZADANA_VISINA_OSTALO = 6.0

CESTE = {'motorway', 'trunk', 'primary', 'secondary', 'tertiary', 'unclassified', 'residential', 'living_street',
         'service', 'motorway_link', 'trunk_link', 'primary_link', 'secondary_link', 'tertiary_link',
         'construction', 'road'}
STAZE = {'footway', 'path', 'steps', 'pedestrian', 'cycleway', 'track', 'bridleway'}
OZNAKE_BEZ = ('addr:', 'payment:', 'contact:', 'fuel:', 'source', 'check_date', 'opening_hours', 'website', 'phone',
              'email', 'wikimedia_commons', 'wikipedia', 'wikidata', 'brand', 'operator', 'gtfs', 'ref:', 'note',
              'fixme', 'created_by', 'survey', 'image', 'mapillary', 'inscription', 'description', 'compressed_air',
              'notable_tenant', 'architect', 'home_club', 'internet_access', 'fax', 'social_facility:for')


def xy(lon: float, lat: float) -> tuple[float, float]:
    return ((lon - LON0) * KX, (lat - LAT0) * KY)


def lonlat(x: float, y: float) -> tuple[float, float]:
    return (LON0 + x / KX, LAT0 + y / KY)


OKVIR = box(*xy(BBOX[0], BBOX[1]), *xy(BBOX[2], BBOX[3]))


# --- preuzimanje -------------------------------------------------------------------------------------
class Mreza:
    def __init__(self, dopusti: bool):
        self.dopusti, self.zadnji, self.zahtjeva = dopusti, 0.0, 0

    def get(self, url: str) -> tuple[int, bytes]:
        if not self.dopusti:
            raise SystemExit(f'Nema predmemorije za {url}, a mreža je isključena (--bez-mreze).')
        import requests
        cekaj = RAZMAK_S - (time.time() - self.zadnji)
        if cekaj > 0:
            time.sleep(cekaj)
        r = requests.get(url, headers={'User-Agent': UA}, timeout=180)
        self.zadnji = time.time()
        self.zahtjeva += 1
        return r.status_code, r.content


def preuzmi_plocicu(m: Mreza, cache: str, w: float, s: float, e: float, n: float, dubina: int = 0) -> list[str]:
    """Jedna pločica map poziva; na HTTP 400 (previše čvorova) dijeli se na četiri."""
    put = os.path.join(cache, f'map_{w:.5f}_{s:.5f}_{e:.5f}_{n:.5f}.xml')
    if os.path.exists(put) and os.path.getsize(put) > 100:
        return [put]
    kod, tijelo = m.get(f'{API}/map?bbox={w:.5f},{s:.5f},{e:.5f},{n:.5f}')
    if kod == 200:
        with open(put, 'wb') as f:
            f.write(tijelo)
        return [put]
    if kod == 400 and dubina < 4:
        mx, my = (w + e) / 2, (s + n) / 2
        out: list[str] = []
        for a, b, c, d in ((w, s, mx, my), (mx, s, e, my), (w, my, mx, n), (mx, my, e, n)):
            out += preuzmi_plocicu(m, cache, a, b, c, d, dubina + 1)
        return out
    raise SystemExit(f'OSM API vratio {kod} za pločicu {w},{s},{e},{n}')


def preuzmi_sve(cache: str, bez_mreze: bool) -> tuple[list[str], str, Mreza]:
    os.makedirs(cache, exist_ok=True)
    m = Mreza(not bez_mreze)
    w, s, e, n = BBOX
    datoteke: list[str] = []
    for i in range(NX):
        for j in range(NY):
            datoteke += preuzmi_plocicu(m, cache, w + (e - w) * i / NX, s + (n - s) * j / NY,
                                        w + (e - w) * (i + 1) / NX, s + (n - s) * (j + 1) / NY)
    park = os.path.join(cache, f'relation_{PARK_REL}_full.xml')
    if not (os.path.exists(park) and os.path.getsize(park) > 100):
        kod, tijelo = m.get(f'{API}/relation/{PARK_REL}/full')
        if kod != 200:
            raise SystemExit(f'OSM API vratio {kod} za relaciju {PARK_REL}')
        with open(park, 'wb') as f:
            f.write(tijelo)
    return datoteke, park, m


# --- čitanje ---------------------------------------------------------------------------------------
class Osm:
    def __init__(self):
        self.nodes: dict[str, tuple[float, float, dict]] = {}
        self.ways: dict[str, tuple[list[str], dict]] = {}
        self.rels: dict[str, tuple[list[tuple[str, str, str]], dict]] = {}

    def ucitaj(self, put: str):
        root = ET.parse(put).getroot()
        for n in root.iter('node'):
            x, y = xy(float(n.get('lon')), float(n.get('lat')))
            self.nodes[n.get('id')] = (x, y, {t.get('k'): t.get('v') for t in n.findall('tag')})
        for w in root.iter('way'):
            self.ways[w.get('id')] = ([nd.get('ref') for nd in w.findall('nd')],
                                      {t.get('k'): t.get('v') for t in w.findall('tag')})
        for r in root.iter('relation'):
            self.rels[r.get('id')] = ([(mm.get('type'), mm.get('ref'), mm.get('role') or '') for mm in r.findall('member')],
                                      {t.get('k'): t.get('v') for t in r.findall('tag')})

    def pts(self, refs: list[str]) -> list[tuple[float, float]]:
        return [self.nodes[r][:2] for r in refs if r in self.nodes]

    def zatvoren(self, wid: str) -> bool:
        refs = self.ways[wid][0]
        return len(refs) > 3 and refs[0] == refs[-1]

    def poligon_puta(self, wid: str):
        p = Polygon(self.pts(self.ways[wid][0]))
        return p if p.is_valid else p.buffer(0)

    def poligoni_relacije(self, rid: str):
        """Multipoligon iz članova; None ako neki vanjski put nedostaje ili se prsteni ne zatvaraju."""
        clanovi, _ = self.rels[rid]
        vanj, unut = [], []
        for tip, ref, uloga in clanovi:
            if tip != 'way':
                continue
            if ref not in self.ways:
                if uloga != 'inner':
                    return None
                continue
            ln = self.pts(self.ways[ref][0])
            if len(ln) < 2:
                continue
            (unut if uloga == 'inner' else vanj).append(LineString(ln))
        if not vanj:
            return None
        vp = list(polygonize(unary_union(vanj)))
        if not vp:
            return None
        g = unary_union(vp)
        if unut:
            up = list(polygonize(unary_union(unut)))
            if up:
                g = g.difference(unary_union(up))
        return g if not g.is_empty else None


# --- pomoćne ---------------------------------------------------------------------------------------
def r2(v: float) -> float:
    return round(float(v), 2)


def koord(seq) -> list[list[float]]:
    return [[r2(x), r2(y)] for x, y in seq]


def oznake(t: dict) -> dict:
    return {k: v for k, v in t.items() if not any(k.startswith(p) for p in OZNAKE_BEZ)}


def dijelovi_poligona(g) -> list[Polygon]:
    if g is None or g.is_empty:
        return []
    if isinstance(g, Polygon):
        return [g]
    if isinstance(g, MultiPolygon):
        return list(g.geoms)
    return [p for p in getattr(g, 'geoms', []) if isinstance(p, Polygon)]


def dijelovi_linije(g) -> list[LineString]:
    if g is None or g.is_empty:
        return []
    if isinstance(g, LineString):
        return [g]
    return [p for p in getattr(g, 'geoms', []) if isinstance(p, LineString) and p.length > 0]


def zapis_poligona(p: Polygon) -> dict:
    d = {'poligon': koord(p.exterior.coords), 'povrsina_m2': round(p.area, 1)}
    if p.interiors:
        d['rupe'] = [koord(i.coords) for i in p.interiors]
    return d


def raspon(geom) -> dict:
    a, b, c, d = geom.bounds
    return {'x': [round(a), round(c)], 'y': [round(b), round(d)]}


def visina(t: dict) -> tuple[float, str, str]:
    def broj(s):
        try:
            return float(str(s).replace(',', '.').replace('m', '').strip())
        except ValueError:
            return None
    h = broj(t.get('height')) if 'height' in t else None
    if h and h > 0:
        return r2(h), 'oznaka height', 'visoka'
    lv = broj(t.get('building:levels')) if 'building:levels' in t else None
    if lv and lv > 0:
        return r2(lv * RAZINA_M), f'building:levels={t["building:levels"]} x 3,2 m', 'srednja'
    b = t.get('building', 'yes')
    return ZADANE_VISINE.get(b, ZADANA_VISINA_OSTALO), f'zadano po vrsti ({b}), PRETPOSTAVKA', 'niska'


def azimut(a, b) -> float:
    return (math.degrees(math.atan2(b[0] - a[0], b[1] - a[1])) + 360) % 360


# --- slojevi -----------------------------------------------------------------------------------------
def gradi_slojeve(o: Osm, park_put: str) -> dict:
    S: dict = {}

    # zgrade (putovi i multipoligoni)
    zgrade = []

    def dodaj_zgradu(fid: str, t: dict, geom):
        for i, p in enumerate(dijelovi_poligona(geom)):
            if not OKVIR.contains(p.representative_point()):
                continue
            h, izvor, pouzd = visina(t)
            z = {'id': fid if i == 0 else f'{fid}#{i}', 'naziv': t.get('name'), 'vrsta': t.get('building'),
                 'visina_m': h, 'visina_izvor': izvor, 'visina_pouzdanost': pouzd, 'oznake': oznake(t)}
            z.update(zapis_poligona(p))
            zgrade.append(z)

    for rid, (cl, t) in o.rels.items():
        if t.get('type') == 'multipolygon' and 'building' in t:
            g = o.poligoni_relacije(rid)
            if g is not None:
                dodaj_zgradu(f'relation/{rid}', t, g)
    for wid, (refs, t) in o.ways.items():
        if 'building' in t and o.zatvoren(wid):
            dodaj_zgradu(f'way/{wid}', t, o.poligon_puta(wid))
    S['zgrade'] = zgrade

    # ceste i staze
    ceste, staze, pjes_povrsine = [], [], []
    for wid, (refs, t) in o.ways.items():
        hw = t.get('highway')
        if not hw:
            continue
        p = o.pts(refs)
        if len(p) < 2:
            continue
        if t.get('area') == 'yes' and o.zatvoren(wid):
            for i, pg in enumerate(dijelovi_poligona(o.poligon_puta(wid).intersection(OKVIR))):
                d = {'id': f'way/{wid}' + (f'#{i}' if i else ''), 'vrsta': hw, 'naziv': t.get('name')}
                d.update(zapis_poligona(pg))
                pjes_povrsine.append(d)
            continue
        for i, ln in enumerate(dijelovi_linije(LineString(p).intersection(OKVIR))):
            d = {'id': f'way/{wid}' + (f'#{i}' if i else ''), 'razred': hw, 'naziv': t.get('name'), 'linija': koord(ln.coords)}
            for k_osm, k in (('oneway', 'jednosmjerna'), ('lanes', 'trake'), ('width', 'sirina_oznaka'), ('bridge', 'most'),
                             ('tunnel', 'tunel'), ('layer', 'sloj'), ('surface', 'podloga'), ('footway', 'podvrsta'),
                             ('maxspeed', 'najveca_brzina'), ('service', 'sluzbena'), ('access', 'pristup')):
                if k_osm in t:
                    d[k] = t[k_osm]
            if hw in CESTE:
                ceste.append(d)
            elif hw in STAZE:
                d['vrsta'] = d.pop('razred')
                staze.append(d)
    S['ceste'], S['pjesacke_staze'], S['pjesacke_povrsine'] = ceste, staze, pjes_povrsine

    # opći poligonski slojevi
    def povrsine(uvjet, polja=()):
        out = []

        def dodaj(fid, t, geom):
            for i, pg in enumerate(dijelovi_poligona(geom.intersection(OKVIR))):
                if pg.area < 1:
                    continue
                d = {'id': fid + (f'#{i}' if i else ''), 'naziv': t.get('name')}
                for k in polja:
                    if k in t:
                        d[k] = t[k]
                d.update(zapis_poligona(pg))
                out.append(d)
        for rid, (cl, t) in o.rels.items():
            if t.get('type') == 'multipolygon' and uvjet(t) and rid != PARK_REL:
                g = o.poligoni_relacije(rid)
                if g is not None:
                    dodaj(f'relation/{rid}', t, g)
        for wid, (refs, t) in o.ways.items():
            if uvjet(t) and o.zatvoren(wid):
                dodaj(f'way/{wid}', t, o.poligon_puta(wid))
        return out

    def linije(uvjet, polja=()):
        out = []
        for wid, (refs, t) in o.ways.items():
            if uvjet(t):
                p = o.pts(refs)
                if len(p) < 2:
                    continue
                for i, ln in enumerate(dijelovi_linije(LineString(p).intersection(OKVIR))):
                    d = {'id': f'way/{wid}' + (f'#{i}' if i else ''), 'naziv': t.get('name')}
                    for k in polja:
                        if k in t:
                            d[k] = t[k]
                    d['linija'] = koord(ln.coords)
                    out.append(d)
        return out

    # park Maksimir (puna relacija)
    po = Osm()
    po.ucitaj(park_put)
    pg_park = po.poligoni_relacije(PARK_REL)
    if pg_park is None:
        raise SystemExit('Relacija parka se ne zatvara u poligon.')
    park_oznake = po.rels[PARK_REL][1]
    S['_park_geom'] = pg_park

    S['vode'] = {
        'povrsine': povrsine(lambda t: t.get('natural') == 'water' or t.get('landuse') in ('basin', 'reservoir'), ('water',)),
        'tokovi': linije(lambda t: 'waterway' in t, ('waterway', 'tunnel', 'layer')),
    }
    S['zelenilo'] = {
        'sume': povrsine(lambda t: t.get('landuse') == 'forest' or t.get('natural') == 'wood', ('landuse', 'natural')),
        'parkovi': povrsine(lambda t: t.get('leisure') in ('park', 'garden', 'dog_park', 'playground'), ('leisure',)),
        'travnjaci': povrsine(lambda t: t.get('landuse') in ('grass', 'meadow', 'flowerbed', 'village_green', 'allotments', 'orchard')
                              or t.get('natural') in ('scrub', 'heath', 'grassland'), ('landuse', 'natural')),
        'drvoredi': linije(lambda t: t.get('natural') == 'tree_row'),
        'zivice': linije(lambda t: t.get('barrier') == 'hedge' and 'highway' not in t),
        'stabla': [[r2(x), r2(y)] for nid, (x, y, t) in sorted(o.nodes.items()) if t.get('natural') == 'tree' and OKVIR.contains(Point(x, y))],
    }
    S['sportski_tereni'] = povrsine(lambda t: t.get('leisure') in ('pitch', 'track', 'practice_pitch', 'fitness_station', 'bleachers'),
                                    ('leisure', 'sport', 'surface'))
    S['parkiralista'] = povrsine(lambda t: t.get('amenity') == 'parking' and 'building' not in t, ('parking', 'capacity', 'access', 'surface', 'fee'))
    S['ograde'] = linije(lambda t: t.get('barrier') in ('fence', 'wall', 'retaining_wall', 'city_wall') and 'highway' not in t, ('barrier', 'height'))
    S['namjene'] = povrsine(lambda t: t.get('landuse') in ('residential', 'commercial', 'industrial', 'retail', 'religious', 'education',
                                                            'recreation_ground', 'railway', 'construction', 'brownfield', 'garages', 'farmland'),
                            ('landuse',))

    # tramvaj
    linije_po_putu: dict[str, set] = {}
    naziv_rute: dict[str, set] = {}
    for rid, (cl, t) in o.rels.items():
        if t.get('type') == 'route' and t.get('route') == 'tram':
            for tip, ref, ul in cl:
                if tip == 'way':
                    linije_po_putu.setdefault(ref, set()).add(t.get('ref', '?'))
                    naziv_rute.setdefault(ref, set()).add(t.get('name', ''))
    S['_tram_putovi'] = {wid: (refs, t) for wid, (refs, t) in o.ways.items() if t.get('railway') == 'tram'}
    S['_linije_po_putu'] = linije_po_putu
    S['_naziv_rute'] = naziv_rute

    # željeznica
    zel_pruge = linije(lambda t: t.get('railway') == 'rail', ('name', 'ref', 'bridge', 'layer', 'usage', 'service', 'maxspeed'))
    peroni = []
    for wid, (refs, t) in o.ways.items():
        if t.get('railway') == 'platform' and t.get('train') == 'yes':
            g = o.poligon_puta(wid) if o.zatvoren(wid) else None
            d = {'id': f'way/{wid}', 'naziv': t.get('name') or t.get('official_name')}
            if g is not None:
                d.update(zapis_poligona(g))
            else:
                d['linija'] = koord(o.pts(refs))
            peroni.append(d)
    zel_st = [{'id': f'node/{nid}', 'naziv': t.get('name'), 'vrsta': t.get('railway'), 'tocka': [r2(x), r2(y)]}
              for nid, (x, y, t) in sorted(o.nodes.items())
              if t.get('railway') in ('station', 'halt', 'stop') and t.get('tram') != 'yes' and OKVIR.contains(Point(x, y))]
    S['zeljeznica'] = {'pruge': zel_pruge, 'stajalista': zel_st, 'peroni': peroni,
                       'ostalo': linije(lambda t: t.get('railway') in ('abandoned', 'disused', 'razed'), ('railway',))}

    # stajališta
    tram_st, bus_st = [], []
    for nid, (x, y, t) in sorted(o.nodes.items()):
        if not OKVIR.contains(Point(x, y)):
            continue
        if t.get('railway') == 'tram_stop':
            tram_st.append({'id': f'node/{nid}', 'naziv': t.get('name'), 'tocka': [r2(x), r2(y)], 'vrsta': 'zaustavna tocka'})
        elif t.get('highway') == 'bus_stop' or (t.get('public_transport') == 'platform' and t.get('bus') == 'yes'):
            bus_st.append({'id': f'node/{nid}', 'naziv': t.get('name') or t.get('official_name'), 'tocka': [r2(x), r2(y)], 'vrsta': 'stajaliste'})
    for wid, (refs, t) in o.ways.items():
        if t.get('public_transport') == 'platform' or t.get('railway') == 'platform':
            p = o.pts(refs)
            if not p or not OKVIR.intersects(LineString(p) if len(p) > 1 else Point(p[0])):
                continue
            d = {'id': f'way/{wid}', 'naziv': t.get('name') or t.get('official_name'), 'oznaka': t.get('ref'), 'linija': koord(p), 'vrsta': 'peron'}
            if t.get('tram') == 'yes':
                tram_st.append(d)
            elif t.get('bus') == 'yes' or t.get('highway') == 'bus_stop':
                bus_st.append(d)
    S['stajalista'] = {'tramvaj': tram_st, 'autobus': bus_st}

    # orijentiri (imenovane točke)
    orij = []
    for nid, (x, y, t) in sorted(o.nodes.items()):
        if OKVIR.contains(Point(x, y)) and t.get('name') and (t.get('tourism') in ('artwork', 'attraction') or t.get('historic')):
            orij.append({'id': f'node/{nid}', 'naziv': t['name'], 'vrsta': t.get('historic') or t.get('tourism'), 'tocka': [r2(x), r2(y)]})
    orij = [d for d in orij if d['vrsta'] != 'attraction']
    S['orijentiri'] = orij
    S['_park_oznake'] = park_oznake
    return S


def nadji_put(o: Osm, uvjet):
    return [(wid, refs, t) for wid, (refs, t) in o.ways.items() if uvjet(t)]


# --- izvedeno: os Maksimirske --------------------------------------------------------------------------
def os_maksimirske(o: Osm) -> dict:
    maks = nadji_put(o, lambda t: t.get('highway') and t.get('name') == 'Maksimirska cesta')
    svet = nadji_put(o, lambda t: t.get('highway') and t.get('name') in ('Svetice', 'Ulica Svetice'))
    hond = nadji_put(o, lambda t: t.get('highway') and 'Hondla' in t.get('name', ''))
    cvorovi_m = {r for _, refs, _ in maks for r in refs}
    zajednicki_s = [r for _, refs, _ in svet for r in refs if r in cvorovi_m]
    zajednicki_h = [r for _, refs, _ in hond for r in refs if r in cvorovi_m]
    if not zajednicki_s or not zajednicki_h:
        raise SystemExit('Nisam našao raskrižja Maksimirske sa Sveticama ili Hondlovom.')
    # graf Maksimirske; najkraći put između raskrižja
    susjedi: dict[str, list[tuple[str, float]]] = {}
    for _, refs, _ in maks:
        for a, b in zip(refs, refs[1:]):
            if a in o.nodes and b in o.nodes:
                d = math.dist(o.nodes[a][:2], o.nodes[b][:2])
                susjedi.setdefault(a, []).append((b, d))
                susjedi.setdefault(b, []).append((a, d))
    import heapq
    start, cilj = zajednicki_s[0], set(zajednicki_h)
    dist, pret, hp = {start: 0.0}, {}, [(0.0, start)]
    kraj = None
    while hp:
        d, u = heapq.heappop(hp)
        if u in cilj:
            kraj = u
            break
        if d > dist.get(u, 1e18):
            continue
        for v, w in susjedi.get(u, []):
            if d + w < dist.get(v, 1e18):
                dist[v], pret[v] = d + w, u
                heapq.heappush(hp, (d + w, v))
    if kraj is None:
        raise SystemExit('Maksimirska nije povezana između raskrižja.')
    lanac = [kraj]
    while lanac[-1] != start:
        lanac.append(pret[lanac[-1]])
    lanac.reverse()
    P = [o.nodes[r][:2] for r in lanac]
    ln = LineString(P)
    stac = []
    s = 0.0
    while s <= ln.length + 1e-6:
        p = ln.interpolate(s)
        q0, q1 = ln.interpolate(max(0.0, s - 1.0)), ln.interpolate(min(ln.length, s + 1.0))
        stac.append({'s': r2(s), 'x': r2(p.x), 'y': r2(p.y), 'azimut_deg': round(azimut((q0.x, q0.y), (q1.x, q1.y)), 1)})
        s += 10.0
    jednosmjerni = [wid for wid, refs, t in maks if t.get('oneway') == 'yes' and any(r in set(lanac) for r in refs)]
    trake = sorted({t.get('lanes') for wid, refs, t in maks if t.get('lanes') and len(set(refs) & set(lanac)) > 1})
    return {
        'naziv': 'Os Maksimirske ceste uzduž fronte (raskrižje Svetice - Ulica Aleksandra Hondla)',
        'status': 'PRETPOSTAVKA-IZRAČUN',
        'metoda': 'najkraći lanac OSM putova highway=secondary name="Maksimirska cesta" između čvora zajedničkog s ulicom Svetice '
                  'i čvora zajedničkog s Ulicom Aleksandra Hondla; stacionaža 0 na Sveticama, raste prema istoku; OSM os je crtana '
                  'linija kolnika, ne geodetska os',
        'pocetak': {'naziv': 'raskrižje Svetice / Bukovačka', 'cvor': f'node/{start}', 'tocka': koord([P[0]])[0]},
        'kraj': {'naziv': 'raskrižje Ulica Aleksandra Hondla', 'cvor': f'node/{kraj}', 'tocka': koord([P[-1]])[0]},
        'duljina_m': round(ln.length, 1),
        'azimut_pravca_deg': round(azimut(P[0], P[-1]), 1),
        'jednosmjerni_dijelovi': jednosmjerni,
        'oznake_traka_osm': trake,
        'linija': koord(P),
        'stacionaza_10m': stac,
        '_geom': ln,
    }


def tramvaj(o: Osm, S: dict, os_ln: LineString, ulaz_tocka: Point | None) -> dict:
    putovi = S['_tram_putovi']
    lin, naz = S['_linije_po_putu'], S['_naziv_rute']
    bor_st = [Point(x, y) for nid, (x, y, t) in o.nodes.items() if t.get('railway') == 'tram_stop' and t.get('name') == 'Borongaj']
    bor_c = Point(sum(p.x for p in bor_st) / len(bor_st), sum(p.y for p in bor_st) / len(bor_st)) if bor_st else None
    maks_sve = unary_union([LineString(o.pts(refs)) for wid, refs, t in nadji_put(o, lambda t: t.get('highway') and t.get('name') == 'Maksimirska cesta')])
    pruge = []
    NAZIVI = {
        'maksimirska_pruga': 'Pruga uzduž Maksimirske ceste',
        'okretiste_linije_5': 'Okretište linije 5 kod glavnog ulaza u park (stajalište Park Maksimir)',
        'borongaj_okretiste': 'Okretište Borongaj',
        'borongaj_prilaz': 'Prilazna pruga okretištu Borongaj (Ulica Divka Budaka)',
        'ostalo': 'Ostale tramvajske pruge',
    }
    for wid, (refs, t) in sorted(putovi.items()):
        p = o.pts(refs)
        if len(p) < 2:
            continue
        g = LineString(p)
        refs_lin = lin.get(wid, set())
        nazivi = ' '.join(naz.get(wid, set()))
        if bor_c is not None and all(Point(q).distance(bor_c) < 100 for q in p):
            sk = 'borongaj_okretiste'
        elif 'Borongaj' in nazivi:
            sk = 'borongaj_prilaz'
        elif ulaz_tocka is not None and refs_lin <= {'5'} and all(Point(q).distance(ulaz_tocka) < 130 for q in p):
            sk = 'okretiste_linije_5'
        elif max(Point(q).distance(maks_sve) for l in dijelovi_linije(g.intersection(OKVIR)) for q in l.coords) < 25:
            sk = 'maksimirska_pruga'
        else:
            sk = 'ostalo'
        for i, ln in enumerate(dijelovi_linije(g.intersection(OKVIR))):
            c = list(ln.coords)
            az = azimut(c[0], c[-1])
            d = {'id': f'way/{wid}' + (f'#{i}' if i else ''), 'skupina': sk, 'naziv': NAZIVI[sk],
                 'linije_osm': sorted(refs_lin, key=lambda v: (len(v), v)), 'jednosmjerna': t.get('oneway'),
                 'smjer_voznje': ('prema istoku' if 0 < az < 180 else 'prema zapadu') if sk in ('maksimirska_pruga', 'borongaj_prilaz') else None,
                 'duljina_m': round(ln.length, 1), 'linija': koord(c)}
            if sk == 'maksimirska_pruga':
                uz_frontu = [q for q in c if os_ln.distance(Point(q)) < 12 and 1 < os_ln.project(Point(q)) < os_ln.length - 1]
                if uz_frontu:
                    d['odmak_od_osi_uz_frontu_m'] = round(sum(os_ln.distance(Point(q)) for q in uz_frontu) / len(uz_frontu), 1)
                    q = uz_frontu[len(uz_frontu) // 2]
                    sq = os_ln.project(Point(q))
                    p0, p1 = os_ln.interpolate(sq - 1), os_ln.interpolate(sq + 1)
                    lijevo = (p1.x - p0.x) * (q[1] - p0.y) - (p1.y - p0.y) * (q[0] - p0.x) > 0
                    d['strana_od_osi'] = 'sjever' if lijevo else 'jug'
            pruge.append(d)
    skupine = {}
    for sk, nazv in NAZIVI.items():
        dio = [d for d in pruge if d['skupina'] == sk]
        if not dio:
            continue
        g = unary_union([LineString(d['linija']) for d in dio])
        skupine[sk] = {'naziv': nazv, 'putovi': [d['id'] for d in dio], 'duljina_kolosijeka_m': round(sum(d['duljina_m'] for d in dio)),
                       'raspon': raspon(g), 'linije_osm': sorted({l for d in dio for l in d['linije_osm']}, key=lambda v: (len(v), v))}
    return {'status': 'POTVRĐENO kao OSM geometrija (orijentacijski); nazivi skupina su naše razvrstavanje',
            'metoda': 'railway=tram; skupine po članstvu u OSM relacijama linija, udaljenosti od stajališta Borongaj i od slavoluka glavnog ulaza',
            'pruge': pruge, 'skupine': skupine}


# --- izvedeno: profil koridora ---------------------------------------------------------------------------
def profil_koridora(o: Osm, S: dict, os: dict, stadion, src, rec) -> dict:
    ln: LineString = os['_geom']
    R = 70.0
    zona = ln.buffer(R + 5)

    def unija(geoms):
        gs = [g for g in geoms if g is not None and not g.is_empty and g.intersects(zona)]
        return unary_union(gs) if gs else None

    def gr(pg):
        return pg.boundary

    kat = {
        'kolosijek': unija([LineString(o.pts(refs)) for refs, t in S['_tram_putovi'].values()]),
        'nogostup': unija([LineString(d['linija']) for d in S['pjesacke_staze'] if d.get('podvrsta') == 'sidewalk']),
        'staza': unija([LineString(d['linija']) for d in S['pjesacke_staze'] if d.get('podvrsta') not in ('sidewalk', 'crossing')]),
        'ograda': unija([LineString(d['linija']) for d in S['ograde'] if d.get('barrier') == 'fence']),
        'zivica_zid': unija([LineString(d['linija']) for d in S['ograde'] if d.get('barrier') != 'fence']
                            + [LineString(d['linija']) for d in S['zelenilo']['zivice']]),
        'zgrada': unija([gr(Polygon(d['poligon'])) for d in S['zgrade'] if d['vrsta'] not in ('roof', 'shelter', 'kiosk')]),
        'park_granica': unija([gr(S['_park_geom'])]),
        'stadion_obris': unija([gr(stadion)]) if stadion is not None else None,
        'src_obris': unija([gr(src)]) if src is not None else None,
        'kompleks_dinama': unija([gr(rec)]) if rec is not None else None,
        'zelena_povrsina': unija([gr(Polygon(d['poligon'])) for d in S['zelenilo']['travnjaci'] + S['zelenilo']['parkovi']]),
        'parkiraliste': unija([gr(Polygon(d['poligon'])) for d in S['parkiralista']]),
    }
    profil = []
    for st in os['stacionaza_10m']:
        s = st['s']
        p = ln.interpolate(s)
        a, b = ln.interpolate(max(0, s - 1)), ln.interpolate(min(ln.length, s + 1))
        tx, ty = b.x - a.x, b.y - a.y
        n = math.hypot(tx, ty)
        tx, ty = tx / n, ty / n
        red = {'s': s}
        for strana, (nx, ny) in (('sjever', (-ty, tx)), ('jug', (ty, -tx))):
            zraka = LineString([(p.x + nx * 0.5, p.y + ny * 0.5), (p.x + nx * R, p.y + ny * R)])
            for k, g in kat.items():
                if g is None:
                    continue
                presjek = zraka.intersection(g)
                if presjek.is_empty:
                    continue
                red[f'{strana}_{k}'] = round(min(p.distance(Point(c)) for geom in (getattr(presjek, 'geoms', None) or [presjek]) for c in geom.coords), 1)
        profil.append(red)

    unutra = [r for r in profil if 15 <= r['s'] <= ln.length - 15]  # bez raskrižja na krajevima

    def stat(v):
        v = sorted(v)
        return {'n': len(v), 'od_stacionaza': len(unutra), 'min': v[0], 'medijan': v[len(v) // 2], 'max': v[-1]} if v else None

    kljucevi = sorted({k for r in profil for k in r if k != 's'})
    sazetak = {k: stat([r[k] for r in unutra if k in r]) for k in kljucevi}
    # rub uz cestu: najbliži OSM rub iza nogostupa. Sjever: poligon šume, živica/zid, ograda, zgrada.
    # Jug: obris stadiona, rub kompleksa Dinama, zgrada, živica/zid, rub travnjaka/parka. Ograde (fence) na jugu se NE broje:
    # na 6,7-7,3 m od osi to su zaštitne ograde uz kolnik, ne rub čestice.
    K_SJ = ('sjever_park_granica', 'sjever_zivica_zid', 'sjever_ograda', 'sjever_zgrada')
    K_JU = ('jug_stadion_obris', 'jug_kompleks_dinama', 'jug_zgrada', 'jug_zivica_zid', 'jug_zelena_povrsina')
    sirine = []
    for r in unutra:
        sj = [(r[k], k[7:]) for k in K_SJ if k in r]
        ju = [(r[k], k[4:]) for k in K_JU if k in r]
        if sj and ju:
            (a, ka), (b, kb) = min(sj), min(ju)
            sirine.append({'s': r['s'], 'sjever_m': a, 'sjever_rub': ka, 'jug_m': b, 'jug_rub': kb, 'sirina_m': round(a + b, 1)})
    procelje = [d['sirina_m'] for d in sirine if d['jug_rub'] == 'stadion_obris']
    staze = [round(r['sjever_staza'] + r['jug_staza'], 1) for r in unutra if r.get('sjever_staza', 99) < 14 and r.get('jug_staza', 99) < 14]
    lijevo = ln.parallel_offset(14.0, 'left')
    desno = ln.parallel_offset(14.0, 'right')

    def jedna(g):
        ds = dijelovi_linije(g) or [g]
        return koord(max(ds, key=lambda q: q.length).coords)
    return {
        'status': 'PRETPOSTAVKA-IZRAČUN',
        'metoda': 'iz svake stacionažne točke (korak 10 m) okomita zraka 70 m na sjever i jug; bilježi se prvi presjek s OSM slojem. '
                  'OSM ne sadrži građevinske ni regulacijske linije. "Rub uz cestu" je najbliži od: rub poligona šume, živica/zid, ograda, zgrada '
                  '(sjever) odnosno obris stadiona, rub kompleksa Dinama, zgrada, živica/zid, rub travnjaka ili parka (jug); zaštitne ograde uz kolnik '
                  'na jugu se ne broje. Sažeci su bez prvih i zadnjih 15 m (raskrižja). Širina 28 m ostaje PRETPOSTAVKA.',
        'rub_sjever_pretpostavka_14m': jedna(lijevo), 'rub_jug_pretpostavka_14m': jedna(desno),
        'sirina_pretpostavka_m': 28.0,
        'izmjereno_po_slojevima_m': sazetak,
        'sirina_izmedju_rubova_uz_cestu_m': stat([d['sirina_m'] for d in sirine]),
        'sirina_zivica_parka_do_obrisa_stadiona_m': stat(procelje),
        'sirina_izmedju_osi_pjesackih_staza_uz_cestu_m': stat(staze),
        'rubovi_po_stacionazi': sirine,
        'profil_po_stacionazi': profil,
    }


# --- ispis ---------------------------------------------------------------------------------------------
def ocisti(obj):
    if isinstance(obj, dict):
        return {k: ocisti(v) for k, v in obj.items() if not k.startswith('_') and v is not None}
    if isinstance(obj, list):
        return [ocisti(v) for v in obj]
    return obj


def zapisi_json(put: str, podaci: dict):
    """Čitljiv zapis: svaka značajka u jednom retku, strukture više razine uvučene."""
    def kompakt(v):
        return json.dumps(v, ensure_ascii=False, separators=(',', ':'))

    def jednostavno(v):
        return not isinstance(v, (dict, list)) or (isinstance(v, list) and all(not isinstance(q, (dict, list)) for q in v))

    def pisi(v, uvlaka, dubina):
        raz = ' ' * uvlaka
        if isinstance(v, dict) and dubina < 3 and not all(jednostavno(q) for q in v.values()) or (isinstance(v, dict) and dubina == 0):
            dijelovi = [f'{raz} {json.dumps(k, ensure_ascii=False)}: {pisi(q, uvlaka + 1, dubina + 1)}' for k, q in v.items()]
            return '{\n' + ',\n'.join(dijelovi) + f'\n{raz}}}'
        if isinstance(v, list) and v and isinstance(v[0], dict):
            return '[\n' + ',\n'.join(f'{raz} {kompakt(q)}' for q in v) + f'\n{raz}]'
        return kompakt(v)

    with open(put, 'w', encoding='utf-8') as f:
        f.write(pisi(podaci, 0, 0) + '\n')


# --- pregled (PNG) ---------------------------------------------------------------------------------------
BOJE = {
    'podloga': '#f5f2ea', 'suma': '#a7cfa0', 'park_suma': '#8fc08a', 'park': '#c3e2b5', 'trava': '#dcebc9', 'voda': '#8ec5ea',
    'parking': '#dedede', 'teren': '#9fd19a', 'staza_atl': '#d99a6c', 'zgrada': '#cdbfae', 'zgrada_rub': '#8f8171',
    'tribina': '#7fa3d6', 'cesta_rub': '#9a9a9a', 'cesta': '#ffffff', 'staza': '#b99b6b', 'tram': '#d62728', 'tram5': '#c218b0',
    'borongaj': '#ff7f0e', 'zeljeznica': '#222222', 'stadion': '#1f4fb0', 'src': '#7b3fa0', 'bazen': '#008a9a', 'park_gr': '#1b6e2a',
    'os': '#000000', 'koridor': '#555555', 'obuhvat': '#e0301e', 'zona': '#e0301e', 'tekst': '#222222', 'mreza': '#c9c4b8',
    'stablo': '#3f8f3f', 'ograda': '#8a8a8a', 'bus': '#1f5fbf',
}
SIRINA_CESTE = {'secondary': 9, 'tertiary': 7.5, 'residential': 5.5, 'unclassified': 5.5, 'service': 3.5, 'secondary_link': 5,
                'tertiary_link': 5, 'living_street': 5, 'construction': 4}


def crtaj_pregled(put: str, site: dict, interno: dict):
    from PIL import Image, ImageDraw, ImageFont
    SS = 2
    fput = '/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf'
    fputb = '/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf'

    def font(vel, bold=False):
        for kandidat in ((fputb if bold else fput), 'DejaVuSans-Bold.ttf' if bold else 'DejaVuSans.ttf'):
            try:
                return ImageFont.truetype(kandidat, int(vel * SS))
            except OSError:
                continue
        raise SystemExit('Font DejaVu Sans nije dostupan.')

    okv = OKVIR.bounds
    paneli = [
        {'naslov': 'Blisko polje (okvir preuzimanja)', 'bounds': okv, 'mj': 1.15, 'detalj': False},
        {'naslov': 'Lokacija: fronta Maksimirske, stadion, SRC Svetice, Borongaj', 'bounds': (-540, -660, 500, 320), 'mj': 2.25, 'detalj': True},
    ]
    RUB, VRH, DNO = 30, 96, 250
    x0 = RUB
    for pn in paneli:
        a, b, c, d = pn['bounds']
        pn['w'], pn['h'] = int((c - a) * pn['mj']), int((d - b) * pn['mj'])
        pn['ox'], pn['oy'] = x0, VRH
        x0 += pn['w'] + RUB
    W, H = x0, VRH + max(pn['h'] for pn in paneli) + DNO
    img = Image.new('RGB', (W * SS, H * SS), '#ffffff')
    dr = ImageDraw.Draw(img)

    def crtaj_panel(pn):
        a, b, c, d = pn['bounds']
        mj = pn['mj'] * SS
        ox, oy = pn['ox'] * SS, pn['oy'] * SS
        pw, ph = pn['w'] * SS, pn['h'] * SS
        sloj = Image.new('RGB', (pw, ph), BOJE['podloga'])
        g = ImageDraw.Draw(sloj)
        okvir_p = box(a, b, c, d)

        def px(pt):
            return ((pt[0] - a) * mj, (d - pt[1]) * mj)

        def vidljiv(pts):
            xs = [p[0] for p in pts]
            ys = [p[1] for p in pts]
            return not (max(xs) < a or min(xs) > c or max(ys) < b or min(ys) > d)

        def poly(f, fill, outline=None, w=1):
            pts = f['poligon'] if isinstance(f, dict) else f
            if not vidljiv(pts):
                return
            g.polygon([px(p) for p in pts], fill=fill)
            if isinstance(f, dict):
                for rupa in f.get('rupe', []):
                    g.polygon([px(p) for p in rupa], fill=BOJE['podloga'])
            if outline:
                g.line([px(p) for p in pts] + [px(pts[0])], fill=outline, width=max(1, int(w * SS)))

        def line(pts, fill, w, crt=None):
            if len(pts) < 2 or not vidljiv(pts):
                return
            sir = max(1, int(round(w * SS)))
            if not crt:
                g.line([px(p) for p in pts], fill=fill, width=sir, joint='curve')
                return
            ln = LineString(pts)
            puno, prazno = crt
            s = 0.0
            while s < ln.length:
                p0, p1 = ln.interpolate(s), ln.interpolate(min(ln.length, s + puno))
                g.line([px((p0.x, p0.y)), px((p1.x, p1.y))], fill=fill, width=sir)
                s += puno + prazno

        def tekst(pt, s, vel=11, boja=BOJE['tekst'], bold=False, sidro='mm', podloga=True):
            f = font(vel, bold)
            x, y = px(pt)
            if podloga:
                bb = g.textbbox((x, y), s, font=f, anchor=sidro)
                g.rectangle((bb[0] - 2 * SS, bb[1] - 1 * SS, bb[2] + 2 * SS, bb[3] + 1 * SS), fill='#ffffff')
            g.text((x, y), s, font=f, fill=boja, anchor=sidro)

        Z = site['zelenilo']
        for f in Z['travnjaci']:
            poly(f, BOJE['trava'])
        for f in Z['parkovi']:
            poly(f, BOJE['park'])
        for f in Z['sume']:
            poly(f, BOJE['suma'])
        for f in site['park_maksimir']['granica_osm_u_okviru']:
            poly(f, BOJE['park_suma'])
        for f in site['vode']['povrsine']:
            poly(f, BOJE['voda'])
        for f in site['vode']['tokovi']:
            line(f['linija'], BOJE['voda'], 1.2)
        for f in site['parkiralista']:
            poly(f, BOJE['parking'])
        for f in site['pjesacke_povrsine']:
            poly(f, '#ece6d8')
        for f in site['sportski_tereni']:
            poly(f, BOJE['staza_atl'] if f.get('leisure') == 'track' else BOJE['teren'], '#6aa568', 0.5)
        ceste = sorted(site['ceste'], key=lambda f: SIRINA_CESTE.get(f['razred'], 4))
        for rub in (True, False):
            for f in ceste:
                sir_m = SIRINA_CESTE.get(f['razred'], 4)
                sir = max(1.2, sir_m * pn['mj']) if pn['detalj'] else max(0.8, sir_m * pn['mj'] * 0.9)
                line(f['linija'], BOJE['cesta_rub'] if rub else BOJE['cesta'], sir + (1.4 if rub else 0))
        if pn['detalj']:
            for f in site['pjesacke_staze']:
                line(f['linija'], BOJE['staza'], 0.7)
            for f in site['ograde']:
                line(f['linija'], BOJE['ograda'], 0.6, (2.5, 2.0))
        tribine = {t['id'] for t in site['stadion_maksimir']['tribine']}
        for f in site['zgrade']:
            poly(f, BOJE['tribina'] if f['id'] in tribine else BOJE['zgrada'], BOJE['zgrada_rub'], 0.4)
        for f in Z['drvoredi']:
            line(f['linija'], BOJE['stablo'], 1.2, (2, 3))
        r = (1.4 if pn['detalj'] else 0.8) * SS
        for x, y in Z['stabla']:
            if a <= x <= c and b <= y <= d:
                X, Y = px((x, y))
                g.ellipse((X - r, Y - r, X + r, Y + r), fill=BOJE['stablo'])
        for f in site['zeljeznica']['pruge']:
            line(f['linija'], BOJE['zeljeznica'], 2.2)
            line(f['linija'], '#ffffff', 1.0, (6, 6))
        for f in site['tramvaj']['pruge']:
            boja = {'okretiste_linije_5': BOJE['tram5'], 'borongaj_okretiste': BOJE['borongaj'], 'borongaj_prilaz': BOJE['borongaj']}.get(f['skupina'], BOJE['tram'])
            line(f['linija'], boja, 1.6 if pn['detalj'] else 1.3)
        # posebni obrisi
        line(site['stadion_maksimir']['obris']['poligon'], BOJE['stadion'], 2.0)
        line(site['src_svetice']['obris']['poligon'], BOJE['src'], 1.8, (10, 5))
        line(site['bazen_svetice']['obris']['poligon'], BOJE['bazen'], 2.0)
        gpm = site['izvedeno']['granica_parka_prema_maksimirskoj']
        for f in gpm['rub_poligona_sume']:
            line(f, BOJE['park_gr'], 1.2, (4, 3))
        for f in gpm['linije']:
            line(f['linija'], BOJE['park_gr'], 2.6)
        for f in gpm['zapadni_nastavak_crkvena_cestica']:
            line(f['linija'], BOJE['park_gr'], 1.4, (5, 4))
        ul = site['park_maksimir']['glavni_ulaz']
        if ul:
            poly(ul['poligon'], '#ffd24d', '#7a5a00', 1.0)
        # izvedeno
        izv = site['izvedeno']
        for kljuc in ('rub_sjever_pretpostavka_14m', 'rub_jug_pretpostavka_14m'):
            line(izv['koridor_maksimirske'][kljuc], BOJE['koridor'], 0.9, (6, 4))
        line(izv['os_maksimirske']['linija'], BOJE['os'], 1.2, (12, 4))
        ob = izv.get('obuhvat_i_zone')
        if ob:
            line(ob['sira_zona']['poligon'] + [ob['sira_zona']['poligon'][0]], BOJE['obuhvat'], 1.6, (9, 6))
            line(ob['uza_zona']['poligon'] + [ob['uza_zona']['poligon'][0]], BOJE['obuhvat'], 2.2)
            for z in ob['zone']:
                if z['id'] in ('A', 'B'):
                    line(z['poligon'] + [z['poligon'][0]], BOJE['zona'], 1.1, (3, 3))
        # stajališta
        for vrsta, boja in (('tramvaj', BOJE['tram']), ('autobus', BOJE['bus'])):
            for f in site['stajalista'][vrsta]:
                if 'tocka' in f and a <= f['tocka'][0] <= c and b <= f['tocka'][1] <= d:
                    X, Y = px(f['tocka'])
                    q = (3.2 if pn['detalj'] else 2.2) * SS
                    if vrsta == 'tramvaj':
                        g.ellipse((X - q, Y - q, X + q, Y + q), fill='#ffffff', outline=boja, width=int(1.2 * SS))
                    else:
                        g.rectangle((X - q * 0.8, Y - q * 0.8, X + q * 0.8, Y + q * 0.8), fill='#ffffff', outline=boja, width=int(1.2 * SS))
        for f in site['zeljeznica']['stajalista']:
            X, Y = px(f['tocka'])
            q = 4 * SS
            g.rectangle((X - q, Y - q, X + q, Y + q), fill='#222222')
        # mreža i natpisi
        korak = 100 if pn['detalj'] else 500
        fm = font(8)
        xg = math.ceil(a / korak) * korak
        while xg <= c:
            if pn['detalj']:
                g.line([px((xg, b)), px((xg, d))], fill=BOJE['mreza'], width=1)
            g.text((px((xg, b))[0], ph - 3 * SS), f'x {xg:.0f}', font=fm, fill='#666666', anchor='mb')
            xg += korak
        yg = math.ceil(b / korak) * korak
        while yg <= d:
            if pn['detalj']:
                g.line([px((a, yg)), px((c, yg))], fill=BOJE['mreza'], width=1)
            g.text((3 * SS, px((a, yg))[1]), f'y {yg:.0f}', font=fm, fill='#666666', anchor='lm')
            yg += korak
        X, Y = px((0, 0))
        g.line((X - 8 * SS, Y, X + 8 * SS, Y), fill='#000000', width=SS)
        g.line((X, Y - 8 * SS, X, Y + 8 * SS), fill='#000000', width=SS)
        if pn['detalj']:
            tekst((2, -9), 'ishodište (0,0)', 8, sidro='lt')
            for st in izv['os_maksimirske']['stacionaza_10m']:
                if st['s'] % 100 == 0:
                    az = math.radians(st['azimut_deg'])
                    nx, ny = -math.cos(az), math.sin(az)
                    line([(st['x'] - nx * 6, st['y'] - ny * 6), (st['x'] + nx * 6, st['y'] + ny * 6)], BOJE['os'], 1.4)
                    tekst((st['x'] + nx * 30, st['y'] + ny * 30), f"{st['s']:.0f}", 8, sidro='mm')
            natpisi = interno['natpisi']
            for pt, s, vel, boja, bold in natpisi:
                tekst(pt, s, vel, boja, bold)
            if ob:
                for z in ob['zone']:
                    tekst(z['oznaka_tocka'], z['id'], 22, BOJE['zona'], True)
        else:
            for pt, s in interno['natpisi_sire']:
                tekst(pt, s, 9)
            a2, b2, c2, d2 = paneli[1]['bounds']
            line([(a2, b2), (c2, b2), (c2, d2), (a2, d2), (a2, b2)], '#000000', 1.0, (8, 6))
        # mjerilo i sjever
        dulj = 200 if pn['detalj'] else 500
        mx, my = 24 * SS, ph - 30 * SS
        g.rectangle((mx - 8 * SS, my - 22 * SS, mx + dulj * mj + 8 * SS, my + 10 * SS), fill='#ffffff', outline='#888888')
        for i in range(4):
            g.rectangle((mx + i * dulj * mj / 4, my - 4 * SS, mx + (i + 1) * dulj * mj / 4, my + 2 * SS), fill='#000000' if i % 2 == 0 else '#ffffff', outline='#000000')
        g.text((mx, my - 7 * SS), '0', font=font(9), fill='#000000', anchor='lb')
        g.text((mx + dulj * mj, my - 7 * SS), f'{dulj} m', font=font(9), fill='#000000', anchor='rb')
        g.text((mx + dulj * mj / 2, my - 7 * SS), f'1 px = {1 / pn["mj"]:.2f} m', font=font(8), fill='#444444', anchor='mb')
        sx, sy = pw - 34 * SS, 54 * SS
        g.ellipse((sx - 24 * SS, sy - 40 * SS, sx + 24 * SS, sy + 26 * SS), fill='#ffffff', outline='#888888')
        g.polygon([(sx, sy - 30 * SS), (sx - 9 * SS, sy + 6 * SS), (sx, sy - 2 * SS)], fill='#000000')
        g.polygon([(sx, sy - 30 * SS), (sx + 9 * SS, sy + 6 * SS), (sx, sy - 2 * SS)], fill='#ffffff', outline='#000000')
        g.text((sx, sy + 9 * SS), 'S', font=font(13, True), fill='#000000', anchor='mt')
        img.paste(sloj, (ox, oy))
        dr.rectangle((ox, oy, ox + pw, oy + ph), outline='#444444', width=SS)
        dr.text((ox, oy - 6 * SS), pn['naslov'], font=font(13, True), fill='#222222', anchor='lb')

    for pn in paneli:
        crtaj_panel(pn)
    dr.text((RUB * SS, 12 * SS), 'Maksimir i SRC Svetice: postojeće stanje iz OpenStreetMapa u lokalnom ENU (podloga za tlocrte i 3D model)',
            font=font(19, True), fill='#111111')
    dr.text((RUB * SS, 40 * SS), f"x prema istoku, y prema sjeveru, ishodište 45,8187° N, 16,0185° E · preuzeto {site['meta']['datum_preuzimanja_hr']} · "
            'orijentacijski, nije geodetska podloga · obuhvat, zone i koridor 28 m: PRETPOSTAVKA', font=font(11), fill='#444444')
    # legenda
    ly = (VRH + max(pn['h'] for pn in paneli) + 18) * SS
    stavke = [
        ('poly', BOJE['zgrada'], 'zgrada'), ('poly', BOJE['tribina'], 'tribina stadiona'), ('poly', BOJE['park_suma'], 'OSM poligon „Park šuma Maksimir”'),
        ('poly', BOJE['suma'], 'šuma'), ('poly', BOJE['park'], 'park, vrt, igralište'), ('poly', BOJE['trava'], 'travnjak'),
        ('poly', BOJE['voda'], 'voda'), ('poly', BOJE['teren'], 'sportski teren'), ('poly', BOJE['parking'], 'parkiralište'),
        ('line', BOJE['cesta_rub'], 'cesta'), ('line', BOJE['staza'], 'pješačka staza'), ('line', BOJE['tram'], 'tramvaj: Maksimirska'),
        ('line', BOJE['tram5'], 'tramvaj: okretište linije 5'), ('line', BOJE['borongaj'], 'tramvaj: Borongaj i prilaz'),
        ('line', BOJE['zeljeznica'], 'željeznica (M102)'), ('line', BOJE['stadion'], 'obris stadiona Maksimir'), ('dash', BOJE['src'], 'obris SRC Svetice (OSM)'),
        ('line', BOJE['bazen'], 'bazenski kompleks Svetice'), ('line', BOJE['park_gr'], 'rub parka prema Maksimirskoj (OSM živica i ograda)'),
        ('dash', BOJE['os'], 'os Maksimirske sa stacionažom (m)'), ('dash', BOJE['koridor'], 'koridor ±14 m (PRETPOSTAVKA)'),
        ('line', BOJE['obuhvat'], 'uža zona natječaja (PRETPOSTAVKA)'), ('dash', BOJE['obuhvat'], 'šira zona i zone A–D (PRETPOSTAVKA)'),
        ('dot', BOJE['stablo'], 'stablo / drvored'), ('krug', BOJE['tram'], 'tramvajsko stajalište'), ('kvadrat', BOJE['bus'], 'autobusno stajalište'),
        ('poly', '#ffd24d', 'glavni ulaz u park (slavoluk)'),
    ]
    fl = font(10.5)
    kol_w = 330 * SS
    po_stupcu = 6
    for i, (vrsta, boja, opis) in enumerate(stavke):
        cx = RUB * SS + (i // po_stupcu) * kol_w
        cy = ly + (i % po_stupcu) * 21 * SS
        if vrsta == 'poly':
            dr.rectangle((cx, cy, cx + 26 * SS, cy + 13 * SS), fill=boja, outline='#777777')
        elif vrsta == 'line':
            dr.line((cx, cy + 7 * SS, cx + 26 * SS, cy + 7 * SS), fill=boja, width=3 * SS)
        elif vrsta == 'dash':
            for k in range(3):
                dr.line((cx + k * 10 * SS, cy + 7 * SS, cx + k * 10 * SS + 6 * SS, cy + 7 * SS), fill=boja, width=3 * SS)
        elif vrsta == 'dot':
            dr.ellipse((cx + 10 * SS, cy + 3 * SS, cx + 17 * SS, cy + 10 * SS), fill=boja)
        elif vrsta == 'krug':
            dr.ellipse((cx + 8 * SS, cy + 1 * SS, cx + 19 * SS, cy + 12 * SS), fill='#ffffff', outline=boja, width=2 * SS)
        else:
            dr.rectangle((cx + 9 * SS, cy + 2 * SS, cx + 18 * SS, cy + 11 * SS), fill='#ffffff', outline=boja, width=2 * SS)
        dr.text((cx + 34 * SS, cy + 6 * SS), opis, font=fl, fill='#222222', anchor='lm')
    dr.text((RUB * SS, (H - 62) * SS), 'Podaci: © OpenStreetMap contributors, ODbL 1.0 (openstreetmap.org/copyright). Obrada: scripts/viz/gradi_site.py.',
            font=font(10.5), fill='#333333')
    dr.text((RUB * SS, (H - 44) * SS), 'Podloga za AI građanski koncept „Maksimir iznad prometa”: prikaz postojećeg stanja, ne projekt ni geodetska izmjera. '
            'Granice zona prema Natječajnom programu (str. 12–13, 43, 52–54) ucrtane su približno, uz OSM geometriju.', font=font(10.5), fill='#333333')
    dr.text((RUB * SS, (H - 26) * SS), 'OSM nema zakonsku granicu zaštićenog parka (Z-1528, park-arhitektura); prikazani su poligon šume i živica uz cestu kao orijentir.',
            font=font(10.5), fill='#333333')
    img = img.resize((W, H), Image.LANCZOS)
    # paleta od 256 boja (octree, bez rasterskog šuma): oko 5 puta manja datoteka, boje slojeva ostaju razlučive
    img.quantize(colors=256, method=Image.Quantize.FASTOCTREE, dither=Image.Dither.NONE).save(put, optimize=True)
    return W, H


# --- izvedeno: rub parka, obuhvat i zone -----------------------------------------------------------------
def maksimirska_u_okviru(o: Osm) -> LineString:
    """Cijela Maksimirska u okviru kao jedna linija usmjerena od zapada prema istoku."""
    g = linemerge(unary_union([LineString(o.pts(refs)) for wid, refs, t in
                               nadji_put(o, lambda t: t.get('highway') and t.get('name') == 'Maksimirska cesta')]))
    dio = max(dijelovi_linije(g.intersection(OKVIR)), key=lambda q: q.length)
    c = list(dio.coords)
    return LineString(c if c[0][0] < c[-1][0] else c[::-1])


def granica_parka(o: Osm, S: dict, maks: LineString, s0: float, ulaz, K: dict) -> dict:
    """Rub parka prema Maksimirskoj: OSM živice i ograde uz sjeverni rub ceste + rub OSM poligona šume."""
    park = S['_park_geom']
    pojas = maks.buffer(40, single_sided=True).difference(maks.buffer(6, single_sided=True))  # 6-40 m sjeverno od osi
    crkva = [Polygon(d['poligon']) for d in S['namjene'] if d.get('landuse') == 'religious']
    crkva_g = unary_union(crkva).buffer(4) if crkva else None
    x_ulaz = ulaz.bounds[0] - 25 if ulaz is not None else -1e9
    linije, zapad = [], []
    for d in S['ograde'] + S['zelenilo']['zivice']:
        g = LineString(d['linija'])
        if not g.intersects(pojas):
            continue
        for i, ln in enumerate(dijelovi_linije(g.intersection(pojas))):
            if ln.length < 2:
                continue
            c = list(ln.coords)
            if c[0][0] > c[-1][0]:
                c = c[::-1]
            z = {'id': d['id'] + (f'#{i}' if i else ''), 'vrsta': d.get('barrier', 'hedge'), 'duljina_m': round(ln.length, 1),
                 'stacionaza_od_do_m': [round(maks.project(Point(c[0])) - s0, 1), round(maks.project(Point(c[-1])) - s0, 1)],
                 'udaljenost_od_osi_m': [round(min(maks.distance(Point(q)) for q in c), 1), round(max(maks.distance(Point(q)) for q in c), 1)],
                 'linija': koord(c)}
            if d.get('height'):
                z['visina_oznaka_m'] = d['height']
            if z['stacionaza_od_do_m'][1] < -5 or z['udaljenost_od_osi_m'][0] > 26:
                continue  # zapadno od raskrižja Svetice / Bukovačka ili ograda koja nije uz cestu
            if c[-1][0] < x_ulaz or (crkva_g is not None and crkva_g.contains(ln.interpolate(0.5, normalized=True)) and c[0][0] < x_ulaz + 25):
                zapad.append(z)
            else:
                linije.append(z)
    linije.sort(key=lambda z: z['stacionaza_od_do_m'][0])
    zapad.sort(key=lambda z: z['stacionaza_od_do_m'][0])
    rub = linemerge(MultiLineString([LineString(p.exterior.coords) for p in dijelovi_poligona(park)]).intersection(maks.buffer(45)))
    return {
        'status': 'PRETPOSTAVKA',
        'metoda': 'OSM barrier=hedge/fence/wall u pojasu 6-40 m sjeverno od OSM osi Maksimirske, od raskrižja Svetice do istočnog ruba okvira; '
                  'stacionaža je stacionaža fronte (0 na Sveticama; iznad 722 m je istočno od Hondlove). Istočno od glavnog ulaza to je neprekinuta živica uz cestu; zapadno od ulaza živica omeđuje '
                  'česticu crkve sv. Jeronima i Haulikova ljetnikovca (landuse=religious). Posebno je dan rub OSM poligona šume (relacija 1147778).',
        'napomena': 'OSM ne nosi zakonsku granicu zaštite (kulturno dobro Z-1528; park-arhitektura). Program (str. 46) kaže da zelenilo uz '
                    'Maksimirsku UNUTAR natječajnog obuhvata čini rubni, kontaktni dio zaštićenog Parka Maksimir, pa zaštićeno područje vjerojatno '
                    'prelazi i na južnu stranu ceste. Granicu treba preuzeti s GUP-a 4c (Program, pogl. 5.10) ili iz registra: OTVORENO.',
        'linije': linije,
        'zapadni_nastavak_crkvena_cestica': zapad,
        'rub_poligona_sume': [koord(l.coords) for l in dijelovi_linije(rub) if l.length > 15],
        'udaljenost_poligona_sume_od_osi_fronte_m': K['izmjereno_po_slojevima_m'].get('sjever_park_granica'),
        'udaljenost_zivice_od_osi_fronte_m': K['izmjereno_po_slojevima_m'].get('sjever_zivica_zid'),
    }


# Vanjski rub zone D južno od uže zone: ručno složeno uz OSM osi ulica (Hitrecova, Mije Krešića, kneza Branimira, Divka Budaka)
# prema Kartografskom prikazu 7 (Program, str. 54) i slici 6 (str. 13). Točke su u ENU; pomak od osi ulice 5-9 m za širinu kolnika.
ZONA_D_RUB_JUG = [(61, -322), (83, -411), (88, -431), (101, -472), (113, -509), (120, -527), (128, -549), (135, -558), (147, -561),
                  (150, -574), (100, -590), (75, -598), (55, -596), (48, -588), (22, -573), (-20, -547), (-62, -521), (-86, -505),
                  (-116, -487), (-146, -471), (-172, -458), (-217, -437), (-240, -427), (-267, -418), (-286, -412), (-320, -401),
                  (-347, -394), (-385, -386), (-416, -382)]


def kompleks_dinama(S: dict, stadion):
    rekr = [(Polygon(d['poligon']), d['id']) for d in S['namjene'] if d.get('landuse') == 'recreation_ground' and Polygon(d['poligon']).intersects(stadion)]
    if not rekr:
        raise SystemExit('Nema OSM poligona landuse=recreation_ground uz stadion (kompleks Dinama).')
    return max(rekr, key=lambda q: q[0].area)


def obuhvat_i_zone(o: Osm, S: dict, os_: dict, maks: LineString, stadion, src, bazen, T: dict) -> dict:
    from shapely.ops import substring
    ln: LineString = os_['_geom']
    rec, rec_id = kompleks_dinama(S, stadion)
    sj_i = max(rec.exterior.coords, key=lambda q: q[1])  # sjeveroistočni kut kompleksa uz Maksimirsku
    s_i = ln.project(Point(sj_i))
    s_z = min(ln.project(Point(q)) for q in src.exterior.coords if q[0] < src.bounds[0] + 6)
    dio = substring(ln, s_z, s_i)
    pojas_jug = dio.buffer(-60, single_sided=True).difference(dio.buffer(-14, single_sided=True))  # 14-60 m južno od osi

    def zatvori(g, r=6.0):
        g = g.buffer(r, join_style=2).buffer(-r, join_style=2)
        dij = dijelovi_poligona(g)
        return Polygon(max(dij, key=lambda q: q.area).exterior).simplify(0.3)

    uza = zatvori(unary_union([src, rec, stadion, pojas_jug]))
    zona_b = bazen.intersection(uza)
    zona_a = max(dijelovi_poligona(src.difference(bazen).intersection(uza)), key=lambda q: q.area)
    zona_c = max(dijelovi_poligona(uza.difference(unary_union([src, bazen]).buffer(0.01))), key=lambda q: q.area)

    # šira zona: koridor Maksimirske (28 m), izbočina oko okretišta linije 5, Svetice, čvorište Borongaj
    s0 = maks.project(Point(ln.coords[0]))
    koridor = substring(maks, s0 - 24, s0 + s_i).buffer(14, cap_style=2)
    petlja = [LineString(d['linija']) for d in T['pruge'] if d['skupina'] == 'okretiste_linije_5']
    izbocina = unary_union(petlja).convex_hull.buffer(7) if petlja else Polygon()
    svetice = unary_union([LineString(o.pts(refs)) for wid, refs, t in
                           nadji_put(o, lambda t: t.get('highway') == 'secondary' and t.get('name') == 'Svetice')])
    svetice = svetice.intersection(box(-470, -396, -380, ln.coords[0][1] + 14)).buffer(9, cap_style=2)
    juzni_rub_uze = [q for q in uza.exterior.coords if q[1] < -300]
    d_jezgra = Polygon(ZONA_D_RUB_JUG + [(-416, -312)] + sorted(juzni_rub_uze, key=lambda q: q[0])).buffer(0)
    sira = zatvori(unary_union([uza, koridor, izbocina, svetice, d_jezgra]), 5.0)
    zona_d = sira.difference(uza.buffer(0.01))
    d_dijelovi = sorted(dijelovi_poligona(zona_d), key=lambda q: -q.area)
    d_glavni = d_dijelovi[0]

    def z(idz, naziv, g, razina, program_m2=None, izvor='', oznaka=None):
        d = {'id': idz, 'naziv': naziv, 'razina_natjecaja': razina, 'status': 'PRETPOSTAVKA', 'izvor': izvor}
        d.update(zapis_poligona(g))
        d['povrsina_ha'] = round(g.area / 1e4, 2)
        if program_m2:
            d['povrsina_prema_programu_m2'] = program_m2
            d['razlika_posto'] = round((g.area / program_m2 - 1) * 100, 1)
        t = oznaka or g.representative_point()
        d['oznaka_tocka'] = koord([(t.x, t.y)])[0]
        return d

    zone = [
        z('A', 'Atletika, rekreacija i dvoranski sportovi', zona_a, 'anketna', 76285,
          'Program, pogl. 7.1 (str. 52), slika 32 (str. 53), kart. prikaz 7 (str. 54); površina 76.285 m² na str. 56', Point(-340, -260)),
        z('B', 'Bazenski kompleks (zadržava se)', zona_b, 'zadržava se', None, 'Program, str. 53-54', None),
        z('C', 'Kompleks nogometnog stadiona Maksimir (zona realizacije)', zona_c, 'realizacija', None, 'Program, str. 53-54 i 70', Point(-95, -205)),
        z('D', 'Infrastruktura i prometno čvorište Borongaj (šira zona, IS)', d_glavni, 'anketna', None, 'Program, str. 52-54 i 103', Point(-5, -405)),
    ]
    zone[3]['dijelovi'] = [zapis_poligona(q) for q in d_dijelovi if q.area > 50]
    zone[3]['povrsina_m2'] = round(sum(q.area for q in d_dijelovi), 1)
    zone[3]['povrsina_ha'] = round(sum(q.area for q in d_dijelovi) / 1e4, 2)
    zone[3]['napomena'] = 'zona D je prsten oko uže zone (ulice) i čvorište Borongaj; "poligon" je vanjski rub najvećeg dijela, svi dijelovi su u "dijelovi"'
    uza_d = zapis_poligona(uza)
    uza_d.update({'naziv': 'Uža (neposredna) zona natječaja, GUP R1', 'status': 'PRETPOSTAVKA', 'povrsina_ha': round(uza.area / 1e4, 2),
                  'povrsina_prema_programu_ha': 23.0, 'razlika_posto': round((uza.area / 230000 - 1) * 100, 1),
                  'izvor': 'Program, pogl. 3.1 (str. 12), slika 6 (str. 13), pogl. 6 (str. 43: približno 23 ha, popis k.č.)'})
    sira_d = zapis_poligona(sira)
    sira_d.update({'naziv': 'Vanjski rub šire zone natječaja (uža zona + zona D, GUP IS)', 'status': 'PRETPOSTAVKA', 'povrsina_ha': round(sira.area / 1e4, 2),
                   'izvor': 'Program, slika 6 (str. 13), str. 43 (popis k.č., dio k.č. 5148/1 k.o. Maksimir), kart. prikaz 7 (str. 54)'})
    return {
        'status': 'PRETPOSTAVKA',
        'tocnost': 'orijentacijski, reda veličine 5-25 m; nije katastarska ni natječajna granica',
        'metoda': 'Uža zona = zatvorena unija OSM poligona SRC Svetice (way 29575046), kompleksa Dinama (landuse=recreation_ground, ' + rec_id + '), '
                  'obrisa stadiona i pojasa 14-60 m južno od osi Maksimirske između zapadnog ruba SRC-a i sjeveroistočnog kuta kompleksa; sjeverni rub '
                  'je južni rub pretpostavljenog koridora 28 m. Zona B = OSM poligon bazenskog kompleksa; zona A = SRC bez bazena; zona C = ostatak uže '
                  'zone (uključuje pojas zelenila i parkiralište uz Maksimirsku sjeverno od zone A, kako pokazuje kart. prikaz 7). Šira zona = uža zona + '
                  'koridor Maksimirske 28 m do istočnog kraja uže zone + izbočina oko okretišta linije 5 + ulica Svetice (os ± 9 m) + čvorište Borongaj '
                  'omeđeno ručno složenim rubom uz Hitrecovu, Mije Krešića, kneza Branimira i Divka Budaka. Uspoređeno s rasterom slike 6 i kart. '
                  'prikaza 7 samo vizualno, bez georeferenciranja.',
        'razvojni_obuhvat_napomena': 'razvojni obuhvat koncepta dodatno uključuje koridor Maksimirske do Hondlove (stacionaža '
                                     f'{s_i:.0f}-{ln.length:.0f} m), koji je IZVAN natječajnog obuhvata',
        'kraj_natjecajnog_obuhvata_na_osi_m': round(s_i, 1),
        'uza_zona': uza_d, 'sira_zona': sira_d, 'zone': zone,
        '_geom': {'uza': uza, 'sira': sira, 'rec': rec},
    }


def kljucne_stacionaze(os_: dict, stavke: list[tuple[str, object]]) -> list[dict]:
    ln: LineString = os_['_geom']
    out = []
    for naziv, g in stavke:
        if g is None or g.is_empty:
            continue
        if isinstance(g, Point):
            out.append({'naziv': naziv, 's_m': round(ln.project(g), 1), 'odmak_od_osi_m': round(ln.distance(g), 1)})
            continue
        dijelovi = [q.exterior for q in dijelovi_poligona(g)] or dijelovi_linije(g)
        ss = [ln.project(Point(c)) for q in dijelovi for c in q.coords]
        out.append({'naziv': naziv, 's_od_m': round(min(ss), 1), 's_do_m': round(max(ss), 1), 'najmanji_odmak_od_osi_m': round(ln.distance(g), 1)})
    return sorted(out, key=lambda d: d.get('s_m', d.get('s_od_m')))


# --- meta i provjera ----------------------------------------------------------------------------------------
def transformacija() -> dict:
    d = {
        'ishodiste': {'lat': LAT0, 'lon': LON0},
        'formula': 'x = (lon - lon0) * cos(lat0) * 111320; y = (lat - lat0) * 110574 (research/viz/README.md)',
        'm_po_stupnju_duzine': round(KX, 3), 'm_po_stupnju_sirine': KY,
        'obrat': 'lon = lon0 + x / m_po_stupnju_duzine; lat = lat0 + y / m_po_stupnju_sirine',
        'zaokruzivanje_m': 0.01,
    }
    try:
        from pyproj import Geod, Transformer
    except ImportError:
        d['napomena'] = 'pyproj nije dostupan: usporedba s HTRS96/TM preskočena'
        return d
    import numpy as np
    tr = Transformer.from_crs('EPSG:4326', 'EPSG:3765', always_xy=True)
    e0, n0 = tr.transform(LON0, LAT0)
    a, b, c, dd = OKVIR.bounds
    X, Y, E, N = [], [], [], []
    for i in range(9):
        for j in range(9):
            x, y = a + (c - a) * i / 8, b + (dd - b) * j / 8
            lon, lat = lonlat(x, y)
            e, n = tr.transform(lon, lat)
            X.append(x); Y.append(y); E.append(e); N.append(n)
    A = np.column_stack([np.ones(len(X)), X, Y])
    ke, *_ = np.linalg.lstsq(A, np.array(E), rcond=None)
    kn, *_ = np.linalg.lstsq(A, np.array(N), rcond=None)
    ost = max(float(np.max(np.abs(A @ ke - np.array(E)))), float(np.max(np.abs(A @ kn - np.array(N)))))
    geod = Geod(ellps='GRS80')
    _, _, dx = geod.inv(LON0, LAT0, LON0 + 0.01, LAT0)
    _, _, dy = geod.inv(LON0, LAT0, LON0, LAT0 + 0.01)
    fx, fy = dx / (0.01 * KX), dy / (0.01 * KY)
    d['htrs96_tm_epsg3765'] = {
        'ishodiste_E_N': [round(e0, 2), round(n0, 2)],
        'afina_iz_enu': {'E': [round(float(v), 6) for v in ke], 'N': [round(float(v), 6) for v in kn],
                         'oblik': 'E = E[0] + E[1]*x + E[2]*y; N = N[0] + N[1]*x + N[2]*y', 'najvece_odstupanje_u_okviru_m': round(ost, 3)},
    }
    d['tocnost_ravninske_aproksimacije'] = {
        'status': 'PRETPOSTAVKA-IZRAČUN (pyproj, elipsoid GRS80)',
        'stvarni_m_po_jedinici_x': round(fx, 5), 'stvarni_m_po_jedinici_y': round(fy, 5), 'faktor_povrsine': round(fx * fy, 5),
        'napomena': f'README konstante skraćuju duljine: 1 jedinica x = {fx:.4f} m, 1 jedinica y = {fy:.4f} m na terenu. Na 700 m uzduž x to je '
                    f'{700 * (fx - 1):.1f} m, na 400 m uzduž y {400 * (fy - 1):.1f} m. Tko miješa ove koordinate s HTRS96/TM ili DWG-om mora ići preko '
                    'geografskih koordinata (obrat) ili afine transformacije, a ne preko pretpostavke 1 jedinica = 1 m. Sve duljine i površine u ovoj '
                    f'datoteci su u jedinicama ENU; stvarna površina = zapisana x {fx * fy:.4f}.',
    }
    return d


def provjera(o: Osm, site: dict, os_: dict, stadion, zona: dict) -> dict:
    ln: LineString = os_['_geom']
    T = site['tramvaj']['skupine']
    izm = {
        'stadion': site['stadion_maksimir']['raspon'], 'src_svetice': site['src_svetice']['raspon'], 'bazen': site['bazen_svetice']['raspon'],
        'glavni_ulaz': site['park_maksimir']['glavni_ulaz']['raspon'] if site['park_maksimir']['glavni_ulaz'] else None,
        'okretiste_linije_5': T.get('okretiste_linije_5', {}).get('raspon'),
        'raskrizje_svetice_x': round(ln.coords[0][0]), 'hondlova_x': round(ln.coords[-1][0]),
    }
    ravnice = [r for wid, refs, t in nadji_put(o, lambda t: t.get('highway') and t.get('name') == 'Ravnice') for r in refs]
    maks_cv = {r for wid, refs, t in nadji_put(o, lambda t: t.get('highway') and t.get('name') == 'Maksimirska cesta') for r in refs}
    zaj = [r for r in ravnice if r in maks_cv]
    if zaj:
        izm['ravnice_x'] = round(o.nodes[zaj[0]][0])
    sj = next((t for t in site['stadion_maksimir']['tribine'] if t['strana'] == 'sjever'), None)
    if sj:
        izm['os_maksimirske_od_sjeverne_tribine_m'] = round(Polygon(sj['poligon']).distance(ln), 1)
    odst = []
    for k, ref in README_ORIJENTIRI.items():
        v = izm.get(k)
        if v is None:
            odst.append({'orijentir': k, 'readme': ref, 'izmjereno': None, 'napomena': 'nije nađeno u OSM podacima'})
        elif isinstance(ref, dict):
            dmax = max(abs(v[a][i] - ref[a][i]) for a in ('x', 'y') for i in (0, 1))
            z = {'orijentir': k, 'readme': ref, 'izmjereno': v, 'najvece_odstupanje_m': dmax}
            if k == 'okretiste_linije_5':
                z['napomena'] = 'mjerena je samo petlja; README raspon uključuje i prolazni kolosijek do x -236 (way 383182730), pa razlika nije pogreška'
            odst.append(z)
        else:
            z = {'orijentir': k, 'readme': ref, 'izmjereno': v, 'odstupanje_m': round(v - ref, 1)}
            if k == 'os_maksimirske_od_sjeverne_tribine_m':
                z['napomena'] = 'README vrijednost 12 m je okomica na tetivu Svetice-Hondlova (osm_fronta.json); do izlomljene OSM osi ceste je 14,7 m'
            odst.append(z)
    out = {'orijentiri_readme': odst}
    put_f = os.path.join(REPO, 'research', 'osm_fronta.json')
    if os.path.exists(put_f):
        with open(put_f, encoding='utf-8') as f:
            fr = json.load(f)
        # ponovi mjerenje iz izmjeri_frontu.py u našim koordinatama: projekcija stadiona na tetivu raskrižje-raskrižje
        a, b = ln.coords[0], ln.coords[-1]
        ux, uy = b[0] - a[0], b[1] - a[1]
        n = math.hypot(ux, uy)
        ux, uy = ux / n, uy / n
        pr = [p[0] * ux + p[1] * uy for p in stadion.exterior.coords]
        ok = [abs((-(p[0] * uy) + p[1] * ux) - (-(a[0] * uy) + a[1] * ux)) for p in stadion.exterior.coords]
        k_staro = 6371000.0 * math.pi / 180
        out['osm_fronta_json'] = {
            'datum_ranijeg_mjerenja': fr.get('datum'),
            'fronta_svetice_hondlova_m': {'ranije': fr.get('maksimirska_svetice_hondlova_m'), 'sada': round(ln.length, 1),
                                          'sada_u_mjerilu_ranije_skripte': round(ln.length * math.hypot(ux * k_staro / 111320.0, uy * k_staro / KY), 1)},
            'stadion_projekcija_na_cestu_m': {'ranije': fr.get('stadion_projekcija_na_cestu_m'), 'sada': round(max(pr) - min(pr), 1)},
            'najmanji_odmak_stadiona_od_tetive_m': {'ranije': fr.get('najmanji_odmak_stadiona_od_osi_ceste_m'), 'sada': round(min(ok), 1)},
            'najmanji_odmak_stadiona_od_stvarne_osi_m': site['stadion_maksimir']['najmanja_udaljenost_obrisa_od_osi_maksimirske_m'],
            'napomena': 'ranija skripta koristi kuglu R = 6371 km (111.195 m po stupnju), README 111.320 i 110.574; odmak 12 m iz ranijeg mjerenja je '
                        'okomica na tetivu između raskrižja, ne na izlomljenu os ceste',
        }
    out['fronta_unutar_natjecajnog_obuhvata_m'] = zona['kraj_natjecajnog_obuhvata_na_osi_m']
    return out


# --- glavno --------------------------------------------------------------------------------------------
def main():
    ap = argparse.ArgumentParser(description=__doc__.split('\n')[0])
    ap.add_argument('--cache', default=os.environ.get('VIZ_OSM_CACHE', os.path.join(os.path.expanduser('~'), '.cache', 'viz-osm')),
                    help='mapa predmemorije za sirovi OSM XML (izvan repoa)')
    ap.add_argument('--izlaz', default=os.path.join(REPO, 'research', 'viz', 'site.json'))
    ap.add_argument('--pregled', default=os.path.join(REPO, 'research', 'viz', 'site_pregled.png'))
    ap.add_argument('--bez-mreze', action='store_true', help='koristi samo predmemoriju')
    a = ap.parse_args()

    datoteke, park_put, mreza = preuzmi_sve(a.cache, a.bez_mreze)
    o = Osm()
    for f in datoteke:
        o.ucitaj(f)
    datum = datetime.date.fromtimestamp(min(os.path.getmtime(f) for f in datoteke + [park_put])).isoformat()
    S = gradi_slojeve(o, park_put)
    os_ = os_maksimirske(o)
    os_ln: LineString = os_['_geom']
    maks = maksimirska_u_okviru(o)

    def jedan(uvjet, opis):
        n = nadji_put(o, uvjet)
        if not n:
            raise SystemExit(f'U OSM podacima nema objekta: {opis}')
        return max(n, key=lambda q: o.poligon_puta(q[0]).area if o.zatvoren(q[0]) else 0)

    # stadion
    sw, _, st = jedan(lambda t: t.get('leisure') == 'stadium' and 'Maksimir' in t.get('name', ''), 'stadion Maksimir')
    stadion = o.poligon_puta(sw)
    tereni_u = [f for f in S['sportski_tereni'] if f.get('leisure') == 'pitch' and stadion.contains(Polygon(f['poligon']).representative_point())]
    igraliste = max(tereni_u, key=lambda f: f['povrsina_m2']) if tereni_u else None
    sred = Polygon(igraliste['poligon']).centroid if igraliste else stadion.centroid
    tribine = []
    for zg in S['zgrade']:
        if zg['vrsta'] == 'grandstand' and stadion.buffer(5).contains(Polygon(zg['poligon']).representative_point()):
            c = Polygon(zg['poligon']).centroid
            kut = (math.degrees(math.atan2(c.x - sred.x, c.y - sred.y)) + 360) % 360
            strana = ['sjever', 'istok', 'jug', 'zapad'][int(((kut + 45) % 360) // 90)]
            tribine.append({'id': zg['id'], 'naziv': f'tribina {strana}', 'strana': strana, 'poligon': zg['poligon'], 'povrsina_m2': zg['povrsina_m2'],
                            'visina_m': zg['visina_m'], 'visina_izvor': zg['visina_izvor'], 'raspon': raspon(Polygon(zg['poligon']))})
            zg['naziv'] = zg['naziv'] or f'Stadion Maksimir, tribina {strana}'
    stadion_d = {
        'id': f'way/{sw}', 'naziv': st.get('name'), 'status': 'POTVRĐENO kao OSM geometrija (orijentacijski)',
        'obris': zapis_poligona(stadion), 'raspon': raspon(stadion), 'sredina': koord([(stadion.centroid.x, stadion.centroid.y)])[0],
        'igraliste': ({'id': igraliste['id'], 'poligon': igraliste['poligon'], 'povrsina_m2': igraliste['povrsina_m2'],
                       'sredina': koord([(sred.x, sred.y)])[0], 'raspon': raspon(Polygon(igraliste['poligon']))} if igraliste else None),
        'tribine': sorted(tribine, key=lambda q: ['sjever', 'istok', 'jug', 'zapad'].index(q['strana'])),
        'najmanja_udaljenost_obrisa_od_osi_maksimirske_m': round(stadion.distance(os_ln), 1),
        'napomena': 'visine tribina nisu u OSM-u; zadana vrijednost 20 m je PRETPOSTAVKA niske pouzdanosti. Obris "stadium" uključuje i plato oko tribina.',
    }
    if igraliste:
        c = list(Polygon(igraliste['poligon']).minimum_rotated_rectangle.exterior.coords)
        d1, d2 = math.dist(c[0], c[1]), math.dist(c[1], c[2])
        dulja = (c[0], c[1]) if d1 >= d2 else (c[1], c[2])
        stadion_d['igraliste']['dimenzije_osm_m'] = [round(max(d1, d2), 1), round(min(d1, d2), 1)]
        stadion_d['igraliste']['azimut_duze_osi_deg'] = round(azimut(*dulja) % 180, 1)

    # SRC Svetice i bazen
    cw, _, ct = jedan(lambda t: t.get('leisure') == 'sports_centre' and 'Svetice' in t.get('name', '') and 'Sportsko' in t.get('name', ''), 'SRC Svetice')
    src = o.poligon_puta(cw)
    bw, _, bt = jedan(lambda t: t.get('leisure') == 'sports_centre' and 'Bazen' in t.get('name', ''), 'Bazenski kompleks Svetice')
    bazen = o.poligon_puta(bw)
    src_d = {'id': f'way/{cw}', 'naziv': ct.get('name'), 'status': 'POTVRĐENO kao OSM geometrija (orijentacijski)', 'obris': zapis_poligona(src), 'raspon': raspon(src),
             'tereni': [{'id': f['id'], 'vrsta': f.get('leisure'), 'sport': f.get('sport'), 'povrsina_m2': f['povrsina_m2'], 'raspon': raspon(Polygon(f['poligon']))}
                        for f in S['sportski_tereni'] if src.contains(Polygon(f['poligon']).representative_point())],
             'zgrade': [zg['id'] for zg in S['zgrade'] if src.contains(Polygon(zg['poligon']).representative_point())]}
    bazen_zg = [zg for zg in S['zgrade'] if bazen.buffer(3).contains(Polygon(zg['poligon']).representative_point())]
    for zg in bazen_zg:
        zg['naziv'] = zg['naziv'] or 'Bazenski kompleks Svetice (zgrada)'
    bazen_d = {'id': f'way/{bw}', 'naziv': bt.get('name'), 'status': 'POTVRĐENO kao OSM geometrija (orijentacijski)', 'obris': zapis_poligona(bazen), 'raspon': raspon(bazen),
               'zgrade': [{'id': zg['id'], 'poligon': zg['poligon'], 'povrsina_m2': zg['povrsina_m2'], 'visina_m': zg['visina_m'], 'visina_izvor': zg['visina_izvor']} for zg in bazen_zg]}

    # park Maksimir
    park = S['_park_geom']
    uw = nadji_put(o, lambda t: 'Glavni ulaz' in t.get('name', '') and 'building' in t)
    ulaz = o.poligon_puta(uw[0][0]) if uw else None
    park_d = {
        'id': f'relation/{PARK_REL}', 'naziv': S['_park_oznake'].get('name'), 'oznake': oznake(S['_park_oznake']),
        'status': 'POTVRĐENO kao OSM poligon (landuse=forest); kao granica zaštićenog područja OTVORENO',
        'napomena': 'OSM u ovom okviru nema boundary=protected_area ni leisure=park za Park Maksimir; relacija je poligon šume i ne obuhvaća '
                    'livade, jezera ni ZOO. Zakonsku granicu treba uzeti iz GUP-a 4c ili registra, ne iz OSM-a.',
        'granica_osm_cijela': [zapis_poligona(p) for p in dijelovi_poligona(park)],
        'granica_osm_u_okviru': [zapis_poligona(p) for p in dijelovi_poligona(park.intersection(OKVIR))],
        'raspon_cijeli': raspon(park),
        'glavni_ulaz': ({'id': f'way/{uw[0][0]}', 'naziv': uw[0][2].get('name'), 'godina': uw[0][2].get('start_date'),
                         'poligon': koord(ulaz.exterior.coords), 'raspon': raspon(ulaz),
                         'sredina': koord([(ulaz.centroid.x, ulaz.centroid.y)])[0],
                         'stacionaza_na_osi_m': round(os_ln.project(ulaz.centroid), 1), 'udaljenost_od_osi_m': round(ulaz.distance(os_ln), 1)} if ulaz is not None else None),
        'glavna_aleja': [d['id'] for d in S['pjesacke_staze'] if d.get('naziv') == 'Maksimirski perivoj'],
    }

    T = tramvaj(o, S, os_ln, ulaz.centroid if ulaz is not None else None)
    rec, _ = kompleks_dinama(S, stadion)
    K = profil_koridora(o, S, os_, stadion, src, rec)
    GP = granica_parka(o, S, maks, maks.project(Point(os_ln.coords[0])), ulaz, K)
    ZN = obuhvat_i_zone(o, S, os_, maks, stadion, src, bazen, T)

    petlja5 = unary_union([LineString(d['linija']) for d in T['pruge'] if d['skupina'] == 'okretiste_linije_5'])
    sus_park = [q for q in (Polygon(d['poligon']) for d in S['zelenilo']['parkovi']) if q.intersection(rec.buffer(2)).area > 5 and not q.intersects(stadion)]
    if not petlja5.is_empty:
        T['skupine']['okretiste_linije_5']['presijeca_os_ceste'] = bool(petlja5.intersects(os_ln))
        T['skupine']['okretiste_linije_5']['napomena'] = ('petlja se prema OSM-u odvaja s južnog kolosijeka (smjer istok), prelazi os ceste i sjeverni kolnik '
                                                         'te se vraća na sjeverni kolosijek (smjer zapad); README raspon x -309..-236 uključuje i prolazni '
                                                         'kolosijek između skretnica (way 383182730)')
    sj_trib = next((t for t in stadion_d['tribine'] if t['strana'] == 'sjever'), None)
    os_['kljucne_stacionaze'] = kljucne_stacionaze(os_, [
        ('SRC Svetice (OSM obris)', src), ('stadion Maksimir (OSM obris)', stadion),
        ('sjeverna tribina', Polygon(sj_trib['poligon']) if sj_trib else None),
        ('glavni ulaz u park (slavoluk)', ulaz), ('okretište linije 5 (kolosijeci)', petlja5 if not petlja5.is_empty else None),
        ('kompleks Dinama (recreation_ground), kraj natječajnog obuhvata na istoku', rec),
        ('susjedni park istočno od Hitrec-Kaciana (OSM leisure=park)', max(sus_park, key=lambda q: q.area) if sus_park else None),
        ('parkiralište uz zapadnu tribinu', next((Polygon(d['poligon']) for d in S['parkiralista'] if d.get('capacity') == '246'), None)),
    ] + [(f"tramvajsko stajalište {d['naziv']} ({d['id']})", Point(d['tocka'])) for d in S['stajalista']['tramvaj']
         if 'tocka' in d and os_ln.distance(Point(d['tocka'])) < 12 and 0 < os_ln.project(Point(d['tocka'])) < os_ln.length])

    site = {
        'meta': {},
        'zgrade': S['zgrade'], 'ceste': S['ceste'], 'pjesacke_staze': S['pjesacke_staze'], 'pjesacke_povrsine': S['pjesacke_povrsine'],
        'tramvaj': T, 'zeljeznica': S['zeljeznica'], 'stajalista': S['stajalista'],
        'stadion_maksimir': stadion_d, 'src_svetice': src_d, 'bazen_svetice': bazen_d, 'park_maksimir': park_d,
        'vode': S['vode'], 'zelenilo': S['zelenilo'], 'sportski_tereni': S['sportski_tereni'], 'parkiralista': S['parkiralista'],
        'ograde': S['ograde'], 'namjene': S['namjene'], 'orijentiri': S['orijentiri'],
        'izvedeno': {'os_maksimirske': os_, 'koridor_maksimirske': K, 'granica_parka_prema_maksimirskoj': GP, 'obuhvat_i_zone': ZN},
    }
    vis = {}
    for zg in S['zgrade']:
        vis[zg['visina_pouzdanost']] = vis.get(zg['visina_pouzdanost'], 0) + 1
    a_, b_, c_, d_ = OKVIR.bounds
    site['meta'] = {
        'naziv': 'Postojeće stanje lokacije Maksimir - SRC Svetice - Borongaj iz OpenStreetMapa (lokalni ENU)',
        'status': 'orijentacijska podloga za AI građanski koncept; nije geodetska ni katastarska podloga, nije projekt',
        'izvor': '© OpenStreetMap contributors, ODbL 1.0',
        'licenca_url': 'https://www.openstreetmap.org/copyright',
        'api': f'{API}/map?bbox=... ({NX}x{NY} pločica) i {API}/relation/{PARK_REL}/full',
        'datum_preuzimanja': datum, 'datum_preuzimanja_hr': datetime.date.fromisoformat(datum).strftime('%d.%m.%Y.').replace('.0', '.').lstrip('0'),
        'okvir_wgs84': {'zapad': BBOX[0], 'jug': BBOX[1], 'istok': BBOX[2], 'sjever': BBOX[3]},
        'okvir_enu': {'x': [r2(a_), r2(c_)], 'y': [r2(b_), r2(d_)]},
        'koordinate': 'lokalni ENU u metrima: x prema istoku, y prema sjeveru; z nije u ovoj datoteci',
        'transformacija': transformacija(),
        'obrada': 'scripts/viz/gradi_site.py; linije i površine rezane na okvir, zgrade cijele ako im je unutarnja točka u okviru; '
                  'OSM poligon šume Park Maksimir dan je i cijeli (izvan okvira)',
        'visine_zgrada': {'pravilo': 'oznaka height; inače building:levels x 3,2 m; inače zadano po vrsti (PRETPOSTAVKA)',
                          'broj_po_pouzdanosti': vis, 'zadano_po_vrsti_m': ZADANE_VISINE, 'zadano_ostalo_m': ZADANA_VISINA_OSTALO},
        'statusi': 'POTVRĐENO ovdje znači samo "tako je ucrtano u OSM-u na dan preuzimanja"; sve izvedeno je PRETPOSTAVKA ili PRETPOSTAVKA-IZRAČUN',
        'broj_znacajki': {k: (len(v) if isinstance(v, list) else {kk: len(vv) for kk, vv in v.items() if isinstance(vv, list)})
                          for k, v in site.items() if k not in ('meta', 'izvedeno', 'stadion_maksimir', 'src_svetice', 'bazen_svetice', 'park_maksimir')},
    }
    site['provjera'] = provjera(o, site, os_, stadion, ZN)

    ig = stadion_d['igraliste']['sredina'] if stadion_d['igraliste'] else stadion_d['sredina']
    interno = {
        'natpisi': [
            ((ig[0], ig[1]), 'Stadion Maksimir', 11, BOJE['stadion'], True),
            ((src.centroid.x - 30, src.bounds[3] - 70), 'SRC Svetice', 11, BOJE['src'], True),
            ((bazen.centroid.x, bazen.centroid.y), 'bazen', 9, BOJE['bazen'], True),
            ((-110, 215), 'Park Maksimir', 12, BOJE['park_gr'], True),
            ((-330, 12), 'Maksimirska cesta', 9, BOJE['tekst'], False),
            ((-468, -200), 'Svetice', 9, BOJE['tekst'], False),
            ((os_ln.coords[-1][0] + 55, os_ln.coords[-1][1] - 40), 'Hondlova', 9, BOJE['tekst'], False),
            ((40, -500), 'okretište Borongaj', 9, BOJE['borongaj'], True),
            ((-250, -455), 'prilaz (Divka Budaka)', 8, BOJE['borongaj'], False),
            ((-300, 118), 'okretište linije 5', 9, BOJE['tram5'], True),
            ((park_d['glavni_ulaz']['sredina'][0] + 28, park_d['glavni_ulaz']['sredina'][1] + 22), 'glavni ulaz', 9, '#7a5a00', True),
            ((90, 70), 'Hitrec-Kacian', 8, BOJE['tekst'], False),
            ((190, 165), 'susjedni park', 8, BOJE['tekst'], False),
            ((120, 255), 'ZOO / jezero', 8, BOJE['tekst'], False),
            ((-345, 105), 'sv. Jeronim, ljetnikovac', 8, BOJE['tekst'], False),
        ] + [((f['tocka'][0], f['tocka'][1] - 16), f"stajalište {f['naziv']}", 8, BOJE['zeljeznica'], False) for f in S['zeljeznica']['stajalista'][:1]],
        'natpisi_sire': [((-250, 520), 'Park Maksimir'), ((-45, 0), 'stadion'), ((-290, -190), 'SRC Svetice'), ((40, -520), 'Borongaj'),
                         ((470, -540), 'stajalište Maksimir'), ((760, 440), 'Ravnice'), ((-850, -150), 'Maksimirska')],
    }
    cist = ocisti(site)
    zapisi_json(a.izlaz, cist)
    W, H = crtaj_pregled(a.pregled, cist, interno)
    print(f'{a.izlaz}: {os.path.getsize(a.izlaz) / 1e6:.2f} MB; {a.pregled}: {W}x{H} px; mrežnih zahtjeva: {mreza.zahtjeva}')
    print(json.dumps({'os_duljina_m': os_['duljina_m'], 'uza_ha': ZN['uza_zona']['povrsina_ha'], 'sira_ha': ZN['sira_zona']['povrsina_ha'],
                      'zone_m2': {zz['id']: zz['povrsina_m2'] for zz in ZN['zone']}, 'kraj_obuhvata_s': ZN['kraj_natjecajnog_obuhvata_na_osi_m']}, ensure_ascii=False))


if __name__ == '__main__':
    main()
