#!/usr/bin/env python3
"""Detaljni tlocrti po razinama, presjeci i iskaz površina iz program.json.

AI građanski koncept · PRIJEDLOG · nije projekt. Crteži su vektorske sheme programa po razinama
(format: research/viz/README.md), nisu geodetska ni projektna podloga i ne dokazuju statiku, požarnu
sigurnost ni kapacitet. Sve se crta i mjeri u metričkom sustavu ENU-M (scripts/viz/koordinate.py);
ulazni podaci u nominalnom ENU-N prevode se pri učitavanju.

Naredbe:
  crtaj   <program.json> --out <mapa> [--site research/viz/site.json] [--kote kote.json|ne] [--datum D]
      pregledni list svake razine (cijeli obuhvat) i detaljni listovi gustih dijelova, SVG formata A3
  presjek <program.json> --out <mapa> [--linija "naziv:x1,y1;x2,y2"] [--dmr dmr.json|ne]
      kotirani presjeci bez visinskog pretjerivanja (S-J kroz Maksimirsku i stadion, Z-I kroz bazen i
      stadion, S-J kroz teren nad garažom i halu Borongaj, S-J kroz dvorište bazena i najveću visoku
      dvoranu, svaki ako postoji); izvadci: cijela zdjela stadiona (profil tribina red po red i krov),
      promet pod pokrovom, bazen; --linija dodaje vlastiti presjek (koordinate ENU-N)
  iskaz   <program.json> --out <mapa>
      iskaz površina po razinama i kategorijama, popis prostora i tablica sportova (md i csv)
  sve     <program.json> --out <mapa> [--bez-png] [--bez-pdf] [--png-px 3000]
      sve gore, PNG svakog lista (dulja stranica oko 3000 px) i zbirni vektorski PDF formata A3
  objavi  <program.json> --out <mapa>
      čista izrada kao `sve` u mapu --out, zatim kopija SVG listova, iskaza i manifesta u
      research/viz/program/tlocrti/ te PDF-a, PNG-a preglednih listova i presjeka i POPIS.md u
      dist/assets/viz/tlocrti/ (stari listovi u odredištima se brišu)

Alat ne pretpostavlja id-jeve ni broj razina: detaljne listove određuje grupiranjem prostora, a presjeke
iz objekta "stadion", prometnih prostora i prostora čije ime sadrži "bazen" ili "Borongaj".
Ovisnosti: numpy, shapely, pyproj, pillow, scipy; za PNG i PDF Node s paketom playwright (Chromium).
Font: DejaVu Sans.
"""
from __future__ import annotations

import argparse
import csv
import hashlib
import json
import math
import re
import shutil
import subprocess
import sys
from pathlib import Path

import numpy as np
import shapely
from shapely import affinity
from shapely.geometry import LineString, MultiLineString, Point, Polygon, box
from shapely.ops import polylabel, unary_union
from shapely.prepared import prep
from shapely.strtree import STRtree

OVDJE = Path(__file__).resolve().parent
KORIJEN = OVDJE.parents[1]
sys.path.insert(0, str(OVDJE))
import koordinate as K  # noqa: E402
import program_alat as PA  # noqa: E402

br = PA.br


def bm2(a):
    """Površina za natpis: ispod 10 m² jedna decimala, inače cijeli metri."""
    return br(a, 1 if a < 9.95 else 0)
norm = PA.norm

OZNAKA = 'AI građanski koncept · PRIJEDLOG · nije projekt'
PODLOGE = ('Podloga postojećeg stanja: © OpenStreetMap contributors, ODbL. Kote terena: geotehnički elaborat '
           'GEL-33/2025, prilog 7.1 (situacija 1:1000).')
SUSTAV = 'Koordinate: lokalni ENU-M (metrički), ishodište 45,8187° N, 16,0185° E; x istok, y sjever.'
SITE_ZADANO = KORIJEN / 'research' / 'viz' / 'site.json'
KOTE_ZADANO = KORIJEN / 'research' / 'viz' / 'geodezija' / 'kote_situacija.json'
DMR_ZADANO = KORIJEN / 'research' / 'viz' / 'teren' / 'dmr_blizu_dgu20_5m.json'
SPORTOVI_PUT = OVDJE / 'sportovi_dimenzije.json'

LIST_W, LIST_H = 420.0, 297.0          # A3 položeno, mm
RUB = 5.0                              # okvir lista
MJERILA = [100, 125, 150, 200, 250, 300, 400, 500, 600, 750, 1000, 1250, 1500, 2000, 2500, 3000, 3500, 4000,
           5000, 6000, 7500, 10000]
FONT = 'DejaVu Sans, sans-serif'
F_PODATAK = 1.6                       # najmanja veličina fonta (mm) teksta s podacima na listu
F_NASLOV, F_PODNASLOV, F_TEKST, F_SITNO, F_MIN = 3.5, 2.7, 2.2, 1.9, 1.6

# ---------------------------------------------------------------------------------------------- kategorije
# ispuna, rub, uzorak (None | 'koso' | 'koso2' | 'kriz' | 'tocke' | 'vodoravno'), naziv u legendi
KAT = {
    'stadion': ('#d5deee', '#3f5c9a', None, 'stadion (prostori)'),
    'igraliste': ('#a6d194', '#3d8b37', None, 'igralište'),
    'tribine': ('#aabfe4', '#2f4f9e', None, 'tribine'),
    'sport_zatvoreni': ('#f8dcae', '#b8690a', None, 'sport, zatvoreni'),
    'sport_otvoreni': ('#dde9a8', '#6f8f1c', 'tocke2', 'sport, otvoreni'),
    'zdravlje': ('#f4c6d1', '#b5305c', None, 'zdravlje'),
    'kultura': ('#ddcdec', '#7440a8', 'okomito', 'kultura'),
    'javne_sluzbe': ('#c0e4e1', '#1c7c80', 'tocke2', 'javne službe'),
    'komercijala': ('#f6e9a6', '#9a8000', None, 'komercijala'),
    'ugostiteljstvo': ('#f4cba9', '#b85c1c', 'tocke2', 'ugostiteljstvo'),
    'garaza': ('#e2e2e2', '#5f5f5f', None, 'garaža'),
    'promet_tramvaj': ('#b9d5f1', '#1c5fb8', None, 'promet: tramvaj'),
    'promet_bus': ('#c2decf', '#2f7d4f', 'okomito', 'promet: autobus'),
    'promet_cesta': ('#c4c4d0', '#4a4a5a', None, 'promet: cesta'),
    'topli_put': ('#f9bda6', '#d9480f', None, 'topli put (prostor)'),
    'trg_predvorje': ('#f2ead8', '#8c7a4f', None, 'trg i predvorje'),
    'tehnika': ('#dcd6cc', '#7a6f60', 'koso', 'tehnika'),
    'logistika': ('#d3ccb9', '#6b6142', 'koso2', 'logistika'),
    'park_zelenilo': ('#cbe6bd', '#4f9a3f', None, 'park i zelenilo'),
    'staza': ('#eee5d0', '#a08f63', 'okomito', 'staza'),
    'svjetlarnik': ('#dcf3f9', '#1f8fb0', 'kriz', 'svjetlarnik (staklo)'),
    'voda': ('#b6def3', '#1b84b8', 'vodoravno', 'voda'),
    'dvoriste': ('#ebf4e1', '#7fa35f', 'tocke', 'dvorište'),
    'postojece': ('#e6e6e6', '#7a7a7a', 'koso', 'postojeće'),
}
KAT_RED = list(KAT)
ZATVORENE = PA.ZATVORENE | {'topli_put', 'trg_predvorje', 'tehnika', 'logistika', 'promet_tramvaj', 'promet_bus',
                            'promet_cesta'}
# željeno mjerilo detalja po kategoriji (nazivnik); služi samo grupiranju u listove
ZELJENO = {'sport_zatvoreni': 500, 'zdravlje': 500, 'kultura': 500, 'javne_sluzbe': 500, 'komercijala': 500,
           'ugostiteljstvo': 500, 'tehnika': 500, 'sport_otvoreni': 750}
B_TOPLI_VEZA = '#d9480f'  # crta toplog puta: ista boja kao u legendi, različita od ispune prostora toplog puta
VEZE = {  # boja, naziv u legendi
    'topli_put': (B_TOPLI_VEZA, 'topli put (neprekinuta veza)'),
    'dizalo': ('#1c5fb8', 'dizalo'),
    'stubiste': ('#5b3fb0', 'stubište'),
    'pokretne_stube': ('#0b7285', 'pokretne stube'),
    'rampa': ('#6b4fa0', 'rampa (strelica: uspon, nagib u %)'),
    'svjetlarnik': ('#1f8fb0', 'svjetlarnik (veza)'),
    'ulaz': ('#2b8a3e', 'ulaz'),
    'kolni_ulaz': ('#343a40', 'kolni ulaz'),
    'evakuacija': ('#1f8f4e', 'evakuacijski izlaz'),
}
LINIJSKE_VEZE = {  # crta u legendi za veze zapisane linijom (tip: (boja, debljina, crtkanje), naziv)
    'ulaz': ((VEZE['ulaz'][0], 0.45, None), 'pješački put ili ulaz (linija, strelica: smjer)'),
    'kolni_ulaz': ((VEZE['kolni_ulaz'][0], 0.8, '1.6 0.5'), 'kolni put ili ulaz (linija)'),
    'evakuacija': ((VEZE['evakuacija'][0], 0.35, '1.2 0.6'), 'evakuacijski put (linija)'),
}
B_IZNAD, B_ISPOD = '#8e24aa', '#00695c'
B_OKNO = '#fff6cf'      # svjetlosno okno ispod svjetlarnika u presjeku
B_TOPLI = '#d9480f'


# ------------------------------------------------------------------------------------------------ pomoćno
_FONT_CACHE = {}


def _pil_font(bold):
    if bold not in _FONT_CACHE:
        from PIL import ImageFont
        f = None
        for put in PA.FONTOVI:
            try:
                f = ImageFont.truetype(put.replace('DejaVuSans.ttf', 'DejaVuSans-Bold.ttf') if bold else put, 200)
                break
            except OSError:
                continue
        _FONT_CACHE[bold] = f
    return _FONT_CACHE[bold]


def sirina(s, vel, bold=False):
    """Širina teksta u mm za veličinu fonta vel (mm)."""
    f = _pil_font(bold)
    if f is None:
        return 0.6 * vel * len(s)
    return f.getlength(s) / 200.0 * vel


def esc(s):
    return str(s).replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;').replace('"', '&quot;')


def f2(v):
    s = f'{v:.2f}'
    if '.' in s:
        s = s.rstrip('0').rstrip('.')
    return '0' if s in ('-0', '') else s


def prelomi(s, vel, bold, maxw, max_redaka=4):
    """Prelomi tekst po riječima na širinu maxw (mm); vrati popis redaka ili None ako ne stane."""
    rijeci = [r for r in str(s).split(" ") if r]   # tvrdi razmak (U+00A0) ne lomi redak
    redci, tek = [], ''
    for r in rijeci:
        if sirina(r, vel, bold) > maxw:
            return None
        p = (tek + ' ' + r).strip()
        if sirina(p, vel, bold) <= maxw:
            tek = p
        else:
            redci.append(tek)
            tek = r
    if tek:
        redci.append(tek)
    return redci if len(redci) <= max_redaka else None


def skrati(s, vel, bold, maxw):
    s = str(s)
    if sirina(s, vel, bold) <= maxw:
        return s
    while len(s) > 1 and sirina(s + '…', vel, bold) > maxw:
        s = s[:-1]
    return s.rstrip() + '…'


def mjerilo_za(w_m, h_m, w_mm, h_mm, najmanje=200):
    """Najkrupnije standardno mjerilo (nazivnik) u kojem w_m x h_m stane u w_mm x h_mm."""
    treba = max(w_m * 1000.0 / w_mm, h_m * 1000.0 / h_mm, najmanje)
    for m in MJERILA:
        if m >= treba - 1e-9:
            return m
    return int(math.ceil(treba / 1000.0) * 1000)


def _identitet(a):
    return np.asarray(a, dtype=float).reshape(-1, 2)


def _nm(a):
    a = np.asarray(a, dtype=float).reshape(-1, 2)
    if not len(a):
        return a
    x, y = K.m_iz_n(a[:, 0], a[:, 1])
    return np.column_stack([np.asarray(x, dtype=float), np.asarray(y, dtype=float)])


def pretvorba(oznaka):
    """Funkcija koja niz točaka iz zapisanog sustava prevodi u ENU-M. Bez oznake vrijedi ENU-N."""
    return _identitet if 'ENU-M' in str(oznaka or '') else _nm


def g_u_m(g, T):
    return shapely.transform(g, T) if g is not None and not g.is_empty else g


def dijelovi(g, tip='Polygon'):
    """Vrati popis jednostavnih geometrija zadanog tipa iz bilo koje geometrije."""
    if g is None or g.is_empty:
        return []
    if g.geom_type == tip:
        return [g]
    if hasattr(g, 'geoms'):
        out = []
        for x in g.geoms:
            out += dijelovi(x, tip)
        return out
    return []


def glavna_os(g):
    """(kut u stupnjevima duže stranice opisanog pravokutnika, duža, kraća stranica)."""
    r = g.minimum_rotated_rectangle
    if r.geom_type != 'Polygon':
        return 0.0, 0.0, 0.0
    c = list(r.exterior.coords)
    a, b = math.dist(c[0], c[1]), math.dist(c[1], c[2])
    if a >= b:
        kut = math.degrees(math.atan2(c[1][1] - c[0][1], c[1][0] - c[0][0]))
    else:
        kut = math.degrees(math.atan2(c[2][1] - c[1][1], c[2][0] - c[1][0]))
    kut = (kut + 90.0) % 180.0 - 90.0
    return kut, max(a, b), min(a, b)


def _kutovi_kandidati(g, najvise=5):
    """Kutovi za upisivanje pravokutnika: glavna os opisanog pravokutnika i smjerovi najduljih stranica
    poligona (bez ponavljanja do 1°, mod 90°)."""
    kut0, _, _ = glavna_os(g)
    out = [kut0]
    bridovi = []
    for d in dijelovi(g):
        c = list(d.exterior.coords)
        for (x0, y0), (x1, y1) in zip(c[:-1], c[1:]):
            L = math.hypot(x1 - x0, y1 - y0)
            if L > 1.0:
                bridovi.append((-L, round((math.degrees(math.atan2(y1 - y0, x1 - x0)) + 90.0) % 180.0 - 90.0, 3)))
    for _, k in sorted(bridovi):
        if len(out) >= najvise:
            break
        if all(min(abs(k - o) % 90.0, 90.0 - abs(k - o) % 90.0) > 1.0 for o in out):
            out.append(k)
    return out


def _raster_unutra(gr, h):
    """Mreža ćelija veličine h u okviru gr; True gdje cijela ćelija leži u gr (središte u gr skupljenom za
    pola dijagonale ćelije). Vrati (maska [redak y, stupac x], x0, y0)."""
    import shapely
    x0, y0, x1, y1 = gr.bounds
    nx, ny = max(1, int(math.ceil((x1 - x0) / h))), max(1, int(math.ceil((y1 - y0) / h)))
    uze = gr.buffer(-h * 0.7072)
    if uze.is_empty:
        return np.zeros((ny, nx), dtype=bool), x0, y0
    xs = x0 + (np.arange(nx) + 0.5) * h
    ys = y0 + (np.arange(ny) + 0.5) * h
    X, Y = np.meshgrid(xs, ys)
    return shapely.contains_xy(uze, X.ravel(), Y.ravel()).reshape(ny, nx), x0, y0


def _najveci_u_maski(m):
    """Najveći pravokutnik od samih True u maski (histogram po retcima). Vrati (r0, c0, r1, c1) uključivo."""
    ny, nx = m.shape
    vis = np.zeros(nx, dtype=int)
    naj, out = 0, None
    for r in range(ny):
        vis = np.where(m[r], vis + 1, 0)
        stog = []
        for c in range(nx + 1):
            hc = vis[c] if c < nx else 0
            poc = c
            while stog and stog[-1][1] >= hc:
                pc, ph = stog.pop()
                pov = ph * (c - pc)
                if pov > naj:
                    naj, out = pov, (r - ph + 1, pc, r, c - 1)
                poc = pc
            stog.append((poc, hc))
    return out


def _gr(g, kut, rub):
    c0 = g.centroid
    gr = affinity.rotate(g, -kut, origin=c0)
    if rub:
        gr = gr.buffer(-rub)
        dj = dijelovi(gr)
        if not dj:
            return None, c0
        gr = max(dj, key=lambda x: x.area)
    return gr, c0


def _korak_rastera(gr):
    x0, y0, x1, y1 = gr.bounds
    return min(2.0, max(0.2, min(x1 - x0, y1 - y0) / 120.0, max(x1 - x0, y1 - y0) / 400.0))


def upisani_pravokutnik(g, rub=0.0):
    """Najveći pravokutnik (po površini) upisan u poligon. Ispituje se nekoliko smjerova (glavna os i
    najdulje stranice); u svakom se traži rasterom (ćelije cijele u poligonu), a zatim se svaka stranica
    točno dorađuje binarnim traženjem. Vrati (cx, cy, kut, a, b): a je stranica uzduž kuta."""
    najbolji = None
    for kut in _kutovi_kandidati(g):
        gr, c0 = _gr(g, kut, rub)
        if gr is None or gr.is_empty:
            continue
        pr = prep(gr)
        x0, y0, x1, y1 = gr.bounds
        if pr.contains(box(x0 + 1e-6, y0 + 1e-6, x1 - 1e-6, y1 - 1e-6)):
            kand = (x0, y0, x1, y1)
        else:
            h = _korak_rastera(gr)
            m, mx0, my0 = _raster_unutra(gr, h)
            r = _najveci_u_maski(m) if m.any() else None
            if r is None:
                continue
            kand = [mx0 + r[1] * h, my0 + r[0] * h, mx0 + (r[3] + 1) * h, my0 + (r[2] + 1) * h]
            for i, smjer in ((0, -1), (2, 1), (1, -1), (3, 1)):     # dorada: svaka stranica posebno
                lo, hi = 0.0, 2.0 * h + 0.5
                for _ in range(14):
                    mid = (lo + hi) / 2
                    k2 = list(kand)
                    k2[i] += smjer * mid
                    if pr.contains(box(*k2)):
                        lo = mid
                    else:
                        hi = mid
                kand[i] += smjer * lo
            kand = tuple(kand)
        pov = (kand[2] - kand[0]) * (kand[3] - kand[1])
        if najbolji is None or pov > najbolji[0] + 1e-6:
            najbolji = (pov, kand, kut, c0)
    if najbolji is None:
        return None
    _, k, kut, c0 = najbolji
    a, b = k[2] - k[0], k[3] - k[1]
    sred = affinity.rotate(Point((k[0] + k[2]) / 2, (k[1] + k[3]) / 2), kut, origin=c0)
    if b > a:       # a je duža stranica, uzduž kuta
        a, b, kut = b, a, kut + 90.0
    return sred.x, sred.y, kut, a, b


def smjesti_pravokutnik(g, l, w, tol=0.0, blizu=None):
    """Gdje u poligon stane pravokutnik l x w (bilo kojim smjerom od kandidata, bilo gdje u poligonu)?
    Raster daje kandidate (s popustom od jedne ćelije), a svaki se kandidat provjerava točno (shapely), s
    pomacima do pola ćelije. Vrati (cx, cy, kut) s l uzduž kuta, najbliže točki blizu (ili središtu), ili None."""
    najbolji = None
    for kut in _kutovi_kandidati(g):
        gr, c0 = _gr(g, kut, 0.0)
        if gr is None or gr.is_empty:
            continue
        x0, y0, x1, y1 = gr.bounds
        h = max(0.2, min(min(l, w) / 40.0, max(x1 - x0, y1 - y0) / 500.0))
        m, mx0, my0 = _raster_unutra(gr, h)
        if not m.any():
            continue
        pr = prep(gr)
        S = np.zeros((m.shape[0] + 1, m.shape[1] + 1), dtype=int)
        S[1:, 1:] = m.astype(int).cumsum(0).cumsum(1)
        if blizu is not None:
            q = affinity.rotate(Point(*blizu), -kut, origin=c0)
            bx, by = q.x, q.y
        else:
            q = gr.centroid
            bx, by = q.x, q.y
        for zak, (dx, dy) in ((False, (l, w)), (True, (w, l))):
            ex, ey = dx - tol, dy - tol
            nx, ny = max(1, int(math.floor(ex / h)) - 1), max(1, int(math.floor(ey / h)) - 1)
            if nx > m.shape[1] or ny > m.shape[0]:
                continue
            zbroj = S[ny:, nx:] - S[:-ny, nx:] - S[ny:, :-nx] + S[:-ny, :-nx]
            rr, cc = np.nonzero(zbroj == nx * ny)
            if not len(rr):
                continue
            cx = mx0 + (cc + nx / 2) * h
            cy = my0 + (rr + ny / 2) * h
            d = np.hypot(cx - bx, cy - by)
            for i in np.argsort(d, kind='stable')[:300]:
                if najbolji is not None and d[i] >= najbolji[0] - 1e-6:
                    break
                nadjeno = None
                for ox in (0.0, -0.5 * h, 0.5 * h, -h, h):
                    for oy in (0.0, -0.5 * h, 0.5 * h, -h, h):
                        X, Y = cx[i] + ox, cy[i] + oy
                        if pr.contains(box(X - ex / 2, Y - ey / 2, X + ex / 2, Y + ey / 2)):
                            nadjeno = (X, Y)
                            break
                    if nadjeno:
                        break
                if nadjeno:
                    p = affinity.rotate(Point(*nadjeno), kut, origin=c0)
                    najbolji = (float(d[i]), p.x, p.y, kut + (90.0 if zak else 0.0))
                    break
    return None if najbolji is None else najbolji[1:]


# ------------------------------------------------------------------------------------------------- podaci
def otisak_programa(put):
    """sha256 datoteke programa (heksadecimalno): list, manifest i popis pokazuju iz kojeg su stanja nastali."""
    return hashlib.sha256(Path(put).read_bytes()).hexdigest()


class Podaci:
    """Program preveden u ENU-M. Brojevi prostora su redni brojevi unutar razine (redoslijed zapisa)."""

    def __init__(self, put):
        self.put = Path(put)
        self.otisak = otisak_programa(self.put)   # sha256 datoteke programa iz koje su listovi nastali
        self.raw = PA.ucitaj_json(put)
        self.model = PA.Model(self.raw)
        self.meta = self.raw.get('meta') if isinstance(self.raw.get('meta'), dict) else {}
        self.T = pretvorba(self.meta.get('koordinate'))
        self.u_metrickom = self.T is _identitet
        self.razine = []
        for r in self.model.razine:
            raw = r['raw']
            self.razine.append({'id': r['id'], 'naziv': r['naziv'], 'kota': r['kota'], 'visina': r['visina'],
                                'geom': g_u_m(r['geom'], self.T), 'i': len(self.razine),
                                'opis': str(raw.get('opis') or ''), 'status': str(raw.get('status') or '')})
        self.razina = {r['id']: r for r in self.razine}
        self.prostori, self.nevaljani = [], []
        brojac = {}
        for s in self.model.prostori:
            if s['geom'] is None or s['razina'] not in self.razina:
                if s['razina'] not in self.razina:
                    razlog = f'razina „{s["razina"]}” ne postoji'
                else:
                    _, pog = PA.napravi_poligon(s['raw'].get('poligon'), s['raw'].get('rupe'))
                    razlog = pog[0] if pog else 'nevaljan poligon'
                self.nevaljani.append(f'{s["id"]} ({razlog})')
                continue
            raw = s['raw']
            g = g_u_m(s['geom'], self.T)
            brojac[s['razina']] = brojac.get(s['razina'], 0) + 1
            kap = raw.get('kapacitet') if isinstance(raw.get('kapacitet'), dict) else None
            vis_vlastita = float(raw['svijetla_visina_m']) if PA.je_broj(raw.get('svijetla_visina_m')) else None
            visina = s['visina']
            if s['kat'] == 'trg_predvorje':
                visina = vis_vlastita     # trg bez vlastite visine je otvoren; visina razine vrijedi za dvorane
            self.prostori.append({
                'id': s['id'], 'razina': s['razina'], 'naziv': s['naziv'], 'kat': s['kat'] if s['kat'] in KAT else
                'postojece', 'geom': g, 'a': g.area, 'a_n': s['geom'].area, 'pod': s['pod'], 'visina': visina,
                'visina_vlastita': vis_vlastita, 'sportovi': s['sportovi'], 'br': brojac[s['razina']],
                'kap': kap, 'razred': raw.get('olimpijski_razred'), 'status': str(raw.get('status') or ''),
                'napomena': str(raw.get('napomena') or ''), 'raw': raw})
        self.po_razini = {r['id']: [s for s in self.prostori if s['razina'] == r['id']] for r in self.razine}
        self.veze = []
        for v in self.model.veze:
            if v['geom'] is None:
                continue
            raw = v['raw']
            self.veze.append({'id': v['id'], 'tip': v['tip'] if v['tip'] in VEZE else 'ulaz',
                              'razine': [x for x in v['razine'] if x in self.razina],
                              'geom': g_u_m(v['geom'], self.T), 'raw': raw,
                              'sirina': float(raw['sirina_m']) if PA.je_broj(raw.get('sirina_m')) else None,
                              'nagib': float(raw['nagib_posto']) if PA.je_broj(raw.get('nagib_posto')) else None,
                              'napomena': str(raw.get('napomena') or '')})
        self.spojevi_tp = self._spoji_topli_put()
        kt = [k for k in (self.raw.get('kote_terena') or []) if isinstance(k, dict) and all(
            PA.je_broj(k.get(a)) for a in ('x', 'y', 'z'))]
        self.kote_xy = self.T(np.array([[k['x'], k['y']] for k in kt], dtype=float)) if kt else np.zeros((0, 2))
        self.kote_z = np.array([k['z'] for k in kt], dtype=float)
        self.stadion = self._stadion(self.raw.get('stadion'))
        g = [s['geom'] for s in self.prostori] + [r['geom'] for r in self.razine if r['geom'] is not None]
        self.obuhvat = unary_union(g).bounds if g else (-450.0, -450.0, 300.0, 200.0)
        self.unija_razine = {}
        for r in self.razine:
            pp = self.po_razini[r['id']]
            self.unija_razine[r['id']] = unary_union([s['geom'] for s in pp]) if pp else None

    def _spoji_topli_put(self, najvise=30.0, udio=0.98):
        """Spoji kraj crte toplog puta s najbližom crtom toplog puta iste razine kad cijela praznina leži u
        prostorima toplog puta ili trga i predvorja te razine (program crta ne dovodi do kraja). Crta veze se
        produži do spoja; popis spojeva ide u manifest i u TLOCRTI.md. Prazninu izvan takvih prostora ne spaja."""
        tp = [v for v in self.veze if v['tip'] == 'topli_put' and v['geom'].geom_type == 'LineString']
        spojevi = []
        for v in tp:
            for raz in v['razine']:
                drugi = [w for w in tp if w is not v and raz in w['razine']]
                pp = [s['geom'] for s in self.prostori if s['razina'] == raz and s['kat'] in ('topli_put', 'trg_predvorje')]
                if not drugi or not pp:
                    continue
                dopusteno = unary_union(pp).buffer(0.5)
                for kraj in (0, -1):
                    c = list(v['geom'].coords)
                    p = Point(c[kraj])
                    if any(w['geom'].distance(p) < 0.5 for w in drugi):
                        continue
                    w = min(drugi, key=lambda w: w['geom'].distance(p))
                    d = w['geom'].distance(p)
                    if d > najvise:
                        continue
                    q = w['geom'].interpolate(w['geom'].project(p))
                    seg = LineString([p, q])
                    if seg.intersection(dopusteno).length < udio * seg.length:
                        continue
                    c = c + [(q.x, q.y)] if kraj == -1 else [(q.x, q.y)] + c
                    v['geom'] = LineString(c)
                    spojevi.append({'veza': v['id'], 'do': w['id'], 'razina': raz, 'duljina_m': round(d, 1)})
        return spojevi

    def _prsten(self, v):
        t = PA.tocke(v)
        if not t or len(set(t)) < 3:
            return None
        try:
            g = Polygon(t)
            g = g if g.is_valid else g.buffer(0)
            dj = dijelovi(g)
            return g_u_m(max(dj, key=lambda x: x.area), self.T) if dj else None
        except Exception:  # noqa: BLE001
            return None

    def _stadion(self, st):
        if not isinstance(st, dict):
            return None
        out = {'igraliste': self._prsten(st.get('igraliste')), 'obris': self._prsten(st.get('vanjski_obris')),
               'tribine': [], 'krov': None, 'procelje': None, 'sredina': None}
        t = PA.tocke([st.get('sredina')]) if st.get('sredina') is not None else None
        if t:
            out['sredina'] = tuple(self.T(np.array(t))[0])
        elif out['igraliste'] is not None:
            out['sredina'] = (out['igraliste'].centroid.x, out['igraliste'].centroid.y)
        for tr in st.get('tribine') or []:
            if not isinstance(tr, dict):
                continue
            un, va = self._prsten(tr.get('unutarnji_obris')), self._prsten(tr.get('vanjski_obris'))
            if un is None or va is None or not PA.je_broj(tr.get('kota_dna_mnv')) or not PA.je_broj(
                    tr.get('kota_vrha_mnv')):
                continue
            out['tribine'].append({'naziv': str(tr.get('naziv', 'tribina')), 'unutarnji': un, 'vanjski': va,
                                   'dno': float(tr['kota_dna_mnv']), 'vrh': float(tr['kota_vrha_mnv']),
                                   'mjesta': tr.get('mjesta'), 'profil': self._profil(tr.get('profil')),
                                   'redova': self._redova(tr)})
        sj = st.get('sjever')
        out['sjever'] = None
        if isinstance(sj, dict):
            g = self._prsten(sj.get('obris'))
            prof = self._profil(sj.get('profil'))
            if g is not None and prof is not None:
                out['sjever'] = {'naziv': str(sj.get('naziv') or 'sjever'), 'obris': g, 'profil': prof,
                                 'dno': float(prof[0][1]), 'vrh': float(prof[-1][1]), 'redova': self._redova(sj)}
        kr = st.get('krov')
        if isinstance(kr, dict):
            un, va = self._prsten(kr.get('unutarnji_rub')), self._prsten(kr.get('vanjski_rub'))
            if un is not None and va is not None:
                out['krov'] = {'unutarnji': un, 'vanjski': va,
                               'rub': float(kr['kota_ruba_mnv']) if PA.je_broj(kr.get('kota_ruba_mnv')) else None,
                               'vrh': float(kr['kota_vrha_mnv']) if PA.je_broj(kr.get('kota_vrha_mnv')) else None}
        pr = st.get('procelje')
        if isinstance(pr, dict) and PA.je_broj(pr.get('kota_dna_mnv')) and PA.je_broj(pr.get('kota_vrha_mnv')):
            out['procelje'] = {'dno': float(pr['kota_dna_mnv']), 'vrh': float(pr['kota_vrha_mnv']),
                               'razmak': pr.get('razmak_lamela_m')}
        return out

    @staticmethod
    def _profil(v):
        """Profil tribine [[d, z], ...] (d m od prvog reda zdjele, z m n. v.), rastući d; None ako ga nema."""
        if not isinstance(v, list):
            return None
        t = [(float(a[0]), float(a[1])) for a in v if isinstance(a, (list, tuple)) and len(a) >= 2 and
             PA.je_broj(a[0]) and PA.je_broj(a[1])]
        t.sort()
        return t if len(t) >= 2 else None

    @staticmethod
    def _redova(tr):
        vid = tr.get('vidljivost') if isinstance(tr.get('vidljivost'), dict) else {}
        return int(vid['redova']) if PA.je_broj(vid.get('redova')) and vid['redova'] > 0 else None

    def datum(self):
        return str(self.meta.get('datum') or '')

    def naslov(self):
        return str(self.meta.get('naziv') or self.put.name)


class Podloga:
    """Postojeće stanje iz site.json prevedeno u ENU-M; slojevi s prostornim indeksom."""

    def __init__(self, put):
        self.ima = False
        self.sloj = {}
        self.stajalista = []
        self.stabla = np.zeros((0, 2))
        if not put or str(put) == 'ne' or not Path(put).is_file():
            return
        try:
            raw = PA.ucitaj_json(put)
        except Exception as e:  # noqa: BLE001
            print(f'NAPOMENA: site.json se ne može pročitati ({e}); crtam bez podloge.', file=sys.stderr)
            return
        T = pretvorba((raw.get('meta') or {}).get('koordinate'))
        self.T = T

        def pol(z):
            t = PA.tocke(z.get('poligon')) if isinstance(z, dict) else None
            if not t or len(set(t)) < 3:
                return None
            rupe = [r for r in (PA.tocke(x) for x in (z.get('rupe') or [])) if r and len(set(r)) >= 3]
            try:
                g = Polygon(t, rupe)
                g = g if g.is_valid else g.buffer(0)
                return g_u_m(g, T) if not g.is_empty else None
            except Exception:  # noqa: BLE001
                return None

        def lin(z):
            t = PA.tocke(z.get('linija')) if isinstance(z, dict) else None
            return g_u_m(LineString(t), T) if t and len(t) >= 2 else None

        def put_(*k):
            v = raw
            for x in k:
                v = v.get(x) if isinstance(v, dict) else None
            return v if isinstance(v, list) else []

        sl = {'zgrade': [(pol(z), z) for z in put_('zgrade')],
              'ceste': [(lin(z), z) for z in put_('ceste')],
              'staze': [(lin(z), z) for z in put_('pjesacke_staze')],
              'tram': [(lin(z), z) for z in put_('tramvaj', 'pruge')],
              'zeljeznica': [(lin(z), z) for z in put_('zeljeznica', 'pruge')],
              'vode': [(pol(z), z) for z in put_('vode', 'povrsine')],
              'zelenilo': [(pol(z), z) for k in ('sume', 'parkovi') for z in put_('zelenilo', k)] +
                          [(pol(z), z) for z in put_('park_maksimir', 'granica_osm_u_okviru')]}
        for k, v in sl.items():
            v = [(g, z) for g, z in v if g is not None and not g.is_empty]
            self.sloj[k] = (v, STRtree([g for g, _ in v]) if v else None)
        for vrsta, kljucevi in (('tramvaj', ('stajalista', 'tramvaj')), ('autobus', ('stajalista', 'autobus')),
                                ('vlak', ('zeljeznica', 'stajalista'))):
            for z in put_(*kljucevi):
                t = PA.tocke([z.get('tocka')]) if isinstance(z, dict) and z.get('tocka') is not None else None
                if t and z.get('naziv'):
                    p = T(np.array(t))[0]
                    self.stajalista.append((vrsta, str(z['naziv']), float(p[0]), float(p[1])))
        st = [t for t in put_('zelenilo', 'stabla') if isinstance(t, (list, tuple)) and len(t) >= 2 and
              PA.je_broj(t[0]) and PA.je_broj(t[1])]
        if st:
            self.stabla = T(np.array([[float(t[0]), float(t[1])] for t in st]))
        self.ima = any(v for v, _ in self.sloj.values())

    def u_okviru(self, sloj, okvir):
        v, stablo = self.sloj.get(sloj, ([], None))
        if stablo is None:
            return []
        return [v[i] for i in sorted(stablo.query(okvir))]


def ucitaj_kote_situacije(put):
    """Stvarne kote terena (samo vrsta teren, visoka pouzdanost) u ENU-M: popis (x, y, z)."""
    if not put or str(put) == 'ne' or not Path(put).is_file():
        return []
    try:
        raw = PA.ucitaj_json(put)
    except Exception:  # noqa: BLE001
        return []
    out = []
    for t in raw.get('tocke') or []:
        if not isinstance(t, dict) or not str(t.get('vrsta', '')).startswith('teren'):
            continue
        if t.get('podvrsta') != 'teren' or t.get('pouzdanost') != 'visoka':
            continue
        if all(PA.je_broj(t.get(a)) for a in ('x', 'y', 'z')):
            out.append((t['x'], t['y'], t['z']))
    if not out:
        return []
    a = _nm(np.array([[x, y] for x, y, _ in out]))
    return [(float(a[i, 0]), float(a[i, 1]), float(out[i][2])) for i in range(len(out))]


# ---------------------------------------------------------------------------------------------------- SVG
class Svg:
    """Mali pisač SVG-a u milimetrima lista. Tekst ostaje tekst."""

    def __init__(self, uid, w=LIST_W, h=LIST_H):
        self.uid, self.w, self.h = uid, w, h
        self.defs, self.el = [], []

    def add(self, s):
        self.el.append(s)

    def otvori(self, **a):
        self.el.append('<g' + ''.join(f' {k.replace("_", "-")}="{esc(v)}"' for k, v in a.items()) + '>')

    def zatvori(self):
        self.el.append('</g>')

    @staticmethod
    def _stil(ispuna=None, rub=None, deb=0.2, crt=None, neprozirnost=None, kraj=None, spoj='round', extra=''):
        s = f' fill="{ispuna or "none"}"'
        if rub:
            s += f' stroke="{rub}" stroke-width="{f2(deb)}" stroke-linejoin="{spoj}"'
            if crt:
                s += f' stroke-dasharray="{crt}"'
            if kraj:
                s += f' stroke-linecap="{kraj}"'
        if neprozirnost is not None:
            s += f' opacity="{f2(neprozirnost)}"'
        return s + extra

    def put(self, d, **k):
        if d:
            self.el.append(f'<path d="{d}"{self._stil(**k)}/>')

    def linija(self, x1, y1, x2, y2, rub='#000', deb=0.2, crt=None, kraj=None, extra=''):
        self.el.append(f'<path d="M{f2(x1)},{f2(y1)}L{f2(x2)},{f2(y2)}"{self._stil(None, rub, deb, crt, None, kraj)}'
                       f'{extra}/>')

    def pravokutnik(self, x, y, w, h, rx=0, **k):
        self.el.append(f'<rect x="{f2(x)}" y="{f2(y)}" width="{f2(w)}" height="{f2(h)}"'
                       + (f' rx="{f2(rx)}"' if rx else '') + f'{self._stil(**k)}/>')

    def krug(self, x, y, r, **k):
        self.el.append(f'<circle cx="{f2(x)}" cy="{f2(y)}" r="{f2(r)}"{self._stil(**k)}/>')

    def tekst(self, x, y, s, vel=F_TEKST, boja='#111', bold=False, sidro='start', kut=0, kurziv=False, extra=''):
        a = f' x="{f2(x)}" y="{f2(y)}" font-size="{f2(vel)}" fill="{boja}"'
        if bold:
            a += ' font-weight="bold"'
        if kurziv:
            a += ' font-style="italic"'
        if sidro != 'start':
            a += f' text-anchor="{sidro}"'
        if kut:
            a += f' transform="rotate({f2(kut)} {f2(x)} {f2(y)})"'
        self.el.append(f'<text{a}{extra}>{esc(s)}</text>')

    def srafura(self, g, vrsta, boja, neprozirnost=0.6):
        """Vektorska šrafura poligona g (koordinate lista): usporedne linije odrezane na poligon. Ne koristi se
        SVG <pattern>, jer ga Chromium u PDF-u pretvara u sliku."""
        if g is None or g.is_empty:
            return
        for kut, razmak, deb, crt in SRAFURE.get(vrsta, SRAFURE['koso']):
            d = d_linija(linije_srafure(g, kut, razmak))
            if d:
                self.put(d, rub=boja, deb=deb, crt=crt, kraj='round' if crt else None, neprozirnost=neprozirnost)

    def isjecak(self, x, y, w, h):
        kid = f'{self.uid}-c{len(self.defs)}'
        self.defs.append(f'<clipPath id="{kid}"><rect x="{f2(x)}" y="{f2(y)}" width="{f2(w)}" height="{f2(h)}"/>'
                         '</clipPath>')
        return f'url(#{kid})'

    def tekst_svg(self):
        return (f'<svg xmlns="http://www.w3.org/2000/svg" width="{f2(self.w)}mm" height="{f2(self.h)}mm" '
                f'viewBox="0 0 {f2(self.w)} {f2(self.h)}" font-family="{FONT}">\n'
                f'<defs>{"".join(self.defs)}</defs>\n'
                f'<rect x="0" y="0" width="{f2(self.w)}" height="{f2(self.h)}" fill="#ffffff"/>\n'
                + '\n'.join(self.el) + '\n</svg>\n')

    def zapisi(self, put):
        Path(put).write_text('<?xml version="1.0" encoding="UTF-8"?>\n' + self.tekst_svg(), encoding='utf-8')


