microsegments 0.1.0__py3-none-any.whl

microsegments/hotspots.py

@@ -0,0 +1,337 @@
+"""Hotspots: stretches of segments where vehicles linger more than at the reference hours.
+
+Per direction, on the display pattern, for every bin (segment x hour, plus the am / pm bands):
+
+1. Day bootstrap (B draws, Rao-Wu rescaled, weekday-stratified, whole days resampled): numerator, passages and
+   reference are recomputed from the same resampled days (``Analysis.estimate`` with day weights).
+2. Candidate bin when
+   * the lower bound of the percentile CI (``level``) of ``excess_per_passage * tick_s`` > ``theta_s``;
+   * daily excess (day's obs/passages minus the full-sample reference) is positive on
+     ≥ ``min_persistence`` of the days with passages;
+   * it passes Benjamini-Hochberg at ``q`` over all tested bins. p-values are one-sided, from the
+     bootstrap standard error (z = (x - θ) / se): percentile p-values cannot go below 1/(B+1), which
+     BH over thousands of bins never accepts.
+3. Temporal persistence: an hourly candidate counts only within a run of ≥ 2 adjacent candidate hours;
+   a band candidate (am / pm) counts for all its hours.
+4. Stretches: candidate segments merge along the pattern with a ``gap``-bin tolerance, and never
+   across a stop / running zone border.
+5. Classes (``fixed_score`` F and ``peak_ratio`` are returned as extra columns):
+   * F = q20 over day hours 6-20 of the stretch occupancy per metre (obs / passage / m), divided by the
+     median of the same quantity over non-candidate segments of the same zone within ±500 m (the
+     "free-flow" level of the day; high when the delay never goes away during the day);
+   * peak_ratio = mean summed excess over peak hours (am / pm bands) / mean over the other day hours;
+   * infrastructure: F ≥ ``f_min`` and peak_ratio < ``peak_ratio``; congestion: peak_ratio ≥
+     ``peak_ratio`` and F < ``f_min``; mixed otherwise.
+   Note: a delay that is also present at the reference hours cancels in the excess and is not detected.
+
+Stretches are ranked by excess observations per day (Σ over stretch hours and segments of
+obs - ref * passages, divided by the number of days).
+"""
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+
+import numpy as np
+import polars as pl
+
+from .metrics import BANDS, BAND_HOUR, Analysis, DirData
+from .schema import HOTSPOT, conform
+
+PEAK_BANDS = ("am", "pm")
+
+
+@dataclass
+class BinStats:
+    """Per-bin statistics of one direction, on the display pattern (columns = output hours + am + pm)."""
+    dd: DirData
+    ks: np.ndarray               # (Kd,) K indices, display order
+    seg_idx: np.ndarray          # (Kd,)
+    x0: np.ndarray
+    length: np.ndarray
+    zone: np.ndarray
+    cols: np.ndarray             # (Hc,) labels: hours, then -1 (am), -2 (pm)
+    x: np.ndarray                # (Hc,Kd) excess per passage (obs / vehicle)
+    est: dict                    # full-sample estimate restricted to (Hc|all hours, Kd), see _cut
+    ci_lo: np.ndarray
+    ci_hi: np.ndarray
+    se: np.ndarray
+    p: np.ndarray
+    reject: np.ndarray
+    persistence: np.ndarray
+    candidate: np.ndarray        # per-bin rule (CI, persistence, BH)
+    draws: np.ndarray            # (B,Hc,Kd) bootstrap excess per passage
+    daily: np.ndarray            # (D,Hc,Kd) daily excess (nan where no passage)
+    theta: float                 # threshold in obs per passage
+
+
+def bootstrap_weights(dow: np.ndarray, B: int, rng: np.random.Generator, stratified: bool = True) -> np.ndarray:
+    """(B, D) day weights of a Rao-Wu rescaled day bootstrap (within each weekday when ``stratified``):
+    n_h - 1 days drawn with replacement in a stratum of n_h days, multiplicities scaled by
+    n_h / (n_h - 1). This removes the (n_h - 1) / n_h variance shrinkage of the naive bootstrap,
+    which matters with few days per weekday. A stratum with one day keeps weight 1."""
+    D = len(dow)
+    W = np.zeros((B, D), np.float32)
+    groups = [np.flatnonzero(dow == w) for w in np.unique(dow)] if stratified else [np.arange(D)]
+    rows = np.arange(B)[:, None]
+    for g in groups:
+        n = len(g)
+        if n == 0:
+            continue
+        if n == 1:
+            W[:, g] = 1.0
+            continue
+        pick = g[rng.integers(0, n, (B, n - 1))]
+        np.add.at(W, (np.broadcast_to(rows, pick.shape), pick), n / (n - 1))
+    return W
+
+
+def _bh(p: np.ndarray, q: float) -> np.ndarray:
+    flat = p.reshape(-1)
+    ok = np.isfinite(flat)
+    out = np.zeros(flat.shape, bool)
+    pv = flat[ok]
+    m = len(pv)
+    if m == 0:
+        return out.reshape(p.shape)
+    order = np.argsort(pv)
+    passed = pv[order] <= q * np.arange(1, m + 1) / m
+    if passed.any():
+        kmax = np.flatnonzero(passed).max()
+        sel = np.zeros(m, bool)
+        sel[order[: kmax + 1]] = True
+        out[np.flatnonzero(ok)[sel]] = True
+    return out.reshape(p.shape)
+
+
+_erfc = np.frompyfunc(math.erfc, 1, 1)
+
+
+def bin_stats(an: Analysis, direction_id: int, *, B: int | None = None, theta_s: float = 2.0, q: float = 0.1,
+              level: float = 0.95, min_persistence: float = 0.6, seed: int = 0, stratified: bool = True,
+              chunk: int = 50) -> BinStats:
+    dd = an.dirs[direction_id]
+    B = an.params.bootstrap if B is None else B
+    tick = an.params.tick_s
+    theta = theta_s / tick
+    ks = dd.pattern_segs[dd.display_uid]
+    out_hours = set(an.hours)
+    ci = np.array([i for i, c in enumerate(dd.cols) if (c >= 0 and int(c) in out_hours)]
+                  + [int(np.flatnonzero(dd.cols == BAND_HOUR[b])[0]) for b in PEAK_BANDS])
+    cols = dd.cols[ci]
+
+    est = an.estimate(direction_id)
+    x = est["excess_per_passage"][0][ci][:, ks]
+
+    rng = np.random.default_rng(seed)
+    W = bootstrap_weights(dd.dow, B, rng, stratified)
+    draws = np.empty((B, len(ci), len(ks)), np.float32)
+    for a in range(0, B, chunk):
+        e = an.estimate(direction_id, W[a:a + chunk])
+        draws[a:a + chunk] = e["excess_per_passage"][:, ci][:, :, ks]
+    alpha = 1 - level
+    with np.errstate(all="ignore"):
+        import warnings
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", RuntimeWarning)
+            lo, hi = np.nanquantile(draws, [alpha / 2, 1 - alpha / 2], axis=0)
+            se = np.nanstd(draws, axis=0, ddof=1)
+    with np.errstate(divide="ignore", invalid="ignore"):
+        z = (x - theta) / se
+        z = np.where(se > 0, z, np.where(x > theta, np.inf, -np.inf))
+        p = 0.5 * _erfc(z / math.sqrt(2)).astype(float)
+    p[~np.isfinite(x)] = np.nan
+    reject = _bh(p, q)
+
+    X = dd.stacked()
+    NM, PM = X["NM"][:, ci][:, :, ks], X["PM"][:, ci][:, :, ks]
+    ref = est["ref"][0][ks]
+    with np.errstate(divide="ignore", invalid="ignore"):
+        daily = np.where(PM > 0, NM / PM - ref[None, None, :], np.nan)
+        npos = (daily > 0).sum(0)
+        nval = np.isfinite(daily).sum(0)
+        pers = np.where(nval > 0, npos / nval, np.nan)
+    cand = (lo > theta) & (pers >= min_persistence) & reject
+    cut = {k: v[0][ci][:, ks] for k, v in est.items() if k != "ref"}
+    cut["ref"] = ref
+    cut["all"] = {k: v[0][:, ks] for k, v in est.items() if k != "ref"}
+    u = dd.display_uid
+    return BinStats(dd=dd, ks=ks, seg_idx=dd.pattern_seg_idx[u], x0=dd.pattern_x0[u], length=dd.seg_len[ks],
+                    zone=dd.seg_zone[ks], cols=cols, x=x, est=cut, ci_lo=lo, ci_hi=hi, se=se, p=p, reject=reject,
+                    persistence=pers, candidate=cand, draws=draws, daily=daily, theta=theta)
+
+
+def bins_frame(st: BinStats) -> pl.DataFrame:
+    Hc, Kd = st.x.shape
+    return pl.DataFrame({
+        "pattern_uid": [st.dd.display_uid] * (Hc * Kd),
+        "direction_id": np.full(Hc * Kd, st.dd.direction_id, np.int8),
+        "seg_idx": np.tile(st.seg_idx, Hc),
+        "hour": np.repeat(st.cols, Kd).astype(np.int8),
+        "excess_per_passage": st.x.reshape(-1),
+        "ci_lo": st.ci_lo.reshape(-1), "ci_hi": st.ci_hi.reshape(-1), "se": st.se.reshape(-1),
+        "p": st.p.reshape(-1), "bh": st.reject.reshape(-1), "persistence": st.persistence.reshape(-1),
+        "candidate": st.candidate.reshape(-1),
+    }, nan_to_null=True)
+
+
+def seg_hours(st: BinStats) -> list[set[int]]:
+    """Hours per segment that pass the temporal rule (≥ 2 adjacent candidate hours, or a whole band)."""
+    hcols = np.flatnonzero(st.cols >= 0)
+    hrs = st.cols[hcols]
+    out = []
+    for j in range(st.x.shape[1]):
+        c = st.candidate[hcols, j]
+        keep: set[int] = set()
+        for i in range(len(hrs)):
+            if not c[i]:
+                continue
+            prev = i > 0 and c[i - 1] and hrs[i - 1] == hrs[i] - 1
+            nxt = i + 1 < len(hrs) and c[i + 1] and hrs[i + 1] == hrs[i] + 1
+            if prev or nxt:
+                keep.add(int(hrs[i]))
+        for b in PEAK_BANDS:
+            bi = np.flatnonzero(st.cols == BAND_HOUR[b])
+            if len(bi) and st.candidate[bi[0], j]:
+                a, z = BANDS[b]
+                keep |= {h for h in range(a, z) if h in set(hrs.tolist())}
+        out.append(keep)
+    return out
+
+
+def stretches(st: BinStats, gap: int = 1) -> list[tuple[int, int, set[int]]]:
+    """[(j0, j1, hours)] in display order (inclusive), merged with a ``gap``-bin tolerance, split at zones."""
+    hs = seg_hours(st)
+    out: list[list] = []
+    for j, h in enumerate(hs):
+        if not h:
+            continue
+        if out:
+            j0, j1, hh = out[-1]
+            if j - j1 <= gap + 1 and all(st.zone[i] == st.zone[j] for i in range(j1, j + 1)):
+                out[-1] = [j0, j, hh | h]
+                continue
+        out.append([j, j, set(h)])
+    return [tuple(s) for s in out]
+
+
+def hotspots(an: Analysis, *, B: int | None = None, theta_s: float = 2.0, q: float = 0.1, level: float = 0.95,
+             min_persistence: float = 0.6, gap: int = 1, f_min: float = 1.5, peak_ratio: float = 2.0,
+             seed: int = 0, stratified: bool = True, links: pl.DataFrame | None = None,
+             stats: dict[int, BinStats] | None = None) -> pl.DataFrame:
+    """Hotspot stretches for every direction of ``an`` (schema.HOTSPOT + extra columns
+    excess_obs_per_day, fixed_score, peak_ratio, seg_keys). ``links`` (schema.LINK) names the stops."""
+    rows = []
+    names = {}
+    if links is not None:
+        for r in links.select("link_key", "from_name", "to_name").iter_rows():
+            names.setdefault(r[0], (r[1], r[2]))
+    for dirid in an.dirs:
+        if len(an.dirs[dirid].days) == 0:
+            continue
+        st = stats[dirid] if stats is not None and dirid in stats else bin_stats(
+            an, dirid, B=B, theta_s=theta_s, q=q, level=level, min_persistence=min_persistence, seed=seed,
+            stratified=stratified)
+        rows += _describe(an, st, stretches(st, gap), names, level, f_min, peak_ratio)
+    schema = {**HOTSPOT, "excess_obs_per_day": pl.Float32, "fixed_score": pl.Float32, "peak_ratio": pl.Float32,
+              "seg_keys": pl.List(pl.Utf8)}
+    if not rows:
+        return pl.DataFrame(schema=schema)
+    df = pl.DataFrame(rows, schema=schema, orient="row")
+    df = df.sort(["direction_id", "excess_obs_per_day"], descending=[False, True])
+    df = df.with_columns(pl.int_range(1, pl.len() + 1).over("direction_id").cast(pl.Int16).alias("rank"))
+    return conform(df, schema)
+
+
+def _describe(an, st: BinStats, strs, names, level, f_min, peak_ratio_min) -> list[tuple]:
+    dd = st.dd
+    hcols = np.flatnonzero(st.cols >= 0)
+    hrs = st.cols[hcols]
+    alpha = 1 - level
+    allc = st.est["all"]
+    hour_cols_all = dd.hour_cols
+    hours_all = dd.cols[hour_cols_all]
+    day_sel = hour_cols_all[(hours_all >= 6) & (hours_all <= 20)]
+    opp_all = allc["obs_per_passage"]                       # (Hx, Kd)
+    cand = np.zeros(len(st.ks), bool)
+    for j0, j1, _ in strs:
+        cand[j0:j1 + 1] = True
+    with np.errstate(all="ignore"):
+        import warnings
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", RuntimeWarning)
+            seg_ff = np.nanquantile(opp_all[day_sel] / st.length[None, :], 0.2, axis=0)
+    mid = st.x0 + st.length / 2
+    D = max(len(dd.days), 1)
+    peak_hours = {h for b in PEAK_BANDS for h in range(*BANDS[b])}
+    obs_h, pas_h, ref = st.est["obs"], st.est["passages"], st.est["ref"]
+    out = []
+    for j0, j1, hours in strs:
+        sl = slice(j0, j1 + 1)
+        hidx = np.array([hcols[np.flatnonzero(hrs == h)[0]] for h in sorted(hours)])
+        sx = np.nansum(st.x[hidx][:, sl], axis=1)
+        pk = int(np.nanargmax(sx))
+        pcol = hidx[pk]
+        peak_hour = int(st.cols[pcol])
+        val = float(sx[pk])
+        d = np.nansum(st.draws[:, pcol, sl], axis=1)
+        lo, hi = np.quantile(d, [alpha / 2, 1 - alpha / 2])
+        dly = st.daily[:, pcol, sl]
+        okd = np.isfinite(dly).all(1)
+        pers = float((dly[okd].sum(1) > 0).mean()) if okd.any() else float("nan")
+        exc_day = float(np.nansum(obs_h[hidx][:, sl] - ref[None, sl] * pas_h[hidx][:, sl]) / D)
+        # fixed score
+        with np.errstate(all="ignore"):
+            occ = np.nansum(opp_all[day_sel][:, sl], axis=1) / st.length[sl].sum()
+            f_num = float(np.nanquantile(occ, 0.2)) if np.isfinite(occ).any() else float("nan")
+        zone = st.zone[j0]
+        c = 0.5 * (mid[j0] + mid[j1])
+        base_m = (~cand) & (st.zone == zone) & np.isfinite(seg_ff)
+        near = base_m & (np.abs(mid - c) <= 500)
+        pool = seg_ff[near] if near.sum() >= 5 else seg_ff[base_m]
+        base = float(np.median(pool)) if len(pool) else float("nan")
+        F = f_num / base if base and base > 0 else float("nan")
+        # peak ratio over day hours, from the full-sample per-hour summed excess
+        dh = [h for h in range(6, 20) if h in set(hrs.tolist())]
+        summed = {h: float(np.nansum(st.x[hcols[np.flatnonzero(hrs == h)[0]], sl])) for h in dh}
+        pv = [v for h, v in summed.items() if h in peak_hours]
+        ov = [v for h, v in summed.items() if h not in peak_hours]
+        pmean = np.mean(pv) if pv else float("nan")
+        omean = np.mean(ov) if ov else float("nan")
+        ratio = float(pmean / max(omean, st.theta / 2)) if np.isfinite(pmean) else float("nan")
+        if np.isfinite(F) and F >= f_min and not ratio >= peak_ratio_min:
+            kind = "infrastructure"
+        elif ratio >= peak_ratio_min and not (np.isfinite(F) and F >= f_min):
+            kind = "congestion"
+        else:
+            kind = "mixed"
+        lk0 = dd.link_keys[dd.seg_link[st.ks[j0]]]
+        lk1 = dd.link_keys[dd.seg_link[st.ks[j1]]]
+        n0 = names.get(lk0, (lk0, None))[0]
+        n1 = names.get(lk1, (None, lk1))[1]
+        out.append((dd.display_uid, dd.direction_id, 0, int(st.seg_idx[j0]), int(st.seg_idx[j1]), float(st.x0[j0]),
+                    float(st.x0[j1] + st.length[j1]), n0, n1, zone, kind, sorted(int(h) for h in hours), peak_hour,
+                    val, float(lo), float(hi), pers, int(dd.V[:, st.ks[sl]].sum(0).min()), exc_day, F, ratio,
+                    dd.seg_keys[st.ks[sl]].tolist()))
+    return out
+
+
+def to_geojson(hotspots: pl.DataFrame, segments: pl.DataFrame) -> dict:
+    """GeoJSON FeatureCollection, one LineString per stretch (concatenated segment geometries)."""
+    geo = {}
+    for (u,), g in segments.select("pattern_uid", "seg_idx", "geometry").group_by(["pattern_uid"]):
+        g = g.sort("seg_idx")
+        geo[u] = (g["seg_idx"].to_numpy(), g["geometry"].to_list())
+    feats = []
+    for r in hotspots.iter_rows(named=True):
+        coords: list = []
+        if r["pattern_uid"] in geo:
+            idx, gs = geo[r["pattern_uid"]]
+            for i in np.flatnonzero((idx >= r["from_seg"]) & (idx <= r["to_seg"])):
+                for pt in gs[i] or []:
+                    if not coords or coords[-1] != list(pt):
+                        coords.append(list(pt))
+        props = {k: (v.isoformat() if hasattr(v, "isoformat") else v) for k, v in r.items()}
+        feats.append({"type": "Feature", "properties": props,
+                      "geometry": {"type": "LineString", "coordinates": coords} if len(coords) >= 2 else None})
+    return {"type": "FeatureCollection", "features": feats}

