core: refactor map layers with optional forests, waterways and coastline

create_map_poster.py

@@ -29,6 +29,184 @@ OVERFETCH = 1.20
 # Buildings are only practical at small scale
 BUILDINGS_MAX_DIST = 5000  # Town threshold
 
+import re
+from shapely.geometry import LineString, MultiLineString
+
+
+def first_tag_value(v):
+    """OSM tags can be scalars or lists. Always return a single scalar."""
+    if isinstance(v, list):
+        return v[0] if v else None
+    return v
+
+
+def _safe_float(x):
+    try:
+        if x is None:
+            return None
+        if isinstance(x, (int, float)):
+            return float(x)
+        # Handle strings like "3", "3.5", "3 m", "3,5"
+        s = str(x).strip().lower().replace(",", ".")
+        m = re.search(r"[-+]?\d*\.?\d+", s)
+        return float(m.group(0)) if m else None
+    except Exception:
+        return None
+
+
+def get_waterway_widths_by_type(waterways_gdf, theme=None):
+    """
+    Return a list of linewidths (floats) aligned with waterways_gdf rows.
+    If a numeric 'width' tag exists in OSM data, it is used as a hint.
+    Otherwise uses a simple hierarchy by waterway type.
+
+    Notes:
+    - OSM 'width' is in meters (often missing / inconsistent). We map it to a
+      plotting linewidth with a gentle clamp.
+    - 'riverbank' is a polygon, so it won't normally be in waterways_gdf (lines).
+    """
+    if waterways_gdf is None or getattr(waterways_gdf, "empty", True):
+        return []
+
+    # Base widths in "plot linewidth units"
+    base = {
+        "river": 1.00,
+        "canal": 0.85,
+        "stream": 0.55,
+        "brook": 0.45,
+        "tidal_channel": 0.65,
+        "ditch": 0.40,
+        "drain": 0.38,
+    }
+    default_w = 0.45
+
+    # Allow theme overrides if you want later
+    # e.g. theme["waterway_river_width"] etc.
+    theme = theme or {}
+    default_w = float(theme.get("waterway_default_width", default_w))
+    base["river"] = float(theme.get("waterway_river_width", base["river"]))
+    base["canal"] = float(theme.get("waterway_canal_width", base["canal"]))
+    base["stream"] = float(theme.get("waterway_stream_width", base["stream"]))
+    base["brook"] = float(theme.get("waterway_brook_width", base["brook"]))
+    base["ditch"] = float(theme.get("waterway_ditch_width", base["ditch"]))
+    base["drain"] = float(theme.get("waterway_drain_width", base["drain"]))
+    base["tidal_channel"] = float(theme.get("waterway_tidal_width", base["tidal_channel"]))
+
+    widths = []
+
+    # Pre-check columns
+    has_type = "waterway" in waterways_gdf.columns
+    has_width = "width" in waterways_gdf.columns
+
+    for _, row in waterways_gdf.iterrows():
+        wtype = first_tag_value(row.get("waterway")) if has_type else None
+        lw = base.get(wtype, default_w)
+
+        # Optional: use OSM "width" tag as a hint when present
+        if has_width:
+            osm_w = _safe_float(first_tag_value(row.get("width")))
+            if osm_w is not None:
+                # Map meters -> linewidth. Keep it subtle.
+                # 0..30m -> 0.4..2.2 (clamped)
+                mapped = 0.4 + (min(max(osm_w, 0.0), 30.0) / 30.0) * 1.8
+                # Blend with hierarchy so width doesn't explode on bad tags
+                lw = 0.6 * lw + 0.4 * mapped
+
+        # Safety clamp (avoids ugly giant strokes)
+        lw = float(np.clip(lw, 0.25, 2.4))
+        widths.append(lw)
+
+    return widths
+
+
+def get_waterway_alphas_by_type(waterways_gdf, theme=None):
+    """
+    Optional: alpha hierarchy (bigger waterways slightly more opaque).
+    """
+    if waterways_gdf is None or getattr(waterways_gdf, "empty", True):
+        return []
+
+    theme = theme or {}
+
+    base = {
+        "river": 0.75,
+        "canal": 0.70,
+        "stream": 0.60,
+        "brook": 0.55,
+        "tidal_channel": 0.65,
+        "ditch": 0.50,
+        "drain": 0.50,
+    }
+    default_a = float(theme.get("waterway_default_alpha", 0.60))
+
+    alphas = []
+    has_type = "waterway" in waterways_gdf.columns
+
+    for _, row in waterways_gdf.iterrows():
+        wtype = first_tag_value(row.get("waterway")) if has_type else None
+        a = float(base.get(wtype, default_a))
+        a = float(np.clip(a, 0.25, 0.90))
+        alphas.append(a)
+
+    return alphas
+
+
+def plot_waterways_by_hierarchy(
+    ax,
+    waterways_gdf,
+    *,
+    color,
+    theme=None,
+    zorder=2.2,
+    dash=None,
+):
+    """
+    Plot waterways with per-feature linewidth/alpha (like road hierarchy).
+
+    - dash=None => solid line
+    - dash=(0,(3,3)) => dashed etc.
+    """
+    if waterways_gdf is None or getattr(waterways_gdf, "empty", True):
+        return
+
+    theme = theme or {}
+    widths = get_waterway_widths_by_type(waterways_gdf, theme=theme)
+    alphas = get_waterway_alphas_by_type(waterways_gdf, theme=theme)
+
+    # Iterate geometries and plot with their style
+    i = 0
+    for geom in waterways_gdf.geometry:
+        if geom is None or geom.is_empty:
+            i += 1
+            continue
+
+        lw = widths[i] if i < len(widths) else 0.45
+        alpha = alphas[i] if i < len(alphas) else 0.60
+        i += 1
+
+        if isinstance(geom, LineString):
+            xs, ys = geom.xy
+            ax.plot(
+                xs, ys,
+                color=color,
+                linewidth=lw,
+                alpha=alpha,
+                zorder=zorder,
+                linestyle=dash if dash is not None else "solid",
+            )
+
+        elif isinstance(geom, MultiLineString):
+            for part in geom.geoms:
+                xs, ys = part.xy
+                ax.plot(
+                    xs, ys,
+                    color=color,
+                    linewidth=lw,
+                    alpha=alpha,
+                    zorder=zorder,
+                    linestyle=dash if dash is not None else "solid",
+                )
+
 def finalize_map_view(ax_map, target_ratio: float, *, pad: float):
     """
     Vue finale sans distorsion et sans letterboxing (bandes blanches).
@@ -760,8 +938,7 @@ def drop_nodes_missing_xy(G, label="graph"):
         print(f"⚠ {label}: dropping {len(bad)} nodes missing x/y (pre-plot safety)")
         G.remove_nodes_from(bad)
     return G 
-    
-from shapely.geometry import LineString, MultiLineString
+
 
 def plot_lines_dashed(ax, gdf, color, lw, alpha, zorder, dash=(0, (3, 3))):
     if gdf is None or getattr(gdf, "empty", True):
@@ -836,6 +1013,9 @@ def create_poster(
     enable_buildings=False,
     enable_railroads=False,
     enable_margins=True,
+    enable_waterways=True,
+    enable_forests=True,
+    enable_coastline=True,
 ):
     print(f"\nGenerating map for {city}, {country}...")
 
@@ -845,7 +1025,19 @@ def create_poster(
         print(f"⚠ Buildings layer disabled (distance {dist}m > {BUILDINGS_MAX_DIST}m).")
         enable_buildings = False
 
-    steps = 4 + (1 if enable_buildings else 0) + (1 if enable_railroads else 0)
+    # ---- Build dynamic progress steps (avoid downloading unused layers) ----
+    # Always: streets + water polygons + green (parks/grass)
+    steps = 3
+    if enable_coastline:
+        steps += 1
+    if enable_waterways:
+        steps += 1
+    if enable_forests:
+        steps += 1
+    if enable_buildings:
+        steps += 1
+    if enable_railroads:
+        steps += 1
 
     with tqdm(
         total=steps,
@@ -854,19 +1046,24 @@ def create_poster(
         bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt}",
     ) as pbar:
 
+        # ---- Streets ----
         pbar.set_description("Downloading street network")
         G = ox.graph_from_point(point, dist=dist_fetch, dist_type="bbox", network_type="all")
         pbar.update(1)
-        time.sleep(0.5)
-
-        pbar.set_description("Downloading coastline")
-        try:
-            coast = ox.features_from_point(point, tags={"natural": "coastline"}, dist=dist_fetch)
-        except Exception:
-            coast = None
-        pbar.update(1)
         time.sleep(0.2)
 
+        # ---- Coastline (optional) ----
+        coast = None
+        if enable_coastline:
+            pbar.set_description("Downloading coastline")
+            try:
+                coast = ox.features_from_point(point, tags={"natural": "coastline"}, dist=dist_fetch)
+            except Exception:
+                coast = None
+            pbar.update(1)
+            time.sleep(0.1)
+
+        # ---- Water polygons (always) ----
         pbar.set_description("Downloading water features")
         try:
             water = ox.features_from_point(
@@ -875,18 +1072,59 @@ def create_poster(
         except Exception:
             water = None
         pbar.update(1)
-        time.sleep(0.3)
+        time.sleep(0.15)
 
-        pbar.set_description("Downloading parks/green spaces")
+        # ---- Waterways lines (optional) ----
+        waterways = None
+        if enable_waterways:
+            pbar.set_description("Downloading waterways")
+            try:
+                waterways = ox.features_from_point(
+                    point,
+                    tags={"waterway": ["river", "stream", "brook", "canal", "ditch", "drain", "tidal_channel"]},
+                    dist=dist_fetch,
+                )
+            except Exception:
+                waterways = None
+            pbar.update(1)
+            time.sleep(0.1)
+
+        # ---- Green (parks + grass) (always) ----
+        green = None
+        pbar.set_description("Downloading parks / grass")
         try:
-            parks = ox.features_from_point(
-                point, tags={"leisure": "park", "landuse": "grass"}, dist=dist_fetch
+            green = ox.features_from_point(
+                point,
+                tags={
+                    "leisure": "park",
+                    "landuse": ["grass"],
+                },
+                dist=dist_fetch,
             )
         except Exception:
-            parks = None
+            green = None
         pbar.update(1)
-        time.sleep(0.3)
+        time.sleep(0.1)
+
+        # ---- Forests (optional, separated) ----
+        forests = None
+        if enable_forests:
+            pbar.set_description("Downloading forests")
+            try:
+                forests = ox.features_from_point(
+                    point,
+                    tags={
+                        "landuse": "forest",
+                        "natural": "wood",
+                    },
+                    dist=dist_fetch,
+                )
+            except Exception:
+                forests = None
+            pbar.update(1)
+            time.sleep(0.1)
 
+        # ---- Buildings (optional) ----
         buildings = None
         if enable_buildings:
             pbar.set_description("Downloading buildings")
@@ -895,7 +1133,9 @@ def create_poster(
             except Exception:
                 buildings = None
             pbar.update(1)
+            time.sleep(0.1)
 
+        # ---- Railroads (optional) ----
         rails = None
         if enable_railroads:
             pbar.set_description("Downloading railroads")
@@ -904,17 +1144,17 @@ def create_poster(
             except Exception:
                 rails = None
             pbar.update(1)
-            time.sleep(0.2)
+            time.sleep(0.1)
 
     print("✓ All data downloaded successfully!")
 
-    # ---- Project to metric CRS (stabilizes aspect + enables correct cropping) ----
+    # ---- Project to metric CRS ----
     G = ox.project_graph(G)
     G = ensure_graph_xy(G)
     G = drop_nodes_missing_xy(G, label="projected G")
     crs = G.graph.get("crs", None)
 
-    # Build a bbox polygon in projected CRS from the graph nodes
+    # Build bbox polygon in projected CRS from graph nodes
     bbox_poly = None
     try:
         xs = [data["x"] for _, data in G.nodes(data=True)]
@@ -924,6 +1164,7 @@ def create_poster(
     except Exception:
         bbox_poly = None
 
+    # Reproject layers to graph CRS
     if crs is not None:
         try:
             if water is not None and hasattr(water, "to_crs") and not water.empty:
@@ -931,8 +1172,18 @@ def create_poster(
         except Exception:
             pass
         try:
-            if parks is not None and hasattr(parks, "to_crs") and not parks.empty:
-                parks = parks.to_crs(crs)
+            if waterways is not None and hasattr(waterways, "to_crs") and not waterways.empty:
+                waterways = waterways.to_crs(crs)
+        except Exception:
+            pass
+        try:
+            if green is not None and hasattr(green, "to_crs") and not green.empty:
+                green = green.to_crs(crs)
+        except Exception:
+            pass
+        try:
+            if forests is not None and hasattr(forests, "to_crs") and not forests.empty:
+                forests = forests.to_crs(crs)
         except Exception:
             pass
         try:
@@ -945,11 +1196,20 @@ def create_poster(
                 rails = rails.to_crs(crs)
         except Exception:
             pass
+        try:
+            if coast is not None and hasattr(coast, "to_crs") and crs is not None and not coast.empty:
+                coast = coast.to_crs(crs)
+        except Exception:
+            pass
 
-    # Remove point artifacts (GeoPandas default blue markers)
+    # Clean geometries
     buildings = _clean_polygons(buildings)
     water = _clean_polygons(water)
-    parks = _clean_polygons(parks)
+    green = _clean_polygons(green)
+    forests = _clean_polygons(forests)
+    waterways = _clean_lines(waterways)
+    rails = _clean_lines(rails)
+    coast = _clean_lines(coast)
 
     if buildings is not None and not buildings.empty:
         try:
@@ -957,8 +1217,6 @@ def create_poster(
         except Exception:
             pass
 
-    rails = _clean_lines(rails)
-
     # Optional rail noise filters
     if rails is not None and not getattr(rails, "empty", True):
         if "service" in rails.columns:
@@ -992,11 +1250,11 @@ def create_poster(
     ax_map = fig.add_axes([0, 0, 1, 1])
     ax_map.set_axis_off()
 
-    # ---- Coastline-aware ocean fill ----
+    # ---- Coastline-aware ocean fill (optional) ----
     land_poly = None
     ocean_poly = None
 
-    if bbox_poly is not None:
+    if enable_coastline and bbox_poly is not None and coast is not None and not getattr(coast, "empty", True):
         land_poly = coastline_land_polygon(coast, point, crs, bbox_poly)
         if land_poly is not None:
             ocean_poly = bbox_poly.difference(land_poly)
@@ -1015,29 +1273,50 @@ def create_poster(
             ocean_poly = None
             land_poly = None
 
+    is_coastal = (ocean_poly is not None)
+
     # Fallback background
-    ax_map.set_facecolor(THEME["bg"] if ocean_poly is None else THEME["water"])
+    ax_map.set_facecolor(THEME["bg"] if not is_coastal else THEME["water"])
 
     ax_page = fig.add_axes([0, 0, 1, 1], facecolor="none")
     ax_page.set_axis_off()
 
-    # ---- Layer 1: polygons ----
+    # ---- Layer 1: polygons (bottom) ----
     if water is not None and not getattr(water, "empty", True):
-        water.plot(ax=ax_map, facecolor=THEME["water"], edgecolor="none", zorder=1)
-    if parks is not None and not getattr(parks, "empty", True):
-        parks.plot(ax=ax_map, facecolor=THEME["parks"], edgecolor="none", zorder=2)
+        water.plot(ax=ax_map, facecolor=THEME["water"], edgecolor="none", zorder=0.6)
+
+    if green is not None and not getattr(green, "empty", True):
+        green.plot(ax=ax_map, facecolor=THEME["parks"], edgecolor="none", zorder=0.7)
+
+    # Forests (separate optional layer)
+    if enable_forests and forests is not None and not getattr(forests, "empty", True):
+        forest_color = THEME.get("forests", THEME.get("parks", "#F0F0F0"))
+        forest_alpha = float(THEME.get("forests_alpha", 1.0))
+        forest_alpha = max(0.05, min(1.0, forest_alpha))
+        forests.plot(ax=ax_map, facecolor=forest_color, edgecolor="none", alpha=forest_alpha, zorder=0.75)
+
+    # ---- Waterways (optional) ----
+    if enable_waterways and waterways is not None and not getattr(waterways, "empty", True):
+        plot_waterways_by_hierarchy(
+            ax_map,
+            waterways,
+            color=THEME["water"],
+            theme=THEME,
+            zorder=2.2,
+            dash=None,
+        )
 
-    # ---- Layer 1.5: buildings ----
+    # ---- Buildings ----
     if enable_buildings and buildings is not None and not getattr(buildings, "empty", True):
         face, alpha = buildings_style_from_text(THEME)
-        buildings.plot(ax=ax_map, facecolor=face, edgecolor="none", alpha=alpha, zorder=3)
+        buildings.plot(ax=ax_map, facecolor=face, edgecolor="none", alpha=alpha, zorder=3.0)
 
-    # ---- Layer 2: roads ----
+    # ---- Roads ----
     print("Applying road hierarchy colors...")
     edge_colors = get_edge_colors_by_type(G)
     edge_widths = get_edge_widths_by_type(G)
 
-    bgcolor_roads = THEME["water"] if ocean_poly is not None else THEME["bg"]
+    bgcolor_roads = THEME["water"] if is_coastal else THEME["bg"]
 
     ox.plot_graph(
         G,
@@ -1054,7 +1333,13 @@ def create_poster(
         close=False,
     )
 
-    # ---- Layer 2.5: railroads ----
+    # Ensure plotted roads sit above polygons/waterways
+    from matplotlib.collections import LineCollection
+    for coll in ax_map.collections:
+        if isinstance(coll, LineCollection):
+            coll.set_zorder(2.6)
+
+    # ---- Railroads ----
     if enable_railroads and rails is not None and not getattr(rails, "empty", True):
         rail_color = THEME.get("rail_color", THEME.get("text", "#000000"))
         rail_width = float(THEME.get("rail_width", 0.6))
@@ -1069,21 +1354,18 @@ def create_poster(
             dash=(0, (3, 3)),
         )
 
-    # ---- Hard clamp view to bbox (kills OSMnx/GeoPandas autoscale padding) ----
+    # ---- Hard clamp view to bbox ----
     if bbox_poly is not None:
         minx, miny, maxx, maxy = bbox_poly.bounds
         ax_map.set_xlim(minx, maxx)
         ax_map.set_ylim(miny, maxy)
         ax_map.margins(0)
-    
-    # ---- Cropping + edge treatment (OPTIONAL) ----
-    # Règle: on garde toujours un rendu sans distorsion.
-    # - margins ON: inland => pad + fades ; coastal => pad=0 + frame
-    # - margins OFF: pas de fades, pas de frame ; pad=0
-    
+
+    # ---- Cropping + edge treatment ----
+    frame_t = 0.0
+
     if enable_margins:
-        if ocean_poly is None:
-            # inland: pad + fades
+        if not is_coastal:
             finalize_map_view(ax_map, target_ratio, pad=MAP_PAD)
 
             if orientation == "portrait":
@@ -1092,16 +1374,12 @@ def create_poster(
             elif orientation == "landscape":
                 create_gradient_fade(ax_map, THEME["gradient_color"], "left", thickness=fade_lr)
                 create_gradient_fade(ax_map, THEME["gradient_color"], "right", thickness=fade_lr)
-
         else:
-            # coastal: pas de pad + frame uniforme
             finalize_map_view(ax_map, target_ratio, pad=0.0)
 
             frame_t = margin_thickness_from_layout(THEME)
             add_margin_frame(ax_page, color=THEME["bg"], thickness=frame_t, zorder=10)
-
     else:
-        # no-margins: pas de fades, pas de frame, mais ratio OK et pas de squizz
         finalize_map_view(ax_map, target_ratio, pad=0.0)
 
     if THEME.get("_text_fade", False):
@@ -1114,16 +1392,16 @@ def create_poster(
             zorder=10,
         )
 
+    # ---- Bottom text ----
     city_label = city or "Custom"
-
     lat, lon = point
     coords = f"{lat:.4f}° N / {lon:.4f}° E" if lat >= 0 else f"{abs(lat):.4f}° S / {lon:.4f}° E"
     if lon < 0:
         coords = coords.replace("E", "W")
 
     text_offset = 0.0
-    if enable_margins and (ocean_poly is not None):
-        text_offset = frame_t  # même valeur que la marge du bas
+    if enable_margins and is_coastal:
+        text_offset = frame_t
 
     layout_bottom_text(
         ax_page=ax_page,
@@ -1133,7 +1411,7 @@ def create_poster(
         theme=THEME,
         fonts=FONTS,
         zorder=11,
-        bottom_offset=text_offset,  # <-- NEW
+        bottom_offset=text_offset,
     )
 
     dpi = int(THEME.get("_dpi", DEFAULT_DPI))
@@ -1260,6 +1538,24 @@ Examples:
         help='Enable railroads layer (OSM railway=rail).'
     )
 
+    parser.add_argument(
+        '--waterways',
+        action='store_true',
+        help='Enable waterways layer (rivers, streams, canals, etc.)'
+    )
+
+    parser.add_argument(
+        '--forests',
+        action='store_true',
+        help='Enable forests layer (wooded areas)'
+    )
+
+    parser.add_argument(
+        '--coastline',
+        action='store_true',
+        help='Enable coastline detection and ocean fill'
+    )
+
     args = parser.parse_args()
 
     if len(os.sys.argv) == 1:
@@ -1316,6 +1612,9 @@ Examples:
             enable_buildings=bool(args.buildings),
             enable_railroads=bool(args.railroads),
             enable_margins=(not bool(args.no_margins)),
+            enable_waterways=bool(args.waterways),
+            enable_forests=bool(args.forests),
+            enable_coastline=bool(args.coastline),
         )
 
         print("\n" + "=" * 50)