ObjectNat 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

objectnat/_api.py

@@ -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/_version.py

@@ -1 +1 @@
-VERSION = "1.0.0"
+VERSION = "1.1.0"

objectnat/methods/coverage_zones/__init__.py

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

objectnat/methods/coverage_zones/graph_coverage.py

@@ -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/methods/coverage_zones/stepped_coverage.py

@@ -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/methods/isochrones/isochrone_utils.py

@@ -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
@@ -74,11 +76,11 @@ def _process_pt_data(
     nodes: gpd.GeoDataFrame, edges: gpd.GeoDataFrame, graph_type: str
 ) -> tuple[gpd.GeoDataFrame, gpd.GeoDataFrame] | tuple[None, None]:
     """Process public transport data if available."""
-    if "desc" in nodes.columns and "stop" in nodes["desc"].unique():
-        pt_nodes = nodes[nodes["desc"] == "stop"]
+    if "type" in nodes.columns and "platform" in nodes["type"].unique():
+        pt_nodes = nodes[(nodes["type"] != "platform") & (~nodes["type"].isna())]
         if graph_type == "intermodal":
             edges = edges[~edges["type"].isin(["walk", "boarding"])]
-        pt_nodes = pt_nodes[["desc", "route", "geometry"]]
+        pt_nodes = pt_nodes[["type", "route", "geometry"]]
         edges = edges[["type", "route", "geometry"]]
         return pt_nodes, edges
     return None, None
@@ -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/methods/isochrones/isochrones.py

@@ -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/methods/noise/noise_sim.py

@@ -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/methods/utils/graph_utils.py

@@ -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

{objectnat-1.0.0.dist-info → objectnat-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ObjectNat
-Version: 1.0.0
+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,11 +12,11 @@ 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)
 Requires-Dist: pandas (>=2.2.0,<3.0.0)
-Requires-Dist: pytest (>=8.3.5,<9.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
@@ -45,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)
@@ -70,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.
@@ -85,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>
 
@@ -94,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>
 
 
@@ -105,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.0.dist-info → objectnat-1.1.0.dist-info}/RECORD

@@ -1,19 +1,20 @@
 objectnat/__init__.py,sha256=OnDvrLPLEeYIE_9qOVYgMc-PkRzIqShtGxirguEXiRU,260
-objectnat/_api.py,sha256=5TvsMjWjiR7kFIWnfRJxngWOrC_eKQ7Pt-TSMpjqzI0,595
+objectnat/_api.py,sha256=aTUevxMYHWnRxQhoLNkV80OrlRQmtkW8d0bh6jURRa4,623
 objectnat/_config.py,sha256=fGPsMZqA8FVBBOINxRiTFkOOZsNLyablM5G0tdKeQB4,1306
-objectnat/_version.py,sha256=lzGFsymf0DtA_1oAZcPbeQ557iY-1BRkekhfA2qaFh8,18
+objectnat/_version.py,sha256=DFGnvNkISEu0RDsAfc03O0dRz9PfmIb63Kyi-am-trE,18
 objectnat/methods/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-objectnat/methods/coverage_zones/__init__.py,sha256=cdXjW041ysfIlr4sGQ_Xa2nok4tHfMJTEf8pem-0m-U,95
-objectnat/methods/coverage_zones/graph_coverage.py,sha256=3nVZekDAmbz2ZzxsayX9KIgudlSZF3OnZ9g5kFmVt8o,4797
-objectnat/methods/coverage_zones/radius_voronoi.py,sha256=H4_lvSc770TO6-xq6EzgWuUf00N5vYCMO3X6UJhZYAQ,1735
+objectnat/methods/coverage_zones/__init__.py,sha256=3uTDC1xf3zgQRqSQR4URp__HjZ8eVUtjK8r3mGq-zuQ,161
+objectnat/methods/coverage_zones/graph_coverage.py,sha256=iYI2huF9jLPPlISeh7R05ZaaWZ7s8ZBPGIk1WUeM-EI,4355
+objectnat/methods/coverage_zones/radius_voronoi_coverage.py,sha256=H4_lvSc770TO6-xq6EzgWuUf00N5vYCMO3X6UJhZYAQ,1735
+objectnat/methods/coverage_zones/stepped_coverage.py,sha256=dgNDHh2nG2zXcLHOIJZyZGVgcKnoxtu5iP1_aHdOYNM,5951
 objectnat/methods/isochrones/__init__.py,sha256=bDfUZPbS3_PuTEB2QcRTYjvyJtUvjbDhAw6QJvD_ih4,90
