ObjectNat 0.2.6__py3-none-any.whl → 0.2.7__py3-none-any.whl

objectnat/_api.py

@@ -6,6 +6,7 @@ from .methods.cluster_points_in_polygons import get_clusters_polygon
 from .methods.coverage_zones import get_isochrone_zone_coverage, get_radius_zone_coverage
 from .methods.isochrones import get_accessibility_isochrones
 from .methods.living_buildings_osm import download_buildings
+from .methods.noise import simulate_noise
 from .methods.provision.provision import clip_provision, get_service_provision, recalculate_links
 from .methods.visibility_analysis import (
     calculate_visibility_catchment_area,

objectnat/_version.py

@@ -1 +1 @@
-VERSION = "0.2.6"
+VERSION = "0.2.7"

objectnat/methods/isochrones.py

@@ -57,7 +57,7 @@ def get_accessibility_isochrones(
     >>> from iduedu import get_intermodal_graph
     >>> graph = get_intermodal_graph(polygon=my_territory_polygon)
     >>> points = gpd.GeoDataFrame(geometry=[Point(30.33, 59.95)], crs=4326).to_crs(graph.graph['crs'])
-    >>> isochrones, pt_stops, pt_routes = get_accessibility_isochrones(points,weight_value=15, weight_type="time_min", graph_nx=my_graph)
+    >>> isochrones, stops, routes = get_accessibility_isochrones(points,15,weight_type="time_min", graph_nx=graph)
 
     """
 

objectnat/methods/living_buildings_osm.py

@@ -75,7 +75,7 @@ def eval_population(source: gpd.GeoDataFrame, population_column: str, area_per_p
     df = source.copy()
     local_crs = source.estimate_utm_crs()
     df["area"] = df.to_crs(local_crs).geometry.area.astype(float)
-    df["building:levels_is_real"] = df["building:levels"].apply(lambda x: False if pd.isna(x) else True)
+    df["building:levels_is_real"] = df["building:levels"].apply(lambda x: not pd.isna(x))
     df["building:levels"] = df["building:levels"].fillna(1)
     df["building:levels"] = pd.to_numeric(df["building:levels"], errors="coerce")
     df = df.dropna(subset=["building:levels"])
@@ -126,7 +126,7 @@ def download_buildings(
     Returns
     -------
     gpd.GeoDataFrame or None
-        A GeoDataFrame containing building geometries and attributes, or None if no buildings are found or an error occurs.
+        A GeoDataFrame containing building geometries and attributes, or None if no buildings are found.
 
     Examples
     --------

objectnat/methods/noise/__init__.py

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

objectnat/methods/noise/noise_exceptions.py

@@ -0,0 +1,14 @@
+class InvalidStepError(ValueError):
+    def __init__(self, source_noise_db, target_noise_db, db_sim_step, div_, *args):
+        if args:
+            self.message = args[0]
+        else:
+            self.message = (
+                f"The difference between `source_noise_db`({source_noise_db}) and `target_noise_db`({target_noise_db})"
+                f" is not divisible by the step size ({db_sim_step}, remainder = {div_})"
+            )
+
+    def __str__(self):
+        if self.message:
+            return self.message
+        return "The difference between `source_noise_db` and `target_noise_db` is not divisible by the step size"

objectnat/methods/noise/noise_init_data.py

@@ -0,0 +1,10 @@
+import pandas as pd
+
+data = {
+    30: {63: 0, 125: 0.0002, 250: 0.0009, 500: 0.003, 1000: 0.0075, 2000: 0.014, 4000: 0.025, 8000: 0.064},
+    20: {63: 0, 125: 0.0003, 250: 0.0011, 500: 0.0028, 1000: 0.0052, 2000: 0.0096, 4000: 0.025, 8000: 0.083},
+    10: {63: 0, 125: 0.0004, 250: 0.001, 500: 0.002, 1000: 0.0039, 2000: 0.01, 4000: 0.035, 8000: 0.125},
+    0: {63: 0, 125: 0.0004, 250: 0.0008, 500: 0.0017, 1000: 0.0049, 2000: 0.017, 4000: 0.058, 8000: 0.156},
+}
+
+air_resist_ratio = pd.DataFrame(data)

objectnat/methods/noise/noise_reduce.py

@@ -0,0 +1,155 @@
+import numpy as np
+from scipy.optimize import fsolve
+
+from objectnat import config
+
+from .noise_init_data import air_resist_ratio
+
+logger = config.logger
+
+
+def get_air_resist_ratio(temp, freq, check_temp_freq=False):
+    if check_temp_freq:
+        if temp > max(air_resist_ratio.columns) or temp < min(air_resist_ratio.columns):
+            logger.warning(
+                f"The specified temperature of {temp}°C is outside the tabulated data range. "
+                f"The air resistance coefficient for these values may be inaccurate. "
+                f"Recommended temperature range: {min(air_resist_ratio.columns)}°C "
+                f"to {max(air_resist_ratio.columns)}°C."
+            )
+
+        if freq > max(air_resist_ratio.index) or freq < min(air_resist_ratio.index):
+            logger.warning(
+                f"The specified geometric mean frequency of {freq} Hz is outside the tabulated data range."
+                f" The air resistance coefficient for these values may be inaccurate."
+                f" Recommended frequency range: {min(air_resist_ratio.index)} Hz to {max(air_resist_ratio.index)} Hz."
+            )
+
+    def get_nearest_values(array, value):
+        sorted_array = sorted(array)
+        if value in sorted_array:
+            return [value]
+        if value > max(sorted_array):
+            return [sorted_array[-1]]
+        if value < min(sorted_array):
+            return [sorted_array[0]]
+
+        for i, val in enumerate(sorted_array):
+            if value < val:
+                return sorted_array[max(i - 1, 0)], sorted_array[i]
+        return sorted_array[-2], sorted_array[-1]
+
+    nearest_temp = get_nearest_values(air_resist_ratio.columns, temp)
+    nearest_freq = get_nearest_values(air_resist_ratio.index, freq)
+
+    if len(nearest_temp) == 1 and len(nearest_freq) == 1:
+        return air_resist_ratio.loc[nearest_freq[0], nearest_temp[0]]
+
+    if len(nearest_temp) == 2 and len(nearest_freq) == 2:
+        freq1, freq2 = nearest_freq
+        temp1, temp2 = nearest_temp
+
+        coef_temp1_freq1 = air_resist_ratio.loc[freq1, temp1]
+        coef_temp1_freq2 = air_resist_ratio.loc[freq2, temp1]
+        coef_temp2_freq1 = air_resist_ratio.loc[freq1, temp2]
+        coef_temp2_freq2 = air_resist_ratio.loc[freq2, temp2]
+
+        weight_temp1 = (temp2 - temp) / (temp2 - temp1)
+        weight_temp2 = (temp - temp1) / (temp2 - temp1)
+        weight_freq1 = (freq2 - freq) / (freq2 - freq1)
+        weight_freq2 = (freq - freq1) / (freq2 - freq1)
+
+        coef_freq1 = coef_temp1_freq1 * weight_temp1 + coef_temp2_freq1 * weight_temp2
+        coef_freq2 = coef_temp1_freq2 * weight_temp1 + coef_temp2_freq2 * weight_temp2
+
+        final_coef = coef_freq1 * weight_freq1 + coef_freq2 * weight_freq2
+
+        return final_coef
+
+    if len(nearest_temp) == 2 and len(nearest_freq) == 1:
+        temp1, temp2 = nearest_temp
+        freq1 = nearest_freq[0]
+
+        coef_temp1 = air_resist_ratio.loc[freq1, temp1]
+        coef_temp2 = air_resist_ratio.loc[freq1, temp2]
+
+        weight_temp1 = (temp2 - temp) / (temp2 - temp1)
+        weight_temp2 = (temp - temp1) / (temp2 - temp1)
+
+        return coef_temp1 * weight_temp1 + coef_temp2 * weight_temp2
+
+    if len(nearest_temp) == 1 and len(nearest_freq) == 2:
+        temp1 = nearest_temp[0]
+        freq1, freq2 = nearest_freq
+
+        coef_freq1 = air_resist_ratio.loc[freq1, temp1]
+        coef_freq2 = air_resist_ratio.loc[freq2, temp1]
+
+        weight_freq1 = (freq2 - freq) / (freq2 - freq1)
+        weight_freq2 = (freq - freq1) / (freq2 - freq1)
+
+        return coef_freq1 * weight_freq1 + coef_freq2 * weight_freq2
+
+
+def dist_to_target_db(
+    init_noise_db, target_noise_db, geometric_mean_freq_hz, air_temperature, return_desc=False, check_temp_freq=False
+) -> float | str:
+    """
+    Calculates the distance required for a sound wave to decay from an initial noise level to a target noise level,
+    based on the geometric mean frequency of the sound and the air temperature. Optionally, can return a description
+    of the sound propagation behavior.
+
+    Args:
+        init_noise_db (float): The initial noise level of the source in decibels (dB). This is the starting sound
+            intensity.
+        target_noise_db (float): The target noise level in decibels (dB), representing the level to which the sound
+            decays over distance.
+        geometric_mean_freq_hz (float): The geometric mean frequency of the sound (in Hz). This frequency influences
+            the attenuation of sound over distance. Higher frequencies decay faster than lower ones.
+        air_temperature (float): The temperature of the air in degrees Celsius. This influences the air's resistance
+            to sound propagation.
+        return_desc (bool, optional): If set to `True`, the function will return a description of the sound decay
+            process instead of the calculated distance.
+        check_temp_freq (bool, optional): If `True`, the function will check whether the temperature and frequency
+            are within valid ranges.
+
+    Returns:
+        float or str: If `return_desc` is `False`, the function returns the distance (in meters) over which the sound
+        decays from `init_noise_db` to `target_noise_db`. If `return_desc` is `True`, a descriptive string is returned
+        explaining the calculation and the conditions.
+    """
+
+    def equation(r):
+        return l - l_ist + 20 * np.log10(r) + k * r
+
+    l_ist = init_noise_db
+    l = target_noise_db
+    k = get_air_resist_ratio(air_temperature, geometric_mean_freq_hz, check_temp_freq)
+    initial_guess = 1
+    r_solution = fsolve(equation, initial_guess)
+    if return_desc:
+        string = (
+            f"Noise level of {init_noise_db} dB "
+            f"with a geometric mean frequency of {geometric_mean_freq_hz} Hz "
+            f"at an air temperature of {air_temperature}°C decays to {target_noise_db} dB "
+            f"over a distance of {r_solution[0]} meters. Air resistance coefficient: {k}."
+        )
+        return string
+    return r_solution[0]
+
+
+def green_noise_reduce_db(geometric_mean_freq_hz, r_tree) -> float:
+    """
+    Calculates the amount of noise reduction (in dB) provided by vegetation of a given thickness at a specified
+    geometric mean frequency. The function models the reduction based on the interaction of the sound with trees or
+    vegetation.
+
+    Args:
+        geometric_mean_freq_hz (float): The geometric mean frequency of the sound (in Hz).
+        r_tree (float): The thickness or density of the vegetation (in meters).
+
+    Returns:
+        float: The noise reduction (in dB) achieved by the vegetation. This value indicates how much quieter the sound
+        will be after passing through or interacting with the vegetation of the specified thickness.
+    """
+    return round(0.08 * r_tree * ((geometric_mean_freq_hz ** (1 / 3)) / 8), 1)

objectnat/methods/noise/noise_sim.py

@@ -0,0 +1,418 @@
+import concurrent.futures
+import math
+import multiprocessing
+import time
+
+import geopandas as gpd
+import pandas as pd
+from shapely import GEOSException
+from shapely.geometry import GeometryCollection, MultiPolygon, Point, Polygon
+from shapely.ops import polygonize, unary_union
+from tqdm import tqdm
+
+from objectnat import config
+from objectnat.methods.noise.noise_reduce import dist_to_target_db, green_noise_reduce_db
+from objectnat.methods.noise.noise_exceptions import InvalidStepError
+from objectnat.methods.utils.geom_utils import (
+    gdf_to_circle_zones_from_point,
+    get_point_from_a_thorough_b,
+    polygons_to_multilinestring,
+)
+from objectnat.methods.visibility_analysis import get_visibility_accurate
+
+logger = config.logger
+
+
+def simulate_noise(
+    source_points: gpd.GeoDataFrame, obstacles: gpd.GeoDataFrame, source_noise_db, geometric_mean_freq_hz, **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.
+        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.
+
+    Optional kwargs:
+        absorb_ratio_column (str, optional): The name of the column in the `obstacles` GeoDataFrame that contains the
+            sound absorption coefficients for each obstacle. Default is None. If not specified, all obstacles will have
+            the `standart_absorb_ratio`.
+        standart_absorb_ratio (float, optional): The default sound absorption coefficient to use for obstacles without
+            specified values in the `absorb_ratio_column`. Default is 0.05, which is a typical value for concrete walls.
+        trees (gpd.GeoDataFrame, optional): A GeoDataFrame containing trees or dense vegetation along the sound wave's
+            path. Trees will scatter and absorb sound waves.
+        tree_resolution (int, optional): A resolution parameter for simulating tree interactions with sound waves.
+            Recommended values are between 2 and 16, with higher values providing more accurate simulation results.
+        air_temperature (float, optional): The air temperature in degrees Celsius. The recommended range is from 0 to
+            30 degrees Celsius, as temperatures outside this range will be clipped. Temperature affects the sound
+            propagation in the air.
+        target_noise_db (float, optional): The target noise level (in dB) for the simulation. Default is 40 dB.
+            Lower values may not be relevant for further analysis, as they are near the threshold of human hearing.
+        db_sim_step (float, optional): The step size in decibels for the noise simulation. Default is 1. For more
+            precise analysis, this can be adjusted. If the difference between `source_noise_db` and `target_noise_db`
+            is not divisible by the step size, the function will raise an error.
+        reflection_n (int, optional): The maximum number of reflections (bounces) to simulate for each sound wave.
+            Recommended values are between 1 and 3. Larger values will result in longer simulation times.
+        dead_area_r (float, optional): A debugging parameter that defines the radius of the "dead zone" for reflections.
+            Points within this area will not generate reflections. This is useful to prevent the algorithm from getting
+            stuck in corners or along building walls.
+
+    Returns:
+        gpd.GeoDataFrame: A GeoDataFrame containing the noise simulation results, including noise levels and geometries
+        of the affected areas. Each point's simulation results will be merged into a single GeoDataFrame.
+    """
+    # Obstacles args
+    absorb_ratio_column = kwargs.get("absorb_ratio_column", None)
+    standart_absorb_ratio = kwargs.get("standart_absorb_ratio", 0.05)
+
+    # Trees args
+    trees = kwargs.get("trees", None)
+    tree_res = kwargs.get("tree_resolution", 4)
+
+    # Simulation conditions
+    air_temperature = kwargs.get("air_temperature", 20)
+    target_noise_db = kwargs.get("target_noise_db", 40)
+
+    # Simulation params
+    db_sim_step = kwargs.get("db_sim_step", 1)
+    reflection_n = kwargs.get("reflection_n", 3)
+    dead_area_r = kwargs.get("dead_area_r", 5)
+    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
+    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)
+        source_points.to_crs(local_crs, inplace=True)
+    else:
+        local_crs = source_points.estimate_utm_crs()
+        source_points = source_points.copy()
+        source_points.to_crs(local_crs, inplace=True)
+        source_points.reset_index(drop=True)
+        source_points.geometry = source_points.centroid
+
+    # Simplifying trees
+    if trees is not None:
+        trees = trees.copy()
+        trees.to_crs(local_crs, inplace=True)
+        trees.geometry = trees.geometry.simplify(tolerance=1)
+    else:
+        trees = gpd.GeoDataFrame()
+
+    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 = 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 = []
+    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()
+        args = (source_point, obstacles, trees, 0, 0, dist_db)
+        kwargs = {
+            "reflection_n": reflection_n,
+            "geometric_mean_freq_hz": geometric_mean_freq_hz,
+            "tree_res": tree_res,
+            "min_db": target_noise_db,
+        }
+        task_queue.put((_noise_from_point_task, args, kwargs))
+
+        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 = 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).unary_union)), 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)
+
+    return gpd.GeoDataFrame(pd.concat(all_p_res, ignore_index=True), crs=local_crs)
+
+
+def _noise_from_point_task(task, **kwargs) -> tuple[gpd.GeoDataFrame, list[tuple] | None]:
+    # Unpacking task
+    point_from, obstacles, trees_orig, passed_dist, deep, dist_db = task
+
+    def donuts_dist_values(dist_db, passed_dist, max_view_dist):
+        new_dist_db = dist_db + [(passed_dist, None), (max_view_dist + passed_dist, None)]
+        new_dist_db = sorted(new_dist_db, key=lambda x: x[0])
+        start = None
+        end = None
+        for i, (dist, db) in enumerate(new_dist_db[:-1]):
+            if db is None:
+                if start is None:
+                    new_dist_db[i] = (dist, new_dist_db[i - 1][1])
+                    start = i
+                else:
+                    new_dist_db[i] = (dist, new_dist_db[i + 1][1])
+                    end = i + 1
+                    break
+        return [(dist - passed_dist, db) for dist, db in new_dist_db[start:end]]
+
+    max_dist = max(dist_db, key=lambda x: x[0])[0]
+    min_db = kwargs.get("min_db")
+    reflection_n = kwargs.get("reflection_n")
+    geometric_mean_freq_hz = kwargs.get("geometric_mean_freq_hz")
+    tree_res = kwargs.get("tree_res")
+    local_crs = obstacles.crs
+    dist = round(max_dist - passed_dist, 1)
+
+    obstacles = obstacles[obstacles.intersects(point_from.buffer(dist, resolution=8))]
+
+    if len(obstacles) == 0:
+        obstacles_union = Polygon()
+    else:
+        obstacles_union = obstacles.unary_union
+
+    vis_poly, max_view_dist = get_visibility_accurate(point_from, obstacles, dist, return_max_view_dist=True)
+
+    donuts_dist_values = donuts_dist_values(dist_db, passed_dist, max_view_dist)
+
+    allowed_geom_types = ["MultiPolygon", "Polygon"]
+
+    # Trees noise reduce
+    reduce_polygons = []
+    if len(trees_orig) > 0:
+        trees_orig = trees_orig[trees_orig.intersects(point_from.buffer(dist, resolution=8))]
+        if len(trees_orig) > 0:
+            try:
+                trees = gdf_to_circle_zones_from_point(trees_orig, point_from, dist, resolution=tree_res)
+                trees = trees.clip(vis_poly, keep_geom_type=True).explode(index_parts=False)
+            except TypeError:
+                trees = gpd.GeoDataFrame()
+
+            for _, row in trees.iterrows():
+                tree_geom = row.geometry
+                if tree_geom.area < 1:
+                    continue
+                dist_to_centroid = tree_geom.centroid.distance(point_from)
+
+                points_with_angle = [
+                    (
+                        Point(pt),
+                        round(abs(math.atan2(pt[1] - point_from.y, pt[0] - point_from.x)), 5),
+                        Point(pt).distance(point_from),
+                    )
+                    for pt in tree_geom.exterior.coords
+                ]
+
+                p0_1 = max(points_with_angle, key=lambda x: (x[1], x[2]))
+                p0_2 = min(points_with_angle, key=lambda x: (x[1], -x[2]))
+                delta_angle = 2 * math.pi + p0_1[1] - p0_2[1]
+                if delta_angle > math.pi:
+                    delta_angle = 2 * math.pi - delta_angle
+
+                a = math.sqrt((dist**2) * (1 + (math.tan(delta_angle / 2) ** 2)))
+                p1 = get_point_from_a_thorough_b(point_from, p0_1[0], a)
+                p2 = get_point_from_a_thorough_b(point_from, p0_2[0], a)
+                red_polygon = unary_union([Polygon([p0_1[0], p1, p2, p0_2[0]]).intersection(vis_poly), tree_geom])
+                if isinstance(red_polygon, GeometryCollection):
+                    red_polygon = max(
+                        ((poly, poly.area) for poly in red_polygon.geoms if isinstance(poly, (MultiPolygon, Polygon))),
+                        key=lambda x: x[1],
+                    )[0]
+                if isinstance(red_polygon, MultiPolygon):
+                    red_polygon = red_polygon.buffer(0.1, resolution=1).buffer(-0.1, resolution=1)
+                if isinstance(red_polygon, MultiPolygon):
+                    red_polygon = max(((poly, poly.area) for poly in red_polygon.geoms), key=lambda x: x[1])[0]
+                if isinstance(red_polygon, Polygon) and not red_polygon.is_empty:
+                    red_polygon = Polygon(red_polygon.exterior)
+                    r_tree_new = round(
+                        tree_geom.area / (2 * dist_to_centroid * math.sin(abs(p0_1[1] - p0_2[1]) / 2)), 2
+                    )
+
+                    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)
+    )
+
+    # intersect noise poly with noise reduce
+    if len(reduce_polygons) > 0:
+        reduce_polygons = gpd.GeoDataFrame(
+            reduce_polygons, columns=["geometry", "reduce"], geometry="geometry", crs=local_crs
+        )
+
+        all_lines = (
+            reduce_polygons.geometry.apply(polygons_to_multilinestring).tolist()
+            + noise_from_point.geometry.apply(polygons_to_multilinestring).tolist()
+        )
+
+        cutted_polygons = gpd.GeoDataFrame(geometry=list(polygonize(unary_union(all_lines))), crs=local_crs)
+
+        cutted_polygons_points = cutted_polygons.copy()
+        cutted_polygons_points.geometry = cutted_polygons.representative_point()
+
+        joined = (
+            cutted_polygons_points.sjoin(noise_from_point, predicate="within", how="left")
+            .drop(columns="index_right")
+            .sjoin(reduce_polygons, predicate="within", how="left")
+            .drop(columns="index_right")
+        )
+        joined.geometry = cutted_polygons.geometry
+        joined = (
+            joined.reset_index().groupby("index").agg({"geometry": "first", "reduce": "sum", "noise_level": "first"})
+        )
+        joined = gpd.GeoDataFrame(joined, geometry="geometry", crs=local_crs)
+        noise_from_point = joined.copy()
+
+        noise_from_point = noise_from_point.dropna(subset=["noise_level"])
+
+        noise_from_point["reduce"] = noise_from_point["reduce"].fillna(0)
+        noise_from_point["noise_level"] = noise_from_point["noise_level"] - noise_from_point["reduce"]
+    else:
+        noise_from_point["reduce"] = 0
+    noise_from_point = noise_from_point[noise_from_point.geom_type.isin(allowed_geom_types)]
+    noise_from_point = noise_from_point[noise_from_point["noise_level"] >= min_db]
+    if deep == reflection_n:
+        return noise_from_point, None
+
+    if isinstance(vis_poly, Polygon):
+        vis_poly_points = [Point(coords) for coords in vis_poly.exterior.coords]
+    else:
+        vis_poly_points = [Point(coords) for geom in vis_poly.geoms for coords in geom.exterior.coords]
+    vis_poly_points = gpd.GeoDataFrame(geometry=vis_poly_points, crs=local_crs)
+
+    # Generating reflection points
+    vis_poly_points["point"] = vis_poly_points.geometry
+    vis_poly_points.geometry = vis_poly_points.geometry.buffer(1, resolution=1)
+    vis_poly_points = vis_poly_points.sjoin(obstacles, predicate="intersects").drop(columns="index_right")
+    vis_poly_points = vis_poly_points[~vis_poly_points.index.duplicated(keep="first")]
+    vis_poly_points.dropna(subset=["absorb_ratio"], inplace=True)
+    nearby_poly = point_from.buffer(1.1, resolution=2)
+    try:
+        vis_poly_points.geometry = (
+            vis_poly_points.difference(vis_poly).difference(obstacles_union).difference(nearby_poly)
+        )
+    except GEOSException:
+        return noise_from_point, None
+    vis_poly_points = vis_poly_points[~vis_poly_points.is_empty]
+    vis_poly_points = vis_poly_points[vis_poly_points.area >= 0.01]
+    vis_poly_points.geometry = vis_poly_points["point"]
+    vis_poly_points["dist"] = vis_poly_points.distance(point_from)
+    vis_poly_points = vis_poly_points[vis_poly_points["dist"] < max_dist - 5]
+    vis_poly_points = vis_poly_points.sjoin(noise_from_point, predicate="intersects", how="left")
+
+    if len(vis_poly_points) == 0:
+        return noise_from_point, None
+
+    new_obs = pd.concat([obstacles, gpd.GeoDataFrame(geometry=[vis_poly], crs=local_crs)], ignore_index=True)
+
+    # Creating new reflection tasks
+    new_tasks = []
+    for _, loc in vis_poly_points.iterrows():
+        new_passed_dist = round(loc.dist + passed_dist, 2)
+        dist_last = max_dist - new_passed_dist
+        if dist_last > 1:
+            db_change = loc["reduce"]
+            dist_change = loc["absorb_ratio"] * dist_last
+            new_dist_db = [(dist - dist_change, db - db_change) for dist, db in dist_db]
+            task_obs = new_obs.copy()
+            task_obs.geometry = task_obs.difference(loc.geometry.buffer(1, resolution=1))
+            new_tasks.append(
+                (
+                    _noise_from_point_task,
+                    (loc.geometry, task_obs, trees_orig, new_passed_dist, deep + 1, new_dist_db),
+                    kwargs,
+                )
+            )
+
+    return noise_from_point, new_tasks
+
+
+def _parallel_split_queue(task_queue: multiprocessing.Queue, dead_area: Polygon, 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:
+            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
+
+                done, _ = concurrent.futures.wait(future_to_task.keys(), return_when=concurrent.futures.FIRST_COMPLETED)
+
+                for future in done:
+                    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)
+                        total_tasks += new_tasks_n
+                        pbar.total = total_tasks
+                        pbar.refresh()
+                    results.append(result)
+                    pbar.update(1)
+                time.sleep(0.01)
+                if not future_to_task and task_queue.empty():
+                    break
+
+    return results

