ObjectNat 0.2.7__tar.gz → 1.0.1__tar.gz

objectnat-1.0.1/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.1
+Name: ObjectNat
+Version: 1.0.1
+Summary: ObjectNat is an open-source library created for geospatial analysis created by IDU team
+License: BSD-3-Clause
+Author: DDonnyy
+Author-email: 63115678+DDonnyy@users.noreply.github.com
+Requires-Python: >=3.10,<3.13
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: geopandas (>=1.0.1,<2.0.0)
+Requires-Dist: networkx (>=3.4.2,<4.0.0)
+Requires-Dist: numpy (>=2.1.3,<3.0.0)
+Requires-Dist: pandarallel (>=1.6.5,<2.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)
+Description-Content-Type: text/markdown
+
+# ObjectNat
+
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![PyPI version](https://img.shields.io/pypi/v/objectnat.svg)](https://pypi.org/project/objectnat/)
+[![CI](https://github.com/DDonnyy/ObjectNat/actions/workflows/ci_pipeline.yml/badge.svg)](https://github.com/DDonnyy/ObjecNat/actions/workflows/ci_pipeline.yml)
+[![codecov](https://codecov.io/gh/DDonnyy/ObjectNat/graph/badge.svg?token=K6JFSJ02GU)](https://codecov.io/gh/DDonnyy/ObjectNat)
+[![License](https://img.shields.io/badge/license-BSD--3--Clause-blue.svg)](https://opensource.org/licenses/MIT)
+
+- [РИДМИ (Russian)](README_ru.md)
+<p align="center">
+<img src="https://github.com/user-attachments/assets/ed0f226e-1728-4659-9e21-b4d499e703cd" alt="logo" width="400">
+</p>
+
+#### **ObjectNat** is an open-source library created for geospatial analysis created by **IDU team**
+
+## Features and how to use
+
+1. **[Isochrones and Transport Accessibility](./examples/isochrone_generator.ipynb)** — Isochrones represent areas reachable from a starting point within a given time limit along a transport network. This function enables analysis of transport accessibility using pedestrian, automobile, public transport graphs, or their combination.
+
+   The library offers multiple isochrone generation methods:
+   - **Baseline isochrones**: show a single area reachable within a specified time.
+   - **Stepped isochrones**: show accessibility ranges divided into time intervals (e.g., 5, 10, 15 minutes).
+
+   <p align="center">
+     <img src="https://github.com/user-attachments/assets/b1787430-63e1-4907-9198-a6171d546599" alt="isochrone_ways_15_min" width="300">
+     <img src="https://github.com/user-attachments/assets/64fce6bf-6509-490c-928c-dbd8daf9f570" alt="isochrone_radius_15_min" width="300">
+   </p>
+   <p align="center">
+     <img src="https://github.com/user-attachments/assets/ac9f8840-a867-4eb5-aec8-91a411d4e545" alt="stepped_isochrone_stepped_ways_15_min" width="300">
+     <img src="https://github.com/user-attachments/assets/b5429aa1-4625-44d1-982f-8bd4264148fb" alt="stepped_isochrone_stepped_radius_15_min" width="300">
+     <img src="https://github.com/user-attachments/assets/042c7362-70e1-45df-b2e1-02fc76bf638c" alt="stepped_isochrone_stepped_separate_15_min" width="300">
+   </p>
+
+
+2. **[Coverage Zones](./examples/graph_coverage.ipynb)** — Function for generating **coverage zones** from a set of source points using a transport network. It calculates the area each point can reach based on **travel time** or **distance**, then builds polygons via **Voronoi diagrams** and clips them to a custom boundary if provided.
+
+   <p align="center">
+		<img src="https://github.com/user-attachments/assets/fa8057d7-77aa-48a2-aa10-ea3e292a918d" alt="coverage_zones_time_10min" width="350">
+   	<img src="https://github.com/user-attachments/assets/44362dde-c3b0-4321-9a0a-aa547f0f2e04" alt="coverage_zones_distance_600m" width="350">
+   </p>
+ 
+3. **[Service Provision Analysis](./examples/calculate_provision.ipynb)** — Function for evaluating the provision of residential buildings and their population with services (e.g., schools, clinics)
+    that have limited **capacity** and a defined **accessibility threshold** (in minutes or distance). The function models **demand-supply balance**, estimating how well services meet the needs of nearby buildings within the allowed time.
+
+   The library also supports:
+   - **Recalculation** of existing provision results using a new time threshold.
+   - **Clipping** of provision results to a custom analysis area (e.g., administrative boundaries).
+
+   <p align="center">
+     <img src="https://github.com/user-attachments/assets/ff1ed08d-9a35-4035-9e1f-9a7fdae5b0e0" alt="service_provision_initial" width="300">
+     <img src="https://github.com/user-attachments/assets/a0c0a6b0-f83f-4982-bfb3-4a476b2153ea" alt="service_provision_recalculated" width="300">
+     <img src="https://github.com/user-attachments/assets/f57dc1c6-21a0-458d-85f4-fe1b17c77695" alt="service_provision_clipped" width="300">
+   </p>
+
+4. **[Visibility Analysis](./examples/visibility_analysis.ipynb)** — Function for estimating visibility from a given point or multiple points to nearby buildings within a certain distance.
+   This can be used to assess visual accessibility in urban environments.
+   The library also includes a **catchment area calculator** for large-scale visibility analysis based on a dense grid of observer points (recommended: ~1000 points spaced 10–20 meters apart).
+   Points can be generated using a road network and distributed along edges.
+
+   The module includes:
+   - A **fast approximate method** for large datasets.
+   - A **accurate method** for detailed local analysis.
+
+   <p align="center">
+     <img src="https://github.com/user-attachments/assets/aa139d29-07d4-4560-b835-9646c8802fe1" alt="visibility_comparison_methods" height="250">
+     <img src="https://github.com/user-attachments/assets/b5b0d4b3-a02f-4ade-8772-475703cd6435" alt="visibility-catchment-area" height="250">
+   </p>
+
+5. **[Noise Simulation](./examples/noise_simulation.ipynb)** — Simulates noise propagation from a set of source points, taking into account **obstacles**, **vegetation**, and **environmental factors**.
+
+   🔗 **[See detailed explanation in the Wiki](https://github.com/DDonnyy/ObjectNat/wiki/Noise-simulation)**
+
+   <p align="center">
+     <img src="https://github.com/user-attachments/assets/b3a41962-6220-49c4-90d4-2e756f9706cf" alt="noise_simulation_test_result" width="400">
+   </p>
+
+
+6. **[Point Clusterization](./examples/point_clusterization.ipynb)** — Function to generate **cluster polygons** from a set of input points based on:
+   - Minimum **distance** between points.
+   - Minimum **number of points** per cluster.
+
+   Additionally, the function can calculate the **relative ratio** of different service types within each cluster, enabling spatial analysis of service composition.
+
+   <p align="center">
+     <img src="https://github.com/user-attachments/assets/f86aac61-497a-4330-b4cf-68f4fc47fd34" alt="building_clusters" width="400">
+   </p>
+
+## City graphs
+
+To ensure optimal performance of ObjectNat's geospatial analysis functions, it's recommended to utilize urban graphs sourced from the [IduEdu](https://github.com/DDonnyy/IduEdu) library.
+**IduEdu** is an open-source Python library designed for the creation and manipulation of complex city networks derived from OpenStreetMap data. 
+
+**IduEdu** can be installed with ``pip``:
+```
+pip install IduEdu
+```
+## Installation
+
+**ObjectNat** can be installed with ``pip``:
+
+```
+pip install ObjectNat
+```
+### Configuration changes
+
+```python
+from objectnat import config
+
+config.change_logger_lvl('INFO')  # To mute all debug msgs
+config.set_enable_tqdm(False)  # To mute all tqdm's progress bars
+```
+## Contacts
+
+- [NCCR](https://actcognitive.org/) - National Center for Cognitive Research
+- [IDU](https://idu.itmo.ru/) - Institute of Design and Urban Studies
+- [Natalya Chichkova](https://t.me/nancy_nat) - project manager
+- [Danila Oleynikov (Donny)](https://t.me/ddonny_dd) - lead software engineer
+
+## Publications
+

objectnat-1.0.1/README.md

@@ -0,0 +1,119 @@
+# ObjectNat
+
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![PyPI version](https://img.shields.io/pypi/v/objectnat.svg)](https://pypi.org/project/objectnat/)
+[![CI](https://github.com/DDonnyy/ObjectNat/actions/workflows/ci_pipeline.yml/badge.svg)](https://github.com/DDonnyy/ObjecNat/actions/workflows/ci_pipeline.yml)
+[![codecov](https://codecov.io/gh/DDonnyy/ObjectNat/graph/badge.svg?token=K6JFSJ02GU)](https://codecov.io/gh/DDonnyy/ObjectNat)
+[![License](https://img.shields.io/badge/license-BSD--3--Clause-blue.svg)](https://opensource.org/licenses/MIT)
+
+- [РИДМИ (Russian)](README_ru.md)
+<p align="center">
+<img src="https://github.com/user-attachments/assets/ed0f226e-1728-4659-9e21-b4d499e703cd" alt="logo" width="400">
+</p>
+
+#### **ObjectNat** is an open-source library created for geospatial analysis created by **IDU team**
+
+## Features and how to use
+
+1. **[Isochrones and Transport Accessibility](./examples/isochrone_generator.ipynb)** — Isochrones represent areas reachable from a starting point within a given time limit along a transport network. This function enables analysis of transport accessibility using pedestrian, automobile, public transport graphs, or their combination.
+
+   The library offers multiple isochrone generation methods:
+   - **Baseline isochrones**: show a single area reachable within a specified time.
+   - **Stepped isochrones**: show accessibility ranges divided into time intervals (e.g., 5, 10, 15 minutes).
+
+   <p align="center">
+     <img src="https://github.com/user-attachments/assets/b1787430-63e1-4907-9198-a6171d546599" alt="isochrone_ways_15_min" width="300">
+     <img src="https://github.com/user-attachments/assets/64fce6bf-6509-490c-928c-dbd8daf9f570" alt="isochrone_radius_15_min" width="300">
+   </p>
+   <p align="center">
+     <img src="https://github.com/user-attachments/assets/ac9f8840-a867-4eb5-aec8-91a411d4e545" alt="stepped_isochrone_stepped_ways_15_min" width="300">
+     <img src="https://github.com/user-attachments/assets/b5429aa1-4625-44d1-982f-8bd4264148fb" alt="stepped_isochrone_stepped_radius_15_min" width="300">
+     <img src="https://github.com/user-attachments/assets/042c7362-70e1-45df-b2e1-02fc76bf638c" alt="stepped_isochrone_stepped_separate_15_min" width="300">
+   </p>
+
+
+2. **[Coverage Zones](./examples/graph_coverage.ipynb)** — Function for generating **coverage zones** from a set of source points using a transport network. It calculates the area each point can reach based on **travel time** or **distance**, then builds polygons via **Voronoi diagrams** and clips them to a custom boundary if provided.
+
+   <p align="center">
+		<img src="https://github.com/user-attachments/assets/fa8057d7-77aa-48a2-aa10-ea3e292a918d" alt="coverage_zones_time_10min" width="350">
+   	<img src="https://github.com/user-attachments/assets/44362dde-c3b0-4321-9a0a-aa547f0f2e04" alt="coverage_zones_distance_600m" width="350">
+   </p>
+ 
+3. **[Service Provision Analysis](./examples/calculate_provision.ipynb)** — Function for evaluating the provision of residential buildings and their population with services (e.g., schools, clinics)
+    that have limited **capacity** and a defined **accessibility threshold** (in minutes or distance). The function models **demand-supply balance**, estimating how well services meet the needs of nearby buildings within the allowed time.
+
+   The library also supports:
+   - **Recalculation** of existing provision results using a new time threshold.
+   - **Clipping** of provision results to a custom analysis area (e.g., administrative boundaries).
+
+   <p align="center">
+     <img src="https://github.com/user-attachments/assets/ff1ed08d-9a35-4035-9e1f-9a7fdae5b0e0" alt="service_provision_initial" width="300">
+     <img src="https://github.com/user-attachments/assets/a0c0a6b0-f83f-4982-bfb3-4a476b2153ea" alt="service_provision_recalculated" width="300">
+     <img src="https://github.com/user-attachments/assets/f57dc1c6-21a0-458d-85f4-fe1b17c77695" alt="service_provision_clipped" width="300">
+   </p>
+
+4. **[Visibility Analysis](./examples/visibility_analysis.ipynb)** — Function for estimating visibility from a given point or multiple points to nearby buildings within a certain distance.
+   This can be used to assess visual accessibility in urban environments.
+   The library also includes a **catchment area calculator** for large-scale visibility analysis based on a dense grid of observer points (recommended: ~1000 points spaced 10–20 meters apart).
+   Points can be generated using a road network and distributed along edges.
+
+   The module includes:
+   - A **fast approximate method** for large datasets.
+   - A **accurate method** for detailed local analysis.
+
+   <p align="center">
+     <img src="https://github.com/user-attachments/assets/aa139d29-07d4-4560-b835-9646c8802fe1" alt="visibility_comparison_methods" height="250">
+     <img src="https://github.com/user-attachments/assets/b5b0d4b3-a02f-4ade-8772-475703cd6435" alt="visibility-catchment-area" height="250">
+   </p>
+
+5. **[Noise Simulation](./examples/noise_simulation.ipynb)** — Simulates noise propagation from a set of source points, taking into account **obstacles**, **vegetation**, and **environmental factors**.
+
+   🔗 **[See detailed explanation in the Wiki](https://github.com/DDonnyy/ObjectNat/wiki/Noise-simulation)**
+
+   <p align="center">
+     <img src="https://github.com/user-attachments/assets/b3a41962-6220-49c4-90d4-2e756f9706cf" alt="noise_simulation_test_result" width="400">
+   </p>
+
+
+6. **[Point Clusterization](./examples/point_clusterization.ipynb)** — Function to generate **cluster polygons** from a set of input points based on:
+   - Minimum **distance** between points.
+   - Minimum **number of points** per cluster.
+
+   Additionally, the function can calculate the **relative ratio** of different service types within each cluster, enabling spatial analysis of service composition.
+
+   <p align="center">
+     <img src="https://github.com/user-attachments/assets/f86aac61-497a-4330-b4cf-68f4fc47fd34" alt="building_clusters" width="400">
+   </p>
+
+## City graphs
+
+To ensure optimal performance of ObjectNat's geospatial analysis functions, it's recommended to utilize urban graphs sourced from the [IduEdu](https://github.com/DDonnyy/IduEdu) library.
+**IduEdu** is an open-source Python library designed for the creation and manipulation of complex city networks derived from OpenStreetMap data. 
+
+**IduEdu** can be installed with ``pip``:
+```
+pip install IduEdu
+```
+## Installation
+
+**ObjectNat** can be installed with ``pip``:
+
+```
+pip install ObjectNat
+```
+### Configuration changes
+
+```python
+from objectnat import config
+
+config.change_logger_lvl('INFO')  # To mute all debug msgs
+config.set_enable_tqdm(False)  # To mute all tqdm's progress bars
+```
+## Contacts
+
+- [NCCR](https://actcognitive.org/) - National Center for Cognitive Research
+- [IDU](https://idu.itmo.ru/) - Institute of Design and Urban Studies
+- [Natalya Chichkova](https://t.me/nancy_nat) - project manager
+- [Danila Oleynikov (Donny)](https://t.me/ddonny_dd) - lead software engineer
+
+## Publications

{objectnat-0.2.7 → objectnat-1.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ObjectNat"
-version = "0.2.7"
+version = "1.0.1"
 description = "ObjectNat is an open-source library created for geospatial analysis created by IDU team"
 license = "BSD-3-Clause"
 authors = ["DDonnyy <63115678+DDonnyy@users.noreply.github.com>"]
@@ -10,22 +10,27 @@ packages = [{ include = "objectnat", from = "src" }]
 
 [tool.poetry.dependencies]
 python = ">=3.10,<3.13"
-numpy = "^1.26.4"
+numpy = "^2.1.3"
 pandas = "^2.2.0"
-geopandas = "^0.14.3"
+geopandas = "^1.0.1"
 tqdm = "^4.66.2"
 pandarallel = "^1.6.5"
-networkx = "^3.3"
-population-restorator = "^0.2.3"
-iduedu = "^0.2.2"
+networkx = "^3.4.2"
 scikit-learn = "^1.4.0"
 
 
 [tool.poetry.group.dev.dependencies]
+iduedu = "^0.5.0"
+pyarrow = "^19.0.1"
 black = "^24.2.0"
 pylint = "^3.0.3"
 isort = "^5.13.2"
 jupyter = "^1.0.0"
+pytest = "^8.3.5"
+pytest-cov = "^6.0.0"
+folium = "^0.19.5"
+matplotlib = "^3.10.1"
+mapclassify = "^2.8.1"
 
 [build-system]
 requires = ["poetry-core"]

objectnat-1.0.1/src/objectnat/_api.py

@@ -0,0 +1,13 @@
+# pylint: disable=unused-import,wildcard-import,unused-wildcard-import
+
+from .methods.coverage_zones import get_graph_coverage, get_radius_coverage
+from .methods.isochrones import get_accessibility_isochrone_stepped, get_accessibility_isochrones
+from .methods.noise import simulate_noise
+from .methods.point_clustering import get_clusters_polygon
+from .methods.provision import clip_provision, get_service_provision, recalculate_links
+from .methods.visibility import (
+    calculate_visibility_catchment_area,
+    get_visibilities_from_points,
+    get_visibility,
+    get_visibility_accurate,
+)

{objectnat-0.2.7 → objectnat-1.0.1}/src/objectnat/_config.py

@@ -1,7 +1,6 @@
 import sys
 from typing import Literal
 
-from iduedu import config as iduedu_config
 from loguru import logger
 
 
@@ -12,10 +11,6 @@ class Config:
 
     Attributes
     ----------
-    overpass_url : str
-        URL for accessing the Overpass API. Defaults to "http://lz4.overpass-api.de/api/interpreter".
-    timeout : int or None
-        Timeout in seconds for API requests. If None, no timeout is applied.
     enable_tqdm_bar : bool
         Enables or disables progress bars (via tqdm). Defaults to True.
     logger : Logger
@@ -25,43 +20,24 @@ class Config:
     -------
     change_logger_lvl(lvl: Literal["TRACE", "DEBUG", "INFO", "WARN", "ERROR"])
         Changes the logging level to the specified value.
-    set_overpass_url(url: str)
-        Sets a new Overpass API URL.
-    set_timeout(timeout: int)
-        Sets the timeout for API requests.
     set_enable_tqdm(enable: bool)
         Enables or disables progress bars in the application.
     """
 
     def __init__(
         self,
-        overpass_url="http://lz4.overpass-api.de/api/interpreter",
-        timeout=None,
         enable_tqdm_bar=True,
     ):
-        self.overpass_url = overpass_url
-        self.timeout = timeout
         self.enable_tqdm_bar = enable_tqdm_bar
         self.logger = logger
-        self.iduedu_config = iduedu_config
         self.pandarallel_use_file_system = False
 
     def change_logger_lvl(self, lvl: Literal["TRACE", "DEBUG", "INFO", "WARN", "ERROR"]):
         self.logger.remove()
         self.logger.add(sys.stderr, level=lvl)
-        self.iduedu_config.change_logger_lvl(lvl)
-
-    def set_overpass_url(self, url: str):
-        self.overpass_url = url
-        self.iduedu_config.set_overpass_url(url)
-
-    def set_timeout(self, timeout: int):
-        self.timeout = timeout
-        self.iduedu_config.set_timeout(timeout)
 
     def set_enable_tqdm(self, enable: bool):
         self.enable_tqdm_bar = enable
-        self.iduedu_config.set_enable_tqdm(enable)
 
     def set_pandarallel_use_file_system(self, enable: bool):
         self.pandarallel_use_file_system = enable

objectnat-1.0.1/src/objectnat/_version.py

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

objectnat-1.0.1/src/objectnat/methods/coverage_zones/__init__.py

@@ -0,0 +1,2 @@
+from .graph_coverage import get_graph_coverage
+from .radius_voronoi import get_radius_coverage

objectnat-1.0.1/src/objectnat/methods/coverage_zones/graph_coverage.py

@@ -0,0 +1,118 @@
+from typing import Literal
+
+import geopandas as gpd
+import networkx as nx
+import pandas as pd
+from pyproj.exceptions import CRSError
+from shapely import Point, concave_hull
+
+from objectnat.methods.utils.graph_utils import get_closest_nodes_from_gdf, remove_weakly_connected_nodes
+
+
+def get_graph_coverage(
+    gdf_from: gpd.GeoDataFrame,
+    nx_graph: nx.Graph,
+    weight_type: Literal["time_min", "length_meter"],
+    weight_value_cutoff: float = None,
+    zone: gpd.GeoDataFrame = None,
+):
+    """
+    Calculate coverage zones from source points through a graph network using Dijkstra's algorithm
+    and Voronoi diagrams.
+
+    The function works by:
+    1. Finding nearest graph nodes for each input point
+    2. Calculating all reachable nodes within cutoff distance using Dijkstra
+    3. Creating Voronoi polygons around graph nodes
+    4. Combining reachability information with Voronoi cells
+    5. Clipping results to specified zone boundary
+
+    Parameters
+    ----------
+    gdf_from : gpd.GeoDataFrame
+        Source points from which coverage is calculated.
+    nx_graph : nx.Graph
+        NetworkX graph representing the transportation network.
+    weight_type : Literal["time_min", "length_meter"]
+        Edge attribute to use as weight for path calculations.
+    weight_value_cutoff : float, optional
+        Maximum weight value for path calculations (e.g., max travel time/distance).
+    zone : gpd.GeoDataFrame, optional
+        Boundary polygon to clip the resulting coverage zones. If None, concave hull of reachable nodes will be used.
+
+    Returns
+    -------
+    gpd.GeoDataFrame
+        GeoDataFrame with coverage zones polygons, each associated with its source point, returns in the same CRS as
+        original gdf_from.
+
+    Notes
+    -----
+    - The graph must have a valid CRS attribute in its graph properties
+    - MultiGraph/MultiDiGraph inputs will be converted to simple Graph/DiGraph
+
+    Examples
+    --------
+    >>> from iduedu import get_intermodal_graph # pip install iduedu to get OSM city network graph
+    >>> points = gpd.read_file('points.geojson')
+    >>> graph = get_intermodal_graph(osm_id=1114252)
+    >>> coverage = get_graph_coverage(points, graph, "time_min", 15)
+    """
+    original_crs = gdf_from.crs
+    try:
+        local_crs = nx_graph.graph["crs"]
+    except KeyError as exc:
+        raise ValueError("Graph does not have crs attribute") from exc
+
+    try:
+        points = gdf_from.copy()
+        points.to_crs(local_crs, inplace=True)
+    except CRSError as e:
+        raise CRSError(f"Graph crs ({local_crs}) has invalid format.") from e
+
+    if nx_graph.is_multigraph():
+        if nx_graph.is_directed():
+            nx_graph = nx.DiGraph(nx_graph)
+        else:
+            nx_graph = nx.Graph(nx_graph)
+    nx_graph = remove_weakly_connected_nodes(nx_graph)
+    sparse_matrix = nx.to_scipy_sparse_array(nx_graph, weight=weight_type)
+    transposed_matrix = sparse_matrix.transpose()
+    reversed_graph = nx.from_scipy_sparse_array(
+        transposed_matrix, edge_attribute=weight_type, create_using=type(nx_graph)
+    )
+
+    points.geometry = points.representative_point()
+
+    _, nearest_nodes = get_closest_nodes_from_gdf(points, nx_graph)
+
+    points["nearest_node"] = nearest_nodes
+
+    _, nearest_paths = nx.multi_source_dijkstra(
+        reversed_graph, nearest_nodes, weight=weight_type, cutoff=weight_value_cutoff
+    )
+    reachable_nodes = list(nearest_paths.keys())
+    graph_points = pd.DataFrame(
+        data=[{"node": node, "geometry": Point(data["x"], data["y"])} for node, data in nx_graph.nodes(data=True)]
+    ).set_index("node")
+    nearest_nodes = pd.DataFrame(
+        data=[path[0] for path in nearest_paths.values()], index=reachable_nodes, columns=["node_to"]
+    )
+    graph_nodes_gdf = gpd.GeoDataFrame(
+        graph_points.merge(nearest_nodes, left_index=True, right_index=True, how="left"),
+        geometry="geometry",
+        crs=local_crs,
+    )
+    graph_nodes_gdf["node_to"] = graph_nodes_gdf["node_to"].fillna("non_reachable")
+    voronois = gpd.GeoDataFrame(geometry=graph_nodes_gdf.voronoi_polygons(), crs=local_crs)
+    graph_nodes_gdf = graph_nodes_gdf[graph_nodes_gdf["node_to"] != "non_reachable"]
+    zone_coverages = voronois.sjoin(graph_nodes_gdf).dissolve(by="node_to").reset_index().drop(columns=["node"])
+    zone_coverages = zone_coverages.merge(
+        points.drop(columns="geometry"), left_on="node_to", right_on="nearest_node", how="inner"
+    ).reset_index(drop=True)
+    zone_coverages.drop(columns=["node_to", "nearest_node"], inplace=True)
+    if zone is None:
+        zone = concave_hull(graph_nodes_gdf[~graph_nodes_gdf["node_to"].isna()].union_all(), ratio=0.5)
+    else:
+        zone = zone.to_crs(local_crs)
+    return zone_coverages.clip(zone).to_crs(original_crs)

objectnat-1.0.1/src/objectnat/methods/coverage_zones/radius_voronoi.py

@@ -0,0 +1,45 @@
+import geopandas as gpd
+import numpy as np
+
+
+def get_radius_coverage(gdf_from: gpd.GeoDataFrame, radius: float, resolution: int = 32):
+    """
+    Calculate radius-based coverage zones using Voronoi polygons.
+
+    Parameters
+    ----------
+    gdf_from : gpd.GeoDataFrame
+        Source points for which coverage zones are calculated.
+    radius : float
+        Maximum coverage radius in meters.
+    resolution : int, optional
+        Number of segments used to approximate quarter-circle in buffer (default=32).
+
+    Returns
+    -------
+    gpd.GeoDataFrame
+        GeoDataFrame with smoothed coverage zone polygons in the same CRS as original gdf_from.
+
+    Notes
+    -----
+    - Automatically converts to local UTM CRS for accurate distance measurements
+    - Final zones are slightly contracted then expanded for smoothing effect
+
+    Examples
+    --------
+    >>> facilities = gpd.read_file('healthcare.shp')
+    >>> coverage = get_radius_coverage(facilities, radius=500)
+    """
+    original_crs = gdf_from.crs
+    local_crs = gdf_from.estimate_utm_crs()
+    gdf_from = gdf_from.to_crs(local_crs)
+    bounds = gdf_from.buffer(radius).union_all()
+    coverage_polys = gpd.GeoDataFrame(geometry=gdf_from.voronoi_polygons().clip(bounds, keep_geom_type=True))
+    coverage_polys = coverage_polys.sjoin(gdf_from)
+    coverage_polys["area"] = coverage_polys.area
+    coverage_polys["buffer"] = np.pow(coverage_polys["area"], 1 / 3)
+    coverage_polys.geometry = coverage_polys.buffer(-coverage_polys["buffer"], resolution=1, join_style="mitre").buffer(
+        coverage_polys["buffer"] * 0.9, resolution=resolution
+    )
+    coverage_polys.drop(columns=["buffer", "area"], inplace=True)
+    return coverage_polys.to_crs(original_crs)

objectnat-1.0.1/src/objectnat/methods/isochrones/__init__.py

@@ -0,0 +1 @@
+from .isochrones import get_accessibility_isochrones, get_accessibility_isochrone_stepped