ObjectNat 1.4.0__tar.gz → 2.0.0__tar.gz

objectnat-2.0.0/.gitignore

@@ -0,0 +1,59 @@
+# Project caches
+.iduedu_cache/
+cache/
+__pycache__/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+
+# Python bytecode
+*.py[cod]
+*$py.class
+
+# Build / dist artifacts
+/dist/
+/build/
+/*.egg-info/
+
+# Virtual envs
+/.venv/
+/.env
+
+# IDE / tools
+/.idea/
+/.vscode/
+*.swp
+*.swo
+
+# Coverage / test artifacts
+.coverage
+.coverage.*
+htmlcov/
+coverage.xml
+
+# Sphinx docs
+docs/_build/
+docs/_autoapi/
+docs/api/generated/
+docs/_autosummary/
+docs/_doctrees/
+docs/api/generated
+_build/
+_autosummary/
+
+# Local dev stuff
+/dev
+.claude
+.codex
+
+# OS junk
+.DS_Store
+Thumbs.db
+
+# test artifacts (rendered plots + downloaded/cached OSM graph)
+/tests/test_output/
+/tests/test_cache/
+
+# graphify knowledge graph (generated locally, not committed)
+/graphify-out/
+

{objectnat-1.4.0 → objectnat-2.0.0}/PKG-INFO

@@ -1,23 +1,18 @@
 Metadata-Version: 2.4
 Name: ObjectNat
-Version: 1.4.0
+Version: 2.0.0
 Summary: ObjectNat is an open-source library created for geospatial analysis created by IDU team
-License: BSD-3-Clause
+Author-email: DDonnyy <63115678+DDonnyy@users.noreply.github.com>
+License-Expression: BSD-3-Clause
 License-File: LICENSE.txt
-Author: DDonnyy
-Author-email: 63115678+DDonnyy@users.noreply.github.com
-Requires-Python: >=3.11,<3.13
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: geopandas (>=1.0.1,<2.0.0)
-Requires-Dist: loguru (>=0.7.3,<0.8.0)
-Requires-Dist: networkx (>=3.4.2,<4.0.0)
-Requires-Dist: numpy (>=2.1.3,<3.0.0)
-Requires-Dist: pandas (>=2.2.0,<3.0.0)
-Requires-Dist: scikit-learn (>=1.4.0,<2.0.0)
-Requires-Dist: tqdm (>=4.66.2,<5.0.0)
+Requires-Python: <3.13,>=3.11
+Requires-Dist: geopandas<2.0.0,>=1.1.0
+Requires-Dist: iduedu<3.0.0,>=2.0.0
+Requires-Dist: loguru<0.8.0,>=0.7.3
+Requires-Dist: numpy<3.0.0,>=2.4.0
+Requires-Dist: pandas<4.0.0,>=3.0.0
+Requires-Dist: scipy<2.0.0,>=1.17.0
+Requires-Dist: tqdm<5.0.0,>=4.66.2
 Description-Content-Type: text/x-rst
 
 ObjectNat
@@ -34,12 +29,12 @@ Object-oriented Network Analysis Tools
    :target: https://pypi.org/project/objectnat/
    :alt: PyPI version
 
-.. |badge-ci| image:: https://github.com/IDUclub/ObjectNat/actions/workflows/ci_pipeline.yml/badge.svg
-   :target: https://github.com/IDUclub/ObjectNat/actions/workflows/ci_pipeline.yml
-   :alt: CI
+.. |badge-ci| image:: https://github.com/IDUclub/ObjectNat/actions/workflows/quality.yml/badge.svg
+   :target: https://github.com/IDUclub/ObjectNat/actions/workflows/quality.yml
+   :alt: Tests and coverage
 
-.. |badge-codecov| image:: https://codecov.io/gh/DDonnyy/ObjectNat/graph/badge.svg?token=K6JFSJ02GU
-   :target: https://codecov.io/gh/DDonnyy/ObjectNat
+.. |badge-codecov| image:: https://codecov.io/gh/IDUclub/ObjectNat/graph/badge.svg?token=K6JFSJ02GU
+   :target: https://codecov.io/gh/IDUclub/ObjectNat
    :alt: Coverage
 
 .. |badge-license| image:: https://img.shields.io/badge/license-BSD--3--Clause-blue.svg
@@ -75,7 +70,7 @@ Each feature includes a **Jupyter Notebook example** and **full documentation**.
 
    Isochrones represent areas reachable from an origin point within a specified time along a transport network.
    This feature allows the analysis of transport accessibility using pedestrian, road,
-   public transport, or multimodal graphs.
+   public transport, or multimodal ``UrbanGraph`` objects prepared by IduEdu.
 
    The library supports several methods for building isochrones:
 
@@ -102,6 +97,8 @@ Each feature includes a **Jupyter Notebook example** and **full documentation**.
    and a defined **accessibility threshold** (in minutes or meters).
    The function models the **balance between supply and demand**,
    assessing how well services meet the needs of nearby buildings within an acceptable time.
+   ObjectNat 2.0 returns a structured ``ProvisionResult`` with a sparse flow matrix
+   and materialization helpers for buildings, services, and link geometries.
 
    📘 `Example <https://iduclub.github.io/ObjectNat/methods/examples/provision.html>`__
    🔗 `Documentation <https://iduclub.github.io/ObjectNat/methods/provision.html>`__
@@ -110,9 +107,8 @@ Each feature includes a **Jupyter Notebook example** and **full documentation**.
 
    A function for evaluating visibility from a given point or set of points to nearby buildings within a given radius.
    It is used to assess visual accessibility in urban environments.
-   A module is also implemented for computing **visibility coverage zones**
-   using a dense observer grid (recommended ~1000 points with a 10–20 m spacing).
-   Points can be generated along the transport network and distributed across its edges.
+   The unified ``get_visibility`` API supports accurate and simplified methods,
+   including parallel execution for batches of observer points.
 
    📘 `Example <https://iduclub.github.io/ObjectNat/methods/examples/visibility.html>`__
    🔗 `Documentation <https://iduclub.github.io/ObjectNat/methods/visibility.html>`__
@@ -126,19 +122,6 @@ Each feature includes a **Jupyter Notebook example** and **full documentation**.
    🔗 `Documentation <https://iduclub.github.io/ObjectNat/methods/noise.html>`__
    🧠 `Detailed theory <https://github.com/DDonnyy/ObjectNat/wiki/Noise-simulation>`__
 
-6. **Point Clusterization**  
-
-   A function for constructing **cluster polygons** based on a set of points using:
-
-   - Minimum **distance** between points.
-   - Minimum **number of points** in a cluster.
-
-   The function can also compute the **ratio of service types** in each cluster
-   for spatial analysis of service composition.
-
-   📘 `Example <https://iduclub.github.io/ObjectNat/methods/examples/clustering.html>`__
-   🔗 `Documentation <https://iduclub.github.io/ObjectNat/methods/clustering.html>`__
-
 ----
 
 City Graphs via *IduEdu*
@@ -146,6 +129,8 @@ City Graphs via *IduEdu*
 
 For optimal performance, **ObjectNat** is recommended to be used with graphs
 created by the `IduEdu <https://github.com/IDUclub/IduEdu>`_ library.
+Graph-based ObjectNat methods consume ``iduedu.UrbanGraph`` directly; ObjectNat
+does not build NetworkX graphs internally.
 
 **IduEdu** is an open-source Python library designed for building and processing
 complex urban networks based on OpenStreetMap data.
@@ -160,7 +145,7 @@ Example usage::
     from iduedu import get_4326_boundary, get_intermodal_graph
 
     poly = get_4326_boundary(osm_id=1114252)
-    G_intermodal = get_intermodal_graph(territory=poly, clip_by_territory=True)
+    urban_graph = get_intermodal_graph(territory=poly, clip_by_territory=True)
 
 ----
 
@@ -183,6 +168,14 @@ You can adjust logging and progress bar output using the config module::
     config.change_logger_lvl("INFO")   # mute debug logs
     config.set_enable_tqdm(False)      # disable tqdm progress bars
 
+Migration to ObjectNat 2.0
+--------------------------
+
+ObjectNat 2.0 replaces NetworkX-based graph inputs with ``iduedu.UrbanGraph``,
+renames accessibility functions, and returns ``ProvisionResult`` from service
+provision. See the migration guide in the documentation:
+`Migration 1.x to 2.0 <https://iduclub.github.io/ObjectNat/migration_1_to_2.html>`__.
+
 ----
 
 Contacts
@@ -199,4 +192,3 @@ Publications
 ------------
 
 Coming soon.
-

{objectnat-1.4.0 → objectnat-2.0.0}/README.rst

@@ -12,12 +12,12 @@ Object-oriented Network Analysis Tools
    :target: https://pypi.org/project/objectnat/
    :alt: PyPI version
 
-.. |badge-ci| image:: https://github.com/IDUclub/ObjectNat/actions/workflows/ci_pipeline.yml/badge.svg
-   :target: https://github.com/IDUclub/ObjectNat/actions/workflows/ci_pipeline.yml
-   :alt: CI
+.. |badge-ci| image:: https://github.com/IDUclub/ObjectNat/actions/workflows/quality.yml/badge.svg
+   :target: https://github.com/IDUclub/ObjectNat/actions/workflows/quality.yml
+   :alt: Tests and coverage
 
-.. |badge-codecov| image:: https://codecov.io/gh/DDonnyy/ObjectNat/graph/badge.svg?token=K6JFSJ02GU
-   :target: https://codecov.io/gh/DDonnyy/ObjectNat
+.. |badge-codecov| image:: https://codecov.io/gh/IDUclub/ObjectNat/graph/badge.svg?token=K6JFSJ02GU
+   :target: https://codecov.io/gh/IDUclub/ObjectNat
    :alt: Coverage
 
 .. |badge-license| image:: https://img.shields.io/badge/license-BSD--3--Clause-blue.svg
@@ -53,7 +53,7 @@ Each feature includes a **Jupyter Notebook example** and **full documentation**.
 
    Isochrones represent areas reachable from an origin point within a specified time along a transport network.
    This feature allows the analysis of transport accessibility using pedestrian, road,
-   public transport, or multimodal graphs.
+   public transport, or multimodal ``UrbanGraph`` objects prepared by IduEdu.
 
    The library supports several methods for building isochrones:
 
@@ -80,6 +80,8 @@ Each feature includes a **Jupyter Notebook example** and **full documentation**.
    and a defined **accessibility threshold** (in minutes or meters).
    The function models the **balance between supply and demand**,
    assessing how well services meet the needs of nearby buildings within an acceptable time.
+   ObjectNat 2.0 returns a structured ``ProvisionResult`` with a sparse flow matrix
+   and materialization helpers for buildings, services, and link geometries.
 
    📘 `Example <https://iduclub.github.io/ObjectNat/methods/examples/provision.html>`__
    🔗 `Documentation <https://iduclub.github.io/ObjectNat/methods/provision.html>`__
@@ -88,9 +90,8 @@ Each feature includes a **Jupyter Notebook example** and **full documentation**.
 
    A function for evaluating visibility from a given point or set of points to nearby buildings within a given radius.
    It is used to assess visual accessibility in urban environments.
-   A module is also implemented for computing **visibility coverage zones**
-   using a dense observer grid (recommended ~1000 points with a 10–20 m spacing).
-   Points can be generated along the transport network and distributed across its edges.
+   The unified ``get_visibility`` API supports accurate and simplified methods,
+   including parallel execution for batches of observer points.
 
    📘 `Example <https://iduclub.github.io/ObjectNat/methods/examples/visibility.html>`__
    🔗 `Documentation <https://iduclub.github.io/ObjectNat/methods/visibility.html>`__
@@ -104,19 +105,6 @@ Each feature includes a **Jupyter Notebook example** and **full documentation**.
    🔗 `Documentation <https://iduclub.github.io/ObjectNat/methods/noise.html>`__
    🧠 `Detailed theory <https://github.com/DDonnyy/ObjectNat/wiki/Noise-simulation>`__
 
-6. **Point Clusterization**  
-
-   A function for constructing **cluster polygons** based on a set of points using:
-
-   - Minimum **distance** between points.
-   - Minimum **number of points** in a cluster.
-
-   The function can also compute the **ratio of service types** in each cluster
-   for spatial analysis of service composition.
-
-   📘 `Example <https://iduclub.github.io/ObjectNat/methods/examples/clustering.html>`__
-   🔗 `Documentation <https://iduclub.github.io/ObjectNat/methods/clustering.html>`__
-
 ----
 
 City Graphs via *IduEdu*
@@ -124,6 +112,8 @@ City Graphs via *IduEdu*
 
 For optimal performance, **ObjectNat** is recommended to be used with graphs
 created by the `IduEdu <https://github.com/IDUclub/IduEdu>`_ library.
+Graph-based ObjectNat methods consume ``iduedu.UrbanGraph`` directly; ObjectNat
+does not build NetworkX graphs internally.
 
 **IduEdu** is an open-source Python library designed for building and processing
 complex urban networks based on OpenStreetMap data.
@@ -138,7 +128,7 @@ Example usage::
     from iduedu import get_4326_boundary, get_intermodal_graph
 
     poly = get_4326_boundary(osm_id=1114252)
-    G_intermodal = get_intermodal_graph(territory=poly, clip_by_territory=True)
+    urban_graph = get_intermodal_graph(territory=poly, clip_by_territory=True)
 
 ----
 
@@ -161,6 +151,14 @@ You can adjust logging and progress bar output using the config module::
     config.change_logger_lvl("INFO")   # mute debug logs
     config.set_enable_tqdm(False)      # disable tqdm progress bars
 
+Migration to ObjectNat 2.0
+--------------------------
+
+ObjectNat 2.0 replaces NetworkX-based graph inputs with ``iduedu.UrbanGraph``,
+renames accessibility functions, and returns ``ProvisionResult`` from service
+provision. See the migration guide in the documentation:
+`Migration 1.x to 2.0 <https://iduclub.github.io/ObjectNat/migration_1_to_2.html>`__.
+
 ----
 
 Contacts

objectnat-2.0.0/objectnat/_api.py

@@ -0,0 +1,20 @@
+# pylint: disable=unused-import,wildcard-import,unused-wildcard-import
+
+from .methods.accessibility import (
+    get_graph_coverage,
+    get_graph_isochrones,
+    get_radius_coverage,
+    get_stepped_graph_coverage,
+    get_stepped_graph_isochrones,
+)
+from .methods.noise import calculate_simplified_noise_frame, simulate_noise
+from .methods.provision import (
+    ProvisionResult,
+    clip_provision,
+    get_provision_buildings,
+    get_provision_links,
+    get_provision_services,
+    get_service_provision,
+    recalculate_links,
+)
+from .methods.visibility import get_visibility

{objectnat-1.4.0/src → objectnat-2.0.0}/objectnat/_config.py

@@ -31,7 +31,7 @@ class Config:
         self.enable_tqdm_bar = enable_tqdm_bar
         self.logger = logger
 
-    def change_logger_lvl(self, lvl: Literal["TRACE", "DEBUG", "INFO", "WARN", "ERROR"]):
+    def change_logger_lvl(self, lvl: Literal["TRACE", "DEBUG", "INFO", "WARNING", "ERROR"]):
         self.logger.remove()
         self.logger.add(sys.stderr, level=lvl)
 
@@ -40,4 +40,4 @@ class Config:
 
 
 config = Config()
-config.change_logger_lvl("INFO")
+config.change_logger_lvl("WARNING")

objectnat-2.0.0/objectnat/_version.py

@@ -0,0 +1 @@
+VERSION = "2.0.0"

objectnat-2.0.0/objectnat/methods/accessibility/__init__.py

@@ -0,0 +1,3 @@
+from .coverage import get_graph_coverage, get_stepped_graph_coverage
+from .isochrones import get_graph_isochrones, get_stepped_graph_isochrones
+from .radius import get_radius_coverage

objectnat-2.0.0/objectnat/methods/accessibility/_utils.py

@@ -0,0 +1,285 @@
+from typing import Any, Literal
+
+import geopandas as gpd
+import numpy as np
+import pandas as pd
+from iduedu import UrbanGraph
+from shapely import convex_hull
+from shapely.geometry import GeometryCollection, MultiPolygon, Polygon
+from shapely.ops import polygonize, unary_union
+
+from objectnat.methods.utils.geom_utils import polygons_to_multilinestring
+
+SteppedGeometryType = Literal["radius", "ways", "separate"] | None
+
+# Graph types whose "ways" geometry must be built from pedestrian edges only.
+# On these graphs non-walk edges (transit legs) are straight lines between
+# distant stops; buffering them would create spurious corridors.
+_WALK_ONLY_WAYS_GRAPH_TYPES = {"intermodal", "walk"}
+
+
+def road_edges_for_ways(urban_graph: UrbanGraph) -> gpd.GeoDataFrame:
+    """Return the edge subset used to build ``geometry_type="ways"`` geometry.
+
+    For intermodal/walk graphs only pedestrian (``type == "walk"``) edges are
+    kept, so transit legs do not distort the resulting shape. Other graph types
+    (or graphs without a ``type`` column) use every edge.
+    """
+    edges = urban_graph.edges_gdf
+    if urban_graph.type in _WALK_ONLY_WAYS_GRAPH_TYPES and "type" in edges.columns:
+        walk_edges = edges[edges["type"] == "walk"]
+        if not walk_edges.empty:
+            return walk_edges
+    return edges
+
+
+def build_voronoi_cells(
+    urban_graph: UrbanGraph,
+    reachable_graph_nodes_gdf: gpd.GeoDataFrame,
+    *,
+    value_column: str,
+    local_crs: Any,
+    clip_geom=None,
+) -> gpd.GeoDataFrame:
+    reachable_node_index = pd.Index(reachable_graph_nodes_gdf.index)
+    if clip_geom is None:
+        edges = urban_graph.edges_gdf[["u", "v"]]
+        edges_near_reachable = edges[edges["u"].isin(reachable_node_index) | edges["v"].isin(reachable_node_index)]
+        neighbor_nodes = pd.Index(edges_near_reachable["u"]).append(pd.Index(edges_near_reachable["v"])).unique()
+        boundary_nodes = neighbor_nodes.difference(reachable_node_index)
+        voronoi_node_index = reachable_node_index.append(boundary_nodes).unique()
+    else:
+        clip_mask = urban_graph.nodes_gdf.geometry.intersects(clip_geom)
+        voronoi_node_index = urban_graph.nodes_gdf.index[clip_mask].append(reachable_node_index).unique()
+    voronoi_nodes = urban_graph.nodes_gdf.loc[voronoi_node_index, ["geometry"]]
+    voronois = gpd.GeoDataFrame(geometry=list(voronoi_nodes.geometry.voronoi_polygons()), crs=local_crs)
+    reachable_cell_index = reachable_graph_nodes_gdf.reset_index(names="node").sjoin(voronois, how="inner")
+    return gpd.GeoDataFrame(
+        reachable_cell_index[["node", value_column]].reset_index(drop=True),
+        geometry=voronois.geometry.iloc[reachable_cell_index["index_right"].to_numpy()].reset_index(drop=True),
+        crs=local_crs,
+    )
+
+
+def edge_speed_m_per_min(urban_graph: UrbanGraph) -> float:
+    edge_speeds = urban_graph.edges_gdf["length_meter"] / urban_graph.edges_gdf["time_min"]
+    edge_speeds = edge_speeds.replace([np.inf, -np.inf], np.nan).dropna()
+    edge_speeds = edge_speeds[edge_speeds > 0]
+    if edge_speeds.empty:
+        raise ValueError("Cannot calculate speed_m_per_min from edge length_meter/time_min")
+    return float(edge_speeds.median())
+
+
+def build_radius_clip_geometry(
+    reachable_graph_nodes_gdf: gpd.GeoDataFrame,
+    *,
+    weight_value: float,
+    weight_type: str,
+    speed_m_per_min: float | None,
+):
+    buffer_size = (float(weight_value) - reachable_graph_nodes_gdf["dist"].astype(float)).clip(lower=0.0)
+
+    if weight_type == "time_min":
+        if speed_m_per_min is None:
+            raise ValueError("speed_m_per_min is required for weight_type='time_min'")
+        buffer_size = buffer_size * float(speed_m_per_min)
+    return reachable_graph_nodes_gdf.geometry.buffer(buffer_size, resolution=4).union_all()
+
+
+def remove_inner_geom(geom):
+    if geom.is_empty:
+        return geom
+    if geom.geom_type == "Polygon":
+        return Polygon(geom.exterior)
+    if geom.geom_type == "MultiPolygon":
+        return MultiPolygon([Polygon(polygon.exterior) for polygon in geom.geoms])
+    if geom.geom_type == "GeometryCollection":
+        polygon_geoms = [
+            remove_inner_geom(part) for part in geom.geoms if part.geom_type in {"Polygon", "MultiPolygon"}
+        ]
+        if not polygon_geoms:
+            return GeometryCollection()
+        return unary_union(polygon_geoms)
+    return geom
+
+
+def build_ways_clip_geometry(
+    urban_graph: UrbanGraph,
+    reachable_graph_nodes_gdf: gpd.GeoDataFrame,
+    *,
+    weight_value: float,
+    weight_type: str,
+    speed_m_per_min: float | None,
+    road_buffer_size: float,
+):
+    radius_geom = build_radius_clip_geometry(
+        reachable_graph_nodes_gdf,
+        weight_value=weight_value,
+        weight_type=weight_type,
+        speed_m_per_min=speed_m_per_min,
+    )
+    reachable_node_index = pd.Index(reachable_graph_nodes_gdf.index)
+    edges = road_edges_for_ways(urban_graph)
+    edge_mask = edges["u"].isin(reachable_node_index) | edges["v"].isin(reachable_node_index)
+    if not edge_mask.any():
+        return GeometryCollection()
+
+    roads = gpd.GeoDataFrame(
+        geometry=[edges.loc[edge_mask].geometry.buffer(float(road_buffer_size), resolution=1).union_all()],
+        crs=urban_graph.edges_gdf.crs,
+    )
+    clipped_roads = roads.clip(radius_geom, keep_geom_type=True).explode(ignore_index=True)
+    if clipped_roads.empty:
+        return GeometryCollection()
+
+    geom_to_keep = clipped_roads.sjoin(reachable_graph_nodes_gdf[["geometry"]], how="inner").index.unique()
+    if len(geom_to_keep) == 0:
+        return GeometryCollection()
+    return remove_inner_geom(clipped_roads.loc[geom_to_keep].union_all())
+
+
+def build_separated_dist_polygons(
+    points: gpd.GeoDataFrame,
+    *,
+    weight_value: float,
+    weight_type: str,
+    step: float,
+    speed_m_per_min: float | None = None,
+    buffer_ratio: float = 0.7,
+) -> gpd.GeoDataFrame:
+    """
+    Build independent per-step buffer polygons over reachable graph nodes.
+
+    ``points`` must contain point geometry and a ``dist`` column in units of
+    ``weight_type``. For ``time_min`` the buffer size is converted to meters via
+    ``speed_m_per_min``.
+    """
+
+    def empty_result() -> gpd.GeoDataFrame:
+        return gpd.GeoDataFrame({"dist": []}, geometry=[], crs=points.crs)
+
+    if points.empty:
+        return empty_result()
+    if "dist" not in points.columns:
+        raise KeyError("points must contain 'dist' column")
+    if weight_value < 0:
+        raise ValueError(f"weight_value must be >= 0, got {weight_value}")
+    if step <= 0:
+        raise ValueError(f"step must be > 0, got {step}")
+    if weight_type == "time_min" and (speed_m_per_min is None or speed_m_per_min <= 0):
+        raise ValueError("speed_m_per_min must be positive for weight_type='time_min'")
+
+    points = points.loc[points["dist"].notna(), ["dist", points.geometry.name]].copy()
+    if points.empty:
+        return empty_result()
+
+    dist_for_buffer = points["dist"].astype(float).clip(lower=0.1)
+    upper_step = np.minimum((np.floor(dist_for_buffer / float(step)) + 1.0) * float(step), float(weight_value))
+    buffer_size = np.maximum(upper_step - dist_for_buffer, 0.0) * float(buffer_ratio)
+    if weight_type == "time_min":
+        buffer_size = buffer_size * float(speed_m_per_min)
+
+    points["dist"] = np.minimum(
+        np.ceil(points["dist"].astype(float).to_numpy() / float(step)) * float(step),
+        float(weight_value),
+    )
+    points.geometry = points.geometry.buffer(buffer_size)
+    points = points[~points.geometry.is_empty]
+    if points.empty:
+        return empty_result()
+
+    dissolved = points.dissolve(by="dist", as_index=False)
+    lines = dissolved.geometry.apply(polygons_to_multilinestring).union_all()
+    polygons = gpd.GeoDataFrame(geometry=list(polygonize(lines)), crs=points.crs)
+    if polygons.empty:
+        return empty_result()
+
+    polygon_points = polygons.copy()
+    polygon_points.geometry = polygons.representative_point()
+    stepped = polygon_points.sjoin(dissolved[["dist", "geometry"]], predicate="within")
+    if stepped.empty:
+        return empty_result()
+
+    stepped_dist = stepped.groupby(level=0)["dist"].mean()
+    stepped_dist = np.minimum(np.floor(stepped_dist / float(step)) * float(step), float(weight_value))
+    stepped_polygons = gpd.GeoDataFrame(
+        {"dist": stepped_dist.to_numpy()},
+        geometry=polygons.geometry.loc[stepped_dist.index].to_numpy(),
+        crs=points.crs,
+    )
+    return stepped_polygons.dissolve(by="dist", as_index=False).explode(ignore_index=True)
+
+
+def build_stepped_accessibility_geometry(
+    urban_graph: UrbanGraph,
+    reachable_graph_nodes_gdf: gpd.GeoDataFrame,
+    *,
+    geometry_type: SteppedGeometryType,
+    weight_value: float,
+    weight_type: str,
+    step: float,
+    local_crs: Any,
+    zone: gpd.GeoDataFrame | gpd.GeoSeries | None,
+    buffer_factor: float,
+    road_buffer_size: float,
+) -> gpd.GeoDataFrame:
+    if reachable_graph_nodes_gdf.empty:
+        return gpd.GeoDataFrame()
+
+    speed_m_per_min = edge_speed_m_per_min(urban_graph) if weight_type == "time_min" else None
+
+    if geometry_type == "separate":
+        result = build_separated_dist_polygons(
+            reachable_graph_nodes_gdf,
+            weight_value=float(weight_value),
+            weight_type=weight_type,
+            step=float(step),
+            speed_m_per_min=speed_m_per_min,
+            buffer_ratio=buffer_factor,
+        )
+        if zone is not None and not result.empty:
+            result = result.clip(zone.to_crs(local_crs))
+        return result
+
+    if geometry_type is None:
+        if zone is None:
+            clip_geom = convex_hull(reachable_graph_nodes_gdf.union_all())
+        else:
+            clip_geom = zone.to_crs(local_crs).union_all()
+    elif geometry_type == "radius":
+        clip_geom = build_radius_clip_geometry(
+            reachable_graph_nodes_gdf,
+            weight_value=float(weight_value),
+            weight_type=weight_type,
+            speed_m_per_min=speed_m_per_min,
+        )
+    elif geometry_type == "ways":
+        clip_geom = build_ways_clip_geometry(
+            urban_graph,
+            reachable_graph_nodes_gdf,
+            weight_value=float(weight_value),
+            weight_type=weight_type,
+            speed_m_per_min=speed_m_per_min,
+            road_buffer_size=road_buffer_size,
+        )
+    else:
+        raise ValueError(f"Unsupported geometry_type={geometry_type!r}")
+
+    if geometry_type is not None and zone is not None:
+        clip_geom = clip_geom.intersection(zone.to_crs(local_crs).union_all())
+
+    nodes_for_voronoi = reachable_graph_nodes_gdf.copy()
+    nodes_for_voronoi["dist"] = np.minimum(
+        np.ceil(nodes_for_voronoi["dist"].astype(float).to_numpy() / float(step)) * float(step),
+        float(weight_value),
+    )
+
+    cells = build_voronoi_cells(
+        urban_graph,
+        nodes_for_voronoi,
+        value_column="dist",
+        local_crs=local_crs,
+        clip_geom=clip_geom if geometry_type is not None else None,
+    )
+    result = cells.dissolve(by="dist", as_index=False).drop(columns=["node"])
+    return result.clip(clip_geom)