# šrafure: (kut u stupnjevima, razmak u mm, debljina, crtkanje); crtkanje "0.01 n" uz zaobljene krajeve daje točke
SRAFURE = {
    'koso': [(45.0, 1.4, 0.12, None)],
    'koso2': [(135.0, 1.4, 0.12, None)],
    'kriz': [(45.0, 2.2, 0.1, None), (135.0, 2.2, 0.1, None)],
    'tocke': [(45.0, 1.7, 0.3, '0.01 2.4')],
    'vodoravno': [(0.0, 1.6, 0.11, None)],
    'okomito': [(90.0, 1.8, 0.11, None)],
    'tocke2': [(0.0, 3.0, 0.26, '0.01 3.0')],
    'tlo': [(45.0, 2.2, 0.1, None), (135.0, 4.4, 0.24, '0.01 3.1')],
    'beton': [(45.0, 0.9, 0.11, None)],
}


def linije_srafure(g, kut, razmak):
    """Usporedne linije pod kutom, na razmaku (mm), odrezane na geometriju; mreža je vezana za ishodište lista
    pa se šrafure susjednih poligona poklapaju."""
    c, s_ = math.cos(math.radians(kut)), math.sin(math.radians(kut))
    x0, y0, x1, y1 = g.bounds
    kutovi = [(x0, y0), (x1, y0), (x1, y1), (x0, y1)]
    n = [-s_ * x + c * y for x, y in kutovi]      # udaljenost od pravca kroz ishodište
    t = [c * x + s_ * y for x, y in kutovi]
    linije = []
    i = math.ceil(min(n) / razmak)
    while i * razmak <= max(n):
        d = i * razmak
        px, py = -s_ * d, c * d
        linije.append([(px + c * (min(t) - 1), py + s_ * (min(t) - 1)), (px + c * (max(t) + 1), py + s_ * (max(t) + 1))])
        i += 1
    if not linije:
        return None
    return MultiLineString(linije).intersection(g)


def d_prsten(c):
    return 'M' + 'L'.join(f'{f2(x)},{f2(y)}' for x, y in c[:-1]) + 'Z'


def d_poligon(g):
    """Put SVG-a za poligon ili više poligona (već u koordinatama lista)."""
    out = []
    for p in dijelovi(g):
        out.append(d_prsten(list(p.exterior.coords)))
        for r in p.interiors:
            out.append(d_prsten(list(r.coords)))
    return ''.join(out)


def d_linija(g):
    out = []
    for l in dijelovi(g, 'LineString'):
        c = list(l.coords)
        if len(c) >= 2:
            out.append('M' + 'L'.join(f'{f2(x)},{f2(y)}' for x, y in c))
    for p in dijelovi(g, 'Polygon'):
        out.append(d_prsten(list(p.exterior.coords)))
    for p in dijelovi(g, 'LinearRing'):
        out.append(d_prsten(list(p.coords)))
    return ''.join(out)


def d_tocke(t, zatvori=False):
    if len(t) < 2:
        return ''
    return 'M' + 'L'.join(f'{f2(x)},{f2(y)}' for x, y in t) + ('Z' if zatvori else '')


class Pogled:
    """Preslikavanje ENU-M -> mm lista u točnom mjerilu 1:mjerilo, za pravokutnik karte (x, y, w, h)."""

    def __init__(self, cx, cy, mjerilo, okvir_mm):
        self.cx, self.cy, self.mjerilo = cx, cy, mjerilo
        self.k = 1000.0 / mjerilo
        self.x, self.y, self.w, self.h = okvir_mm
        self.ax = self.x + self.w / 2 - self.k * cx
        self.ay = self.y + self.h / 2 + self.k * cy
        hw, hh = self.w / 2 / self.k, self.h / 2 / self.k
        self.svijet = box(cx - hw, cy - hh, cx + hw, cy + hh)
        self.granice = (cx - hw, cy - hh, cx + hw, cy + hh)
        self.pravokutnik = box(self.x, self.y, self.x + self.w, self.y + self.h)

    def t(self, x, y):
        return self.ax + self.k * x, self.ay - self.k * y

    def g(self, geom):
        return affinity.affine_transform(geom, [self.k, 0, 0, -self.k, self.ax, self.ay])

    def gk(self, geom):
        """Odreži na okvir pogleda pa preslikaj."""
        c = geom.intersection(self.svijet)
        return None if c.is_empty else self.g(c)


class Sudari:
    """Zauzeti pravokutnici na listu (mm) za izbjegavanje preklapanja natpisa."""

    def __init__(self):
        self.tvrdi, self.meki = [], []

    @staticmethod
    def _sijece(a, b):
        return a[0] < b[2] and a[2] > b[0] and a[1] < b[3] and a[3] > b[1]

    def slobodno(self, r, i_meki=False):
        for q in self.tvrdi:
            if self._sijece(r, q):
                return False
        if i_meki:
            for q in self.meki:
                if self._sijece(r, q):
                    return False
        return True

    def dodaj(self, r, meki=False):
        (self.meki if meki else self.tvrdi).append(r)


# ---------------------------------------------------------------------------------------- sportska borilišta
# Crtež borilišta: popis elemenata (vrsta, točke, stil) u lokalnim koordinatama borilišta (m), ishodište u
# sredini, x uzduž duže stranice. vrsta: 'l' linija, 'p' ispunjeni poligon. stil linije: 'rub' (granica
# igraće površine), 'n' (obična), 'c' (crtkana), 't' (tanka); stil poligona: ključ boje ispune.
# Dimenzije igraće površine i pojaseva dolaze iz sportovi_dimenzije.json; unutarnje oznake (krugovi, crte
# napada, kazneni prostori) upisane su ovdje prema pravilima saveza iz općeg znanja (PRETPOSTAVKA).
SPORT_DODATNI = {  # sportovi kojih nema u sportovi_dimenzije.json, a crtač ih zna nacrtati
    'tenis': {'id': 'tenis', 'naziv': 'tenis', 'razred': None, 'igraca_povrsina_m': [23.77, 10.97],
              'sigurnosni_pojas_m': {'uzduzno_ukupno': 12.8, 'poprecno_ukupno': 7.32},
              'min_svijetla_visina_m': None, 'skupina': 'tenis',
              'izvor': 'ITF Rules of Tennis, pravilo 1 (PRETPOSTAVKA, upisano u crtaču)'},
}
ISPUNE_BORILISTA = {'parket': '#fbf4e4', 'strunjaca': '#f6e7a1', 'pojas': '#efc4b2', 'stol': '#5b8fd0',
                    'trava': '#bfe3ad', 'staza': '#d98d6a', 'pijesak': '#f1e2b6', 'platforma': '#e9dcc3',
                    'led': '#e8f4fb'}
BOJE_LINIJA = ['#1f3a5f', '#b03a2e', '#1e7d4e', '#7d3c98', '#b9770e', '#117a8b']


def _luk(cx, cy, r, a0, a1, korak=6.0):
    n = max(2, int(abs(a1 - a0) / korak) + 1)
    return [(cx + r * math.cos(math.radians(a0 + (a1 - a0) * i / n)),
             cy + r * math.sin(math.radians(a0 + (a1 - a0) * i / n))) for i in range(n + 1)]


def _prav(x0, y0, x1, y1):
    return [(x0, y0), (x1, y0), (x1, y1), (x0, y1), (x0, y0)]


def _zrcali(el):
    """Dodaj zrcalnu sliku elemenata po osi y (druga polovica igrališta)."""
    return el + [(v, [(-x, y) for x, y in t], s) for v, t, s in el]


def _odrezi(el, hx, hy):
    """Odreži linije na pravokutnik igrališta."""
    okv = box(-hx, -hy, hx, hy)
    out = []
    for v, t, s in el:
        if v != 'l':
            out.append((v, t, s))
            continue
        c = LineString(t).intersection(okv)
        for l in dijelovi(c, 'LineString'):
            out.append((v, list(l.coords), s))
    return out


def _vrata_luk(hx, r, pola=1.5, stil='n'):
    """Crta na udaljenosti r od vrata: četvrtine kruga oko vratnica i ravni dio između (rukomet, futsal)."""
    t = _luk(hx, -pola, r, 270, 180) + _luk(hx, pola, r, 180, 90)
    return [('l', t, stil)]


def t_rukomet(L, W, e):
    hx, hy = L / 2, W / 2
    pol = _vrata_luk(hx, 6.0) + _vrata_luk(hx, 9.0, stil='c') + [
        ('l', [(hx - 7, -0.5), (hx - 7, 0.5)], 'n'), ('l', _prav(hx, -1.5, hx + 1.0, 1.5), 't')]
    return [('p', _prav(-hx, -hy, hx, hy), 'parket'), ('l', _prav(-hx, -hy, hx, hy), 'rub'),
            ('l', [(0, -hy), (0, hy)], 'n')] + _odrezi(_zrcali(pol), hx + 1.0, hy)


def t_futsal(L, W, e):
    hx, hy = L / 2, W / 2
    pol = _vrata_luk(hx, 6.0) + [('l', _luk(hx - 6, 0, 0.12, 0, 360, 60), 'n'),
                                 ('l', _luk(hx - 10, 0, 0.12, 0, 360, 60), 'n'),
                                 ('l', _prav(hx, -1.5, hx + 1.0, 1.5), 't')]
    return [('p', _prav(-hx, -hy, hx, hy), 'parket'), ('l', _prav(-hx, -hy, hx, hy), 'rub'),
            ('l', [(0, -hy), (0, hy)], 'n'), ('l', _luk(0, 0, 3.0, 0, 360), 'n')] + _odrezi(_zrcali(pol), hx + 1, hy)


def _kos_polovica(hx, hy):
    """Oznake jedne polovice košarkaškog igrališta; koš je na x = +hx."""
    kx = hx - 1.575
    yk = min(hy - 0.9, 6.6)
    dx = math.sqrt(max(6.75 ** 2 - yk ** 2, 0.0))
    a = math.degrees(math.atan2(yk, -dx))
    trica = [(hx, -yk), (kx - dx, -yk)] + _luk(kx, 0, 6.75, 360 - a, a)[1:-1] + [(kx - dx, yk), (hx, yk)]
    return [('l', _prav(hx - 5.8, -2.45, hx, 2.45), 'n'), ('l', _luk(hx - 5.8, 0, 1.8, 90, 270), 'n'),
            ('l', trica, 'n'), ('l', [(hx - 1.2, -0.9), (hx - 1.2, 0.9)], 'n'),
            ('l', _luk(kx, 0, 0.23, 0, 360, 45), 't'), ('l', _luk(kx, 0, 1.25, 90, 270), 't')]


def t_kosarka(L, W, e):
    hx, hy = L / 2, W / 2
    return [('p', _prav(-hx, -hy, hx, hy), 'parket'), ('l', _prav(-hx, -hy, hx, hy), 'rub'),
            ('l', [(0, -hy), (0, hy)], 'n'), ('l', _luk(0, 0, 1.8, 0, 360), 'n')] + _zrcali(_kos_polovica(hx, hy))


def t_kosarka_3x3(L, W, e):
    # igraća površina 15 (širina uz koš) x 11 (dubina): koš je na sredini duže stranice
    hx, hy = L / 2, W / 2
    pol = _kos_polovica(hy, hx)  # u okviru dubina (x), širina (y); zakreni tako da koš bude na y = -hy
    zak = [(v, [(y, -x) for x, y in t], s) for v, t, s in pol]
    return [('p', _prav(-hx, -hy, hx, hy), 'parket'), ('l', _prav(-hx, -hy, hx, hy), 'rub')] + _odrezi(zak, hx, hy)


def t_odbojka(L, W, e):
    hx, hy = L / 2, W / 2
    ispuna = 'pijesak' if 'pijes' in e.get('id', '') else 'parket'
    out = [('p', _prav(-hx, -hy, hx, hy), ispuna), ('l', _prav(-hx, -hy, hx, hy), 'rub'),
           ('l', [(0, -hy - 0.9), (0, hy + 0.9)], 'n')]
    if ispuna == 'parket':
        out += [('l', [(-3, -hy), (-3, hy)], 'n'), ('l', [(3, -hy), (3, hy)], 'n')]
    return out


def t_badminton(L, W, e):
    hx, hy = L / 2, W / 2
    pol = [('l', [(1.98, -hy), (1.98, hy)], 'n'), ('l', [(hx - 0.76, -hy), (hx - 0.76, hy)], 'n'),
           ('l', [(1.98, 0), (hx, 0)], 'n')]
    return [('p', _prav(-hx, -hy, hx, hy), 'parket'), ('l', _prav(-hx, -hy, hx, hy), 'rub'),
            ('l', [(0, -hy - 0.3), (0, hy + 0.3)], 'n'), ('l', [(-hx, -hy + 0.46), (hx, -hy + 0.46)], 'n'),
            ('l', [(-hx, hy - 0.46), (hx, hy - 0.46)], 'n')] + _zrcali(pol)


def t_tenis(L, W, e):
    hx, hy = L / 2, W / 2
    ys = hy - 1.37
    return [('p', _prav(-hx, -hy, hx, hy), 'parket'), ('l', _prav(-hx, -hy, hx, hy), 'rub'),
            ('l', [(0, -hy - 0.91), (0, hy + 0.91)], 'n'), ('l', [(-hx, -ys), (hx, -ys)], 'n'),
            ('l', [(-hx, ys), (hx, ys)], 'n'), ('l', [(-6.4, -ys), (-6.4, ys)], 'n'),
            ('l', [(6.4, -ys), (6.4, ys)], 'n'), ('l', [(-6.4, 0), (6.4, 0)], 'n')]


def t_stolni_tenis(L, W, e):
    hx, hy = L / 2, W / 2
    return [('l', _prav(-hx, -hy, hx, hy), 'c'), ('p', _prav(-1.37, -0.7625, 1.37, 0.7625), 'stol'),
            ('l', _prav(-1.37, -0.7625, 1.37, 0.7625), 'rub'), ('l', [(0, -0.915), (0, 0.915)], 'n'),
            ('l', [(-1.37, 0), (1.37, 0)], 't')]


def t_squash(L, W, e):
    hx, hy = L / 2, W / 2
    xs = -hx + 5.44
    return [('p', _prav(-hx, -hy, hx, hy), 'parket'), ('l', _prav(-hx, -hy, hx, hy), 'rub'),
            ('l', [(xs, -hy), (xs, hy)], 'n'), ('l', [(xs, 0), (hx, 0)], 'n'),
            ('l', [(xs + 1.6, -hy), (xs + 1.6, -hy + 1.6), (xs, -hy + 1.6)], 'n'),
            ('l', [(xs + 1.6, hy), (xs + 1.6, hy - 1.6), (xs, hy - 1.6)], 'n')]


def t_strunjaca(L, W, e):
    """Borilište s pojasom: unutarnji kvadrat (borba) i vanjski (sigurnosni pojas)."""
    hx, hy = L / 2, W / 2
    sp = e.get('sigurnosni_pojas_m') or {}
    ox, oy = hx + float(sp.get('uzduzno_ukupno') or 0) / 2, hy + float(sp.get('poprecno_ukupno') or 0) / 2
    sid = e.get('id', '')
    if sid.startswith('gimnastika') or sid == 'trampolin':
        out = [('l', _prav(-ox, -oy, ox, oy), 'c'), ('p', _prav(-hx, -hy, hx, hy), 'strunjaca'),
               ('l', _prav(-hx, -hy, hx, hy), 'rub')]
        if sid == 'trampolin':
            out = [('l', _prav(-hx, -hy, hx, hy), 'c'), ('p', _prav(-2.52, -1.46, 2.52, 1.46), 'strunjaca'),
                   ('l', _prav(-2.52, -1.46, 2.52, 1.46), 'rub'), ('l', _prav(-2.14, -1.07, 2.14, 1.07), 't')]
        return out
    unutra = 'platforma' if sid == 'dizanje_utega' else 'strunjaca'
    return [('p', _prav(-ox, -oy, ox, oy), 'pojas' if unutra == 'strunjaca' else 'parket'),
            ('l', _prav(-ox, -oy, ox, oy), 'n'), ('p', _prav(-hx, -hy, hx, hy), unutra),
            ('l', _prav(-hx, -hy, hx, hy), 'rub')]


def t_hrvanje(L, W, e):
    sp = e.get('sigurnosni_pojas_m') or {}
    o = L / 2 + float(sp.get('uzduzno_ukupno') or 0) / 2
    return [('p', _prav(-o, -o, o, o), 'pojas'), ('l', _prav(-o, -o, o, o), 'n'),
            ('p', _luk(0, 0, L / 2, 0, 360), 'strunjaca'), ('l', _luk(0, 0, L / 2, 0, 360), 'rub'),
            ('l', _luk(0, 0, L / 2 - 1.0, 0, 360), 'n'), ('l', _luk(0, 0, 0.5, 0, 360, 20), 'n')]


def t_boks(L, W, e):
    sp = e.get('sigurnosni_pojas_m') or {}
    h = L / 2
    o = h + float(sp.get('uzduzno_ukupno') or 0) / 2
    return [('p', _prav(-o, -o, o, o), 'platforma'), ('l', _prav(-o, -o, o, o), 'n'),
            ('l', _prav(-h, -h, h, h), 'rub'), ('l', _prav(-h + 0.3, -h + 0.3, h - 0.3, h - 0.3), 't'),
            ('l', [(-h, -h), (-o, -o)], 't'), ('l', [(h, h), (o, o)], 't'), ('l', [(-h, h), (-o, o)], 't'),
            ('l', [(h, -h), (o, -o)], 't')]


def t_macevanje(L, W, e):
    hx, hy = L / 2, W / 2
    sp = e.get('sigurnosni_pojas_m') or {}
    ox = hx + float(sp.get('uzduzno_ukupno') or 0) / 2
    return [('l', _prav(-ox, -hy, ox, hy), 'c'), ('p', _prav(-hx, -hy, hx, hy), 'platforma'),
            ('l', _prav(-hx, -hy, hx, hy), 'rub'), ('l', [(0, -hy), (0, hy)], 'n'),
            ('l', [(-2, -hy), (-2, hy)], 'n'), ('l', [(2, -hy), (2, hy)], 'n'),
            ('l', [(-hx + 2, -hy), (-hx + 2, hy)], 't'), ('l', [(hx - 2, -hy), (hx - 2, hy)], 't')]


def t_staza_gadanja(L, W, e):
    """Uzdužna staza (streljana, streličarstvo, kuglanje, bowling, boćanje): prilaz ili prostor iza crte i staza."""
    hx, hy = L / 2, W / 2
    sp = e.get('sigurnosni_pojas_m') or {}
    pr = float(sp.get('uzduzno_ukupno') or 0)
    out = [('p', _prav(-hx, -hy, hx, hy), 'platforma'), ('l', _prav(-hx, -hy, hx, hy), 'rub')]
    if pr:
        out += [('l', _prav(-hx - pr, -hy, -hx, hy), 'c')]
    out += [('l', [(-hx, -hy), (-hx, hy)], 'n')]
    sid = e.get('id', '')
    if 'strelj' in sid or 'strelic' in sid:
        out += [('p', _prav(hx - 0.25, -min(hy, 0.3), hx, min(hy, 0.3)), 'stol')]
    return out


def t_atletika(L, W, e):
    """Kružna staza 400 m: dva pravca i dva polukruga; širina staze 1,22 m. Iz ukupnih mjera L x W."""
    r_v = W / 2
    pr = (L - W) / 2      # pola duljine pravca
    n = 8 if r_v - 8 * 1.22 > 20 else max(4, int((r_v - 20) / 1.22))
    r_u = r_v - n * 1.22

    def oval(r):
        return _luk(pr, 0, r, -90, 90, 4) + _luk(-pr, 0, r, 90, 270, 4) + [(pr, -r)]
    out = [('p', oval(r_v), 'staza'), ('p', oval(r_u), 'trava')]
    for i in range(n + 1):
        out.append(('l', oval(r_u + i * 1.22), 'rub' if i in (0, n) else 't'))
    out += [('l', [(pr, -r_v), (pr, -r_u)], 'n'), ('l', [(-pr, -r_v), (-pr, -r_u)], 't'),
            ('l', [(pr, r_v), (pr, r_u)], 't'), ('l', [(-pr, r_v), (-pr, r_u)], 't')]
    if r_u < 30.0:
        return out
    # Tehničke discipline u polukružnim segmentima (shematski raspored crtača, PRETPOSTAVKA): mjere krugova,
    # jame i sektora prema pravilima WA iz općeg znanja; točan položaj određuje projekt atletskog stadiona.
    sek = math.radians(34.92 / 2)

    def sektor(cx, cy, smjer, duljina):
        a, b = smjer - sek, smjer + sek
        return [('l', [(cx + duljina * math.cos(a), cy + duljina * math.sin(a)), (cx, cy),
                       (cx + duljina * math.cos(b), cy + duljina * math.sin(b))], 'c')]
    xd = -(pr + 15.0)                                  # zapad: skok u dalj i troskok, zalet uzduž osi y
    out += [('l', _prav(xd - 0.61, -27.0, xd + 0.61, 18.0), 'n'),
            ('p', _prav(xd - 1.375, 18.0, xd + 1.375, 27.0), 'pijesak'), ('l', _prav(xd - 1.375, 18.0, xd + 1.375, 27.0), 'n'),
            ('x', [(xd + 3.0, -6.0)], 'dalj / troskok')]
    xk, yk = -(pr + 28.0), 10.0                        # zapad: bacanje kugle (krug 2,135 m, sektor 34,92°)
    out += [('l', _luk(xk, yk, 1.0675, 0, 360, 20), 'n')] + sektor(xk, yk, -math.pi / 2, 18.0)
    out += [('x', [(xk, yk + 3.2)], 'kugla')]
    xv = pr + 26.0                                     # istok: skok u vis (strunjača 6 x 4 m, zaletište)
    out += [('p', _prav(xv - 2.0, -3.0, xv + 2.0, 3.0), 'strunjaca'), ('l', _prav(xv - 2.0, -3.0, xv + 2.0, 3.0), 'n'),
            ('l', _luk(xv, 0.0, 14.0, 110, 250, 5), 'c'), ('x', [(xv + 5.2, 0.0)], 'vis')]
    xs, ys = pr + 20.0, -22.0                          # istok: disk i kladivo (krug 2,5 m u kavezu), bacanje preko polja
    out += [('l', _luk(xs, ys, 1.25, 0, 360, 20), 'n'), ('l', _luk(xs, ys, 3.6, 200, 520, 10), 't')]
    out += sektor(xs, ys, math.atan2(-ys, -xs), 70.0)         # prema sredini polja
    out += [('x', [(xs + 1.0, ys - 5.2)], 'disk / kladivo')]
    return out


def t_nogomet(L, W, e):
    hx, hy = L / 2, W / 2
    a = math.degrees(math.acos(min(1.0, 5.5 / 9.15)))
    pol = [('l', [(hx, -20.16), (hx - 16.5, -20.16), (hx - 16.5, 20.16), (hx, 20.16)], 'n'),
           ('l', [(hx, -9.16), (hx - 5.5, -9.16), (hx - 5.5, 9.16), (hx, 9.16)], 'n'),
           ('l', _luk(hx - 11, 0, 0.2, 0, 360, 60), 'n'), ('l', _luk(hx - 11, 0, 9.15, 180 - a, 180 + a), 'n'),
           ('l', _luk(hx, -hy, 1.0, 90, 180), 't'), ('l', _luk(hx, hy, 1.0, 180, 270), 't'),
           ('l', _prav(hx, -3.66, hx + 2.0, 3.66), 't')]
    return [('p', _prav(-hx, -hy, hx, hy), 'trava'), ('l', _prav(-hx, -hy, hx, hy), 'rub'),
            ('l', [(0, -hy), (0, hy)], 'n'), ('l', _luk(0, 0, 9.15, 0, 360), 'n'),
            ('l', _luk(0, 0, 0.2, 0, 360, 60), 'n')] + _odrezi(_zrcali(pol), hx + 2.0, hy)


def t_ragbi(L, W, e):
    hx, hy = L / 2, W / 2
    sp = e.get('sigurnosni_pojas_m') or {}
    ig = float(sp.get('uzduzno_ukupno') or 0) / 2
    pol = [('l', [(hx - 22, -hy), (hx - 22, hy)], 'n'), ('l', [(10, -hy), (10, hy)], 'c'),
           ('l', [(hx, -hy), (hx, hy)], 'n')]
    out = [('p', _prav(-hx - ig, -hy, hx + ig, hy), 'trava'), ('l', _prav(-hx - ig, -hy, hx + ig, hy), 'rub'),
           ('l', [(0, -hy), (0, hy)], 'n')]
    return out + _zrcali(pol)


def t_hokej(L, W, e):
    hx, hy = L / 2, W / 2
    pol = [('l', [(hx - 22.9, -hy), (hx - 22.9, hy)], 'n'), ('l', _vrata_luk(hx, 14.63, 1.83)[0][1], 'n'),
           ('l', _vrata_luk(hx, 19.63, 1.83)[0][1], 'c'), ('l', _prav(hx, -1.83, hx + 1.2, 1.83), 't')]
    return [('p', _prav(-hx, -hy, hx, hy), 'trava'), ('l', _prav(-hx, -hy, hx, hy), 'rub'),
            ('l', [(0, -hy), (0, hy)], 'n')] + _odrezi(_zrcali(pol), hx + 1.2, hy)


def t_flag(L, W, e):
    hx, hy = L / 2, W / 2
    sp = e.get('sigurnosni_pojas_m') or {}
    ez = float(sp.get('uzduzno_ukupno') or 0) / 2
    return [('p', _prav(-hx - ez, -hy, hx + ez, hy), 'trava'), ('l', _prav(-hx - ez, -hy, hx + ez, hy), 'rub'),
            ('l', [(0, -hy), (0, hy)], 'n'), ('l', [(-hx, -hy), (-hx, hy)], 'n'), ('l', [(hx, -hy), (hx, hy)], 'n')]


def t_opce(L, W, e):
    hx, hy = L / 2, W / 2
    isp = 'trava' if e.get('otvoreno') else 'parket'
    return [('p', _prav(-hx, -hy, hx, hy), isp), ('l', _prav(-hx, -hy, hx, hy), 'rub'),
            ('l', [(0, -hy), (0, hy)], 't')]


CRTACI = {
    'rukomet': t_rukomet, 'futsal': t_futsal, 'kosarka': t_kosarka, 'kosarka_3x3': t_kosarka_3x3,
    'odbojka': t_odbojka, 'odbojka_na_pijesku': t_odbojka, 'badminton': t_badminton, 'tenis': t_tenis,
    'stolni_tenis': t_stolni_tenis, 'squash': t_squash, 'judo': t_strunjaca, 'taekwondo': t_strunjaca,
    'borilacki_sportovi': t_strunjaca, 'dizanje_utega': t_strunjaca, 'gimnastika_sportska': t_strunjaca,
    'gimnastika_ritmicka': t_strunjaca, 'trampolin': t_strunjaca, 'hrvanje': t_hrvanje, 'boks': t_boks,
    'macevanje': t_macevanje, 'streljastvo_10m': t_staza_gadanja, 'strelicarstvo_18m': t_staza_gadanja,
    'kuglanje': t_staza_gadanja, 'bowling': t_staza_gadanja, 'bocanje': t_staza_gadanja,
    'atletika': t_atletika, 'nogomet': t_nogomet, 'ragbi_7': t_ragbi, 'hokej_na_travi': t_hokej,
    'flag_football': t_flag,
}
# Najveći broj nacrtanih borilišta jednog sporta u jednom prostoru (PRETPOSTAVKA crtača; shema, ne kapacitet)
NAJVISE = {'kuglanje': 8, 'bowling': 8, 'bocanje': 6, 'macevanje': 8, 'streljastvo_10m': 20,
           'strelicarstvo_18m': 12, 'judo': 4, 'taekwondo': 4, 'hrvanje': 4, 'boks': 2, 'dizanje_utega': 4,
           'borilacki_sportovi': 4, 'gimnastika_sportska': 1, 'gimnastika_ritmicka': 1, 'trampolin': 2,
           'squash': 8, 'nogomet': 1, 'atletika': 1, 'ragbi_7': 1, 'hokej_na_travi': 1, 'flag_football': 1,
           'lacrosse': 1}
RAZMAK_BOCNI = {'macevanje': 1.5}   # razmak između susjednih borilišta (PRETPOSTAVKA crtača)


class Sportovi:
    """Dimenzije iz sportovi_dimenzije.json (PA.Sportovi) uz sportove koje crtač dodatno zna."""

    def __init__(self, put=SPORTOVI_PUT):
        self.sp = PA.Sportovi(put)
        self.meta = {}
        try:
            self.meta = PA.ucitaj_json(put).get('meta') or {}
        except Exception:  # noqa: BLE001
            pass

    def nadji(self, naziv):
        e = self.sp.nadji(naziv)
        if e is None:
            e = SPORT_DODATNI.get(norm(naziv))
        return e

    @staticmethod
    def igraca(e):
        ip = e.get('igraca_povrsina_m')
        return (float(ip[0]), float(ip[1])) if ip else None

    @staticmethod
    def potrebno(e):
        """(duljina, širina) igraće površine s pojasevima, u smjeru igraće površine (ne sortirano)."""
        ip = e.get('igraca_povrsina_m')
        if not ip:
            return None
        sp = e.get('sigurnosni_pojas_m') or {}
        return (float(ip[0]) + float(sp.get('uzduzno_ukupno') or 0), float(ip[1]) + float(sp.get('poprecno_ukupno') or 0))


