networkforge 1.4.1__py3-none-any.whl

networkforge/inputs.py

@@ -0,0 +1,256 @@
+"""
+Checks and clean-up of build_network's inputs, before any work is done.
+
+Input problems raise InputError with a plain-language message. Problems
+with individual custom features (no geometry, not a line, outside the
+bounding box) raise when strict, or are dropped with a warning when not.
+"""
+
+import logging
+
+import geopandas as gpd
+import numpy as np
+import pandas as pd
+import shapely
+from shapely.geometry import box
+
+from .edits import take_edit_ids
+from .errors import InputError
+from .tags import EDIT_ID_COLUMN
+from .validation import RESERVED_COLUMNS
+
+log = logging.getLogger(__name__)
+
+LINE_TYPES = {"LineString", "MultiLineString"}
+# Points carry node tags (barriers, signals ...: see points.py).
+FEATURE_TYPES = LINE_TYPES | {"Point", "MultiPoint"}
+
+# Largest bounding box downloaded from the Overpass API. Overpass is a
+# free shared service (roughly 10,000 queries or 1 GB a day per user);
+# bigger areas must come from a local extract (osm_source=...), which
+# is also faster and gives the same data every run.
+MAX_OVERPASS_AREA_KM2 = 1000
+
+# With a local extract there's no limit, but warn: memory and time grow.
+LARGE_LOCAL_AREA_KM2 = 10_000
+
+# How many offending feature ids to list in a message.
+MAX_LISTED = 10
+
+
+OFF_THE_EARTH = ("has coordinates that can't be longitude / latitude in its CRS: check the "
+                 "layer's CRS is set right")
+
+
+def within_the_earth(geometry: gpd.GeoSeries) -> pd.Series:
+    """
+    For each geometry (finite coordinates, a CRS set): whether every
+    coordinate is a real longitude / latitude once reprojected.
+    """
+    try:
+        wgs84 = geometry.to_crs("EPSG:4326")
+    except Exception:  # noqa: BLE001 - a transform that fails is as bad
+        return pd.Series(False, index=geometry.index)
+    coords, owner = shapely.get_coordinates(wgs84.to_numpy(), return_index=True)
+    bad = ~np.isfinite(coords).all(axis=1) | (np.abs(coords[:, 0]) > 180) | (
+        np.abs(coords[:, 1]) > 90)
+    result = pd.Series(True, index=geometry.index)
+    result.iloc[np.unique(owner[bad])] = False
+    return result
+
+
+def check_bbox(bbox_gdf, local_source: bool = False) -> None:
+    """
+    The bounding box must be a GeoDataFrame with geometry and a CRS,
+    and no bigger than MAX_OVERPASS_AREA_KM2 unless the OSM data comes
+    from a local file (local_source=True).
+    """
+
+    if not isinstance(bbox_gdf, gpd.GeoDataFrame):
+        raise InputError(
+            f"The bounding box must be a GeoDataFrame, not {type(bbox_gdf).__name__}."
+        )
+
+    geometry = bbox_gdf.geometry
+    if bbox_gdf.empty or (geometry.isna() | geometry.is_empty).all():
+        raise InputError("The bounding box has no geometry.")
+
+    if bbox_gdf.crs is None:
+        raise InputError(
+            "The bounding box has no CRS, so its coordinates can't be placed on "
+            "the map. Set one, e.g. bbox_gdf.set_crs('EPSG:4326')."
+        )
+
+    projected = bbox_gdf.to_crs(bbox_gdf.estimate_utm_crs())
+    area_km2 = box(*projected.total_bounds).area / 1e6
+
+    if local_source:
+        if area_km2 > LARGE_LOCAL_AREA_KM2:
+            log.warning("The bounding box covers %.0f km2; expect a long build and "
+                        "high memory use.", area_km2)
+        return
+
+    if area_km2 > MAX_OVERPASS_AREA_KM2:
+        west, south, east, north = bbox_gdf.to_crs("EPSG:4326").total_bounds
+        raise InputError(
+            f"The bounding box covers {area_km2:,.0f} km2, more than the "
+            f"{MAX_OVERPASS_AREA_KM2:,} km2 NetworkForge will download from the shared "
+            "Overpass API. Use a local OSM extract instead:\n"
+            "  1. Download one covering the area, e.g. from "
+            "https://download.geofabrik.de (countries and regions, updated daily)\n"
+            "     or https://extract.bbbike.org (draw your own area).\n"
+            "  2. Optionally crop it to your box (faster builds):\n"
+            f"     osmium extract -b {west:.4f},{south:.4f},{east:.4f},{north:.4f} "
+            "region.osm.pbf -o area.osm.pbf\n"
+            "  3. Pass it in: build_network(..., osm_source='area.osm.pbf')",
+            guide="osm-data.md",
+        )
+
+
+def clean_custom_data(
+    custom_gdf,
+    bbox_gdf: gpd.GeoDataFrame | None,
+    strict: bool = True,
+    edits: bool = True,
+) -> gpd.GeoDataFrame:
+    """
+    Check the custom data and return a cleaned copy: only line (and
+    point) features with geometry that reach into the bounding box, in 2D.
+
+    bbox_gdf None: there is no box (a standalone network), so nothing
+    is outside it. edits False: an OSM id attribute is not read as
+    "change this existing street" (there are no existing streets).
+    """
+
+    if not isinstance(custom_gdf, gpd.GeoDataFrame):
+        raise InputError(
+            f"The custom data must be a GeoDataFrame, not {type(custom_gdf).__name__}."
+        )
+
+    if custom_gdf.empty:
+        raise InputError("The custom data has no features.")
+
+    if custom_gdf.crs is None:
+        raise InputError(
+            "The custom data has no CRS, so its coordinates can't be placed on "
+            "the map. Set one, e.g. custom_gdf.set_crs('EPSG:4326')."
+        )
+
+    check_feature_ids(custom_gdf)
+    custom = take_edit_ids(custom_gdf) if edits else custom_gdf
+    custom = drop_reserved_columns(custom.copy(), quiet=EDIT_ID_COLUMN in custom.columns)
+    if custom.geometry.name != "geometry":
+        # As the network's tables call it (e.g. "geom" from a database):
+        # two geometry columns can't be written to a GeoPackage.
+        custom = custom.drop(columns="geometry", errors="ignore").rename_geometry("geometry")
+    geometry = custom.geometry
+
+    no_geometry = geometry.isna() | geometry.is_empty
+    not_a_line = ~no_geometry & ~geometry.geom_type.isin(FEATURE_TYPES)
+
+    # Coordinates that aren't numbers (NaN, inf) break every geometry operation.
+    coords, owner = shapely.get_coordinates(geometry.to_numpy(), return_index=True)
+    bad_coordinates = pd.Series(False, index=custom.index)
+    bad_coordinates.iloc[np.unique(owner[~np.isfinite(coords).all(axis=1)])] = True
+
+    # Numbers that can't be a place on the earth: usually a layer whose
+    # CRS is wrong (metres labelled as longitude / latitude).
+    off_the_earth = pd.Series(False, index=custom.index)
+    checked = ~no_geometry & ~not_a_line & ~bad_coordinates
+    if checked.any():
+        off_the_earth[checked] = ~within_the_earth(geometry[checked])
+
+    usable = ~no_geometry & ~not_a_line & ~bad_coordinates & ~off_the_earth
+    if bbox_gdf is None:
+        outside = partly_outside = usable & False
+    else:
+        # Only usable geometries: GEOS can't compare one with NaN coordinates.
+        bbox_area = bbox_gdf.to_crs(custom.crs).union_all()
+        inside = pd.Series(False, index=custom.index)
+        within = pd.Series(False, index=custom.index)
+        inside[usable] = geometry[usable].intersects(bbox_area)
+        within[usable] = geometry[usable].within(bbox_area)
+        outside = usable & ~inside
+        partly_outside = usable & ~outside & ~within
+
+    problems, issues = [], []
+    types = geometry[not_a_line].geom_type
+    for mask, reason in (
+        (no_geometry, "no geometry"),
+        (not_a_line, f"{'/'.join(sorted(set(types)))}, not a line or point (only lines can "
+                     "be routed; points tag the network's nodes)"),
+        (bad_coordinates, "has coordinates that aren't numbers (NaN or infinite)"),
+        (off_the_earth, OFF_THE_EARTH),
+        (outside, "completely outside the bounding box"),
+    ):
+        if mask.any():
+            problems.append(f"{_ids(custom, mask)}: {reason}")
+            issues += [{"feature": fid, "message": reason} for fid in custom.index[mask]]
+    for issue in issues:  # say which geometry type each non-line is
+        if issue["feature"] in types.index:
+            issue["message"] = f"{types.loc[issue['feature']]}, not a line or point"
+
+    if problems:
+        message = "Some custom features can't be used - " + "; ".join(problems) + "."
+        if outside.any() and outside.sum() == usable.sum():
+            message += (" None of them is in the box: check the layer's CRS is set right (and, "
+                        "for longitude / latitude, that they aren't the wrong way round).")
+        if strict:
+            raise InputError(message, guide="preparing-your-data", issues=issues)
+        log.warning("strict=False, dropping them: %s", message,
+                    extra={"features": [i["feature"] for i in issues]})
+        custom = custom[usable & ~outside]
+        if custom.empty:
+            raise InputError("No usable custom features are left. " + message, issues=issues)
+
+    partly = partly_outside.loc[custom.index]
+    if partly.any():
+        log.warning(
+            "%s: partly outside the bounding box; the parts outside can't join "
+            "the OSM network.", _ids(custom, partly).capitalize(),
+            extra={"features": list(custom.index[partly])},
+        )
+
+    if custom.geometry.has_z.any():
+        log.info("Dropping Z/M values from custom geometries (2D is used for routing).")
+        custom = custom.set_geometry(shapely.force_2d(custom.geometry.values), crs=custom.crs)
+
+    return custom
+
+
+def check_feature_ids(custom_gdf: gpd.GeoDataFrame) -> None:
+    """The index names features in messages and JSON issues: it must be unique."""
+    if not custom_gdf.index.is_unique:
+        repeated = custom_gdf.index[custom_gdf.index.duplicated()]
+        duplicated = sorted(set(repeated), key=str)[:MAX_LISTED]
+        raise InputError(
+            f"Custom feature ids (the data's index / --id-field) must be unique; "
+            f"repeated: {', '.join(map(str, duplicated))}."
+        )
+
+
+def drop_reserved_columns(custom_gdf: gpd.GeoDataFrame, quiet: bool = False) -> gpd.GeoDataFrame:
+    """
+    Set aside attributes whose names the pipeline uses internally (e.g.
+    `length`, `key` - common in GIS layers). They aren't OSM tags, so
+    nothing is lost; a warning names them. `quiet`: only note it - rows
+    copied from a NetworkForge layer (to change existing streets) always
+    have them.
+    """
+    reserved = sorted(RESERVED_COLUMNS & set(custom_gdf.columns))
+    if reserved:
+        log.log(
+            logging.INFO if quiet else logging.WARNING,
+            "Ignoring custom attribute(s) %s: the names are used internally and "
+            "aren't OSM tags.", ", ".join(reserved), extra={"fields": reserved},
+        )
+        custom_gdf = custom_gdf.drop(columns=reserved)
+    return custom_gdf
+
+
+def _ids(gdf: gpd.GeoDataFrame, mask) -> str:
+    """'feature 3' / 'features 3, 7 and 2 more' for the rows selected by mask."""
+    ids = list(gdf.index[mask])
+    listed = ", ".join(map(str, ids[:MAX_LISTED]))
+    more = f" and {len(ids) - MAX_LISTED} more" if len(ids) > MAX_LISTED else ""
+    return f"feature{'s' if len(ids) > 1 else ''} {listed}{more}"

