PyPI - ObjectNat - Versions diffs - 1.0.1__tar.gz → 1.1.0__tar.gz - Mend

ObjectNat 1.0.1tar.gz → 1.1.0tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of ObjectNat might be problematic. Click here for more details.

Files changed (35) hide show

{objectnat-1.0.1 → objectnat-1.1.0}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ObjectNat
-Version: 1.0.1
+Version: 1.1.0
 Summary: ObjectNat is an open-source library created for geospatial analysis created by IDU team
 License: BSD-3-Clause
 Author: DDonnyy
@@ -12,6 +12,7 @@ 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: 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: pandarallel (>=1.6.5,<2.0.0)
@@ -44,21 +45,26 @@ Description-Content-Type: text/markdown
    - **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">
+      <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/isochrone_ways_15_min.png" alt="isochrone_ways_15_min" width="300">
+      <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/isochrone_radius_15_min.png" alt="isochrone_radius_15_min" width="300">
+      <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/isochrone_3points_radius_8_min.png" alt="isochrone_3points_radius_8_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">
+     <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/stepped_isochrone_ways_15_min.png" alt="stepped_isochrone_ways_15_min" width="300">
+     <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/stepped_isochrone_radius_15_min.png" alt="stepped_isochrone_radius_15_min" width="300">
+     <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/stepped_isochrone_separate_15_min.png" alt="stepped_isochrone_separate_15_min" width="300">
    </p>
