fix: coastline rework

data/kronshtadt_cuts.geojson

@@ -0,0 +1,38 @@
+{
+  "type": "FeatureCollection",
+  "features": [
+    {
+      "type": "Feature",
+      "properties": {"name": "north-east ear cut"},
+      "geometry": {
+        "type": "LineString",
+        "coordinates": [
+          [29.761036841326387, 60.021661076922044],
+          [29.762484232397355, 60.01903326732494]
+        ]
+      }
+    },
+    {
+      "type": "Feature",
+      "properties": {"name": "south-west ear cut"},
+      "geometry": {
+        "type": "LineString",
+        "coordinates": [
+          [29.686663466388694, 59.993833135687055],
+          [29.70662355596363, 59.989413501298884]
+        ]
+      }
+    },
+    {
+      "type": "Feature",
+      "properties": {"name": "first northern port"},
+      "geometry": {
+        "type": "LineString",
+        "coordinates": [
+          [29.743139525632785, 60.02137813492695],
+          [29.746746668132545, 60.02145744067599]
+        ]
+      }
+    }
+  ]
+}

pages/1_map.py

@@ -3,7 +3,15 @@
 import streamlit as st
 import pydeck as pdk
 
-from src.data import load_zones_geojson, load_passages, load_stations_raw
+from shapely.geometry import mapping
+
+from src.data import (
+    load_kronshtadt_outline,
+    load_passages,
+    load_shoreline,
+    load_stations_raw,
+    load_zones_geojson,
+)
 from src.config import get_config_value, MAPBOX_TOKEN
 
 st.set_page_config(page_title="Карта", layout="wide")
@@ -15,10 +23,12 @@ def get_data():
     zones = load_zones_geojson()
     passages = load_passages()
     stations = load_stations_raw()