def razmjesti_sportove(s, sportovi: Sportovi):
    """Rasporedi borilišta u prostor. Vrati (popis smještaja, popis opisa po sportu).
    Smještaj: {'e', 'cx', 'cy', 'kut', 'L', 'W', 'glavni', 'prilagodeno'}; opis: {'naziv', 'e', 'broj', 'stane',
    'L', 'W', 'napomena'}."""
    opisi, smjestaji = [], []
    unosi = []
    nazivi = list(s['sportovi'])
    if s['kat'] == 'igraliste' and not any(sportovi.nadji(n) and sportovi.nadji(n)['id'] == 'nogomet' for n in nazivi):
        nazivi.append('nogomet')
    for n in nazivi:
        e = sportovi.nadji(n)
        if e is None:
            opisi.append({'naziv': n, 'e': None, 'broj': 0, 'stane': None, 'L': None, 'W': None,
                          'napomena': 'sport nije u sportovi_dimenzije.json'})
            continue
        if any(e is u for u in unosi):
            continue
        unosi.append(e)
    crtljivi = [e for e in unosi if Sportovi.igraca(e)]
    for e in unosi:
        if not Sportovi.igraca(e):
            opisi.append({'naziv': e['naziv'], 'e': e, 'broj': 0, 'stane': None, 'L': None, 'W': None,
                          'napomena': 'bez propisane igraće površine; ne crta se borilište'})
    if not crtljivi:
        return smjestaji, opisi
    up = upisani_pravokutnik(s['geom'])
    if up is None:
        for e in crtljivi:
            opisi.append({'naziv': e['naziv'], 'e': e, 'broj': 0, 'stane': False, 'L': None, 'W': None,
                          'napomena': 'prostor nema upisani pravokutnik'})
        return smjestaji, opisi
    cx, cy, kut, A, B = up
    vrsta_kap = norm((s['kap'] or {}).get('vrsta', ''))
    ima_gledaliste = bool(s['kap']) and ('sjed' in vrsta_kap or 'gleda' in vrsta_kap or 'stajac' in vrsta_kap)
    ca, sa = math.cos(math.radians(kut)), math.sin(math.radians(kut))
    TOL = 0.1 + 0.003 * max(A, B)   # program je crtan u ENU-N; dopušteno odstupanje prijenosa u ENU-M

    def dodaj(e, u, v, zakrenut, L, W, glavni, prilagodeno=False):
        smjestaji.append({'e': e, 'cx': cx + u * ca - v * sa, 'cy': cy + u * sa + v * ca,
                          'kut': kut + (90.0 if zakrenut else 0.0), 'L': L, 'W': W, 'glavni': glavni,
                          'prilagodeno': prilagodeno})

    def potrebno(e):
        l, w = Sportovi.potrebno(e)
        return l, w + RAZMAK_BOCNI.get(e['id'], 0.0)

    def vitko(e):
        il, iw = Sportovi.igraca(e)
        return max(il, iw) / max(min(il, iw), 0.1) >= 5

    def popuni(e, u0, v0, a, b, najvise, glavni=True):
        """Složi borilišta sporta e u pravokutnik a x b sa središtem (u0, v0); vrati broj."""
        l, w = potrebno(e)
        il, iw = Sportovi.igraca(e)
        kand = []
        for zak, (dl, dw) in ((False, (l, w)), (True, (w, l))):
            nx, ny = int((a + TOL) // dl), int((b + TOL) // dw)
            if vitko(e):      # staze: jedan red, jedna do druge
                if zak:
                    ny = min(ny, 1)
                else:
                    nx = min(nx, 1)
            kand.append((min(nx * ny, najvise), 0 if not zak else -1, zak, nx, ny, dl, dw))
        kand.sort(reverse=True)
        n, _, zak, nx, ny, dl, dw = kand[0]
        if n == 0:
            return 0
        while nx * ny > najvise and (nx > 1 or ny > 1):
            if nx >= ny and nx > 1:
                nx -= 1
            else:
                ny -= 1
        zbijeno = vitko(e)
        for i in range(nx):
            for j in range(ny):
                if zbijeno:
                    u = u0 + (i - (nx - 1) / 2) * dl
                    v = v0 + (j - (ny - 1) / 2) * dw
                else:
                    u = u0 - a / 2 + (i + 0.5) * a / nx
                    v = v0 - b / 2 + (j + 0.5) * b / ny
                dodaj(e, u, v, zak, il, iw, glavni)
        return nx * ny

    def povrsina(e):
        l, w = Sportovi.potrebno(e)
        return l * w

    najveci = max(crtljivi, key=povrsina)
    preklop = len(crtljivi) > 1 and (ima_gledaliste or povrsina(najveci) >= 0.3 * A * B)
    if len(crtljivi) == 1 or preklop:
        red = sorted(crtljivi, key=lambda e: -povrsina(e)) if preklop else crtljivi
        for k, e in enumerate(red):
            l, w = Sportovi.potrebno(e)
            il, iw = Sportovi.igraca(e)
            najvise = 1 if (ima_gledaliste or preklop) else NAJVISE.get(e['id'], 12)
            n = popuni(e, 0.0, 0.0, A, B, najvise, glavni=(k == 0))
            nap, pril = '', False
            if n == 0:
                # ne stane u najveći upisani pravokutnik: traži bilo gdje u prostoru (raster, više smjerova)
                q = smjesti_pravokutnik(s['geom'], l, w, TOL, blizu=(cx, cy))
                if q is not None:
                    smjestaji.append({'e': e, 'cx': q[0], 'cy': q[1], 'kut': q[2], 'L': il, 'W': iw,
                                      'glavni': k == 0, 'prilagodeno': False})
                    n = 1
            if n == 0 and e['id'] == 'nogomet' and A - 4 >= 90 and B - 4 >= 45:
                # Pravila nogometne igre dopuštaju 90-120 x 45-90 m; standard 105 x 68 ovdje ne stane
                il2, iw2 = min(il, math.floor(A - 4)), min(iw, math.floor(B - 4))
                dodaj(e, 0.0, 0.0, False, il2, iw2, k == 0, True)
                nap = (f'prilagođeno prostoru: {br(il2, 0)} × {br(iw2, 0)} m (standard {br(il, 0)} × {br(iw, 0)} m '
                       'ne stane)')
                n, il, iw, pril = 1, il2, iw2, True
            elif n == 0:
                nap = (f'potrebno {br(l, 2)} × {br(w, 2)} m s pojasevima; ne stane nigdje u prostoru (najveći '
                       f'upisani pravokutnik {br(A, 1)} × {br(B, 1)} m): borilište nije nacrtano')
            opisi.append({'naziv': e['naziv'], 'e': e, 'broj': n, 'stane': n > 0 and not pril, 'L': il, 'W': iw,
                          'napomena': nap})
        return smjestaji, opisi
    # više sportova jedan uz drugi: polja uzduž duže stranice, razmjerno potrebnoj širini polja
    polja = None
    for redova in (1, 2):
        skupine = [crtljivi] if redova == 1 else [crtljivi[:(len(crtljivi) + 1) // 2],
                                                   crtljivi[(len(crtljivi) + 1) // 2:]]
        kand, ok = [], True
        for ri, sk in enumerate(skupine):
            if not sk:
                continue
            bb = B / len([x for x in skupine if x])
            v0 = -B / 2 + (ri + 0.5) * bb
            tez = [min(potrebno(e)) if max(potrebno(e)) <= bb + TOL else max(potrebno(e)) for e in sk]
            u = -A / 2
            for e, t in zip(sk, tez):
                d = A * t / sum(tez)
                l, w = potrebno(e)
                if not ((l <= d + TOL and w <= bb + TOL) or (w <= d + TOL and l <= bb + TOL)):
                    ok = False
                kand.append((e, u + d / 2, v0, d, bb))
                u += d
        if ok or polja is None:
            polja = kand
        if ok:
            break
    for e, u, v, d, bb in polja:
        il, iw = Sportovi.igraca(e)
        n = popuni(e, u, v, d, bb, min(NAJVISE.get(e['id'], 4), 20 if vitko(e) else 4))
        l, w = Sportovi.potrebno(e)
        opisi.append({'naziv': e['naziv'], 'e': e, 'broj': n, 'stane': n > 0, 'L': il, 'W': iw,
                      'napomena': '' if n else f'potrebno {br(l, 2)} × {br(w, 2)} m s pojasevima, polje u prostoru '
                                               f'{br(d, 1)} × {br(bb, 1)} m: borilište nije nacrtano'})
    return smjestaji, opisi


def borilista_prostora(s, sportovi, predmemorija={}):  # noqa: B006
    k = id(s)
    if k not in predmemorija:
        predmemorija[k] = razmjesti_sportove(s, sportovi)
    return predmemorija[k]


def crtaj_boriliste(svg: Svg, pg: Pogled, sm, boja, sitno=False, natpis=True, sudari=None, odgodi=None):
    """Nacrtaj jedno borilište (smještaj sm) u pogledu pg."""
    e = sm['e']
    f = CRTACI.get(e['id'], t_opce)
    el = f(sm['L'], sm['W'], e)
    ca, sa = math.cos(math.radians(sm['kut'])), math.sin(math.radians(sm['kut']))

    def lst(t):
        return [pg.t(sm['cx'] + x * ca - y * sa, sm['cy'] + x * sa + y * ca) for x, y in t]
    deb = 0.16 if not sitno else 0.1
    svg.otvori(data_sport=e['id'])
    for v, t, st in el:
        if v == 'x':           # sitni natpis discipline, vodoravno na listu
            if not sitno and pg.k >= 1.0:
                X, Y = lst(t)[0]
                if odgodi is not None:      # crta se nakon natpisa prostora, samo na slobodno mjesto
                    odgodi.append((X, Y + 0.5, st, boja))
                else:
                    svg.tekst(X, Y + 0.5, st, F_PODATAK, boja, sidro='middle')
            continue
        if v == 'p':
            if sm['glavni']:
                svg.put(d_tocke(lst(t), True), ispuna=ISPUNE_BORILISTA.get(st, '#fbf4e4'), neprozirnost=0.9)
        elif st == 'rub':
            svg.put(d_tocke(lst(t)), rub=boja, deb=deb * 1.6, extra=' data-el="rub"')
        elif st == 'c':
            if not sitno:
                svg.put(d_tocke(lst(t)), rub=boja, deb=deb * 0.8, crt='0.8 0.5')
        elif st == 't':
            if not sitno:
                svg.put(d_tocke(lst(t)), rub=boja, deb=deb * 0.7)
        else:
            svg.put(d_tocke(lst(t)), rub=boja, deb=deb)
    svg.zatvori()
    if natpis:
        natpis_borilista(svg, pg, sm, boja)


def _mjera(v):
    """Mjera u metrima bez suvišnih nula: 40, 13,4, 9,75."""
    t = br(v, 2)
    return t.rstrip('0').rstrip(',') if ',' in t else t


def natpis_borilista(svg: Svg, pg: Pogled, sm, boja, red=None, glavni=None, sudari=None):
    """Naziv sporta i mjere igraće površine uz donji rub borilišta, u smjeru njegove duže stranice.
    red/glavni: kod više preklopljenih borilišta natpisi se slažu ispod glavnog (najvećeg), redak po sportu."""
    e = sm['e']
    ref = glavni or sm
    lp, wp = ref['L'] * pg.k, ref['W'] * pg.k
    tekst = f'{e["naziv"]} {_mjera(sm["L"])} × {_mjera(sm["W"])} m'
    kut = ref['kut'] % 180.0
    kut = kut - 180.0 if kut > 90.0 else kut
    c2, s2 = math.cos(math.radians(kut)), math.sin(math.radians(kut))
    mjere = f'{_mjera(sm["L"])} × {_mjera(sm["W"])} m'
    for vel, tx in ((1.9, tekst), (F_PODATAK, tekst), (1.9, e['naziv']), (F_PODATAK, e['naziv'])):
        if True:
            if sirina(tx, vel) + 1.0 > max(lp, 0.0):
                continue
            if red is None:
                if vel * 3.2 > wp:
                    continue
                od = ref['W'] / 2 - (vel * 0.75 + 0.5) / pg.k        # unutar igraće površine, uz rub
            else:
                od = ref['W'] / 2 + ((red + 0.9) * vel * 1.3 + 0.4) / pg.k   # ispod glavnog borilišta
            kandidati = []
            for sg in (-1, 1):       # od dva duža ruba prvo onaj koji je na listu niže, pa drugi
                wx, wy = ref['cx'] - sg * od * (-s2), ref['cy'] - sg * od * c2
                kandidati.append((wy, wx))
            w_ = sirina(tx, vel)
            hw = w_ / 2 * abs(c2) + vel * 0.6 * abs(s2) + 0.4
            hh = w_ / 2 * abs(s2) + vel * 0.6 * abs(c2) + 0.4
            for wy, wx in sorted(kandidati):
                X, Y = pg.t(wx, wy)
                r = (X - hw, Y - hh, X + hw, Y + hh)
                if sudari is not None and not sudari.slobodno(r):
                    continue
                if not pg.pravokutnik.contains(box(*r)):
                    continue        # natpis bi rub karte odrezao
                svg.tekst(X, Y + vel * 0.35, tx, vel, boja, sidro='middle', kut=-kut)
                if tx != tekst and red is None and sirina(mjere, vel) + 1.0 <= lp and vel * 5.0 <= wp:
                    # naziv bez mjera: mjere u drugom retku, prema sredini borilišta
                    f_ = (vel * 1.3 / pg.k) / max(od, 1e-6)        # pomak prema sredini borilišta
                    wx2, wy2 = wx + (ref['cx'] - wx) * f_, wy + (ref['cy'] - wy) * f_
                    X2, Y2 = pg.t(wx2, wy2)
                    w2 = sirina(mjere, vel)
                    hw2 = w2 / 2 * abs(c2) + vel * 0.6 * abs(s2) + 0.4
                    hh2 = w2 / 2 * abs(s2) + vel * 0.6 * abs(c2) + 0.4
                    r2 = (X2 - hw2, Y2 - hh2, X2 + hw2, Y2 + hh2)
                    if (sudari is None or sudari.slobodno(r2)) and pg.pravokutnik.contains(box(*r2)):
                        svg.tekst(X2, Y2 + vel * 0.35, mjere, vel, boja, sidro='middle', kut=-kut)
                        r = (min(r[0], r2[0]), min(r[1], r2[1]), max(r[2], r2[2]), max(r[3], r2[3]))
                return r
    return None


# --------------------------------------------------------------------------------------------- garaže, tribine
MJESTO_S, MJESTO_D, PROLAZ = 2.5, 5.0, 6.0     # PRETPOSTAVKA: okomito parkiranje 2,5 x 5,0 m, prolaz 6,0 m


def raster_garaze(g, zabrane, predmemorija={}):  # noqa: B006
    """Raster parkirnih mjesta u poligonu garaže. Vrati (popis pravokutnika mjesta u ENU-M, osi prolaza)."""
    k = (g.wkb, zabrane.wkb if zabrane is not None else b'')
    if k in predmemorija:
        return predmemorija[k]
    kut, _, _ = glavna_os(g)
    c0 = g.centroid
    gr = affinity.rotate(g, -kut, origin=c0).buffer(-0.5)
    zr = affinity.rotate(zabrane, -kut, origin=c0) if zabrane is not None and not zabrane.is_empty else None
    mjesta, prolazi = [], []
    if not gr.is_empty:
        pr = prep(gr)
        pz = prep(zr) if zr is not None else None
        x0, y0, x1, y1 = gr.bounds
        modul = 2 * MJESTO_D + PROLAZ
        H = y1 - y0
        n = int(H // modul)
        ostatak = H - n * modul
        trake = []   # (y početka trake mjesta, y osi prolaza)
        y = y0 + (ostatak - (MJESTO_D + PROLAZ if ostatak >= MJESTO_D + PROLAZ else 0)) / 2 if n else y0
        if n == 0 and H >= MJESTO_D + PROLAZ:
            trake.append((y0 + (H - MJESTO_D - PROLAZ) / 2, y0 + (H - MJESTO_D - PROLAZ) / 2 + MJESTO_D + PROLAZ / 2))
        for i in range(n):
            trake.append((y, y + MJESTO_D + PROLAZ / 2))
            trake.append((y + MJESTO_D + PROLAZ, y + MJESTO_D + PROLAZ / 2))
            y += modul
        if n and ostatak >= MJESTO_D + PROLAZ:
            trake.append((y + PROLAZ, y + PROLAZ / 2))
        xa, xb = x0 + PROLAZ, x1 - PROLAZ
        nx = int((xb - xa) // MJESTO_S)
        xa += ((xb - xa) - nx * MJESTO_S) / 2
        vidjeni = set()
        for ty, py in trake:
            for i in range(nx):
                r = box(xa + i * MJESTO_S, ty, xa + (i + 1) * MJESTO_S, ty + MJESTO_D)
                if pr.contains(r) and not (pz is not None and pz.intersects(r)):
                    mjesta.append(r)
            if round(py, 2) not in vidjeni:
                vidjeni.add(round(py, 2))
                l = LineString([(x0, py), (x1, py)]).intersection(gr)
                prolazi += dijelovi(l, 'LineString')
        mjesta = [affinity.rotate(r, kut, origin=c0) for r in mjesta]
        prolazi = [affinity.rotate(l, kut, origin=c0) for l in prolazi]
    predmemorija[k] = (mjesta, prolazi)
    return predmemorija[k]


def redovi_tribine(g, korak):
    """Linije redova tribine: usporednice unutarnjem rubu (prsten) ili dužoj stranici (puni poligon)."""
    out = []
    if g.interiors:
        unutra = Polygon(max(g.interiors, key=lambda r: Polygon(r).area))
        d = korak
        while d < 400:
            l = unutra.buffer(d, join_style=1).exterior.intersection(g)
            if l.is_empty:
                break
            out += dijelovi(l, 'LineString')
            d += korak
    else:
        kut, a, b = glavna_os(g)
        c0 = g.centroid
        gr = affinity.rotate(g, -kut, origin=c0)
        x0, y0, x1, y1 = gr.bounds
        y = y0 + korak
        while y < y1:
            l = LineString([(x0 - 1, y), (x1 + 1, y)]).intersection(gr)
            out += [affinity.rotate(x, kut, origin=c0) for x in dijelovi(l, 'LineString')]
            y += korak
    return out


def redovi_gledalista(g, jezgra, mjesta, korak=0.85):
    """Shematski redovi gledališta dvorane oko igrališta: prstenovi oko pravokutnika jezgre do kapaciteta."""
    out, zbroj = [], 0.0
    unutra = g.buffer(-1.5)
    d = 2.0
    while zbroj < mjesta and d < 60:
        l = jezgra.buffer(d, join_style=2).exterior.intersection(unutra)
        dj = dijelovi(l, 'LineString')
        if not dj:
            break
        out += dj
        zbroj += sum(x.length for x in dj) / 0.5
        d += korak
    return out, zbroj


def os_trake(g):
    """Os izduženog poligona (trake): spoji polovišta nasuprotnih točaka. Vrati LineString ili None."""
    c = list(g.exterior.coords)[:-1]
    n = len(c)
    if n < 4 or n % 2 or g.interiors:
        return None
    najbolje = None
    for pomak in range(n // 2):
        d = c[pomak:] + c[:pomak]
        parovi = [(d[i], d[n - 1 - i]) for i in range(n // 2)]
        sir = [math.dist(a, b) for a, b in parovi]
        sr = sum(sir) / len(sir)
        if sr <= 0 or (max(sir) - min(sir)) / sr > 0.6:
            continue
        os_ = LineString([((a[0] + b[0]) / 2, (a[1] + b[1]) / 2) for a, b in parovi])
        if os_.length < 3 * sr:
            continue
        if najbolje is None or sr < najbolje[0]:
            najbolje = (sr, os_)
    if najbolje is None:
        return None
    os_ = najbolje[1]
    return os_ if os_.is_simple and g.buffer(0.5).contains(os_) else None


# ------------------------------------------------------------------------------------------- simboli veza
def strelica(svg: Svg, x1, y1, x2, y2, boja, deb=0.25, vrh=1.1):
    svg.linija(x1, y1, x2, y2, boja, deb, kraj='round')
    a = math.atan2(y2 - y1, x2 - x1)
    p = [(x2, y2), (x2 - vrh * math.cos(a - 0.42), y2 - vrh * math.sin(a - 0.42)),
         (x2 - vrh * math.cos(a + 0.42), y2 - vrh * math.sin(a + 0.42))]
    svg.put(d_tocke(p, True), ispuna=boja)


def simbol_veze(svg: Svg, tip, x, y, a):
    """Točkasti simbol veze, veličine a (mm), sa središtem (x, y)."""
    b = VEZE[tip][0]
    h = a / 2
    if tip == 'dizalo':
        svg.pravokutnik(x - h, y - h, a, a, ispuna='#ffffff', rub=b, deb=0.22)
        svg.put(f'M{f2(x - h)},{f2(y - h)}L{f2(x + h)},{f2(y + h)}M{f2(x - h)},{f2(y + h)}L{f2(x + h)},{f2(y - h)}',
                rub=b, deb=0.16)
    elif tip in ('stubiste', 'pokretne_stube'):
        w = a * 1.5
        svg.pravokutnik(x - w / 2, y - h, w, a, ispuna='#ffffff', rub=b, deb=0.2)
        n = 5 if tip == 'stubiste' else 9
        d = ''.join(f'M{f2(x - w / 2 + w * i / n)},{f2(y - h)}v{f2(a)}' for i in range(1, n))
        svg.put(d, rub=b, deb=0.1)
        if tip == 'pokretne_stube':
            svg.put(f'M{f2(x - w * 0.2)},{f2(y - h * 0.55)}L{f2(x + w * 0.05)},{f2(y)}L{f2(x - w * 0.2)},'
                    f'{f2(y + h * 0.55)}M{f2(x + w * 0.05)},{f2(y - h * 0.55)}L{f2(x + w * 0.3)},{f2(y)}'
                    f'L{f2(x + w * 0.05)},{f2(y + h * 0.55)}', rub=b, deb=0.24)
        else:
            strelica(svg, x - w * 0.36, y, x + w * 0.38, y, b, 0.2, a * 0.36)
    elif tip == 'ulaz':
        svg.put(d_tocke([(x, y - h * 1.05), (x + h, y + h * 0.8), (x - h, y + h * 0.8)], True), ispuna=b,
                rub='#ffffff', deb=0.12)
    elif tip == 'kolni_ulaz':
        svg.put(d_tocke([(x, y - h * 1.2), (x + h * 1.25, y + h * 0.9), (x - h * 1.25, y + h * 0.9)], True),
                ispuna='#ffffff', rub=b, deb=0.3)
        svg.put(d_tocke([(x, y - h * 0.45), (x + h * 0.55, y + h * 0.55), (x - h * 0.55, y + h * 0.55)], True),
                ispuna=b)
    elif tip == 'evakuacija':
        svg.pravokutnik(x - h, y - h, a, a, rx=a * 0.15, ispuna=b, rub='#ffffff', deb=0.1)
        svg.put(f'M{f2(x - h * 0.6)},{f2(y)}L{f2(x + h * 0.5)},{f2(y)}M{f2(x + h * 0.05)},{f2(y - h * 0.5)}'
                f'L{f2(x + h * 0.6)},{f2(y)}L{f2(x + h * 0.05)},{f2(y + h * 0.5)}', rub='#ffffff', deb=a * 0.11,
                kraj='round')
    elif tip == 'svjetlarnik':
        svg.put(d_tocke([(x, y - h), (x + h, y), (x, y + h), (x - h, y)], True), ispuna='#eaf8fc', rub=b, deb=0.2)
        svg.put(f'M{f2(x - h * 0.5)},{f2(y)}h{f2(a * 0.5)}M{f2(x)},{f2(y - h * 0.5)}v{f2(a * 0.5)}', rub=b, deb=0.1)
    else:  # topli_put kao točka
        svg.krug(x, y, h, ispuna=b, rub='#ffffff', deb=0.15)


def traka_veze(g, sirina, zadano=3.0):
    """Poligon trake uzduž linije veze (ravni krajevi)."""
    return g.buffer(max((sirina or zadano) / 2.0, 0.3), cap_style=2, join_style=2)


def crtaj_linijsku_vezu(svg: Svg, pg: Pogled, v, sitno, uspon=None):
    tip, g = v['tip'], v['geom']
    b = VEZE[tip][0]
    lp = pg.gk(g)
    if lp is None:
        return
    if tip == 'topli_put':
        svg.put(d_linija(lp), rub='#ffffff', deb=1.5 if not sitno else 1.0, kraj='round', neprozirnost=0.85)
        svg.put(d_linija(lp), rub=b, deb=0.9 if not sitno else 0.55, kraj='round')
        return
    if tip in ('rampa', 'stubiste', 'pokretne_stube'):
        tr = pg.gk(traka_veze(g, v['sirina']))
        if tr is not None:
            svg.put(d_poligon(tr), ispuna='#ffffff', rub=b, deb=0.22, neprozirnost=0.92)
            if tip != 'rampa' and not sitno:
                # gazišta okomito na os
                korak = max(0.6, 0.55 / pg.k) if tip == 'stubiste' else max(0.4, 0.4 / pg.k)
                hw = (v['sirina'] or 3.0) / 2
                d = []
                L = g.length
                s = korak
                while s < L:
                    p = g.interpolate(s)
                    q = g.interpolate(min(s + 0.05, L))
                    a = math.atan2(q.y - p.y, q.x - p.x) + math.pi / 2
                    x1, y1 = pg.t(p.x + hw * math.cos(a), p.y + hw * math.sin(a))
                    x2, y2 = pg.t(p.x - hw * math.cos(a), p.y - hw * math.sin(a))
                    d.append(f'M{f2(x1)},{f2(y1)}L{f2(x2)},{f2(y2)}')
                    s += korak
                svg.put(''.join(d), rub=b, deb=0.09)
        # strelica u smjeru uspona (ili zapisa linije)
        c = list(g.coords)
        if uspon is False:
            c = c[::-1]
        ls = LineString(c)
        for l in dijelovi(ls.intersection(pg.svijet), 'LineString'):
            cc = [pg.t(x, y) for x, y in l.coords]
            if LineString(cc).length < 2.5:
                continue
            svg.put(d_tocke(cc[:-1] + [cc[-1]]), rub=b, deb=0.25)
            (xa, ya), (xb, yb) = cc[-2], cc[-1]
            strelica(svg, xa, ya, xb, yb, b, 0.25, 1.3 if not sitno else 0.9)
        return
    if tip == 'kolni_ulaz':
        svg.put(d_linija(lp), rub='#ffffff', deb=1.3, kraj='butt')
        svg.put(d_linija(lp), rub=b, deb=0.8, kraj='butt', crt='1.6 0.5')
        return
    if tip == 'ulaz':
        cc = [pg.t(x, y) for x, y in g.coords]
        svg.put(d_linija(lp), rub=b, deb=0.45)
        if pg.pravokutnik.contains(Point(cc[-1])):
            strelica(svg, cc[-2][0], cc[-2][1], cc[-1][0], cc[-1][1], b, 0.45, 1.5 if not sitno else 1.0)
        return
    if tip == 'evakuacija':
        cc = [pg.t(x, y) for x, y in g.coords]
        svg.put(d_linija(lp), rub=b, deb=0.35, crt='1.2 0.6')
        if pg.pravokutnik.contains(Point(cc[-1])):
            strelica(svg, cc[-2][0], cc[-2][1], cc[-1][0], cc[-1][1], b, 0.3, 1.2)
        return
    svg.put(d_linija(lp), rub=b, deb=0.3, crt='1 0.6')


def kota_ispod(P: Podaci, v, x, y):
    """Kota poda prostora (na razinama veze) u točki, ili None."""
    pt = Point(x, y)
    naj = None
    for s in P.prostori:
        if s['razina'] in v['razine'] and s['pod'] is not None and s['geom'].distance(pt) < 1.5:
            if naj is None or s['a'] < naj[0]:
                naj = (s['a'], s['pod'], s['razina'])
    return naj


def smjer_uspona(P: Podaci, v):
    """True ako linija raste od prve prema zadnjoj točki, False ako pada, None ako se ne može odrediti."""
    c = list(v['geom'].coords)
    a, b = kota_ispod(P, v, *c[0][:2]), kota_ispod(P, v, *c[-1][:2])
    if a and b and abs(a[1] - b[1]) > 0.2:
        return b[1] > a[1]
    return None


# ------------------------------------------------------------------------------------------------ tlocrt
KARTA_X, KARTA_Y = RUB + 7.5, RUB + 5.5
KARTA_H = LIST_H - 2 * RUB - 5.5 - 6.5
PANEL_DETALJ = 104.0


def karta_okvir(panel_w):
    panel_x = LIST_W - RUB - panel_w
    return (KARTA_X, KARTA_Y, panel_x - 6.5 - KARTA_X, KARTA_H), panel_x


class Kontekst:
    """Sve što crtanje listova dijeli: podaci, podloga, sportovi, kote, datum."""

    def __init__(self, P: Podaci, podloga: Podloga, sportovi: Sportovi, kote, datum):
        self.P, self.podloga, self.sportovi, self.kote, self.datum = P, podloga, sportovi, kote, datum
        self._vid = {}
        self._zabrane = {}
        self._obris = {}
        najniza = min((r['kota'] for r in P.razine if r['kota'] is not None), default=0.0)
        self.razine_tla = {r['id'] for r in P.razine if r['kota'] is not None and r['kota'] <= najniza + 3.0}
        g = [x for x in P.unija_razine.values() if x is not None]
        self.sve = unary_union(g).buffer(0) if g else None
        self.raster_broj = {}

    def vidljivo(self, s):
        """Dio prostora koji ne prekrivaju manji prostori iste razine (za smještaj natpisa)."""
        k = id(s)
        if k not in self._vid:
            manji = [o['geom'] for o in self.P.po_razini[s['razina']]
                     if o is not s and o['a'] < s['a'] and o['geom'].intersects(s['geom'])]
            g = s['geom']
            if manji:
                d = g.difference(unary_union(manji))
                if not d.is_empty and d.area > 0.05 * g.area:
                    g = d
            self._vid[k] = g
        return self._vid[k]

    def obris_razine(self, raz):
        """Obris prostora razine sa zatvorenim uskim procjepima (do 3 m), za prikaz na susjednim razinama."""
        k = raz['id']
        if k not in self._obris:
            u = self.P.unija_razine[k]
            self._obris[k] = u.buffer(1.6, join_style=2).buffer(-1.6, join_style=2) if u is not None else raz['geom']
        return self._obris[k]

    def zabrane_garaze(self, s):
        k = id(s)
        if k not in self._zabrane:
            z = []
            for v in self.P.veze:
                if s['razina'] not in v['razine'] or not v['geom'].intersects(s['geom']):
                    continue
                if v['geom'].geom_type == 'Point':
                    if v['tip'] in ('dizalo', 'stubiste', 'pokretne_stube'):
                        z.append(v['geom'].buffer(3.5, cap_style=3))
                elif v['tip'] in ('rampa', 'stubiste', 'pokretne_stube'):
                    z.append(traka_veze(v['geom'], v['sirina']).buffer(1.0, join_style=2))
                elif v['tip'] in ('ulaz', 'topli_put'):
                    z.append(v['geom'].buffer(1.5, cap_style=2))
            self._zabrane[k] = unary_union(z) if z else None
        return self._zabrane[k]

    def raster(self, s):
        mjesta, prolazi = raster_garaze(s['geom'], self.zabrane_garaze(s))
        self.raster_broj[s['id']] = len(mjesta)
        return mjesta, prolazi


def tekst_kapaciteta(s):
    kap = s['kap']
    if not kap or not PA.je_broj(kap.get('broj')):
        return None
    return f'{kap.get("vrsta", "kapacitet")}: {br(kap["broj"], 0)}'


def tekst_sportova(s, sportovi: Sportovi):
    if not s['sportovi']:
        return None
    naz = []
    for n in s['sportovi']:
        e = sportovi.nadji(n)
        naz.append(e['naziv'] if e else n)
    t = ', '.join(dict.fromkeys(naz))
    if s['razred']:
        t += f' · razred\u00a0{s["razred"]}'
    return t


def tekst_ne_stane(s, sportovi: Sportovi):
    """Sportovi čije borilište u prostor ne stane ili je prilagođeno: tekst za natpis i tablicu lista."""
    if not s['sportovi']:
        return None
    _, opisi = borilista_prostora(s, sportovi)
    ne = [o['naziv'] for o in opisi if o['e'] is not None and o['stane'] is False and not o['broj']]
    pril = [f'{o["naziv"]} {_mjera(o["L"])} × {_mjera(o["W"])} m' for o in opisi
            if o['e'] is not None and o['broj'] and o['stane'] is False]
    d = []
    if ne:
        d.append('ne stane: ' + ', '.join(dict.fromkeys(ne)))
    if pril:
        d.append('prilagođeno: ' + ', '.join(dict.fromkeys(pril)))
    return ' · '.join(d) + ' (vidi iskaz)' if d else None


def redak_tablice(K_: Kontekst, s, dodatak=None):
    """Redak tablice uz rub lista: (naziv, bitni podaci, ostali podaci). Kad redak ne stane, krati se naziv i
    ostali podaci; površina, razred, „ne stane” i dodatak ostaju (Panel.tablica)."""
    P = K_.P
    bitno = [f'{bm2(s["a"])} m²']
    if s['razred']:
        bitno.append(f'razred\u00a0{s["razred"]}')
    ns = tekst_ne_stane(s, K_.sportovi)
    if ns:
        bitno.append(ns)
    if dodatak:
        bitno.append(dodatak)
    ostalo = []
    if s['visina']:
        ostalo.append(f'h {br(s["visina"], 1)} m')
    raz = P.razina[s['razina']]
    if s['pod'] is not None and raz['kota'] is not None and abs(s['pod'] - raz['kota']) > 0.05:
        ostalo.append(f'pod {br(s["pod"], 1)}')
    k = tekst_kapaciteta(s)
    if k:
        ostalo.append(k)
    sp = tekst_sportova(s, K_.sportovi)
    if sp:
        ostalo.append(sp.split(' · razred\u00a0')[0])
    return (s['naziv'], tuple(bitno), tuple(ostalo))


def slozi_redak(r, vel, maxw, najvise):
    """Redci jednog retka tablice (najviše `najvise`). Tekstualni redak krati se na kraju; strukturirani
    (naziv, bitno, ostalo) krati prvo ostale podatke na kraju pa naziv, a bitne podatke čuva."""
    if isinstance(r, str):
        l = prelomi(r, vel, False, maxw, 200) or [skrati(r, vel, False, maxw)]
        if len(l) > najvise:
            l = l[:najvise]
            l[-1] = skrati(l[-1] + ' …', vel, False, maxw)
        return l
    naziv, bitno, ostalo = r
    jezgra_ = ' · '.join(bitno)
    zadnji = None
    for nmax in (None, 40, 30, 22, 16, 11, 7):
        n = naziv if nmax is None or len(naziv) <= nmax else naziv[:nmax].rstrip(' ,(-') + '…'
        t = n + ' — ' + ' · '.join(bitno + ostalo)
        jezgra = n + ' — ' + jezgra_
        l = prelomi(t, vel, False, maxw, 200) or [skrati(t, vel, False, maxw)]
        if len(l) <= najvise:
            return l
        l = l[:najvise]
        l[-1] = skrati(l[-1] + ' …', vel, False, maxw)
        zadnji = l
        bez = ' '.join(l).replace('…', '').rstrip()
        if len(bez) >= len(jezgra) and t.startswith(bez[:len(jezgra)]):
            return l
    return zadnji


def blok_natpisa(K_: Kontekst, s, varijanta, vel, maxw):
    """Redci natpisa prostora: [(tekst, veličina, bold, boja)] ili None ako se ne može prelomiti."""
    P = K_.P
    naziv = s['naziv'] if varijanta == 'puni' else f'[{s["br"]}] {s["naziv"]}'
    nl = prelomi(naziv, vel, True, maxw, 3)
    if nl is None:
        return None
    out = [(l, vel, True, '#111111') for l in nl]
    v2 = max(vel * 0.84, F_PODATAK)
    t = f'{bm2(s["a"])} m²' + (f' · h {br(s["visina"], 1)} m' if s['visina'] else '')
    if sirina(t, v2) > maxw:
        return None
    if varijanta != 'puni' and s['razred'] and sirina(t + f' · razred\u00a0{s["razred"]}', v2) <= maxw:
        t += f' · razred\u00a0{s["razred"]}'
    out.append((t, v2, False, '#222222'))
    if varijanta != 'puni':
        return out
    dod = []
    raz = P.razina[s['razina']]
    if s['pod'] is not None and raz['kota'] is not None and abs(s['pod'] - raz['kota']) > 0.05:
        dod.append(f'pod {br(s["pod"], 1)} m n. v.')
    k = tekst_kapaciteta(s)
    if k:
        dod.append(k)
    if s['kat'] == 'garaza' and s['id'] in K_.raster_broj:
        dod.append(f'raster na crtežu: {br(K_.raster_broj[s["id"]], 0)} mjesta')
    sp = tekst_sportova(s, K_.sportovi)
    if sp:
        dod.append(sp)
    for t in dod:
        l = prelomi(t, v2, False, maxw, 3)
        if l is None:
            return None
        out += [(x, v2, False, '#333333') for x in l]
    ns = tekst_ne_stane(s, K_.sportovi)
    if ns:
        l = prelomi(ns, v2, True, maxw, 3)
        if l is None:
            return None
        out += [(x, v2, True, '#b71c1c') for x in l]
    return out


def blok_ima_dodatak(K_: Kontekst, s):
    """Ima li puni natpis prostora više od naziva, površine i visine (kota poda, kapacitet, sportovi)."""
    raz = K_.P.razina[s['razina']]
    return bool((s['pod'] is not None and raz['kota'] is not None and abs(s['pod'] - raz['kota']) > 0.05)
                or tekst_kapaciteta(s) or tekst_sportova(s, K_.sportovi) or tekst_ne_stane(s, K_.sportovi))


def mjere_bloka(redci):
    w = max(sirina(t, v, b) for t, v, b, _ in redci)
    h = sum(v * 1.22 for _, v, _, _ in redci)
    return w, h


def crtaj_blok(svg: Svg, cx, cy, redci, podloga_bijela=False):
    w, h = mjere_bloka(redci)
    if podloga_bijela:
        svg.pravokutnik(cx - w / 2 - 0.6, cy - h / 2 - 0.4, w + 1.2, h + 0.8, rx=0.5, ispuna='#ffffff',
                        neprozirnost=0.85)
    y = cy - h / 2
    for t, v, b, boja in redci:
        y += v * 1.22
        svg.tekst(cx, y - v * 0.3, t, v, boja, bold=b, sidro='middle')


def kandidati_tocke(gp, n=7):
    """Točke unutar poligona (koordinate lista) na kojima se pokušava smjestiti natpis."""
    out = []
    try:
        out.append(polylabel(gp, 0.3))
    except Exception:  # noqa: BLE001
        pass
    c = gp.centroid
    if gp.contains(c):
        out.append(c)
    out.append(gp.representative_point())
    x0, y0, x1, y1 = gp.bounds
    pr = prep(gp)
    mreza = []
    for i in range(1, n + 1):
        for j in range(1, n + 1):
            q = Point(x0 + (x1 - x0) * i / (n + 1), y0 + (y1 - y0) * j / (n + 1))
            if pr.contains(q):
                mreza.append(q)
    p0 = out[0]
    mreza.sort(key=lambda q: (round(q.distance(p0), 3), q.x, q.y))
    return out + mreza


def ulicni_nazivi(svg: Svg, pg: Pogled, podloga: Podloga, sudari: Sudari, vel, zauzeto_p):
    """Nazivi ulica uzduž najdužeg vidljivog dijela, sivo; preskaču se unutar zauzetog područja programa."""
    po_nazivu = {}
    for g, z in podloga.u_okviru('ceste', pg.svijet):
        naz = z.get('naziv')
        if not naz or z.get('razred') in ('service', 'construction'):
            continue
        c = g.intersection(pg.svijet)
        for l in dijelovi(c, 'LineString'):
            po_nazivu.setdefault(str(naz), []).append(l)
    for naz in sorted(po_nazivu):
        best = None
        for l in po_nazivu[naz]:
            cc = list(l.coords)
            for a, b in zip(cc[:-1], cc[1:]):
                d = math.dist(a, b)
                if best is None or d > best[0]:
                    best = (d, a, b)
        w = sirina(naz, vel)
        if best is None or best[0] * pg.k < w * 0.8:
            # pokušaj s cijelom duljinom najdužeg dijela
            l = max(po_nazivu[naz], key=lambda x: x.length)
            if l.length * pg.k < w + 3:
                continue
            a, b = l.interpolate(0.5 * l.length - w / 2 / pg.k), l.interpolate(0.5 * l.length + w / 2 / pg.k)
            best = (l.length, (a.x, a.y), (b.x, b.y))
        (x1, y1), (x2, y2) = pg.t(*best[1]), pg.t(*best[2])
        if x2 < x1:
            x1, y1, x2, y2 = x2, y2, x1, y1
        kut = math.degrees(math.atan2(y2 - y1, x2 - x1))
        mx, my = (x1 + x2) / 2, (y1 + y2) / 2
        hw = w / 2 * abs(math.cos(math.radians(kut))) + vel * abs(math.sin(math.radians(kut)))
        hh = w / 2 * abs(math.sin(math.radians(kut))) + vel * abs(math.cos(math.radians(kut)))
        r = (mx - hw, my - hh, mx + hw, my + hh)
        if not pg.pravokutnik.contains(box(*r)) or not sudari.slobodno(r, True):
            continue
        if zauzeto_p is not None and zauzeto_p.intersects(box(*r)):
            continue
        sudari.dodaj(r, meki=True)
        # pomak okomito na os da tekst ne leži na crti
        ox, oy = math.sin(math.radians(kut)) * vel * 0.38, -math.cos(math.radians(kut)) * vel * 0.38
        svg.tekst(mx - ox, my - oy, naz, vel, '#8a8a8a', sidro='middle', kut=kut, kurziv=True)


def crtaj_podlogu(svg: Svg, pg: Pogled, podloga: Podloga, sitno):
    if not podloga.ima:
        return
    okv = pg.svijet
    d = [d_poligon(pg.g(g.intersection(okv))) for g, _ in podloga.u_okviru('zelenilo', okv)]
    svg.put(''.join(d), ispuna='#f0f5ec')
    d = [d_poligon(pg.g(g.intersection(okv))) for g, _ in podloga.u_okviru('vode', okv)]
    svg.put(''.join(d), ispuna='#e3edf3', rub='#c7d6df', deb=0.1)
    sir = {'secondary': 9.0, 'secondary_link': 6.0, 'tertiary': 7.0, 'tertiary_link': 5.0, 'residential': 5.5,
           'unclassified': 5.0, 'service': 3.2, 'construction': 3.2}
    po_sir = {}
    for g, z in podloga.u_okviru('ceste', okv):
        c = g.intersection(okv)
        if not c.is_empty:
            w = max(sir.get(z.get('razred'), 4.0) * pg.k, 0.22)
            po_sir.setdefault(round(w, 2), []).append(d_linija(pg.g(c)))
    for w in sorted(po_sir):
        svg.put(''.join(po_sir[w]), rub='#e2e2e2', deb=w, kraj='round')
    if not sitno:
        d = [d_linija(pg.g(g.intersection(okv))) for g, _ in podloga.u_okviru('staze', okv)]
        svg.put(''.join(d), rub='#e4e4e4', deb=0.14)
    d = []
    for g, _ in podloga.u_okviru('zgrade', okv):
        if g.intersects(okv):
            d.append(d_poligon(pg.g(g)))
    svg.put(''.join(d), ispuna='#e9e9e9', rub='#c2c2c2', deb=0.1)
    d = [d_linija(pg.g(g.intersection(okv))) for g, _ in podloga.u_okviru('zeljeznica', okv)]
    svg.put(''.join(d), rub='#9a9a9a', deb=0.28, crt='1.6 0.8')
    d = [d_linija(pg.g(g.intersection(okv))) for g, _ in podloga.u_okviru('tram', okv)]
    svg.put(''.join(d), rub='#a4a4a4', deb=0.2)


def _mreza(pg: Pogled, korak=None):
    korak = korak or next((g for g in (5, 10, 20, 25, 50, 100, 200, 250, 500) if g * pg.k >= 22), 500)
    x0, y0, x1, y1 = pg.granice
    xs = [float(x) for x in np.arange(math.ceil(x0 / korak) * korak, x1 + 1e-9, korak)]
    ys = [float(y) for y in np.arange(math.ceil(y0 / korak) * korak, y1 + 1e-9, korak)]
    return korak, xs, ys


def crtaj_mrezu_krizici(svg: Svg, pg: Pogled):
    """Križići koordinatne mreže unutar karte; vrati korak mreže u metrima."""
    korak, xs, ys = _mreza(pg)
    d = []
    for x in xs:
        for y in ys:
            X, Y = pg.t(x, y)
            d.append(f'M{f2(X - 1)},{f2(Y)}h2M{f2(X)},{f2(Y - 1)}v2')
    svg.put(''.join(d), rub='#6f6f6f', deb=0.09)
    return korak


def crtaj_mrezu_oznake(svg: Svg, pg: Pogled, korak):
    """Crtice i oznake koordinata (ENU-M, metri) uz okvir karte."""
    _, xs, ys = _mreza(pg, korak)
    dr = []
    for x in xs:
        X, _ = pg.t(x, 0)
        dr.append(f'M{f2(X)},{f2(pg.y + pg.h)}v1.2M{f2(X)},{f2(pg.y)}v-1.2')
        svg.tekst(X, pg.y + pg.h + 3.3, br(x, 0), 1.7, '#555555', sidro='middle')
        svg.tekst(X, pg.y - 1.7, br(x, 0), 1.7, '#555555', sidro='middle')
    for y in ys:
        _, Y = pg.t(0, y)
        dr.append(f'M{f2(pg.x)},{f2(Y)}h-1.2M{f2(pg.x + pg.w)},{f2(Y)}h1.2')
        svg.tekst(pg.x - 1.5, Y + 0.6, br(y, 0), 1.7, '#555555', sidro='end')
        svg.tekst(pg.x + pg.w + 1.5, Y + 0.6, br(y, 0), 1.7, '#555555')
    svg.put(''.join(dr), rub='#333333', deb=0.15)


def crtaj_mjerilo_i_sjever(svg: Svg, pg: Pogled, sudari: Sudari):
    """Grafičko mjerilo dolje lijevo i strelica sjevera gore desno, na bijeloj podlozi."""
    duljine = [2, 5, 10, 20, 25, 50, 100, 200, 250, 500, 1000]
    D = next((d for d in duljine if d * pg.k >= 38), 1000)
    n = 5 if D in (5, 10, 25, 50, 100, 250, 500, 1000) else 4
    L = D * pg.k
    x0, y0 = polozaj_mjerila(pg)
    svg.pravokutnik(x0 - 2.5, y0 - 5.2, L + 13, 12.6, rx=0.6, ispuna='#ffffff', rub='#888888', deb=0.12,
                    neprozirnost=0.93)
    sudari.dodaj((x0 - 2.5, y0 - 5.2, x0 + L + 10.5, y0 + 7.4))
    svg.otvori(id=f'{svg.uid}-mjerilo', data_duljina_m=str(D), data_mjerilo=str(pg.mjerilo))
    for i in range(n):
        svg.pravokutnik(x0 + i * L / n, y0, L / n, 1.5, ispuna='#222222' if i % 2 == 0 else '#ffffff',
                        rub='#222222', deb=0.12)
    svg.zatvori()
    for i in range(n + 1):
        v = D * i / n
        svg.tekst(x0 + i * L / n, y0 - 0.9, br(v, 0 if v == int(v) else 1) + (' m' if i == n else ''), 1.8,
                  '#222222', sidro='middle' if i < n else 'start', extra='' if i < n else ' dx="-1.2"')
    svg.tekst(x0, y0 + 5.2, f'Mjerilo 1 : {br(pg.mjerilo, 0)} (format A3)', 2.1, '#111111', bold=True)
    # sjever
    nx, ny = pg.x + pg.w - 8, pg.y + 10
    svg.krug(nx, ny, 5.6, ispuna='#ffffff', rub='#888888', deb=0.12, neprozirnost=0.93)
    svg.put(d_tocke([(nx, ny - 4.6), (nx + 1.7, ny + 2.6), (nx, ny + 1.4)], True), ispuna='#222222')
    svg.put(d_tocke([(nx, ny - 4.6), (nx - 1.7, ny + 2.6), (nx, ny + 1.4)], True), ispuna='#ffffff', rub='#222222',
            deb=0.12)
    svg.tekst(nx, ny + 4.9, 'S', 2.0, '#222222', bold=True, sidro='middle')
    sudari.dodaj((nx - 5.8, ny - 5.8, nx + 5.8, ny + 5.8))


def polozaj_mjerila(pg: Pogled, zauzeto=None):
    """Lijevi rub i crta grafičkog mjerila (mm lista). Bira se donji lijevi, donji desni ili gornji lijevi kut
    karte, onaj u kojem podloga mjerila najmanje prekriva prostore razine (zauzeto: geometrija lista).
    Izbor se pamti u pogledu."""
    if getattr(pg, '_mjerilo_xy', None) is not None:
        return pg._mjerilo_xy
    duljine = [2, 5, 10, 20, 25, 50, 100, 200, 250, 500, 1000]
    D = next((d for d in duljine if d * pg.k >= 38), 1000)
    L = D * pg.k
    kand = [(pg.x + 4, pg.y + pg.h - 9.5), (pg.x + pg.w - L - 14, pg.y + pg.h - 9.5), (pg.x + 4, pg.y + 9.0)]
    xy = kand[0]
    if zauzeto is not None and not zauzeto.is_empty:
        def prekrivanje(q):
            return zauzeto.intersection(box(q[0] - 2.5, q[1] - 5.2, q[0] + L + 10.5, q[1] + 7.4)).area
        xy = min(kand, key=lambda q: (round(prekrivanje(q), 1), kand.index(q)))
    pg._mjerilo_xy = xy
    return xy


def _mjerilo_rezervacija(pg: Pogled):
    duljine = [2, 5, 10, 20, 25, 50, 100, 200, 250, 500, 1000]
    D = next((d for d in duljine if d * pg.k >= 38), 1000)
    L = D * pg.k
    x0, y0 = polozaj_mjerila(pg)
    nx, ny = pg.x + pg.w - 8, pg.y + 10
    return [(x0 - 3, y0 - 5.7, x0 + L + 11, y0 + 7.9), (nx - 6.2, ny - 6.2, nx + 6.2, ny + 6.2)]


def crtaj_prostor(svg: Svg, K_: Kontekst, pg: Pogled, s, sitno, info):
    """Ispuna, obris i oprema jednog prostora. Vrati True ako prostor ima opremu (linije) ispod natpisa."""
    P = K_.P
    isp, rub, uzorak, _ = KAT[s['kat']]
    gp = pg.gk(s['geom'])
    if gp is None:
        return False
    d = d_poligon(gp)
    zatvoren = s['kat'] in ZATVORENE
    svg.put(d, ispuna=isp, extra=f' data-prostor="{esc(s["id"])}"')
    if uzorak:
        svg.srafura(gp, uzorak, rub)
    ima = bool(uzorak)
    kat = s['kat']
    if kat == 'garaza':
        mjesta, prolazi = K_.raster(s)
        if not sitno:
            dd = [d_poligon(pg.g(r)) for r in mjesta if r.intersects(pg.svijet)]
            svg.put(''.join(dd), rub='#8c8c8c', deb=0.09)
        dd = [d_linija(pg.g(l.intersection(pg.svijet))) for l in prolazi if l.intersects(pg.svijet)]
        svg.put(''.join(dd), rub='#a8a8a8', deb=0.13, crt='1.4 0.9')
        ima = True
    elif kat == 'tribine':
        n = max(1, math.ceil(0.42 / (0.8 * pg.k)))
        dd = [d_linija(pg.g(l.intersection(pg.svijet))) for l in redovi_tribine(s['geom'], 0.8 * n)
              if l.intersects(pg.svijet)]
        svg.put(''.join(dd), rub='#5e78b8', deb=0.08)
        ima = True
    elif kat in ('promet_tramvaj', 'promet_cesta', 'promet_bus'):
        linije = []
        if kat == 'promet_tramvaj' and K_.podloga.ima:
            for g, _ in K_.podloga.u_okviru('tram', s['geom']):
                c = g.intersection(s['geom'])
                linije += [l for l in dijelovi(c, 'LineString') if l.length > 3.0]
        os_ = os_trake(s['geom'])
        if kat == 'promet_tramvaj':
            if not linije and os_ is not None:
                linije = [os_]
            dd = ''.join(d_linija(pg.g(l.intersection(pg.svijet))) for l in linije if l.intersects(pg.svijet))
            if dd:
                if 1.0 * pg.k >= 0.55:
                    svg.put(dd, rub='#1c3f7a', deb=1.0 * pg.k + 0.14)
                    svg.put(dd, rub=isp, deb=1.0 * pg.k - 0.14)
                else:
                    svg.put(dd, rub='#1c3f7a', deb=0.2)
                info['crte'].add('kolosijek')
                ima = True
        elif kat == 'promet_cesta' and os_ is not None and re.search(r'kolnik|cest|prilaz', norm(s['naziv'])):
            c = pg.gk(os_)
            if c is not None:
                svg.put(d_linija(c), rub='#ffffff', deb=0.3, crt='1.8 1.4')
                info['crte'].add('os kolnika')
    if s['sportovi'] or kat == 'igraliste':
        smj, _ = borilista_prostora(s, K_.sportovi)
        redoslijed = []
        for sm in smj:
            if sm['e']['id'] not in redoslijed:
                redoslijed.append(sm['e']['id'])
        if smj and s['kap'] and not sitno and kat == 'sport_zatvoreni':
            vr = norm((s['kap'] or {}).get('vrsta', ''))
            if ('sjed' in vr or 'gleda' in vr) and PA.je_broj(s['kap'].get('broj')):
                gl = smj[0]
                l, w = Sportovi.potrebno(gl['e'])
                jez = affinity.rotate(box(gl['cx'] - l / 2, gl['cy'] - w / 2, gl['cx'] + l / 2, gl['cy'] + w / 2),
                                      gl['kut'], origin=(gl['cx'], gl['cy']))
                redovi, _ = redovi_gledalista(s['geom'], jez, float(s['kap']['broj']))
                dd = [d_linija(pg.g(x.intersection(pg.svijet))) for x in redovi if x.intersects(pg.svijet)]
                svg.put(''.join(dd), rub='#b08a4a', deb=0.08)
                info['crte'].add('gledalište')
        vidjeni, bez_natpisa = set(), []
        preklop = len(redoslijed) > 1 and len(smj) == len(redoslijed) and \
            max(math.dist((a['cx'], a['cy']), (smj[0]['cx'], smj[0]['cy'])) for a in smj) < 0.5
        for k, sm in enumerate(smj):
            boja = BOJE_LINIJA[redoslijed.index(sm['e']['id']) % len(BOJE_LINIJA)]
            prvi = sm['e']['id'] not in vidjeni
            vidjeni.add(sm['e']['id'])
            r_ = max(sm['L'], sm['W'])
            if not box(sm['cx'] - r_, sm['cy'] - r_, sm['cx'] + r_, sm['cy'] + r_).intersects(pg.svijet):
                continue
            crtaj_boriliste(svg, pg, sm, boja, sitno=pg.mjerilo > 2500, natpis=False,
                            odgodi=info.setdefault('natpisi_disciplina', []))
            if prvi and pg.mjerilo <= 1500 and not preklop:
                r_n = natpis_borilista(svg, pg, sm, boja, sudari=info['sudari'])
                if r_n:
                    info['sudari'].dodaj(r_n)
                else:
                    bez_natpisa.append((sm['e']['id'], boja))
            # borilište je meka prepreka za natpis prostora
            l, w = sm['L'], sm['W']
            pr_ = affinity.rotate(box(sm['cx'] - l / 2, sm['cy'] - w / 2, sm['cx'] + l / 2, sm['cy'] + w / 2),
                                  sm['kut'], origin=(sm['cx'], sm['cy']))
            info['sudari'].dodaj(pg.g(pr_).bounds, meki=True)
        for eid, boja in bez_natpisa:
            # uske staze (streljaštvo, mačevanje, kuglanje): jedan natpis za skupinu staza istog sporta, vodoravno,
            # na bijeloj podlozi u sredini skupine ili odmah ispod/iznad nje
            sk = [sm for sm in smj if sm['e']['id'] == eid]
            okviri = [pg.g(affinity.rotate(box(sm['cx'] - sm['L'] / 2, sm['cy'] - sm['W'] / 2, sm['cx'] + sm['L'] / 2,
                                               sm['cy'] + sm['W'] / 2), sm['kut'], origin=(sm['cx'], sm['cy'])))
                      for sm in sk]
            gx0, gy0, gx1, gy1 = unary_union(okviri).bounds
            vitka = max(sk[0]['L'], sk[0]['W']) >= 5 * max(min(sk[0]['L'], sk[0]['W']), 0.1)
            t1 = f'{sk[0]["e"]["naziv"]}' + (f' ({len(sk)} {"staza" if vitka else "borilišta"})' if len(sk) > 1 else '')
            moj = pg.g(s['geom'])
            t2 = f'{_mjera(sk[0]["L"])} × {_mjera(sk[0]["W"])} m'
            for vel in (1.9, F_PODATAK):
                cx_ = (gx0 + gx1) / 2
                gotovo_ = False
                for cy_k in ('sred', 'ispod', 'iznad'):
                    # u sredini skupine natpis se prelama na širinu skupine (najviše tri retka naziva)
                    nl_ = (prelomi(t1, vel, False, (gx1 - gx0) * 0.95 - 1.2, 3) if cy_k == 'sred' else None) or [t1]
                    redci_ = nl_ + [t2]
                    w_ = max(sirina(t, vel) for t in redci_) + 1.2
                    h_ = len(redci_) * vel * 1.25 + 0.6
                    cy_ = {'sred': (gy0 + gy1) / 2, 'ispod': gy1 + h_ / 2 + 0.6, 'iznad': gy0 - h_ / 2 - 0.6}[cy_k]
                    r_ = (cx_ - w_ / 2, cy_ - h_ / 2, cx_ + w_ / 2, cy_ + h_ / 2)
                    unutra = gy0 <= cy_ <= gy1
                    if unutra and w_ > (gx1 - gx0) * 0.98:
                        continue
                    if not pg.pravokutnik.contains(box(*r_)) or not info['sudari'].slobodno(r_) or \
                            not moj.contains(box(*r_)):
                        continue
                    svg.pravokutnik(r_[0], r_[1], w_, h_, rx=0.4, ispuna='#ffffff', neprozirnost=0.88)
                    for i_, t_ in enumerate(redci_):
                        svg.tekst(cx_, r_[1] + 0.3 + vel + i_ * vel * 1.25, t_, vel, boja, sidro='middle')
                    info['sudari'].dodaj(r_)
                    gotovo_ = True
                    break
                if gotovo_:
                    break
        if preklop and pg.mjerilo <= 1500:
            # natpisi preklopljenih borilišta: blok u sredini glavnog, redak po sportu u boji njegovih linija
            X, Y = pg.t(smj[0]['cx'], smj[0]['cy'])
            for vel in (1.75, F_PODATAK):
                redci_ = [(f'{sm["e"]["naziv"]} {_mjera(sm["L"])} × {_mjera(sm["W"])} m',
                           BOJE_LINIJA[redoslijed.index(sm['e']['id']) % len(BOJE_LINIJA)]) for sm in smj]
                w_ = max(sirina(t, vel) for t, _ in redci_) + 1.2
                h_ = len(redci_) * vel * 1.25 + 0.8
                if w_ <= min(smj[0]['L'], smj[0]['W']) * pg.k * 0.95 or vel == F_PODATAK:
                    break
            r_ = (X - w_ / 2, Y - h_ / 2, X + w_ / 2, Y + h_ / 2)
            if w_ <= max(smj[0]['L'], smj[0]['W']) * pg.k and pg.pravokutnik.contains(box(*r_)):
                svg.pravokutnik(r_[0], r_[1], w_, h_, rx=0.5, ispuna='#ffffff', neprozirnost=0.82)
                for i_, (t, bo) in enumerate(redci_):
                    svg.tekst(X, r_[1] + 0.4 + (i_ + 0.8) * vel * 1.25, t, vel, bo, sidro='middle')
                info['sudari'].dodaj(r_)
        ima = ima or bool(smj)
    svg.put(d, rub='#2b2b2b' if zatvoren else rub, deb=(0.34 if zatvoren else 0.16) * (0.6 if sitno else 1.0))
    info['kat'].add(kat)
    return ima


def smjesti_natpise(svg: Svg, K_: Kontekst, pg: Pogled, prostori, sudari: Sudari, s_opremom, info):
    velicine = (2.5, 2.15, 1.85, 1.65)
    for s in sorted(prostori, key=lambda x: (-x['a'], x['br'])):
        vid = K_.vidljivo(s).intersection(pg.svijet)
        dj = dijelovi(vid)
        if not dj:
            continue
        dio = max(dj, key=lambda x: x.area)
        if dio.area < 0.08 * s['a'] and dio.area * pg.k ** 2 < 150.0:
            continue      # vidi se samo rubni komadić prostora
        gp = pg.g(dio)
        pr = prep(gp)
        kand = kandidati_tocke(gp)
        bx0, by0, bx1, by1 = gp.bounds
        bw, bh = bx1 - bx0, by1 - by0
        gotovo = False
        # uski vodoravni hodnik kroz koji ide crta toplog puta: natpis u jednom retku, uz crtu, a ne preko nje
        topli = info.get('topli')
        if topli is not None and bw >= 3.0 * bh and bh < 13.0 and dio.intersects(topli):
            t2 = ' · ' + f'{bm2(s["a"])} m²' + (f' · h {br(s["visina"], 1)} m' if s['visina'] else '')
            for vel in velicine:
                v2 = max(vel * 0.84, F_PODATAK)
                w1 = sirina(s['naziv'], vel, True)
                w, h = w1 + sirina(t2, v2), vel * 1.22
                if w + 0.8 > bw or h + 0.6 > bh:
                    continue
                for q in kand:
                    r = (q.x - w / 2 - 0.5, q.y - h / 2 - 0.35, q.x + w / 2 + 0.5, q.y + h / 2 + 0.35)
                    if pr.contains(box(*r)) and sudari.slobodno(r, True):
                        svg.pravokutnik(r[0] + 0.2, r[1] + 0.1, r[2] - r[0] - 0.4, r[3] - r[1] - 0.2, rx=0.4,
                                        ispuna='#ffffff', neprozirnost=0.85)
                        svg.tekst(q.x - w / 2, q.y + vel * 0.36, s['naziv'], vel, '#111111', bold=True)
                        svg.tekst(q.x - w / 2 + w1, q.y + vel * 0.36, t2, v2, '#222222')
                        sudari.dodaj(r)
                        gotovo = True
                        break
                if gotovo:
                    break
            if gotovo:
                if blok_ima_dodatak(K_, s):
                    info['tablica'].append((s['br'], redak_tablice(K_, s)))
                continue
        for varijanta in ('puni', 'sazeti'):
            for vel in velicine:
                for maxw in sorted({round(min(bw, 62.0) * 0.94, 1), round(min(bw, 62.0) * 0.6, 1), 21.0},
                                   reverse=True):
                    if maxw < 7.0 or maxw > bw:
                        continue
                    redci = blok_natpisa(K_, s, varijanta, vel, maxw)
                    if redci is None:
                        continue
                    w, h = mjere_bloka(redci)
                    if w + 0.8 > bw or h + 0.6 > bh:
                        continue
                    for i_meki in (True, False):
                        for q in kand:
                            r = (q.x - w / 2 - 0.5, q.y - h / 2 - 0.35, q.x + w / 2 + 0.5, q.y + h / 2 + 0.35)
                            if pr.contains(box(*r)) and sudari.slobodno(r, i_meki):
                                crtaj_blok(svg, q.x, q.y, redci, podloga_bijela=True)
                                sudari.dodaj(r)
                                gotovo = True
                                break
                        if gotovo:
                            break
                    if gotovo:
                        break
                if gotovo:
                    break
            if gotovo:
                if varijanta != 'puni':
                    info['tablica'].append((s['br'], redak_tablice(K_, s)))
                break
        if gotovo:
            continue
        # samo broj; ako ne stane u prostor, izvan njega s crtom vodilicom
        t = str(s['br'])
        vel = 1.75
        w, h = max(sirina(t, vel, True) + 1.3, 3.0), 2.9
        rub = KAT[s['kat']][1]
        mjesto = None
        for q in kand:
            r = (q.x - w / 2, q.y - h / 2, q.x + w / 2, q.y + h / 2)
            if pr.contains(box(*r)) and sudari.slobodno(r):
                mjesto = (q.x, q.y, None)
                break
        if mjesto is None:
            q = kand[0]
            r = (q.x - w / 2, q.y - h / 2, q.x + w / 2, q.y + h / 2)
            if min(bw, bh) >= h * 0.8 and sudari.slobodno(r) and pg.pravokutnik.contains(box(*r)):
                mjesto = (q.x, q.y, None)
        if mjesto is None:
            q = kand[0]
            for dist in (3.5, 5.0, 7.0, 9.5, 13.0, 17.0):
                for i in range(16):
                    a = math.radians(22.5 * i - 67.5)
                    x, y = q.x + dist * math.cos(a), q.y + dist * math.sin(a)
                    r = (x - w / 2, y - h / 2, x + w / 2, y + h / 2)
                    if pg.pravokutnik.contains(box(*r)) and sudari.slobodno(r, True):
                        mjesto = (x, y, (q.x, q.y))
                        break
                if mjesto:
                    break
        if mjesto is None:
            info['tablica'].append((s['br'], redak_tablice(K_, s, 'bez oznake na listu')))
            continue
        x, y, vod = mjesto
        if vod:
            svg.linija(x, y, vod[0], vod[1], '#444444', 0.13)
            svg.krug(vod[0], vod[1], 0.32, ispuna='#444444')
        svg.pravokutnik(x - w / 2, y - h / 2, w, h, rx=1.2, ispuna='#ffffff', rub=rub, deb=0.2)
        svg.tekst(x, y + vel * 0.36, t, vel, '#111111', bold=True, sidro='middle')
        sudari.dodaj((x - w / 2, y - h / 2, x + w / 2, y + h / 2))
        info['tablica'].append((s['br'], redak_tablice(K_, s)))


def natpis_uz_tocku(svg: Svg, pg: Pogled, sudari: Sudari, x, y, tekst, boja, odmak, vel=F_PODATAK, bold=False):
    """Kratki natpis uz točku: prvo desno, pa lijevo, gore, dolje i ukoso; preskoči ako nema mjesta."""
    w, h = sirina(tekst, vel, bold), vel * 1.15
    for dx, dy, sidro in ((odmak, 0, 'start'), (-odmak, 0, 'end'), (0, -odmak - h / 2, 'middle'),
                          (0, odmak + h / 2, 'middle'), (odmak, -odmak, 'start'), (odmak, odmak, 'start'),
                          (-odmak, -odmak, 'end'), (-odmak, odmak, 'end'), (odmak * 2.2, -odmak * 1.6, 'start'),
                          (-odmak * 2.2, odmak * 1.6, 'end')):
        cx = x + dx + (w / 2 if sidro == 'start' else -w / 2 if sidro == 'end' else 0)
        cy = y + dy
        r = (cx - w / 2 - 0.25, cy - h / 2 - 0.15, cx + w / 2 + 0.25, cy + h / 2 + 0.15)
        if pg.pravokutnik.contains(box(*r)) and sudari.slobodno(r):
            svg.pravokutnik(r[0], r[1], r[2] - r[0], r[3] - r[1], rx=0.3, ispuna='#ffffff', neprozirnost=0.82)
            svg.tekst(cx, cy + vel * 0.36, tekst, vel, boja, bold=bold, sidro='middle')
            sudari.dodaj(r)
            return True
    return False


def nastavci_veza(svg: Svg, K_: Kontekst, pg: Pogled, veze, sudari: Sudari, info):
    """Topli put koji izlazi iz okvira karte: na rubu strelica i natpis s preostalom duljinom i odredištem
    (najbliže postojeće stajalište do 150 m od kraja veze, inače opis veze)."""
    okvir = pg.svijet.buffer(-1e-6)
    for v in veze:
        if v['tip'] != 'topli_put' or v['geom'].geom_type == 'Point':
            continue
        vani = v['geom'].difference(okvir)
        for d in dijelovi(vani, 'LineString'):
            if d.length < 5.0:
                continue
            a, b = Point(d.coords[0]), Point(d.coords[-1])
            if a.distance(pg.svijet.exterior) < 0.05:
                rub, kraj, smjer = a, b, d.interpolate(min(2.0, d.length))
            elif b.distance(pg.svijet.exterior) < 0.05:
                rub, kraj, smjer = b, a, d.interpolate(max(0.0, d.length - 2.0))
            else:
                continue
            odr = None
            if K_.podloga is not None and K_.podloga.stajalista:
                naj = min(K_.podloga.stajalista, key=lambda q: math.hypot(q[2] - kraj.x, q[3] - kraj.y))
                if math.hypot(naj[2] - kraj.x, naj[3] - kraj.y) <= 150.0:
                    odr = f'stajalište {naj[1]}' + (' (vlak)' if naj[0] == 'vlak' else '')
            if odr is None:
                odr = skrati(v['napomena'] or v['id'], F_PODATAK, False, 60.0)
            X, Y = pg.t(rub.x, rub.y)
            ux, uy = smjer.x - rub.x, smjer.y - rub.y
            n = math.hypot(ux, uy) or 1.0
            ux, uy = ux / n, -uy / n          # u koordinatama lista (y prema dolje)
            X0, Y0 = X - ux * 6.0, Y - uy * 6.0
            strelica(svg, X0, Y0, X - ux * 0.6, Y - uy * 0.6, B_TOPLI, 0.45, 1.6)
            sudari.dodaj((min(X0, X) - 0.8, min(Y0, Y) - 0.8, max(X0, X) + 0.8, max(Y0, Y) + 0.8))
            natpis_uz_tocku(svg, pg, sudari, X0, Y0, f'topli put dalje: još {br(d.length, 0)} m do: {odr}',
                            B_TOPLI, 1.2, bold=True)
            info['crte'].add('topli put izvan lista')


def crtaj_kartu(svg: Svg, K_: Kontekst, raz, pg: Pogled, pregled):
    """Nacrtaj tlocrt razine u pogledu pg. Vrati info za legendu i tablicu."""
    P = K_.P
    sitno = pg.mjerilo > 1500
    sudari = Sudari()
    info = {'kat': set(), 'veze': set(), 'crte': set(), 'tablica': [], 'korak_mreze': None, 'sudari': sudari}
    if P.unija_razine[raz['id']] is not None:
        polozaj_mjerila(pg, pg.gk(P.unija_razine[raz['id']]))
    for r in _mjerilo_rezervacija(pg):
        sudari.dodaj(r)
    svg.pravokutnik(pg.x, pg.y, pg.w, pg.h, ispuna='#fcfcfb')
    svg.otvori(clip_path=svg.isjecak(pg.x, pg.y, pg.w, pg.h))
    crtaj_podlogu(svg, pg, K_.podloga, sitno)
    if K_.podloga.ima:
        info['crte'].add('podloga')
    prostori = [s for s in P.po_razini[raz['id']] if s['geom'].intersects(pg.svijet)]
    prostori.sort(key=lambda s: (-s['a'], s['br']))
    info['prostori_lista'] = prostori
    # simboli točkastih veza ove razine zauzimaju mjesto prije natpisa borilišta i prostora
    a_ = 1.9 if sitno else 2.9
    for v in P.veze:
        if raz['id'] in v['razine'] and v['geom'].geom_type == 'Point' and pg.svijet.contains(v['geom']):
            X, Y = pg.t(v['geom'].x, v['geom'].y)
            w_ = a_ * (1.5 if v['tip'] in ('stubiste', 'pokretne_stube') else 1.0)
            sudari.dodaj((X - w_ / 2 - 0.2, Y - a_ / 2 - 0.2, X + w_ / 2 + 0.2, Y + a_ / 2 + 0.2))
    s_opremom = set()
    for s in prostori:
        if crtaj_prostor(svg, K_, pg, s, sitno, info):
            s_opremom.add(s['id'])
    # postojeća stabla (OSM) u perivoju koji ostaje na tlu (odluka M30); inventar stabala je OTVOREN
    if len(K_.podloga.stabla) and raz['id'] in K_.razine_tla:
        for s in prostori:
            if not re.search(r'perivoj', norm(s['naziv'])) or 'M30' not in (s['raw'].get('odluke') or []):
                continue
            gp = prep(s['geom'])
            for x, y in K_.podloga.stabla:
                if gp.contains(Point(x, y)) and pg.svijet.contains(Point(x, y)):
                    X, Y = pg.t(x, y)
                    r_ = max(0.6, 3.0 * pg.k) if not sitno else 0.5
                    svg.krug(X, Y, r_, ispuna='#7cb26b', rub='#2e6b1f', deb=0.15, neprozirnost=0.8)
                    svg.krug(X, Y, 0.18, ispuna='#2e6b1f')
                    sudari.dodaj((X - r_, Y - r_, X + r_, Y + r_), meki=True)
                    info['crte'].add('stablo')
                    info['stabla_m30'] = info.get('stabla_m30', 0) + 1
    stajalista = []
    unija = P.unija_razine[raz['id']]
    zauzeto_p = pg.gk(unija) if unija is not None else None
    if K_.podloga.ima:
        ulicni_nazivi(svg, pg, K_.podloga, sudari, 1.7 if sitno else 2.0, zauzeto_p)
        if raz['id'] in K_.razine_tla:
            for vrsta, naz, x, y in K_.podloga.stajalista:
                if not pg.svijet.contains(Point(x, y)):
                    continue
                X, Y = pg.t(x, y)
                r_ = 0.7 if sitno else 0.95
                svg.krug(X, Y, r_, ispuna='#ffffff', rub='#6a6a6a', deb=0.2)
                sudari.dodaj((X - r_, Y - r_, X + r_, Y + r_))
                if not sitno:      # naziv se upisuje zadnji, samo ako ne smeta natpisima i simbolima koncepta
                    stajalista.append((X, Y, f'{naz} ({vrsta[:4]}.)' if vrsta != 'vlak' else f'{naz} (vlak)'))
                info['crte'].add('stajalište')
    # obrisi susjednih razina
    i = raz['i']
    for j, boja, crt, kljuc in ((i + 1, B_IZNAD, '2.4 1.0', 'iznad'), (i - 1, B_ISPOD, '0.7 0.7', 'ispod')):
        if 0 <= j < len(P.razine):
            u = K_.obris_razine(P.razine[j])
            if u is not None:
                c = pg.gk(u.boundary)
                if c is not None:
                    svg.put(d_linija(c), rub=boja, deb=0.2, crt=crt)
                    info['crte'].add(kljuc)
                    info[kljuc] = P.razine[j]
    # svjetlarnici iznad (natpis se upisuje nakon natpisa prostora, samo na slobodno mjesto)
    svj_natpisi = []
    for s in P.prostori:
        rs = P.razina[s['razina']]
        if s['kat'] != 'svjetlarnik' or rs['i'] <= i or not s['geom'].intersects(pg.svijet):
            continue
        if unija is None or not s['geom'].intersects(unija):
            continue
        gp = pg.gk(s['geom'])
        svg.put(d_poligon(gp), ispuna='#bfe9f5', neprozirnost=0.22)
        svg.put(d_poligon(gp), rub=VEZE['svjetlarnik'][0], deb=0.22, crt='1.1 0.6')
        info['crte'].add('svjetlarnik iznad')
        if not sitno:
            svj_natpisi.append(gp)
    # obris stadiona i igrališta kao orijentir
    st = P.stadion
    if st and st.get('obris') is not None:
        c = pg.gk(st['obris'].boundary)
        if c is not None:
            svg.put(d_linija(c), rub='#27408b', deb=0.22, crt='3 0.8 0.6 0.8')
            info['crte'].add('obris stadiona')
        if st.get('igraliste') is not None and not any(s['kat'] == 'igraliste' for s in prostori):
            c = pg.gk(st['igraliste'].boundary)
            if c is not None:
                svg.put(d_linija(c), rub='#3d8b37', deb=0.18, crt='1.4 0.8')
                info['crte'].add('igralište (druga razina)')
    # veze
    a = 1.9 if sitno else 2.9
    veze = [v for v in P.veze if v['geom'].intersects(pg.svijet)]
    for v in veze:      # topli put drugih razina, tanko
        if v['tip'] == 'topli_put' and raz['id'] not in v['razine'] and v['geom'].geom_type != 'Point':
            c = pg.gk(v['geom'])
            if c is not None:
                svg.put(d_linija(c), rub=B_TOPLI, deb=0.3, crt='1.6 1.0', neprozirnost=0.75)
                info['crte'].add('topli put druge razine')
    moje = [v for v in veze if raz['id'] in v['razine']]
    red_tipova = ['evakuacija', 'kolni_ulaz', 'rampa', 'stubiste', 'pokretne_stube', 'ulaz', 'svjetlarnik',
                  'topli_put', 'dizalo']
    moje.sort(key=lambda v: (red_tipova.index(v['tip']) if v['tip'] in red_tipova else 99, v['id']))
    oznake = []
    topli_linije = []
    for v in moje:
        if v['geom'].geom_type == 'Point':
            continue
        usp = smjer_uspona(P, v) if v['tip'] in ('rampa', 'stubiste', 'pokretne_stube') else None
        crtaj_linijsku_vezu(svg, pg, v, sitno, usp)
        info['veze'].add(v['tip'] + '_linija' if v['tip'] in ('ulaz', 'kolni_ulaz', 'evakuacija', 'stubiste',
                                                                'pokretne_stube') else v['tip'])
        # crta veze je meka prepreka natpisima (natpis je zaobilazi kad ima mjesta)
        pola = 0.75
        if v['tip'] in ('rampa', 'stubiste', 'pokretne_stube'):
            pola = max(0.75, (v['sirina'] or 3.0) * pg.k / 2)
        for l in dijelovi(v['geom'].intersection(pg.svijet), 'LineString'):
            lp = pg.g(l)
            n = max(1, int(math.ceil(lp.length / (2 * pola))))
            for j in range(n + 1):
                q = lp.interpolate(j / n, normalized=True)
                sudari.dodaj((q.x - pola, q.y - pola, q.x + pola, q.y + pola), meki=True)
        if v['tip'] == 'topli_put':
            topli_linije.append(v['geom'])
            continue
        vid = v['geom'].intersection(pg.svijet)
        dj = dijelovi(vid, 'LineString')
        if not dj:
            continue
        l = max(dj, key=lambda x: x.length)
        m = l.interpolate(0.5, normalized=True)
        druge = [x for x in v['razine'] if x != raz['id']]
        if v['tip'] == 'rampa':
            t = 'rampa' + (f' {br(v["nagib"], 1)} %' if v['nagib'] is not None else '')
            t += f' · L {br(v["geom"].length, 0)} m'
            if usp is None:
                t += ' (smjer zapisa)'
        elif v['tip'] in ('stubiste', 'pokretne_stube'):
            t = ('stube' if v['tip'] == 'stubiste' else 'pokretne stube') + (' → ' + ', '.join(druge) if druge else '')
        elif v['tip'] == 'kolni_ulaz':
            t = 'kolni ulaz / portal'
        else:
            t = ''
        if t:
            oznake.append((pg.t(m.x, m.y), t, VEZE[v['tip']][0], 1.2))
    for v in moje:
        if v['geom'].geom_type != 'Point':
            continue
        X, Y = pg.t(v['geom'].x, v['geom'].y)
        vel = a * (0.8 if v['tip'] == 'evakuacija' else 1.0)
        simbol_veze(svg, v['tip'], X, Y, vel)
        info['veze'].add(v['tip'])
        w = vel * (1.5 if v['tip'] in ('stubiste', 'pokretne_stube') else 1.0)
        sudari.dodaj((X - w / 2 - 0.2, Y - vel / 2 - 0.2, X + w / 2 + 0.2, Y + vel / 2 + 0.2))
        druge = [x for x in v['razine'] if x != raz['id']]
        if druge and v['tip'] != 'evakuacija':
            oznake.append(((X, Y), '→ ' + ', '.join(druge), VEZE[v['tip']][0], w / 2 + 0.5))
    info['korak_mreze'] = crtaj_mrezu_krizici(svg, pg)
    info['topli'] = unary_union(topli_linije) if topli_linije else None
    smjesti_natpise(svg, K_, pg, prostori, sudari, s_opremom, info)
    for X, Y, t, boja in info.get('natpisi_disciplina', []):
        w = sirina(t, F_PODATAK)
        r = (X - w / 2 - 0.2, Y - F_PODATAK * 0.85, X + w / 2 + 0.2, Y + 0.35)
        if sudari.slobodno(r) and pg.pravokutnik.contains(box(*r)):
            svg.tekst(X, Y, t, F_PODATAK, boja, sidro='middle')
            sudari.dodaj(r)
    for gp in svj_natpisi:
        x0, y0, x1, y1 = gp.bounds
        t = 'svjetlarnik iznad'
        w = sirina(t, F_PODATAK)
        cx, cy = (x0 + x1) / 2, (y0 + y1) / 2
        r = (cx - w / 2, cy - 1.0, cx + w / 2, cy + 1.0)
        if x1 - x0 > w + 1 and y1 - y0 > 2.6 and sudari.slobodno(r, True) and gp.contains(box(*r)):
            svg.tekst(cx, cy + 0.55, t, F_PODATAK, '#0f6f8a', sidro='middle', kurziv=True)
            sudari.dodaj(r)
    if not pregled:
        for (X, Y), t, boja, odmak in oznake:
            if pg.pravokutnik.contains(Point(X, Y)):
                natpis_uz_tocku(svg, pg, sudari, X, Y, t, boja, odmak)
    if pregled:
        nastavci_veza(svg, K_, pg, moje, sudari, info)
    for X, Y, t in stajalista:
        natpis_uz_tocku(svg, pg, sudari, X, Y, t, '#6a6a6a', 1.5)
    # stvarne kote terena: nakon natpisa prostora, samo na slobodno mjesto (ne prekrivaju natpise ni crte veza)
    if K_.kote and not sitno and raz['id'] in K_.razine_tla:
        x0, y0, x1, y1 = pg.granice
        uzete = []
        for x, y, z in sorted(K_.kote, key=lambda p: (round(p[1], 1), round(p[0], 1))):
            if not (x0 < x < x1 and y0 < y < y1):
                continue
            X, Y = pg.t(x, y)
            if any(abs(X - u) < 11 and abs(Y - w_) < 4.2 for u, w_ in uzete):
                continue
            t = br(z, 2)
            w = sirina(t, F_PODATAK)
            r = (X - 0.5, Y - 1.2, X + 0.9 + w, Y + 0.7)
            if not sudari.slobodno(r, True) or not pg.pravokutnik.contains(box(*r)):
                continue
            uzete.append((X, Y))
            svg.put(f'M{f2(X - 0.45)},{f2(Y)}h0.9M{f2(X)},{f2(Y - 0.45)}v0.9', rub='#6d4c41', deb=0.13)
            svg.tekst(X + 0.7, Y + 0.45, t, F_PODATAK, '#6d4c41')
            sudari.dodaj(r)
        if uzete:
            info['crte'].add('kota terena')
    svg.zatvori()
    svg.pravokutnik(pg.x, pg.y, pg.w, pg.h, rub='#222222', deb=0.3)
    crtaj_mrezu_oznake(svg, pg, info['korak_mreze'])
    crtaj_mjerilo_i_sjever(svg, pg, Sudari())
    info['tablica'].sort()
    return info


# ------------------------------------------------------------------------------------------- panel lista
class Panel:
    """Stupac uz desni rub lista: naslov, činjenice, ključni plan, legenda, tablica, izvori."""

    def __init__(self, svg: Svg, x, w):
        self.svg, self.x, self.w = svg, x + 2.5, w - 5.0
        self.y = RUB + 2.5
        self.dno = LIST_H - RUB - 2.5
        svg.pravokutnik(x, RUB, w, LIST_H - 2 * RUB, ispuna='#ffffff', rub='#222222', deb=0.3)

    def oznaka(self):
        s = self.svg
        vel = 2.6 if sirina(OZNAKA, 2.6, True) + 4 <= self.w else 2.3
        s.pravokutnik(self.x, self.y, self.w, 7.0, rx=0.8, ispuna='#fff3cd', rub='#b45f06', deb=0.35)
        s.tekst(self.x + self.w / 2, self.y + 4.5, OZNAKA, vel, '#7a3e00', bold=True, sidro='middle')
        self.y += 9.5

    def odlomak(self, tekst, vel=F_TEKST, bold=False, boja='#111111', max_redaka=6, kurziv=False, razmak=1.0,
                sirina_=None):
        w = sirina_ or self.w
        redci = prelomi(tekst, vel, bold, w, 200) or [skrati(tekst, vel, bold, w)]
        if len(redci) > max_redaka:
            redci = redci[:max_redaka]
            redci[-1] = skrati(redci[-1] + ' …', vel, bold, w)
        for r in redci:
            self.y += vel * 1.25
            self.svg.tekst(self.x, self.y - vel * 0.28, r, vel, boja, bold=bold, kurziv=kurziv)
        self.y += razmak

    def crta(self):
        self.svg.linija(self.x, self.y, self.x + self.w, self.y, '#999999', 0.12)
        self.y += 1.4

    def kljucni_plan(self, K_: Kontekst, raz, pg: Pogled, visina=40.0):
        P = K_.P
        x0, y0, x1, y1 = P.obuhvat
        rubm = 25.0
        wm, hm = x1 - x0 + 2 * rubm, y1 - y0 + 2 * rubm
        k = min(self.w / wm, visina / hm)
        w, h = wm * k, hm * k
        px = self.x + (self.w - w) / 2
        mali = Pogled((x0 + x1) / 2, (y0 + y1) / 2, 1000.0 / k, (px, self.y, w, h))
        s = self.svg
        s.pravokutnik(px, self.y, w, h, ispuna='#fafafa', rub='#999999', deb=0.12)
        if K_.sve is not None:
            s.put(d_poligon(mali.g(K_.sve.simplify(2.0))), ispuna='#ececec', rub='#b5b5b5', deb=0.1)
        u = P.unija_razine[raz['id']]
        if u is not None:
            s.put(d_poligon(mali.g(u.simplify(1.5))), ispuna='#c9c9c9')
        if P.stadion and P.stadion.get('obris') is not None:
            s.put(d_poligon(mali.g(P.stadion['obris'].simplify(1.0))), rub='#27408b', deb=0.15)
        a, b = mali.t(pg.granice[0], pg.granice[3]), mali.t(pg.granice[2], pg.granice[1])
        s.pravokutnik(a[0], a[1], b[0] - a[0], b[1] - a[1], rub='#c62828', deb=0.4, ispuna='#c62828',
                      neprozirnost=None, extra=' fill-opacity="0.12"')
        s.tekst(px + 1, self.y + 2.6, 'položaj lista', 1.6, '#666666')
        self.y += h + 2.0

    def legenda(self, K_: Kontekst, info, stupaca=2):
        s = self.svg
        stavke = []
        for k in KAT_RED:
            if k in info['kat']:
                stavke.append(('kat', k, KAT[k][3]))
        for tip in VEZE:
            if tip in info['veze'] or (tip + '_linija' in info['veze'] and tip in ('stubiste', 'pokretne_stube')):
                stavke.append(('veza', tip, VEZE[tip][1]))
            if tip + '_linija' in info['veze'] and tip in LINIJSKE_VEZE:
                stavke.append(('crta', LINIJSKE_VEZE[tip][0], LINIJSKE_VEZE[tip][1]))
        crte = info['crte']
        if 'iznad' in crte:
            stavke.append(('crta', (B_IZNAD, 0.2, '2.4 1.0'), f'obris razine iznad ({info["iznad"]["id"]})'))
        if 'ispod' in crte:
            stavke.append(('crta', (B_ISPOD, 0.2, '0.7 0.7'), f'obris razine ispod ({info["ispod"]["id"]})'))
        if 'svjetlarnik iznad' in crte:
            stavke.append(('crta', (VEZE['svjetlarnik'][0], 0.22, '1.1 0.6'), 'svjetlarnik iznad'))
        if 'topli put druge razine' in crte:
            stavke.append(('crta', (B_TOPLI, 0.3, '1.6 1.0'), 'topli put na drugoj razini'))
        if 'topli put izvan lista' in crte:
            stavke.append(('crta', (B_TOPLI, 0.45, None), 'topli put dalje izvan lista (strelica)'))
        if 'obris stadiona' in crte:
            stavke.append(('crta', ('#27408b', 0.22, '3 0.8 0.6 0.8'), 'vanjski obris stadiona'))
        if 'igralište (druga razina)' in crte:
            stavke.append(('crta', ('#3d8b37', 0.18, '1.4 0.8'), 'igralište (na drugoj razini)'))
        if 'kolosijek' in crte:
            stavke.append(('crta', ('#1c3f7a', 0.3, None), 'tramvajski kolosijek'))
        if 'gledalište' in crte:
            stavke.append(('crta', ('#b08a4a', 0.12, None), 'redovi gledališta (shema)'))
        if 'kota terena' in crte:
            stavke.append(('kota', None, 'stvarna kota terena (m n. v.)'))
        if 'stajalište' in crte:
            stavke.append(('staj', None, 'postojeće stajalište (OSM)'))
        if 'stablo' in crte:
            stavke.append(('stablo', None, 'postojeće stablo (OSM), ostaje (M30)'))
        if 'podloga' in crte:
            stavke.append(('podloga', None, 'postojeće stanje (OSM), sivo'))
        self.crtaj_stavke(stavke, stupaca)

    def crtaj_stavke(self, stavke, stupaca=2):
        """Stavke legende u stupcima: (vrsta, ključ, naziv)."""
        s = self.svg
        if not stavke:
            return
        sw = self.w / stupaca
        red_h = 3.35
        n = len(stavke)
        po_stupcu = math.ceil(n / stupaca)
        y0 = self.y
        for i, (vrsta, kljuc, naziv) in enumerate(stavke):
            cx = self.x + (i // po_stupcu) * sw
            cy = y0 + (i % po_stupcu) * red_h
            if vrsta == 'kat':
                isp, rub, uz, _ = KAT[kljuc]
                s.pravokutnik(cx, cy + 0.3, 4.6, 2.5, ispuna=isp, rub='#2b2b2b' if kljuc in ZATVORENE else rub,
                              deb=0.22 if kljuc in ZATVORENE else 0.14)
                if uz:
                    s.srafura(box(cx, cy + 0.3, cx + 4.6, cy + 2.8), uz, rub)
            elif vrsta == 'ispuna':
                isp, uz, boja_uz, rub = kljuc
                s.pravokutnik(cx, cy + 0.3, 4.6, 2.5, ispuna=isp, rub=rub, deb=0.18)
                if uz:
                    s.srafura(box(cx, cy + 0.3, cx + 4.6, cy + 2.8), uz, boja_uz, 0.85)
            elif vrsta == 'trokut':
                s.put(d_tocke([(cx + 1.6, cy + 0.6), (cx + 3.0, cy + 0.6), (cx + 2.3, cy + 2.2)], True),
                      ispuna='#6d4c41')
            elif vrsta == 'veza':
                if kljuc == 'topli_put':
                    s.linija(cx, cy + 1.55, cx + 4.6, cy + 1.55, B_TOPLI, 0.9, kraj='round')
                elif kljuc == 'rampa':
                    s.pravokutnik(cx, cy + 0.6, 4.6, 1.9, ispuna='#ffffff', rub=VEZE[kljuc][0], deb=0.2)
                    strelica(s, cx + 0.5, cy + 1.55, cx + 4.2, cy + 1.55, VEZE[kljuc][0], 0.2, 0.9)
                else:
                    simbol_veze(s, kljuc, cx + 2.3, cy + 1.55, 2.3)
            elif vrsta == 'crta':
                boja, deb, crt = kljuc
                s.linija(cx, cy + 1.55, cx + 4.6, cy + 1.55, boja, deb, crt)
            elif vrsta == 'kota':
                s.put(f'M{f2(cx + 1.6)},{f2(cy + 1.55)}h1.4M{f2(cx + 2.3)},{f2(cy + 0.85)}v1.4', rub='#6d4c41', deb=0.16)
            elif vrsta == 'staj':
                s.krug(cx + 2.3, cy + 1.55, 0.9, ispuna='#ffffff', rub='#6a6a6a', deb=0.2)
            elif vrsta == 'stablo':
                s.krug(cx + 2.3, cy + 1.55, 1.1, ispuna='#7cb26b', rub='#2e6b1f', deb=0.15, neprozirnost=0.8)
                s.krug(cx + 2.3, cy + 1.55, 0.18, ispuna='#2e6b1f')
            elif vrsta == 'podloga':
                s.pravokutnik(cx, cy + 0.3, 4.6, 2.5, ispuna='#e9e9e9', rub='#c2c2c2', deb=0.1)
            vel = 1.85 if sirina(naziv, 1.85) <= sw - 6.2 else F_PODATAK
            s.tekst(cx + 5.6, cy + 2.25, skrati(naziv, vel, False, sw - 6.2), vel, '#222222')
        self.y = y0 + po_stupcu * red_h + 1.2

    def tablica(self, redci, naslov, dno, stupaca=1):
        """Tablica prostora označenih brojem; smanjuje slova, dodaje stupac i krati retke dok ne stane.

        Ako ni najsitnije ne stane, zadnji redak upozorava na izostavljene prostore (iznad navoda podloga)."""
        if not redci:
            return
        s = self.svg
        self.odlomak(naslov, 2.0, True, razmak=0.3)
        y0 = self.y
        mogucnosti = [stupaca] + ([stupaca + 1] if self.w / (stupaca + 1) >= 44.0 else [])

        def rasporedi(stupci, visina):
            sw = self.w / stupci
            for vel, najvise in ((1.85, 3), (1.7, 3), (1.6, 2), (1.6, 1)):
                blokovi = []
                for brj, t in redci:
                    blokovi.append((brj, slozi_redak(t, vel, sw - 6.8, najvise)))
                rh = vel * 1.2
                stup, yy, raspored, stane = 0, 0.0, [], True
                for brj, l in blokovi:
                    h = len(l) * rh + 0.35
                    if yy + h > visina:
                        stup += 1
                        yy = 0.0
                        if stup >= stupci:
                            stane = False
                            break
                    raspored.append((stup, yy, brj, l))
                    yy += h
                if stane:
                    return True, vel, rh, sw, raspored
            return False, vel, rh, sw, raspored

        izbor = None
        for stupci in mogucnosti:
            izbor = rasporedi(stupci, dno - y0)
            if izbor[0]:
                break
        if not izbor[0]:      # ne stane ni najsitnije: ostavi redak za upozorenje
            izbor = rasporedi(mogucnosti[-1], dno - y0 - 2.6)
        _, vel, rh, sw, raspored = izbor
        izostalo = len(redci) - len(raspored)
        for stup, yy, brj, l in raspored:
            x = self.x + stup * sw
            s.tekst(x + 4.6, y0 + yy + vel * 0.95, str(brj), vel, '#111111', bold=True, sidro='end')
            for i, r in enumerate(l):
                s.tekst(x + 5.8, y0 + yy + vel * 0.95 + i * rh, r, vel, '#222222')
        if izostalo:
            rijec = 'prostor' if izostalo % 10 == 1 and izostalo % 100 != 11 else 'prostora'
            s.tekst(self.x, dno - 0.7, f'… i još {izostalo} {rijec}: vidi iskaz_povrsina.md', 1.6, '#aa0000')
        self.y = dno

    def izvori(self, K_: Kontekst, dodatno=None):
        """Navod podloga i sustava pri dnu panela; vrati y gornjeg ruba."""
        redci = []
        for t in [PODLOGE, SUSTAV] + list(dodatno or []):
            redci += prelomi(t, F_PODATAK, False, self.w, 50) or [t]
        h = len(redci) * 2.0 + 1.0
        y = self.dno - h
        self.svg.linija(self.x, y, self.x + self.w, y, '#999999', 0.12)
        for i, r in enumerate(redci):
            self.svg.tekst(self.x, y + 2.2 + i * 2.0, r, F_PODATAK, '#444444')
        return y - 1.0


def list_tlocrta(K_: Kontekst, raz, cx, cy, mjerilo, panel_w, vrsta, podnaslov, oznaka_lista, uid):
    """Sastavi jedan list tlocrta. vrsta: 'pregled' | 'sektor' | 'detalj'. Vrati (Svg, info, Pogled)."""
    P = K_.P
    svg = Svg(uid)
    okvir, panel_x = karta_okvir(panel_w)
    pg = Pogled(cx, cy, mjerilo, okvir)
    svg.pravokutnik(RUB, RUB, LIST_W - 2 * RUB, LIST_H - 2 * RUB, rub='#222222', deb=0.3)
    info = crtaj_kartu(svg, K_, raz, pg, pregled=(vrsta == 'pregled'))
    pan = Panel(svg, panel_x, panel_w)
    pan.oznaka()
    pan.odlomak(P.naslov(), 2.0, False, '#333333', max_redaka=3, razmak=0.6)
    pan.odlomak(f'Tlocrt razine {raz["id"]}: {raz["naziv"]}', F_NASLOV if panel_w > 120 else 3.1, True, max_redaka=3,
                razmak=0.4)
    pan.odlomak(podnaslov, 2.3, False, '#222222', max_redaka=4, razmak=0.8)
    c = [f'Kota poda razine: {br(raz["kota"], 1)} m n. v.' if raz['kota'] is not None else 'Kota poda: –']
    if raz['visina']:
        c[0] += f' · svijetla visina {br(raz["visina"], 1)} m'
    c.append(f'Mjerilo 1 : {br(mjerilo, 0)} (A3) · mreža {br(info["korak_mreze"], 0)} m · {oznaka_lista}')
    c.append(f'Datum: {K_.datum} · program sha256 {P.otisak[:12]} · status razine: {raz["status"] or "–"}')
    for t in c:
        pan.odlomak(t, 2.0, False, '#111111', max_redaka=2, razmak=0.0)
    pan.y += 1.0
    if vrsta == 'pregled' and raz['opis']:
        pan.odlomak(raz['opis'], 1.8, False, '#444444', max_redaka=5, kurziv=True, razmak=0.8)
    if not P.po_razini[raz['id']]:
        pan.odlomak('Napomena: razina nema prostora u programu. Crtaju se samo obris razine (ako je zadan), '
                    'veze, obrisi susjednih razina i postojeće stanje.', 2.0, True, '#b71c1c', max_redaka=4,
                    razmak=0.8)
    pan.crta()
    dodatno = ['Površine su tlocrtne površine crteža u ENU-M (m²). h = svijetla visina. Borilišta: linije i '
               'mjere prema scripts/viz/sportovi_dimenzije.json; garaže: shematski raster 2,5 × 5,0 m, '
               'prolaz 6,0 m (PRETPOSTAVKA). Shema programa: nije dokaz statike, požarne sigurnosti ni '
               'kapaciteta.']
    if any(s['kat'] == 'garaza' for s in info.get('prostori_lista', [])):
        dodatno.append('Garaže: broj mjesta iz programa računa 30 m² bruto tlocrta po mjestu (odluka M29, IZRAČUN) '
                       'i uključuje rampe, jezgre, stupove i tehniku; raster na crtežu je shema bez njih, pa daje '
                       'više mjesta. Mjerodavan je broj iz programa.')
    if any('M30' in (s['raw'].get('odluke') or []) and re.search(r'perivoj|drvored', norm(s['naziv']))
           for s in info.get('prostori_lista', [])):
        n_st = info.get('stabla_m30', 0)
        dodatno.append(f'Perivoj pred glavnim ulazom (odluka M30): ucrtana su postojeća stabla iz OSM-a unutar '
                       f'perivoja ({n_st}); položaj je iz OSM-a, vrsta i stanje nisu poznati: inventar stabala je '
                       f'OTVOREN (docs/04).' if n_st else 'Perivoj pred glavnim ulazom (odluka M30): postojeća '
                       'stabla nisu ucrtana, inventar stabala je OTVOREN (docs/04).')
    dno = pan.izvori(K_, dodatno)
    if vrsta != 'pregled':
        pan.kljucni_plan(K_, raz, pg, visina=34.0)
    stup = max(2, int(pan.w // 48))
    pan.odlomak('Legenda', 2.0, True, razmak=0.2)
    pan.legenda(K_, info, stupaca=stup)
    pan.crta()
    pan.tablica(info['tablica'], f'Prostori označeni brojem (razina {raz["id"]})', dno,
                stupaca=max(1, int(pan.w // 62)) if panel_w > 120 else 1)
    return svg, info, pg


# -------------------------------------------------------------------------------------- grupiranje u listove
def _granice(stavke):
    return (min(s['b'][0] for s in stavke), min(s['b'][1] for s in stavke),
            max(s['b'][2] for s in stavke), max(s['b'][3] for s in stavke))


def _stane(stavke, fw, fh):
    b = _granice(stavke)
    return b[2] - b[0] <= fw and b[3] - b[1] <= fh


def stavke_prostora(prostori, fw, fh):
    """Prostori kao stavke za grupiranje; prostor veći od okvira reže se mrežom na komade."""
    out = []
    for s in prostori:
        b = s['geom'].bounds
        if b[2] - b[0] > 0.85 * fw or b[3] - b[1] > 0.85 * fh:
            nx = max(1, math.ceil((b[2] - b[0]) / (0.5 * fw)))
            ny = max(1, math.ceil((b[3] - b[1]) / (0.5 * fh)))
            for i in range(nx):
                for j in range(ny):
                    cel = box(b[0] + (b[2] - b[0]) * i / nx, b[1] + (b[3] - b[1]) * j / ny,
                              b[0] + (b[2] - b[0]) * (i + 1) / nx, b[1] + (b[3] - b[1]) * (j + 1) / ny)
                    d = s['geom'].intersection(cel)
                    if not d.is_empty and d.area > 25.0:
                        out.append({'s': s, 'b': d.bounds, 'a': d.area, 'cijeli': False})
        else:
            out.append({'s': s, 'b': b, 'a': s['a'], 'cijeli': True})
    return out


def podijeli(stavke, fw, fh):
    """Rekurzivno prepolovi skup stavki dok svaki dio ne stane u okvir fw x fh (metri)."""
    if len(stavke) <= 1 or _stane(stavke, fw, fh):
        return [stavke]
    b = _granice(stavke)
    os_ = 0 if (b[2] - b[0]) / fw >= (b[3] - b[1]) / fh else 1
    lo, hi = b[os_], b[os_ + 2]

    def centar(s):
        return (s['b'][os_] + s['b'][os_ + 2]) / 2
    centri = sorted({round(centar(s), 2) for s in stavke})
    kand = [(a + c) / 2 for a, c in zip(centri[:-1], centri[1:])]
    sred = [c for c in kand if lo + 0.25 * (hi - lo) <= c <= hi - 0.25 * (hi - lo)]
    kand = sred or kand
    if not kand:
        pola = len(stavke) // 2
        st = sorted(stavke, key=lambda s: (s['b'][1 - os_], s['s']['br']))
        return podijeli(st[:pola], fw, fh) + podijeli(st[pola:], fw, fh)

    def cijena(c):
        rez = sum(min(s['b'][os_ + 2] - c, c - s['b'][os_]) for s in stavke if s['b'][os_] < c < s['b'][os_ + 2])
        return (round(rez + 0.02 * abs(c - (lo + hi) / 2) * len(stavke), 3), c)
    c = min(kand, key=cijena)
    L = [s for s in stavke if centar(s) < c]
    R = [s for s in stavke if centar(s) >= c]
    return podijeli(L, fw, fh) + podijeli(R, fw, fh)


def spoji(skupine, fw, fh):
    """Pohlepno spoji skupine čija unija stane u okvir."""
    skupine = [list(x) for x in skupine]
    while True:
        najbolje = None
        for i in range(len(skupine)):
            for j in range(i + 1, len(skupine)):
                u = skupine[i] + skupine[j]
                if _stane(u, fw, fh):
                    b = _granice(u)
                    p = (b[2] - b[0]) * (b[3] - b[1])
                    if najbolje is None or p < najbolje[0]:
                        najbolje = (p, i, j)
        if najbolje is None:
            return skupine
        _, i, j = najbolje
        skupine[i] = skupine[i] + skupine[j]
        del skupine[j]


def skupine_po_blizini(stavke, razmak):
    """Povezane skupine stavki čiji su pravokutnici međusobno bliže od razmaka."""
    n = len(stavke)
    rod = list(range(n))

    def nadi(i):
        while rod[i] != i:
            rod[i] = rod[rod[i]]
            i = rod[i]
        return i
    for i in range(n):
        a = stavke[i]['b']
        for j in range(i + 1, n):
            c = stavke[j]['b']
            dx = max(0.0, max(a[0], c[0]) - min(a[2], c[2]))
            dy = max(0.0, max(a[1], c[1]) - min(a[3], c[3]))
            if math.hypot(dx, dy) <= razmak:
                rod[nadi(i)] = nadi(j)
    out = {}
    for i in range(n):
        out.setdefault(nadi(i), []).append(stavke[i])
    return [out[k] for k in sorted(out)]


def naziv_skupine(stavke, najvise=4):
    vid, naz = set(), []
    for s in sorted(stavke, key=lambda x: (-x['a'] if x['cijeli'] else 0.0, x['s']['br'])):
        n = re.sub(r'\s*\(\d+\)$', '', s['s']['naziv'])
        if n not in vid:
            vid.add(n)
            naz.append(n)
    return ', '.join(naz[:najvise]) + (' i drugo' if len(naz) > najvise else '')


def listovi_razine(K_: Kontekst, raz, mjerilo_pregleda):
    """Odredi sektorske i detaljne listove razine iz podataka. Vrati popis rječnika (vrsta, cx, cy, mjerilo,
    naziv, granice)."""
    P = K_.P
    prostori = P.po_razini[raz['id']]
    if not prostori:
        return []
    (_, _, kw, kh), _ = karta_okvir(PANEL_DETALJ)
    rub_mm = 7.0
    zatv = sum(s['a'] for s in prostori if s['kat'] in ZATVORENE)
    T1 = 1000 if zatv >= 0.15 * sum(s['a'] for s in prostori) else 1500
    out = []

    def okvir_m(T):
        return (kw - 2 * rub_mm) * T / 1000.0, (kh - 2 * rub_mm) * T / 1000.0

    def list_iz(skupina, vrsta):
        b = _granice(skupina)
        m = mjerilo_za(b[2] - b[0], b[3] - b[1], kw - 2 * rub_mm, kh - 2 * rub_mm)
        return {'vrsta': vrsta, 'cx': (b[0] + b[2]) / 2, 'cy': (b[1] + b[3]) / 2, 'mjerilo': m,
                'naziv': naziv_skupine(skupina), 'granice': b, 'stavke': skupina}

    fw, fh = okvir_m(T1)
    stavke = stavke_prostora(prostori, fw, fh)
    sektori = spoji(podijeli(stavke, fw, fh), fw, fh)
    sektori.sort(key=lambda sk: (-round(_granice(sk)[3] / 50.0), _granice(sk)[0]))
    for sk in sektori:
        l = list_iz(sk, 'sektor')
        if l['mjerilo'] > 0.75 * mjerilo_pregleda:
            continue     # sektor ne bi bio čitljiviji od preglednog lista
        out.append(l)
        fini = [s for s in sk if ZELJENO.get(s['s']['kat'], 99999) <= 0.76 * l['mjerilo']]
        if not fini:
            continue
        for grupa in skupine_po_blizini(fini, 14.0):
            T2 = min(ZELJENO.get(s['s']['kat'], 500) for s in grupa)
            f2w, f2h = okvir_m(T2)
            dijelovi_ = spoji(podijeli(grupa, f2w, f2h), f2w, f2h)
            dijelovi_.sort(key=lambda sk2: (-round(_granice(sk2)[3] / 25.0), _granice(sk2)[0]))
            for d in dijelovi_:
                ld = list_iz(d, 'detalj')
                if ld['mjerilo'] > 0.7 * l['mjerilo']:
                    continue
                if len({x['s']['id'] for x in d}) < 2 and not any(x['s']['sportovi'] for x in d):
                    continue
                out.append(ld)
    return out


def pregledni_pogled(P: Podaci):
    """Zajednički obuhvat i mjerilo preglednih listova: cijeli program, širina panela iz ostatka lista."""
    x0, y0, x1, y1 = P.obuhvat
    rub_m = 20.0
    wm, hm = x1 - x0 + 2 * rub_m, y1 - y0 + 2 * rub_m
    najuza_karta = 150.0
    m = mjerilo_za(wm, hm, LIST_W - 2 * RUB - 14 - 120.0, KARTA_H, najmanje=500)
    kw = max(wm * 1000.0 / m + 6.0, najuza_karta)
    panel_w = LIST_W - RUB - 6.5 - KARTA_X - kw
    panel_w = max(120.0, min(panel_w, 215.0))
    return (x0 + x1) / 2, (y0 + y1) / 2, m, panel_w


def ime_datoteke(tekst):
    return re.sub(r'[^A-Za-z0-9]+', '-', norm(tekst)).strip('-') or 'x'


def naredba_crtaj(K_: Kontekst, out: Path, tiho=False):
    """Nacrtaj sve tlocrte. Vrati popis zapisa o listovima (za manifest i zbirni PDF)."""
    P = K_.P
    out.mkdir(parents=True, exist_ok=True)
    cx, cy, m0, panel0 = pregledni_pogled(P)
    plan = []
    for raz in P.razine:
        plan.append((raz, {'vrsta': 'pregled', 'cx': cx, 'cy': cy, 'mjerilo': m0, 'naziv': 'cijeli obuhvat'}))
        for l in listovi_razine(K_, raz, m0):
            plan.append((raz, l))
    for s in P.prostori:      # raster garaža treba biti poznat prije natpisa
        if s['kat'] == 'garaza':
            K_.raster(s)
    zapisi = []
    brojaci = {}
    for raz, l in plan:
        kljuc = (raz['id'], l['vrsta'])
        brojaci[kljuc] = brojaci.get(kljuc, 0) + 1
        l['rb'] = brojaci[kljuc]
    for i, (raz, l) in enumerate(plan):
        uk = sum(1 for r2, l2 in plan if r2 is raz and l2['vrsta'] == l['vrsta'])
        rid = ime_datoteke(raz['id'])
        if l['vrsta'] == 'pregled':
            ime = f'T{raz["i"] + 1:02d}-{rid}-0-pregled'
            podn = 'Pregledni list: cijeli obuhvat programa.'
            oznaka = 'pregledni list'
        else:
            slovo = 'S' if l['vrsta'] == 'sektor' else 'D'
            ime = f'T{raz["i"] + 1:02d}-{rid}-{slovo}{l["rb"]}'
            podn = (f'{"Sektor" if slovo == "S" else "Detalj"} {l["rb"]} od {uk}: {l["naziv"].rstrip(". ")}.')
            oznaka = f'{"sektor" if slovo == "S" else "detalj"} {slovo}{l["rb"]}'
        svg, info, pg = list_tlocrta(K_, raz, l['cx'], l['cy'], l['mjerilo'],
                                     panel0 if l['vrsta'] == 'pregled' else PANEL_DETALJ, l['vrsta'], podn,
                                     oznaka, ime)
        put = out / f'{ime}.svg'
        svg.zapisi(put)
        zapisi.append({'red': [1, raz['i'], {'pregled': 0, 'sektor': 1, 'detalj': 2}[l['vrsta']], l.get('rb', 0)],
                       'datoteka': put.name, 'vrsta': 'tlocrt-' + l['vrsta'], 'razina': raz['id'],
                       'naslov': f'Tlocrt razine {raz["id"]}: {raz["naziv"]}', 'podnaslov': podn,
                       'mjerilo': l['mjerilo'], 'okvir_enu_m': [round(v, 2) for v in pg.granice],
                       'karta_mm': [round(v, 2) for v in (pg.x, pg.y, pg.w, pg.h)],
                       'prostora_u_tablici': len(info['tablica'])})
        if not tiho:
            print(f'  {put.name}: 1:{l["mjerilo"]}, {podn[:70]}')
    return zapisi


# ------------------------------------------------------------------------------------------------ presjeci
class Teren:
    """Model reljefa (DMR) u rasteru ENU-N; uzorkovanje bilinearno u točkama ENU-M."""

    def __init__(self, put):
        self.ima = False
        if not put or str(put) == 'ne' or not Path(put).is_file():
            return
        try:
            from PIL import Image
            meta = PA.ucitaj_json(put)
            m = meta['mreza']
            slika = Path(put).with_name(meta.get('datoteka') or (Path(put).stem + '.png'))
            a = np.asarray(Image.open(slika)).astype(float)
            self.z = np.where(a > 0, a / 10.0, np.nan)
            self.x0, self.y1, self.korak = float(m['x_min']), float(m['y_max']), float(m['korak_m'])
            self.izvor = str(meta.get('izvor') or 'model reljefa')
            self.ima = True
        except Exception as e:  # noqa: BLE001
            print(f'NAPOMENA: model reljefa se ne može pročitati ({e}); presjek bez linije DMR-a.', file=sys.stderr)

    def visine(self, xy_m):
        """Kote u točkama ENU-M (niz Nx2); NaN izvan rastera."""
        xy_m = np.asarray(xy_m, dtype=float).reshape(-1, 2)
        if not self.ima or not len(xy_m):
            return np.full(len(xy_m), np.nan)
        xn, yn = K.n_iz_m(xy_m[:, 0], xy_m[:, 1])
        c = (np.asarray(xn) - self.x0) / self.korak
        r = (self.y1 - np.asarray(yn)) / self.korak
        h, w = self.z.shape
        ok = (c >= 0) & (c <= w - 1.001) & (r >= 0) & (r <= h - 1.001)
        c0, r0 = np.clip(np.floor(c).astype(int), 0, w - 2), np.clip(np.floor(r).astype(int), 0, h - 2)
        fc, fr = c - c0, r - r0
        z = (self.z[r0, c0] * (1 - fc) * (1 - fr) + self.z[r0, c0 + 1] * fc * (1 - fr) +
             self.z[r0 + 1, c0] * (1 - fc) * fr + self.z[r0 + 1, c0 + 1] * fc * fr)
        return np.where(ok, z, np.nan)


class Presjek:
    """Presjek: ishodište O, jedinični smjer u (stacionaža raste uzduž u), dionice (s0, s1, bočni pomak).
    Više dionica s različitim pomakom daje lomljeni presjek s usporednim ravninama."""

    def __init__(self, oznaka, naziv, O, u, dionice, opis=''):
        self.oznaka, self.naziv, self.opis = oznaka, naziv, opis
        self.O = (float(O[0]), float(O[1]))
        d = math.hypot(u[0], u[1])
        self.u = (u[0] / d, u[1] / d)
        self.n = (-self.u[1], self.u[0])
        self.dionice = [(float(a), float(b), float(c)) for a, b, c in dionice]
        self.s0, self.s1 = self.dionice[0][0], self.dionice[-1][1]

    def tocka(self, s, pomak=0.0):
        return (self.O[0] + self.u[0] * s + self.n[0] * pomak, self.O[1] + self.u[1] * s + self.n[1] * pomak)

    def stacionaza(self, x, y):
        return (x - self.O[0]) * self.u[0] + (y - self.O[1]) * self.u[1]

    def bocno(self, x, y):
        return (x - self.O[0]) * self.n[0] + (y - self.O[1]) * self.n[1]

    def linije(self):
        return [(LineString([self.tocka(a, c), self.tocka(b, c)]), a, b, c) for a, b, c in self.dionice]

    def strane(self):
        """Oznake strana svijeta na početku i kraju."""
        az = math.degrees(math.atan2(self.u[0], self.u[1])) % 360
        imena = ['S', 'SI', 'I', 'JI', 'J', 'JZ', 'Z', 'SZ']
        kraj = imena[int((az + 22.5) // 45) % 8]
        poc = imena[(int((az + 22.5) // 45) + 4) % 8]
        return poc, kraj


def _raspon_na_pravcu(geom, O, u, pomak=0.0, duljina=5000.0):
    """Najmanja i najveća stacionaža presjeka pravca (kroz O, smjer u, bočni pomak) s geometrijom."""
    n = (-u[1], u[0])
    a = (O[0] - u[0] * duljina + n[0] * pomak, O[1] - u[1] * duljina + n[1] * pomak)
    b = (O[0] + u[0] * duljina + n[0] * pomak, O[1] + u[1] * duljina + n[1] * pomak)
    c = LineString([a, b]).intersection(geom)
    if c.is_empty:
        return None
    x0, y0, x1, y1 = c.bounds
    st = [(x - O[0]) * u[0] + (y - O[1]) * u[1] for x, y in ((x0, y0), (x0, y1), (x1, y0), (x1, y1))]
    # točne krajnje točke: iz koordinata dijelova
    st = []
    for l in dijelovi(c, 'LineString'):
        for x, y in l.coords:
            st.append((x - O[0]) * u[0] + (y - O[1]) * u[1])
    return (min(st), max(st)) if st else None


def automatski_presjeci(K_: Kontekst):
    """Presjeci iz podataka: P1 uzduž duže osi igrališta (sjever-jug, kroz Maksimirsku), P2 okomito na nju
    kroz bazen i stadion (lomljen), P3 sjever-jug kroz halu Borongaj ako postoji."""
    P = K_.P
    out = []
    st = P.stadion
    sve = K_.sve
    if sve is None:
        return out
    if st and st.get('sredina'):
        O = st['sredina']
        if st.get('igraliste') is not None:
            kut, _, _ = glavna_os(st['igraliste'])
        else:
            kut = 90.0
        u = (math.cos(math.radians(kut)), math.sin(math.radians(kut)))
        if u[1] > 0:
            u = (-u[0], -u[1])          # stacionaža raste prema jugu
        r = _raspon_na_pravcu(sve.buffer(1.0), O, u)
        if r:
            out.append(Presjek('P1', 'Presjek P1: sjever – jug kroz Maksimirsku, pokrov, podij i igralište', O, u,
                               [(r[0] - 35.0, r[1] + 30.0, 0.0)],
                               'uzduž duže osi igrališta, kroz sredinu stadiona'))
        v = (-u[1], u[0])
        if v[0] < 0:
            v = (-v[0], -v[1])          # stacionaža raste prema istoku
        bazen = [s for s in P.prostori if 'bazen' in norm(s['naziv']) and s['kat'] in ('postojece', 'voda',
                                                                                         'sport_zatvoreni')]
        dion = None
        r0 = _raspon_na_pravcu(sve.buffer(1.0), O, v)
        if bazen and r0:
            b = max(bazen, key=lambda s: s['a'])
            c = b['geom'].centroid
            pomak = (c.x - O[0]) * (-v[1]) + (c.y - O[1]) * v[0]
            sb = [(x - O[0]) * v[0] + (y - O[1]) * v[1] for x, y in b['geom'].exterior.coords]
            ss = [(x - O[0]) * v[0] + (y - O[1]) * v[1] for x, y in st['obris'].exterior.coords] if st.get(
                'obris') is not None else [0.0]
            rb = _raspon_na_pravcu(sve.buffer(1.0), O, v, pomak)
            if abs(pomak) > 15.0 and rb:
                if max(sb) < min(ss):       # bazen zapadno od stadiona
                    lom = (max(sb) + min(ss)) / 2
                    dion = [(rb[0] - 30.0, lom, pomak), (lom, r0[1] + 30.0, 0.0)]
                elif min(sb) > max(ss):
                    lom = (min(sb) + max(ss)) / 2
                    dion = [(r0[0] - 30.0, lom, 0.0), (lom, rb[1] + 30.0, pomak)]
        if dion is None and r0:
            dion = [(r0[0] - 30.0, r0[1] + 30.0, 0.0)]
        if dion:
            lomljen = len(dion) > 1
            out.append(Presjek('P2', 'Presjek P2: zapad – istok kroz ' + ('bazen, ' if lomljen else '') +
                               'stadion i istočni rub', O, v, dion,
                               ('lomljeni presjek: zapadni dio kroz bazen, istočni kroz sredinu stadiona'
                                if lomljen else 'okomito na dužu os igrališta, kroz sredinu stadiona')))
    # hala Borongaj: razina ili prostori s tim imenom
    kand = [s for s in P.prostori if s['kat'] in ('promet_tramvaj', 'promet_bus') and (
        'borongaj' in norm(P.razina[s['razina']]['naziv']) or 'borongaj' in norm(s['naziv']) or
        'okretist' in norm(s['naziv']))]
    if st and st.get('sredina'):
        kand = [s for s in kand if math.dist((s['geom'].centroid.x, s['geom'].centroid.y), st['sredina']) > 200.0]
    if kand:
        h = max(kand, key=lambda s: s['a'])
        c = h['geom'].representative_point() if not h['geom'].contains(h['geom'].centroid) else h['geom'].centroid
        u = (0.0, -1.0)
        O = (c.x, c.y)
        opis = f'kroz prostor „{h["naziv"]}”'
        naziv = 'halu Borongaj'
        # otvoreni teren nad garažom u više etaža (npr. trening-teren nad P1 do P3): presjek kroz oba, ako se
        # tlocrtno preklapaju po x
        gar = [s for s in P.prostori if s['kat'] == 'garaza']
        tereni = []
        for s in P.prostori:
            if s['kat'] in ('sport_otvoreni', 'igraliste') and s['a'] > 2000.0:
                ispod = {g['razina'] for g in gar if g['geom'].intersection(s['geom']).area > 0.5 * s['a']}
                if len(ispod) >= 2:
                    tereni.append((len(ispod), s['a'], s))
        if tereni:
            te = max(tereni, key=lambda x: (x[0], x[1]))
            hb = unary_union([s['geom'] for s in P.po_razini[h['razina']]]).bounds
            tb = te[2]['geom'].bounds
            lo, hi = max(hb[0], tb[0]), min(hb[2], tb[2])
            if hi - lo >= 10.0:
                x = (lo + hi) / 2
                L = LineString([(x, tb[1] - 1), (x, tb[3] + 1)]).intersection(te[2]['geom'])
                if L.length > 20.0:
                    O = (x, c.y)
                    ime = te[2]['naziv'].split('(')[0].split(',')[0].strip()
                    rijec = {2: 'dvije', 3: 'tri', 4: 'četiri'}.get(te[0], str(te[0]))
                    naziv = f'{ime[0].lower() + ime[1:]}, garažu u {rijec} etaže i halu Borongaj'
                    opis = f'kroz „{te[2]["naziv"]}”, garažu ispod i prostor „{h["naziv"]}”'
        r = _raspon_na_pravcu(sve.buffer(1.0), O, u)
        if r:
            s_sj = r[0] - 20.0
            if st and st.get('sredina'):
                s_sj = max(s_sj, -(st['sredina'][1] - O[1]))     # ne dalje na sjever od sredine stadiona
            n_ = len(out) + 1
            out.append(Presjek(f'P{n_}', f'Presjek P{n_}: sjever – jug kroz {naziv}', O, u,
                               [(s_sj, r[1] + 30.0, 0.0)], opis))
    # velika dvorana pod parkom (svijetla visina >= 10 m), brijeg iznad nje i dvorište bazena
    dv = [s for s in P.prostori if s['kat'] == 'sport_zatvoreni' and (s['visina'] or 0.0) >= 10.0]
    if dv:
        d = max(dv, key=lambda s: s['a'])
        c = d['geom'].representative_point() if not d['geom'].contains(d['geom'].centroid) else d['geom'].centroid
        u = (0.0, -1.0)
        O = (c.x, c.y)
        L = LineString([(c.x, -1e4), (c.x, 1e4)])
        dvor = [s for s in P.prostori if s['kat'] == 'dvoriste' and 'bazen' in norm(s['naziv']) and
                s['geom'].intersects(L)]
        brijeg = [s for s in P.prostori if 'brijeg' in norm(s['naziv']) and s['geom'].intersects(L) and
                  s['kat'] in ('park_zelenilo', 'staza', 'sport_otvoreni')]
        r = _raspon_na_pravcu(sve.buffer(1.0), O, u)
        if r:
            y_sj = (max(s['geom'].intersection(L).bounds[3] for s in dvor) + 25.0) if dvor else \
                d['geom'].bounds[3] + 60.0
            dijelovi_ = (['dvorište bazena'] if dvor else []) + \
                ([max(brijeg, key=lambda s: s['a'])['naziv'].split('(')[0].strip()] if brijeg else []) + \
                [f'dvoranu „{d["naziv"].split("(")[0].strip()}”']
            naziv = ', '.join(dijelovi_[:-1]) + ' i ' + dijelovi_[-1] if len(dijelovi_) > 1 else dijelovi_[0]
            n_ = len(out) + 1
            out.append(Presjek(f'P{n_}', f'Presjek P{n_}: sjever – jug kroz {naziv}', O, u,
                               [(max(r[0] - 20.0, O[1] - y_sj), r[1] + 30.0, 0.0)],
                               f'kroz prostor „{d["naziv"]}”'))
    return out


def presjek_iz_zapisa(K_: Kontekst, tekst, rb):
    """--linija "naziv:x1,y1;x2,y2" (koordinate u sustavu programa)."""
    naziv, _, koord = tekst.rpartition(':')
    t = [tuple(float(v) for v in p.split(',')) for p in koord.split(';') if p.strip()]
    if len(t) != 2:
        raise ValueError('presjek traži točno dvije točke: "naziv:x1,y1;x2,y2"')
    a = K_.P.T(np.array(t))
    O, B = (a[0, 0], a[0, 1]), (a[1, 0], a[1, 1])
    u = (B[0] - O[0], B[1] - O[1])
    return Presjek(f'P{rb}', f'Presjek P{rb}: {naziv or "zadana linija"}', O, u, [(0.0, math.hypot(*u), 0.0)],
                   'zadana linija')


def presjek_podaci(K_: Kontekst, pr: Presjek, teren: Teren):
    """Sve što presjek siječe, po stacionaži."""
    P = K_.P
    D = {'prostori': [], 'tribine': [], 'krov': [], 'procelje': [], 'tlo': None, 'kote': [], 'povrsina': None,
         'lomovi': [d[0] for d in pr.dionice[1:]]}

    def stac(l, lin_a, s_a):
        c = list(l.coords)
        a = s_a + math.dist(c[0], lin_a)
        b = s_a + math.dist(c[-1], lin_a)
        return (min(a, b), max(a, b))

    st = P.stadion
    for L, a, b, pomak in pr.linije():
        A = L.coords[0]
        for s in P.prostori:
            if not s['geom'].intersects(L):
                continue
            if s['kat'] == 'postojece':
                s = postojeca_zgrada(K_, s)
            for l in dijelovi(s['geom'].intersection(L), 'LineString'):
                sa, sb = stac(l, A, a)
                if sb - sa > 0.05:
                    D['prostori'].append((s, sa, sb))
        if st:
            s_sred = pr.stacionaza(*st['sredina']) if st.get('sredina') else (a + b) / 2
            D['tribine'] += tribine_na_presjeku(st, pr, a, b, pomak)
            fas = []
            if st.get('obris') is not None:
                c = st['obris'].exterior.intersection(L)
                for q in dijelovi(c, 'Point'):
                    fas.append(a + math.dist((q.x, q.y), A))
                if st.get('procelje'):
                    D['procelje'] += [(x, st['procelje']) for x in fas]
            if st.get('krov'):
                kr = st['krov']
                prsten = kr['vanjski'].difference(kr['unutarnji'])
                for l in dijelovi(prsten.intersection(L), 'LineString'):
                    sa, sb = stac(l, A, a)
                    if sb - sa > 0.3:
                        unutra_a = abs(sa - s_sred) < abs(sb - s_sred)
                        f = [x for x in fas if sa < x < sb]
                        D['krov'].append((kr, sa, sb, unutra_a, f[0] if f else None))
        for x, y, z in K_.kote:
            s = pr.stacionaza(x, y)
            if a <= s <= b and abs(pr.bocno(x, y) - pomak) <= 10.0:
                D['kote'].append((s, z, abs(pr.bocno(x, y) - pomak)))
    # uzorci tla i projektirane površine svakih KORAK_PRESJEKA m
    ss, tocke_ = [], []
    for a, b, pomak in pr.dionice:
        for s in np.arange(a, b + 1e-6, KORAK_PRESJEKA):
            ss.append(float(s))
            tocke_.append(pr.tocka(float(s), pomak))
    ss = np.array(ss)
    tocke_ = np.array(tocke_)
    D['s'] = ss
    D['tlo'] = teren.visine(tocke_) if teren is not None and teren.ima else np.full(len(ss), np.nan)
    D['dionica'] = np.concatenate([np.full(len(np.arange(a, b + 1e-6, KORAK_PRESJEKA)), i)
                                   for i, (a, b, _) in enumerate(pr.dionice)]) if pr.dionice else np.zeros(0)
    D['povrsina'], D['povrsina_izvor'] = projektirana_povrsina(P, D, tocke_)
    D['kote'].sort()
    D['rampe'] = rampe_na_presjeku(P, pr)
    if D['tribine']:
        D['prostori'] = odrezi_pod_tribinama(D['prostori'], D['tribine'])
    return D


def rampe_na_presjeku(P: Podaci, pr: 'Presjek'):
    """Rampe (veze tipa rampa) koje presjek siječe uzdužno: dio veze gotovo usporedan s presjekom (do 30°) i
    najviše pola širine + 2 m od ravnine presjeka. Kote krajeva su kote poda prostora uz krajeve
    (kota_ispod), linearno po duljini veze; bez dviju različitih kota rampa se ne crta. Vraća (sa, za, sb, zb, veza)."""
    out = []
    for v in P.veze:
        if v['tip'] != 'rampa' or v['geom'].geom_type != 'LineString':
            continue
        c = list(v['geom'].coords)
        za_, zb_ = kota_ispod(P, v, *c[0][:2]), kota_ispod(P, v, *c[-1][:2])
        duljina = v['geom'].length
        for (x0, y0), (x1, y1) in zip([q[:2] for q in c[:-1]], [q[:2] for q in c[1:]]):
            dl = math.hypot(x1 - x0, y1 - y0)
            if dl < 3.0:
                continue
            for a, b, pomak in pr.dionice:
                cos_ = abs((x1 - x0) * pr.u[0] + (y1 - y0) * pr.u[1]) / dl
                tol = (v['sirina'] or 3.0) / 2 + 2.0
                if cos_ < math.cos(math.radians(30)) or abs(pr.bocno(x0, y0) - pomak) > tol or \
                        abs(pr.bocno(x1, y1) - pomak) > tol:
                    continue
                s0, s1 = pr.stacionaza(x0, y0), pr.stacionaza(x1, y1)
                if max(s0, s1) < a or min(s0, s1) > b:
                    continue
                # kote krajeva cijele veze, linearno po duljini do krajeva ovog dijela
                if za_ and zb_ and abs(za_[1] - zb_[1]) > 0.05:
                    z0_, z1_ = za_[1], zb_[1]
                else:
                    continue        # smjer nagiba se ne može odrediti iz kota: ne crta se (tlocrt ga pokazuje)
                d0 = v['geom'].project(Point(x0, y0))
                d1 = v['geom'].project(Point(x1, y1))
                f = lambda d: z0_ + (z1_ - z0_) * d / max(duljina, 1e-6)  # noqa: E731
                out.append((s0, f(d0), s1, f(d1), v))
    return out


RED_TRIBINE = 0.8       # dubina reda kad program ne daje broj redova (PRETPOSTAVKA crtača)
NOSAC_TRIBINE = 1.2     # debljina kose ploče tribine ispod profila (PRETPOSTAVKA crtača)


def _profil_tribine(tr, d):
    """Kote stepenastog profila (red po red) i glatke crte profila za udaljenosti d od prvog reda zdjele."""
    prof = tr.get('profil')
    if not prof:
        return None, None
    ds, zs = np.array([p[0] for p in prof]), np.array([p[1] for p in prof])
    d0, d1 = ds[0], ds[-1]
    n = tr.get('redova') or max(1, int(round((d1 - d0) / RED_TRIBINE)))
    T = (d1 - d0) / n
    dd = np.clip(d, d0, d1)
    k = np.clip(np.floor((dd - d0) / T + 1e-9), 0, n - 1)
    return np.interp(d0 + k * T, ds, zs), np.interp(dd, ds, zs)


def tribine_na_presjeku(st, pr: 'Presjek', a, b, pomak):
    """Dijelovi tribina koje dionica presjeka siječe: za svaki dio stacionaže, stepenasti profil red po red
    (iz stadion.tribine[].profil i stadion.sjever.profil, d od prvog reda zdjele) i donji rub kose ploče.
    Bez profila tribina je pravac od kote dna do kote vrha."""
    import shapely
    tribine = st['tribine']
    if not tribine:
        return []
    ss = np.arange(a, b + 1e-9, 0.1)
    xy = np.array([pr.tocka(float(s), pomak) for s in ss])
    zdjela = min(tribine, key=lambda tr: tr['dno'])['unutarnji']
    d = shapely.distance(shapely.points(xy), zdjela.exterior)
    unutar_zdjele = shapely.contains_xy(zdjela, xy[:, 0], xy[:, 1])
    oznaka = np.full(len(ss), -1)
    for i, tr in enumerate(tribine):
        prsten = tr['vanjski'].difference(tr['unutarnji'])
        m = (oznaka < 0) & shapely.contains_xy(prsten, xy[:, 0], xy[:, 1]) & ~unutar_zdjele
        oznaka[m] = i
    sj = st.get('sjever')
    if sj:
        m = shapely.contains_xy(sj['obris'], xy[:, 0], xy[:, 1]) & ~unutar_zdjele
        oznaka[m] = len(tribine)
    out = []
    i = 0
    while i < len(ss):
        if oznaka[i] < 0:
            i += 1
            continue
        j = i
        while j + 1 < len(ss) and oznaka[j + 1] == oznaka[i]:
            j += 1
        if ss[j] - ss[i] > 0.3:
            tr = sj if oznaka[i] == len(tribine) else tribine[oznaka[i]]
            dd = d[i:j + 1]
            z, zg = _profil_tribine(tr, dd)
            if z is None:          # bez profila: pravac od dna (bliže zdjeli) do vrha
                u = (dd - dd.min()) / max(dd.max() - dd.min(), 1e-6)
                z = zg = tr['dno'] + (tr['vrh'] - tr['dno']) * u
            out.append({'tr': tr, 'sa': float(ss[i]), 'sb': float(ss[j]), 's': ss[i:j + 1], 'z': z,
                        'zb': zg - NOSAC_TRIBINE, 'unutra_a': bool(dd[0] < dd[-1]),
                        'sjever': oznaka[i] == len(tribine)})
        i = j + 1
    return out


def podnozje_tribina(tribine, s):
    """Najniži donji rub tribina na stacionažama s (inf gdje tribine nema)."""
    out = np.full(len(s), np.inf)
    for t in tribine:
        m = (s >= t['sa']) & (s <= t['sb'])
        if m.any():
            out[m] = np.minimum(out[m], np.interp(s[m], t['s'], t['zb']))
    return out


def odrezi_pod_tribinama(prostori, tribine):
    """Prostori kategorije tribine crtaju se kao profil tribina, pa se iz presjeka izostavljaju; prostori
    stadiona (hodnici, klupska razina) crtaju se samo ondje gdje su ispod kose ploče tribina."""
    out = []
    for s, a, b in prostori:
        if s['kat'] == 'tribine':
            continue
        if s['kat'] != 'stadion' or s['pod'] is None:
            out.append((s, a, b))
            continue
        vrh = _vrh_prostora(s)
        gore = (vrh if vrh is not None else s['pod'] + 0.3) - 0.05
        x = np.arange(a, b + 1e-9, 0.25)
        ok = podnozje_tribina(tribine, x) >= gore
        i = 0
        while i < len(x):
            if not ok[i]:
                i += 1
                continue
            j = i
            while j + 1 < len(x) and ok[j + 1]:
                j += 1
            if x[j] - x[i] > 0.5:
                out.append((s, float(x[i]), float(min(b, x[j] + 0.25 if j + 1 < len(x) else b))))
            i = j + 1
    return out


KORAK_PRESJEKA = 0.5          # razmak uzoraka tla i projektirane površine uzduž presjeka (m)
BRID_INTERPOLACIJE = 40.0     # najdulji brid trokuta kota_terena koji se još interpolira (m)
NAJVISE_TLA_IZNAD_STROPA = 6.0  # najdeblji sloj tla i konstrukcije iznad stropa koji se još prihvaća (m)


def _interpolator_prostora(P: Podaci, sp):
    """Interpolator kota_terena koje leže u prostoru sp (ili do 1 m od njegova ruba): linearno unutar
    Delaunayjevih trokuta s najduljim bridom <= BRID_INTERPOLACIJE. Kote susjednih prostora na drugoj koti
    (npr. podij uz otvoreno dvorište) tako ne ulaze u interpolaciju. None ako u prostoru nema barem tri kote."""
    pred = P.__dict__.setdefault('_ip_prostora', {})
    if sp['id'] in pred:
        return pred[sp['id']]
    ip = None
    if len(P.kote_z) >= 3:
        import shapely
        x_, y_ = P.kote_xy[:, 0], P.kote_xy[:, 1]
        m = shapely.contains_xy(sp['geom'].buffer(1.0), x_, y_)
        unutra = m & shapely.contains_xy(sp['geom'].buffer(-1.0), x_, y_)
        # kote na samom rubu (do 1 m) često opisuju vrh i dno potpornog zida susjednog prostora: zadržavaju se
        # samo ako su u rasponu unutarnjih kota (± 1 m), a bez unutarnjih kota ako su do 2 m od poda
        if unutra.sum() >= 3:
            lo, hi = P.kote_z[unutra].min() - 1.0, P.kote_z[unutra].max() + 1.0
        elif sp['pod'] is not None:
            lo, hi = sp['pod'] - 2.0, sp['pod'] + (NAJVISE_TLA_IZNAD_STROPA + (sp['visina'] or 0.0)
                                                   if _vrh_prostora(sp) is not None else 2.0)
        else:
            lo, hi = -1e9, 1e9
        m &= unutra | ((P.kote_z >= lo) & (P.kote_z <= hi))
        if m.sum() >= 3:
            try:
                ip = _interpolator_kota(P.kote_xy[m], P.kote_z[m])
            except Exception:  # noqa: BLE001  (npr. sve točke na pravcu)
                ip = None
    pred[sp['id']] = ip
    return ip


def _interpolator_kota(xy, z):
    """Linearna interpolacija kota samo unutar Delaunayjevih trokuta kojima je najdulji brid
    <= BRID_INTERPOLACIJE; vraća funkciju (Nx2 ENU-M) -> kote (NaN izvan)."""
    from scipy.spatial import Delaunay
    tri = Delaunay(xy)
    v = xy[tri.simplices]
    brid = np.max(np.stack([np.hypot(*(v[:, i] - v[:, (i + 1) % 3]).T) for i in range(3)]), axis=0)
    dobar = brid <= BRID_INTERPOLACIJE

    def ip(t):
        t = np.asarray(t, dtype=float).reshape(-1, 2)
        out = np.full(len(t), np.nan)
        si = tri.find_simplex(t)
        m = (si >= 0)
        m[m] = dobar[si[m]]
        if m.any():
            T_ = tri.transform[si[m]]
            b = np.einsum('ijk,ik->ij', T_[:, :2], t[m] - T_[:, 2])
            bc = np.c_[b, 1 - b.sum(axis=1)]
            out[m] = (z[tri.simplices[si[m]]] * bc).sum(axis=1)
        return out
    return ip


def projektirana_povrsina(P: Podaci, D, tocke_):
    """Projektirana površina uzduž presjeka (svaki metar). Crta se samo ondje gdje presjek siječe neki prostor
    programa izvan obrisa stadiona; mjerodavan je najviši element na toj stacionaži (vrh zatvorenog prostora
    ili pod otvorenog):
    - otvoreni prostor (pod nebom): kote_terena koje leže u tom prostoru, interpolirane (trokuti s bridom do
      BRID_INTERPOLACIJE); prostor bez vlastitih kota ostaje na koti poda (npr. otvoreno dvorište bazena, M7);
    - zatvoreni prostor: kote_terena u tom prostoru, samo ako leže na stropu ili do NAJVISE_TLA_IZNAD_STROPA
      iznad njega; inače se ne crta (konstrukcija se crta zadanom debljinom);
    - bez prostora i u otvorenim prostorima na prirodnom tlu ili postojećoj koti: ništa (površina je današnje
      tlo, koje pokazuje linija modela reljefa).
    Kote susjednih prostora ne ulaze u interpolaciju, pa linija ne premošćuje praznine ni rubove.
    Staza bez vlastitih kota koja leži između dviju kosina s kotama preuzima kosinu susjeda (linearno uzduž
    presjeka između njihovih krajeva), umjesto da stoji kao vodoravni blok na koti poda.
    Vraća (kote, izvor): izvor je 'k' (kote_terena), 'p' (pod otvorenog prostora), 'n' (kosina susjeda) ili ''."""
    ss = D['s']
    out = np.full(len(ss), np.nan)
    izvor = np.full(len(ss), '', dtype=object)
    if not D['prostori'] or not len(tocke_):
        return out, izvor
    sa_ = np.array([a for _, a, _ in D['prostori']])
    sb_ = np.array([b for _, _, b in D['prostori']])
    # unutar obrisa stadiona vrijedi vlastiti crtež (igralište, tribine, krov): ondje nema linije površine
    u_stadionu = np.zeros(len(ss), dtype=bool)
    if P.stadion and P.stadion.get('obris') is not None:
        import shapely
        u_stadionu = shapely.contains_xy(P.stadion['obris'], tocke_[:, 0], tocke_[:, 1])
    vrhovi, bez_kota = [], []
    for i, s in enumerate(ss):
        naj, naj_z, otvoren = None, -1e9, False
        if not u_stadionu[i]:
            for j in np.nonzero((sa_ <= s + 1e-6) & (sb_ >= s - 1e-6))[0]:
                sp = D['prostori'][j][0]
                if sp['pod'] is None or sp['kat'] in ('stadion', 'tribine', 'igraliste'):
                    continue
                vrh = _vrh_prostora(sp)
                z = vrh if vrh is not None else sp['pod']
                if z > naj_z + 1e-6:
                    naj, naj_z, otvoren = sp, z, vrh is None
        vrhovi.append((naj, naj_z, otvoren))
    for sp_id in sorted({v[0]['id'] for v in vrhovi if v[0] is not None}):
        idx = [i for i, v in enumerate(vrhovi) if v[0] is not None and v[0]['id'] == sp_id]
        sp, naj_z, otvoren = vrhovi[idx[0]]
        if otvoren and ('prirodn' in norm(sp['naziv']) or 'postojeca kota' in norm(sp['naziv']) or
                        sp['kat'] == 'postojece'):
            continue      # prirodno tlo i postojeće stanje: površina je današnje tlo (linija modela reljefa)
        try:
            ip = _interpolator_prostora(P, sp)
        except Exception as e:  # noqa: BLE001
            print(f'NAPOMENA: kote prostora {sp_id} se ne mogu interpolirati ({e}).', file=sys.stderr)
            ip = None
        z = ip(tocke_[idx]) if ip is not None else np.full(len(idx), np.nan)
        if otvoren:
            ok = ~np.isnan(z) & (np.abs(z - naj_z) <= 10.0)
            if not ok.any():
                out[idx], izvor[idx] = naj_z, 'p'
                if sp['kat'] == 'staza':
                    bez_kota.append(idx)
            else:
                # izvan trokuta vlastitih kota: linearno uzduž presjeka između najbližih interpoliranih
                # uzoraka istog prostora (na krajevima zadnja vrijednost), bez skoka na kotu poda
                si_ = ss[idx]
                out[idx] = np.interp(si_, si_[ok], z[ok])
                izvor[idx] = 'k'
        else:
            ok = ~np.isnan(z) & (z >= naj_z - 0.05) & (z <= naj_z + NAJVISE_TLA_IZNAD_STROPA)
            ii = np.array(idx)[ok]
            out[ii], izvor[ii] = z[ok], 'k'
    for idx in bez_kota:      # staza bez kota između dviju kosina s kotama: kosina susjeda
        for dio in np.split(np.array(idx), np.nonzero(np.diff(idx) > 1)[0] + 1):
            i0, i1 = int(dio[0]) - 1, int(dio[-1]) + 1
            if i0 < 0 or i1 >= len(ss) or izvor[i0] not in ('k', 'p') or izvor[i1] not in ('k', 'p') or \
                    'k' not in (izvor[i0], izvor[i1]):
                continue
            if abs(out[i1] - out[i0]) < 0.3:
                continue
            out[dio] = np.interp(ss[dio], [ss[i0], ss[i1]], [out[i0], out[i1]])
            izvor[dio] = 'n'
    return out, izvor


def postojeca_zgrada(K_: Kontekst, s):
    """Postojeći prostor u presjeku crta se kao zgrada: visina iz zgrada site.json (OSM) koje leže u njemu
    (najveća visina_m zgrade kojoj barem 30 % tlocrta leži u prostoru), inače vlastita svijetla visina iz
    programa, inače obris zadane visine 4 m, crtkano, s oznakom „visina nije zadana”. Vanjski tereni
    (igralište, teren, vanjsko, dvorište) bez zgrade ostaju otvoreni. Vraća kopiju prostora s 'visina' i
    'visina_izvor' ('site.json', 'program', 'nije zadana') ili sam prostor ako ostaje otvoren."""
    pred = K_.__dict__.setdefault('_postojece', {})
    if s['id'] in pred:
        return pred[s['id']]
    h, izvor = None, 'nije zadana'
    if K_.podloga is not None and K_.podloga.ima:
        for g, z in K_.podloga.u_okviru('zgrade', s['geom']):
            try:
                udio = g.intersection(s['geom']).area / max(g.area, 1e-6)
            except Exception:  # noqa: BLE001
                continue
            v = z.get('visina_m')
            if udio >= 0.3 and PA.je_broj(v) and float(v) > 0:
                if h is None or float(v) > h:
                    h, izvor = float(v), 'site.json'
    if h is None and s['visina_vlastita']:
        h, izvor = s['visina_vlastita'], 'program'
    if h is None and re.search(r'igralist|teren|vanjsk|dvorist|otvoren', norm(s['naziv'])):
        out = dict(s, visina=None)
    else:
        out = dict(s, visina=h if h is not None else 4.0, visina_izvor=izvor)
    pred[s['id']] = out
    return out


def _vrh_prostora(s):
    """Kota stropa zatvorenog prostora ili None za otvoreni. Postojeća zgrada s visinom iz site.json (ili
    zadanom) crta se kao zatvorena."""
    if (s['kat'] in ZATVORENE or s.get('visina_izvor') or (s['kat'] == 'stadion' and s.get('visina_vlastita'))) \
            and s['pod'] is not None and s['visina']:
        return s['pod'] + s['visina']
    return None


def _krov_profil(kr, sa, sb, unutra_a, s_fas, procelje):
    """Lomljena linija krova (stacionaža, kota): unutarnji rub na koti ruba, sljeme nad pročeljem na koti vrha,
    vanjski rub na vrhu pročelja. PRETPOSTAVKA crtača: program daje samo dvije kote."""
    rub = kr['rub'] if kr['rub'] is not None else (kr['vrh'] or 150.0)
    vrh = kr['vrh'] if kr['vrh'] is not None else rub
    su, sv = (sa, sb) if unutra_a else (sb, sa)
    t = [(su, rub)]
    if s_fas is not None:
        t.append((s_fas, vrh))
        t.append((sv, procelje['vrh'] if procelje else rub))
    else:
        t.append((sv, vrh))
    return t


class TrakaPresjeka:
    """Jedan red presjeka: prozor stacionaže [sa, sb] i visina [z0, z1] u pravokutniku lista."""

    def __init__(self, x, y, sa, sb, z0, z1, mjerilo):
        self.x, self.y, self.sa, self.sb, self.z0, self.z1 = x, y, sa, sb, z0, z1
        self.k = 1000.0 / mjerilo
        self.w, self.h = (sb - sa) * self.k, (z1 - z0) * self.k

    def X(self, s):
        return self.x + (s - self.sa) * self.k

    def Y(self, z):
        return self.y + self.h - (z - self.z0) * self.k


def _vozilo(svg: Svg, T: TrakaPresjeka, s, pod, vrsta):
    """Obris vozila sprijeda (tramvaj, autobus, automobil) na stacionaži s; mjere su tipske (PRETPOSTAVKA)."""
    mj = {'tramvaj': (2.3, 3.4, '#4f7fc0'), 'autobus': (2.55, 3.1, '#5a9a72'), 'auto': (1.8, 1.45, '#8a8a96')}
    w, h, boja = mj[vrsta]
    x, y = T.X(s - w / 2), T.Y(pod + h)
    svg.pravokutnik(x, y + 0.25 * T.k, w * T.k, (h - 0.25) * T.k, rx=min(0.35 * T.k, 1.2), ispuna=boja, rub='#333333',
                    deb=0.15, neprozirnost=0.9)
    svg.pravokutnik(x + 0.15 * w * T.k, y + (0.25 + 0.18 * h) * T.k, 0.7 * w * T.k, 0.3 * h * T.k, ispuna='#e8f1fa',
                    rub='#333333', deb=0.08)
    if vrsta == 'tramvaj':
        svg.put(f'M{f2(T.X(s))},{f2(y + 0.25 * T.k)}L{f2(T.X(s))},{f2(T.Y(pod + 4.6))}M{f2(T.X(s - 0.6))},'
                f'{f2(T.Y(pod + 4.6))}h{f2(1.2 * T.k)}', rub='#333333', deb=0.14)
        svg.put(f'M{f2(T.X(s - 0.5))},{f2(T.Y(pod))}v-{f2(0.15 * T.k)}M{f2(T.X(s + 0.5))},{f2(T.Y(pod))}'
                f'v-{f2(0.15 * T.k)}', rub='#222222', deb=0.3)
    return (x, y + 0.25 * T.k, x + w * T.k, T.Y(pod))


def _covjek(svg: Svg, T: TrakaPresjeka, s, pod):
    h = 1.75
    x = T.X(s)
    svg.krug(x, T.Y(pod + h - 0.13), 0.13 * T.k, ispuna='#444444')
    svg.put(f'M{f2(x)},{f2(T.Y(pod + h - 0.28))}L{f2(x)},{f2(T.Y(pod + 0.8))}M{f2(x)},{f2(T.Y(pod + 0.8))}'
            f'L{f2(x - 0.22 * T.k)},{f2(T.Y(pod))}M{f2(x)},{f2(T.Y(pod + 0.8))}L{f2(x + 0.22 * T.k)},{f2(T.Y(pod))}'
            f'M{f2(x - 0.3 * T.k)},{f2(T.Y(pod + 1.25))}L{f2(x + 0.3 * T.k)},{f2(T.Y(pod + 1.25))}', rub='#444444',
            deb=max(0.12, 0.09 * T.k))


def crtaj_traku_presjeka(svg: Svg, K_: Kontekst, pr: Presjek, D, T: TrakaPresjeka, info):
    """Nacrtaj jedan red presjeka u pravokutnik trake T."""
    P = K_.P
    sud = Sudari()
    svg.pravokutnik(T.x, T.y, T.w, T.h, ispuna='#fdfdfc')
    svg.otvori(clip_path=svg.isjecak(T.x, T.y, T.w, T.h))
    u_prozoru = (D['s'] >= T.sa - 1.0) & (D['s'] <= T.sb + 1.0)
    ss, tlo, pov = D['s'][u_prozoru], D['tlo'][u_prozoru], D['povrsina'][u_prozoru]
    izv = D['povrsina_izvor'][u_prozoru]
    info.setdefault('napomene', [])
    # 1) današnje tlo: ispuna ispod linije modela reljefa
    ok = ~np.isnan(tlo)
    if ok.sum() >= 2:
        t = [(T.X(s), T.Y(z)) for s, z in zip(ss[ok], tlo[ok])]
        pol = [(t[0][0], T.y + T.h)] + t + [(t[-1][0], T.y + T.h)]
        svg.put(d_tocke(pol, True), ispuna='#efe8dc')
        try:
            svg.srafura(Polygon(pol).buffer(0).intersection(box(T.x, T.y, T.x + T.w, T.y + T.h)), 'tlo', '#b8a98f',
                        0.85)
        except Exception:  # noqa: BLE001
            pass
        info['crte'].add('tlo')

    def tlo_na(s):
        if not ok.any():
            return None
        return float(np.interp(s, ss[ok], tlo[ok]))

    def pov_na(s):
        okp = ~np.isnan(pov)
        if not okp.any():
            return None
        i = int(np.argmin(np.abs(ss - s)))
        return float(pov[i]) if not np.isnan(pov[i]) else None

    prostori = [(s, a, b) for s, a, b in D['prostori'] if b > T.sa and a < T.sb]
    zatv = [(s, a, b) for s, a, b in prostori if _vrh_prostora(s) is not None]
    otv = [(s, a, b) for s, a, b in prostori if _vrh_prostora(s) is None and s['pod'] is not None]
    # 2) konstrukcija i tlo iznad zatvorenih prostora; međuprostor ispod poda
    lomne = sorted({max(T.sa, a) for _, a, _ in prostori} | {min(T.sb, b) for _, _, b in prostori})
    debljine, p_beton, p_medju, p_okno = [], [], [], []
    for a, b in zip(lomne[:-1], lomne[1:]):
        if b - a < 0.05:
            continue
        m = (a + b) / 2
        ovdje_z = sorted([s for s, x, y in zatv if x <= m <= y], key=lambda s: s['pod'])
        ovdje_o = [s for s, x, y in otv if x <= m <= y]
        zp = pov_na(m)
        for s in ovdje_z:
            vrh = _vrh_prostora(s)
            # svjetlarnik iznad: otvor (svjetlosno okno) od stropa do stakla, ne pod ni konstrukcija
            svj = [o['pod'] for o in ovdje_o if o['kat'] == 'svjetlarnik' and o['pod'] >= vrh - 0.02]
            if svj and not [o for o in ovdje_z if o is not s and vrh - 0.02 <= o['pod'] < min(svj) - 0.02]:
                if min(svj) - vrh > 0.02:
                    p_okno.append(box(T.X(a), T.Y(min(svj)), T.X(b), T.Y(vrh)))
                    info['crte'].add('okno')
                continue
            iznad = [o['pod'] for o in ovdje_z if o is not s and o['pod'] >= vrh - 0.02]
            iznad += [o['pod'] for o in ovdje_o if o['pod'] >= vrh - 0.02]
            if zp is not None and zp >= vrh - 0.02:
                iznad.append(zp)
            if not iznad and s.get('visina_izvor'):
                continue        # postojeća zgrada: krov nije dio prijedloga
            do = min(iznad) if iznad else vrh + 0.6
            if do - vrh > 0.02:
                p_beton.append(box(T.X(a), T.Y(do), T.X(b), T.Y(vrh)))
                info['crte'].add('konstrukcija')
                if iznad:
                    debljine.append((a, b, vrh, do))
        svi = ovdje_z + ovdje_o
        if svi:
            naj_s = min(svi, key=lambda o: o['pod'])
            naj = naj_s['pod']
            zt = tlo_na(m)
            mm = (ss >= a - 1e-6) & (ss <= b + 1e-6)
            zz_ = pov[mm]
            ok_m = ~np.isnan(zz_) & (np.abs(zz_ - naj) <= 10.0)
            if naj_s in ovdje_o and mm.sum() >= 3 and ok_m.mean() >= 0.6 and ok.any():
                # otvoreni prostor s kotama: gornji rub međuprostora po projektiranoj površini
                sx = np.concatenate([[a], ss[mm][ok_m], [b]])        # do samih rubova intervala
                sz = np.concatenate([[zz_[ok_m][0]], zz_[ok_m], [zz_[ok_m][-1]]])
                gore_ = [(T.X(x), T.Y(max(z, tlo_na(x)))) for x, z in zip(sx, sz)]
                dolje_ = [(T.X(x), T.Y(tlo_na(x))) for x in sx[::-1]]
                try:
                    pm = Polygon(gore_ + dolje_).buffer(0)
                    if not pm.is_empty and pm.area > 0.05:
                        p_medju.append(pm)
                        info['crte'].add('medjuprostor')
                except Exception:  # noqa: BLE001
                    pass
            elif zt is not None and naj - zt > 0.3:
                p_medju.append(box(T.X(a), T.Y(naj), T.X(b), T.Y(zt)))
                info['crte'].add('medjuprostor')
    okvir_trake = box(T.x, T.y, T.x + T.w, T.y + T.h)
    for skup, isp_, vrsta_, boja_ in ((p_medju, '#f3efe6', 'tocke', '#a89a7f'), (p_beton, '#d9d9d6', 'beton', '#6f6f6f')):
        if skup:
            u = unary_union(skup).intersection(okvir_trake)
            svg.put(d_poligon(u), ispuna=isp_)
            svg.srafura(u, vrsta_, boja_, 0.8)
    if p_okno:       # svjetlosno okno: svijetla ispuna, kose zrake i bočni rubovi okna
        u = unary_union(p_okno).intersection(okvir_trake)
        svg.put(d_poligon(u), ispuna=B_OKNO)
        svg.srafura(u, 'koso', '#e2b33c', 0.6)
        svg.put(d_poligon(u), rub=VEZE['svjetlarnik'][0], deb=0.22, crt='1.1 0.6')
    # praznine programa između prostora (presjek prolazi kroz mjesto bez ijednog prostora): „izvan programa”
    izvan_natpisi = []
    pokriveno = sorted((max(T.sa, a), min(T.sb, b)) for _, a, b in D['prostori'] if b > T.sa and a < T.sb)
    for tb in D['tribine']:
        if tb['sb'] > T.sa and tb['sa'] < T.sb:
            pokriveno.append((max(T.sa, tb['sa']), min(T.sb, tb['sb'])))
    pokriveno.sort()
    spojeno_p = []
    for a, b in pokriveno:
        if spojeno_p and a <= spojeno_p[-1][1] + 0.05:
            spojeno_p[-1][1] = max(spojeno_p[-1][1], b)
        else:
            spojeno_p.append([a, b])
    for (_, a), (b, _) in zip(spojeno_p[:-1], spojeno_p[1:]):
        if b - a < 1.5 or any(a < s_l < b for s_l in D['lomovi']):
            continue
        z_l, z_d = pov_na(a - 0.3), pov_na(b + 0.3)
        zt_l, zt_d = tlo_na(a), tlo_na(b)
        if zt_l is None or zt_d is None:
            continue
        z_gore = max([z for z in (z_l, z_d) if z is not None] or [max(zt_l, zt_d) + 2.0])
        pol_ = [(T.X(a), T.Y(z_gore)), (T.X(b), T.Y(z_gore))] + \
               [(T.X(x), T.Y(tlo_na(x))) for x in np.linspace(b, a, 8)]
        try:
            g_ = Polygon(pol_).buffer(0)
        except Exception:  # noqa: BLE001
            continue
        if g_.is_empty or g_.area < 0.3:
            continue
        svg.put(d_poligon(g_), ispuna='#ffffff', neprozirnost=0.6)
        svg.srafura(g_, 'koso2', '#c9c9c9', 0.9)
        svg.put(f'M{f2(T.X(a))},{f2(T.Y(z_gore))}V{f2(T.Y(zt_l))}M{f2(T.X(b))},{f2(T.Y(z_gore))}V{f2(T.Y(zt_d))}',
                rub='#9a9a9a', deb=0.15, crt='0.8 0.6')
        info['crte'].add('izvan')
        izvan_natpisi.append((a, b, z_gore))
    # svijetla visina kolnika do površine iznad: ključna kota presjeka kroz Maksimirsku, rezervira mjesto prva
    kote_pokrova = []
    for s, a, b in zatv:
        if s['kat'] not in ('promet_cesta', 'promet_tramvaj') or not (T.sa < (a + b) / 2 < T.sb):
            continue
        m = (a + b) / 2
        iznad = [o['pod'] for o, x, y in otv if x <= m <= y and o['pod'] > s['pod'] + 1.0]
        zp = pov_na(m)
        if zp is not None and zp > s['pod'] + 1.0:
            iznad.append(zp)
        if not iznad or not re.search(r'kolnik', norm(s['naziv'])):
            continue
        do = max(iznad)
        X = T.X(max(a, T.sa)) + 1.6
        visina_mm = abs(T.Y(do) - T.Y(s['pod']))
        puni = f'{br(do - s["pod"], 1)} m (pod {br(s["pod"], 1)} – površina {br(do, 1)})'
        kratki = f'{br(do - s["pod"], 1)} m'
        if sirina(puni, F_PODATAK) <= visina_mm - 1.0:
            tekst_, kraj_ = puni, []
        else:
            tekst_ = kratki
            kraj_ = [(X + 1.0, T.Y(do) - 0.5, br(do, 1)), (X + 2.6, T.Y(s['pod']) - 0.4, br(s['pod'], 1))]
        r = (X - 0.9, T.Y(do), X + 1.9, T.Y(s['pod']))
        if not sud.slobodno(r):
            continue
        sud.dodaj(r)
        kraj_ok = []
        for xk, yk, tk in kraj_:
            rk = (xk - 0.2, yk - F_PODATAK * 0.8, xk + sirina(tk, F_PODATAK) + 0.2, yk + F_PODATAK * 0.2)
            if sud.slobodno(rk):
                sud.dodaj(rk)
                kraj_ok.append((xk, yk, tk))
        kote_pokrova.append((X, s['pod'], do, tekst_, kraj_ok))
    # debljina sloja između stropa i površine iznad: jedan natpis po neprekinutom dijelu iste debljine
    spojeno = []
    for a, b, vrh, do in debljine:
        if spojeno and abs(spojeno[-1][1] - a) < 1e-6 and abs(spojeno[-1][2] - vrh) < 0.05 and \
                abs(spojeno[-1][3] - do) < 0.05:
            spojeno[-1][1] = b
        else:
            spojeno.append([a, b, vrh, do])
    for a, b, vrh, do in spojeno:
        t = f'{br(do - vrh, 1)} m'
        w_, h_ = sirina(t, F_PODATAK, True) + 0.8, 2.1
        if (b - a) * T.k >= w_ + 1.0 and (do - vrh) * T.k >= h_ + 0.2:
            X, Y = T.X((a + b) / 2), T.Y((vrh + do) / 2)
            r = (X - w_ / 2, Y - h_ / 2, X + w_ / 2, Y + h_ / 2)
            if sud.slobodno(r):
                svg.pravokutnik(r[0], r[1], w_, h_, rx=0.3, ispuna='#ffffff', neprozirnost=0.85)
                svg.tekst(X, Y + 0.55, t, F_PODATAK, '#333333', bold=True, sidro='middle')
                sud.dodaj(r)
    # 3) zatvoreni prostori
    for s, a, b in sorted(zatv, key=lambda x: (x[0]['pod'], x[1])):
        isp, rub, uz, _ = KAT[s['kat']]
        x, y, w, h = T.X(a), T.Y(_vrh_prostora(s)), (b - a) * T.k, s['visina'] * T.k
        if s.get('visina_izvor') == 'nije zadana':
            svg.pravokutnik(x, y, w, h, ispuna=isp, rub='#2b2b2b', deb=0.22, crt='1.2 0.7')
        else:
            svg.pravokutnik(x, y, w, h, ispuna=isp, rub='#2b2b2b', deb=0.22)
        if uz:
            svg.srafura(box(x, y, x + w, y + h).intersection(okvir_trake), uz, rub)
        info['kat'].add(s['kat'])
    # 3a) rampe uzduž presjeka: kosi pod prema kotama krajeva ili nagibu iz programa
    for s0, z0_, s1, z1_, v in D.get('rampe', []):
        if max(s0, s1) < T.sa or min(s0, s1) > T.sb:
            continue
        zn = min(z0_, z1_)
        svg.put(d_tocke([(T.X(s0), T.Y(z0_)), (T.X(s1), T.Y(z1_)), (T.X(s1), T.Y(zn)), (T.X(s0), T.Y(zn))], True),
                ispuna='#d9d9d6')
        svg.linija(T.X(s0), T.Y(z0_), T.X(s1), T.Y(z1_), VEZE['rampa'][0], 0.45)
        info['crte'].add('rampa')
        tk = f'rampa {br(v["nagib"], 1) + " %" if v["nagib"] else ""} ({br(z0_, 1)} – {br(z1_, 1)})'
        X, Y = T.X((s0 + s1) / 2), T.Y(max(z0_, z1_)) - 1.0
        bw = sirina(tk, F_PODATAK)
        r = (X - bw / 2 - 0.3, Y - F_PODATAK, X + bw / 2 + 0.3, Y + 0.4)
        if abs(T.X(s1) - T.X(s0)) > 4.0 and sud.slobodno(r):
            svg.tekst(X, Y, tk, F_PODATAK, VEZE['rampa'][0], sidro='middle')
            sud.dodaj(r)
    # 4) otvoreni prostori: površina na koti poda; kosina s vlastitim kotama (kote_terena) po projektiranoj
    #    površini, samo jednom (bez vodoravne trake na koti poda)
    nagib_otv = {}
    for s, a, b in sorted(otv, key=lambda x: (x[0]['pod'], x[1])):
        isp, rub, _, _ = KAT[s['kat']]
        d = max(0.35, 0.5 / T.k)
        m_ = (ss >= max(a, T.sa) - 1e-6) & (ss <= min(b, T.sb) + 1e-6)
        zz = pov[m_]
        ok_ = ~np.isnan(zz) & (np.abs(zz - s['pod']) <= 10.0)
        if m_.sum() >= 3 and ok_.mean() >= 0.6:
            s_ok, z_ok = ss[m_][ok_], zz[ok_]
            gore = [(T.X(x), T.Y(z)) for x, z in zip(s_ok, z_ok)]
            dolje = [(T.X(x), T.Y(z - d)) for x, z in zip(s_ok, z_ok)][::-1]
            svg.put(d_tocke(gore + dolje, True), ispuna=isp)
            nagib_otv[(s['id'], a)] = (float(z_ok.min()), float(z_ok.max()), float(z_ok[0]), float(z_ok[-1]),
                                       bool((izv[m_][ok_] == 'n').mean() > 0.5))
        else:
            svg.pravokutnik(T.X(a), T.Y(s['pod']), (b - a) * T.k, d * T.k, ispuna=isp)
            svg.linija(T.X(a), T.Y(s['pod']), T.X(b), T.Y(s['pod']), rub, 0.35)
        info['kat'].add(s['kat'])
    # 5) stadion: tribine, krov, pročelje
    st = P.stadion
    for tb in D['tribine']:
        if tb['sb'] < T.sa or tb['sa'] > T.sb or float(np.min(tb['zb'])) > T.z1:
            continue
        # stepenasti profil red po red (gazište i čelo svakog reda) i donji rub kose ploče
        s_, z_ = tb['s'], tb['z']
        gore = [(T.X(s_[0]), T.Y(z_[0]))]
        for i in range(1, len(s_)):
            if abs(z_[i] - z_[i - 1]) > 1e-6:
                gore.append((T.X(s_[i]), T.Y(z_[i - 1])))
            gore.append((T.X(s_[i]), T.Y(z_[i])))
        dolje = [(T.X(s), T.Y(z)) for s, z in zip(s_[::4], tb['zb'][::4])] + [(T.X(s_[-1]), T.Y(tb['zb'][-1]))]
        svg.put(d_tocke(gore + dolje[::-1], True), ispuna='#aabfe4', rub='#2f4f9e', deb=0.12)
        info['crte'].add('tribina')
        zb_ = np.interp(s_, tb['s'], tb['zb']) if len(tb['zb']) != len(s_) else np.asarray(tb['zb'])
        for i in range(len(s_) - 1):        # profil tribine je prepreka natpisima (red po red)
            x0_, x1_ = sorted((T.X(s_[i]), T.X(s_[i + 1])))
            sud.dodaj((x0_ - 0.2, T.Y(max(z_[i], z_[i + 1])) - 0.3, x1_ + 0.2,
                       T.Y(min(zb_[i], zb_[i + 1])) + 0.3))
    for kr, a, b, unutra_a, s_fas in D['krov']:
        if b < T.sa or a > T.sb:
            continue
        prof = _krov_profil(kr, a, b, unutra_a, s_fas, st.get('procelje') if st else None)
        if min(z for _, z in prof) - 1.5 > T.z1 or max(z for _, z in prof) < T.z0:
            continue        # krov iznad prozora izvatka: ne crta se i ne ulazi u legendu
        gore = [(T.X(s), T.Y(z)) for s, z in prof]
        dolje = [(T.X(s), T.Y(z - 1.5)) for s, z in prof][::-1]
        svg.put(d_tocke(gore + dolje, True), ispuna='#f7f7f7', rub='#333333', deb=0.25)
        info['crte'].add('krov')
    for s_f, pc in D['procelje']:
        if T.sa <= s_f <= T.sb and pc['dno'] < T.z1:
            svg.linija(T.X(s_f), T.Y(pc['dno']), T.X(s_f), T.Y(pc['vrh']), '#27408b', 0.5, crt='1.6 0.5')
            info['crte'].add('procelje')
    # 6) projektirana površina i današnje tlo kao linije
    okp = ~np.isnan(pov)
    if okp.sum() >= 2:
        # po dionicama: linija se prekida na lomu presjeka, na skoku većem od 1 m po metru (rub prostora,
        # potporni zid) i ondje gdje nema prostora ispod
        # dio više od 0,5 m ispod linije modela reljefa crta se crtkano (usjek ili razlika podloga, OTVORENO)
        dio_ = D['dionica'][u_prozoru]
        ispod_ = ~np.isnan(tlo) & (pov < tlo - 0.5)
        dijelovi_p, dijelovi_i, tek, preth, zidovi = [], [], [], None, []
        for s, z, o, di, isp in zip(ss, pov, okp, dio_, ispod_):
            if o and preth is not None and di == preth[0] and 1.0 < abs(z - preth[1]) <= 15.0 and \
                    s - preth[3] <= KORAK_PRESJEKA + 1e-6:
                # skok između susjednih uzoraka: potporni zid ili rub prostora (npr. par kota_terena 0,3 m)
                zidovi.append((T.X((s + preth[3]) / 2), T.Y(preth[1]), T.Y(z)))
            if o and preth is not None and (di != preth[0] or abs(z - preth[1]) > 1.0 or isp != preth[2]):
                if len(tek) >= 2:
                    (dijelovi_i if preth[2] else dijelovi_p).append(tek)
                tek = [tek[-1]] if (tek and di == preth[0] and abs(z - preth[1]) <= 1.0) else []
            if o:
                tek.append((T.X(s), T.Y(z)))
                preth = (di, z, bool(isp), s)
            else:
                if len(tek) >= 2:
                    (dijelovi_i if preth[2] else dijelovi_p).append(tek)
                preth = None
                tek = []
        if len(tek) >= 2 and preth is not None and preth[2]:
            dijelovi_i.append(tek)
            tek = []
        if dijelovi_i:
            svg.put(''.join(d_tocke(t) for t in dijelovi_i), rub='#2e7d32', deb=0.45, crt='1.0 0.7')
            info['crte'].add('povrsina_ispod')
        if tek:
            dijelovi_p.append(tek)
        svg.put(''.join(d_tocke(t) for t in dijelovi_p if len(t) >= 2), rub='#2e7d32', deb=0.45)
        info['crte'].add('povrsina')
        if zidovi:
            svg.put(''.join(f'M{f2(x)},{f2(y1)}L{f2(x)},{f2(y2)}' for x, y1, y2 in zidovi), rub='#1b4d1e', deb=0.6)
            info['crte'].add('zid')
    for s, a, b in otv:       # staklo svjetlarnika iznad crte površine (crta površine ga ne smije zatvoriti)
        if s['kat'] == 'svjetlarnik':
            svg.linija(T.X(max(a, T.sa)), T.Y(s['pod']), T.X(min(b, T.sb)), T.Y(s['pod']), VEZE['svjetlarnik'][0], 0.7)
            for x_ in np.arange(max(a, T.sa) + 0.75, min(b, T.sb) - 0.25, 1.5):
                svg.linija(T.X(x_), T.Y(s['pod']) - 0.6, T.X(x_), T.Y(s['pod']) + 0.6, VEZE['svjetlarnik'][0], 0.12)
    if ok.sum() >= 2:
        svg.put(d_tocke([(T.X(s), T.Y(z)) for s, z in zip(ss[ok], tlo[ok])]), rub='#6d4c41', deb=0.3, crt='2.2 0.9')
    # 7) vozila i ljudi u mjerilu
    for s, a, b in zatv + otv:
        if s['kat'] not in ('promet_tramvaj', 'promet_cesta', 'promet_bus') or s['pod'] is None:
            continue
        os_ = os_trake(s['geom'])
        sir_trake = s['a'] / max(os_.length, 1.0) if os_ is not None else 0.0
        if b - a < 2.6:
            continue
        sred = (max(a, T.sa) + min(b, T.sb)) / 2
        if s['kat'] in ('promet_tramvaj', 'promet_bus'):
            # traka: jedno vozilo u sredini; hala ili terminal (presjek poprijeko kroz više kolosijeka ili
            # stajališnih mjesta): vozila na razmaku oko 12 m, shematski (PRETPOSTAVKA crtača)
            n_ = 1 if b - a <= max(2.5 * sir_trake, 6.0) else max(1, min(4, int(round((b - a) / 12.0))))
            vr_ = 'tramvaj' if s['kat'] == 'promet_tramvaj' else 'autobus'
            for i_ in range(n_):
                sud.dodaj(_vozilo(svg, T, a + (b - a) * (i_ + 0.5) / n_, s['pod'], vr_))
            if n_ > 1 and T.k >= 0.9:
                for i_ in range(n_ - 1):
                    _covjek(svg, T, a + (b - a) * (i_ + 1) / n_, s['pod'])
        elif b - a > 2.5 * sir_trake:
            continue
        elif re.search(r'kolnik|prilaz|cest', norm(s['naziv'])):
            if b - a >= 6.0:
                _vozilo(svg, T, a + (b - a) * 0.27, s['pod'], 'auto')
                _vozilo(svg, T, a + (b - a) * 0.73, s['pod'], 'auto')
            else:
                _vozilo(svg, T, sred, s['pod'], 'auto')
        info['crte'].add('vozila')
    for s, a, b in otv:
        if s['kat'] in ('staza', 'trg_predvorje', 'park_zelenilo', 'igraliste') and b - a >= 8.0 and T.k >= 0.9:
            m = (a + b) / 2
            if T.sa + 2 < m < T.sb - 2:
                _covjek(svg, T, m, s['pod'])
    # 8) razine: crte i kote
    for r in P.razine:
        if r['kota'] is None or not (T.z0 < r['kota'] < T.z1):
            continue
        svg.linija(T.x, T.Y(r['kota']), T.x + T.w, T.Y(r['kota']), '#888888', 0.09, crt='4 1 0.6 1')
    # 10) visinske kote: svijetla visina od kolnika do površine iznad (mjesta rezervirana prije natpisa)
    for X, pod_, do_, tekst_, kraj_ in kote_pokrova:
        svg.linija(X, T.Y(pod_), X, T.Y(do_), '#b71c1c', 0.18)
        svg.put(f'M{f2(X - 0.7)},{f2(T.Y(pod_))}h1.4M{f2(X - 0.7)},{f2(T.Y(do_))}h1.4', rub='#b71c1c', deb=0.18)
        svg.tekst(X + 1.6, (T.Y(do_) + T.Y(pod_)) / 2, tekst_, F_PODATAK, '#b71c1c', sidro='middle', kut=-90)
        for (xk, yk, tk) in kraj_:
            svg.pravokutnik(xk - 0.2, yk - F_PODATAK * 0.8, sirina(tk, F_PODATAK) + 0.4, F_PODATAK, rx=0.2,
                            ispuna='#ffffff', neprozirnost=0.85)
            svg.tekst(xk, yk, tk, F_PODATAK, '#b71c1c')
        info['crte'].add('kota pokrova')
    # 9) natpisi prostora
    for s, a, b in sorted(zatv, key=lambda x: -(min(x[2], T.sb) - max(x[1], T.sa))):
        xa, xb = T.X(max(a, T.sa)), T.X(min(b, T.sb))
        w, h = xb - xa, s['visina'] * T.k
        cy = T.Y(s['pod'] + s['visina'] / 2)
        gotovo = False
        dod = f'h {br(s["visina"], 1)} m · pod {br(s["pod"], 1)}'
        if s.get('visina_izvor') == 'site.json':
            dod = f'postojeće, visina zgrade ~{br(s["visina"], 0)} m (OSM) · pod {br(s["pod"], 1)}'
        elif s.get('visina_izvor') == 'program':
            dod = f'postojeće · h {br(s["visina"], 1)} m · pod {br(s["pod"], 1)}'
        elif s.get('visina_izvor'):
            dod = f'postojeće, visina nije zadana · pod {br(s["pod"], 1)}'
        for vel in (2.0, 1.8, 1.6):
            for s_dod, maxw in ((True, w - 1.0), (True, (w - 1.0) * 0.72), (False, w - 1.0), (False, (w - 1.0) * 0.72)):
                nl = prelomi(s['naziv'], vel, True, maxw, 3)
                if nl is None:
                    continue
                redci = [(l, vel, True, '#111111') for l in nl]
                if s_dod:
                    if sirina(dod, max(F_PODATAK, vel * 0.85)) > maxw:
                        continue
                    redci.append((dod, max(F_PODATAK, vel * 0.85), False, '#222222'))
                bw, bh = mjere_bloka(redci)
                if bh > h - 0.3:
                    continue
                cy_gore = T.Y(_vrh_prostora(s)) + bh / 2 + 0.6     # uz strop, kad sredinu zauzimaju vozila
                for pomak, cy_ in [(p_, c_) for c_ in ((cy, cy_gore) if cy_gore < cy - 0.5 else (cy,))
                                   for p_ in (0.0, (w - bw) / 2 - 0.4, -(w - bw) / 2 + 0.4)]:
                    cx = (xa + xb) / 2 + pomak
                    r = (cx - bw / 2, cy_ - bh / 2, cx + bw / 2, cy_ + bh / 2)
                    if sud.slobodno(r):
                        crtaj_blok(svg, cx, cy_, redci, podloga_bijela=True)
                        sud.dodaj(r)
                        gotovo = True
                        break
                if gotovo:
                    break
            if gotovo:
                break
        if not gotovo and h >= 6.0 and w >= 2.4:
            # uski visoki prostor: okomiti natpis, samo puni naziv (skraćeni naziv ne bi se dao prepoznati)
            for vel in (1.8, 1.6):
                t = s['naziv']
                if vel * 1.2 <= w - 0.4 and sirina(t, vel, True) <= h - 1.0:
                    bw_ = sirina(t, vel, True)
                    r = ((xa + xb) / 2 - vel * 0.6, cy - bw_ / 2, (xa + xb) / 2 + vel * 0.6, cy + bw_ / 2)
                    if sud.slobodno(r):
                        svg.tekst((xa + xb) / 2 + vel * 0.35, cy, t, vel, '#111111', bold=True, sidro='middle', kut=-90)
                        sud.dodaj(r)
                        gotovo = True
                        break
        if not gotovo:
            # oznaka razina·broj (vodoravno ili okomito) i redak u tablici „Prostori označeni oznakom”
            t = f'{s["razina"]}·{s["br"]}'
            vel = F_PODATAK
            tw = sirina(t, vel, True)
            X = (xa + xb) / 2
            for vod, r in ((True, (X - tw / 2 - 0.2, cy - vel * 0.7, X + tw / 2 + 0.2, cy + vel * 0.7)),
                           (False, (X - vel * 0.6, cy - tw / 2 - 0.2, X + vel * 0.6, cy + tw / 2 + 0.2))):
                stane = (tw <= w - 0.3 and h >= 1.9) if vod else (h >= tw + 0.6 and w >= vel * 1.1)
                if stane and sud.slobodno(r):
                    if vod:
                        svg.tekst(X, cy + vel * 0.36, t, vel, '#111111', bold=True, sidro='middle')
                    else:
                        svg.tekst(X + vel * 0.35, cy, t, vel, '#111111', bold=True, sidro='middle', kut=-90)
                    sud.dodaj(r)
                    info['brojevi'].add((s['razina'], s['br'], s['naziv']))
                    gotovo = True
                    break
            if not gotovo and w >= 0.6:
                # premalen prostor: oznaka iznad presjeka s vodilicom do sredine prostora
                Y0 = T.Y(_vrh_prostora(s))
                for dy in (4.0, 6.4, 8.8, 11.2, 13.6, 16.0):
                    for dx in (0.0, 3.5, -3.5, 7.0, -7.0):
                        Yt = Y0 - dy
                        r = (X + dx - tw / 2 - 0.3, Yt - vel, X + dx + tw / 2 + 0.3, Yt + 0.4)
                        if r[1] > T.y + 0.5 and T.x < r[0] and r[2] < T.x + T.w and sud.slobodno(r):
                            svg.linija(X, Y0 - 0.2, X + dx, Yt + 0.5, '#444444', 0.1)
                            svg.pravokutnik(r[0], r[1], r[2] - r[0], r[3] - r[1], rx=0.3, ispuna='#ffffff',
                                            neprozirnost=0.85)
                            svg.tekst(X + dx, Yt, t, vel, '#111111', bold=True, sidro='middle')
                            sud.dodaj(r)
                            info['brojevi'].add((s['razina'], s['br'], s['naziv']))
                            gotovo = True
                            break
                    if gotovo:
                        break
    # otvoreni prostori: naziv iznad površine, ako ima mjesta
    for s, a, b in sorted(otv, key=lambda x: -(min(x[2], T.sb) - max(x[1], T.sa))):
        if s['kat'] == 'tribine' and D['tribine']:
            continue
        xa, xb = T.X(max(a, T.sa)), T.X(min(b, T.sb))
        w = xb - xa
        gotovo = False
        ng = nagib_otv.get((s['id'], a))
        napomena_ = None
        if ng:       # površina po kotama (kote_terena): raspon kota u smjeru stacionaže
            kt = f'{br(ng[2], 1)} do {br(ng[3], 1)}' if ng[1] - ng[0] > 0.3 else br((ng[0] + ng[1]) / 2, 1)
            if ng[4]:
                napomena_ = (f'{s["naziv"]}: nema vlastitih kota; na presjeku preuzima kosinu susjednih prostora '
                             f'({kt}), pod u programu {br(s["pod"], 1)} (OTVORENO)')
                kt += ' (kosina susjeda, kote nisu zadane)'
            elif not (ng[0] - 0.5 <= s['pod'] <= ng[1] + 0.5):
                napomena_ = f'{s["naziv"]}: kote_terena na presjeku {kt}, a pod u programu {br(s["pod"], 1)}'
                kt += f' (kote; pod u programu {br(s["pod"], 1)})'
            varijante = (f'{s["naziv"]} · {kt}', s['naziv'])
            z_natpisa = ng[1]
        elif re.search(r'kosin|padin|rampa|nagib|\d_do_\d', norm(s['naziv'])) or '%' in s['naziv']:
            varijante = (f'{s["naziv"]} · {br(s["pod"], 1)} · kosina, kote nisu zadane (OTVORENO)',
                         f'{s["naziv"]} · kosina, kote nisu zadane (OTVORENO)', f'{s["naziv"]} · kote nisu zadane')
            z_natpisa = s['pod']
        else:
            varijante = (f'{s["naziv"]} · {br(s["pod"], 1)}', s['naziv'])
            z_natpisa = s['pod']
        for t in varijante:
            for vel in (1.8, F_PODATAK):
                bw = sirina(t, vel)
                if bw > w - 1.0:
                    continue
                y = T.Y(z_natpisa) - 1.0 - (1.9 * T.k if T.k >= 0.9 else 0.0)
                for dy in (0.0, -2.2, -4.4, 2.6 + 0.5 * T.k):
                    r = ((xa + xb) / 2 - bw / 2 - 0.3, y + dy - vel, (xa + xb) / 2 + bw / 2 + 0.3, y + dy + 0.4)
                    if sud.slobodno(r) and r[1] > T.y + 0.5:
                        svg.pravokutnik(r[0], r[1], r[2] - r[0], r[3] - r[1], rx=0.3, ispuna='#ffffff',
                                        neprozirnost=0.75)
                        svg.tekst((xa + xb) / 2, y + dy, t, vel, KAT[s['kat']][1], sidro='middle')
                        sud.dodaj(r)
                        gotovo = True
                        break
                if gotovo:
                    break
            if gotovo:
                break
        if napomena_ and (not gotovo or t != varijante[0]) and s['id'] not in info.setdefault('napomene_id', set()):
            info['napomene'].append(napomena_)       # ne stane u crtež: redak u tablici lista
            info['napomene_id'].add(s['id'])
    # tribine, krov, pročelje: natpisi
    for tb in D['tribine']:
        tr, a, b = tb['tr'], tb['sa'], tb['sb']
        m = (max(a, T.sa) + min(b, T.sb)) / 2
        if not (T.sa < m < T.sb) or (b - a) * T.k < 8.0:
            continue
        ime = tr['naziv'].split('(')[0].split(',')[0].strip()
        n_ = tr.get('redova')
        dod = (f'{n_} ' + ('red' if n_ % 10 == 1 and n_ % 100 != 11 else 'reda' if n_ % 10 in (2, 3, 4) and
                           n_ % 100 not in (12, 13, 14) else 'redova') + ' · ') if n_ else ''
        z0_, z1_ = float(np.min(tb['z'])), float(np.max(tb['z']))
        vel = F_PODATAK
        for t in (f'{ime}: {dod}{br(z0_, 1)} – {br(z1_, 1)}', f'{ime}: {br(z0_, 1)} – {br(z1_, 1)}', ime):
            bw = sirina(t, vel)
            X = T.X(m)
            gotovo = False
            for Y in (T.Y((z0_ + z1_) / 2) - 3.0, T.Y(z1_) - 2.5, T.Y(z0_) + 4.0):
                r = (X - bw / 2 - 0.3, Y - vel, X + bw / 2 + 0.3, Y + 0.4)
                if sud.slobodno(r) and T.x < r[0] and r[2] < T.x + T.w and r[1] > T.y:
                    svg.pravokutnik(r[0], r[1], r[2] - r[0], r[3] - r[1], rx=0.3, ispuna='#ffffff', neprozirnost=0.8)
                    svg.tekst(X, Y, t, vel, '#2f4f9e', sidro='middle')
                    sud.dodaj(r)
                    gotovo = True
                    break
            if gotovo:
                break
    for kr, a, b, unutra_a, s_fas in D['krov']:
        m = (max(a, T.sa) + min(b, T.sb)) / 2
        if not (T.sa < m < T.sb):
            continue
        prof = _krov_profil(kr, a, b, unutra_a, s_fas, st.get('procelje') if st else None)
        zv = max(z for _, z in prof)
        t = f'krov (gruba geometrija): rub {br(kr["rub"], 1)}, vrh {br(kr["vrh"], 1)}'
        vel = F_PODATAK
        bw = sirina(t, vel)
        X, Y = T.X(m), T.Y(zv) - 1.2
        r = (X - bw / 2 - 0.3, Y - vel, X + bw / 2 + 0.3, Y + 0.4)
        if sud.slobodno(r) and T.x < r[0] and r[2] < T.x + T.w and r[1] > T.y:
            svg.tekst(X, Y, t, vel, '#333333', sidro='middle')
            sud.dodaj(r)
    uzete = []
    for s_k, z, d in D['kote']:
        if not (T.sa + 0.5 < s_k < T.sb - 0.5) or not (T.z0 < z < T.z1):
            continue
        X, Y = T.X(s_k), T.Y(z)
        if any(abs(X - u_) < 2.2 for u_ in uzete):
            continue
        t = br(z, 2)
        r = (X - 1.0, Y + 0.6, X + 1.0, Y + 1.2 + sirina(t, F_PODATAK))
        svg.put(d_tocke([(X - 0.55, Y - 0.95), (X + 0.55, Y - 0.95), (X, Y)], True), ispuna='#6d4c41')
        uzete.append(X)
        if sud.slobodno(r) and r[3] < T.y + T.h:
            svg.tekst(X + 0.55, Y + 1.0, t, F_PODATAK, '#5d4037', kut=90)
            sud.dodaj(r)
        info['crte'].add('kota terena')
    for a, b, z_g in izvan_natpisi:
        if not (T.sa <= a and b <= T.sb):
            continue
        t = 'izvan programa'
        w_ = sirina(t, F_PODATAK)
        X = T.X((a + b) / 2)
        if (b - a) * T.k >= w_ + 0.8:
            for Y in (T.Y(z_g) - 1.2, T.Y(z_g) - 3.4):
                r = (X - w_ / 2 - 0.3, Y - F_PODATAK, X + w_ / 2 + 0.3, Y + 0.4)
                if sud.slobodno(r) and r[1] > T.y:
                    svg.tekst(X, Y, t, F_PODATAK, '#777777', sidro='middle', kurziv=True)
                    sud.dodaj(r)
                    break
        else:
            for Y in (T.Y(z_g) - 1.0 - w_ / 2, T.Y(z_g) + 1.0 + w_ / 2):
                r = (X - 1.0, Y - w_ / 2, X + 1.0, Y + w_ / 2)
                if sud.slobodno(r) and r[1] > T.y and r[3] < T.y + T.h:
                    svg.tekst(X + 0.55, Y, t, F_PODATAK, '#777777', sidro='middle', kut=-90, kurziv=True)
                    sud.dodaj(r)
                    break
    for s_l in D['lomovi']:
        if T.sa < s_l < T.sb:
            svg.linija(T.X(s_l), T.y, T.X(s_l), T.y + T.h, '#c62828', 0.3, crt='5 1.2 0.8 1.2')
            svg.tekst(T.X(s_l) + 0.8, T.y + 3.0, 'lom presjeka', 1.6, '#c62828')
    svg.zatvori()
    svg.pravokutnik(T.x, T.y, T.w, T.h, rub='#222222', deb=0.25)
    # osi: kote lijevo i desno, stacionaža dolje
    d = []
    z = math.ceil(T.z0)
    while z <= T.z1 + 1e-9:
        dulj = 1.6 if z % 5 == 0 else 0.7
        d.append(f'M{f2(T.x)},{f2(T.Y(z))}h-{f2(dulj)}M{f2(T.x + T.w)},{f2(T.Y(z))}h{f2(dulj)}')
        if z % 5 == 0 or T.k >= 3.0:
            svg.tekst(T.x - 2.0, T.Y(z) + 0.6, br(z, 0), 1.6, '#444444', sidro='end')
            svg.tekst(T.x + T.w + 2.0, T.Y(z) + 0.6, br(z, 0), 1.6, '#444444')
        z += 1
    korak_s = next((g for g in (5, 10, 20, 25, 50, 100) if g * T.k >= 16), 100)
    s = math.ceil(T.sa / korak_s) * korak_s
    while s <= T.sb + 1e-9:
        d.append(f'M{f2(T.X(s))},{f2(T.y + T.h)}v1.4')
        svg.tekst(T.X(s), T.y + T.h + 3.4, br(s, 0), 1.6, '#444444', sidro='middle')
        s += korak_s
    svg.put(''.join(d), rub='#333333', deb=0.13)
    # oznake razina desno od trake: sve razine u rasponu visina, bliske se razmaknu i spoje vodilicom;
    # ako ni tako ne stanu, prve otpadaju razine koje presjek ne siječe (PARK, M2, ostaje uvijek)
    for r_, y_ in oznake_razina(P, D, T):
        Y = T.Y(r_['kota'])
        svg.put(f'M{f2(T.x + T.w)},{f2(Y)}H{f2(T.x + T.w + 5.6)}L{f2(T.x + T.w + 7.0)},{f2(y_)}'
                f'H{f2(T.x + T.w + 7.6)}', rub='#888888', deb=0.09)
        svg.tekst(T.x + T.w + 7.9, y_ + 0.6, f'▽ {br(r_["kota"], 1)} {r_["id"]}', F_PODATAK, '#333333', bold=True)


def oznake_razina(P: Podaci, D, T: 'TrakaPresjeka', razmak=2.1):
    """Položaji oznaka razina uz desnu os trake: [(razina, y oznake)]. Prednost imaju PARK i razine koje
    presjek siječe; ostale otpadaju samo ako sve ne stanu u visinu trake (uz 3 mm iznad i ispod)."""
    sijece = {s['razina'] for s, a, b in D['prostori'] if b > T.sa and a < T.sb}
    kand = sorted([r for r in P.razine if r['kota'] is not None and T.z0 < r['kota'] < T.z1],
                  key=lambda r: -r['kota'])
    gore, dolje = T.y - 3.0, T.y + T.h + 3.0
    while True:
        y = [T.Y(r['kota']) for r in kand]
        for i in range(1, len(y)):
            y[i] = max(y[i], y[i - 1] + razmak)
        if y and y[-1] > dolje:
            y[-1] = dolje
            for i in range(len(y) - 2, -1, -1):
                y[i] = min(y[i], y[i + 1] - razmak)
        if not y or y[0] >= gore:
            return list(zip(kand, y))
        manje = [r for r in kand if r['id'] != 'PARK' and r['id'] not in sijece] or \
            [r for r in kand if r['id'] != 'PARK']
        if not manje:
            return list(zip(kand, y))
        kand.remove(manje[-1])


PANEL_PRESJEK = 88.0
LEGENDA_PRESJEKA = [
    ('tlo', ('ispuna', ('#efe8dc', 'tlo', '#b8a98f', None)), 'današnje tlo (ispod modela reljefa)'),
    ('tlo', ('crta', ('#6d4c41', 0.3, '2.2 0.9')), 'današnje tlo: model reljefa DGU'),
    ('kota terena', ('trokut', None), 'stvarna kota terena (do 10 m)'),
    ('povrsina', ('crta', ('#2e7d32', 0.45, None)), 'projektirana površina nad prostorom'),
    ('povrsina_ispod', ('crta', ('#2e7d32', 0.45, '1.0 0.7')), 'proj. površina > 0,5 m ispod DMR-a'),
    ('zid', ('crta', ('#1b4d1e', 0.6, None)), 'skok površine: zid ili rub (kote)'),
    ('rampa', ('crta', (VEZE['rampa'][0], 0.45, None)), 'rampa uzduž presjeka (kosi pod)'),
    ('konstrukcija', ('ispuna', ('#d9d9d6', 'beton', '#6f6f6f', None)), 'konstrukcija i tlo iznad'),
    ('okno', ('ispuna', (B_OKNO, 'koso', '#e2b33c', VEZE['svjetlarnik'][0])), 'svjetlosno okno do svjetlarnika'),
    ('izvan', ('ispuna', ('#ffffff', 'koso2', '#c9c9c9', '#9a9a9a')), 'izvan programa (nema prostora)'),
    ('medjuprostor', ('ispuna', ('#f3efe6', 'tocke', '#a89a7f', None)), 'između tla i poda (OTVORENO)'),
    ('tribina', ('ispuna', ('#aabfe4', None, None, '#2f4f9e')), 'tribina (gruba geometrija)'),
    ('krov', ('ispuna', ('#f7f7f7', None, None, '#333333')), 'krov (gruba geom., PRETPOSTAVKA)'),
    ('procelje', ('crta', ('#27408b', 0.5, '1.6 0.5')), 'pročelje (lamele)'),
    ('kota pokrova', ('crta', ('#b71c1c', 0.2, None)), 'visina od kolnika do površine'),
    ('vozila', ('ispuna', ('#4f7fc0', None, None, '#333333')), 'vozila i ljudi (tipske mjere)'),
]


def raspon_visina(D, sa, sb, st, sa_stadionom=True):
    """(z0, z1) prozora presjeka: od 3 m ispod najnižeg tla do 2,5 m iznad najvišeg elementa."""
    m = (D['s'] >= sa) & (D['s'] <= sb)
    nisko, visoko = [], []
    for niz in (D['tlo'][m], D['povrsina'][m]):
        if (~np.isnan(niz)).any():
            nisko.append(float(np.nanmin(niz)))
            visoko.append(float(np.nanmax(niz)))
    for s, a, b in D['prostori']:
        if b > sa and a < sb and s['pod'] is not None:
            nisko.append(s['pod'])
            visoko.append(_vrh_prostora(s) or s['pod'] + 2.0)
    if not sa_stadionom:
        visoko = [max(visoko) + 4.0] if visoko else []
    for tb in D['tribine'] if sa_stadionom else []:
        if tb['sb'] > sa and tb['sa'] < sb:
            visoko.append(float(np.max(tb['z'])))
    for kr, a, b, ua, sf in D['krov'] if sa_stadionom else []:
        if b > sa and a < sb:
            visoko.append(max(z for _, z in _krov_profil(kr, a, b, ua, sf, st.get('procelje') if st else None)))
    for s_f, pc in D['procelje'] if sa_stadionom else []:
        if sa <= s_f <= sb:
            visoko.append(pc['vrh'])
    for s_k, z, _ in D['kote']:
        if sa <= s_k <= sb:
            nisko.append(z)
    if not nisko:
        return 110.0, 135.0
    return math.floor(min(nisko) - 3.0), math.ceil(max(visoko) + 2.5)


def prozori_izvadaka(K_: Kontekst, pr: Presjek, D):
    """Prozori stacionaže za krupnije izvatke: promet pod pokrovom i bazen; inače najgušći dio."""
    out = []
    prom = sorted((a, b, s) for s, a, b in D['prostori']
                  if s['kat'] in ('promet_tramvaj', 'promet_cesta', 'promet_bus') and s['pod'] is not None)
    skupine = []
    for a, b, s in prom:
        if skupine and a - skupine[-1][1] <= 12.0:
            skupine[-1][1] = max(skupine[-1][1], b)
            skupine[-1][2].append(s)
        else:
            skupine.append([a, b, [s]])
    for a, b, ss in skupine:
        if any(s['kat'] == 'promet_tramvaj' or 'kolnik' in norm(s['naziv']) for s in ss) and b - a >= 6.0:
            out.append([a - 8.0, b + 8.0, 'promet ispod pokrova'])
    baz = [(a, b) for s, a, b in D['prostori'] if 'bazen' in norm(s['naziv'])]
    if baz:
        out.append([min(a for a, _ in baz) - 12.0, max(b for _, b in baz) + 12.0, 'bazen i topla veza'])
    if not out:
        zatv = [(a, b) for s, a, b in D['prostori'] if _vrh_prostora(s) is not None]
        if zatv:
            naj = max(np.arange(pr.s0, max(pr.s0 + 1, pr.s1 - 120.0), 10.0),
                      key=lambda x: sum(1 for a, b in zatv if b > x and a < x + 120.0))
            out.append([float(naj), float(naj) + 120.0, 'najgušći dio'])
    stadion = []
    fas = sorted(s_f for s_f, _ in D['procelje'])
    if len(fas) >= 2 and fas[-1] - fas[0] > 60.0:
        stadion = [[max(pr.s0, fas[0] - 10.0), min(pr.s1, fas[-1] + 10.0), 'stadion: profil tribina i krov']]
    cisti = []
    for a, b, n in sorted(out):
        a, b = max(pr.s0, a), min(pr.s1, b)
        if b - a > 260.0:
            c = (a + b) / 2
            a, b = c - 130.0, c + 130.0
        if cisti and min(b, cisti[-1][1]) - max(a, cisti[-1][0]) > 0.5 * min(b - a, cisti[-1][1] - cisti[-1][0]):
            cisti[-1] = [min(a, cisti[-1][0]), max(b, cisti[-1][1]), cisti[-1][2] + ', ' + n]
        else:
            cisti.append([a, b, n])
    return stadion + cisti[:2]


def panel_presjeka(svg: Svg, K_: Kontekst, pr: Presjek, svi, naslov, podnaslov, cinjenice, info, teren):
    P = K_.P
    panel_x = LIST_W - RUB - PANEL_PRESJEK
    pan = Panel(svg, panel_x, PANEL_PRESJEK)
    pan.oznaka()
    pan.odlomak(P.naslov(), 1.9, False, '#333333', max_redaka=3, razmak=0.6)
    pan.odlomak(naslov, 3.0, True, max_redaka=4, razmak=0.4)
    pan.odlomak(podnaslov, 2.1, False, '#222222', max_redaka=5, razmak=0.8)
    for t in cinjenice:
        pan.odlomak(t, 1.95, False, '#111111', max_redaka=3, razmak=0.0)
    pan.y += 1.0
    pan.crta()
    dod = ['Presjek je shema iz razina, prostora, kote_terena i objekta „stadion”: svijetle visine iz programa, '
           'debljine konstrukcije i tla iznad izlaze iz razlike kota. Nije dokaz statike ni izvedivosti.']
    if teren is not None and teren.ima:
        dod.append('Današnje tlo: DGU, Visine INSPIRE (model reljefa 20 m), Otvorena dozvola; orijentacijski.')
    dno = pan.izvori(K_, dod)
    # ključni plan s linijama presjeka
    x0, y0, x1, y1 = P.obuhvat
    rubm = 30.0
    wm, hm = x1 - x0 + 2 * rubm, y1 - y0 + 2 * rubm
    k = min(pan.w / wm, 52.0 / hm)
    w, h = wm * k, hm * k
    px = pan.x + (pan.w - w) / 2
    mali = Pogled((x0 + x1) / 2, (y0 + y1) / 2, 1000.0 / k, (px, pan.y, w, h))
    svg.pravokutnik(px, pan.y, w, h, ispuna='#fafafa', rub='#999999', deb=0.12)
    svg.otvori(clip_path=svg.isjecak(px, pan.y, w, h))
    if K_.sve is not None:
        svg.put(d_poligon(mali.g(K_.sve.simplify(2.0))), ispuna='#e6e6e6', rub='#b5b5b5', deb=0.1)
    if P.stadion and P.stadion.get('obris') is not None:
        svg.put(d_poligon(mali.g(P.stadion['obris'].simplify(1.0))), rub='#27408b', deb=0.15)
    if P.stadion and P.stadion.get('igraliste') is not None:
        svg.put(d_poligon(mali.g(P.stadion['igraliste'])), ispuna='#b7dba6')
    for q in svi:
        aktivan = q is pr
        boja = '#c62828' if aktivan else '#9a9a9a'
        tocke_ = []
        for a, b, c in q.dionice:
            tocke_ += [mali.t(*q.tocka(a, c)), mali.t(*q.tocka(b, c))]
        svg.put(d_tocke(tocke_), rub=boja, deb=0.45 if aktivan else 0.2, crt=None if aktivan else '1.2 0.8')
        svg.tekst(tocke_[0][0] + 0.8, tocke_[0][1] + 2.4, q.oznaka, 1.8, boja, bold=True)
        if aktivan:
            strelica(svg, tocke_[-2][0], tocke_[-2][1], tocke_[-1][0], tocke_[-1][1], boja, 0.45, 1.6)
    svg.zatvori()
    svg.tekst(px + 1, pan.y + 2.6, 'položaj presjeka (S gore)', 1.6, '#666666')
    pan.y += h + 2.0
    pan.odlomak('Legenda', 2.0, True, razmak=0.2)
    stavke = [('kat', k_, KAT[k_][3]) for k_ in KAT_RED if k_ in info['kat']]
    vid = set()
    for kljuc, (vrsta, par), naziv in LEGENDA_PRESJEKA:
        if kljuc in info['crte'] and naziv not in vid:
            vid.add(naziv)
            stavke.append((vrsta, par, naziv))
    pan.crtaj_stavke(stavke, stupaca=1 if len(stavke) <= 24 else 2)
    pan.crta()
    br_ = sorted(info['brojevi'])
    redci = [(f'{r}·{b}', n) for r, b, n in br_] + [('•', t) for t in info.get('napomene', [])]
    naslov_t = 'Prostori označeni oznakom razina·broj' if br_ else 'Napomene'
    if br_ and info.get('napomene'):
        naslov_t += ' i napomene (•)'
    pan.tablica(redci, naslov_t, dno, stupaca=1)


def list_presjeka(K_: Kontekst, pr: Presjek, svi, D, teren, prozor, mjerilo, naslov_dijela, oznaka_lista, uid,
                  sa_stadionom=True):
    """List presjeka: prozor stacionaže (sa, sb) u jednom ili više redova, bez visinskog pretjerivanja."""
    P = K_.P
    svg = Svg(uid)
    svg.pravokutnik(RUB, RUB, LIST_W - 2 * RUB, LIST_H - 2 * RUB, rub='#222222', deb=0.3)
    sa, sb = prozor
    z0, z1 = raspon_visina(D, sa, sb, P.stadion, sa_stadionom)
    k = 1000.0 / mjerilo
    x0 = RUB + 11.0
    sirina_platna = LIST_W - RUB - PANEL_PRESJEK - 26.0 - x0
    visina_platna = LIST_H - 2 * RUB - 6.0
    redova = max(1, math.ceil((sb - sa) * k / sirina_platna - 1e-6))
    red_h = (z1 - z0) * k
    dulj = (sb - sa) / redova
    slobodno = visina_platna - redova * (red_h + 13.0)
    y = RUB + 4.0 + max(0.0, slobodno / (redova + 1))
    info = {'kat': set(), 'crte': set(), 'brojevi': set()}
    poc, kraj = pr.strane()
    for i in range(redova):
        a, b = sa + i * dulj, sa + (i + 1) * dulj
        T = TrakaPresjeka(x0 + (sirina_platna - dulj * k) / 2, y + 5.0, a, b, z0, z1, mjerilo)
        t = f'{pr.oznaka} · stacionaža {br(round(a) + 0.0, 0)} – {br(round(b) + 0.0, 0)} m'
        if redova > 1:
            t += f' · red {i + 1} od {redova}'
        svg.tekst(T.x, y + 3.2, t, 2.2, '#111111', bold=True)
        svg.tekst(T.x + T.w, y + 3.2, f'{poc} ◂   ▸ {kraj}', 2.0, '#555555', sidro='end')
        crtaj_traku_presjeka(svg, K_, pr, D, T, info)
        svg.tekst(T.x - 2.0, T.y - 1.2, 'm n. v.', F_PODATAK, '#444444', sidro='end')
        svg.tekst(T.x + T.w, T.y + T.h + 6.2, 'stacionaža (m)', F_PODATAK, '#444444', sidro='end')
        y += red_h + 13.0 + max(0.0, slobodno / (redova + 1))
    # grafičko mjerilo
    Dm = next((d for d in (2, 5, 10, 20, 25, 50, 100, 200) if d * k >= 30), 200)
    bx, by = x0, LIST_H - RUB - 5.0
    svg.otvori(id=f'{uid}-mjerilo', data_duljina_m=str(Dm), data_mjerilo=str(mjerilo))
    for i in range(4):
        svg.pravokutnik(bx + i * Dm * k / 4, by, Dm * k / 4, 1.3, ispuna='#222222' if i % 2 == 0 else '#ffffff',
                        rub='#222222', deb=0.12)
    svg.zatvori()
    svg.tekst(bx + Dm * k + 1.5, by + 1.3, f'{br(Dm, 0)} m · mjerilo 1 : {br(mjerilo, 0)} (A3), visine i duljine u '
              'istom mjerilu (bez pretjerivanja)', 1.9, '#111111', bold=True)
    cinj = [f'Mjerilo 1 : {br(mjerilo, 0)} (A3), bez visinskog pretjerivanja · {oznaka_lista}',
            f'Stacionaža {br(round(sa) + 0.0, 0)} – {br(round(sb) + 0.0, 0)} m od početka presjeka; smjer {poc} → {kraj}.',
            f'Datum: {K_.datum} · program sha256 {K_.P.otisak[:12]} · kote u m n. v.']
    if not sa_stadionom and (D['tribine'] or D['krov']):
        cinj.append('Izvadak prikazuje donji dio; tribine i krov stadiona su na listu cijelog presjeka.')
    panel_presjeka(svg, K_, pr, svi, pr.naziv, f'{naslov_dijela} ({pr.opis}).', cinj, info, teren)
    return svg, info


def naredba_presjek(K_: Kontekst, out: Path, teren: Teren, linije=(), tiho=False):
    out.mkdir(parents=True, exist_ok=True)
    presjeci = automatski_presjeci(K_)
    for t in linije:
        try:
            presjeci.append(presjek_iz_zapisa(K_, t, len(presjeci) + 1))
        except ValueError as e:
            print(f'NAPOMENA: preskačem --linija "{t}": {e}', file=sys.stderr)
    zapisi = []
    sirina_platna = LIST_W - 2 * RUB - PANEL_PRESJEK - 37.0
    visina_platna = LIST_H - 2 * RUB - 6.0
    for pr in presjeci:
        D = presjek_podaci(K_, pr, teren)
        z0, z1 = raspon_visina(D, pr.s0, pr.s1, K_.P.stadion)
        m_cijeli = None
        for m in MJERILA:
            if m < 200:
                continue
            k = 1000.0 / m
            redova = math.ceil((pr.s1 - pr.s0) * k / sirina_platna - 1e-6)
            if redova <= 3 and redova * ((z1 - z0) * k + 13.0) <= visina_platna:
                m_cijeli = m
                break
        m_cijeli = m_cijeli or 2000
        listovi = [((pr.s0, pr.s1), m_cijeli, 'Cijeli presjek', 'cijeli')]
        for i, (a, b, naz) in enumerate(prozori_izvadaka(K_, pr, D)):
            # najkrupnije mjerilo u kojem jezgra prozora stane u jedan ili dva reda; prozor se zatim širi do
            # pune širine platna. Stadion: cijela zdjela u jednom redu, s tribinama i krovom.
            st_ = naz.startswith('stadion')
            izbor = None
            for m in MJERILA:
                if m < 200:
                    continue
                k = 1000.0 / m
                for redova in (1, 2):
                    sir_m = redova * sirina_platna / k
                    if sir_m < (b - a):
                        continue
                    c = (a + b) / 2
                    pa, pb = c - sir_m / 2, c + sir_m / 2
                    if pa < pr.s0:
                        pa, pb = pr.s0, min(pr.s1, pr.s0 + sir_m)
                    if pb > pr.s1:
                        pa, pb = max(pr.s0, pr.s1 - sir_m), pr.s1
                    za, zb = raspon_visina(D, pa, pb, K_.P.stadion, st_)
                    if redova * ((zb - za) * k + 13.0) <= visina_platna:
                        izbor = (m, pa, pb)
                        break
                if izbor:
                    break
            if izbor and (izbor[0] < 0.8 * m_cijeli or (st_ and izbor[0] <= m_cijeli)):
                listovi.append(((izbor[1], izbor[2]), izbor[0], f'Izvadak: {naz}',
                                'stadion' if st_ else f'izvadak{sum(1 for x in listovi if x[3] != "stadion")}'))
        for j, (prozor, m, naslov_dijela, kljuc) in enumerate(listovi):
            ime = f'{pr.oznaka}-{j + 1}-{kljuc}'
            svg, info = list_presjeka(K_, pr, presjeci, D, teren, prozor, m, naslov_dijela,
                                      f'list {j + 1} od {len(listovi)} presjeka {pr.oznaka}', ime,
                                      sa_stadionom=kljuc in ('cijeli', 'stadion'))
            put = out / f'{ime}.svg'
            svg.zapisi(put)
            zapisi.append({'red': [2, presjeci.index(pr), j, 0], 'datoteka': put.name, 'vrsta': 'presjek',
                           'razina': None, 'naslov': pr.naziv,
                           'podnaslov': naslov_dijela, 'mjerilo': m, 'pretjerivanje_visina': 1.0,
                           'stacionaza_m': [round(prozor[0], 1), round(prozor[1], 1)],
                           'ishodiste_enu_m': [round(v, 2) for v in pr.O], 'smjer': [round(v, 5) for v in pr.u],
                           'dionice': [[round(v, 2) for v in d] for d in pr.dionice]})
            if not tiho:
                print(f'  {put.name}: 1:{m}, {naslov_dijela}, stacionaža {prozor[0]:.0f}–{prozor[1]:.0f} m')
    return zapisi


# --------------------------------------------------------------------------------------------------- iskaz
def naredba_iskaz(K_: Kontekst, out: Path, tiho=False):
    """Iskaz površina (ENU-M) po razinama i kategorijama, popis prostora i tablica sportova: md i csv."""
    P = K_.P
    out.mkdir(parents=True, exist_ok=True)
    sp = K_.sportovi
    for s in P.prostori:
        if s['kat'] == 'garaza':
            K_.raster(s)
    uk_m = sum(s['a'] for s in P.prostori)
    uk_n = sum(s['a_n'] for s in P.prostori)
    try:
        alat = PA.bilanca(P.raw, P.put, PA.Sportovi())
        uk_alat = alat['ukupno']
    except Exception:  # noqa: BLE001
        uk_alat = None
    po_rk, po_k = {}, {}
    for s in P.prostori:
        k = (s['razina'], s['kat'])
        a = po_rk.setdefault(k, [0.0, 0.0, 0])
        a[0] += s['a']
        a[1] += s['a_n']
        a[2] += 1
        b = po_k.setdefault(s['kat'], [0.0, 0])
        b[0] += s['a']
        b[1] += 1

    def raz_posto(m, n):
        if not n:
            return '–'
        d = 100.0 * (m - n) / n
        return ('+' if d >= 0 else '−') + f'{br(abs(d), 2)} %'

    L = [f'# Iskaz površina: {P.naslov()}', '',
         f'**{OZNAKA}.** Površine su tlocrtne površine poligona iz `{P.put.name}` (verzija '
         f'{P.meta.get("verzija", "–")}, datum {P.datum() or "–"}), ne neto ni bruto površine projekta. Prostori '
         'različitih razina koji leže jedan iznad drugoga zbrajaju se svaki za sebe.', '',
         '## Kako su površine izračunate', '',
         '- Sustav: ' + ('program je već zapisan u ENU-M.' if P.u_metrickom else
                         'poligoni su iz nominalnog ENU-N prevedeni u metrički ENU-M (scripts/viz/koordinate.py) i '
                         'tek tada izmjereni.'),
         f'- Zbroj svih prostora u ENU-M: **{br(uk_m, 0)} m²** ({len(P.prostori)} prostora).',
         f'- Zbroj istih poligona u ENU-N: {br(uk_n, 0)} m²'
         + (f'; bilanca alata program_alat.py: {br(uk_alat, 0)} m²' if uk_alat is not None else '') + '.',
         f'- Razlika ENU-M prema ENU-N: **{raz_posto(uk_m, uk_n)}** (očekivano oko +0,7 %: stvarne duljine su veće '
         'oko 0,17 % po x i 0,52 % po y).', '']
    if P.nevaljani:
        L += [f'Preskočeni prostori (nisu uračunati; prag površine {PA.MIN_POVRSINA_M2:g} m²): '
              f'{"; ".join(P.nevaljani)}.', '']
    L += ['## Razine', '', '| Razina | Kota poda (m n. v.) | Površina prostora, ENU-M (m²) | Razlika prema ENU-N |',
          '| --- | --- | --- | --- |']
    for r in P.razine:
        pp = P.po_razini[r['id']]
        m, n = sum(s['a'] for s in pp), sum(s['a_n'] for s in pp)
        L.append(f'| {r["id"]}: {r["naziv"]} | {br(r["kota"], 1)} | {br(m, 0)} | {raz_posto(m, n)} |')
    L.append(f'| **Ukupno** | | **{br(uk_m, 0)}** | {raz_posto(uk_m, uk_n)} |')
    L += ['', '## Površine po razini i kategoriji', '', '| Razina | Kategorija | Površina (m²) | Broj prostora |',
          '| --- | --- | --- | --- |']
    for r in P.razine:
        for k in KAT_RED:
            if (r['id'], k) in po_rk:
                a = po_rk[(r['id'], k)]
                L.append(f'| {r["id"]} | {KAT[k][3]} | {br(a[0], 0)} | {a[2]} |')
    L += ['', '## Površine po kategoriji (sve razine)', '', '| Kategorija | Površina (m²) | Udio | Broj prostora |',
          '| --- | --- | --- | --- |']
    for k, (a, n) in sorted(po_k.items(), key=lambda x: -x[1][0]):
        L.append(f'| {KAT[k][3]} | {br(a, 0)} | {br(100 * a / uk_m, 1) if uk_m else "–"} % | {n} |')
    L += ['', '## Popis prostora', '',
          'Broj je redni broj prostora unutar razine; isti broj stoji na listovima tlocrta i u presjecima '
          '(oznaka razina·broj). h = svijetla visina.', '']
    for r in P.razine:
        pp = P.po_razini[r['id']]
        if not pp:
            continue
        L += [f'### Razina {r["id"]}: {r["naziv"]} (kota poda {br(r["kota"], 1)} m n. v.)', '',
              '| Br. i oznaka | Naziv | Kategorija, pod, visina, kapacitet | Površina (m²) |', '| --- | --- | --- | --- |']
        for s in pp:
            d = [KAT[s['kat']][3]]
            if s['pod'] is not None:
                d.append(f'pod {br(s["pod"], 1)}')
            if s['visina']:
                d.append(f'h {br(s["visina"], 1)} m')
            kap = tekst_kapaciteta(s)
            if kap:
                d.append(kap)
            spt = (tekst_sportova(s, sp) or "").replace("\u00a0", " ")
            if spt:
                d.append(spt)
            L.append(f'| {s["br"]} · {s["id"]} | {s["naziv"]} | {"; ".join(d)} | {bm2(s["a"])} |')
        L.append('')
    gar = [s for s in P.prostori if s['kat'] == 'garaza']
    L += ['## Garaže', '']
    if gar:
        L += ['Raster na crtežu je geometrijska provjera: okomita mjesta 2,5 × 5,0 m i prolaz 6,0 m (PRETPOSTAVKA '
              'crtača), bez stupova i bez mjesta unutar jezgri, rampi i pješačkih izlaza. Nije projekt garaže.', '',
              '| Garaža (razina) | Površina (m²) | Mjesta po programu | Raster na crtežu |', '| --- | --- | --- | --- |']
        zb_p, zb_r = 0, 0
        for s in gar:
            broj = s['kap']['broj'] if s['kap'] and PA.je_broj(s['kap'].get('broj')) else None
            ras = K_.raster_broj.get(s['id'], 0)
            zb_p += broj or 0
            zb_r += ras
            L.append(f'| {s["naziv"]} ({s["razina"]}) | {br(s["a"], 0)} | {br(broj, 0)} | {br(ras, 0)} |')
        L.append(f'| **Ukupno** | {br(sum(s["a"] for s in gar), 0)} | **{br(zb_p, 0)}** | {br(zb_r, 0)} |')
    else:
        L.append('Nema prostora kategorije garaža.')
    L += ['', '## Sportovi', '',
          'Dimenzije igraće površine i pojaseva: scripts/viz/sportovi_dimenzije.json (donje granice; vidi statuse u toj '
          'datoteci). „Nacrtano” je broj borilišta koji je crtač smjestio u prostor uz pune pojaseve; to je shema, ne '
          'kapacitet dvorane. Razredi A i B prema docs/19 (odluka M13); M8 su dodatni sadržaji iz odluke M8.', '',
          '| Sport (razred) | Prostor (razina) | Borilište (m) | Svijetla visina (m) |', '| --- | --- | --- | --- |']
    redci_sport, smjesteni = [], set()
    for s in P.prostori:
        if not (s['sportovi'] or s['kat'] == 'igraliste'):
            continue
        _, opisi = borilista_prostora(s, sp)
        for o in opisi:
            e = o['e']
            if e is not None:
                smjesteni.add(e.get('skupina', e['id']))
            redci_sport.append((s, o))

    def kljuc_reda(x):
        e = x[1]['e']
        raz = (e or {}).get('razred')
        return ({'A': 0, 'B': 1, 'M8': 2}.get(raz, 3), norm((e or {}).get('naziv', x[1]['naziv'])),
                P.razina[x[0]['razina']]['i'], x[0]['br'])
    redci_sport.sort(key=kljuc_reda)
    csv_sport = []
    for s, o in redci_sport:
        e = o['e']
        razred = (e or {}).get('razred') or '–'
        naziv = (e or {}).get('naziv', o['naziv'])
        ig = Sportovi.igraca(e) if e else None
        po = Sportovi.potrebno(e) if e else None
        if ig:
            bor = f'{_mjera(ig[0])} × {_mjera(ig[1])}'
            if po and (po[0] != ig[0] or po[1] != ig[1]):
                bor += f'; s pojasevima {_mjera(po[0])} × {_mjera(po[1])}'
            bor += f'; nacrtano {o["broj"]}'
            if o['napomena']:
                bor += f' ({o["napomena"]})'
        else:
            bor = o['napomena'] or '–'
        mv = (e or {}).get('min_svijetla_visina_m')
        vis = br(s['visina'], 1) if s['visina'] else ('otvoreno' if s['kat'] not in ZATVORENE else '–')
        dovoljna = None
        if mv and s['visina']:
            dovoljna = s['visina'] + 1e-9 >= mv
            vis += f' (najmanje {br(mv, 2 if mv % 1 else 1)}' + ('' if dovoljna else ': PRENISKO') + ')'
        elif mv and s['kat'] in ZATVORENE:
            vis += f' (najmanje {br(mv, 1)}; visina nije zadana)'
        L.append(f'| {naziv} ({razred}) | {s["naziv"]} ({s["razina"]}·{s["br"]}) | {bor} | {vis} |')
        csv_sport.append([(e or {}).get('id', ''), naziv, razred if razred != '–' else '', s['id'], s['naziv'],
                          s['razina'], ig[0] if ig else '', ig[1] if ig else '', po[0] if po else '',
                          po[1] if po else '', o['broj'], '' if o['stane'] is None else ('da' if o['stane'] else 'ne'),
                          s['visina'] if s['visina'] else '', mv if mv else '',
                          '' if dovoljna is None else ('da' if dovoljna else 'ne'),
                          (e or {}).get('status_dimenzija', ''), o['napomena']])
    nesmj = []
    vid = set()
    for e in sp.sp.popis:
        sk = e.get('skupina', e['id'])
        if e.get('razred') in ('A', 'B') and e.get('obvezan_smjestaj', True) and sk not in smjesteni and sk not in vid:
            vid.add(sk)
            nesmj.append(f'{e["naziv"] if sk == e["id"] else sk.replace("_", " ")} ({e["razred"]})')
    dogadaji = []
    for e in sp.sp.popis:
        sk = e.get('skupina', e['id'])
        if e.get('razred') in ('A', 'B') and not e.get('obvezan_smjestaj', True) and sk not in smjesteni and \
                sk not in vid:
            vid.add(sk)
            dogadaji.append(f'{e["naziv"]} ({e["razred"]})')
    L += ['', '### Sportovi razreda A i B bez prostora u programu', '',
          (', '.join(nesmj) + '.') if nesmj else 'Svi sportovi razreda A i B iz sportovi_dimenzije.json imaju prostor.', '']
    if dogadaji:
        L += ['Bez obveznog prostora (događaj ili privremena postava, `obvezan_smjestaj: false` u '
              'scripts/viz/sportovi_dimenzije.json), a program im ne zadaje ni dionicu ni mjesto: '
              + ', '.join(dogadaji) + '. Je li to šetnica ili pokrov kao dionica događaja, pitanje je programa '
              '(OTVORENO).', '']
    L += [
          '## Kontrola', '',
          f'- zbroj po razinama (ENU-M): {br(sum(sum(s["a"] for s in P.po_razini[r["id"]]) for r in P.razine), 1)} m²',
          f'- zbroj po kategorijama (ENU-M): {br(sum(a for a, _ in po_k.values()), 1)} m²',
          f'- zbroj svih prostora (ENU-M): {br(uk_m, 1)} m²; u ENU-N: {br(uk_n, 1)} m²; omjer {br(uk_m / uk_n, 5)}'
          if uk_n else '- nema prostora', '']
    (out / 'iskaz_povrsina.md').write_text('\n'.join(L), encoding='utf-8')
    with open(out / 'iskaz_prostori.csv', 'w', newline='', encoding='utf-8') as f:
        w = csv.writer(f)
        w.writerow(['razina', 'broj', 'id', 'naziv', 'kategorija', 'kota_poda_mnv', 'svijetla_visina_m',
                    'kapacitet_vrsta', 'kapacitet_broj', 'raster_mjesta_na_crtezu', 'sportovi', 'olimpijski_razred',
                    'status', 'povrsina_enu_m_m2', 'povrsina_enu_n_m2'])
        for s in P.prostori:
            kap = s['kap'] or {}
            w.writerow([s['razina'], s['br'], s['id'], s['naziv'], s['kat'], '' if s['pod'] is None else s['pod'],
                        s['visina'] or '', kap.get('vrsta', ''), kap.get('broj', ''),
                        K_.raster_broj.get(s['id'], '') if s['kat'] == 'garaza' else '', '; '.join(s['sportovi']),
                        s['razred'] or '', s['status'], f'{s["a"]:.1f}', f'{s["a_n"]:.1f}'])
    with open(out / 'iskaz_razine_kategorije.csv', 'w', newline='', encoding='utf-8') as f:
        w = csv.writer(f)
        w.writerow(['razina', 'kota_poda_mnv', 'kategorija', 'povrsina_enu_m_m2', 'povrsina_enu_n_m2', 'broj_prostora'])
        for r in P.razine:
            for k in KAT_RED:
                if (r['id'], k) in po_rk:
                    a = po_rk[(r['id'], k)]
                    w.writerow([r['id'], r['kota'], k, f'{a[0]:.1f}', f'{a[1]:.1f}', a[2]])
        w.writerow(['UKUPNO', '', '', f'{uk_m:.1f}', f'{uk_n:.1f}', len(P.prostori)])
    with open(out / 'iskaz_sportovi.csv', 'w', newline='', encoding='utf-8') as f:
        w = csv.writer(f)
        w.writerow(['sport_id', 'sport', 'razred', 'prostor_id', 'prostor', 'razina', 'igraca_duljina_m',
                    'igraca_sirina_m', 'potrebno_duljina_m', 'potrebno_sirina_m', 'nacrtano_borilista', 'stane',
                    'svijetla_visina_m', 'min_svijetla_visina_m', 'visina_dovoljna', 'status_dimenzija', 'napomena'])
        w.writerows(csv_sport)
    if not tiho:
        print(f'  iskaz_povrsina.md, iskaz_prostori.csv, iskaz_razine_kategorije.csv, iskaz_sportovi.csv: '
              f'{br(uk_m, 0)} m² u ENU-M, {raz_posto(uk_m, uk_n)} prema ENU-N')
    return {'ukupno_enu_m': uk_m, 'ukupno_enu_n': uk_n}


# -------------------------------------------------------------------------------------------- PNG i PDF
_JS_IZVOZ = r"""
const { chromium } = require('playwright');
const fs = require('fs');
const path = require('path');
(async () => {
  const posao = JSON.parse(fs.readFileSync(process.argv[2], 'utf8'));
  const b = await chromium.launch();
  if (posao.png.length) {
    const ctx = await b.newContext({ viewport: { width: posao.sirina_px, height: posao.visina_px },
                                     deviceScaleFactor: posao.faktor });
    const page = await ctx.newPage();
    for (const [svg, png] of posao.png) {
      await page.goto('file://' + svg);
      await page.screenshot({ path: png, clip: { x: 0, y: 0, width: posao.sirina_px, height: posao.visina_px } });
    }
    await ctx.close();
  }
  if (posao.pdf) {
    const page = await b.newPage();
    await page.goto('file://' + posao.html);
    await page.pdf({ path: posao.pdf, width: posao.w_mm + 'mm', height: posao.h_mm + 'mm', printBackground: true,
                     margin: { top: 0, right: 0, bottom: 0, left: 0 }, preferCSSPageSize: true });
  }
  await b.close();
})().catch(e => { console.error(String(e && e.stack || e)); process.exit(1); });
"""


def izvezi(out: Path, datoteke, png=True, pdf=None, dulja_px=3500, naslov='Tlocrti i presjeci'):
    """PNG svakog lista i zbirni vektorski PDF preko Chromiuma (Node + playwright). Vrati (broj PNG, put PDF)."""
    out = Path(out).resolve()
    rad = out / '_izvoz'
    rad.mkdir(parents=True, exist_ok=True)
    px_mm = 96.0 / 25.4
    sirina_px, visina_px = math.ceil(LIST_W * px_mm), math.ceil(LIST_H * px_mm)
    posao = {'png': [[str(out / d), str(out / (Path(d).stem + '.png'))] for d in datoteke] if png else [],
             'sirina_px': sirina_px, 'visina_px': visina_px, 'faktor': dulja_px / (LIST_W * px_mm),
             'pdf': None, 'html': None, 'w_mm': LIST_W, 'h_mm': LIST_H}
    if pdf:
        dijelovi_html = []
        for d in datoteke:
            t = (out / d).read_text(encoding='utf-8')
            t = t[t.index('<svg'):]
            dijelovi_html.append(f'<div class="l">{t}</div>')
        html = ('<!DOCTYPE html><html lang="hr"><head><meta charset="utf-8"><title>' + esc(naslov) + '</title><style>'
                f'@page{{size:{f2(LIST_W)}mm {f2(LIST_H)}mm;margin:0}}html,body{{margin:0;padding:0}}'
                f'.l{{width:{f2(LIST_W)}mm;height:{f2(LIST_H)}mm;overflow:hidden;page-break-after:always;'
                'break-after:page}.l:last-child{page-break-after:auto;break-after:auto}svg{display:block}'
                '</style></head><body>' + ''.join(dijelovi_html) + '</body></html>')
        (rad / 'zbirni.html').write_text(html, encoding='utf-8')
        posao['pdf'], posao['html'] = str(Path(pdf).resolve()), str(rad / 'zbirni.html')
    (rad / 'posao.json').write_text(json.dumps(posao), encoding='utf-8')
    (rad / 'izvoz.js').write_text(_JS_IZVOZ, encoding='utf-8')
    try:
        r = subprocess.run(['node', str(rad / 'izvoz.js'), str(rad / 'posao.json')], capture_output=True, text=True,
                           timeout=1500)
    except (OSError, subprocess.TimeoutExpired) as e:
        print(f'NAPOMENA: izvoz PNG/PDF nije uspio ({e}); SVG listovi su zapisani.', file=sys.stderr)
        return 0, None
    if r.returncode != 0:
        print('NAPOMENA: izvoz PNG/PDF nije uspio (Node + playwright); SVG listovi su zapisani.\n' + r.stderr[-800:],
              file=sys.stderr)
        return 0, None
    for f in rad.iterdir():
        f.unlink()
    rad.rmdir()
    return len(posao['png']), posao['pdf']


# ---------------------------------------------------------------------------------------------------- CLI
def _kontekst(a):
    P = Podaci(a.program)
    podloga = Podloga(a.site)
    kote = ucitaj_kote_situacije(a.kote)
    return Kontekst(P, podloga, Sportovi(), kote, a.datum or P.datum())


def list_popisa(K_: Kontekst, listovi):
    """Naslovni list: popis svih listova, konvencije i izvori."""
    P = K_.P
    svg = Svg('L00')
    svg.pravokutnik(RUB, RUB, LIST_W - 2 * RUB, LIST_H - 2 * RUB, rub='#222222', deb=0.3)
    x, y = RUB + 8.0, RUB + 8.0
    w = LIST_W - 2 * RUB - 16.0
    svg.pravokutnik(x, y, w, 9.0, rx=0.8, ispuna='#fff3cd', rub='#b45f06', deb=0.35)
    svg.tekst(x + w / 2, y + 6.0, OZNAKA, 3.4, '#7a3e00', bold=True, sidro='middle')
    y += 17.0
    svg.tekst(x, y, 'Tlocrti po razinama, presjeci i iskaz površina', 5.2, '#111111', bold=True)
    y += 6.5
    for r in prelomi(P.naslov(), 3.0, False, w, 3) or [P.naslov()]:
        svg.tekst(x, y, r, 3.0, '#333333')
        y += 4.0
    svg.tekst(x, y + 0.5, f'Program: {P.put.name}, verzija {P.meta.get("verzija", "–")}, datum {K_.datum}. '
              f'Listova: {len(listovi) + 1} (s ovim naslovnim). Format A3 položeno; sva mjerila vrijede za ispis '
              f'u 100 %.', 2.3, '#333333')
    y += 3.6
    svg.tekst(x, y + 0.5, f'Otisak programa (sha256): {P.otisak}', 2.1, '#333333')
    y += 6.0
    napomene = [
        'Što je ovo: vektorske sheme programa po razinama, nacrtane izravno iz program.json u metričkom sustavu ENU-M. '
        'Nisu geodetska ni projektna podloga i ne dokazuju statiku, požarnu sigurnost, kapacitet ni izvedivost.',
        'Tlocrti: za svaku razinu pregledni list cijelog obuhvata, zatim sektori i detalji gustih dijelova koje alat '
        'određuje grupiranjem prostora. Prostor nosi naziv, površinu (m², ENU-M), svijetlu visinu h i kapacitet; mali '
        'prostori nose broj (redni broj unutar razine) i redak u tablici uz rub lista. Broj u uglatoj zagradi ispred '
        'naziva, npr. [37], isti je redni broj: upisuje se kad natpis stane samo u kraćem obliku.',
        'Borilišta su nacrtana stvarnim mjerama iz scripts/viz/sportovi_dimenzije.json; unutarnje oznake prema '
        'pravilima saveza iz općeg znanja (PRETPOSTAVKA). Garaže: shematski raster 2,5 × 5,0 m s prolazom 6,0 m.',
        'Presjeci: bez visinskog pretjerivanja. Današnje tlo iz DGU modela reljefa i stvarnih kota (GEL-33/2025, '
        'prilog 7.1); projektirana površina iz kote_terena; krov, tribine i pročelje su gruba geometrija.',
        PODLOGE + ' ' + SUSTAV,
    ]
    for t in napomene:
        for r in prelomi(t, 2.15, False, w, 6) or [t]:
            svg.tekst(x, y, r, 2.15, '#222222')
            y += 2.9
        y += 0.9
    y += 2.0
    svg.tekst(x, y, 'Popis listova', 3.0, '#111111', bold=True)
    y += 2.0
    stupaca = 2 if len(listovi) <= 2 * int((LIST_H - RUB - 6.0 - y) // 2.75) else 3
    sw = w / stupaca
    po = math.ceil(len(listovi) / stupaca)
    vel = 1.95 if po * 2.75 <= LIST_H - RUB - 6.0 - y else max(F_PODATAK, 1.95 * (LIST_H - RUB - 6.0 - y) / (po * 2.75))
    rh = vel * 1.41
    for i, z in enumerate(listovi):
        cx = x + (i // po) * sw
        cy = y + (i % po + 1) * rh
        svg.tekst(cx, cy, f'{i + 2}', vel, '#555555')
        svg.tekst(cx + 5.0, cy, Path(z['datoteka']).stem, vel, '#111111', bold=True)
        opis = z['naslov'] + ' · ' + z['podnaslov']
        svg.tekst(cx + 34.0, cy, skrati(opis, vel, False, sw - 34.0 - 19.0), vel, '#222222')
        svg.tekst(cx + sw - 3.0, cy, f'1 : {br(z["mjerilo"], 0)}', vel, '#222222', sidro='end')
    return svg


def zapisi_manifest(out: Path, K_: Kontekst, zapisi):
    stari = {}
    put = out / 'listovi.json'
    if put.is_file():
        try:
            stari = {z['datoteka']: z for z in PA.ucitaj_json(put).get('listovi', [])}
        except Exception:  # noqa: BLE001
            stari = {}
    if zapisi:      # nova naredba zamjenjuje stare listove iste vrste (broj listova ovisi o programu)
        nove_vrste = {z['vrsta'].split('-')[0] for z in zapisi}
        for k in [k for k, z in stari.items() if str(z.get('vrsta', '')).split('-')[0] in nove_vrste]:
            if k not in {z['datoteka'] for z in zapisi}:
                for f in (out / k, out / (Path(k).stem + '.png')):
                    if f.is_file():
                        f.unlink()
            del stari[k]
    for z in zapisi:
        stari[z['datoteka']] = z
    svi = [stari[k] for k in sorted(stari, key=lambda k: (stari[k].get('red') or [9, 0, 0, 0], k))
           if (out / k).is_file() and stari[k].get('vrsta') != 'popis']
    if svi:
        list_popisa(K_, svi).zapisi(out / 'L00-popis-listova.svg')
        svi.insert(0, {'red': [0, 0, 0, 0], 'datoteka': 'L00-popis-listova.svg', 'vrsta': 'popis', 'razina': None,
                       'naslov': 'Popis listova', 'podnaslov': 'naslovni list', 'mjerilo': None})
    put.write_text(json.dumps({
        'oznaka': OZNAKA, 'program': K_.P.put.name, 'program_verzija': K_.P.meta.get('verzija'),
        'program_sha256': K_.P.otisak, 'naziv': K_.P.naslov(), 'datum': K_.datum,
        'spojevi_toplog_puta': K_.P.spojevi_tp,
        'koordinate': 'ENU-M', 'format': 'A3 položeno, 420 x 297 mm', 'listovi': svi}, ensure_ascii=False, indent=1),
        encoding='utf-8')
    return svi


def main(argv=None):
    ap = argparse.ArgumentParser(description=__doc__.split('\n')[0])
    sub = ap.add_subparsers(dest='naredba', required=True)
    for ime in ('crtaj', 'presjek', 'iskaz', 'sve', 'objavi'):
        p = sub.add_parser(ime)
        p.add_argument('program')
        p.add_argument('--out', required=True)
        p.add_argument('--site', default=str(SITE_ZADANO))
        p.add_argument('--kote', default=str(KOTE_ZADANO))
        p.add_argument('--dmr', default=str(DMR_ZADANO))
        p.add_argument('--datum', default=None, help='datum na listovima; zadano meta.datum programa')
        p.add_argument('--linija', action='append', default=[], help='vlastiti presjek "naziv:x1,y1;x2,y2" (ENU-N)')
        p.add_argument('--bez-png', action='store_true')
        p.add_argument('--bez-pdf', action='store_true')
        p.add_argument('--png-px', type=int, default=3000, help='dulja stranica PNG-a u pikselima')
        if ime == 'objavi':
            p.add_argument('--repo-listovi', default=str(OBJAVA_LISTOVI), help='odredište SVG listova i iskaza')
            p.add_argument('--repo-dist', default=str(OBJAVA_DIST), help='odredište PDF-a i PNG-a')
    a = ap.parse_args(argv)
    out = Path(a.out)
    if a.naredba == 'objavi' and out.exists():
        # čista izrada: stari listovi drugog programa ne smiju ostati u manifestu
        for f in out.iterdir():
            if f.is_file() and f.suffix in ('.svg', '.png', '.pdf', '.md', '.csv', '.json'):
                f.unlink()
    try:
        K_ = _kontekst(a)
    except (OSError, ValueError) as e:
        print(f'GREŠKA: program se ne može pročitati: {e}', file=sys.stderr)
        return 2
    if K_.P.nevaljani:
        print(f'NAPOMENA: preskočeni prostori (prag površine {PA.MIN_POVRSINA_M2:g} m²): {"; ".join(K_.P.nevaljani)}',
              file=sys.stderr)
    zapisi = []
    if a.naredba in ('crtaj', 'sve', 'objavi'):
        zapisi += naredba_crtaj(K_, out)
    if a.naredba in ('presjek', 'sve', 'objavi'):
        zapisi += naredba_presjek(K_, out, Teren(a.dmr), a.linija)
    if a.naredba in ('iskaz', 'sve', 'objavi'):
        naredba_iskaz(K_, out)
    svi = zapisi_manifest(out, K_, zapisi)
    print(f'{len(svi)} listova u manifestu {out / "listovi.json"} (ovom naredbom nacrtano {len(zapisi)} i naslovni '
          f'list L00); otisak programa sha256 {K_.P.otisak}')
    if a.naredba in ('sve', 'objavi'):
        dat = [z['datoteka'] for z in svi]
        n, pdf = izvezi(out, dat, png=not a.bez_png, pdf=None if a.bez_pdf else out / PDF_IME,
                        naslov=K_.P.naslov(), dulja_px=a.png_px)
        print(f'PNG: {n}; PDF: {pdf or "nije izrađen"}')
    if a.naredba == 'objavi':
        if a.bez_png or a.bez_pdf or not pdf:
            print('GREŠKA: objava traži PNG i PDF (izvoz nije uspio ili je isključen); ništa nije kopirano.',
                  file=sys.stderr)
            return 3
        sada = otisak_programa(K_.P.put)
        if sada != K_.P.otisak:
            print(f'GREŠKA: program se promijenio za vrijeme izrade (otisak {K_.P.otisak[:12]} na početku, '
                  f'{sada[:12]} sada); ništa nije kopirano. Zamrznite program i ponovite.', file=sys.stderr)
            return 4
        objavi(out, K_, svi, Path(a.repo_listovi), Path(a.repo_dist))
    return 0


OBJAVA_LISTOVI = KORIJEN / 'research' / 'viz' / 'program' / 'tlocrti'
OBJAVA_DIST = KORIJEN / 'dist' / 'assets' / 'viz' / 'tlocrti'
PDF_IME = 'tlocrti_i_presjeci_A3.pdf'


def objavi(out: Path, K_: Kontekst, svi, cilj_listovi: Path, cilj_dist: Path):
    """Kopiraj gotovu izradu: SVG listove, iskaz i manifest u repozitorij (research/viz/program/tlocrti/);
    zbirni PDF, PNG preglednih listova i presjeka te kratki popis u dist/assets/viz/tlocrti/. Stare datoteke
    istih vrsta u odredištima brišu se, da ne ostanu listovi kojih više nema."""
    for cilj, vrste in ((cilj_listovi, ('.svg', '.md', '.csv', '.json')), (cilj_dist, ('.pdf', '.png', '.md'))):
        cilj.mkdir(parents=True, exist_ok=True)
        for f in cilj.iterdir():
            if f.is_file() and f.suffix in vrste:
                f.unlink()
    n_l = 0
    for z in svi:
        shutil.copy2(out / z['datoteka'], cilj_listovi / z['datoteka'])
        n_l += 1
    for f in sorted(out.glob('iskaz_*')) + [out / 'listovi.json']:
        shutil.copy2(f, cilj_listovi / f.name)
    shutil.copy2(out / PDF_IME, cilj_dist / PDF_IME)
    png = [z for z in svi if z['vrsta'] in ('tlocrt-pregled', 'presjek')]
    for z in png:
        ime = Path(z['datoteka']).stem + '.png'
        shutil.copy2(out / ime, cilj_dist / ime)
    L = [f'# Tlocrti i presjeci: objavljene datoteke', '',
         f'**{OZNAKA}.** Vektorske sheme programa po razinama, izrađene alatom `scripts/viz/tlocrti.py` iz '
         f'`{K_.P.put.name}` (verzija {K_.P.meta.get("verzija", "–")}, datum {K_.datum}, otisak sha256 '
         f'`{K_.P.otisak}`). Nisu geodetska ni '
         'projektna podloga. Izvorni SVG listovi, iskaz površina i manifest su u '
         '`research/viz/program/tlocrti/`; opis alata i naredba za ponavljanje u `research/viz/program/TLOCRTI.md`.',
         '', f'- `{PDF_IME}`: svi listovi ({len(svi)} str. formata A3, vektorski, tekst je tekst).',
         f'- PNG ({len(png)}): pregledni list svake razine i svi listovi presjeka, dulja stranica oko 3.000 px.', '',
         '| Datoteka | Sadržaj | Mjerilo (A3) |', '| --- | --- | --- |']
    for z in png:
        L.append(f'| {Path(z["datoteka"]).stem}.png | {z["naslov"]} · {z["podnaslov"]} | '
                 f'1 : {br(z["mjerilo"], 0)} |')
    L += ['', PODLOGE, '']
    (cilj_dist / 'POPIS.md').write_text('\n'.join(L), encoding='utf-8')
    print(f'Objavljeno: {n_l} SVG listova, iskaz i manifest u {cilj_listovi}; PDF, {len(png)} PNG i POPIS.md u '
          f'{cilj_dist}')


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