ObjectNat 1.0.1__py3-none-any.whl → 1.2.0__py3-none-any.whl

objectnat/_api.py

@@ -1,10 +1,11 @@
 # 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.noise import calculate_simplified_noise_frame, simulate_noise
 from .methods.point_clustering import get_clusters_polygon
 from .methods.provision import clip_provision, get_service_provision, recalculate_links
+from .methods.utils import gdf_to_graph, graph_to_gdf
 from .methods.visibility import (
     calculate_visibility_catchment_area,
     get_visibilities_from_points,

objectnat/_version.py

@@ -1 +1 @@
-VERSION = "1.0.1"
+VERSION = "1.2.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
@@ -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/__init__.py

@@ -1,3 +1,4 @@
-from .noise_sim import simulate_noise
+from .noise_simulation import simulate_noise
 from .noise_reduce import dist_to_target_db, green_noise_reduce_db
 from .noise_exceptions import InvalidStepError
+from .noise_simulation_simplified import calculate_simplified_noise_frame

objectnat/methods/noise/{noise_sim.py → noise_simulation.py}

@@ -13,6 +13,7 @@ from tqdm import tqdm
 from objectnat import config
 from objectnat.methods.noise.noise_exceptions import InvalidStepError
 from objectnat.methods.noise.noise_reduce import dist_to_target_db, green_noise_reduce_db
+from objectnat.methods.noise.noise_simulation_simplified import _eval_donuts_gdf
 from objectnat.methods.utils.geom_utils import (
     gdf_to_circle_zones_from_point,
     get_point_from_a_thorough_b,
@@ -22,26 +23,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 +96,46 @@ 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."
+            )
+        if source_points["source_noise_db"].isnull().any():
+            raise ValueError(f"Column 'source_noise_db' contains missing (NaN) values")
+        use_column_db = True
+
+    use_column_freq = False
+    if "geometric_mean_freq_hz" in source_points.columns:
+        if source_points["geometric_mean_freq_hz"].isnull().any():
+            raise ValueError(f"Column 'geometric_mean_freq_hz' contains missing (NaN) values")
+        use_column_freq = True
+
+    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 +160,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
@@ -272,22 +305,7 @@ def _noise_from_point_task(task, **kwargs) -> tuple[gpd.GeoDataFrame, list[tuple
                     noise_reduce = int(round(green_noise_reduce_db(geometric_mean_freq_hz, r_tree_new)))
                     reduce_polygons.append((red_polygon, noise_reduce))
 
-    # Generating donuts - db values
-    donuts = []
-    don_values = []
-    to_cut_off = point_from
-    for i in range(len(donuts_dist_values[:-1])):
-        cur_buffer = point_from.buffer(donuts_dist_values[i + 1][0])
-        donuts.append(cur_buffer.difference(to_cut_off))
-        don_values.append(donuts_dist_values[i][1])
-        to_cut_off = cur_buffer
-
-    noise_from_point = (
-        gpd.GeoDataFrame(geometry=donuts, data={"noise_level": don_values}, crs=local_crs)
-        .clip(vis_poly, keep_geom_type=True)
-        .explode(ignore_index=True)
-    )
-
+    noise_from_point = _eval_donuts_gdf(point_from, donuts_dist_values, local_crs, vis_poly)
     # intersect noise poly with noise reduce
     if len(reduce_polygons) > 0:
         reduce_polygons = gpd.GeoDataFrame(
@@ -383,34 +401,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 +437,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/noise/noise_simulation_simplified.py

@@ -0,0 +1,135 @@
+# simplified version
+import geopandas as gpd
+import pandas as pd
+from shapely.ops import polygonize, unary_union
+
+from objectnat.methods.noise.noise_reduce import dist_to_target_db
+from objectnat.methods.utils.geom_utils import (
+    distribute_points_on_linestrings,
+    distribute_points_on_polygons,
+    polygons_to_multilinestring,
+)
+from objectnat.methods.visibility.visibility_analysis import get_visibility_accurate
+
+MAX_DB_VALUE = 194
+
+
+def calculate_simplified_noise_frame(
+    noise_sources: gpd.GeoDataFrame, obstacles: gpd.GeoDataFrame, air_temperature, **kwargs
+) -> gpd.GeoDataFrame:
+    target_noise_db = kwargs.get("target_noise_db", 40)
+    db_sim_step = kwargs.get("db_sim_step", 5)
+    linestring_point_radius = kwargs.get("linestring_point_radius", 20)
+    polygon_point_radius = kwargs.get("polygon_point_radius", 10)
+
+    required_columns = ["source_noise_db", "geometric_mean_freq_hz"]
+    for col in required_columns:
+        if col not in noise_sources.columns:
+            raise ValueError(f"'{col}' column is missing in provided GeoDataFrame")
+        if noise_sources[col].isnull().any():
+            raise ValueError(f"Column '{col}' contains missing (NaN) values")
+    if (noise_sources["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."
+        )
+    original_crs = noise_sources.crs
+    if len(obstacles) > 0:
+        obstacles = obstacles.copy()
+        obstacles.geometry = obstacles.geometry.simplify(tolerance=1)
+        local_crs = obstacles.estimate_utm_crs()
+        obstacles.to_crs(local_crs, inplace=True)
+        noise_sources.to_crs(local_crs, inplace=True)
+    else:
+        local_crs = noise_sources.estimate_utm_crs()
+        noise_sources.to_crs(local_crs, inplace=True)
+        noise_sources.reset_index(drop=True)
+
+    noise_sources = noise_sources.explode(ignore_index=True)
+    noise_sources["geom_type"] = noise_sources.geom_type
+
+    grouped_sources = noise_sources.groupby(by=["source_noise_db", "geometric_mean_freq_hz", "geom_type"])
+
+    frame_result = []
+
+    for (source_db, freq_hz, geom_type), group_gdf in grouped_sources:
+        # calculating layer dist and db values
+        dist_db = [(0, source_db)]
+        cur_db = source_db - db_sim_step
+        max_dist = 0
+        while cur_db > target_noise_db - db_sim_step:
+            if cur_db - db_sim_step < target_noise_db:
+                cur_db = target_noise_db
+            max_dist = dist_to_target_db(source_db, cur_db, freq_hz, air_temperature)
+            dist_db.append((max_dist, cur_db))
+            cur_db -= db_sim_step
+
+        if geom_type == "Point":
+            for _, row in group_gdf.iterrows():
+                point_from = row.geometry
+                point_buffer = point_from.buffer(max_dist, resolution=16)
+                local_obstacles = obstacles[obstacles.intersects(point_buffer)]
+                vis_poly = get_visibility_accurate(point_from, obstacles=local_obstacles, view_distance=max_dist)
+                noise_from_feature = _eval_donuts_gdf(point_from, dist_db, local_crs, vis_poly)
+                frame_result.append(noise_from_feature)
+
+        elif geom_type == "LineString":
+            layer_points = distribute_points_on_linestrings(group_gdf, radius=linestring_point_radius, lloyd_relax_n=1)
+            noise_from_feature = _process_lines_or_polygons(
+                group_gdf, max_dist, obstacles, layer_points, dist_db, local_crs
+            )
+            frame_result.append(noise_from_feature)
+        elif geom_type == "Polygon":
+            group_gdf.geometry = group_gdf.buffer(0.1, resolution=1)
+            layer_points = distribute_points_on_polygons(
+                group_gdf, only_exterior=False, radius=polygon_point_radius, lloyd_relax_n=1
+            )
+            noise_from_feature = _process_lines_or_polygons(
+                group_gdf, max_dist, obstacles, layer_points, dist_db, local_crs
+            )
+            frame_result.append(noise_from_feature)
+        else:
+            pass
+
+    noise_gdf = gpd.GeoDataFrame(pd.concat(frame_result, 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 sim_result.to_crs(original_crs)
+
+
+def _process_lines_or_polygons(group_gdf, max_dist, obstacles, layer_points, dist_db, local_crs) -> gpd.GeoDataFrame:
+    features_vision_polys = []
+    layer_buffer = group_gdf.buffer(max_dist, resolution=16).union_all()
+    local_obstacles = obstacles[obstacles.intersects(layer_buffer)]
+    for _, row in layer_points.iterrows():
+        point_from = row.geometry
+        vis_poly = get_visibility_accurate(point_from, obstacles=local_obstacles, view_distance=max_dist)
+        features_vision_polys.append(vis_poly)
+    features_vision_polys = unary_union(features_vision_polys)
+    return _eval_donuts_gdf(group_gdf.union_all(), dist_db, local_crs, features_vision_polys)
+
+
+def _eval_donuts_gdf(initial_geometry, dist_db, local_crs, clip_poly) -> gpd.GeoDataFrame:
+    donuts = []
+    don_values = []
+    to_cut_off = initial_geometry
+    for i in range(len(dist_db[:-1])):
+        cur_buffer = initial_geometry.buffer(dist_db[i + 1][0])
+        donuts.append(cur_buffer.difference(to_cut_off))
+        don_values.append(dist_db[i][1])
+        to_cut_off = cur_buffer
+    noise_from_feature = (
+        gpd.GeoDataFrame(geometry=donuts, data={"noise_level": don_values}, crs=local_crs)
+        .clip(clip_poly, keep_geom_type=True)
+        .explode(ignore_index=True)
+    )
+    return noise_from_feature

objectnat/methods/utils/__init__.py

@@ -0,0 +1 @@
+from .graph_utils import gdf_to_graph, graph_to_gdf

objectnat/methods/utils/geom_utils.py

@@ -15,9 +15,9 @@ def polygons_to_multilinestring(geom: Polygon | MultiPolygon):
 
     def convert_polygon(polygon: Polygon):
         lines = []
-        exterior = LineString(polygon.exterior.coords)
+        exterior = LineString(polygon.exterior)
         lines.append(exterior)
-        interior = [LineString(p.coords) for p in polygon.interiors]
+        interior = [LineString(p) for p in polygon.interiors]
         lines = lines + interior
         return lines
 
@@ -128,3 +128,46 @@ def combine_geometry(gdf: gpd.GeoDataFrame) -> gpd.GeoDataFrame:
     joined["geometry"] = enclosures
     joined = gpd.GeoDataFrame(joined, geometry="geometry", crs=crs)
     return joined
+
+
+def distribute_points_on_linestrings(lines: gpd.GeoDataFrame, radius, lloyd_relax_n=2) -> gpd.GeoDataFrame:
+    lines = lines.copy()
+    lines = lines.explode(ignore_index=True)
+    lines = lines[lines.geom_type == "LineString"]
+    original_crs = lines.crs
+    lines = lines.to_crs(crs=lines.estimate_utm_crs())
+    lines = lines.reset_index(drop=True)
+    lines = lines[["geometry"]]
+    radius = radius * 1.1
+    segmentized = lines.geometry.apply(lambda x: x.simplify(radius).segmentize(radius))
+    points = [Point(pt) for line in segmentized for pt in line.coords]
+
+    points = gpd.GeoDataFrame(geometry=points, crs=lines.crs)
+    lines["lines"] = lines.geometry
+    geom_concave = lines.buffer(5, resolution=1).union_all()
+
+    for i in range(lloyd_relax_n):
+        points.geometry = points.voronoi_polygons().clip(geom_concave).centroid
+        points = points.sjoin_nearest(lines, how="left")
+        points = points[~points.index.duplicated(keep="first")]
+        points["geometry"] = points["lines"].interpolate(points["lines"].project(points.geometry))
+        points.drop(columns=["lines", "index_right"], inplace=True)
+
+    return points.dropna().to_crs(original_crs)
+
+
+def distribute_points_on_polygons(
+    polygons: gpd.GeoDataFrame, radius, only_exterior=True, lloyd_relax_n=2
+) -> gpd.GeoDataFrame:
+    polygons = polygons.copy()
+    polygons = polygons.explode(ignore_index=True)
+    polygons = polygons[polygons.geom_type == "Polygon"]
+
+    if only_exterior:
+        polygons.geometry = polygons.geometry.apply(lambda x: LineString(x.exterior))
+    else:
+        polygons = gpd.GeoDataFrame(
+            geometry=list(polygons.geometry.apply(polygons_to_multilinestring)), crs=polygons.crs
+        )
+
+    return distribute_points_on_linestrings(polygons, radius, lloyd_relax_n=lloyd_relax_n)

objectnat/methods/utils/graph_utils.py

@@ -4,7 +4,7 @@ import numpy as np
 import pandas as pd
 from loguru import logger
 from scipy.spatial import KDTree
-from shapely import LineString
+from shapely import LineString, MultiLineString, line_merge, node
 from shapely.geometry.point import Point
 
 
@@ -89,7 +89,143 @@ def graph_to_gdf(
     return nodes_gdf, edges_gdf
 
 
+def gdf_to_graph(
+    gdf: gpd.GeoDataFrame, project_gdf_attr=True, reproject_to_utm_crs=True, speed=5, check_intersections=True
+) -> nx.DiGraph:
+    """
+    Converts a GeoDataFrame of LineStrings into a directed graph (nx.DiGraph).
+
+    This function transforms a set of linear geometries (which may or may not form a planar graph)
+    into a directed graph where each edge corresponds to a LineString (or its segment) from the GeoDataFrame.
+    Intersections are optionally checked and merged. Attributes from the original GeoDataFrame
+    can be projected onto the graph edges using spatial matching.
+
+    Parameters
+    ----------
+    gdf : gpd.GeoDataFrame
+        A GeoDataFrame containing at least one LineString geometry.
+    project_gdf_attr : bool, default=True
+        If True, attributes from the input GeoDataFrame will be spatially projected
+        onto the resulting graph edges. This can be an expensive operation for large datasets.
+    reproject_to_utm_crs : bool, default=True
+        If True, reprojects the GeoDataFrame to the estimated local UTM CRS
+        to ensure accurate edge length calculations in meters.
+        If False, edge lengths are still computed in UTM CRS, but the final graph
+        will remain in the original CRS of the input GeoDataFrame.
+    speed : float, default=5
+        Assumed travel speed in km/h used to compute edge traversal time (in minutes).
+    check_intersections : bool, default=True
+        If True, merges geometries to ensure topological correctness.
+        Can be disabled if the input geometries already form a proper planar graph
+        with no unintended intersections.
+
+    Returns
+    -------
+    nx.DiGraph
+        A directed graph where each edge corresponds to a line segment from the input GeoDataFrame.
+        Edge attributes include geometry, length in meters, travel time (in minutes), and any
+        additional projected attributes from the original GeoDataFrame.
+
+    Raises
+    ------
+    ValueError
+        If the input GeoDataFrame contains no valid LineStrings.
+    """
+
+    def unique_list(agg_vals):
+        agg_vals = list(set(agg_vals.dropna()))
+        if len(agg_vals) == 1:
+            return agg_vals[0]
+        return agg_vals
+
+    original_crs = gdf.crs
+    gdf = gdf.to_crs(gdf.estimate_utm_crs())
+
+    gdf = gdf.explode(ignore_index=True)
+    gdf = gdf[gdf.geom_type == "LineString"]
+
+    if len(gdf) == 0:
+        raise ValueError("Provided GeoDataFrame contains no valid LineStrings")
+
+    if check_intersections:
+        lines = line_merge(node(MultiLineString(gdf.geometry.to_list())))
+    else:
+        lines = line_merge(MultiLineString(gdf.geometry.to_list()))
+
+    lines = gpd.GeoDataFrame(geometry=list(lines.geoms), crs=gdf.crs)
+
+    if len(gdf.columns) > 1 and project_gdf_attr:
+        lines_centroids = lines.copy()
+        lines_centroids.geometry = lines_centroids.apply(
+            lambda row: row.geometry.line_interpolate_point(row.geometry.length / 2), axis=1
+        ).buffer(0.05, resolution=2)
+        lines_with_attrs = gpd.sjoin(lines_centroids, gdf, how="left", predicate="intersects")
+        aggregated_attrs = (
+            lines_with_attrs.drop(columns=["geometry", "index_right"])  # убрать геометрию буфера
+            .groupby(lines_with_attrs.index)
+            .agg(unique_list)
+        )
+        lines = pd.concat([lines, aggregated_attrs], axis=1)
+
+    lines["length_meter"] = np.round(lines.length, 2)
+    if not reproject_to_utm_crs:
+        lines = lines.to_crs(original_crs)
+
+    coords = lines.geometry.get_coordinates()
+    coords_grouped_by_index = coords.reset_index(names="old_index").groupby("old_index")
+    start_coords = coords_grouped_by_index.head(1).apply(lambda a: (a.x, a.y), axis=1).rename("start")
+    end_coords = coords_grouped_by_index.tail(1).apply(lambda a: (a.x, a.y), axis=1).rename("end")
+    coords = pd.concat([start_coords.reset_index(), end_coords.reset_index()], axis=1)[["start", "end"]]
+    lines = pd.concat([lines, coords], axis=1)
+    unique_coords = pd.concat([coords["start"], coords["end"]], ignore_index=True).unique()
+    coord_to_index = {coord: idx for idx, coord in enumerate(unique_coords)}
+
+    lines["u"] = lines["start"].map(coord_to_index)
+    lines["v"] = lines["end"].map(coord_to_index)
+
+    speed = speed * 1000 / 60
+    lines["time_min"] = np.round(lines["length_meter"] / speed, 2)
+
+    graph = nx.Graph()
+    for coords, node_id in coord_to_index.items():
+        x, y = coords
+        graph.add_node(node_id, x=float(x), y=float(y))
+
+    columns_to_attr = lines.columns.difference(["start", "end", "u", "v"])
+    for _, row in lines.iterrows():
+        edge_attrs = {}
+        for col in columns_to_attr:
+            edge_attrs[col] = row[col]
+        graph.add_edge(row.u, row.v, **edge_attrs)
+
+    graph.graph["crs"] = lines.crs
+    graph.graph["speed m/min"] = speed
+    return nx.DiGraph(graph)
+
+
 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 +239,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 +279,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/methods/visibility/visibility_analysis.py

@@ -87,9 +87,9 @@ def get_visibility_accurate(
         point_from = point_from.iloc[0].geometry
     else:
         obstacles = obstacles.copy()
-
+    if obstacles.contains(point_from).any():
+        return Polygon()
     obstacles.reset_index(inplace=True, drop=True)
-
     point_buffer = point_from.buffer(view_distance, resolution=32)
     allowed_geom_types = ["MultiPolygon", "Polygon", "LineString", "MultiLineString"]
     obstacles = obstacles[obstacles.geom_type.isin(allowed_geom_types)]

{objectnat-1.0.1.dist-info → objectnat-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ObjectNat
-Version: 1.0.1
+Version: 1.2.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.2.0.dist-info/RECORD

@@ -0,0 +1,34 @@
+objectnat/__init__.py,sha256=OnDvrLPLEeYIE_9qOVYgMc-PkRzIqShtGxirguEXiRU,260
+objectnat/_api.py,sha256=0R1nypAQUcbQ9YSLw_MUgUWoNl8c1zMZteV8wGzdkvc,711
+objectnat/_config.py,sha256=fGPsMZqA8FVBBOINxRiTFkOOZsNLyablM5G0tdKeQB4,1306
+objectnat/_version.py,sha256=viNrPDalxthAcGDGV3QUhm0tvEB8vd-Uh-27v9_MV7c,18
+objectnat/methods/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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=dJwvoGXUypwU2_oF-rdxNZm90gOi-RUp_0WM1C2HaPU,6870
+objectnat/methods/isochrones/isochrones.py,sha256=TceEQ8xJ-KZR29fAZ1v9gLl42iN2vvDmoOIi1VkvQd4,12625
+objectnat/methods/noise/__init__.py,sha256=Z5hdRiiv7tDgRAyrhwrTWkonI5dyLU3vfxHl-qdzw9A,233
+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_simulation.py,sha256=1hONZuYobyI9mVzkjVXost8XzEsZS8un2v7VTQobXQk,21680
+objectnat/methods/noise/noise_simulation_simplified.py,sha256=_2wZ3nb-w-77aZiida0dOTGS4Yuq4PnRKmXi9xQEhYU,6135
+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
+objectnat/methods/provision/provision.py,sha256=g00mN6RGFZcLg0PIMgywnO3TWiFqx3sTYqTeG3Kl33s,4749
+objectnat/methods/provision/provision_exceptions.py,sha256=lznEmlmZDzGIOtapZVqZDMutIi5eGbFuVCYeVa7VZWk,1687
+objectnat/methods/provision/provision_model.py,sha256=_IKS3pe_i7gLcA56baB0g3mH77T9pPP_4FzjuK_FZ5Y,14529
+objectnat/methods/utils/__init__.py,sha256=sGXy4KUOe5I0UYztnB4rIl2HNd-oqnqRYrBsiU-dpNY,52
+objectnat/methods/utils/geom_utils.py,sha256=PdUjQDZ8drJ1ZFCFabDJnD6oFvgHeAQrsbeivuDOdcI,6385
+objectnat/methods/utils/graph_utils.py,sha256=oIKG7XqVRkXE-QQaReXxClU8aHSKoAdwj_3g-ectUgo,12487
+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=J-GtggH12DoZaquZuDR7edDsXtCqxI3qKSRpT2ULPGs,21251
+objectnat-1.2.0.dist-info/LICENSE.txt,sha256=yPEioMfTd7JAQgAU6J13inS1BSjwd82HFlRSoIb4My8,1498
+objectnat-1.2.0.dist-info/METADATA,sha256=SerHhzYYX6o31ph9Yqm7MxxozcQ4Yxhcmzt9kKyvbI0,8881
+objectnat-1.2.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+objectnat-1.2.0.dist-info/RECORD,,

objectnat-1.0.1.dist-info/RECORD

@@ -1,32 +0,0 @@
-objectnat/__init__.py,sha256=OnDvrLPLEeYIE_9qOVYgMc-PkRzIqShtGxirguEXiRU,260
-objectnat/_api.py,sha256=5TvsMjWjiR7kFIWnfRJxngWOrC_eKQ7Pt-TSMpjqzI0,595
-objectnat/_config.py,sha256=fGPsMZqA8FVBBOINxRiTFkOOZsNLyablM5G0tdKeQB4,1306
-objectnat/_version.py,sha256=9C8U_kMX0x98w3CUW1G2vm12pYBsE-TE72pXihbWYqU,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/isochrones/__init__.py,sha256=bDfUZPbS3_PuTEB2QcRTYjvyJtUvjbDhAw6QJvD_ih4,90
-objectnat/methods/isochrones/isochrone_utils.py,sha256=XdgjmGgeNfgXa3ERkkGEEzrzF5TTkrI6U8hxFAFHRkg,4861
-objectnat/methods/isochrones/isochrones.py,sha256=GoaFGiLSsG-RRXA5jtij3zsrwxH5ThKDh8XexZ3rD3k,14046
-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/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
-objectnat/methods/provision/provision.py,sha256=g00mN6RGFZcLg0PIMgywnO3TWiFqx3sTYqTeG3Kl33s,4749
-objectnat/methods/provision/provision_exceptions.py,sha256=lznEmlmZDzGIOtapZVqZDMutIi5eGbFuVCYeVa7VZWk,1687
-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/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.1.dist-info/LICENSE.txt,sha256=yPEioMfTd7JAQgAU6J13inS1BSjwd82HFlRSoIb4My8,1498
-objectnat-1.0.1.dist-info/METADATA,sha256=2cgaqgB4Q4sXRbrBkVrzOKUIXEjIOejwS9f9kJIuxxE,8040
-objectnat-1.0.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-objectnat-1.0.1.dist-info/RECORD,,