objectnat/methods/provision/provision.py

@@ -51,9 +51,12 @@ def clip_provision(
     buildings: gpd.GeoDataFrame, services: gpd.GeoDataFrame, links: gpd.GeoDataFrame, selection_zone: gpd.GeoDataFrame
 ) -> Tuple[gpd.GeoDataFrame, gpd.GeoDataFrame, gpd.GeoDataFrame]:
 
-    assert (
-        selection_zone.crs == buildings.crs == services.crs == links.crs
-    ), f"CRS mismatch: buildings_crs:{buildings.crs}, links_crs:{links.crs} , services_crs:{services.crs}, selection_zone_crs:{selection_zone.crs}"
+    assert selection_zone.crs == buildings.crs == services.crs == links.crs, (
+        f"CRS mismatch: buildings_crs:{buildings.crs}, "
+        f"links_crs:{links.crs} , "
+        f"services_crs:{services.crs}, "
+        f"selection_zone_crs:{selection_zone.crs}"
+    )
     buildings = buildings.copy()
     links = links.copy()
     services = services.copy()

objectnat/methods/provision/provision_exceptions.py

@@ -7,7 +7,7 @@ class CapacityKeyError(KeyError):
 
     def __str__(self):
         if self.message:
-            return "CapacityKeyError, {0} ".format(self.message)
+            return f"CapacityKeyError, {self.message} "
 
         return (
             "Column 'capacity' was not found in provided 'services' GeoDataFrame. This attribute "
@@ -24,7 +24,7 @@ class CapacityValueError(ValueError):
 
     def __str__(self):
         if self.message:
-            return "CapacityValueError, {0} ".format(self.message)
+            return f"CapacityValueError, {self.message} "
 
         return "Column 'capacity' in 'services' GeoDataFrame  has no valid value."
 
@@ -38,7 +38,7 @@ class DemandKeyError(KeyError):
 
     def __str__(self):
         if self.message:
-            return "DemandKeyError, {0} ".format(self.message)
+            return f"DemandKeyError, {self.message} "
 
         return (
             "The column 'demand' was not found in the provided 'demanded_buildings' GeoDataFrame. "
@@ -55,5 +55,5 @@ class DemandValueError(ValueError):
 
     def __str__(self):
         if self.message:
-            return "DemandValueError, {0} ".format(self.message)
+            return f"DemandValueError, {self.message} "
         return "Column 'demand' in 'demanded_buildings' GeoDataFrame  has no valid value."

objectnat/methods/provision/provision_model.py

@@ -19,9 +19,9 @@ class Provision:
     Represents the logic for city provision calculations using a gravity or linear model.
 
     Args:
-        services (InstanceOf[gpd.GeoDataFrame]): GeoDataFrame representing the services available in the city.
-        demanded_buildings (InstanceOf[gpd.GeoDataFrame]): GeoDataFrame representing the buildings with demands for services.
-        adjacency_matrix (InstanceOf[pd.DataFrame]): DataFrame representing the adjacency matrix between buildings.
+        services (gpd.GeoDataFrame): GeoDataFrame representing the services available in the city.
+        demanded_buildings (gpd.GeoDataFrame): GeoDataFrame representing the buildings with demands for services.
+        adjacency_matrix (pd.DataFrame): DataFrame representing the adjacency matrix between buildings.
         threshold (int): Threshold value for the provision calculations.
         calculation_type (str, optional): Type of calculation ("gravity" or "linear"). Defaults to "gravity".
 
@@ -67,9 +67,11 @@ class Provision:
 
     @staticmethod
     def check_crs(demanded_buildings, services):
-        assert (
-            demanded_buildings.crs == services.crs
-        ), f"\nThe CRS in the provided geodataframes are different.\nBuildings CRS:{demanded_buildings.crs}\nServices CRS:{services.crs} \n"
+        assert demanded_buildings.crs == services.crs, (
+            f"\nThe CRS in the provided geodataframes are different."
+            f"\nBuildings CRS:{demanded_buildings.crs}"
+            f"\nServices CRS:{services.crs}"
+        )
 
     @staticmethod
     def delete_useless_matrix_rows_columns(adjacency_matrix, demanded_buildings, services):
@@ -294,7 +296,7 @@ def _additional_options(
     buildings["supplyed_demands_without"] = 0
     services["carried_capacity_within"] = 0
     services["carried_capacity_without"] = 0
-    for i, loc in destination_matrix.iterrows():
+    for _, loc in destination_matrix.iterrows():
         distances_all = matrix.loc[loc.name]
         distances = distances_all[distances_all <= normative_distance]
         s = matrix.loc[loc.name] <= normative_distance

objectnat/methods/utils/geom_utils.py

@@ -0,0 +1,79 @@
+import math
+
+import geopandas as gpd
+from shapely import LineString, MultiLineString, MultiPolygon, Point, Polygon
+from shapely.ops import polygonize, unary_union
+
+from objectnat import config
+
+logger = config.logger
+
+
+def polygons_to_multilinestring(geom: Polygon | MultiPolygon):
+    def convert_polygon(polygon: Polygon):
+        lines = []
+        exterior = LineString(polygon.exterior.coords)
+        lines.append(exterior)
+        interior = [LineString(p.coords) for p in polygon.interiors]
+        lines = lines + interior
+        return lines
+
+    def convert_multipolygon(polygon: MultiPolygon):
+        return MultiLineString(sum([convert_polygon(p) for p in polygon.geoms], []))
+
+    if geom.geom_type == "Polygon":
+        return MultiLineString(convert_polygon(geom))
+    return convert_multipolygon(geom)
+
+
+def explode_linestring(geometry: LineString) -> list[LineString]:
+    """A function to return all segments of a linestring as a list of linestrings"""
+    coords_ext = geometry.coords  # Create a list of all line node coordinates
+    result = [LineString(part) for part in zip(coords_ext, coords_ext[1:])]
+    return result
+
+
+def point_side_of_line(line: LineString, point: Point) -> int:
+    """A positive indicates the left-hand side a negative indicates the right-hand side"""
+    x1, y1 = line.coords[0]
+    x2, y2 = line.coords[-1]
+    x, y = point.coords[0]
+    cross_product = (x2 - x1) * (y - y1) - (y2 - y1) * (x - x1)
+    if cross_product > 0:
+        return 1
+    return -1
+
+
+def get_point_from_a_thorough_b(a: Point, b: Point, dist):
+    """
+    Func to get Point from point a thorough point b on dist
+    """
+    direction = math.atan2(b.y - a.y, b.x - a.x)
+    c_x = a.x + dist * math.cos(direction)
+    c_y = a.y + dist * math.sin(direction)
+    return Point(c_x, c_y)
+
+
+def gdf_to_circle_zones_from_point(
+    gdf: gpd.GeoDataFrame, point_from: Point, zone_radius, resolution=4, explode_multigeom=True
+) -> gpd.GeoDataFrame:
+    """n_segments = 4*resolution,e.g. if resolution = 4 that means there will be 16 segments"""
+    crs = gdf.crs
+    buffer = point_from.buffer(zone_radius, resolution=resolution)
+    gdf_unary = gdf.clip(buffer, keep_geom_type=True).unary_union
+    gdf_geometry = (
+        gpd.GeoDataFrame(geometry=[gdf_unary], crs=crs)
+        .explode(index_parts=True)
+        .geometry.apply(polygons_to_multilinestring)
+        .unary_union
+    )
+    zones_lines = [LineString([Point(coords1), Point(point_from)]) for coords1 in buffer.exterior.coords[:-1]]
+    if explode_multigeom:
+        return (
+            gpd.GeoDataFrame(geometry=list(polygonize(unary_union([gdf_geometry] + zones_lines))), crs=crs)
+            .clip(gdf_unary, keep_geom_type=True)
+            .explode(index_parts=False)
+        )
+    return gpd.GeoDataFrame(geometry=list(polygonize(unary_union([gdf_geometry] + zones_lines))), crs=crs).clip(
+        gdf_unary, keep_geom_type=True
+    )

objectnat/methods/visibility_analysis.py

@@ -10,11 +10,19 @@ from shapely.ops import polygonize, unary_union
 from tqdm.contrib.concurrent import process_map
 
 from objectnat import config
+from objectnat.methods.utils.geom_utils import (
+    explode_linestring,
+    get_point_from_a_thorough_b,
+    point_side_of_line,
+    polygons_to_multilinestring,
+)
 
 logger = config.logger
 
 
-def get_visibility_accurate(point_from: Point, obstacles: gpd.GeoDataFrame, view_distance) -> Polygon:
+def get_visibility_accurate(
+    point_from: Point, obstacles: gpd.GeoDataFrame, view_distance, return_max_view_dist=False
+) -> Polygon | tuple[Polygon, float]:
     """
     Function to get accurate visibility from a given point to buildings within a given distance.
 
@@ -26,11 +34,13 @@ def get_visibility_accurate(point_from: Point, obstacles: gpd.GeoDataFrame, view
         A GeoDataFrame containing the geometry of the obstacles.
     view_distance : float
         The distance of view from the point.
+    return_max_view_dist
+        If True, the max view distance is returned with view polygon in tuple.
 
     Returns
     -------
-    Polygon
-        A polygon representing the area of visibility from the given point.
+    Polygon | tuple[Polygon, float]
+        A polygon representing the area of visibility from the given point or polygon with max view distance.
 
     Notes
     -----
@@ -45,34 +55,29 @@ def get_visibility_accurate(point_from: Point, obstacles: gpd.GeoDataFrame, view
     >>> visibility = get_visibility_accurate(point_from, obstacles, view_distance)
     """
 
-    def get_point_from_a_thorough_b(a: Point, b: Point, dist):
-        """
-        Func to get Point from point a thorough point b on dist
-        """
-        direction = math.atan2(b.y - a.y, b.x - a.x)
-        c_x = a.x + dist * math.cos(direction)
-        c_y = a.y + dist * math.sin(direction)
-        return Point(c_x, c_y)
-
-    def polygon_to_linestring(geometry: Polygon):
-        """A function to return all segments of a polygon as a list of linestrings"""
-        coords_ext = geometry.exterior.coords  # Create a list of all line node coordinates
-        polygons_inter = [Polygon(x) for x in geometry.interiors]
-        result = [LineString(part) for part in zip(coords_ext, coords_ext[1:])]
-        for poly in polygons_inter:
-            poly_coords = poly.exterior.coords
-            result.extend([LineString(part) for part in zip(poly_coords, poly_coords[1:])])
-        return result
+    def find_furthest_point(point_from, view_polygon):
+        try:
+            res = round(max(Point(coords).distance(point_from) for coords in view_polygon.exterior.coords), 1)
+        except Exception as e:
+            print(view_polygon)
+            raise e
+        return res
+
+    obstacles = obstacles.copy()
+    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)]
     s = obstacles.intersects(point_buffer)
-    buildings_in_buffer = obstacles.loc[s[s].index]
-    # TODO kick all geoms except Polygons/MultiPolygons
-    buildings_in_buffer = buildings_in_buffer.geometry.apply(
-        lambda x: list(x.geoms) if isinstance(x, MultiPolygon) else x
-    ).explode()
+    obstacles_in_buffer = obstacles.loc[s[s].index].geometry
+
+    buildings_lines_in_buffer = gpd.GeoSeries(
+        pd.Series(
+            obstacles_in_buffer.apply(polygons_to_multilinestring).explode(index_parts=False).apply(explode_linestring)
+        ).explode()
+    )
 
-    buildings_lines_in_buffer = gpd.GeoSeries(buildings_in_buffer.apply(polygon_to_linestring).explode())
     buildings_lines_in_buffer = buildings_lines_in_buffer.loc[buildings_lines_in_buffer.intersects(point_buffer)]
 
     buildings_in_buffer_points = gpd.GeoSeries(
@@ -82,15 +87,12 @@ def get_visibility_accurate(point_from: Point, obstacles: gpd.GeoDataFrame, view
 
     max_dist = max(view_distance, buildings_in_buffer_points.distance(point_from).max())
     polygons = []
-    buildings_lines_in_buffer = gpd.GeoDataFrame(geometry=buildings_lines_in_buffer, crs=obstacles.crs).reset_index(
-        drop=True
-    )
-    iteration = 0
+    buildings_lines_in_buffer = gpd.GeoDataFrame(geometry=buildings_lines_in_buffer, crs=obstacles.crs).reset_index()
+    logger.debug("Calculation vis polygon")
     while not buildings_lines_in_buffer.empty:
-        iteration += 1
         gdf_sindex = buildings_lines_in_buffer.sindex
         # TODO check if 2 walls are nearest and use the widest angle between points
-        nearest_wall_sind = gdf_sindex.nearest(point_from, return_all=False)
+        nearest_wall_sind = gdf_sindex.nearest(point_from, return_all=False, max_distance=max_dist)
         nearest_wall = buildings_lines_in_buffer.loc[nearest_wall_sind[1]].iloc[0]
         wall_points = [Point(coords) for coords in nearest_wall.geometry.coords]
 
@@ -98,31 +100,49 @@ def get_visibility_accurate(point_from: Point, obstacles: gpd.GeoDataFrame, view
         points_with_angle = sorted(
             [(pt, math.atan2(pt.y - point_from.y, pt.x - point_from.x)) for pt in wall_points], key=lambda x: x[1]
         )
-
         delta_angle = 2 * math.pi + points_with_angle[0][1] - points_with_angle[-1][1]
-        if delta_angle > math.pi:
-            delta_angle = 2 * math.pi - delta_angle
-        a = math.sqrt((max_dist**2) * (1 + (math.tan(delta_angle / 2) ** 2)))
-        p1 = get_point_from_a_thorough_b(point_from, points_with_angle[0][0], a)
-        p2 = get_point_from_a_thorough_b(point_from, points_with_angle[1][0], a)
-        polygon = Polygon([points_with_angle[0][0], p1, p2, points_with_angle[1][0]])
+        if round(delta_angle, 10) == round(math.pi, 10):
+            wall_b_centroid = obstacles_in_buffer.loc[nearest_wall["index"]].centroid
+            p1 = get_point_from_a_thorough_b(point_from, points_with_angle[0][0], max_dist)
+            p2 = get_point_from_a_thorough_b(point_from, points_with_angle[1][0], max_dist)
+            polygon = LineString([p1, p2])
+            polygon = polygon.buffer(
+                distance=max_dist * point_side_of_line(polygon, wall_b_centroid), single_sided=True
+            )
+        else:
+            if delta_angle > math.pi:
+                delta_angle = 2 * math.pi - delta_angle
+            a = math.sqrt((max_dist**2) * (1 + (math.tan(delta_angle / 2) ** 2)))
+            p1 = get_point_from_a_thorough_b(point_from, points_with_angle[0][0], a)
+            p2 = get_point_from_a_thorough_b(point_from, points_with_angle[-1][0], a)
+            polygon = Polygon([points_with_angle[0][0], p1, p2, points_with_angle[1][0]])
 
         polygons.append(polygon)
-
         buildings_lines_in_buffer.drop(nearest_wall_sind[1], inplace=True)
 
+        if not polygon.is_valid or polygon.area < 1:
+            buildings_lines_in_buffer.reset_index(drop=True, inplace=True)
+            continue
+
         lines_to_kick = buildings_lines_in_buffer.within(polygon)
         buildings_lines_in_buffer = buildings_lines_in_buffer.loc[~lines_to_kick]
         buildings_lines_in_buffer.reset_index(drop=True, inplace=True)
-    res = point_buffer.difference(unary_union(polygons))
+    logger.debug("Done calculating!")
+    res = point_buffer.difference(unary_union(polygons + obstacles_in_buffer.to_list()))
+
     if isinstance(res, Polygon):
+        if return_max_view_dist:
+            return res, find_furthest_point(point_from, res)
         return res
     res = list(res.geoms)
     polygon_containing_point = None
+
     for polygon in res:
-        if polygon.contains(point_from):
+        if polygon.intersects(point_from):
             polygon_containing_point = polygon
             break
+    if return_max_view_dist:
+        return polygon_containing_point, find_furthest_point(point_from, polygon_containing_point)
     return polygon_containing_point
 
 

{objectnat-0.2.6.dist-info → objectnat-0.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ObjectNat
-Version: 0.2.6
+Version: 0.2.7
 Summary: ObjectNat is an open-source library created for geospatial analysis created by IDU team
 License: BSD-3-Clause
 Author: DDonnyy
@@ -41,45 +41,52 @@ Description-Content-Type: text/markdown
 
 ## Features and how to use
 
-1. **[City graph from OSM (IduEdu)](./examples/get_any_graph.ipynb)** - Functions to assemble a road, pedestrian,
-   and public transport graph from OpenStreetMap (OSM) and creating Intermodal graph. 
+1. **[City graph from OSM (IduEdu)](./examples/get_any_graph.ipynb)** - Functions to assemble a road, pedestrian, and public transport graph
+from OpenStreetMap (OSM) and creating Intermodal graph. 
 
    <img src="https://github.com/user-attachments/assets/8dc98da9-8462-415e-8cc8-bdfca788e206" alt="IntermodalGraph" height="250">
 
-2. **[Adjacency matrix](./examples/calculate_adjacency_matrix.ipynb)** - Calculate adjacency matrix based on the provided
-   graph and edge weight type (time or distance). The intermodal graph can be obtained using the previous example.
+2. **[Adjacency matrix](./examples/calculate_adjacency_matrix.ipynb)** - Calculate adjacency matrix based on the provided graph and edge weight type
+(time or distance). The intermodal graph can be obtained using the previous example.
 
 3. **[Isochrones,transport accessibility](./examples/isochrone_generator.ipynb)** - Function for generating isochrones to
-   analyze transportation accessibility from specified starting coordinates. Isochrones can be constructed based on
-   pedestrian, automobile, or public transport graphs, or a combination thereof.
+analyze transportation accessibility from specified starting coordinates. Isochrones can be constructed based on
+pedestrian, automobile, or public transport graphs, or a combination thereof.
 
    <img src="https://github.com/user-attachments/assets/37f308a5-db56-497d-b080-4edef3584fe5" alt="isochrones" height="250">
 
 4. **[Population restoration](./examples/restore_population.ipynb)** - Function for resettling population into the provided
-   layer of residential buildings. This function distributes people among dwellings based on the total city population
-   and the living area of each house.
-5. **[Service provision](./examples/calculate_provision.ipynb)** - Function for calculating the provision of residential
-   buildings and population with services. 
+layer of residential buildings. This function distributes people among dwellings based on the total city population
+and the living area of each house.
+5. **[Service provision](./examples/calculate_provision.ipynb)** - Function for calculating the provision of residential buildings and population
+with services. 
 
    <img src="https://github.com/user-attachments/assets/5f2b3c55-9a02-4d70-80f4-503b77023eda" alt="ProvisionSchools" height="250">
 
 6. **[Visibility analysis](./examples/visibility_analysis.ipynb)** - Function to get a quick estimate of visibility from a
-   given point(s) to buildings within a given distance. Also, there is a visibility catchment area calculator for a
-   large
-   urban area. This function is designed to work with at least 1000 points spaced 10-20 meters apart for optimal
-   results. Points can be generated using a road graph and random point distribution along edges.
+given point(s) to buildings within a given distance. Also, there is a visibility catchment area calculator for a large
+urban area. This function is designed to work with at least 1000 points spaced 10-20 meters apart for optimal
+results. Points can be generated using a road graph and random point distribution along edges.
 
    <img src="https://github.com/user-attachments/assets/2927ac86-01e8-4b0e-9ea8-72ad81c13cf5" alt="visibility-from-point" height="250"> 
 
    <img src="https://github.com/user-attachments/assets/b5b0d4b3-a02f-4ade-8772-475703cd6435" alt="visibility-catchment-area" height="250">
-   
-7. **[Point clusterization](./examples/point_clusterization.ipynb)** - Function to generate cluster polygons for given
-   points based on a specified minimum distance and minimum points per cluster. Optionally, calculate the relative ratio
-   between types of services within the clusters.
+
+7. **[Noise simulation](./examples/noise_simulation.ipynb)** - Simulates noise propagation from a set of source points
+considering obstacles, trees, and environmental factors.
+**[Detailed information in Wiki](https://github.com/DDonnyy/ObjectNat/wiki/Noise-simulation)**
+
+   <img src="https://github.com/user-attachments/assets/dd185867-67c4-4d03-8905-d06dd1d36fb3" alt="noise_sim" height="250">
+
+8. **[Point clusterization](./examples/point_clusterization.ipynb)** - Function to generate cluster polygons for given
+points based on a specified minimum distance and minimum points per cluster. Optionally, calculate the relative ratio
+between types of services within the clusters.
 
    <img src="https://github.com/user-attachments/assets/2a9ad722-87d2-4954-9612-5ac3765aa824" alt="service-clusterization" height="250">
    
-8. **[Living buildings from OSM](./examples/download_buildings_from_osm.ipynb)** - This function downloads building geometries from OpenStreetMap (OSM) for a specified territory and assigns attributes to each building. Specifically, it determines whether a building is residential (`is_living` attribute) and estimates the approximate number of inhabitants (`approximate_pop` attribute).
+9. **[Living buildings from OSM](./examples/download_buildings_from_osm.ipynb)** - This function downloads building geometries from OpenStreetMap (OSM)
+for a specified territory and assigns attributes to each building. Specifically, it determines whether a building
+is residential (`is_living` attribute) and estimates the approximate number of inhabitants (`approximate_pop` attribute).
    
    <img src="https://github.com/user-attachments/assets/d60dcd85-1a2e-4342-aae4-561aeda18858" alt="Living buildings" height="250">
    
@@ -102,10 +109,8 @@ config.set_overpass_url('http://your.overpass-api.de/interpreter/URL')
 ```
 ## Contacts
 
-- [NCCR](https://actcognitive.org/) - National
-  Center for Cognitive Research
-- [IDU](https://idu.itmo.ru/) - Institute of
-  Design and Urban Studies
+- [NCCR](https://actcognitive.org/) - National Center for Cognitive Research
+- [IDU](https://idu.itmo.ru/) - Institute of Design and Urban Studies
 - [Natalya Chichkova](https://t.me/nancy_nat) - project manager
 - [Danila Oleynikov (Donny)](https://t.me/ddonny_dd) - lead software engineer
 

objectnat-0.2.7.dist-info/RECORD

@@ -0,0 +1,26 @@
+objectnat/__init__.py,sha256=OnDvrLPLEeYIE_9qOVYgMc-PkRzIqShtGxirguEXiRU,260
+objectnat/_api.py,sha256=UX9XwHzpXbkPZksovT33kn5_g9r0qm_cGVbGLsBLoZg,746
+objectnat/_config.py,sha256=sv13J3yMw1cmmkgPMf08zinLwPKYwXHJGfchqmurSg8,2268
+objectnat/_version.py,sha256=ZQLNbaBb3Roa6Z5LEm--iZickCQhYJVSrDpqf4YBbzc,18
+objectnat/methods/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+objectnat/methods/balanced_buildings.py,sha256=hLT2QgmGWpROtnL8SJQIujeP6q9ou15yIdHpv66CfMs,2892
+objectnat/methods/cluster_points_in_polygons.py,sha256=ANoPHB89Ih6SYUTs0VoYqW7zi9GVIytSOGySoQ3vby4,5073
+objectnat/methods/coverage_zones.py,sha256=yMeK1DjneMAxxKv9busEKdAsP25xiJMcPCixlJCDI4s,2835
+objectnat/methods/isochrones.py,sha256=EbcTMCz9W9_QzvL7Of_nXWVEMv_3CqqiEvLX0Z_pagY,6123
+objectnat/methods/living_buildings_osm.py,sha256=DW7k-SWJA3Ot8qoE1FEsEH8PkB_uLQwd7KGVwfYFanE,5786
+objectnat/methods/noise/__init__.py,sha256=7B05RT3g9NXzTBC9OLKkzlHF7EOdZfVs_QZJibTfusU,150
+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=YWTzFnwIamsb9qlIZTWPNh26Z1S29uoS54ImHWYH8qg,20109
+objectnat/methods/provision/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+objectnat/methods/provision/provision.py,sha256=YDhEbGQksfaLPmqt0GOl7zsBdOlCxXesznZQ40vODjY,4749
+objectnat/methods/provision/provision_exceptions.py,sha256=lznEmlmZDzGIOtapZVqZDMutIi5eGbFuVCYeVa7VZWk,1687
+objectnat/methods/provision/provision_model.py,sha256=lL-Oynm_0Z0PXbw2bnQ1gB1kmZmSR4pBmVtqWD_JQo4,14452
+objectnat/methods/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+objectnat/methods/utils/geom_utils.py,sha256=HxC5xSDHFaTZW2HgUuXeRabGfDuz0J009hLVM60rLE4,2923
+objectnat/methods/visibility_analysis.py,sha256=PolNPU9Qyc6DrOWUwZDY_ErODxrCsfrn-zfg1pIt7Po,21618
+objectnat-0.2.7.dist-info/LICENSE.txt,sha256=yPEioMfTd7JAQgAU6J13inS1BSjwd82HFlRSoIb4My8,1498
+objectnat-0.2.7.dist-info/METADATA,sha256=FRTcsM3_rR577RnhGAfRTb0g9A9rC1A0-15QwD6JUYY,6112
+objectnat-0.2.7.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+objectnat-0.2.7.dist-info/RECORD,,

objectnat-0.2.6.dist-info/RECORD

@@ -1,19 +0,0 @@
-objectnat/__init__.py,sha256=OnDvrLPLEeYIE_9qOVYgMc-PkRzIqShtGxirguEXiRU,260
-objectnat/_api.py,sha256=oiEO2P-tv6AMDdNoT8d0BWMmgeUJa4bhzGDTU2BWTXI,704
-objectnat/_config.py,sha256=sv13J3yMw1cmmkgPMf08zinLwPKYwXHJGfchqmurSg8,2268
-objectnat/_version.py,sha256=XC2MYZybet-wsd8zs6MBULy8nzAc7dUW0vmpI8ttNTI,18
-objectnat/methods/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-objectnat/methods/balanced_buildings.py,sha256=hLT2QgmGWpROtnL8SJQIujeP6q9ou15yIdHpv66CfMs,2892
-objectnat/methods/cluster_points_in_polygons.py,sha256=ANoPHB89Ih6SYUTs0VoYqW7zi9GVIytSOGySoQ3vby4,5073
-objectnat/methods/coverage_zones.py,sha256=yMeK1DjneMAxxKv9busEKdAsP25xiJMcPCixlJCDI4s,2835
-objectnat/methods/isochrones.py,sha256=CBJprxcyPIYC4RJizqJ1MJL-Zkea4iyr7wHTOOQ7DC8,6146
-objectnat/methods/living_buildings_osm.py,sha256=Qdh9vq3Da7-aYayZ33eBdo012jleNmQ2evbbrGtdUj8,5820
-objectnat/methods/provision/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-objectnat/methods/provision/provision.py,sha256=qPPE5G8kylCfWE5SUz8LlxqEsC4NFmIniKVKPeqyRGs,4713
-objectnat/methods/provision/provision_exceptions.py,sha256=-TK4A-vacUuzlPJGSt2YyawRwKDLCZFlAbuIvIf1FnY,1723
-objectnat/methods/provision/provision_model.py,sha256=UqF_4oTzclwaLhU5JvH2Pxqq-pm5GHxXorHAnA0Lpyo,14459
-objectnat/methods/visibility_analysis.py,sha256=__S01m4YcIZbUcr6Umzvr4NpaCsajXxKNcfJm3zquVY,20690
-objectnat-0.2.6.dist-info/LICENSE.txt,sha256=yPEioMfTd7JAQgAU6J13inS1BSjwd82HFlRSoIb4My8,1498
-objectnat-0.2.6.dist-info/METADATA,sha256=aB9-0qbiYOC0G-nPS0Vao_IWKuR81lvySTIkeLZcsUQ,5761
-objectnat-0.2.6.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-objectnat-0.2.6.dist-info/RECORD,,