Upload folder using huggingface_hub

.gitattributes

@@ -1,60 +1 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.avro filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mds filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text
+*.geoparquet filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,82 @@
+# EEA Industrial Emissions - River Proximity Dataset
+
+This dataset matches **160,576 industrial facilities** from the European Environment Agency (EEA) Industrial Emissions database to nearby river segments from HydroRIVERS, with upstream/downstream flow analysis.
+
+## Dataset Description
+
+For each facility within 1km of a river:
+- **Upstream segments**: River parts flowing *toward* the facility (potential source water)
+- **Downstream segments**: River parts flowing *away* from the facility (potentially affected by emissions)
+
+The split point is the closest point on the river to each facility.
+
+## Files
+
+### `river_data_facilities.geoparquet`
+Main dataset with 160,576 facilities and their river associations.
+
+| Column | Description |
+|--------|-------------|
+| `facilityName` | Name of the industrial facility |
+| `city`, `countryName` | Location |
+| `EPRTR_SectorCode/Name` | Industry sector |
+| `Pollutant`, `Releases` | Emission data |
+| `closest_river_id` | HydroRIVERS segment ID |
+| `distance_to_river_m` | Distance to nearest river (meters) |
+| `river_strahler` | Strahler stream order |
+| `river_discharge` | Average discharge (m³/s) |
+| `upstream_segment_ids` | List of upstream HydroRIVERS IDs |
+| `downstream_segment_ids` | List of downstream HydroRIVERS IDs |
+| `n_upstream`, `n_downstream` | Count of segments |
+| `upstream_line_wkb`, `downstream_line_wkb` | River line geometries (WKB) |
+| `upstream_poly_wkb`, `downstream_poly_wkb` | Water surface polygons (WKB) |
+| `geometry` | Facility point location |
+
+### `river_data_segments.geoparquet`
+28,434 river segment geometries with direction labels.
+
+| Column | Description |
+|--------|-------------|
+| `HYRIV_ID` | HydroRIVERS segment ID |
+| `direction` | "upstream" or "downstream" |
+| `ORD_STRA` | Strahler stream order |
+| `DIS_AV_CMS` | Average discharge (m³/s) |
+| `LENGTH_KM` | Segment length (km) |
+| `geometry` | LineString geometry |
+
+## Usage
+
+```python
+import geopandas as gpd
+from shapely import wkb
+
+# Load facilities
+facilities = gpd.read_parquet("river_data_facilities.geoparquet")
+
+# Get a facility's upstream river geometry
+facility = facilities[facilities['facilityName'].str.contains('PRECHEZA')].iloc[0]
+upstream_line = wkb.loads(facility['upstream_line_wkb'])
+downstream_line = wkb.loads(facility['downstream_line_wkb'])
+```
+
+## Visualization Scripts
+
+- `visualize_single_facility.py` - Interactive map for a single facility
+- `visualize_facilities_rivers.py` - Overview map with sampled facilities
+
+## Source Data
+
+- **Facilities**: [EEA Industrial Emissions Database](https://www.eea.europa.eu/data-and-maps/data/industrial-reporting-under-the-industrial-6)
+- **Rivers**: [HydroRIVERS v1.0](https://www.hydrosheds.org/products/hydrorivers)
+- **Water Polygons**: [EU-Hydro River Network Database](https://land.copernicus.eu/imagery-in-situ/eu-hydro)
+
+## Parameters Used
+
+- Max distance to river: 1,000m
+- Upstream trace distance: 10km
+- Downstream trace distance: 10km
+- Polygon buffer: 600m
+
+## License
+
+The derived dataset follows the licenses of the source datasets. See original sources for details.

river_data_facilities.geoparquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f77d31ba498f4865a4f9212842a001391e0a9a7a34420bf481511a64308d23a3
+size 2623539851

river_data_segments.geoparquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f42748db4285312ce018be67ca74543e72c385af36653cd8f666f56cf7b6537c
+size 1658895

river_proximity.py

@@ -0,0 +1,617 @@
+"""
+Match industrial facilities to nearby river segments with upstream/downstream split.
+
+Optimized for batch processing:
+1. Find closest rivers for all facilities (using spatial index)
+2. Trace upstream/downstream segment IDs (fast lookups)
+3. Batch build geometries at the end using lookup dicts
+4. Batch clip polygons once at the end
+"""
+
+import geopandas as gpd
+import pandas as pd
+import numpy as np
+from pathlib import Path
+from shapely.ops import unary_union
+from shapely.geometry import Point, LineString, MultiLineString
+from shapely import STRtree
+from collections import defaultdict
+import sys
+
+def log(msg):
+    print(msg, flush=True)
+
+
+def load_facilities(filepath: Path) -> gpd.GeoDataFrame:
+    """Load water-releasing facilities and convert to GeoDataFrame."""
+    log(f"Loading facilities from {filepath}...")
+    df = pd.read_csv(filepath, low_memory=False)
+    df = df.dropna(subset=["Longitude", "Latitude"])
+    gdf = gpd.GeoDataFrame(
+        df,
+        geometry=gpd.points_from_xy(df.Longitude, df.Latitude),
+        crs="EPSG:4326"
+    )
+    log(f"Loaded {len(gdf):,} facilities with valid coordinates")
+    return gdf
+
+
+def load_rivers(filepath: Path, min_strahler_order: int = 1) -> gpd.GeoDataFrame:
+    """Load HydroRIVERS data."""
+    log(f"Loading HydroRIVERS from {filepath}...")
+    gdf = gpd.read_parquet(filepath)
+    if min_strahler_order > 1:
+        original_count = len(gdf)
+        gdf = gdf[gdf["ORD_STRA"] >= min_strahler_order].copy()
+        log(f"Filtered rivers: {original_count:,} -> {len(gdf):,} (Strahler >= {min_strahler_order})")
+    else:
+        log(f"Loaded {len(gdf):,} river segments")
+    return gdf
+
+
+def load_river_polygons(polygon_dir: Path) -> gpd.GeoDataFrame:
+    """Load all EU-Hydro river polygon shards."""
+    log(f"Loading EU-Hydro river polygons from {polygon_dir}...")
+    shards = sorted(polygon_dir.glob("*.geoparquet"))
+    if not shards:
+        raise FileNotFoundError(f"No geoparquet files found in {polygon_dir}")
+    gdfs = [gpd.read_parquet(shard) for shard in shards]
+    result = pd.concat(gdfs, ignore_index=True)
+    result = gpd.GeoDataFrame(result, geometry="geometry", crs=gdfs[0].crs)
+    log(f"Loaded {len(result):,} river polygons from {len(shards)} basin shards")
+    return result
+
+
+def build_river_network(rivers: gpd.GeoDataFrame) -> tuple[dict, dict, dict]:
+    """Build lookup dictionaries for river network traversal."""
+    log("Building river network graph...")
+    id_to_downstream = dict(zip(rivers["HYRIV_ID"], rivers["NEXT_DOWN"]))
+    id_to_length = dict(zip(rivers["HYRIV_ID"], rivers["LENGTH_KM"]))
+
+    id_to_upstream = {}
+    for hyriv_id, next_down in id_to_downstream.items():
+        if next_down != 0:
+            if next_down not in id_to_upstream:
+                id_to_upstream[next_down] = []
+            id_to_upstream[next_down].append(hyriv_id)
+
+    log(f"  Network has {len(id_to_downstream):,} segments")
+    return id_to_downstream, id_to_upstream, id_to_length
+
+
+def build_river_lookups(rivers: gpd.GeoDataFrame, rivers_proj: gpd.GeoDataFrame):
+    """Build lookup dictionaries for fast access."""
+    log("Building river lookup dictionaries...")
+
+    # Geometry lookup (projected for line splitting)
+    id_to_geom_proj = dict(zip(rivers_proj["HYRIV_ID"], rivers_proj.geometry))
+
+    # Metadata lookup
+    id_to_strahler = dict(zip(rivers["HYRIV_ID"], rivers["ORD_STRA"]))
+    id_to_discharge = dict(zip(rivers["HYRIV_ID"], rivers["DIS_AV_CMS"]))
+
+    log(f"  Built lookups for {len(id_to_geom_proj):,} segments")
+    return id_to_geom_proj, id_to_strahler, id_to_discharge
+
+
+def split_line_at_point(line: LineString, point: Point) -> tuple[LineString, LineString]:
+    """
+    Split a LineString at the closest point to the given point.
+    Returns (upstream_part, downstream_part).
+    """
+    distance_along = line.project(point)
+
+    if distance_along <= 0:
+        return None, line
+    elif distance_along >= line.length:
+        return line, None
+
+    split_point = line.interpolate(distance_along)
+    coords = list(line.coords)
+
+    upstream_coords = [coords[0]]
+    downstream_coords = []
+
+    cumulative_dist = 0
+    split_inserted = False
+
+    for i in range(1, len(coords)):
+        segment = LineString([coords[i-1], coords[i]])
+        segment_length = segment.length
+
+        if not split_inserted and cumulative_dist + segment_length >= distance_along:
+            upstream_coords.append((split_point.x, split_point.y))
+            downstream_coords.append((split_point.x, split_point.y))
+            downstream_coords.append(coords[i])
+            split_inserted = True
+        elif not split_inserted:
+            upstream_coords.append(coords[i])
+        else:
+            downstream_coords.append(coords[i])
+
+        cumulative_dist += segment_length
+
+    upstream_line = LineString(upstream_coords) if len(upstream_coords) >= 2 else None
+    downstream_line = LineString(downstream_coords) if len(downstream_coords) >= 2 else None
+
+    return upstream_line, downstream_line
+
+
+def trace_downstream_segments(
+    start_id: int,
+    id_to_downstream: dict,
+    id_to_length: dict,
+    max_distance_km: float
+) -> list:
+    """Trace downstream and return list of segment IDs in order."""
+    segments = []
+    current_id = id_to_downstream.get(start_id, 0)
+    distance = 0
+
+    while current_id != 0 and distance < max_distance_km:
+        segments.append(current_id)
+        distance += id_to_length.get(current_id, 0)
+        current_id = id_to_downstream.get(current_id, 0)
+
+    return segments
+
+
+def trace_upstream_segments(
+    start_id: int,
+    id_to_upstream: dict,
+    id_to_length: dict,
+    max_distance_km: float
+) -> list:
+    """Trace upstream using BFS and return list of segment IDs."""
+    segments = []
+    queue = [(uid, 0) for uid in id_to_upstream.get(start_id, [])]
+    visited = set()
+
+    while queue:
+        current_id, dist = queue.pop(0)
+        if current_id in visited or dist > max_distance_km:
+            continue
+        visited.add(current_id)
+        segments.append(current_id)
+        seg_len = id_to_length.get(current_id, 0)
+        for uid in id_to_upstream.get(current_id, []):
+            queue.append((uid, dist + seg_len))
+
+    return segments
+
+
+def process_facilities_fast(
+    facilities: gpd.GeoDataFrame,
+    facilities_proj: gpd.GeoDataFrame,
+    rivers_proj: gpd.GeoDataFrame,
+    id_to_downstream: dict,
+    id_to_upstream: dict,
+    id_to_length: dict,
+    id_to_geom_proj: dict,
+    id_to_strahler: dict,
+    id_to_discharge: dict,
+    max_distance_m: float,
+    upstream_distance_km: float,
+    downstream_distance_km: float,
+):
+    """Process all facilities in an optimized way."""
+
+    # Build spatial index
+    log("Building spatial index for rivers...")
+    river_tree = STRtree(rivers_proj.geometry.values)
+    river_indices = rivers_proj.index.values
+    river_ids = rivers_proj["HYRIV_ID"].values
+    log(f"  Spatial index built for {len(rivers_proj):,} rivers")
+
+    log(f"\nProcessing {len(facilities):,} facilities...")
+
+    results = []
+    all_upstream_ids = set()
+    all_downstream_ids = set()
+
+    # Store split line parts for later geometry building
+    facility_split_parts = {}  # facility_idx -> (upstream_part_proj, downstream_part_proj)
+
+    for i, (idx, row) in enumerate(facilities.iterrows()):
+        if i % 10000 == 0 and i > 0:
+            log(f"  Processed {i:,}/{len(facilities):,}...")
+
+        facility_point_proj = facilities_proj.loc[idx].geometry
+
+        # Find closest river using spatial index
+        buffer = facility_point_proj.buffer(max_distance_m)
+        candidate_indices = river_tree.query(buffer)
+
+        if len(candidate_indices) == 0:
+            continue
+
+        # Get candidates
+        candidate_geoms = rivers_proj.geometry.iloc[candidate_indices]
+        distances = candidate_geoms.distance(facility_point_proj)
+
+        # Filter by max distance
+        nearby_mask = distances <= max_distance_m
+        if not nearby_mask.any():
+            continue
+
+        # Get closest
+        closest_local_idx = distances[nearby_mask].idxmin()
+        closest_distance = distances[closest_local_idx]
+        closest_river_id = rivers_proj.loc[closest_local_idx, "HYRIV_ID"]
+
+        # Get the geometry from lookup (faster than GeoDataFrame access)
+        river_geom_proj = id_to_geom_proj.get(closest_river_id)
+        if river_geom_proj is None:
+            continue
+
+        # Split the closest segment at the nearest point to facility
+        upstream_part, downstream_part = split_line_at_point(river_geom_proj, facility_point_proj)
+
+        # Trace further upstream/downstream (just IDs, very fast)
+        upstream_segment_ids = trace_upstream_segments(closest_river_id, id_to_upstream, id_to_length, upstream_distance_km)
+        downstream_segment_ids = trace_downstream_segments(closest_river_id, id_to_downstream, id_to_length, downstream_distance_km)
+
+        # Collect all segment IDs
+        all_upstream_ids.update(upstream_segment_ids)
+        all_downstream_ids.update(downstream_segment_ids)
+        all_upstream_ids.add(closest_river_id)
+        all_downstream_ids.add(closest_river_id)
+
+        # Store split parts for geometry building later
+        facility_split_parts[idx] = (upstream_part, downstream_part)
+
+        # Build result (without geometries for now)
+        results.append({
+            "facility_idx": idx,
+            "facilityName": row.get("facilityName"),
+            "city": row.get("city"),
+            "countryName": row.get("countryName"),
+            "EPRTR_SectorCode": row.get("EPRTR_SectorCode"),
+            "EPRTR_SectorName": row.get("EPRTR_SectorName"),
+            "Pollutant": row.get("Pollutant"),
+            "Releases": row.get("Releases"),
+            "facility_lon": row.get("Longitude"),
+            "facility_lat": row.get("Latitude"),
+            "closest_river_id": closest_river_id,
+            "distance_to_river_m": closest_distance,
+            "river_strahler": id_to_strahler.get(closest_river_id),
+            "river_discharge": id_to_discharge.get(closest_river_id),
+            "upstream_segment_ids": upstream_segment_ids,
+            "downstream_segment_ids": downstream_segment_ids,
+            "n_upstream": len(upstream_segment_ids) + (1 if upstream_part else 0),
+            "n_downstream": len(downstream_segment_ids) + (1 if downstream_part else 0),
+        })
+
+    log(f"  Found {len(results):,} facilities with nearby rivers")
+    log(f"  Total unique upstream segments: {len(all_upstream_ids):,}")
+    log(f"  Total unique downstream segments: {len(all_downstream_ids):,}")
+
+    return results, all_upstream_ids, all_downstream_ids, facility_split_parts
+
+
+def build_geometries_and_clip_polygons(
+    results: list,
+    facility_split_parts: dict,
+    id_to_geom_proj: dict,
+    river_polygons: gpd.GeoDataFrame,
+    buffer_meters: float,
+):
+    """Build line geometries and clip polygons for all facilities."""
+    log("\nBuilding line geometries and clipping polygons...")
+
+    # Ensure polygons in EPSG:3035
+    if river_polygons.crs.to_epsg() != 3035:
+        river_polygons_proj = river_polygons.to_crs("EPSG:3035")
+    else:
+        river_polygons_proj = river_polygons
+
+    # Build spatial index for polygons
+    polygon_sindex = river_polygons_proj.sindex
+
+    for i, result in enumerate(results):
+        if i % 5000 == 0 and i > 0:
+            log(f"  Processed {i:,}/{len(results):,}...")
+
+        facility_idx = result["facility_idx"]
+        upstream_part, downstream_part = facility_split_parts.get(facility_idx, (None, None))
+
+        # Build upstream line geometry (in projected CRS)
+        upstream_geoms = []
+        if upstream_part is not None and not upstream_part.is_empty:
+            upstream_geoms.append(upstream_part)
+        for seg_id in result["upstream_segment_ids"]:
+            geom = id_to_geom_proj.get(seg_id)
+            if geom is not None:
+                upstream_geoms.append(geom)
+
+        # Build downstream line geometry (in projected CRS)
+        downstream_geoms = []
+        if downstream_part is not None and not downstream_part.is_empty:
+            downstream_geoms.append(downstream_part)
+        for seg_id in result["downstream_segment_ids"]:
+            geom = id_to_geom_proj.get(seg_id)
+            if geom is not None:
+                downstream_geoms.append(geom)
+
+        # Merge line geometries (still in EPSG:3035)
+        upstream_line_proj = unary_union(upstream_geoms) if upstream_geoms else None
+        downstream_line_proj = unary_union(downstream_geoms) if downstream_geoms else None
+
+        # Clip polygons based on line geometries
+        upstream_poly_proj = None
+        downstream_poly_proj = None
+
+        if upstream_line_proj is not None:
+            upstream_buffer = upstream_line_proj.buffer(buffer_meters)
+            candidates_idx = list(polygon_sindex.intersection(upstream_buffer.bounds))
+            if candidates_idx:
+                candidates = river_polygons_proj.iloc[candidates_idx]
+                intersecting = candidates[candidates.intersects(upstream_buffer)]
+                if len(intersecting) > 0:
+                    clipped = [row.geometry.intersection(upstream_buffer) for _, row in intersecting.iterrows()]
+                    clipped = [p for p in clipped if not p.is_empty]
+                    if clipped:
+                        upstream_poly_proj = unary_union(clipped)
+
+        if downstream_line_proj is not None:
+            downstream_buffer = downstream_line_proj.buffer(buffer_meters)
+            candidates_idx = list(polygon_sindex.intersection(downstream_buffer.bounds))
+            if candidates_idx:
+                candidates = river_polygons_proj.iloc[candidates_idx]
+                intersecting = candidates[candidates.intersects(downstream_buffer)]
+                if len(intersecting) > 0:
+                    clipped = [row.geometry.intersection(downstream_buffer) for _, row in intersecting.iterrows()]
+                    clipped = [p for p in clipped if not p.is_empty]
+                    if clipped:
+                        downstream_poly_proj = unary_union(clipped)
+
+        # Convert everything to WGS84
+        upstream_line = None
+        downstream_line = None
+        upstream_poly = None
+        downstream_poly = None
+
+        if upstream_line_proj:
+            upstream_line = gpd.GeoSeries([upstream_line_proj], crs="EPSG:3035").to_crs("EPSG:4326").iloc[0]
+        if downstream_line_proj:
+            downstream_line = gpd.GeoSeries([downstream_line_proj], crs="EPSG:3035").to_crs("EPSG:4326").iloc[0]
+        if upstream_poly_proj:
+            upstream_poly = gpd.GeoSeries([upstream_poly_proj], crs="EPSG:3035").to_crs("EPSG:4326").iloc[0]
+        if downstream_poly_proj:
+            downstream_poly = gpd.GeoSeries([downstream_poly_proj], crs="EPSG:3035").to_crs("EPSG:4326").iloc[0]
+
+        result["upstream_line_geom"] = upstream_line
+        result["downstream_line_geom"] = downstream_line
+        result["upstream_poly_geom"] = upstream_poly
+        result["downstream_poly_geom"] = downstream_poly
+
+    log(f"  Processed {len(results):,} facilities")
+    return results
+
+
+def batch_clip_polygons(
+    all_segment_ids: set,
+    direction: str,
+    rivers_proj: gpd.GeoDataFrame,
+    river_polygons: gpd.GeoDataFrame,
+    buffer_meters: float,
+) -> gpd.GeoDataFrame:
+    """Batch clip polygons for all segments at once."""
+    log(f"  Clipping {direction} polygons for {len(all_segment_ids):,} segments...")
+
+    if not all_segment_ids:
+        return gpd.GeoDataFrame(columns=["geometry", "direction", "HYRIV_ID", "matched_river_ids", "source_basin"])
+
+    # Get all segment geometries
+    segments_gdf = rivers_proj[rivers_proj["HYRIV_ID"].isin(all_segment_ids)].copy()
+    if len(segments_gdf) == 0:
+        return gpd.GeoDataFrame(columns=["geometry", "direction", "HYRIV_ID", "matched_river_ids", "source_basin"])
+
+    # Create buffer for each segment
+    segments_gdf["buffer"] = segments_gdf.geometry.buffer(buffer_meters)
+
+    # Ensure polygons in EPSG:3035
+    if river_polygons.crs.to_epsg() != 3035:
+        river_polygons_proj = river_polygons.to_crs("EPSG:3035")
+    else:
+        river_polygons_proj = river_polygons
+
+    # Build spatial index for polygons
+    polygon_sindex = river_polygons_proj.sindex
+
+    clipped_results = []
+    processed = 0
+
+    for idx, seg_row in segments_gdf.iterrows():
+        seg_id = seg_row["HYRIV_ID"]
+        buffer_geom = seg_row["buffer"]
+
+        # Find candidate polygons
+        candidates_idx = list(polygon_sindex.intersection(buffer_geom.bounds))
+        if not candidates_idx:
+            continue
+
+        candidates = river_polygons_proj.iloc[candidates_idx]
+        intersecting = candidates[candidates.intersects(buffer_geom)]
+
+        for poly_idx, poly_row in intersecting.iterrows():
+            clipped = poly_row.geometry.intersection(buffer_geom)
+            if not clipped.is_empty:
+                clipped_results.append({
+                    "geometry": clipped,
+                    "direction": direction,
+                    "HYRIV_ID": seg_id,
+                    "matched_river_ids": [seg_id],
+                    "source_basin": poly_row.get("source_basin"),
+                    "OBJECT_ID": poly_row.get("OBJECT_ID"),
+                })
+
+        processed += 1
+        if processed % 10000 == 0:
+            log(f"    Processed {processed:,}/{len(segments_gdf):,} segments...")
+
+    if not clipped_results:
+        return gpd.GeoDataFrame(columns=["geometry", "direction", "HYRIV_ID", "matched_river_ids", "source_basin"])
+
+    result = gpd.GeoDataFrame(clipped_results, crs="EPSG:3035")
+    log(f"    Clipped {len(result):,} polygons")
+    return result.to_crs("EPSG:4326")
+
+
+def main(
+    facilities_path: Path,
+    rivers_path: Path,
+    polygons_path: Path,
+    output_facilities_path: Path,
+    output_segments_path: Path,
+    max_distance_m: float = 1000,
+    upstream_distance_km: float = 10,
+    downstream_distance_km: float = 10,
+    polygon_buffer_m: float = 600,
+    min_strahler_order: int = 1,
+    limit: int = None,
+):
+    """Main pipeline - polygons are stored per-facility as WKB."""
+
+    # Load data
+    facilities = load_facilities(facilities_path)
+    rivers = load_rivers(rivers_path, min_strahler_order)
+    river_polygons = load_river_polygons(polygons_path)
+
+    # Keep only needed columns
+    river_columns = ["HYRIV_ID", "NEXT_DOWN", "ORD_STRA", "DIS_AV_CMS", "LENGTH_KM", "UPLAND_SKM", "DIST_DN_KM"]
+    rivers = rivers[["geometry"] + river_columns]
+
+    # Build network
+    id_to_downstream, id_to_upstream, id_to_length = build_river_network(rivers)
+
+    # Project for distance calculations
+    log("Projecting data to EPSG:3035...")
+    facilities_proj = facilities.to_crs("EPSG:3035")
+    rivers_proj = rivers.to_crs("EPSG:3035")
+
+    # Build lookups
+    id_to_geom_proj, id_to_strahler, id_to_discharge = build_river_lookups(rivers, rivers_proj)
+
+    # Process facilities
+    if limit:
+        facilities = facilities.head(limit)
+        facilities_proj = facilities_proj.head(limit)
+
+    # Phase 1: Process all facilities (fast - just IDs)
+    results, all_upstream_ids, all_downstream_ids, facility_split_parts = process_facilities_fast(
+        facilities, facilities_proj, rivers_proj,
+        id_to_downstream, id_to_upstream, id_to_length,
+        id_to_geom_proj, id_to_strahler, id_to_discharge,
+        max_distance_m, upstream_distance_km, downstream_distance_km
+    )
+
+    if not results:
+        log("No facilities found near rivers!")
+        return None, None, None
+
+    # Phase 2: Build line geometries and clip polygons per facility
+    results = build_geometries_and_clip_polygons(
+        results, facility_split_parts, id_to_geom_proj,
+        river_polygons, polygon_buffer_m
+    )
+
+    # Create facilities GeoDataFrame
+    result_df = pd.DataFrame(results)
+
+    # Convert line and polygon geometries to WKB for parquet storage
+    from shapely import wkb
+    result_df["upstream_line_wkb"] = result_df["upstream_line_geom"].apply(
+        lambda g: g.wkb if g is not None else None
+    )
+    result_df["downstream_line_wkb"] = result_df["downstream_line_geom"].apply(
+        lambda g: g.wkb if g is not None else None
+    )
+    result_df["upstream_poly_wkb"] = result_df["upstream_poly_geom"].apply(
+        lambda g: g.wkb if g is not None else None
+    )
+    result_df["downstream_poly_wkb"] = result_df["downstream_poly_geom"].apply(
+        lambda g: g.wkb if g is not None else None
+    )
+    result_df = result_df.drop(columns=["upstream_line_geom", "downstream_line_geom", "upstream_poly_geom", "downstream_poly_geom"])
+
+    facilities_gdf = gpd.GeoDataFrame(
+        result_df,
+        geometry=gpd.points_from_xy(result_df["facility_lon"], result_df["facility_lat"]),
+        crs="EPSG:4326"
+    )
+
+    # Phase 3: Build segments dataset
+    log(f"\nBuilding segments dataset...")
+
+    all_segment_ids = all_upstream_ids | all_downstream_ids
+    segments_data = []
+
+    for seg_id in all_segment_ids:
+        seg_row = rivers[rivers["HYRIV_ID"] == seg_id]
+        if len(seg_row) == 0:
+            continue
+        seg_row = seg_row.iloc[0]
+
+        direction = []
+        if seg_id in all_upstream_ids:
+            direction.append("upstream")
+        if seg_id in all_downstream_ids:
+            direction.append("downstream")
+
+        for d in direction:
+            segments_data.append({
+                "HYRIV_ID": seg_id,
+                "direction": d,
+                "geometry": seg_row.geometry,
+                "ORD_STRA": seg_row["ORD_STRA"],
+                "DIS_AV_CMS": seg_row["DIS_AV_CMS"],
+                "LENGTH_KM": seg_row["LENGTH_KM"],
+            })
+
+    segments_gdf = gpd.GeoDataFrame(segments_data, crs=rivers.crs)
+    log(f"  Created {len(segments_gdf):,} segment entries")
+
+    # Save outputs (polygons are now stored per-facility in facilities file as WKB)
+    log(f"\nSaving outputs...")
+    log(f"  Facilities: {output_facilities_path}")
+    facilities_gdf.to_parquet(output_facilities_path)
+
+    log(f"  Segments: {output_segments_path}")
+    segments_gdf.to_parquet(output_segments_path)
+
+    # Note: Polygons are now stored per-facility as upstream_poly_wkb and downstream_poly_wkb
+    # in the facilities file, so we don't create a separate polygons file
+
+    log("\nDone!")
+    log(f"  Facilities with rivers: {len(facilities_gdf):,}")
+    if len(facilities_gdf) > 0:
+        log(f"  Avg upstream parts: {facilities_gdf['n_upstream'].mean():.1f}")
+        log(f"  Avg downstream parts: {facilities_gdf['n_downstream'].mean():.1f}")
+
+    return facilities_gdf, segments_gdf
+
+
+if __name__ == "__main__":
+    base_dir = Path(__file__).resolve().parent
+
+    facilities_path = base_dir / "tabular" / "F2_4_Water_Releases_Facilities.csv"
+    rivers_path = base_dir.parent / "hydro-rivers-europe" / "HydroRIVERS_v10_eu.geoparquet"
+    polygons_path = base_dir.parent / "eu-hydro-master-skeleton" / "eu_hydro_master_skeleton_geoparquet" / "river_polygons"
+
+    output_facilities_path = base_dir / "river_data_facilities.geoparquet"
+    output_segments_path = base_dir / "river_data_segments.geoparquet"
+
+    result = main(
+        facilities_path=facilities_path,
+        rivers_path=rivers_path,
+        polygons_path=polygons_path,
+        output_facilities_path=output_facilities_path,
+        output_segments_path=output_segments_path,
+        max_distance_m=1000,
+        upstream_distance_km=10,
+        downstream_distance_km=10,
+        polygon_buffer_m=600,
+        min_strahler_order=1,
+        limit=None,
+    )

visualize_facilities_rivers.py

@@ -0,0 +1,311 @@
+"""
+Visualize facilities with upstream/downstream river segments and polygons.
+Uses polygon WKB stored per facility for correct clipping.
+"""
+
+import geopandas as gpd
+import folium
+from folium.plugins import AntPath, MarkerCluster
+from pathlib import Path
+from shapely import wkb
+
+
+def load_facilities(filepath: Path) -> gpd.GeoDataFrame:
+    """Load facility data with upstream/downstream geometries."""
+    print(f"Loading facilities from {filepath}...")
+    gdf = gpd.read_parquet(filepath)
+    print(f"Loaded {len(gdf):,} facilities")
+    return gdf
+
+
+def load_segments(filepath: Path) -> gpd.GeoDataFrame:
+    """Load river segments with direction info."""
+    print(f"Loading segments from {filepath}...")
+    gdf = gpd.read_parquet(filepath)
+    print(f"Loaded {len(gdf):,} segments ({gdf['direction'].value_counts().to_dict()})")
+    return gdf
+
+
+def get_facility_color(sector_code: int) -> str:
+    """Color based on industry sector."""
+    colors = {
+        1: "#e41a1c",  # Energy - red
+        2: "#377eb8",  # Metals - blue
+        3: "#4daf4a",  # Minerals - green
+        4: "#984ea3",  # Chemical - purple
+        5: "#ff7f00",  # Waste/wastewater - orange
+        6: "#a65628",  # Paper - brown
+        7: "#f781bf",  # Livestock - pink
+        8: "#999999",  # Food - gray
+        9: "#66c2a5",  # Other - teal
+    }
+    return colors.get(sector_code, "#999999")
+
+
+# Upstream = green/teal tones (coming from nature)
+# Downstream = red/orange tones (affected by pollution)
+UPSTREAM_LINE_COLOR = "#2ca02c"  # Green
+DOWNSTREAM_LINE_COLOR = "#d62728"  # Red
+UPSTREAM_POLY_COLOR = "#98df8a"  # Light green
+DOWNSTREAM_POLY_COLOR = "#ff9896"  # Light red
+
+
+def create_map(
+    facilities: gpd.GeoDataFrame,
+    segments: gpd.GeoDataFrame,
+    output_path: Path,
+    sample_facilities: int = 2000
+) -> None:
+    """Create interactive map with upstream/downstream visualization."""
+    print("Creating map...")
+
+    # Sample facilities for performance
+    if len(facilities) > sample_facilities:
+        print(f"Sampling {sample_facilities} facilities for performance...")
+        facilities = facilities.sample(sample_facilities, random_state=42)
+
+    # Get segment IDs for sampled facilities
+    upstream_ids = set()
+    downstream_ids = set()
+    for _, row in facilities.iterrows():
+        upstream_ids.update(row.get("upstream_segment_ids", []))
+        downstream_ids.update(row.get("downstream_segment_ids", []))
+
+    # Filter segments
+    upstream_segments = segments[(segments["direction"] == "upstream") & (segments["HYRIV_ID"].isin(upstream_ids))]
+    downstream_segments = segments[(segments["direction"] == "downstream") & (segments["HYRIV_ID"].isin(downstream_ids))]
+
+    print(f"  Upstream segments: {len(upstream_segments):,}")
+    print(f"  Downstream segments: {len(downstream_segments):,}")
+
+    # Calculate center
+    center_lat = facilities.geometry.y.mean()
+    center_lon = facilities.geometry.x.mean()
+
+    # Create map
+    m = folium.Map(
+        location=[center_lat, center_lon],
+        zoom_start=5,
+        tiles="CartoDB positron"
+    )
+
+    # Feature groups
+    upstream_poly_layer = folium.FeatureGroup(name="Upstream Polygons", show=True)
+    downstream_poly_layer = folium.FeatureGroup(name="Downstream Polygons", show=True)
+    upstream_line_layer = folium.FeatureGroup(name="Upstream Flow", show=True)
+    downstream_line_layer = folium.FeatureGroup(name="Downstream Flow", show=True)
+
+    # Add polygons from facility WKB
+    print("Adding polygons from facility data...")
+    poly_count_up = 0
+    poly_count_down = 0
+
+    for _, row in facilities.iterrows():
+        # Upstream polygon
+        if row.get("upstream_poly_wkb") is not None:
+            try:
+                geom = wkb.loads(row["upstream_poly_wkb"])
+                if geom is not None and not geom.is_empty:
+                    if geom.geom_type == "Polygon":
+                        polys = [geom]
+                    elif geom.geom_type == "MultiPolygon":
+                        polys = list(geom.geoms)
+                    else:
+                        polys = []
+
+                    for poly in polys:
+                        coords = [[c[1], c[0]] for c in poly.exterior.coords]
+                        folium.Polygon(
+                            locations=coords,
+                            color=UPSTREAM_LINE_COLOR,
+                            weight=1,
+                            fill=True,
+                            fill_color=UPSTREAM_POLY_COLOR,
+                            fill_opacity=0.5,
+                        ).add_to(upstream_poly_layer)
+                        poly_count_up += 1
+            except:
+                pass
+
+        # Downstream polygon
+        if row.get("downstream_poly_wkb") is not None:
+            try:
+                geom = wkb.loads(row["downstream_poly_wkb"])
+                if geom is not None and not geom.is_empty:
+                    if geom.geom_type == "Polygon":
+                        polys = [geom]
+                    elif geom.geom_type == "MultiPolygon":
+                        polys = list(geom.geoms)
+                    else:
+                        polys = []
+
+                    for poly in polys:
+                        coords = [[c[1], c[0]] for c in poly.exterior.coords]
+                        folium.Polygon(
+                            locations=coords,
+                            color=DOWNSTREAM_LINE_COLOR,
+                            weight=1,
+                            fill=True,
+                            fill_color=DOWNSTREAM_POLY_COLOR,
+                            fill_opacity=0.5,
+                        ).add_to(downstream_poly_layer)
+                        poly_count_down += 1
+            except:
+                pass
+
+    print(f"  Added {poly_count_up:,} upstream polygons, {poly_count_down:,} downstream polygons")
+
+    # Add upstream segments with flow animation (reverse direction - going upstream)
+    print("Adding upstream segments...")
+    for idx, row in upstream_segments.iterrows():
+        geom = row.geometry
+        if geom is None or geom.is_empty:
+            continue
+
+        if geom.geom_type == "LineString":
+            coords = list(geom.coords)
+        elif geom.geom_type == "MultiLineString":
+            coords = []
+            for part in geom.geoms:
+                coords.extend(list(part.coords))
+        else:
+            continue
+
+        if not coords:
+            continue
+
+        # Reverse coords for upstream (animation goes against flow)
+        coords_latlon = [[c[1], c[0]] for c in reversed(coords)]
+        weight = max(1, row["ORD_STRA"] - 2)
+
+        popup_html = f"""
+        <b>Upstream Segment</b><br>
+        <b>ID:</b> {row['HYRIV_ID']}<br>
+        <b>Strahler:</b> {row['ORD_STRA']}<br>
+        <b>Discharge:</b> {row['DIS_AV_CMS']:.1f} m³/s
+        """
+
+        AntPath(
+            locations=coords_latlon,
+            weight=weight,
+            color=UPSTREAM_LINE_COLOR,
+            pulse_color="#ffffff",
+            delay=800,
+            dash_array=[10, 20],
+            popup=folium.Popup(popup_html, max_width=250)
+        ).add_to(upstream_line_layer)
+
+    # Add downstream segments with flow animation
+    print("Adding downstream segments...")
+    for idx, row in downstream_segments.iterrows():
+        geom = row.geometry
+        if geom is None or geom.is_empty:
+            continue
+
+        if geom.geom_type == "LineString":
+            coords = list(geom.coords)
+        elif geom.geom_type == "MultiLineString":
+            coords = []
+            for part in geom.geoms:
+                coords.extend(list(part.coords))
+        else:
+            continue
+
+        if not coords:
+            continue
+
+        coords_latlon = [[c[1], c[0]] for c in coords]
+        weight = max(1, row["ORD_STRA"] - 2)
+
+        popup_html = f"""
+        <b>Downstream Segment</b><br>
+        <b>ID:</b> {row['HYRIV_ID']}<br>
+        <b>Strahler:</b> {row['ORD_STRA']}<br>
+        <b>Discharge:</b> {row['DIS_AV_CMS']:.1f} m³/s
+        """
+
+        AntPath(
+            locations=coords_latlon,
+            weight=weight,
+            color=DOWNSTREAM_LINE_COLOR,
+            pulse_color="#ffffff",
+            delay=800,
+            dash_array=[10, 20],
+            popup=folium.Popup(popup_html, max_width=250)
+        ).add_to(downstream_line_layer)
+
+    # Add facilities
+    print("Adding facilities...")
+    marker_cluster = MarkerCluster(name="Facilities").add_to(m)
+
+    for _, row in facilities.iterrows():
+        color = get_facility_color(row.get("EPRTR_SectorCode", 0))
+
+        popup_html = f"""
+        <b>{row.get('facilityName', 'Unknown')}</b><br>
+        <b>City:</b> {row.get('city', 'N/A')}<br>
+        <b>Sector:</b> {row.get('EPRTR_SectorName', 'N/A')}<br>
+        <b>Pollutant:</b> {row.get('Pollutant', 'N/A')}<br>
+        <b>Upstream segments:</b> {row.get('n_upstream', 0)}<br>
+        <b>Downstream segments:</b> {row.get('n_downstream', 0)}
+        """
+
+        folium.CircleMarker(
+            location=[row.geometry.y, row.geometry.x],
+            radius=6,
+            color=color,
+            fill=True,
+            fill_color=color,
+            fill_opacity=0.7,
+            popup=folium.Popup(popup_html, max_width=300)
+        ).add_to(marker_cluster)
+
+    # Add layers
+    upstream_poly_layer.add_to(m)
+    downstream_poly_layer.add_to(m)
+    upstream_line_layer.add_to(m)
+    downstream_line_layer.add_to(m)
+    folium.LayerControl().add_to(m)
+
+    # Legend
+    legend_html = """
+    <div style="position: fixed; bottom: 50px; left: 50px; z-index: 1000;
+                background-color: white; padding: 15px; border-radius: 8px;
+                border: 2px solid #333; font-size: 12px; max-width: 200px;
+                box-shadow: 0 2px 6px rgba(0,0,0,0.3);">
+        <b>River Flow Analysis</b><br><br>
+        <b style="color: #2ca02c;">━━━ Upstream</b><br>
+        Source water (green)<br><br>
+        <b style="color: #d62728;">━━━ Downstream</b><br>
+        Potentially affected (red)<br><br>
+        <b>Facilities:</b><br>
+        Colored by industry sector<br>
+        <small>Click for details</small>
+    </div>
+    """
+    m.get_root().html.add_child(folium.Element(legend_html))
+
+    # Save
+    print(f"Saving map to {output_path}...")
+    m.save(str(output_path))
+    print(f"Done!")
+
+
+def main():
+    base_dir = Path(__file__).resolve().parent
+
+    # Paths
+    facilities_path = base_dir / "river_data_facilities.geoparquet"
+    segments_path = base_dir / "river_data_segments.geoparquet"
+    output_path = base_dir / "facilities_rivers_map.html"
+
+    # Load data
+    facilities = load_facilities(facilities_path)
+    segments = load_segments(segments_path)
+
+    # Create map
+    create_map(facilities, segments, output_path, sample_facilities=2000)
+
+
+if __name__ == "__main__":
+    main()

visualize_single_facility.py

@@ -0,0 +1,191 @@
+"""
+Visualize a single facility with its upstream/downstream river split.
+Uses pre-generated river_data files with polygon WKB stored per facility.
+"""
+
+import geopandas as gpd
+import folium
+from folium.plugins import AntPath
+from pathlib import Path
+import sys
+from shapely import wkb
+
+UPSTREAM_COLOR = "#2ca02c"  # Green
+DOWNSTREAM_COLOR = "#d62728"  # Red
+UPSTREAM_POLY_COLOR = "#98df8a"
+DOWNSTREAM_POLY_COLOR = "#ff9896"
+
+
+def create_facility_map(facility_name: str, output_path: Path):
+    """Create a map focused on a single facility showing upstream/downstream split."""
+
+    base_dir = Path(__file__).resolve().parent
+
+    # Load pre-generated facility data
+    print(f"Loading data...")
+    facilities_path = base_dir / "river_data_facilities.geoparquet"
+    facilities = gpd.read_parquet(facilities_path)
+    print(f"Loaded {len(facilities):,} facilities")
+
+    # Find facility
+    facility_matches = facilities[facilities['facilityName'].str.contains(facility_name, case=False, na=False)]
+    if len(facility_matches) == 0:
+        print(f"Facility '{facility_name}' not found!")
+        return
+
+    facility = facility_matches.iloc[0]
+    print(f"Found: {facility['facilityName']} in {facility['city']}")
+    print(f"  Closest river: {facility['closest_river_id']} ({facility['distance_to_river_m']:.0f}m away)")
+    print(f"  Upstream: {facility['n_upstream']} parts")
+    print(f"  Downstream: {facility['n_downstream']} parts")
+
+    # Parse geometries from WKB
+    upstream_line_geom = None
+    downstream_line_geom = None
+    upstream_poly_geom = None
+    downstream_poly_geom = None
+
+    if 'upstream_line_wkb' in facility.index and facility['upstream_line_wkb'] is not None:
+        upstream_line_geom = wkb.loads(facility['upstream_line_wkb'])
+    if 'downstream_line_wkb' in facility.index and facility['downstream_line_wkb'] is not None:
+        downstream_line_geom = wkb.loads(facility['downstream_line_wkb'])
+    if 'upstream_poly_wkb' in facility.index and facility['upstream_poly_wkb'] is not None:
+        upstream_poly_geom = wkb.loads(facility['upstream_poly_wkb'])
+    if 'downstream_poly_wkb' in facility.index and facility['downstream_poly_wkb'] is not None:
+        downstream_poly_geom = wkb.loads(facility['downstream_poly_wkb'])
+
+    # Create map
+    m = folium.Map(
+        location=[facility.geometry.y, facility.geometry.x],
+        zoom_start=13,
+        tiles="CartoDB positron"
+    )
+
+    # Add upstream polygons
+    if upstream_poly_geom is not None:
+        if upstream_poly_geom.geom_type == "Polygon":
+            polys = [upstream_poly_geom]
+        elif upstream_poly_geom.geom_type == "MultiPolygon":
+            polys = list(upstream_poly_geom.geoms)
+        else:
+            polys = []
+
+        for poly in polys:
+            coords = [[c[1], c[0]] for c in poly.exterior.coords]
+            folium.Polygon(
+                locations=coords,
+                color=UPSTREAM_COLOR,
+                weight=1,
+                fill=True,
+                fill_color=UPSTREAM_POLY_COLOR,
+                fill_opacity=0.4,
+                popup="Upstream water surface"
+            ).add_to(m)
+
+    # Add downstream polygons
+    if downstream_poly_geom is not None:
+        if downstream_poly_geom.geom_type == "Polygon":
+            polys = [downstream_poly_geom]
+        elif downstream_poly_geom.geom_type == "MultiPolygon":
+            polys = list(downstream_poly_geom.geoms)
+        else:
+            polys = []
+
+        for poly in polys:
+            coords = [[c[1], c[0]] for c in poly.exterior.coords]
+            folium.Polygon(
+                locations=coords,
+                color=DOWNSTREAM_COLOR,
+                weight=1,
+                fill=True,
+                fill_color=DOWNSTREAM_POLY_COLOR,
+                fill_opacity=0.4,
+                popup="Downstream water surface"
+            ).add_to(m)
+
+    # Add upstream line (animated going upstream = reversed coords)
+    if upstream_line_geom is not None:
+        if upstream_line_geom.geom_type == "LineString":
+            lines = [upstream_line_geom]
+        elif upstream_line_geom.geom_type == "MultiLineString":
+            lines = list(upstream_line_geom.geoms)
+        else:
+            lines = []
+
+        for line in lines:
+            coords = [[c[1], c[0]] for c in reversed(list(line.coords))]
+            AntPath(
+                locations=coords,
+                weight=4,
+                color=UPSTREAM_COLOR,
+                pulse_color="#ffffff",
+                delay=600,
+                dash_array=[10, 20],
+                popup="Upstream (source water)"
+            ).add_to(m)
+
+    # Add downstream line (animated going downstream)
+    if downstream_line_geom is not None:
+        if downstream_line_geom.geom_type == "LineString":
+            lines = [downstream_line_geom]
+        elif downstream_line_geom.geom_type == "MultiLineString":
+            lines = list(downstream_line_geom.geoms)
+        else:
+            lines = []
+
+        for line in lines:
+            coords = [[c[1], c[0]] for c in line.coords]
+            AntPath(
+                locations=coords,
+                weight=4,
+                color=DOWNSTREAM_COLOR,
+                pulse_color="#ffffff",
+                delay=600,
+                dash_array=[10, 20],
+                popup="Downstream (affected area)"
+            ).add_to(m)
+
+    # Add facility marker
+    folium.Marker(
+        location=[facility.geometry.y, facility.geometry.x],
+        popup=f"""
+        <b>{facility['facilityName']}</b><br>
+        {facility.get('city', '')}, {facility.get('countryName', '')}<br>
+        <hr>
+        <b>Closest river:</b> {facility['closest_river_id']}<br>
+        <b>Distance:</b> {facility['distance_to_river_m']:.0f}m<br>
+        <b>River order:</b> {facility['river_strahler']}<br>
+        <b>Discharge:</b> {facility['river_discharge']:.1f} m³/s<br>
+        <hr>
+        <b style="color:{UPSTREAM_COLOR}">Upstream:</b> {facility['n_upstream']} parts<br>
+        <b style="color:{DOWNSTREAM_COLOR}">Downstream:</b> {facility['n_downstream']} parts
+        """,
+        icon=folium.Icon(color='orange', icon='industry', prefix='fa')
+    ).add_to(m)
+
+    # Legend
+    legend_html = f"""
+    <div style="position: fixed; bottom: 50px; left: 50px; z-index: 1000;
+                background-color: white; padding: 15px; border-radius: 8px;
+                border: 2px solid #333; font-size: 12px; max-width: 220px;">
+        <b>{facility['facilityName']}</b><br>
+        <small>{facility.get('city', '')}</small><br><br>
+        <b style="color: {UPSTREAM_COLOR};">━━━ Upstream ({facility['n_upstream']})</b><br>
+        Source water flowing toward facility<br><br>
+        <b style="color: {DOWNSTREAM_COLOR};">━━━ Downstream ({facility['n_downstream']})</b><br>
+        Water flowing away (potentially affected)<br><br>
+        <small>River split at closest point to facility</small>
+    </div>
+    """
+    m.get_root().html.add_child(folium.Element(legend_html))
+
+    # Save
+    print(f"Saving to {output_path}...")
+    m.save(str(output_path))
+    print("Done!")
+
+
+if __name__ == "__main__":
+    facility_name = sys.argv[1] if len(sys.argv) > 1 else "PRECHEZA"
+    output_path = Path(__file__).resolve().parent / "facility_map.html"
+    create_facility_map(facility_name, output_path)