microsegments/html/__init__.py

@@ -0,0 +1,6 @@
+"""Standalone HTML report (map, hotspots, hour x micro-segment matrix, coverage calendar; fr / en)."""
+from __future__ import annotations
+
+from .export import export, render
+
+__all__ = ["export", "render"]

microsegments/html/export.py

@@ -0,0 +1,96 @@
+"""Standalone HTML report: ``template.html`` filled with the JSON contract (``report.to_contract``).
+
+The page needs Leaflet JS from cdnjs (and, if ``tiles``, CARTO base-map tiles) for the map; the
+matrix, profile, hotspots and coverage calendar work offline. Leaflet's CSS is inlined.
+"""
+from __future__ import annotations
+
+import html
+import json
+import re
+from importlib import resources
+from pathlib import Path
+from typing import Any
+
+PLACEHOLDERS = ("__LANG__", "__TITLE__", "__DESC__", "__LEAFLETCSS__", "__DATA__")
+
+
+def _resource(name: str) -> str:
+    return resources.files("microsegments.html").joinpath(name).read_text(encoding="utf-8")
+
+
+def _contract(obj, **kw) -> dict[str, Any]:
+    if isinstance(obj, dict):
+        return obj
+    from ..metrics import Analysis
+    from ..report import to_contract
+    if isinstance(obj, Analysis):
+        return to_contract(obj, **kw)
+    if hasattr(obj, "contract"):            # pipeline.RunResult
+        return obj.contract(**kw)
+    raise TypeError(f"expected an Analysis, a RunResult or a contract dict, got {type(obj).__name__}")
+
+
+def _json_for_script(data: dict) -> str:
+    s = json.dumps(data, separators=(",", ":"), ensure_ascii=False, allow_nan=False, default=str)
+    # safe inside <script type="application/json">
+    return s.replace("<", "\\u003c").replace(">", "\\u003e").replace("&", "\\u0026") \
+        .replace("\u2028", "\\u2028").replace("\u2029", "\\u2029")
+
+
+def _default_title(c: dict, lang: str) -> str:
+    line = c.get("line") or ""
+    d = (c.get("dirs") or [{}])[0]
+    ends = f"{d.get('from')} ↔ {d.get('to')}" if d.get("from") else ""
+    if lang == "en":
+        return f"Line {line}, observations per micro-segment" + (f" ({ends})" if ends else "")
+    return f"Ligne {line}, observations par microsegment" + (f" ({ends})" if ends else "")
+
+
+def render(analysis_or_contract, *, title: str | None = None, lang: str = "fr", tiles: bool = True,
+           scales: dict | None = None, description: str | None = None, **contract_kw) -> str:
+    """The full HTML document as a string. ``scales``: fixed colour-scale tops, e.g.
+    ``{"oph": 20, "opp": 3, "ex": 1.5, "oph10": 8}`` (or ``{"oph": {"true": 20, "false": 6}}`` per
+    stop-zone toggle); default: p98 of the 6-21 h values. ``contract_kw`` go to ``to_contract`` when an
+    Analysis / RunResult is given."""
+    c = dict(_contract(analysis_or_contract, **contract_kw))
+    c["tiles"] = bool(tiles)
+    if scales:
+        c["scales"] = scales
+    if title:
+        c["title"] = title
+    page_title = c.get("title") or _default_title(c, lang)
+    p = c.get("period") or {}
+    desc = description or (
+        f"{page_title}. {p.get('first', '')} – {p.get('last', '')}, {p.get('days', 0)} "
+        + ("days." if lang == "en" else "jours."))
+    out = _resource("template.html")
+    out = out.replace("__LANG__", "en" if lang == "en" else "fr")
+    out = out.replace("__TITLE__", html.escape(page_title))
+    out = out.replace("__DESC__", html.escape(desc, quote=True))
+    out = out.replace("__LEAFLETCSS__", _resource("leaflet.min.css"))
+    out = out.replace("__DATA__", _json_for_script(c))
+    left = [m for m in re.findall(r"__[A-Z]+__", out) if m in PLACEHOLDERS]
+    if left:  # pragma: no cover - template bug
+        raise RuntimeError(f"unfilled placeholders {left}")
+    return out
+
+
+def export(analysis_or_contract, path: str | Path, *, title: str | None = None, lang: str = "fr",
+           standalone: bool = True, tiles: bool = True, scales: dict | None = None, **contract_kw) -> Path:
+    """Write the report to ``path``. ``analysis_or_contract``: an ``Analysis``, a ``RunResult`` or a
+    contract dict (``report.to_contract``). ``standalone`` (default): a complete HTML document; False:
+    only what goes inside ``<body>`` (head elements included inline), to embed in another page."""
+    page = render(analysis_or_contract, title=title, lang=lang, tiles=tiles, scales=scales, **contract_kw)
+    if not standalone:
+        head = re.search(r"<head>(.*)</head>", page, re.DOTALL).group(1)
+        body = re.search(r"<body>(.*)</body>", page, re.DOTALL).group(1)
+        head = re.sub(r"<meta[^>]*>\n?", "", head)
+        page = head + body
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(page, encoding="utf-8")
+    return path
+
+
+__all__ = ["export", "render"]

