networkforge 1.4.1__py3-none-any.whl

networkforge/coverage.py

@@ -0,0 +1,176 @@
+"""
+Does a local OSM file cover the whole area? A region's extract stops at
+its boundary: a box reaching across it builds a network with part of
+the streets missing, and nothing else says so - the file overlaps the
+area (so it isn't refused) and keeps the ways crossing its edge whole
+(so none is "cut at the extract's edge").
+
+What a missing part looks like: a stretch of the area, reaching its
+edge, with no street at all. Real places like that exist (sea, a lake,
+moorland), so this only warns, and counts the sea side of a coastline
+as covered.
+"""
+
+import logging
+from collections import deque
+
+import numpy as np
+import shapely
+from pyproj import CRS, Transformer
+
+log = logging.getLogger(__name__)
+
+# The area is split into about CELLS_ACROSS x CELLS_ACROSS cells, none
+# smaller than MIN_CELL_M; a cell no street passes through is empty.
+CELLS_ACROSS = 40
+MIN_CELL_M = 25.0
+
+# Empty cells joined side to side, reaching the area's edge, covering at
+# least this share of it: warned about.
+MIN_GAP_SHARE = 0.05
+
+_WINDS = ["east", "north-east", "north", "north-west", "west", "south-west", "south",
+          "south-east"]
+
+
+def warn_about_gaps(elements: list[dict], coastlines: list, polygon, analysis_crs: CRS,
+                    name: str) -> list:
+    """
+    Log a warning for each part of `polygon` (the area, WGS84) where the
+    file `name` has no streets: `elements` are its Overpass-JSON nodes
+    and ways, `coastlines` its natural=coastline ways as [(lon, lat), ...].
+    Returns the parts warned about (WGS84 polygons), largest first.
+    """
+    to_crs = Transformer.from_crs("EPSG:4326", analysis_crs, always_xy=True)
+    area = shapely.ops.transform(to_crs.transform, polygon)
+    if area.area <= 0:
+        return []
+
+    cells, rows, cols = _cells(area)
+    empty = ~_crossed(cells, _ways(elements, to_crs))
+    if empty.any() and coastlines:
+        centres = shapely.centroid(cells[empty])
+        empty[np.flatnonzero(empty)[_at_sea(centres, coastlines, to_crs)]] = False
+
+    edge = shapely.intersects(cells, area.boundary)
+    in_area = shapely.area(shapely.intersection(cells, area))
+    to_wgs84 = Transformer.from_crs(analysis_crs, "EPSG:4326", always_xy=True)
+    gaps = []
+    for region in _regions(empty, rows, cols):
+        share = in_area[region].sum() / area.area
+        if share < MIN_GAP_SHARE or not edge[region].any():
+            continue
+        gap = shapely.intersection(shapely.union_all(cells[region]), area)
+        gaps.append((share, gap))
+
+    if not gaps:
+        return []
+    gaps.sort(key=lambda gap: -gap[0])
+    found = [shapely.ops.transform(to_wgs84.transform, gap) for _, gap in gaps]
+    parts = [
+        ("" if len(gaps) == 1 else f"{100 * share:.0f}%, ")
+        + f"{gap.area / 1e6:.1f} km2 to the {_direction(gap, area)}: "
+        f"lon {west:.3f}..{east:.3f}, lat {south:.3f}..{north:.3f}"
+        for (share, gap), (west, south, east, north)
+        in zip(gaps, (part.bounds for part in found), strict=True)
+    ]
+    log.warning(
+        "%s has no streets in about %.0f%% of the area (%s). The file probably stops "
+        "there - a region's extract ends at its boundary - so those streets are missing "
+        "from the network. Use a file that covers the whole area (see docs/osm-data.md). "
+        "If that part really has no streets (water, open country), ignore this.",
+        name, 100 * sum(share for share, _ in gaps), "; ".join(parts),
+        extra={"gaps": [tuple(round(v, 5) for v in part.bounds) for part in found]},
+    )
+    return found
+
+
+def _cells(area) -> tuple[np.ndarray, int, int]:
+    """Square cells over `area`'s bounds, row by row from the south-west."""
+    west, south, east, north = area.bounds
+    size = max(np.sqrt(area.area) / CELLS_ACROSS, MIN_CELL_M)
+    cols = max(int(np.ceil((east - west) / size)), 1)
+    rows = max(int(np.ceil((north - south) / size)), 1)
+    x0, y0 = np.meshgrid(west + size * np.arange(cols), south + size * np.arange(rows))
+    cells = shapely.box(x0.ravel(), y0.ravel(), x0.ravel() + size, y0.ravel() + size)
+    return cells, rows, cols
+
+
+def _ways(elements: list[dict], to_crs: Transformer) -> np.ndarray:
+    """Every way (street or ferry) in `elements` as a projected line."""
+    nodes = [e for e in elements if e["type"] == "node"]
+    if not nodes:
+        return np.array([], dtype=object)
+    x, y = to_crs.transform([e["lon"] for e in nodes], [e["lat"] for e in nodes])
+    position = {e["id"]: i for i, e in enumerate(nodes)}
+    refs = [[position[ref] for ref in e["nodes"] if ref in position]
+            for e in elements if e["type"] == "way"]
+    refs = [way for way in refs if len(way) >= 2]
+    if not refs:
+        return np.array([], dtype=object)
+    order = np.concatenate(refs)
+    way = np.repeat(np.arange(len(refs)), [len(r) for r in refs])
+    return shapely.linestrings(np.column_stack([np.asarray(x)[order], np.asarray(y)[order]]),
+                               indices=way)
+
+
+def _crossed(cells: np.ndarray, lines: np.ndarray) -> np.ndarray:
+    """For each cell: does any of `lines` pass through it?"""
+    crossed = np.zeros(len(cells), dtype=bool)
+    if len(lines):
+        hits = shapely.STRtree(lines).query(cells, predicate="intersects")
+        crossed[hits[0]] = True
+    return crossed
+
+
+def _at_sea(points: np.ndarray, coastlines: list, to_crs: Transformer) -> np.ndarray:
+    """
+    For each point: is it on the sea side of the nearest coastline? OSM
+    draws coastlines with the land on the left and the sea on the right.
+    """
+    starts, ends = [], []
+    for line in coastlines:
+        if len(line) < 2:
+            continue
+        x, y = to_crs.transform(*zip(*line, strict=True))
+        xy = np.column_stack([x, y])
+        starts.append(xy[:-1])
+        ends.append(xy[1:])
+    if not starts:
+        return np.zeros(len(points), dtype=bool)
+    a, b = np.concatenate(starts), np.concatenate(ends)
+    segments = shapely.linestrings(np.stack([a, b], axis=1))
+    nearest = shapely.STRtree(segments).query_nearest(points, all_matches=False)[1]
+    p = shapely.get_coordinates(points)
+    a, b = a[nearest], b[nearest]
+    right = (b[:, 0] - a[:, 0]) * (p[:, 1] - a[:, 1]) - (b[:, 1] - a[:, 1]) * (p[:, 0] - a[:, 0])
+    return right < 0
+
+
+def _regions(empty: np.ndarray, rows: int, cols: int) -> list[np.ndarray]:
+    """Groups of empty cells joined side to side (cell numbers)."""
+    grid = empty.reshape(rows, cols)
+    seen = np.zeros_like(grid)
+    regions = []
+    for start in zip(*np.nonzero(grid), strict=True):
+        if seen[start]:
+            continue
+        seen[start] = True
+        queue, region = deque([start]), []
+        while queue:
+            row, col = queue.popleft()
+            region.append(row * cols + col)
+            for r, c in ((row + 1, col), (row - 1, col), (row, col + 1), (row, col - 1)):
+                if 0 <= r < rows and 0 <= c < cols and grid[r, c] and not seen[r, c]:
+                    seen[r, c] = True
+                    queue.append((r, c))
+        regions.append(np.array(region))
+    return regions
+
+
+def _direction(gap, area) -> str:
+    """Compass direction of `gap` from the middle of `area`."""
+    dx, dy = np.subtract(gap.centroid.coords[0], area.centroid.coords[0])
+    if np.hypot(dx, dy) < 1e-9:
+        return "middle"
+    return _WINDS[int(np.round(np.degrees(np.arctan2(dy, dx)) / 45)) % 8]