networkforge/modes.py

@@ -0,0 +1,336 @@
+"""
+Transport-mode access rules.
+
+Two layers, applied to plain tag dicts:
+
+1. OSMnx's own Overpass network filters (parsed from OSMnx), which
+   decide by way type: e.g. no cars on footways, no walking on
+   motorways.
+2. The OSM access hierarchy, which OSMnx only partly applies: the most
+   specific access tag for the mode decides (for cars: motorcar >
+   motor_vehicle > vehicle > access). This closes ways tagged e.g.
+   access=no or motor_vehicle=private, keeps busways for buses only,
+   and opens ways a mode-specific tag explicitly allows, e.g. a footway
+   with bicycle=designated (a shared-use path).
+
+The same rules are used to:
+  - validate custom features before a build (validation.py),
+  - decide which OSM tags must survive download and export, and
+  - filter a loaded graph down to one mode at routing time.
+
+Note: `_get_network_filter` is private OSMnx API (checked against
+OSMnx 2.1). If a future release changes it, `mode_rules` will fail
+loudly rather than silently allowing everything.
+"""
+
+import re
+from functools import cache
+
+import networkx as nx
+import osmnx as ox
+from osmnx._overpass import _get_network_filter
+
+from .errors import InputError
+from .tags import BASE_WAY_TAGS, CUSTOM_TAG, FERRY_ROUTES, NODE_TAGS, ROUTING_WAY_TAGS
+
+# Routing modes a network can be filtered to. "all" / "all_public"
+# are download scopes rather than travel modes, so they're left out.
+MODES = ("drive", "drive_service", "walk", "bike")
+
+_CLAUSE = re.compile(r'\["([^"]+)"(?:(!?~)"([^"]*)")?\]')
+
+# OSM access hierarchy per mode, general -> specific. The most specific
+# tag present decides: access=no + bicycle=yes is open to bikes only.
+ACCESS_HIERARCHY = {
+    "drive": ("access", "vehicle", "motor_vehicle", "motorcar"),
+    "drive_service": ("access", "vehicle", "motor_vehicle", "motorcar"),
+    "bike": ("access", "vehicle", "bicycle"),
+    "walk": ("access", "foot"),
+}
+
+# Access values that close a way to general routing. (destination,
+# customers, permissive, discouraged, dismount etc. stay open.)
+DENIED_ACCESS = {
+    "no", "private", "agricultural", "forestry", "delivery", "emergency",
+    "military", "restricted", "permit", "use_sidepath",
+}
+
+# Mode-specific values that explicitly open a way.
+GRANTED_ACCESS = {"yes", "designated", "permissive", "official"}
+
+# Way types closed to these modes unless a mode-specific tag opens them:
+# busways are for buses; cycling on a pedestrian street needs e.g.
+# bicycle=yes (OSM's default, and how Valhalla reads it).
+CLOSED_BY_DEFAULT = {
+    "busway": ("drive", "drive_service", "bike", "walk"),
+    "pedestrian": ("bike",),
+}
+
+# motorroad=yes: motorway-like rules on any road type - no walking or
+# cycling unless foot= / bicycle= says otherwise.
+MOTORROAD_CLOSED = ("bike", "walk")
+
+# Access tags for vehicles NetworkForge has no mode for. A way open
+# only to these (a bus gate, a busway) is still a real way: routers
+# with a bus, truck or taxi profile use it.
+OTHER_VEHICLE_KEYS = (
+    "bus", "psv", "hgv", "goods", "taxi", "motorcycle", "moped", "emergency", "horse", "hov",
+)
+BUS_HIGHWAYS = {"busway", "bus_guideway"}
+
+# Way types OSMnx excludes for a mode that a mode-specific tag may open:
+# a footway with bicycle=yes/designated is a shared-use path; a
+# cycleway with foot=yes is walkable.
+OPENABLE = {"bike": {"footway"}, "walk": {"cycleway"}}
+
+
+@cache
+def mode_rules(mode: str) -> tuple[tuple[str, str | None, str | None], ...]:
+    """
+    Parse OSMnx's filter for `mode` into (key, operator, regex)
+    clauses. operator is None ("key must exist"), "~" (value must
+    match) or "!~" (value must not match; a missing key passes).
+    """
+    filter_string = _get_network_filter(mode)
+    clauses = tuple(_CLAUSE.findall(filter_string))
+
+    if not clauses or "".join(f'["{k}"{op}"{rx}"]' if op else f'["{k}"]'
+                              for k, op, rx in clauses) != filter_string:
+        raise RuntimeError(
+            f"Could not parse OSMnx network filter for {mode!r}: "
+            f"{filter_string}. OSMnx's filter format may have changed."
+        )
+
+    return tuple((k, op or None, rx or None) for k, op, rx in clauses)
+
+
+def mode_tag_keys() -> set[str]:
+    """Every OSM tag key any mode's access rules depend on."""
+    return {
+        key
+        for mode in ("all", "all_public", *MODES)
+        for key, _, _ in mode_rules(mode)
+    } | {key for keys in ACCESS_HIERARCHY.values() for key in keys} | {"motorroad"}
+
+
+def keep_mode_tags() -> None:
+    """
+    Make OSMnx keep every tag the access rules use, and every way and
+    node tag export writes (see tags.py). By default OSMnx discards
+    e.g. motor_vehicle, foot, bicycle and barrier, which silently
+    removes restrictions from the network. Call before any graph is
+    downloaded or loaded from XML.
+    """
+    ox.settings.useful_tags_way = sorted(
+        set(ox.settings.useful_tags_way) | mode_tag_keys()
+        | set(BASE_WAY_TAGS) | set(ROUTING_WAY_TAGS) | {CUSTOM_TAG}
+    )
+    ox.settings.useful_tags_node = sorted(set(ox.settings.useful_tags_node) | set(NODE_TAGS))
+
+
+def _as_text(value) -> str | None:
+    if value is None:
+        return None
+    if isinstance(value, float) and value != value:  # NaN
+        return None
+    if isinstance(value, list):
+        return ";".join(map(str, value))
+    return str(value)
+
+
+def effective_access(tags: dict, mode: str) -> tuple[str, str] | None:
+    """(key, value) of the most specific access tag for `mode`, if any."""
+    for key in reversed(ACCESS_HIERARCHY.get(mode, ())):
+        value = _as_text(tags.get(key))
+        if value is not None:
+            return key, value
+    return None
+
+
+def is_ferry(tags: dict) -> bool:
+    """A ferry or shuttle-train route: a way routers use that isn't a highway."""
+    return _as_text(tags.get("highway")) is None and _as_text(tags.get("route")) in FERRY_ROUTES
+
+
+def allows_mode(tags: dict, mode: str) -> bool:
+    """True if a way with these tags is usable by `mode`."""
+    if is_ferry(tags):
+        # Open to everyone unless an access tag closes it (as Valhalla
+        # reads it: route=ferry alone carries cars, bikes and walkers).
+        access = effective_access(tags, mode)
+        return access is None or access[1] not in DENIED_ACCESS
+    if mode not in ACCESS_HIERARCHY:  # download scopes "all" / "all_public"
+        return _passes_osmnx_filter(tags, mode)
+
+    access = effective_access(tags, mode)
+    if access is not None and access[1] in DENIED_ACCESS:
+        return False
+
+    # Opened by a mode-specific tag, not just access=yes.
+    granted = access is not None and access[0] != "access" and access[1] in GRANTED_ACCESS
+    highway = _as_text(tags.get("highway"))
+
+    if mode in CLOSED_BY_DEFAULT.get(highway, ()) and not granted:
+        return False
+    if mode in MOTORROAD_CLOSED and _as_text(tags.get("motorroad")) == "yes" and not granted:
+        return False
+
+    # The hierarchy above replaces OSMnx's own access clauses (e.g. its
+    # motor_vehicle!~no would reject motor_vehicle=no + motorcar=yes).
+    access_keys = set(ACCESS_HIERARCHY[mode])
+    ignore_highway_type = granted and highway in OPENABLE.get(mode, ())
+    return _passes_osmnx_filter(tags, mode, access_keys, ignore_highway_type)
+
+
+def _passes_osmnx_filter(
+    tags: dict,
+    mode: str,
+    skip_keys: set[str] = frozenset(),
+    ignore_highway_type: bool = False,
+) -> bool:
+    """
+    OSMnx's network filter for `mode`, without clauses on `skip_keys`
+    and, if asked, without its highway-type exclusions.
+    """
+    for key, op, regex in mode_rules(mode):
+        if key in skip_keys or (ignore_highway_type and key == "highway" and op == "!~"):
+            continue
+        value = _as_text(tags.get(key))
+
+        if op is None:
+            if value is None:
+                return False
+        elif op == "~":
+            if value is None or not re.search(regex, value):
+                return False
+        elif value is not None and re.search(regex, value):
+            return False
+
+    return True
+
+
+def open_to_other_vehicles(tags: dict) -> bool:
+    """
+    True if the tags open the way to a vehicle NetworkForge has no mode
+    for (buses, taxis, lorries ...): a busway, or e.g. bus=yes / psv=yes.
+    """
+    if _as_text(tags.get("highway")) in BUS_HIGHWAYS:
+        return True
+    return any(_as_text(tags.get(key)) in GRANTED_ACCESS for key in OTHER_VEHICLE_KEYS)
+
+
+def usable_modes(tags: dict) -> list[str]:
+    """All modes in MODES that a way with these tags supports."""
+    return [mode for mode in MODES if allows_mode(tags, mode)]
+
+
+def filter_graph_by_mode(graph: nx.MultiDiGraph, mode: str) -> nx.MultiDiGraph:
+    """
+    Return a copy of `graph` keeping only edges usable by `mode`.
+    The graph must have been loaded after keep_mode_tags().
+    """
+    if mode not in MODES:
+        raise InputError(f"Unknown mode {mode!r}. Choose one of: {', '.join(MODES)}")
+
+    keep = [edge for edge, data in graph.edges.items() if allows_mode(data, mode)]
+    return graph.edge_subgraph(keep).copy()
+
+
+def load_graph(osm_file: str, mode: str) -> nx.MultiDiGraph:
+    """
+    Load an exported OSM XML file as a routable graph for one mode.
+
+    Keeps access tags, then drops edges the mode can't use. Walking
+    ignores oneway (OSMnx only does that when bidirectional=True).
+    """
+    keep_mode_tags()
+
+    graph = ox.graph_from_xml(
+        osm_file,
+        simplify=False,
+        bidirectional=(mode == "walk"),
+    )
+
+    return filter_graph_by_mode(graph, mode)
+
+
+# Fixed speeds (km/h) for ways without a maxspeed tag. OSMnx's default
+# instead imputes the mean maxspeed of each highway type across the
+# whole graph, so adding custom edges (with their own maxspeed) changes
+# the speed of unrelated OSM edges and baseline vs custom travel times
+# stop being comparable. Every highway type is listed because OSMnx
+# falls back to that mean for any type missing from this dict.
+DEFAULT_SPEEDS_KPH = {
+    "motorway": 100, "motorway_link": 60,
+    "trunk": 80, "trunk_link": 50,
+    "primary": 60, "primary_link": 40,
+    "secondary": 50, "secondary_link": 40,
+    "tertiary": 40, "tertiary_link": 30,
+    "unclassified": 30, "residential": 30, "road": 30,
+    "living_street": 10, "service": 15, "busway": 30, "bus_guideway": 30,
+    "pedestrian": 5, "track": 15, "footway": 5, "cycleway": 15,
+    "bridleway": 5, "path": 5, "steps": 3, "corridor": 5,
+}
+
+
+# Ferry and shuttle-train speeds without a maxspeed or duration (Valhalla's).
+FERRY_SPEEDS_KPH = {"ferry": 10, "shuttle_train": 65}
+
+
+_SPEED = re.compile(r"^\s*(\d+(?:\.\d+)?)\s*(mph|knots)?\s*$")
+_TO_KPH = {None: 1.0, "mph": 1.609344, "knots": 1.852}
+
+
+def maxspeed_kph(value) -> float | None:
+    """
+    A maxspeed tag in km/h: "50" (km/h), "30 mph", "20 knots", or
+    ";"-separated values (averaged, as OSMnx does). None if there's no
+    number above 0 (e.g. "signals", "GB:nsl_single", "0"): a speed of 0
+    would make every trip on the way take forever.
+    """
+    text = _as_text(value)
+    if text is None:
+        return None
+    speeds = [float(m[1]) * _TO_KPH[m[2]] for m in map(_SPEED.match, text.split(";"))
+              if m and float(m[1]) > 0]
+    return sum(speeds) / len(speeds) if speeds else None
+
+
+def car_speed_kph(tags: dict) -> float:
+    """
+    Car speed for a way: its maxspeed, else DEFAULT_SPEEDS_KPH for its
+    highway type (30 km/h if unknown) - the same rule add_travel_times uses.
+    Ferries: FERRY_SPEEDS_KPH (a `duration` is applied per line, by
+    export.analysis_edges).
+    """
+    speed = maxspeed_kph(tags.get("maxspeed"))
+    if speed is None and is_ferry(tags):
+        speed = FERRY_SPEEDS_KPH[_as_text(tags.get("route"))]
+    if speed is None:
+        speed = DEFAULT_SPEEDS_KPH.get(_as_text(tags.get("highway")), 30.0)
+    return float(speed)
+
+
+def add_travel_times(graph: nx.MultiDiGraph) -> nx.MultiDiGraph:
+    """
+    Add speed_kph and travel_time (car speeds) to every edge. Edges
+    keep their own maxspeed; untagged ones get DEFAULT_SPEEDS_KPH, so
+    the same road gets the same speed in the baseline and custom graphs.
+    Ferries get FERRY_SPEEDS_KPH (a `duration` is not applied here).
+    """
+    # OSMnx needs a highway type to give a speed: lend ferries their route.
+    ferries = [(u, v, k) for u, v, k, data in graph.edges(keys=True, data=True)
+               if is_ferry(data)]
+    for edge in ferries:
+        graph.edges[edge]["highway"] = graph.edges[edge]["route"]
+    # OSMnx reads maxspeed=0 as 0 km/h (an endless trip): hide it, as
+    # maxspeed_kph does, so the way gets its type's speed.
+    zero = {(u, v, k): data.pop("maxspeed") for u, v, k, data in graph.edges(keys=True, data=True)
+            if "maxspeed" in data and maxspeed_kph(data["maxspeed"]) is None}
+    graph = ox.add_edge_speeds(graph, hwy_speeds={**DEFAULT_SPEEDS_KPH, **FERRY_SPEEDS_KPH},
+                               fallback=30)
+    for edge in ferries:
+        del graph.edges[edge]["highway"]
+    for edge, value in zero.items():
+        graph.edges[edge]["maxspeed"] = value
+    return ox.add_edge_travel_times(graph)