microsegments/html/leaflet.min.css

@@ -0,0 +1,2 @@
+/* Leaflet 1.9.4 CSS - BSD-2-Clause - (c) 2010-2023 Volodymyr Agafonkin, (c) 2010-2011 CloudMade */
+.leaflet-image-layer,.leaflet-layer,.leaflet-marker-icon,.leaflet-marker-shadow,.leaflet-pane,.leaflet-pane>canvas,.leaflet-pane>svg,.leaflet-tile,.leaflet-tile-container,.leaflet-zoom-box{position:absolute;left:0;top:0}.leaflet-container{overflow:hidden}.leaflet-marker-icon,.leaflet-marker-shadow,.leaflet-tile{-webkit-user-select:none;-moz-user-select:none;user-select:none;-webkit-user-drag:none}.leaflet-tile::selection{background:0 0}.leaflet-safari .leaflet-tile{image-rendering:-webkit-optimize-contrast}.leaflet-safari .leaflet-tile-container{width:1600px;height:1600px;-webkit-transform-origin:0 0}.leaflet-marker-icon,.leaflet-marker-shadow{display:block}.leaflet-container .leaflet-overlay-pane svg{max-width:none!important;max-height:none!important}.leaflet-container .leaflet-marker-pane img,.leaflet-container .leaflet-shadow-pane img,.leaflet-container .leaflet-tile,.leaflet-container .leaflet-tile-pane img,.leaflet-container img.leaflet-image-layer{max-width:none!important;max-height:none!important;width:auto;padding:0}.leaflet-container img.leaflet-tile{mix-blend-mode:plus-lighter}.leaflet-container.leaflet-touch-zoom{-ms-touch-action:pan-x pan-y;touch-action:pan-x pan-y}.leaflet-container.leaflet-touch-drag{-ms-touch-action:pinch-zoom;touch-action:none;touch-action:pinch-zoom}.leaflet-container.leaflet-touch-drag.leaflet-touch-zoom{-ms-touch-action:none;touch-action:none}.leaflet-container{-webkit-tap-highlight-color:transparent}.leaflet-container a{-webkit-tap-highlight-color:rgba(51,181,229,.4)}.leaflet-tile{filter:inherit;visibility:hidden}.leaflet-tile-loaded{visibility:inherit}.leaflet-zoom-box{width:0;height:0;-moz-box-sizing:border-box;box-sizing:border-box;z-index:800}.leaflet-overlay-pane svg{-moz-user-select:none}.leaflet-pane{z-index:400}.leaflet-tile-pane{z-index:200}.leaflet-overlay-pane{z-index:400}.leaflet-shadow-pane{z-index:500}.leaflet-marker-pane{z-index:600}.leaflet-tooltip-pane{z-index:650}.leaflet-popup-pane{z-index:700}.leaflet-map-pane canvas{z-index:100}.leaflet-map-pane svg{z-index:200}.leaflet-vml-shape{width:1px;height:1px}.lvml{behavior:url(#default#VML);display:inline-block;position:absolute}.leaflet-control{position:relative;z-index:800;pointer-events:visiblePainted;pointer-events:auto}.leaflet-bottom,.leaflet-top{position:absolute;z-index:1000;pointer-events:none}.leaflet-top{top:0}.leaflet-right{right:0}.leaflet-bottom{bottom:0}.leaflet-left{left:0}.leaflet-control{float:left;clear:both}.leaflet-right .leaflet-control{float:right}.leaflet-top .leaflet-control{margin-top:10px}.leaflet-bottom .leaflet-control{margin-bottom:10px}.leaflet-left .leaflet-control{margin-left:10px}.leaflet-right .leaflet-control{margin-right:10px}.leaflet-fade-anim .leaflet-popup{opacity:0;-webkit-transition:opacity .2s linear;-moz-transition:opacity .2s linear;transition:opacity .2s linear}.leaflet-fade-anim .leaflet-map-pane .leaflet-popup{opacity:1}.leaflet-zoom-animated{-webkit-transform-origin:0 0;-ms-transform-origin:0 0;transform-origin:0 0}svg.leaflet-zoom-animated{will-change:transform}.leaflet-zoom-anim .leaflet-zoom-animated{-webkit-transition:-webkit-transform .25s cubic-bezier(0,0,.25,1);-moz-transition:-moz-transform .25s cubic-bezier(0,0,.25,1);transition:transform .25s cubic-bezier(0,0,.25,1)}.leaflet-pan-anim .leaflet-tile,.leaflet-zoom-anim .leaflet-tile{-webkit-transition:none;-moz-transition:none;transition:none}.leaflet-zoom-anim .leaflet-zoom-hide{visibility:hidden}.leaflet-interactive{cursor:pointer}.leaflet-grab{cursor:-webkit-grab;cursor:-moz-grab;cursor:grab}.leaflet-crosshair,.leaflet-crosshair .leaflet-interactive{cursor:crosshair}.leaflet-control,.leaflet-popup-pane{cursor:auto}.leaflet-dragging .leaflet-grab,.leaflet-dragging .leaflet-grab .leaflet-interactive,.leaflet-dragging .leaflet-marker-draggable{cursor:move;cursor:-webkit-grabbing;cursor:-moz-grabbing;cursor:grabbing}.leaflet-image-layer,.leaflet-marker-icon,.leaflet-marker-shadow,.leaflet-pane>svg path,.leaflet-tile-container{pointer-events:none}.leaflet-image-layer.leaflet-interactive,.leaflet-marker-icon.leaflet-interactive,.leaflet-pane>svg path.leaflet-interactive,svg.leaflet-image-layer.leaflet-interactive path{pointer-events:visiblePainted;pointer-events:auto}.leaflet-container{background:#ddd;outline-offset:1px}.leaflet-container a{color:#0078a8}.leaflet-zoom-box{border:2px dotted #38f;background:rgba(255,255,255,.5)}.leaflet-container{font-family:"Helvetica Neue",Arial,Helvetica,sans-serif;font-size:12px;font-size:.75rem;line-height:1.5}.leaflet-bar{box-shadow:0 1px 5px rgba(0,0,0,.65);border-radius:4px}.leaflet-bar a{background-color:#fff;border-bottom:1px solid #ccc;width:26px;height:26px;line-height:26px;display:block;text-align:center;text-decoration:none;color:#000}.leaflet-bar a,.leaflet-control-layers-toggle{background-position:50% 50%;background-repeat:no-repeat;display:block}.leaflet-bar a:focus,.leaflet-bar a:hover{background-color:#f4f4f4}.leaflet-bar a:first-child{border-top-left-radius:4px;border-top-right-radius:4px}.leaflet-bar a:last-child{border-bottom-left-radius:4px;border-bottom-right-radius:4px;border-bottom:none}.leaflet-bar a.leaflet-disabled{cursor:default;background-color:#f4f4f4;color:#bbb}.leaflet-touch .leaflet-bar a{width:30px;height:30px;line-height:30px}.leaflet-touch .leaflet-bar a:first-child{border-top-left-radius:2px;border-top-right-radius:2px}.leaflet-touch .leaflet-bar a:last-child{border-bottom-left-radius:2px;border-bottom-right-radius:2px}.leaflet-control-zoom-in,.leaflet-control-zoom-out{font:bold 18px 'Lucida Console',Monaco,monospace;text-indent:1px}.leaflet-touch .leaflet-control-zoom-in,.leaflet-touch .leaflet-control-zoom-out{font-size:22px}.leaflet-control-layers{box-shadow:0 1px 5px rgba(0,0,0,.4);background:#fff;border-radius:5px}.leaflet-control-layers-toggle{background-image:url(images/layers.png);width:36px;height:36px}.leaflet-retina .leaflet-control-layers-toggle{background-image:url(images/layers-2x.png);background-size:26px 26px}.leaflet-touch .leaflet-control-layers-toggle{width:44px;height:44px}.leaflet-control-layers .leaflet-control-layers-list,.leaflet-control-layers-expanded .leaflet-control-layers-toggle{display:none}.leaflet-control-layers-expanded .leaflet-control-layers-list{display:block;position:relative}.leaflet-control-layers-expanded{padding:6px 10px 6px 6px;color:#333;background:#fff}.leaflet-control-layers-scrollbar{overflow-y:scroll;overflow-x:hidden;padding-right:5px}.leaflet-control-layers-selector{margin-top:2px;position:relative;top:1px}.leaflet-control-layers label{display:block;font-size:13px;font-size:1.08333em}.leaflet-control-layers-separator{height:0;border-top:1px solid #ddd;margin:5px -10px 5px -6px}.leaflet-default-icon-path{background-image:url(images/marker-icon.png)}.leaflet-container .leaflet-control-attribution{background:#fff;background:rgba(255,255,255,.8);margin:0}.leaflet-control-attribution,.leaflet-control-scale-line{padding:0 5px;color:#333;line-height:1.4}.leaflet-control-attribution a{text-decoration:none}.leaflet-control-attribution a:focus,.leaflet-control-attribution a:hover{text-decoration:underline}.leaflet-attribution-flag{display:inline!important;vertical-align:baseline!important;width:1em;height:.6669em}.leaflet-left .leaflet-control-scale{margin-left:5px}.leaflet-bottom .leaflet-control-scale{margin-bottom:5px}.leaflet-control-scale-line{border:2px solid #777;border-top:none;line-height:1.1;padding:2px 5px 1px;white-space:nowrap;-moz-box-sizing:border-box;box-sizing:border-box;background:rgba(255,255,255,.8);text-shadow:1px 1px #fff}.leaflet-control-scale-line:not(:first-child){border-top:2px solid #777;border-bottom:none;margin-top:-2px}.leaflet-control-scale-line:not(:first-child):not(:last-child){border-bottom:2px solid #777}.leaflet-touch .leaflet-bar,.leaflet-touch .leaflet-control-attribution,.leaflet-touch .leaflet-control-layers{box-shadow:none}.leaflet-touch .leaflet-bar,.leaflet-touch .leaflet-control-layers{border:2px solid rgba(0,0,0,.2);background-clip:padding-box}.leaflet-popup{position:absolute;text-align:center;margin-bottom:20px}.leaflet-popup-content-wrapper{padding:1px;text-align:left;border-radius:12px}.leaflet-popup-content{margin:13px 24px 13px 20px;line-height:1.3;font-size:13px;font-size:1.08333em;min-height:1px}.leaflet-popup-content p{margin:17px 0;margin:1.3em 0}.leaflet-popup-tip-container{width:40px;height:20px;position:absolute;left:50%;margin-top:-1px;margin-left:-20px;overflow:hidden;pointer-events:none}.leaflet-popup-tip{width:17px;height:17px;padding:1px;margin:-10px auto 0;pointer-events:auto;-webkit-transform:rotate(45deg);-moz-transform:rotate(45deg);-ms-transform:rotate(45deg);transform:rotate(45deg)}.leaflet-popup-content-wrapper,.leaflet-popup-tip{background:#fff;color:#333;box-shadow:0 3px 14px rgba(0,0,0,.4)}.leaflet-container a.leaflet-popup-close-button{position:absolute;top:0;right:0;border:none;text-align:center;width:24px;height:24px;font:16px/24px Tahoma,Verdana,sans-serif;color:#757575;text-decoration:none;background:0 0}.leaflet-container a.leaflet-popup-close-button:focus,.leaflet-container a.leaflet-popup-close-button:hover{color:#585858}.leaflet-popup-scrolled{overflow:auto}.leaflet-oldie .leaflet-popup-content-wrapper{-ms-zoom:1}.leaflet-oldie .leaflet-popup-tip{width:24px;margin:0 auto}.leaflet-oldie .leaflet-control-layers,.leaflet-oldie .leaflet-control-zoom,.leaflet-oldie .leaflet-popup-content-wrapper,.leaflet-oldie .leaflet-popup-tip{border:1px solid #999}.leaflet-div-icon{background:#fff;border:1px solid #666}.leaflet-tooltip{position:absolute;padding:6px;background-color:#fff;border:1px solid #fff;border-radius:3px;color:#222;white-space:nowrap;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;pointer-events:none;box-shadow:0 1px 3px rgba(0,0,0,.4)}.leaflet-tooltip.leaflet-interactive{cursor:pointer;pointer-events:auto}.leaflet-tooltip-bottom:before,.leaflet-tooltip-left:before,.leaflet-tooltip-right:before,.leaflet-tooltip-top:before{position:absolute;pointer-events:none;border:6px solid transparent;background:0 0;content:""}.leaflet-tooltip-bottom{margin-top:6px}.leaflet-tooltip-top{margin-top:-6px}.leaflet-tooltip-bottom:before,.leaflet-tooltip-top:before{left:50%;margin-left:-6px}.leaflet-tooltip-top:before{bottom:0;margin-bottom:-12px;border-top-color:#fff}.leaflet-tooltip-bottom:before{top:0;margin-top:-12px;margin-left:-6px;border-bottom-color:#fff}.leaflet-tooltip-left{margin-left:-6px}.leaflet-tooltip-right{margin-left:6px}.leaflet-tooltip-left:before,.leaflet-tooltip-right:before{top:50%;margin-top:-6px}.leaflet-tooltip-left:before{right:0;margin-right:-12px;border-left-color:#fff}.leaflet-tooltip-right:before{left:0;margin-left:-12px;border-right-color:#fff}@media print{.leaflet-control{-webkit-print-color-adjust:exact;print-color-adjust:exact}}