+2. **[Coverage Zones](./examples/coverage_zones.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.
-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">
+      <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/coverage_zones_time_10min.png" alt="coverage_zones_time_10min" width="350">
+      <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/coverage_zones_distance_600m.png" alt="coverage_zones_distance_600m" width="350">
+      <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/coverage_zones_radius_distance_800m.png" alt="coverage_zones_distance_radius_voronoi" width="350">
+   </p>
+   <p align="center">
+      <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/stepped_coverage_zones_separate.png" alt="stepped_coverage_zones_separate" width="350">
+      <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/stepped_coverage_zones_voronoi.png" alt="stepped_coverage_zones_voronoi" 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)
@@ -69,9 +75,9 @@ Description-Content-Type: text/markdown
    - **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">
+      <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/service_provision_initial.png" alt="service_provision_initial" width="300">
+      <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/service_provision_recalculated.png" alt="service_provision_recalculated" width="300">
+      <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/service_provision_clipped.png" 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.
@@ -84,7 +90,7 @@ Description-Content-Type: text/markdown
    - 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://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/visibility_comparison_methods.png" 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>
@@ -93,7 +99,7 @@ Description-Content-Type: text/markdown
    🔗 **[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">
+      <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/noise_simulation_1point.png" alt="noise_simulation_1point" width="400">
    </p>
@@ -104,7 +110,7 @@ Description-Content-Type: text/markdown
    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">
+     <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/building_clusters.png" alt="building_clusters" width="400">
    </p>
 ## City graphs

{objectnat-1.0.1 → objectnat-1.1.0}/README.md RENAMED Viewed

@@ -22,21 +22,26 @@
    - **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">
+      <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/isochrone_ways_15_min.png" alt="isochrone_ways_15_min" width="300">
+      <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/isochrone_radius_15_min.png" alt="isochrone_radius_15_min" width="300">
+      <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/isochrone_3points_radius_8_min.png" alt="isochrone_3points_radius_8_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">
+     <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/stepped_isochrone_ways_15_min.png" alt="stepped_isochrone_ways_15_min" width="300">
+     <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/stepped_isochrone_radius_15_min.png" alt="stepped_isochrone_radius_15_min" width="300">
+     <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/stepped_isochrone_separate_15_min.png" alt="stepped_isochrone_separate_15_min" width="300">
    </p>
+2. **[Coverage Zones](./examples/coverage_zones.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.
-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">
+      <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/coverage_zones_time_10min.png" alt="coverage_zones_time_10min" width="350">
+      <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/coverage_zones_distance_600m.png" alt="coverage_zones_distance_600m" width="350">
+      <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/coverage_zones_radius_distance_800m.png" alt="coverage_zones_distance_radius_voronoi" width="350">
+   </p>
+   <p align="center">
+      <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/stepped_coverage_zones_separate.png" alt="stepped_coverage_zones_separate" width="350">
+      <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/stepped_coverage_zones_voronoi.png" alt="stepped_coverage_zones_voronoi" 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)
@@ -47,9 +52,9 @@
    - **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">
+      <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/service_provision_initial.png" alt="service_provision_initial" width="300">
+      <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/service_provision_recalculated.png" alt="service_provision_recalculated" width="300">
+      <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/service_provision_clipped.png" 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.
@@ -62,7 +67,7 @@
    - 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://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/visibility_comparison_methods.png" 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>
@@ -71,7 +76,7 @@
    🔗 **[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">
+      <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/noise_simulation_1point.png" alt="noise_simulation_1point" width="400">
    </p>
@@ -82,7 +87,7 @@
    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">
+     <img src="https://raw.githubusercontent.com/DDonnyy/ObjectNat/assets/building_clusters.png" alt="building_clusters" width="400">
    </p>
 ## City graphs

{objectnat-1.0.1 → objectnat-1.1.0}/pyproject.toml RENAMED Viewed

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ObjectNat"
-version = "1.0.1"
+version = "1.1.0"
 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>"]
@@ -17,6 +17,7 @@ tqdm = "^4.66.2"
 pandarallel = "^1.6.5"
 networkx = "^3.4.2"
 scikit-learn = "^1.4.0"
+loguru = "^0.7.3"
 [tool.poetry.group.dev.dependencies]
@@ -28,6 +29,7 @@ isort = "^5.13.2"
 jupyter = "^1.0.0"
 pytest = "^8.3.5"
 pytest-cov = "^6.0.0"
+pre-commit = "^4.2.0"
 folium = "^0.19.5"
 matplotlib = "^3.10.1"
 mapclassify = "^2.8.1"
@@ -56,9 +58,6 @@ disable = [
     "too-many-arguments",
     "cyclic-import"
 ]
-good-names = [
-]
 [tool.isort]
 multi_line_output = 3

{objectnat-1.0.1 → objectnat-1.1.0}/src/objectnat/_api.py RENAMED Viewed

@@ -1,6 +1,6 @@
 # pylint: disable=unused-import,wildcard-import,unused-wildcard-import
-from .methods.coverage_zones import get_graph_coverage, get_radius_coverage
+from .methods.coverage_zones import get_graph_coverage, get_radius_coverage, get_stepped_graph_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

objectnat-1.1.0/src/objectnat/_version.py ADDED Viewed

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

objectnat-1.1.0/src/objectnat/methods/coverage_zones/__init__.py ADDED Viewed

@@ -0,0 +1,3 @@
+from .graph_coverage import get_graph_coverage
+from .radius_voronoi_coverage import get_radius_coverage
+from .stepped_coverage import get_stepped_graph_coverage

{objectnat-1.0.1 → objectnat-1.1.0}/src/objectnat/methods/coverage_zones/graph_coverage.py RENAMED Viewed

@@ -6,11 +6,11 @@ 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
+from objectnat.methods.utils.graph_utils import get_closest_nodes_from_gdf, reverse_graph
 def get_graph_coverage(
-    gdf_from: gpd.GeoDataFrame,
+    gdf_to: gpd.GeoDataFrame,
     nx_graph: nx.Graph,
     weight_type: Literal["time_min", "length_meter"],
     weight_value_cutoff: float = None,
@@ -29,8 +29,8 @@ def get_graph_coverage(
     Parameters
     ----------
-    gdf_from : gpd.GeoDataFrame
-        Source points from which coverage is calculated.
+    gdf_to : gpd.GeoDataFrame
+        Source points to which coverage is calculated.
     nx_graph : nx.Graph
         NetworkX graph representing the transportation network.
     weight_type : Literal["time_min", "length_meter"]
@@ -58,29 +58,19 @@ def get_graph_coverage(
     >>> graph = get_intermodal_graph(osm_id=1114252)
     >>> coverage = get_graph_coverage(points, graph, "time_min", 15)
     """
-    original_crs = gdf_from.crs
+    original_crs = gdf_to.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 = gdf_to.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)
-    )
+    nx_graph, reversed_graph = reverse_graph(nx_graph, weight_type)
     points.geometry = points.representative_point()
@@ -88,7 +78,7 @@ def get_graph_coverage(
     points["nearest_node"] = nearest_nodes
-    _, nearest_paths = nx.multi_source_dijkstra(
+    nearest_paths = nx.multi_source_dijkstra_path(
         reversed_graph, nearest_nodes, weight=weight_type, cutoff=weight_value_cutoff
     )
     reachable_nodes = list(nearest_paths.keys())

objectnat-1.1.0/src/objectnat/methods/coverage_zones/stepped_coverage.py ADDED Viewed

@@ -0,0 +1,142 @@
+from typing import Literal
+import geopandas as gpd
+import networkx as nx
+import numpy as np
+import pandas as pd
+from pyproj.exceptions import CRSError
+from shapely import Point, concave_hull
+from objectnat.methods.isochrones.isochrone_utils import create_separated_dist_polygons
+from objectnat.methods.utils.graph_utils import get_closest_nodes_from_gdf, reverse_graph
+def get_stepped_graph_coverage(
+    gdf_to: gpd.GeoDataFrame,
+    nx_graph: nx.Graph,
+    weight_type: Literal["time_min", "length_meter"],
+    step_type: Literal["voronoi", "separate"],
+    weight_value_cutoff: float = None,
+    zone: gpd.GeoDataFrame = None,
+    step: float = None,
+):
+    """
+    Calculate stepped coverage zones from source points through a graph network using Dijkstra's algorithm
+    and Voronoi-based or buffer-based isochrone steps.
+    This function combines graph-based accessibility with stepped isochrone logic. It:
+    1. Finds nearest graph nodes for each input point
+    2. Computes reachability for increasing weights (e.g. time or distance) in defined steps
+    3. Generates Voronoi-based or separate buffer zones around network nodes
+    4. Aggregates zones into stepped coverage layers
+    5. Optionally clips results to a boundary zone
+    Parameters
+    ----------
+    gdf_to : gpd.GeoDataFrame
+        Source points from which stepped coverage is calculated.
+    nx_graph : nx.Graph
+        NetworkX graph representing the transportation network.
+    weight_type : Literal["time_min", "length_meter"]
+        Type of edge weight to use for path calculation:
+        - "time_min": Edge travel time in minutes
+        - "length_meter": Edge length in meters
+    step_type : Literal["voronoi", "separate"]
+        Method for generating stepped zones:
+        - "voronoi": Stepped zones based on Voronoi polygons around graph nodes
+        - "separate": Independent buffer zones per step
+    weight_value_cutoff : float, optional
+        Maximum weight value (e.g., max travel time or distance) to limit the coverage extent.
+    zone : gpd.GeoDataFrame, optional
+        Optional boundary polygon to clip resulting stepped zones. If None, concave hull of reachable area is used.
+    step : float, optional
+        Step interval for coverage zone construction. Defaults to:
+        - 100 meters for distance-based weight
+        - 1 minute for time-based weight
+    Returns
+    -------
+    gpd.GeoDataFrame
+        GeoDataFrame with polygons representing stepped coverage zones for each input point, annotated by step range.
+    Notes
+    -----
+    - Input graph must have a valid CRS defined.
+    - MultiGraph or MultiDiGraph inputs will be simplified.
+    - Designed for accessibility and spatial equity analyses over multimodal networks.
+    Examples
+    --------
+    >>> from iduedu import get_intermodal_graph
+    >>> points = gpd.read_file('destinations.geojson')
+    >>> graph = get_intermodal_graph(osm_id=1114252)
+    >>> stepped_coverage = get_stepped_graph_coverage(
+    ...     points, graph, "time_min", step_type="voronoi", weight_value_cutoff=30, step=5
+    ... )
+    >>> # Using buffer-style zones
+    >>> stepped_separate = get_stepped_graph_coverage(
+    ...     points, graph, "length_meter", step_type="separate", weight_value_cutoff=1000, step=200
+    ... )
+    """
+    if step is None:
+        if weight_type == "length_meter":
+            step = 100
+        else:
+            step = 1
+    original_crs = gdf_to.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_to.copy()
+        points.to_crs(local_crs, inplace=True)
+    except CRSError as e:
+        raise CRSError(f"Graph crs ({local_crs}) has invalid format.") from e
+    nx_graph, reversed_graph = reverse_graph(nx_graph, weight_type)
+    points.geometry = points.representative_point()
+    distances, nearest_nodes = get_closest_nodes_from_gdf(points, nx_graph)
+    points["nearest_node"] = nearest_nodes
+    points["distance"] = distances
+    dist = nx.multi_source_dijkstra_path_length(
+        reversed_graph, nearest_nodes, weight=weight_type, cutoff=weight_value_cutoff
+    )
+    graph_points = pd.DataFrame(
+        data=[{"node": node, "geometry": Point(data["x"], data["y"])} for node, data in nx_graph.nodes(data=True)]
+    )
+    nearest_nodes = pd.DataFrame.from_dict(dist, orient="index", columns=["dist"]).reset_index()
+    graph_nodes_gdf = gpd.GeoDataFrame(
+        graph_points.merge(nearest_nodes, left_on="node", right_on="index", how="left").reset_index(drop=True),
+        geometry="geometry",
+        crs=local_crs,
+    )
+    graph_nodes_gdf.drop(columns=["index", "node"], inplace=True)
+    if weight_value_cutoff is None:
+        weight_value_cutoff = max(nearest_nodes["dist"])
+    if step_type == "voronoi":
+        graph_nodes_gdf["dist"] = np.minimum(np.ceil(graph_nodes_gdf["dist"] / step) * step, weight_value_cutoff)
+        voronois = gpd.GeoDataFrame(geometry=graph_nodes_gdf.voronoi_polygons(), crs=local_crs)
+        zone_coverages = voronois.sjoin(graph_nodes_gdf).dissolve(by="dist", as_index=False, dropna=False)
+        zone_coverages = zone_coverages[["dist", "geometry"]].explode(ignore_index=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)
+        zone_coverages = zone_coverages.clip(zone).to_crs(original_crs)
+    else:  # step_type == 'separate':
+        speed = 83.33  # TODO HARDCODED WALK SPEED
+        weight_value = weight_value_cutoff
+        zone_coverages = create_separated_dist_polygons(graph_nodes_gdf, weight_value, weight_type, step, speed)
+        if zone is not None:
+            zone = zone.to_crs(local_crs)
+            zone_coverages = zone_coverages.clip(zone).to_crs(original_crs)
+    return zone_coverages

{objectnat-1.0.1 → objectnat-1.1.0}/src/objectnat/methods/isochrones/isochrone_utils.py RENAMED Viewed

@@ -5,8 +5,10 @@ import networkx as nx
 import numpy as np
 import pandas as pd
 from pyproj.exceptions import CRSError
+from shapely.ops import polygonize
 from objectnat import config
+from objectnat.methods.utils.geom_utils import polygons_to_multilinestring
 from objectnat.methods.utils.graph_utils import get_closest_nodes_from_gdf, remove_weakly_connected_nodes
 logger = config.logger
@@ -128,3 +130,38 @@ def _create_isochrones_gdf(
     isochrones["weight_type"] = weight_type
     isochrones["weight_value"] = weight_value
     return isochrones
+def create_separated_dist_polygons(
+    points: gpd.GeoDataFrame, weight_value, weight_type, step, speed
+) -> gpd.GeoDataFrame:
+    points["dist"] = points["dist"].clip(lower=0.1)
+    steps = np.arange(0, weight_value + step, step)
+    if steps[-1] > weight_value:
+        steps[-1] = weight_value  # Ensure last step doesn't exceed weight_value
+    for i in range(len(steps) - 1):
+        min_dist = steps[i]
+        max_dist = steps[i + 1]
+        nodes_in_step = points["dist"].between(min_dist, max_dist, inclusive="left")
+        nodes_in_step = nodes_in_step[nodes_in_step].index
+        if not nodes_in_step.empty:
+            buffer_size = (max_dist - points.loc[nodes_in_step, "dist"]) * 0.7
+            if weight_type == "time_min":
+                buffer_size = buffer_size * speed
+            points.loc[nodes_in_step, "buffer_size"] = buffer_size
+    points.geometry = points.geometry.buffer(points["buffer_size"])
+    points["dist"] = np.minimum(np.ceil(points["dist"] / step) * step, weight_value)
+    points = points.dissolve(by="dist", as_index=False)
+    polygons = gpd.GeoDataFrame(
+        geometry=list(polygonize(points.geometry.apply(polygons_to_multilinestring).union_all())),
+        crs=points.crs,
+    )
+    polygons_points = polygons.copy()
+    polygons_points.geometry = polygons.representative_point()
+    stepped_polygons = polygons_points.sjoin(points, predicate="within").reset_index()
+    stepped_polygons = stepped_polygons.groupby("index").agg({"dist": "mean"})
+    stepped_polygons["dist"] = np.minimum(np.floor(stepped_polygons["dist"] / step) * step, weight_value)
+    stepped_polygons["geometry"] = polygons
+    stepped_polygons = gpd.GeoDataFrame(stepped_polygons, geometry="geometry", crs=points.crs).reset_index(drop=True)
+    stepped_polygons = stepped_polygons.dissolve(by="dist", as_index=False).explode(ignore_index=True)
+    return stepped_polygons

{objectnat-1.0.1 → objectnat-1.1.0}/src/objectnat/methods/isochrones/isochrones.py RENAMED Viewed

@@ -3,7 +3,6 @@ from typing import Literal
 import geopandas as gpd
 import networkx as nx
 import numpy as np
-from shapely.ops import polygonize
 from objectnat import config
 from objectnat.methods.isochrones.isochrone_utils import (
@@ -12,8 +11,9 @@ from objectnat.methods.isochrones.isochrone_utils import (
     _prepare_graph_and_nodes,
     _process_pt_data,
     _validate_inputs,
+    create_separated_dist_polygons,
 )
-from objectnat.methods.utils.geom_utils import polygons_to_multilinestring, remove_inner_geom
+from objectnat.methods.utils.geom_utils import remove_inner_geom
 from objectnat.methods.utils.graph_utils import graph_to_gdf
 logger = config.logger
@@ -116,35 +116,9 @@ def get_accessibility_isochrone_stepped(
     logger.info("Building isochrones geometry...")
     nodes, edges = graph_to_gdf(subgraph)
     nodes.loc[dist_matrix.columns, "dist"] = dist_matrix.iloc[0]
-    steps = np.arange(0, weight_value + step, step)
-    if steps[-1] > weight_value:
-        steps[-1] = weight_value  # Ensure last step doesn't exceed weight_value
     if isochrone_type == "separate":
-        for i in range(len(steps) - 1):
-            min_dist = steps[i]
-            max_dist = steps[i + 1]
-            nodes_in_step = nodes["dist"].between(min_dist, max_dist, inclusive="left")
-            nodes_in_step = nodes_in_step[nodes_in_step].index
-            if not nodes_in_step.empty:
-                buffer_size = (max_dist - nodes.loc[nodes_in_step, "dist"]) * 0.7
-                if weight_type == "time_min":
-                    buffer_size = buffer_size * speed
-                nodes.loc[nodes_in_step, "buffer_size"] = buffer_size
-        nodes.geometry = nodes.geometry.buffer(nodes["buffer_size"])
-        nodes["dist"] = np.round(nodes["dist"], 0)
-        nodes = nodes.dissolve(by="dist", as_index=False)
-        polygons = gpd.GeoDataFrame(
-            geometry=list(polygonize(nodes.geometry.apply(polygons_to_multilinestring).union_all())),
-            crs=local_crs,
-        )
-        polygons_points = polygons.copy()
-        polygons_points.geometry = polygons.representative_point()
-        stepped_iso = polygons_points.sjoin(nodes, predicate="within").reset_index()
-        stepped_iso = stepped_iso.groupby("index").agg({"dist": "mean"})
-        stepped_iso["geometry"] = polygons
-        stepped_iso = gpd.GeoDataFrame(stepped_iso, geometry="geometry", crs=local_crs).reset_index(drop=True)
+        stepped_iso = create_separated_dist_polygons(nodes, weight_value, weight_type, step, speed)
     else:
         if isochrone_type == "radius":
             isochrone_geoms = _build_radius_isochrones(

{objectnat-1.0.1 → objectnat-1.1.0}/src/objectnat/methods/noise/noise_sim.py RENAMED Viewed

@@ -22,26 +22,33 @@ from objectnat.methods.visibility.visibility_analysis import get_visibility_accu
 logger = config.logger
+MAX_DB_VALUE = 194
 def simulate_noise(
-    source_points: gpd.GeoDataFrame, obstacles: gpd.GeoDataFrame, source_noise_db, geometric_mean_freq_hz, **kwargs
+    source_points: gpd.GeoDataFrame,
+    obstacles: gpd.GeoDataFrame,
+    source_noise_db: float = None,
+    geometric_mean_freq_hz: float = None,
+    **kwargs,
 ):
     """
     Simulates noise propagation from a set of source points considering obstacles, trees, and environmental factors.
     Args:
-        source_points (gpd.GeoDataFrame): A GeoDataFrame containing one or more points representing the noise sources.
-            A separate simulation will be run for each point.
+         source_points (gpd.GeoDataFrame): A GeoDataFrame with one or more point geometries representing noise sources.
+            Optionally, it can include 'source_noise_db' and 'geometric_mean_freq_hz' columns for per-point simulation.
         obstacles (gpd.GeoDataFrame): A GeoDataFrame representing obstacles in the environment. If a column with
             sound absorption coefficients is present, its name should be provided in the `absorb_ratio_column` argument.
             Missing values will be filled with the `standart_absorb_ratio`.
-        source_noise_db (float): The noise level of the point source in decibels (dB). Decibels are logarithmic units
-            used to measure sound intensity. A value of 20 dB represents a barely audible whisper, while 140 dB
-            is comparable to the noise of jet engines.
-        geometric_mean_freq_hz (float): The geometric mean frequency of the sound (in Hz). This parameter influences
-            the sound wave's propagation and scattering in the presence of trees. Lower frequencies travel longer
-            distances than higher frequencies. It's recommended to use values between 63 Hz and 8000 Hz; values outside
-            this range will be clamped to the nearest boundary for the sound absorption coefficient calculation.
+        source_noise_db  (float, optional): Default noise level (dB) to use if not specified per-point. Decibels are
+            logarithmic units used to measure sound intensity. A value of 20 dB represents a barely audible whisper,
+            while 140 dB is comparable to the noise of jet engines.
+        geometric_mean_freq_hz (float, optional):  Default frequency (Hz) to use if not specified per-point.
+            This parameter influences the sound wave's propagation and scattering in the presence of trees.
+            Lower frequencies travel longer distances than higher frequencies.
+            It's recommended to use values between 63 Hz and 8000 Hz; values outside this range will be clamped to the
+            nearest boundary for the sound absorption coefficient calculation.
     Optional kwargs:
         absorb_ratio_column (str, optional): The name of the column in the `obstacles` GeoDataFrame that contains the
@@ -88,12 +95,40 @@ def simulate_noise(
     reflection_n = kwargs.get("reflection_n", 3)
     dead_area_r = kwargs.get("dead_area_r", 5)
+    # Validate optional columns or default values
+    use_column_db = False
+    if "source_noise_db" in source_points.columns:
+        if (source_points["source_noise_db"] > MAX_DB_VALUE).any():
+            raise ValueError(
+                f"One or more values in 'source_noise_db' column exceed the physical limit of {MAX_DB_VALUE} dB."
+            )
+        use_column_db = True
+    use_column_freq = "geometric_mean_freq_hz" in source_points.columns
+    if not use_column_db:
+        if source_noise_db is None:
+            raise ValueError(
+                "Either `source_noise_db` must be provided or the `source_points` must contain a 'source_noise_db' column."
+            )
+        if source_noise_db > MAX_DB_VALUE:
+            raise ValueError(
+                f"source_noise_db ({source_noise_db} dB) exceeds the physical limit of {MAX_DB_VALUE} dB in air."
+            )
+    if not use_column_freq:
+        if geometric_mean_freq_hz is None:
+            raise ValueError(
+                "Either `geometric_mean_freq_hz` must be provided or the `source_points` must contain a 'geometric_mean_freq_hz' column."
+            )
+    if not use_column_db and not use_column_freq and len(source_points) > 1:
+        logger.warning(
+            "`source_noise_db` and `geometric_mean_freq_hz` will be used for all points. Per-point simulation parameters not found."
+        )
     original_crs = source_points.crs
+    source_points = source_points.copy()
-    div_ = (source_noise_db - target_noise_db) % db_sim_step
-    if div_ != 0:
-        raise InvalidStepError(source_noise_db, target_noise_db, db_sim_step, div_)
-    # Choosing crs and simplifying obs if any
     source_points = source_points.copy()
     if len(obstacles) > 0:
         obstacles = obstacles.copy()
@@ -118,63 +153,54 @@ def simulate_noise(
     if absorb_ratio_column is None:
         obstacles["absorb_ratio"] = standart_absorb_ratio
     else:
-        obstacles["absorb_ratio"] = obstacles[absorb_ratio_column]
-        obstacles["absorb_ratio"] = obstacles["absorb_ratio"].fillna(standart_absorb_ratio)
+        obstacles["absorb_ratio"] = obstacles[absorb_ratio_column].fillna(standart_absorb_ratio)
     obstacles = obstacles[["absorb_ratio", "geometry"]]
-    logger.info(
-        dist_to_target_db(
-            source_noise_db,
-            target_noise_db,
-            geometric_mean_freq_hz,
-            air_temperature,
-            return_desc=True,
-            check_temp_freq=True,
-        )
-    )
-    # calculating layer dist and db values
-    dist_db = [(0, source_noise_db)]
-    cur_db = source_noise_db - db_sim_step
-    while cur_db != target_noise_db - db_sim_step:
-        max_dist = dist_to_target_db(source_noise_db, cur_db, geometric_mean_freq_hz, air_temperature)
-        dist_db.append((max_dist, cur_db))
-        cur_db = cur_db - db_sim_step
     # creating initial task and simulating for each point
-    all_p_res = []
+    task_queue = multiprocessing.Queue()
+    dead_area_dict = {}
     for ind, row in source_points.iterrows():
-        logger.info(f"Started simulation for point {ind+1} / {len(source_points)}")
         source_point = row.geometry
-        task_queue = multiprocessing.Queue()
+        local_db = row["source_noise_db"] if use_column_db else source_noise_db
+        local_freq = row["geometric_mean_freq_hz"] if use_column_freq else geometric_mean_freq_hz
+        div_ = (local_db - target_noise_db) % db_sim_step
+        if div_ != 0:
+            raise InvalidStepError(local_db, target_noise_db, db_sim_step, div_)
+        # calculating layer dist and db values
+        dist_db = [(0, local_db)]
+        cur_db = local_db - db_sim_step
+        while cur_db != target_noise_db - db_sim_step:
+            max_dist = dist_to_target_db(local_db, cur_db, local_freq, air_temperature)
+            dist_db.append((max_dist, cur_db))
+            cur_db -= db_sim_step
         args = (source_point, obstacles, trees, 0, 0, dist_db)
         kwargs = {
             "reflection_n": reflection_n,
-            "geometric_mean_freq_hz": geometric_mean_freq_hz,
+            "geometric_mean_freq_hz": local_freq,
             "tree_res": tree_res,
             "min_db": target_noise_db,
+            "simulation_ind": ind,
         }
         task_queue.put((_noise_from_point_task, args, kwargs))
+        dead_area_dict[ind] = source_point.buffer(dead_area_r, resolution=2)
-        noise_gdf = _parallel_split_queue(
-            task_queue, dead_area=source_point.buffer(dead_area_r, resolution=2), dead_area_r=dead_area_r
-        )
+    noise_gdf = _parallel_split_queue(task_queue, dead_area_dict=dead_area_dict, dead_area_r=dead_area_r)
-        noise_gdf = gpd.GeoDataFrame(pd.concat(noise_gdf, ignore_index=True), crs=local_crs)
-        polygons = gpd.GeoDataFrame(
-            geometry=list(polygonize(noise_gdf.geometry.apply(polygons_to_multilinestring).union_all())), crs=local_crs
-        )
-        polygons_points = polygons.copy()
-        polygons_points.geometry = polygons.representative_point()
-        sim_result = polygons_points.sjoin(noise_gdf, predicate="within").reset_index()
-        sim_result = sim_result.groupby("index").agg({"noise_level": "max"})
-        sim_result["geometry"] = polygons
-        sim_result = (
-            gpd.GeoDataFrame(sim_result, geometry="geometry", crs=local_crs).dissolve(by="noise_level").reset_index()
-        )
-        sim_result["source_point_ind"] = ind
-        all_p_res.append(sim_result)
+    noise_gdf = gpd.GeoDataFrame(pd.concat(noise_gdf, ignore_index=True), crs=local_crs)
+    polygons = gpd.GeoDataFrame(
+        geometry=list(polygonize(noise_gdf.geometry.apply(polygons_to_multilinestring).union_all())), crs=local_crs
+    )
+    polygons_points = polygons.copy()
+    polygons_points.geometry = polygons.representative_point()
+    sim_result = polygons_points.sjoin(noise_gdf, predicate="within").reset_index()
+    sim_result = sim_result.groupby("index").agg({"noise_level": "max"})
+    sim_result["geometry"] = polygons
+    sim_result = (
+        gpd.GeoDataFrame(sim_result, geometry="geometry", crs=local_crs).dissolve(by="noise_level").reset_index()
+    )
-    return gpd.GeoDataFrame(pd.concat(all_p_res, ignore_index=True), crs=local_crs).to_crs(original_crs)
+    return sim_result.to_crs(original_crs)
 def _noise_from_point_task(task, **kwargs) -> tuple[gpd.GeoDataFrame, list[tuple] | None]:  # pragma: no cover
@@ -383,34 +409,34 @@ def _noise_from_point_task(task, **kwargs) -> tuple[gpd.GeoDataFrame, list[tuple
     return noise_from_point, new_tasks
-def _parallel_split_queue(task_queue: multiprocessing.Queue, dead_area: Polygon, dead_area_r: int):
+def _parallel_split_queue(task_queue: multiprocessing.Queue, dead_area_dict: dict, dead_area_r: int):
     results = []
     total_tasks = task_queue.qsize()
     with tqdm(total=total_tasks, desc="Simulating noise") as pbar:
         with concurrent.futures.ProcessPoolExecutor() as executor:
+            # with concurrent.futures.ThreadPoolExecutor() as executor:
             future_to_task = {}
             while True:
                 while not task_queue.empty() and len(future_to_task) < executor._max_workers:
                     func, task, kwargs = task_queue.get_nowait()
                     future = executor.submit(func, task, **kwargs)
-                    future_to_task[future] = task
+                    future_to_task[future] = kwargs["simulation_ind"]
                 done, _ = concurrent.futures.wait(future_to_task.keys(), return_when=concurrent.futures.FIRST_COMPLETED)
                 for future in done:
-                    future_to_task.pop(future)
+                    simulation_ind = future_to_task.pop(future)
                     result, new_tasks = future.result()
                     if new_tasks:
                         new_tasks_n = 0
-                        new_dead_area_points = [dead_area]
-                        for func, new_task, kwargs in new_tasks:
-                            if not dead_area.covers(new_task[0]):
-                                new_tasks_n = new_tasks_n + 1
-                                task_queue.put((func, new_task, kwargs))
-                                new_dead_area_points.append(new_task[0].buffer(dead_area_r, resolution=2))
-                        dead_area = unary_union(new_dead_area_points)
+                        local_dead_area = dead_area_dict.get(simulation_ind)
+                        new_dead_area_points = [local_dead_area]
+                        for func, new_task, new_kwargs in new_tasks:
+                            new_point = new_task[0]
+                            if not local_dead_area.covers(new_point):
+                                task_queue.put((func, new_task, new_kwargs))
+                                new_dead_area_points.append(new_point.buffer(dead_area_r, resolution=2))
+                                new_tasks_n += 1
+                        dead_area_dict[simulation_ind] = unary_union(new_dead_area_points)
                         total_tasks += new_tasks_n
                         pbar.total = total_tasks
                         pbar.refresh()
@@ -419,5 +445,4 @@ def _parallel_split_queue(task_queue: multiprocessing.Queue, dead_area: Polygon,
                 time.sleep(0.01)
                 if not future_to_task and task_queue.empty():
                     break
     return results

{objectnat-1.0.1 → objectnat-1.1.0}/src/objectnat/methods/utils/graph_utils.py RENAMED Viewed

@@ -90,6 +90,28 @@ def graph_to_gdf(
 def get_closest_nodes_from_gdf(gdf: gpd.GeoDataFrame, nx_graph: nx.Graph) -> tuple:
+    """
+    Finds the closest graph nodes to the geometries in a GeoDataFrame.
+    Parameters
+    ----------
+    gdf : gpd.GeoDataFrame
+        GeoDataFrame with geometries for which the nearest graph nodes will be found.
+    nx_graph : nx.Graph
+        A NetworkX graph where nodes have 'x' and 'y' attributes (coordinates).
+    Returns
+    -------
+    tuple
+        A tuple of (distances, nearest_nodes), where:
+        - distances: List of distances from each geometry to the nearest node.
+        - nearest_nodes: List of node IDs closest to each geometry in the input GeoDataFrame.
+    Raises
+    ------
+    ValueError
+        If any node in the graph is missing 'x' or 'y' attributes.
+    """
     nodes_with_data = list(nx_graph.nodes(data=True))
     try:
         coordinates = np.array([(data["x"], data["y"]) for node, data in nodes_with_data])
@@ -103,6 +125,24 @@ def get_closest_nodes_from_gdf(gdf: gpd.GeoDataFrame, nx_graph: nx.Graph) -> tup
 def remove_weakly_connected_nodes(graph: nx.DiGraph) -> nx.DiGraph:
+    """
+    Removes all nodes that are not part of the largest strongly connected component in the graph.
+    Parameters
+    ----------
+    graph : nx.DiGraph
+        A directed NetworkX graph.
+    Returns
+    -------
+    nx.DiGraph
+        A new graph with only the largest strongly connected component retained.
+    Notes
+    -----
+    - Also logs a warning if multiple weakly connected components are detected.
+    - Logs the number of nodes removed and size of the remaining component.
+    """
     graph = graph.copy()
     weakly_connected_components = list(nx.weakly_connected_components(graph))
@@ -125,3 +165,42 @@ def remove_weakly_connected_nodes(graph: nx.DiGraph) -> nx.DiGraph:
         graph.remove_nodes_from(nodes_to_del)
     return graph
+def reverse_graph(nx_graph: nx.Graph, weight: str) -> tuple[nx.Graph, nx.DiGraph]:
+    """
+    Generate a reversed version of a directed or weighted graph.
+    If the input graph is undirected, the original graph is returned as-is.
+    For directed graphs, the function returns a new graph with all edge directions reversed,
+    preserving the specified edge weight.
+    Parameters
+    ----------
+    nx_graph : nx.Graph
+        Input NetworkX graph (can be directed or undirected).
+    weight : str
+        Name of the edge attribute to use as weight in graph conversion.
+    Returns
+    -------
+    tuple[nx.Graph, nx.DiGraph]
+        A tuple containing:
+        - normalized_graph: Original graph with relabeled nodes (if needed)
+        - reversed_graph: Directed graph with reversed edges and preserved weights
+    """
+    if nx_graph.is_multigraph():
+        nx_graph = nx.DiGraph(nx_graph) if nx_graph.is_directed() else nx.Graph(nx_graph)
+    if not nx_graph.is_multigraph() and not nx_graph.is_directed():
+        return nx_graph, nx_graph
+    nx_graph = remove_weakly_connected_nodes(nx_graph)
+    mapping = {old_label: new_label for new_label, old_label in enumerate(nx_graph.nodes())}
+    nx_graph = nx.relabel_nodes(nx_graph, mapping)
+    sparse_matrix = nx.to_scipy_sparse_array(nx_graph, weight=weight)
+    transposed_matrix = sparse_matrix.transpose()
+    reversed_graph = nx.from_scipy_sparse_array(transposed_matrix, edge_attribute=weight, create_using=type(nx_graph))
+    return nx_graph, reversed_graph