networkforge/edits.py

@@ -0,0 +1,460 @@
+"""
+Changing existing streets.
+
+A custom feature with an OSM way id (an `osm_id` or `osmid` attribute,
+as on a QuickOSM layer or NetworkForge's own GeoPackage) is not a new
+line: it says "this stretch of that way should have these tags". Copy
+the street out of such a layer, change an attribute (oneway=yes,
+maxspeed=20 mph, access=no) and add it to the custom layer.
+
+What changes:
+    - Only tags whose value differs from the way's value in OSM. The
+      rest of the feature's attributes are ignored, so a row copied with
+      all its attributes changes nothing until one is edited.
+    - Only the stretches of the way the feature lies along, in whole
+      steps from one OSM node to the next (every junction is a node).
+      A feature covering part of a way changes that part.
+    - `oneway` follows the direction the feature is drawn, as for new
+      lines: reverse the line (or use -1) to reverse the street.
+    - Several features may cover the same stretch (rows copied twice,
+      overlapping selections) as long as they ask for the same change.
+    - A tag is set by giving it a value: close a street with access=no,
+      open a bus gate with motor_vehicle=yes. An empty attribute changes
+      nothing; to delete tags from the way, list them in `remove_tags`
+      (`remove_tags=maxspeed;access`). Deleting `oneway` makes the
+      stretch two-way (a roundabout stays one-way).
+    - `remove=yes` takes the stretch out of the network altogether (its
+      other attributes are then ignored): it is in neither the edge table
+      nor the OSM file. The way's remaining parts stay; a turn
+      restriction that needs the removed part goes with it.
+
+apply_edits() updates the edge table (so the GeoPackage columns and
+NetworkForge's own routing follow) and returns the tag changes; export
+writes each edited stretch as its own way with those tags and
+`nf:modified=yes` (the id of the way it was cut from stays with the
+unchanged part). The "before" network is never touched.
+"""
+
+import logging
+
+import geopandas as gpd
+import numpy as np
+import osmnx as ox
+import pandas as pd
+import shapely
+
+from .errors import InputError, InvalidTagsError
+from .export import reverse_copies
+from .osm import OSMSource
+from .tags import (
+    EDIT_COLUMN,
+    EDIT_ID_COLUMN,
+    EDIT_ID_COLUMNS,
+    MODIFIED_COLUMN,
+    REMOVE_COLUMN,
+    REMOVE_TAGS_COLUMN,
+)
+from .validation import (
+    KNOWN_HIGHWAYS,
+    KNOWN_TAG_KEYS,
+    _tag_value,
+    tag_value_problems,
+    unknown_values,
+    warn_about_unknown_values,
+)
+
+log = logging.getLogger(__name__)
+
+# How OSMnx (and OSM) read oneway values.
+ONEWAY_FORWARD = {"yes", "true", "1"}
+ONEWAY_BACKWARD = {"-1", "reverse", "t"}
+
+# Two features this close (m) to the same stretch are both on it.
+ON_FEATURE = 0.01
+
+# A feature lies along a stretch if, beside the stretch's middle, the two
+# run within this angle (degrees) of each other: one drawn ACROSS a block
+# passes its middle too.
+MAX_ANGLE = 45
+
+# The "change" a feature with remove=yes asks for.
+REMOVAL = {REMOVE_COLUMN: "yes"}
+
+
+def take_edit_ids(custom_gdf: gpd.GeoDataFrame) -> gpd.GeoDataFrame:
+    """
+    Put the OSM way id of each feature that edits an existing way in one
+    column, EDIT_ID_COLUMN (missing for new lines), whichever of
+    EDIT_ID_COLUMNS the data uses.
+    """
+    present = [column for column in EDIT_ID_COLUMNS if column in custom_gdf.columns]
+    if not present:
+        return custom_gdf
+
+    custom = custom_gdf.copy()
+    ids = pd.Series(np.nan, index=custom.index, dtype="float64")
+    issues = []
+    for column in present:
+        for feature, value in custom[column].items():
+            text = _tag_value(value)
+            if text is None or text == "":
+                continue
+            # QuickOSM writes "123"; a full_id-style "w123" is accepted too.
+            number = text[1:] if text[:1] in "wW" else text
+            if number.isdigit() and int(number) > 0:
+                ids.at[feature] = int(number)
+            else:
+                issues.append({"feature": feature,
+                               "message": f"{column}={text!r} is not an OSM way id"})
+    if issues:
+        raise InputError(
+            "Some features have an OSM id that isn't a way id (a whole number) - "
+            + "; ".join(f"feature {i['feature']}: {i['message']}" for i in issues) + ".",
+            guide="changing-existing-streets", issues=issues,
+        )
+
+    custom = custom.drop(columns=present)
+    custom[EDIT_ID_COLUMN] = ids
+    return custom
+
+
+# What a `remove` attribute may say; anything else is a mistake worth reporting.
+REMOVE_YES = {"yes", "true", "1"}
+REMOVE_NO = {"no", "false", "0", ""}
+
+
+def wants_removal(value) -> bool | None:
+    """True / False for a `remove` attribute value; None if it isn't a yes or no."""
+    text = (_tag_value(value) or "").strip().lower()
+    return True if text in REMOVE_YES else False if text in REMOVE_NO else None
+
+
+def split_edits(custom_gdf: gpd.GeoDataFrame) -> tuple[gpd.GeoDataFrame, gpd.GeoDataFrame]:
+    """(new lines, edits to existing ways) of cleaned custom data."""
+    is_edit = (custom_gdf[EDIT_ID_COLUMN].notna() if EDIT_ID_COLUMN in custom_gdf.columns
+               else pd.Series(False, index=custom_gdf.index))
+    new_lines = custom_gdf[~is_edit].drop(columns=[EDIT_ID_COLUMN], errors="ignore")
+    edits = custom_gdf[is_edit]
+    if EDIT_ID_COLUMN not in edits.columns:
+        edits = edits.assign(**{EDIT_ID_COLUMN: np.nan})
+
+    for column, is_set in ((REMOVE_COLUMN, lambda value: wants_removal(value) is not False),
+                           (REMOVE_TAGS_COLUMN, lambda value: bool(tags_to_remove(value)))):
+        if column not in custom_gdf.columns:
+            continue
+        # Only an existing street can lose tags or be removed: a new line
+        # marked so has most likely lost its OSM id on the way here.
+        marked = [feature for feature, value in new_lines[column].items() if is_set(value)]
+        if marked:
+            raise InputError(
+                f"{column}= is for existing streets: feature(s) "
+                f"{', '.join(map(str, marked))} have no OSM id ({' / '.join(EDIT_ID_COLUMNS)}) "
+                "saying which street to change.",
+                guide="changing-existing-streets",
+                issues=[{"feature": feature, "message": f"{column} set, but no OSM id"}
+                        for feature in marked],
+            )
+        new_lines = new_lines.drop(columns=[column])
+    return new_lines, edits
+
+
+def tags_to_remove(value) -> list[str]:
+    """The tag keys a `remove_tags` attribute lists (separated by ; or ,)."""
+    text = _tag_value(value) or ""
+    return list(dict.fromkeys(key.strip() for key in text.replace(",", ";").split(";")
+                              if key.strip()))
+
+
+def edit_tags(row: pd.Series) -> dict[str, str]:
+    """The feature's attributes that are tags NetworkForge knows, as text."""
+    tags = {}
+    for key, value in row.items():
+        text = _tag_value(value)
+        if key in KNOWN_TAG_KEYS and text is not None:
+            tags[key] = text
+    return tags
+
+
+def check_edit_tags(edits_gdf: gpd.GeoDataFrame, strict: bool = True) -> None:
+    """The values edits would set must be valid, like those of new lines."""
+    issues = []
+    unknown = {}
+    for feature, row in edits_gdf.drop(columns=edits_gdf.geometry.name).iterrows():
+        tags = edit_tags(row)
+        problems, _ = tag_value_problems(tags)
+        for pair in unknown_values(tags):
+            unknown.setdefault(pair, []).append(feature)
+        if REMOVE_COLUMN in row and wants_removal(row[REMOVE_COLUMN]) is None:
+            problems.append(f"{REMOVE_COLUMN}={_tag_value(row[REMOVE_COLUMN])!r} must be yes or no")
+        if "highway" in tags and tags["highway"] not in KNOWN_HIGHWAYS:
+            problems.append(f"highway={tags['highway']!r} is not a routable highway value")
+        removing = tags_to_remove(row.get(REMOVE_TAGS_COLUMN))
+        if "highway" in removing:
+            problems.append(f"{REMOVE_TAGS_COLUMN} can't delete highway: use "
+                            f"{REMOVE_COLUMN}=yes to take the street out")
+        for key in sorted(set(removing) & tags.keys()):
+            problems.append(f"{key} is both given a value ({tags[key]!r}) and listed in "
+                            f"{REMOVE_TAGS_COLUMN}")
+        issues += [(feature, problem) for problem in problems]
+
+    warn_about_unknown_values(unknown)
+    if issues:
+        error = InvalidTagsError(issues)
+        if strict:
+            raise error
+        log.warning("strict=False, continuing anyway: %s", error,
+                    extra={"features": [i["feature"] for i in error.issues]})
+
+
+def _oneway_state(value: str | None, tags: dict | None = None) -> str:
+    """
+    'forward', 'backward' or 'both', relative to the direction of the
+    way's nodes. With the way's `tags`: a roundabout is one-way without
+    saying so.
+    """
+    text = (value or "").lower()
+    if text in ONEWAY_FORWARD:
+        return "forward"
+    if text in ONEWAY_BACKWARD:
+        return "backward"
+    if value is None and tags and tags.get("junction") in ("roundabout", "circular"):
+        return "forward"
+    return "both"
+
+
+def apply_edits(
+    edges_gdf: gpd.GeoDataFrame,
+    nodes_gdf: gpd.GeoDataFrame,
+    edits_gdf: gpd.GeoDataFrame,
+    source: OSMSource,
+    tolerance: float,
+    bidirectional: bool = False,
+    strict: bool = True,
+) -> tuple[gpd.GeoDataFrame, dict[int, dict[str, str]], int]:
+    """
+    Apply the edit features (see the module docstring) to a copy of the
+    OSM edge table.
+
+    Returns (edges, changes, removed). Edited edges carry
+    MODIFIED_COLUMN="yes" and EDIT_COLUMN=n; changes[n] holds the tags
+    edit n sets on its stretch of the way, as OSM tags of that way
+    (oneway relative to the way's own direction). `removed` is the
+    number of streets (GeoPackage rows) taken out.
+
+    edits_gdf: features with EDIT_ID_COLUMN, in the edges' CRS.
+    bidirectional: the network type holds every way in both directions
+        (OSMnx's walk network), so one-way changes don't alter the edges.
+    """
+    # Each part of a multi-part feature on its own: `oneway` follows the
+    # direction each part is drawn in.
+    edits_gdf = edits_gdf.explode(index_parts=False)
+
+    edges = edges_gdf.copy()
+    edges[MODIFIED_COLUMN] = None
+    edges[EDIT_COLUMN] = np.nan
+    issues = []      # (feature, message): the feature can't be applied
+    unchanged = []   # features that differ from OSM in nothing
+    node_xy = nodes_gdf.geometry
+    edit_columns = [c for c in edits_gdf.columns if c != edits_gdf.geometry.name]
+    features = list(edits_gdf.index)
+
+    # 1. What each feature would change, and which edges it lies along.
+    wanted: dict[int, dict[str, str]] = {}
+    way_steps: dict[int, set[tuple[int, int]]] = {}
+    claims = []  # (edge label, distance of its middle from the feature, edit number)
+    for number, (feature, row) in enumerate(edits_gdf[edit_columns].iterrows()):
+        way_id = int(row[EDIT_ID_COLUMN])
+        line = edits_gdf.geometry.iloc[number]  # by position: parts share their feature id
+        of_way = (edges["osmid"] == way_id).to_numpy()
+        if way_id not in source.ways or not of_way.any():
+            issues.append((feature, f"OSM way {way_id} is not in this network (outside the "
+                                    "area, not a street, or changed in OSM since the "
+                                    "layer was made)"))
+            continue
+
+        # The stretches (node to node) of the way the feature lies along.
+        middles = shapely.line_interpolate_point(
+            edges.geometry.to_numpy()[of_way], 0.5, normalized=True)
+        distances = shapely.distance(middles, line)
+        near = (distances <= tolerance) & _parallel(edges.geometry.to_numpy()[of_way], line)
+        covered = edges.index[of_way][near]
+        if len(covered) == 0:
+            issues.append((feature, f"doesn't lie along OSM way {way_id}"))
+            continue
+
+        refs, current = source.ways[way_id]
+        # The way's own steps, node to node. (Not positions along it: a
+        # way that closes on itself has its first node twice, and the
+        # closing step was read backwards.)
+        steps = set(zip(refs, refs[1:], strict=False))
+        along_way = _drawn_along(line, edges.loc[covered], steps, node_xy)
+
+        change = {}
+        if REMOVE_COLUMN in row and wants_removal(row[REMOVE_COLUMN]):
+            change = dict(REMOVAL)
+        # A deleted tag is a change to None.
+        if not change:
+            change = {key: None for key in tags_to_remove(row.get(REMOVE_TAGS_COLUMN))
+                      if key in current}
+        for key, value in ({} if REMOVE_COLUMN in change
+                           else edit_tags(row.drop(EDIT_ID_COLUMN))).items():
+            if key == "oneway":
+                state = _oneway_state(value)
+                if not along_way:
+                    state = {"forward": "backward", "backward": "forward"}.get(state, state)
+                if state != _oneway_state(current.get("oneway"), current):
+                    change[key] = {"forward": "yes", "backward": "-1", "both": "no"}[state]
+            elif current.get(key) != value:
+                change[key] = value
+        if not change:
+            unchanged.append(feature)
+            continue
+
+        wanted[number], way_steps[number] = change, steps
+        claims += zip(covered, distances[near], [number] * len(covered),
+                      strict=True)
+
+    # 2. One feature per edge. A stretch shorter than the tolerance is also
+    # within reach of the feature on the next stretch: the feature it lies
+    # on (distance 0) wins. Two features really on the same stretch must
+    # agree on the change.
+    owner: dict = {}
+    for label, distance, number in sorted(claims, key=lambda claim: (claim[1], claim[2])):
+        if label not in owner:
+            owner[label] = (distance, number)
+            continue
+        best_distance, best = owner[label]
+        same_place = distance - best_distance <= ON_FEATURE
+        both_stand = number in wanted and best in wanted
+        if same_place and both_stand and wanted[number] != wanted[best]:
+            way_id = int(edges.at[label, "osmid"])
+            issues.append((features[number], f"overlaps feature {features[best]} on OSM "
+                                             f"way {way_id} with a different change"))
+            wanted.pop(number)
+
+    # 3. Apply.
+    changes: dict[int, dict[str, str]] = {}
+    drop, rebuilt, removed = [], [], 0
+    for number, change in wanted.items():
+        rows = pd.Index([label for label, (_, n) in owner.items() if n == number])
+        if rows.empty:
+            continue
+        if change == REMOVAL:
+            log.info("Feature %s removes %d edge(s) of OSM way %d", features[number],
+                     len(rows), int(edges.at[rows[0], "osmid"]))
+            drop.append(rows)
+            # Counted per street, as the GeoPackage has them.
+            removed += int((~reverse_copies(edges.loc[rows])).sum())
+            continue
+        changes[number] = change
+        log.info("Feature %s changes %d edge(s) of OSM way %d: %s", features[number], len(rows),
+                 int(edges.at[rows[0], "osmid"]),
+                 ", ".join(f"{k}={v}" if v is not None else f"{k} deleted"
+                           for k, v in change.items()))
+
+        for key, value in change.items():
+            if key not in edges.columns:
+                edges[key] = None
+            if key != "oneway":
+                edges[key] = edges[key].astype(object)
+                edges.loc[rows, key] = value
+        edges.loc[rows, MODIFIED_COLUMN] = "yes"
+        edges.loc[rows, EDIT_COLUMN] = number
+        if "oneway" in change and not bidirectional:
+            drop.append(rows)
+            way_tags = source.ways[int(edges.at[rows[0], "osmid"])][1]
+            rebuilt += _in_direction(edges.loc[rows], way_steps[number],
+                                     _oneway_state(change["oneway"], {**way_tags, **change}))
+    if drop:
+        edges = pd.concat([edges.drop(drop[0].append(drop[1:])), *rebuilt], ignore_index=True)
+
+    issues = list(dict.fromkeys(issues))  # the same problem with two parts of one feature
+    if issues:
+        error = InputError(
+            "Some features that change an existing street can't be applied - "
+            + "; ".join(f"feature {feature}: {message}" for feature, message in issues) + ".",
+            guide="changing-existing-streets",
+            issues=[{"feature": feature, "message": message} for feature, message in issues],
+        )
+        if strict:
+            raise error
+        log.warning("strict=False, skipping them: %s", error,
+                    extra={"features": [feature for feature, _ in issues]})
+    unchanged = list(dict.fromkeys(unchanged))  # a feature's parts are listed once
+    if unchanged:
+        log.warning("%d feature(s) with an OSM id change nothing: their tags are the same "
+                    "as the way's in OpenStreetMap (features %s).", len(unchanged),
+                    ", ".join(map(str, unchanged)), extra={"features": unchanged})
+
+    if not changes:
+        edges = edges.drop(columns=[MODIFIED_COLUMN, EDIT_COLUMN])
+    return edges, changes, removed
+
+
+def _direction(lines, at) -> np.ndarray:
+    """Unit vectors along `lines` at distances `at` along them (1 m each side)."""
+    lengths = shapely.length(lines)
+    ahead = shapely.line_interpolate_point(lines, np.minimum(at + 1, lengths))
+    behind = shapely.line_interpolate_point(lines, np.maximum(at - 1, 0))
+    vectors = shapely.get_coordinates(ahead) - shapely.get_coordinates(behind)
+    return vectors / np.maximum(np.linalg.norm(vectors, axis=1), 1e-12)[:, None]
+
+
+def _parallel(stretches: np.ndarray, line) -> np.ndarray:
+    """For each stretch: does `line`, where nearest its middle, run along it (MAX_ANGLE)?"""
+    middles = shapely.line_interpolate_point(stretches, 0.5, normalized=True)
+    along = _direction(stretches, shapely.length(stretches) / 2)
+    feature = np.full(len(stretches), line, dtype=object)
+    drawn = _direction(feature, shapely.line_locate_point(feature, middles))
+    return np.abs((along * drawn).sum(axis=1)) >= np.cos(np.radians(MAX_ANGLE))
+
+
+def _drawn_along(line, covered: gpd.GeoDataFrame, steps: set, node_xy) -> bool:
+    """
+    Is the feature `line` drawn in the direction of the way's nodes?
+    Each covered step of the way votes: does a point early on it come
+    before a point late on it, along the line.
+    """
+    votes = 0
+    for u, v in {(int(u), int(v)) for u, v in zip(covered["u"], covered["v"], strict=True)}:
+        if (u, v) not in steps:
+            if (v, u) not in steps:
+                continue
+            u, v = v, u
+        step = shapely.LineString([node_xy.loc[u], node_xy.loc[v]])
+        early, late = (line.project(step.interpolate(part, normalized=True))
+                       for part in (0.25, 0.75))
+        votes += (late > early) - (late < early)
+    return votes >= 0
+
+
+def _in_direction(stretch: gpd.GeoDataFrame, steps: set[tuple[int, int]], state: str) -> list:
+    """
+    The edges of some stretches of one way, rebuilt for a new one-way
+    state the way OSMnx holds them: a one-way stretch is one edge in the
+    direction of travel; a two-way stretch is two, the second marked
+    reversed. `steps`: the way's (node, next node) pairs.
+    """
+    if "reversed" in stretch:
+        stretch = stretch[stretch["reversed"] != True]  # noqa: E712 - one row per stretch
+
+    # Each row oriented along the way (from the earlier node to the later).
+    against = np.array([(int(u), int(v)) not in steps and (int(v), int(u)) in steps
+                        for u, v in zip(stretch["u"], stretch["v"], strict=True)], dtype=bool)
+    forward = stretch.copy()
+    forward.loc[against, ["u", "v"]] = stretch.loc[against, ["v", "u"]].to_numpy()
+    geometries = forward.geometry.to_numpy().copy()
+    geometries[against] = shapely.reverse(geometries[against])
+    forward = forward.set_geometry(geometries, crs=stretch.crs)
+
+    backward = forward.copy()
+    backward[["u", "v"]] = forward[["v", "u"]].to_numpy()
+    backward = backward.set_geometry(shapely.reverse(geometries), crs=stretch.crs)
+
+    forward["reversed"], backward["reversed"] = False, state == "both"
+    forward["oneway"] = backward["oneway"] = state != "both"
+    return {"forward": [forward], "backward": [backward], "both": [forward, backward]}[state]
+
+
+def is_bidirectional(network_type: str) -> bool:
+    return network_type in ox.settings.bidirectional_network_types