ObjectNat 1.1.0__tar.gz → 1.2.0__tar.gz

{objectnat-1.1.0 → objectnat-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ObjectNat
-Version: 1.1.0
+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

{objectnat-1.1.0 → objectnat-1.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ObjectNat"
-version = "1.1.0"
+version = "1.2.0"
 description = "ObjectNat is an open-source library created for geospatial analysis created by IDU team"
 license = "BSD-3-Clause"
 authors = ["DDonnyy <63115678+DDonnyy@users.noreply.github.com>"]
@@ -19,7 +19,6 @@ networkx = "^3.4.2"
 scikit-learn = "^1.4.0"
 loguru = "^0.7.3"
 
-
 [tool.poetry.group.dev.dependencies]
 iduedu = "^0.5.0"
 pyarrow = "^19.0.1"

{objectnat-1.1.0 → objectnat-1.2.0}/src/objectnat/_api.py

@@ -2,9 +2,10 @@
 
 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-1.2.0/src/objectnat/_version.py

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

objectnat-1.2.0/src/objectnat/methods/noise/__init__.py

@@ -0,0 +1,4 @@
+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-1.1.0/src/objectnat/methods/noise/noise_sim.py → objectnat-1.2.0/src/objectnat/methods/noise/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,
@@ -102,9 +103,15 @@ def simulate_noise(
             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 = "geometric_mean_freq_hz" in source_points.columns
+    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:
@@ -298,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(

objectnat-1.2.0/src/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-1.2.0/src/objectnat/methods/utils/__init__.py

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

{objectnat-1.1.0 → objectnat-1.2.0}/src/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-1.1.0 → objectnat-1.2.0}/src/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,6 +89,120 @@ 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.

{objectnat-1.1.0 → objectnat-1.2.0}/src/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.1.0/src/objectnat/_version.py

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

objectnat-1.1.0/src/objectnat/methods/noise/__init__.py

@@ -1,3 +0,0 @@
-from .noise_sim import simulate_noise
-from .noise_reduce import dist_to_target_db, green_noise_reduce_db
-from .noise_exceptions import InvalidStepError