-objectnat/methods/isochrones/isochrone_utils.py,sha256=KubqeysYetj1dbWJ_WGrewfM_jWYmRFjj8AWz8aEc1I,4825
-objectnat/methods/isochrones/isochrones.py,sha256=GoaFGiLSsG-RRXA5jtij3zsrwxH5ThKDh8XexZ3rD3k,14046
+objectnat/methods/isochrones/isochrone_utils.py,sha256=dJwvoGXUypwU2_oF-rdxNZm90gOi-RUp_0WM1C2HaPU,6870
+objectnat/methods/isochrones/isochrones.py,sha256=TceEQ8xJ-KZR29fAZ1v9gLl42iN2vvDmoOIi1VkvQd4,12625
 objectnat/methods/noise/__init__.py,sha256=6JV586JdOqE0OUFUyxsrCoGuDxRuB-6ItSA5CRuFdsE,152
 objectnat/methods/noise/noise_exceptions.py,sha256=nTav5kp6RNpi0kxD9cMULTApOuvAu9wEiX28fkLAnOc,634
 objectnat/methods/noise/noise_init_data.py,sha256=Vp-R_yH7CgYqZEtbGAdr1iiIbgauReniLQ_a2TcszhY,503
 objectnat/methods/noise/noise_reduce.py,sha256=B85ifAN_mHiBKJso-cZiSkj7588w2sA-ugGvEal4CBw,6885
-objectnat/methods/noise/noise_sim.py,sha256=qb0C2CD-sIEcdUWO3xSwCGjuR94xPgU81FC94TeXHBo,20278
+objectnat/methods/noise/noise_sim.py,sha256=6R6TsrIkUWb5qglAWejR6yCbjqSHOydnKc0pblW9UNU,21716
 objectnat/methods/point_clustering/__init__.py,sha256=pX2qDUCvs9LJI36mr65vbdRml6AE8hIYYxIJLdQZQxs,61
 objectnat/methods/point_clustering/cluster_points_in_polygons.py,sha256=kwiZHY3TCUCE-nN5IdhCwDESWJvSCZUfrUJU3yC1csc,5042
 objectnat/methods/provision/__init__.py,sha256=0Uy66n2xH0Y45JyhIYHEVfC2rig6bMYp6PV2KkNhbK8,80
@@ -22,11 +23,11 @@ objectnat/methods/provision/provision_exceptions.py,sha256=lznEmlmZDzGIOtapZVqZD
 objectnat/methods/provision/provision_model.py,sha256=_IKS3pe_i7gLcA56baB0g3mH77T9pPP_4FzjuK_FZ5Y,14529
 objectnat/methods/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 objectnat/methods/utils/geom_utils.py,sha256=6tt7gKztDYOTqaZ1sLO4vN2sNPV9qeFyKK1BbvwwD18,4582
-objectnat/methods/utils/graph_utils.py,sha256=M983Hy1CXRIGg_q71tW0HVB8ZS4ZpDK5I2J3imyznUQ,4799
+objectnat/methods/utils/graph_utils.py,sha256=-72BWU7gi-5scOKOjx94a7Aseum6gLvznborP7rYkLw,7534
 objectnat/methods/utils/math_utils.py,sha256=Vc8U15LtFOwgIt1YSOSKWYOIiW_1XLuMGOa6ejBpEUk,839
 objectnat/methods/visibility/__init__.py,sha256=Mx1kaoV-yfQUxlMkgNF4AhjSweFEJMEx3NBis5OM3mA,161
 objectnat/methods/visibility/visibility_analysis.py,sha256=fDIZ5S7oR-5ZEsjZPFexb7oFw-1X6uj0A4xuP3pX354,21183
-objectnat-1.0.0.dist-info/LICENSE.txt,sha256=yPEioMfTd7JAQgAU6J13inS1BSjwd82HFlRSoIb4My8,1498
-objectnat-1.0.0.dist-info/METADATA,sha256=ybm0Wwz002c0AWq9qJw6g6ZTveQB4yZJLekYC3kB70I,8079
-objectnat-1.0.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-objectnat-1.0.0.dist-info/RECORD,,
+objectnat-1.1.0.dist-info/LICENSE.txt,sha256=yPEioMfTd7JAQgAU6J13inS1BSjwd82HFlRSoIb4My8,1498
+objectnat-1.1.0.dist-info/METADATA,sha256=qJyn7mHu--UnDLqGd8WOUV9xqEA573hWub5FsHjNB_Y,8881
+objectnat-1.1.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+objectnat-1.1.0.dist-info/RECORD,,