-    return zones, passages, stations
+    mainland_geom = mapping(load_shoreline())
+    kron_geom = mapping(load_kronshtadt_outline())
+    return zones, passages, stations, mainland_geom, kron_geom
 
 
-zones, passages, stations = get_data()
+zones, passages, stations, mainland_geom, kron_geom = get_data()
 station_charset = '"' + "".join(sorted({ch for s in stations for ch in s["name"]})) + '"'
 
 zones_colored = {
@@ -55,6 +65,28 @@ zone_layer = pdk.Layer(
     pickable=True,
 )
 
+mainland_layer = pdk.Layer(
+    "GeoJsonLayer",
+    data={"type": "Feature", "geometry": mainland_geom, "properties": {"name": "Берег материка"}},
+    stroked=True,
+    filled=False,
+    get_line_color=[230, 30, 60, 80],    # magenta-red, translucent
+    get_line_width=70,
+    line_width_min_pixels=2,
+    pickable=True,
+)
+
+kronshtadt_layer = pdk.Layer(
+    "GeoJsonLayer",
+    data={"type": "Feature", "geometry": kron_geom, "properties": {"name": "Берег Кронштадта"}},
+    stroked=True,
+    filled=False,
+    get_line_color=[20, 200, 230, 80],   # cyan, translucent
+    get_line_width=70,
+    line_width_min_pixels=2,
+    pickable=True,
+)
+
 passage_layer = pdk.Layer(
     "ScatterplotLayer",
     data=passages_data,
@@ -91,7 +123,7 @@ map_style = get_config_value("map_style")
 
 st.pydeck_chart(
     pdk.Deck(
-        layers=[zone_layer, passage_layer, station_layer, station_labels],
+        layers=[zone_layer, mainland_layer, kronshtadt_layer, passage_layer, station_layer, station_labels],
         initial_view_state=view,
         tooltip={"text": "{name}"},
         map_style=map_style,
@@ -99,3 +131,9 @@ st.pydeck_chart(
     ),
     height=800,
 )
+
+st.caption(
+    "🟥 Берег материка (`shoreline.geojson`) — источник кандидатов «материк». "
+    "🟦 Контур Кронштадта (включая прилегающие сегменты КЗС) — источник кандидатов «остров». "
+    "Тёмные обводы зон — полные границы акватории (туда станции уже не сэмплируются)."
+)

src/data.py

@@ -7,7 +7,7 @@ from pathlib import Path
 
 import numpy as np
 from shapely import contains_xy
-from shapely.geometry import shape
+from shapely.geometry import LineString, MultiLineString, Point, box, shape
 from shapely.ops import unary_union
 
 DATA_DIR = Path(__file__).resolve().parent.parent / "data"
@@ -89,6 +89,106 @@ def load_zone_polygons() -> list[tuple[str, any]]:
     ]
 
 
+# Bounding box around Kronshtadt island (incl. КЗС causeway segments alongside it).
+# Used to extract the island outline from zone outer rings.
+KRONSHTADT_BBOX = (29.62, 59.97, 29.83, 60.04)  # (lon_min, lat_min, lon_max, lat_max)
+
+# Minimum length (in degrees) for a Kronshtadt outline segment to be kept.
+# Drops tiny artifact runs (~21 pts near С-2 entry).
+_KRONSHTADT_MIN_PART_LEN_DEG = 0.005
+
+# Tolerance for detecting whether a fragment touches an "ear tip" (endpoint of
+# the original outer-ring run inside the bbox). ~10m at this latitude.
+_KRONSHTADT_EAR_TOL_DEG = 1e-4
+
+
+@lru_cache(maxsize=1)
+def load_kronshtadt_cuts():
+    """User-provided line segments that trim КЗС "ears" from the Kronshtadt outline."""
+    with open(DATA_DIR / "kronshtadt_cuts.geojson", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def _extract_runs_in_bbox(bbox) -> list[LineString]:
+    runs: list[LineString] = []
+    for _zone_name, polygon in load_zone_polygons():
+        coords = list(polygon.exterior.coords)
+        cur: list[tuple[float, float]] = []
+        for x, y in coords:
+            if bbox.covers(Point(x, y)):
+                cur.append((x, y))
+            else:
+                if len(cur) >= 2:
+                    runs.append(LineString(cur))
+                cur = []
+        if len(cur) >= 2:
+            runs.append(LineString(cur))
+    return runs
+
+
+@lru_cache(maxsize=1)
+def load_kronshtadt_outline():
+    """Outline of Kronshtadt as a MultiLineString.
+
+    Pipeline:
+    1. Take north + south zone outer rings restricted to KRONSHTADT_BBOX.
+    2. Split each run at intersections with cuts from `kronshtadt_cuts.geojson`.
+    3. Drop fragments that touch an original run endpoint — these are the КЗС
+       causeway "ears" approaching С-1 / С-2.
+    4. Drop fragments whose both endpoints lie on the SAME cut — these are
+       inlets (ports) where the contour wraps in and out across one cut line.
+    5. Drop fragments shorter than `_KRONSHTADT_MIN_PART_LEN_DEG`.
+    """
+    from shapely.ops import split, unary_union
+
+    bbox = box(*KRONSHTADT_BBOX)
+    raw_runs = _extract_runs_in_bbox(bbox)
+    if not raw_runs:
+        raise RuntimeError("Kronshtadt outline extraction returned no segments")
+
+    ear_tips = []
+    for run in raw_runs:
+        ear_tips.append(Point(run.coords[0]))
+        ear_tips.append(Point(run.coords[-1]))
+
+    cuts_geojson = load_kronshtadt_cuts()
+    cut_lines = [shape(f["geometry"]) for f in cuts_geojson["features"]]
+    cuts_union = unary_union(cut_lines) if cut_lines else None
+
+    def closest_cut_idx(pt: Point) -> int | None:
+        if not cut_lines:
+            return None
+        dists = [pt.distance(c) for c in cut_lines]
+        return int(min(range(len(cut_lines)), key=lambda i: dists[i]))
+
+    kept: list[LineString] = []
+    for run in raw_runs:
+        pieces = [run]
+        if cuts_union is not None and run.intersects(cuts_union):
+            split_result = split(run, cuts_union)
+            pieces = [g for g in split_result.geoms if isinstance(g, LineString)]
+        for piece in pieces:
+            if piece.length < _KRONSHTADT_MIN_PART_LEN_DEG:
+                continue
+            if any(piece.distance(t) < _KRONSHTADT_EAR_TOL_DEG for t in ear_tips):
+                continue
+            # Detect inlet: both ends lie on the same cut LineString (within tol).
+            if cut_lines:
+                a = Point(piece.coords[0])
+                b = Point(piece.coords[-1])
+                ia, ib = closest_cut_idx(a), closest_cut_idx(b)
+                if ia is not None and ia == ib:
+                    da = a.distance(cut_lines[ia])
+                    db = b.distance(cut_lines[ib])
+                    if da < _KRONSHTADT_EAR_TOL_DEG and db < _KRONSHTADT_EAR_TOL_DEG:
+                        continue
+            kept.append(piece)
+
+    if not kept:
+        raise RuntimeError("Kronshtadt outline: nothing left after cuts")
+    return MultiLineString(kept)
+
+
 @lru_cache(maxsize=1)
 def _north_zone_union():
     return unary_union([p for name, p in load_zone_polygons() if name == "north"])

src/optimization/__init__.py

@@ -10,7 +10,13 @@ Public API:
 """
 
 from .algorithms import Solution, greedy, greedy_then_swap, local_swap
-from .candidates import sample_shore_candidates, sample_shore_points
+from .candidates import (
+    sample_kronshtadt_candidates,
+    sample_kronshtadt_points,
+    sample_mainland_candidates,
+    sample_mainland_points,
+    sample_shore_candidates,
+)
 from .objective import (
     SeparableObjective,
     expected_failure,
@@ -29,7 +35,10 @@ __all__ = [
     "from_stations",
     "attach_travel_times",
     "sample_shore_candidates",
-    "sample_shore_points",
+    "sample_mainland_candidates",
+    "sample_mainland_points",
+    "sample_kronshtadt_candidates",
+    "sample_kronshtadt_points",
     "Problem",
     "Solution",
     "greedy",

src/optimization/candidates.py

@@ -1,4 +1,14 @@
-"""Sample candidate placements along the shore (boundary of water polygons)."""
+"""Sample candidate placements along the mainland shore and the Kronshtadt outline.
+
+Two physical sources:
+- Mainland coast — `load_shoreline()` (curated north + south mainland LineStrings).
+- Kronshtadt outline — `load_kronshtadt_outline()` (extracted from zone outer rings
+  inside the Kronshtadt bbox; includes adjacent КЗС causeway segments).
+
+`sample_shore_candidates` returns the union of both. Other water-boundary points
+(small islands, the dam outside Kronshtadt) are intentionally excluded — placing a
+rescue station there is not physically meaningful.
+"""
 
 from typing import Sequence
 
@@ -7,13 +17,16 @@ from scipy.sparse import csr_matrix
 from shapely.geometry import LineString, MultiLineString
 from shapely.ops import transform
 
-from ..data import load_water_polygon
+from ..data import load_kronshtadt_outline, load_shoreline
 from ..grid import METERS_PER_DEG_LAT, METERS_PER_DEG_LON
 from .placement import PlacementSet, attach_travel_times
 
 
 def _to_meters(geom):
-    return transform(lambda lon, lat, z=None: (lon * METERS_PER_DEG_LON, lat * METERS_PER_DEG_LAT), geom)
+    return transform(
+        lambda lon, lat, z=None: (lon * METERS_PER_DEG_LON, lat * METERS_PER_DEG_LAT),
+        geom,
+    )
 
 
 def _from_meters(x: float, y: float) -> tuple[float, float]:
@@ -33,22 +46,21 @@ def _iter_linestrings(geom) -> list[LineString]:
     raise TypeError(f"unsupported boundary geometry: {type(geom).__name__}")
 
 
-def sample_shore_points(step_m: float = 300.0) -> tuple[np.ndarray, np.ndarray]:
-    """Walk along the water boundary in local meters and sample every `step_m`.
-
-    Returns (lats, lons). Includes outer shores AND interior holes (Кронштадт).
-    """
+def _sample_along(
+    geom,
+    step_m: float,
+    min_segment_m: float = 200.0,
+) -> tuple[np.ndarray, np.ndarray]:
+    """Walk every linestring in `geom` (lon/lat) and emit a point every step_m meters."""
     if step_m <= 0:
         raise ValueError("step_m must be positive")
 
-    water = load_water_polygon()
-    boundary_m = _to_meters(water.boundary)
-
+    geom_m = _to_meters(geom)
     lats: list[float] = []
     lons: list[float] = []
-    for line in _iter_linestrings(boundary_m):
+    for line in _iter_linestrings(geom_m):
         L = line.length
-        if L <= 0:
+        if L < min_segment_m:
             continue
         n_steps = max(1, int(np.floor(L / step_m)))
         for k in range(n_steps):
@@ -56,54 +68,128 @@ def sample_shore_points(step_m: float = 300.0) -> tuple[np.ndarray, np.ndarray]:
             la, lo = _from_meters(pt.x, pt.y)
             lats.append(la)
             lons.append(lo)
-
     return np.asarray(lats, dtype=np.float64), np.asarray(lons, dtype=np.float64)
 
 
-def sample_shore_candidates(
+def sample_mainland_points(step_m: float = 300.0) -> tuple[np.ndarray, np.ndarray]:
+    """Sample the mainland (`shoreline.geojson`) at constant arclength."""
+    return _sample_along(load_shoreline(), step_m=step_m)
+
+
+def sample_kronshtadt_points(step_m: float = 300.0) -> tuple[np.ndarray, np.ndarray]:
+    """Sample the Kronshtadt outline (extracted from zone outer rings)."""
+    return _sample_along(load_kronshtadt_outline(), step_m=step_m)
+
+
+def _build(
     *,
-    step_m: float = 300.0,
-    speed_kmh: float = 40.0,
+    lat: np.ndarray,
+    lon: np.ndarray,
+    speed_kmh: float,
+    label_prefix: str,
     graph: csr_matrix,
     grid_lats: np.ndarray,
     grid_lons: np.ndarray,
-    exclude_grid_indices: Sequence[int] = (),
+    exclude_grid_indices: Sequence[int],
 ) -> PlacementSet:
-    """Sample shore candidates and attach precomputed travel times."""
-    lat, lon = sample_shore_points(step_m=step_m)
     speed = np.full(len(lat), float(speed_kmh), dtype=np.float64)
-    labels = [f"shore_{i:04d}" for i in range(len(lat))]
-
+    labels = [f"{label_prefix}_{i:04d}" for i in range(len(lat))]
     placements = attach_travel_times(
         lat=lat, lon=lon, speed_kmh=speed, labels=labels,
         graph=graph, grid_lats=grid_lats, grid_lons=grid_lons,
     )
-
-    # Drop candidates that snap onto a cell already occupied by an existing station
     if len(exclude_grid_indices):
-        excl = set(int(i) for i in exclude_grid_indices)
+        excl = {int(i) for i in exclude_grid_indices}
         keep = np.array([int(i) not in excl for i in placements.grid_index], dtype=bool)
-        if not keep.all():
-            placements = PlacementSet(
-                lat=placements.lat[keep],
-                lon=placements.lon[keep],
-                speed_kmh=placements.speed_kmh[keep],
-                grid_index=placements.grid_index[keep],
-                travel_times=placements.travel_times[keep],
-                labels=[lbl for lbl, k in zip(placements.labels, keep) if k],
-            )
-
-    # Deduplicate candidates that snapped to the same grid cell — keep first
+        placements = _select(placements, keep)
+    # Dedupe candidates that snapped to the same grid cell — keep first
     _, first_idx = np.unique(placements.grid_index, return_index=True)
     first_idx = np.sort(first_idx)
     if len(first_idx) != placements.K:
-        placements = PlacementSet(
-            lat=placements.lat[first_idx],
-            lon=placements.lon[first_idx],
-            speed_kmh=placements.speed_kmh[first_idx],
-            grid_index=placements.grid_index[first_idx],
-            travel_times=placements.travel_times[first_idx],
-            labels=[placements.labels[i] for i in first_idx],
-        )
-
+        placements = _select_by_index(placements, first_idx)
     return placements
+
+
+def _select(p: PlacementSet, mask: np.ndarray) -> PlacementSet:
+    return PlacementSet(
+        lat=p.lat[mask], lon=p.lon[mask], speed_kmh=p.speed_kmh[mask],
+        grid_index=p.grid_index[mask], travel_times=p.travel_times[mask],
+        labels=[lbl for lbl, k in zip(p.labels, mask) if k],
+    )
+
+
+def _select_by_index(p: PlacementSet, idx: np.ndarray) -> PlacementSet:
+    return PlacementSet(
+        lat=p.lat[idx], lon=p.lon[idx], speed_kmh=p.speed_kmh[idx],
+        grid_index=p.grid_index[idx], travel_times=p.travel_times[idx],
+        labels=[p.labels[int(i)] for i in idx],
+    )
+
+
+def _concat(a: PlacementSet, b: PlacementSet) -> PlacementSet:
+    return PlacementSet(
+        lat=np.concatenate([a.lat, b.lat]),
+        lon=np.concatenate([a.lon, b.lon]),
+        speed_kmh=np.concatenate([a.speed_kmh, b.speed_kmh]),
+        grid_index=np.concatenate([a.grid_index, b.grid_index]),
+        travel_times=np.concatenate([a.travel_times, b.travel_times], axis=0),
+        labels=list(a.labels) + list(b.labels),
+    )
+
+
+def sample_mainland_candidates(
+    *,
+    step_m: float = 300.0,
+    speed_kmh: float = 40.0,
+    graph: csr_matrix,
+    grid_lats: np.ndarray,
+    grid_lons: np.ndarray,
+    exclude_grid_indices: Sequence[int] = (),
+) -> PlacementSet:
+    lat, lon = sample_mainland_points(step_m=step_m)
+    return _build(
+        lat=lat, lon=lon, speed_kmh=speed_kmh, label_prefix="main",
+        graph=graph, grid_lats=grid_lats, grid_lons=grid_lons,
+        exclude_grid_indices=exclude_grid_indices,
+    )
+
+
+def sample_kronshtadt_candidates(
+    *,
+    step_m: float = 300.0,
+    speed_kmh: float = 40.0,
+    graph: csr_matrix,
+    grid_lats: np.ndarray,
+    grid_lons: np.ndarray,
+    exclude_grid_indices: Sequence[int] = (),
+) -> PlacementSet:
+    lat, lon = sample_kronshtadt_points(step_m=step_m)
+    return _build(
+        lat=lat, lon=lon, speed_kmh=speed_kmh, label_prefix="kron",
+        graph=graph, grid_lats=grid_lats, grid_lons=grid_lons,
+        exclude_grid_indices=exclude_grid_indices,
+    )
+
+
+def sample_shore_candidates(
+    *,
+    step_m: float = 300.0,
+    speed_kmh: float = 40.0,
+    graph: csr_matrix,
+    grid_lats: np.ndarray,
+    grid_lons: np.ndarray,
+    exclude_grid_indices: Sequence[int] = (),
+) -> PlacementSet:
+    """Mainland coast + Kronshtadt outline, both at the same `step_m`."""
+    mainland = sample_mainland_candidates(
+        step_m=step_m, speed_kmh=speed_kmh,
+        graph=graph, grid_lats=grid_lats, grid_lons=grid_lons,
+        exclude_grid_indices=exclude_grid_indices,
+    )
+    kron = sample_kronshtadt_candidates(
+        step_m=step_m, speed_kmh=speed_kmh,
+        graph=graph, grid_lats=grid_lats, grid_lons=grid_lons,
+        exclude_grid_indices=tuple(int(i) for i in exclude_grid_indices)
+        + tuple(int(i) for i in mainland.grid_index),
+    )
+    return _concat(mainland, kron)