ObjectNat 1.2.1__py3-none-any.whl → 1.3.0__py3-none-any.whl

objectnat/_config.py

@@ -30,7 +30,6 @@ class Config:
     ):
         self.enable_tqdm_bar = enable_tqdm_bar
         self.logger = logger
-        self.pandarallel_use_file_system = False
 
     def change_logger_lvl(self, lvl: Literal["TRACE", "DEBUG", "INFO", "WARN", "ERROR"]):
         self.logger.remove()
@@ -39,9 +38,6 @@ class Config:
     def set_enable_tqdm(self, enable: bool):
         self.enable_tqdm_bar = enable
 
-    def set_pandarallel_use_file_system(self, enable: bool):
-        self.pandarallel_use_file_system = enable
-
 
 config = Config()
 config.change_logger_lvl("INFO")

objectnat/_version.py

@@ -1 +1 @@
-VERSION = "1.2.1"
+VERSION = "1.3.0"

objectnat/methods/coverage_zones/graph_coverage.py

@@ -27,20 +27,27 @@ def get_graph_coverage(
         4. Combining reachability information with Voronoi cells
         5. Clipping results to specified zone boundary
 
-    Parameters:
+    Args:
         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"]):
-            Edge attribute to use as weight for path calculations.
+
+        weight_type:
+            Type of edge weight to use for path calculation:
+
+            - ``"time_min"``: Edge travel time in minutes
+            - ``"length_meter"``: Edge length in meters
+
         weight_value_cutoff (float):
             Maximum weight value for path calculations (e.g., max travel time/distance).
+
         zone (gpd.GeoDataFrame):
             Boundary polygon to clip the resulting coverage zones. If None, concave hull of reachable nodes will be used.
 
     Returns:
-        (gpd.GeoDataFrame):
+        gpd.GeoDataFrame:
             GeoDataFrame with coverage zones polygons, each associated with its source point, returns in the same CRS
             as original gdf_from.
 

objectnat/methods/coverage_zones/radius_voronoi_coverage.py

@@ -6,16 +6,18 @@ def get_radius_coverage(gdf_from: gpd.GeoDataFrame, radius: float, resolution: i
     """
     Calculate radius-based coverage zones using Voronoi polygons.
 
-    Parameters:
+    Args:
         gdf_from (gpd.GeoDataFrame):
             Source points for which coverage zones are calculated.
+
         radius (float):
             Maximum coverage radius in meters.
+
         resolution (int):
             Number of segments used to approximate quarter-circle in buffer (default=32).
 
     Returns:
-        (gpd.GeoDataFrame):
+        gpd.GeoDataFrame:
             GeoDataFrame with smoothed coverage zone polygons in the same CRS as original gdf_from.
 
     Notes:

objectnat/methods/coverage_zones/stepped_coverage.py

@@ -31,30 +31,40 @@ def get_stepped_graph_coverage(
         4. Aggregates zones into stepped coverage layers
         5. Optionally clips results to a boundary zone
 
-    Parameters:
+    Args:
         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"]):
+
+        weight_type:
             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"]):
+
+            - ``"time_min"``: Edge travel time in minutes
+            - ``"length_meter"``: Edge length in meters
+
+        step_type:
             Method for generating stepped zones:
-            - "voronoi": Stepped zones based on Voronoi polygons around graph nodes
-            - "separate": Independent buffer zones per step
+
+            - ``"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
+
+            - 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,
+        gpd.GeoDataFrame:
+            GeoDataFrame with polygons representing stepped coverage zones for each input point,
             annotated by step range.
 
     Notes:

objectnat/methods/isochrones/isochrones.py

@@ -31,33 +31,44 @@ def get_accessibility_isochrone_stepped(
     """
     Calculate stepped accessibility isochrones for a single point with specified intervals.
 
-    Parameters:
-        isochrone_type (Literal["radius", "ways", "separate"]):
+    Args:
+        isochrone_type:
             Visualization method for stepped isochrones:
-            - "radius": Voronoi-based in circular buffers
-            - "ways": Voronoi-based in road network polygons
-            - "separate": Circular buffers for each step
+
+            - ``"radius"``: Voronoi-based in circular buffers
+            - ``"ways"``: Voronoi-based in road network polygons
+            - ``"separate"``: Circular buffers for each step
+
         point (gpd.GeoDataFrame):
             Single source point for isochrone calculation (uses first geometry if multiple provided).
+
         weight_value (float):
             Maximum travel time (minutes) or distance (meters) threshold.
-        weight_type (Literal["time_min", "length_meter"]):
+
+        weight_type:
             Type of weight calculation:
+
             - "time_min": Time-based in minutes
             - "length_meter": Distance-based in meters
+
         nx_graph (nx.Graph):
             NetworkX graph representing the transportation network.
+
         step (float, optional):
             Interval between isochrone steps. Defaults to:
+
             - 100 meters for distance-based
             - 1 minute for time-based
+
         **kwargs: Additional parameters:
+
             - buffer_factor: Size multiplier for buffers (default: 0.7)
             - road_buffer_size: Buffer size for road edges in meters (default: 5)
 
     Returns:
-        (tuple[gpd.GeoDataFrame, gpd.GeoDataFrame | None, gpd.GeoDataFrame | None]):
+        tuple[gpd.GeoDataFrame, gpd.GeoDataFrame | None, gpd.GeoDataFrame | None]:
             Tuple containing:
+
             - stepped_isochrones: GeoDataFrame with stepped polygons and distance/time attributes
             - pt_stops: Public transport stops within isochrones (if available)
             - pt_routes: Public transport routes within isochrones (if available)
@@ -150,29 +161,38 @@ def get_accessibility_isochrones(
         - 'radius': Circular buffer-based isochrones
         - 'ways': Road network-based isochrones
 
-    Parameters:
-        isochrone_type (Literal["radius", "ways"]):
+    Args:
+        isochrone_type:
             Type of isochrone to calculate:
+
             - "radius": Creates circular buffers around reachable nodes
             - "ways": Creates polygons based on reachable road network
+
         points (gpd.GeoDataFrame):
             GeoDataFrame containing source points for isochrone calculation.
+
         weight_value (float):
             Maximum travel time (minutes) or distance (meters) threshold.
-        weight_type (Literal["time_min", "length_meter"]):
+
+        weight_type:
             Type of weight calculation:
+
             - "time_min": Time-based accessibility in minutes
             - "length_meter": Distance-based accessibility in meters
+
         nx_graph (nx.Graph):
             NetworkX graph representing the transportation network.
             Must contain CRS and speed attributes for time calculations.
+
         **kwargs: Additional parameters:
+
             - buffer_factor: Size multiplier for buffers (default: 0.7)
             - road_buffer_size: Buffer size for road edges in meters (default: 5)
 
     Returns:
-        (tuple[gpd.GeoDataFrame, gpd.GeoDataFrame | None, gpd.GeoDataFrame | None]):
+        tuple[gpd.GeoDataFrame, gpd.GeoDataFrame | None, gpd.GeoDataFrame | None]:
             Tuple containing:
+
             - isochrones: GeoDataFrame with calculated isochrone polygons
             - pt_stops: Public transport stops within isochrones (if available)
             - pt_routes: Public transport routes within isochrones (if available)

objectnat/methods/noise/noise_simulation.py

@@ -35,7 +35,7 @@ def simulate_noise(
     """
     Simulates noise propagation from a set of source points considering obstacles, trees, and environmental factors.
 
-    Parameters:
+    Args:
         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.
@@ -53,32 +53,33 @@ def simulate_noise(
             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
+    Keyword Args:
+        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
+        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
+        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.
+        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
+        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.
+        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
+        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.
+        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.
+        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.
-        - use_parallel (bool, optional): Whether to use ProcessPool for task distribution or not. Default is True.
+        use_parallel (bool, optional): Whether to use ProcessPool for task distribution or not. Default is True.
+
     Returns:
-        (gpd.GeoDataFrame): A GeoDataFrame containing the noise simulation results, including noise levels and geometries
+        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

objectnat/methods/noise/noise_simulation_simplified.py

@@ -31,9 +31,10 @@ def calculate_simplified_noise_frame(
     Args:
         noise_sources (gpd.GeoDataFrame): A GeoDataFrame containing geometries of noise sources (Point, LineString,
             or Polygon). Each feature must have the following two columns:
-                - 'source_noise_db': Initial sound level at the source, in decibels (dB).
-                - 'geometric_mean_freq_hz': Characteristic sound frequency (Hz) used to model distance-based
-                  attenuation.
+
+            - 'source_noise_db': Initial sound level at the source, in decibels (dB).
+            - 'geometric_mean_freq_hz': Characteristic sound frequency (Hz) used to model distance-based attenuation.
+
             Values in 'source_noise_db' must not exceed the physical maximum of 194 dB. Missing or NaN values in
             required fields will raise an error.
 
@@ -45,21 +46,21 @@ def calculate_simplified_noise_frame(
             attenuation model of sound in the atmosphere. Temperatures significantly outside the typical 0–30°C
             range may lead to inaccurate results.
 
-    Optional kwargs:
-        - target_noise_db (float, optional): The minimum sound level threshold (in dB) to be modeled. Any value below
+    Keyword Args:
+        target_noise_db (float, optional): The minimum sound level threshold (in dB) to be modeled. Any value below
             this threshold is considered insignificant and will be excluded from the resulting noise frame.
             Default is 40 dB.
-        - db_sim_step (float, optional): The simulation step size (in dB) used to discretize sound levels into
+        db_sim_step (float, optional): The simulation step size (in dB) used to discretize sound levels into
             spatial layers. Default is 5. Smaller values produce more detailed output but increase computation time.
-        - linestring_point_radius (float, optional): The spacing radius (in meters) used when converting LineString
+        linestring_point_radius (float, optional): The spacing radius (in meters) used when converting LineString
             geometries into distributed point sources for simulation. Default is 30. Reducing this value improves
             detail along long lines.
-        - polygon_point_radius (float, optional): The point spacing (in meters) for distributing sources within
+        polygon_point_radius (float, optional): The point spacing (in meters) for distributing sources within
             Polygon geometries. Default is 15. Points are sampled across the polygon’s surface and perimeter to
             represent the full sound-emitting area.
 
     Returns:
-        (gpd.GeoDataFrame): A GeoDataFrame representing simplified noise distribution areas. The output geometries
+        gpd.GeoDataFrame: A GeoDataFrame representing simplified noise distribution areas. The output geometries
             are polygons where each polygon is associated with the maximum sound level (in dB) present in that area,
             as derived from overlapping source zones. The resulting data is dissolved by noise level and returned in
             the original coordinate reference system (CRS) of the input sources.

objectnat/methods/point_clustering/cluster_points_in_polygons.py

@@ -39,7 +39,7 @@ def get_clusters_polygon(
     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 points within the clusters.
 
-    Parameters:
+    Args:
         points (gpd.GeoDataFrame):
             GeoDataFrame containing the points to be clustered.
             Must include a 'service_code' column for service ratio calculations.
@@ -47,13 +47,13 @@ def get_clusters_polygon(
             Minimum distance between points to be considered part of the same cluster. Defaults to 100.
         min_point (int, optional):
             Minimum number of points required to form a cluster. Defaults to 5.
-        method (Literal["DBSCAN", "HDBSCAN"], optional):
+        method:
             The clustering method to use. Must be either "DBSCAN" or "HDBSCAN". Defaults to "HDBSCAN".
         service_code_column (str, optional):
             Column, containing service type for relative ratio in clasterized polygons. Defaults to "service_code".
 
     Returns:
-        (tuple[gpd.GeoDataFrame, gpd.GeoDataFrame]):
+        tuple[gpd.GeoDataFrame, gpd.GeoDataFrame]:
             A tuple containing the clustered polygons GeoDataFrame and the original points GeoDataFrame with cluster labels.
     """
     if method not in ["DBSCAN", "HDBSCAN"]:

objectnat/methods/provision/provision.py

@@ -1,5 +1,3 @@
-from typing import Tuple
-
 import geopandas as gpd
 import numpy as np
 import pandas as pd
@@ -18,26 +16,53 @@ def get_service_provision(
     threshold: int,
     buildings_demand_column: str = "demand",
     services_capacity_column: str = "capacity",
-) -> Tuple[gpd.GeoDataFrame, gpd.GeoDataFrame, gpd.GeoDataFrame]:
-    """Calculate load from buildings with demands on the given services using the distances matrix between them.
+) -> tuple[gpd.GeoDataFrame, gpd.GeoDataFrame, gpd.GeoDataFrame]:
+    """
+    Compute service provision between demand locations (buildings) and service facilities.
 
-    Parameters:
-        services (gpd.GeoDataFrame):
-            GeoDataFrame of services
-        adjacency_matrix (pd.DataFrame):
-            DataFrame representing the adjacency matrix
+    The function implements a **gravity-based allocation model**: service capacity is
+    distributed across nearby demand points with weights that **decay with the square
+    of distance (or generalized cost)**. Closer buildings receive proportionally
+    higher shares of the available capacity.
+
+    Args:
         buildings (gpd.GeoDataFrame):
-            GeoDataFrame of demanded buildings
+            GeoDataFrame of **demand locations** (e.g., residential buildings).
+            Must include a numeric column with demand values
+            (see ``buildings_demand_column``).
+        adjacency_matrix (pd.DataFrame):
+            A rectangular DataFrame representing **OD (origin–destination) costs**
+            between ``buildings`` (rows) and ``services`` (columns).
+            Units must match ``threshold`` (e.g., minutes or meters).
+            Missing or infinite values (``NaN`` or ``inf``) are treated as **unreachable**.
+            The row index must match ``buildings.index`` and column index must
+            match ``services.index``.
+        services (gpd.GeoDataFrame):
+            GeoDataFrame of **service facilities** (e.g., schools, clinics).
+            Must include a numeric column with service capacity
+            (see ``services_capacity_column``).
         threshold (int):
-            Threshold value
+            Maximum allowed cost value for assignment.
+            Any OD entry **greater than this threshold** is considered unreachable.
+            Units are the same as in ``adjacency_matrix``.
         buildings_demand_column (str):
-            column name of buildings demands
+            Column name of building demand values. Default is ``"demand"``.
         services_capacity_column (str):
-            column name of services capacity
+            Column name of service capacity values. Default is ``"capacity"``.
 
     Returns:
-        (Tuple[gpd.GeoDataFrame, gpd.GeoDataFrame, gpd.GeoDataFrame]): Tuple of GeoDataFrames representing provision
-        buildings, provision services, and provision links
+        Tuple[gpd.GeoDataFrame, gpd.GeoDataFrame, gpd.GeoDataFrame]:
+            A tuple of three GeoDataFrames:
+
+            - **buildings**: input buildings with updated provision metrics.
+            - **services**: input services with updated load and capacity metrics.
+            - **links**: building–service links within the threshold, containing
+              allocated demand shares and distances/costs based on the gravity model.
+
+    Notes:
+        - The model is **gravity-based**, with cost weights decaying by the **square of distance**.
+        - Unreachable OD pairs (``NaN`` or ``inf``) are ignored.
+        - The function does not perform routing; it expects a precomputed OD matrix.
     """
     buildings = buildings.copy()
     services = services.copy()
@@ -56,8 +81,36 @@ def get_service_provision(
 
 def clip_provision(
     buildings: gpd.GeoDataFrame, services: gpd.GeoDataFrame, links: gpd.GeoDataFrame, selection_zone: gpd.GeoDataFrame
-) -> Tuple[gpd.GeoDataFrame, gpd.GeoDataFrame, gpd.GeoDataFrame]:
+) -> tuple[gpd.GeoDataFrame, gpd.GeoDataFrame, gpd.GeoDataFrame]:
+    """
+    Clip service provision results to a specific geographic boundary.
+
+    Keeps only:
+      * buildings that intersect the ``selection_zone``;
+      * links that connect to the kept buildings;
+      * services referenced by those links.
+
+    Args:
+        buildings:
+            GeoDataFrame of buildings **after** :func:`get_service_provision`.
+        services:
+            GeoDataFrame of services **after** :func:`get_service_provision`.
+        links:
+            GeoDataFrame of building–service links from
+            :func:`get_service_provision`. Must include indices or columns
+            to match buildings and services.
+        selection_zone:
+            GeoDataFrame (polygon or multipolygon) defining the clipping area.
+
+    Returns:
+        Tuple[gpd.GeoDataFrame, gpd.GeoDataFrame, gpd.GeoDataFrame]:
+            The filtered subsets of buildings, services, and links
+            that fall inside the specified zone.
 
+    Notes:
+        - The function performs **spatial filtering only**.
+          It does **not** recompute or redistribute demand/supply.
+    """
     assert selection_zone.crs == buildings.crs == services.crs == links.crs, (
         f"CRS mismatch: buildings_crs:{buildings.crs}, "
         f"links_crs:{links.crs} , "
@@ -79,6 +132,49 @@ def clip_provision(
 def recalculate_links(
     buildings: gpd.GeoDataFrame, services: gpd.GeoDataFrame, links: gpd.GeoDataFrame, new_max_dist: float
 ) -> tuple[gpd.GeoDataFrame, gpd.GeoDataFrame, gpd.GeoDataFrame]:
+    """
+    Recalculate provision aggregates after tightening the accessibility threshold.
+
+    Removes all links whose cost (distance or time) exceeds ``new_max_dist``, then
+    updates demand and capacity aggregates accordingly. This is done **without
+    redistributing** removed demand to alternative services.
+
+    Args:
+        buildings:
+            GeoDataFrame of buildings after :func:`get_service_provision`.
+            Expected to include provision-related fields such as demand, demand_left,
+            supplied demand, and average distance/cost.
+
+        services:
+            GeoDataFrame of services after :func:`get_service_provision`, with
+            fields describing remaining capacity and service load.
+
+        links:
+            GeoDataFrame of building–service links containing at least:
+
+            - ``building_index``
+            - ``service_index``
+            - ``distance`` (or time cost, in the same units as ``new_max_dist``)
+            - ``demand`` (assigned portion)
+
+        new_max_dist:
+            New maximum allowed cost value (same units as OD/threshold).
+            Links with cost **greater than** this value are removed.
+
+    Returns:
+        tuple[gpd.GeoDataFrame, gpd.GeoDataFrame, gpd.GeoDataFrame]:
+            - **buildings**: updated aggregate demand metrics and recalculated
+              average cost.
+            - **services**: updated load and capacity fields after freeing excess capacity.
+            - **links**: subset of links that remain within the new threshold.
+
+    Notes:
+        - If no links exceed ``new_max_dist``, the function logs a warning
+          and returns the original inputs unchanged.
+        - Average cost values are recomputed based on remaining links.
+          If a building has no remaining assigned demand, ``avg_dist`` becomes ``NaN``.
+        - Removed demand is **not reallocated** to other services.
+    """
     buildings = buildings.copy()
     services = services.copy()
     links = links.copy()

objectnat/methods/provision/provision_model.py

@@ -4,7 +4,6 @@ from typing import Tuple
 import geopandas as gpd
 import numpy as np
 import pandas as pd
-from pandarallel import pandarallel
 from shapely import LineString
 
 from objectnat import config
@@ -48,7 +47,6 @@ class Provision:
         ).copy()
         self.threshold = threshold
         self.services.to_crs(self.demanded_buildings.crs, inplace=True)
-        pandarallel.initialize(progress_bar=False, verbose=0, use_memory_fs=config.pandarallel_use_file_system)
 
     @staticmethod
     def ensure_buildings(v: gpd.GeoDataFrame) -> gpd.GeoDataFrame:
@@ -81,15 +79,7 @@ class Provision:
 
     def run(self) -> Tuple[gpd.GeoDataFrame, gpd.GeoDataFrame, gpd.GeoDataFrame]:
 
-        def apply_function_based_on_size(df, func, axis, threshold=100):
-            if len(df) > threshold:
-                return df.parallel_apply(func, axis=axis)
-            return df.apply(func, axis=axis)
-
         def calculate_flows_y(loc):
-            import numpy as np  # pylint: disable=redefined-outer-name,reimported,import-outside-toplevel
-            import pandas as pd  # pylint: disable=redefined-outer-name,reimported,import-outside-toplevel
-
             c = services_table.loc[loc.name]["capacity_left"]
             p = 1 / loc / loc
             p = p / p.sum()
@@ -106,9 +96,6 @@ class Provision:
             return choice
 
         def balance_flows_to_demands(loc):
-            import numpy as np  # pylint: disable=redefined-outer-name,reimported,import-outside-toplevel
-            import pandas as pd  # pylint: disable=redefined-outer-name,reimported,import-outside-toplevel
-
             d = houses_table.loc[loc.name]["demand_left"]
             loc = loc[loc > 0]
             if loc.sum() > 0:
@@ -159,12 +146,11 @@ class Provision:
                 f" Best houses: {best_houses}"
             )
 
-            temp_destination_matrix = apply_function_based_on_size(
-                distance_matrix, lambda x: calculate_flows_y(x[x <= selection_range]), 1
+            temp_destination_matrix = distance_matrix.apply(
+                lambda x: calculate_flows_y(x[x <= selection_range]), axis=1
             )
-
             temp_destination_matrix = temp_destination_matrix.fillna(0)
-            temp_destination_matrix = apply_function_based_on_size(temp_destination_matrix, balance_flows_to_demands, 0)
+            temp_destination_matrix = temp_destination_matrix.apply(balance_flows_to_demands, axis=0)
             temp_destination_matrix = temp_destination_matrix.fillna(0)
             temp_destination_matrix_aligned = temp_destination_matrix.reindex(
                 index=destination_matrix.index, columns=destination_matrix.columns, fill_value=0

objectnat/methods/utils/graph_utils.py

@@ -51,7 +51,7 @@ def graph_to_gdf(
     """
     Converts nx graph to gpd.GeoDataFrame as edges.
 
-    Parameters:
+    Args:
         graph (nx.MultiDiGraph):
             The graph to convert.
         edges (bool):
@@ -98,7 +98,7 @@ def gdf_to_graph(
     Intersections are optionally checked and merged. Attributes from the original GeoDataFrame
     can be projected onto the graph edges using spatial matching.
 
-    Parameters:
+    Args:
         gdf (gpd.GeoDataFrame): A GeoDataFrame containing at least one LineString geometry.
         project_gdf_attr (bool): 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.
@@ -193,7 +193,7 @@ def get_closest_nodes_from_gdf(gdf: gpd.GeoDataFrame, nx_graph: nx.Graph) -> tup
     """
     Finds the closest graph nodes to the geometries in a GeoDataFrame.
 
-    Parameters
+    Args
     ----------
     gdf : gpd.GeoDataFrame
         GeoDataFrame with geometries for which the nearest graph nodes will be found.
@@ -228,7 +228,7 @@ 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
+    Args
     ----------
     graph : nx.DiGraph
         A directed NetworkX graph.
@@ -275,7 +275,7 @@ def reverse_graph(nx_graph: nx.Graph, weight: str) -> tuple[nx.Graph, nx.DiGraph
     For directed graphs, the function returns a new graph with all edge directions reversed,
     preserving the specified edge weight.
 
-    Parameters
+    Args
     ----------
     nx_graph : nx.Graph
         Input NetworkX graph (can be directed or undirected).

objectnat/methods/utils/math_utils.py

@@ -5,7 +5,7 @@ def min_max_normalization(data, new_min=0, new_max=1):
     """
     Min-max normalization for a given array of data.
 
-    Parameters
+    Args
     ----------
     data: numpy.ndarray
         Input data to be normalized.

objectnat/methods/visibility/visibility_analysis.py

@@ -4,7 +4,6 @@ from multiprocessing import cpu_count
 import geopandas as gpd
 import numpy as np
 import pandas as pd
-from pandarallel import pandarallel
 from shapely import LineString, MultiPolygon, Point, Polygon
 from shapely.ops import unary_union
 from tqdm.contrib.concurrent import process_map
@@ -28,7 +27,7 @@ def get_visibility_accurate(
     """
     Function to get accurate visibility from a given point to buildings within a given distance.
 
-    Parameters:
+    Args:
         point_from (Point | gpd.GeoDataFrame):
             The point or GeoDataFrame with 1 point from which the line of sight is drawn.
             If Point is provided it should be in the same crs as obstacles.
@@ -165,7 +164,7 @@ def get_visibility(
     """
     Function to get a quick estimate of visibility from a given point to buildings within a given distance.
 
-    Parameters:
+    Args:
         point_from (Point | gpd.GeoDataFrame):
             The point or GeoDataFrame with 1 point from which the line of sight is drawn.
             If Point is provided it should be in the same crs as obstacles.
@@ -239,7 +238,7 @@ def get_visibilities_from_points(
     """
     Calculate visibility polygons from a set of points considering obstacles within a specified view distance.
 
-    Parameters:
+    Args:
         points (gpd.GeoDataFrame):
             GeoDataFrame containing the points from which visibility is calculated.
         obstacles (gpd.GeoDataFrame):
@@ -297,7 +296,7 @@ def calculate_visibility_catchment_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.
 
-    Parameters:
+    Args:
         points (gpd.GeoDataFrame): GeoDataFrame containing the points from which visibility is calculated.
         obstacles (gpd.GeoDataFrame): GeoDataFrame containing the obstacles that block visibility.
         view_distance (int | float): The maximum distance from each point within which visibility is calculated.
@@ -313,21 +312,12 @@ def calculate_visibility_catchment_area(
         return x
 
     def calc_group_factor(x):
-        # pylint: disable-next=redefined-outer-name,reimported,import-outside-toplevel
-        import numpy as np
-
         return np.mean(x.new_ratio) * x.count_n
 
     def unary_union_groups(x):
-        # pylint: disable-next=redefined-outer-name,reimported,import-outside-toplevel
-        from shapely import MultiPolygon
-
-        # pylint: disable-next=redefined-outer-name,reimported,import-outside-toplevel
-        from shapely.ops import unary_union
-
         return unary_union(MultiPolygon(list(x["geometry"])).buffer(0))
 
-    pandarallel.initialize(progress_bar=True, verbose=0)
+    raise NotImplementedError("This method is temporarily unsupported.")
 
     local_crs = obstacles.estimate_utm_crs()
     obstacles = obstacles.to_crs(local_crs)
@@ -370,7 +360,7 @@ def calculate_visibility_catchment_area(
     all_in["count_n"] = all_in["index_right"].apply(len)
 
     logger.info("Calculating intersection's parameters")
-    all_in["factor"] = all_in.parallel_apply(calc_group_factor, axis=1)
+    # all_in["factor"] = all_in.parallel_apply(calc_group_factor, axis=1) # TODO replace pandarallel methods
     threshold = all_in["factor"].quantile(0.3)
     all_in = all_in[all_in["factor"] > threshold]
 
@@ -378,7 +368,9 @@ def calculate_visibility_catchment_area(
         min_max_normalization(np.sqrt(all_in["factor"].values), new_min=1, new_max=5)
     ).astype(int)
     logger.info("Calculating normalized groups geometry...")
-    all_in = all_in.groupby("factor_normalized").parallel_apply(unary_union_groups).reset_index()
+    all_in = (
+        all_in.groupby("factor_normalized").parallel_apply(unary_union_groups).reset_index()
+    )  # TODO replace pandarallel methods
     all_in = gpd.GeoDataFrame(data=all_in.rename(columns={0: "geometry"}), geometry="geometry", crs=32636)
 
     all_in = all_in.explode(index_parts=True).reset_index(drop=True)

objectnat-1.3.0.dist-info/METADATA

@@ -0,0 +1,201 @@
+Metadata-Version: 2.3
+Name: ObjectNat
+Version: 1.3.0
+Summary: ObjectNat is an open-source library created for geospatial analysis created by IDU team
+License: BSD-3-Clause
+Author: DDonnyy
+Author-email: 63115678+DDonnyy@users.noreply.github.com
+Requires-Python: >=3.11,<3.13
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+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: pandas (>=2.2.0,<3.0.0)
+Requires-Dist: scikit-learn (>=1.4.0,<2.0.0)
+Requires-Dist: tqdm (>=4.66.2,<5.0.0)
+Description-Content-Type: text/x-rst
+
+ObjectNat
+=========
+
+Object-oriented Network Analysis Tools
+--------------------------------------
+
+.. |badge-black| image:: https://img.shields.io/badge/code%20style-black-000000.svg
+   :target: https://github.com/psf/black
+   :alt: Code style: black
+
+.. |badge-pypi| image:: https://img.shields.io/pypi/v/objectnat.svg
+   :target: https://pypi.org/project/objectnat/
+   :alt: PyPI version
+
+.. |badge-ci| image:: https://github.com/IDUclub/ObjectNat/actions/workflows/ci_pipeline.yml/badge.svg
+   :target: https://github.com/IDUclub/ObjectNat/actions/workflows/ci_pipeline.yml
+   :alt: CI
+
+.. |badge-codecov| image:: https://codecov.io/gh/DDonnyy/ObjectNat/graph/badge.svg?token=K6JFSJ02GU
+   :target: https://codecov.io/gh/DDonnyy/ObjectNat
+   :alt: Coverage
+
+.. |badge-license| image:: https://img.shields.io/badge/license-BSD--3--Clause-blue.svg
+   :target: https://opensource.org/licenses/BSD-3-Clause
+   :alt: License
+
+.. |badge-docs| image:: https://img.shields.io/badge/docs-latest-4aa0d5?logo=readthedocs
+   :target: https://iduclub.github.io/ObjectNat/
+   :alt: Docs
+
+|badge-black| |badge-pypi| |badge-ci| |badge-codecov| |badge-license| |badge-docs|
+
+`РИДМИ (Russian) <https://github.com/IDUclub/ObjectNat/blob/main/README_RU.rst>`__
+
+.. image:: https://raw.githubusercontent.com/IDUclub/ObjectNat/main/docs/_static/ONlogo.svg
+   :align: center
+   :width: 400
+   :alt: ObjectNat logo
+
+
+**ObjectNat** is an open-source library developed by the **IDU** team
+for spatial and network analysis in urban studies.
+The library provides tools for analyzing **accessibility**, **visibility**,
+**noise propagation**, and **service provision**.
+----
+
+Key Features
+------------
+
+Each feature includes a **Jupyter Notebook example** and **full documentation**.
+
+1. **Isochrones and Transport Accessibility**  
+
+   Isochrones represent areas reachable from an origin point within a specified time along a transport network.
+   This feature allows the analysis of transport accessibility using pedestrian, road,
+   public transport, or multimodal graphs.
+
+   The library supports several methods for building isochrones:
+
+   - **Basic isochrones**: display a single zone reachable within a specified time.
+   - **Step isochrones**: divide the accessibility area into time intervals (e.g., 3, 5, 10 minutes).
+
+
+   📘 `Example <https://iduclub.github.io/ObjectNat/methods/examples/isochrones.html>`__
+   🔗 `Documentation <https://iduclub.github.io/ObjectNat/methods/isochrones.html>`__
+
+2. **Graph Coverage Zones from Points**
+
+   A function for generating **coverage areas** from a set of origin points using a transport network.
+   It computes the area reachable from each point by **travel time** or **distance**,
+   then builds polygons using **Voronoi diagrams** and clips them by a given boundary if specified.
+
+   📘 `Example <https://iduclub.github.io/ObjectNat/methods/examples/coverage.html>`__
+   🔗 `Documentation <https://iduclub.github.io/ObjectNat/methods/coverage.html>`__
+
+3. **Service Provision Analysis**  
+
+   A function to evaluate how well residential buildings and their populations are provided
+   with services (e.g., schools, clinics) that have limited **capacity**
+   and a defined **accessibility threshold** (in minutes or meters).
+   The function models the **balance between supply and demand**,
+   assessing how well services meet the needs of nearby buildings within an acceptable time.
+
+   📘 `Example <https://iduclub.github.io/ObjectNat/methods/examples/provision.html>`__
+   🔗 `Documentation <https://iduclub.github.io/ObjectNat/methods/provision.html>`__
+
+4. **Visibility Analysis**  
+
+   A function for evaluating visibility from a given point or set of points to nearby buildings within a given radius.
+   It is used to assess visual accessibility in urban environments.
+   A module is also implemented for computing **visibility coverage zones**
+   using a dense observer grid (recommended ~1000 points with a 10–20 m spacing).
+   Points can be generated along the transport network and distributed across its edges.
+
+   📘 `Example <https://iduclub.github.io/ObjectNat/methods/examples/visibility.html>`__
+   🔗 `Documentation <https://iduclub.github.io/ObjectNat/methods/visibility.html>`__
+
+5. **Noise Simulation & Noise Frame**
+
+   Simulation of noise propagation from sources, taking into account **obstacles**, **vegetation**,
+   and **environmental factors**.
+
+   📘 `Example <https://iduclub.github.io/ObjectNat/methods/examples/noise.html>`__
+   🔗 `Documentation <https://iduclub.github.io/ObjectNat/methods/noise.html>`__
+   🧠 `Detailed theory <https://github.com/DDonnyy/ObjectNat/wiki/Noise-simulation>`__
+
+6. **Point Clusterization**  
+
+   A function for constructing **cluster polygons** based on a set of points using:
+
+   - Minimum **distance** between points.
+   - Minimum **number of points** in a cluster.
+
+   The function can also compute the **ratio of service types** in each cluster
+   for spatial analysis of service composition.
+
+   📘 `Example <https://iduclub.github.io/ObjectNat/methods/examples/clustering.html>`__
+   🔗 `Documentation <https://iduclub.github.io/ObjectNat/methods/clustering.html>`__
+
+----
+
+City Graphs via *IduEdu*
+------------------------
+
+For optimal performance, **ObjectNat** is recommended to be used with graphs
+created by the `IduEdu <https://github.com/IDUclub/IduEdu>`_ library.
+
+**IduEdu** is an open-source Python library designed for building and processing
+complex urban networks based on OpenStreetMap data.
+
+
+**IduEdu** can be installed via ``pip``::
+
+    pip install IduEdu
+
+Example usage::
+
+    from iduedu import get_4326_boundary, get_intermodal_graph
+
+    poly = get_4326_boundary(osm_id=1114252)
+    G_intermodal = get_intermodal_graph(territory=poly, clip_by_territory=True)
+
+----
+
+Installation
+------------
+
+**ObjectNat** can be installed via ``pip``::
+
+    pip install ObjectNat
+
+----
+
+Configuration
+-------------
+
+You can adjust logging and progress bar output using the config module::
+
+    from objectnat import config
+
+    config.change_logger_lvl("INFO")   # mute debug logs
+    config.set_enable_tqdm(False)      # disable tqdm progress bars
+
+----
+
+Contacts
+--------
+
+- `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
+
+----
+
+Publications
+------------
+
+Coming soon.
+

objectnat-1.3.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+objectnat/__init__.py,sha256=VZ0TaIuB73EOl5Tin4Cs6-TCEOgBImCNYozwHD3bI_g,248
+objectnat/_api.py,sha256=tor-BVRvbVeqGUrFlNc3pVJ_N3gpyDgMpxQfHgV5Y1U,725
+objectnat/_config.py,sha256=OVOw0yORiirljN866xs45OLcRFhOV-xznZU6kI58ScI,1188
+objectnat/_version.py,sha256=5O6-qxBThm-gXXX0GfrBRhqSXFn9X_TTRdp9PZJHO6o,19
+objectnat/methods/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+objectnat/methods/coverage_zones/__init__.py,sha256=iebp-RbU60GRjIosd0Yvypz8-XNCme7f1Aah2nqynig,164
+objectnat/methods/coverage_zones/graph_coverage.py,sha256=0ct66u6YblxcQmVtqpa-yX2xpb83Jagxxd6HkgCBVP4,4264
+objectnat/methods/coverage_zones/radius_voronoi_coverage.py,sha256=okU6rcCwyNOXbHORYxPyh_j_J2LnQUEiD1ROiTYSndA,1627
+objectnat/methods/coverage_zones/stepped_coverage.py,sha256=QVzRP_IKqjuWBWGYTnd4FFKzWtL_xxMXvO-_GpDlL2Y,5619
+objectnat/methods/isochrones/__init__.py,sha256=inpyVZ4Mfz53k8HxW1zz3XFAqOE1xOQfpnfsS2f-a58,91
+objectnat/methods/isochrones/isochrone_utils.py,sha256=84OLlj0tbnJAg7H_k0Il3wRHzdFhlMNU4G3w8z1_x6c,7037
+objectnat/methods/isochrones/isochrones.py,sha256=qMBH8GMbfWcTgw-PMcX4FEIyLc2EB_p7Uox6_Qq0a8g,11465
+objectnat/methods/noise/__init__.py,sha256=fXlEuZ1z9Pw7cP4YRcbLaQnEgJIRkFdr2dTe2ypMhgg,189
+objectnat/methods/noise/noise_init_data.py,sha256=jMFOqi5T7FYqcKjYg8AOIr_VNYbRZQks9wGULYNaMlw,513
+objectnat/methods/noise/noise_reduce.py,sha256=KuVYLF5-hQGDqki6KU4BtgEufQ8tkOZvBWjFFjgw4m4,7040
+objectnat/methods/noise/noise_simulation.py,sha256=dO94kumoK--OVAqQ-rbWTC8M_2r-j5SIC_dDM_yrCrA,22360
+objectnat/methods/noise/noise_simulation_simplified.py,sha256=J2vt2Qj5wYHdo2AkHJhlgd8SAsOEFRA0SMOhZMJJ14s,11058
+objectnat/methods/point_clustering/__init__.py,sha256=SLRcjLZ_NyQvKBu5SHZTt7snCWpa0n7HlJqxlACJMyM,62
+objectnat/methods/point_clustering/cluster_points_in_polygons.py,sha256=Bu5RONhMCWivCCl8dZjh9DlhgEV-BGy0T1DLY8sldV4,5144
+objectnat/methods/provision/__init__.py,sha256=a8h_Md3rBnmXK0o-MuaYiTIMRFMFu0bRZJ7ZP0P2hDQ,81
+objectnat/methods/provision/provision.py,sha256=IL0PWNpm6fdzdyGlzRbDl-i4lU-OVLhBt0uGuH8qfmw,9730
+objectnat/methods/provision/provision_exceptions.py,sha256=ofZOEv0jIZRNBgfrwqphkIHUWaGDo2WOa-hf7EuCM1g,1746
+objectnat/methods/provision/provision_model.py,sha256=e8hfolPq8LK3SLI1nXffXqjtHgG0VWvwV7VFMzPbYzI,14024
+objectnat/methods/utils/__init__.py,sha256=1jhuPYwWwlNALtiO6n5IF-5z85nLKX4aC-ZaI85LEMM,53
+objectnat/methods/utils/geom_utils.py,sha256=lCuMayV1iu8WJVVtwbswxfvl4B4dwxAqRcFfF1jd98M,6558
+objectnat/methods/utils/graph_utils.py,sha256=5GI7WwwkK7tA72gpoMMMgoqugrIeomJK-OC5bjCT1dk,12637
+objectnat/methods/utils/math_utils.py,sha256=AoOx0hjIRfir-Fw2s2t6PubfybHuVoLKLbv-SJE0BGs,865
+objectnat/methods/visibility/__init__.py,sha256=vgrN4OTnap4fYfqm5GgNi787TZ85GbS9LbGfTIyTg-I,167
+objectnat/methods/visibility/visibility_analysis.py,sha256=Y76mRbYHBy8O1iUaOTBIA_Wy6OHJL8cKfXAqRWWe7_8,20504
+objectnat-1.3.0.dist-info/LICENSE.txt,sha256=gI3AMqmBc4AdVW3_l1YV4pBBhle1fvAqiK62uA543uI,1526
+objectnat-1.3.0.dist-info/METADATA,sha256=S0F3otCDjST9WJzOvLXYwzfFCvi-vhVCSg0UYjyEiY4,7370
+objectnat-1.3.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+objectnat-1.3.0.dist-info/RECORD,,

{objectnat-1.2.1.dist-info → objectnat-1.3.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: poetry-core 2.1.3
 Root-Is-Purelib: true
 Tag: py3-none-any

objectnat-1.2.1.dist-info/METADATA

@@ -1,115 +0,0 @@
-Metadata-Version: 2.1
-Name: ObjectNat
-Version: 1.2.1
-Summary: ObjectNat is an open-source library created for geospatial analysis created by IDU team
-License: BSD-3-Clause
-Author: DDonnyy
-Author-email: 63115678+DDonnyy@users.noreply.github.com
-Requires-Python: >=3.10,<3.13
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: geopandas (>=1.0.1,<2.0.0)
-Requires-Dist: loguru (>=0.7.3,<0.8.0)
-Requires-Dist: networkx (>=3.4.2,<4.0.0)
-Requires-Dist: numpy (>=2.1.3,<3.0.0)
-Requires-Dist: pandarallel (>=1.6.5,<2.0.0)
-Requires-Dist: pandas (>=2.2.0,<3.0.0)
-Requires-Dist: scikit-learn (>=1.4.0,<2.0.0)
-Requires-Dist: tqdm (>=4.66.2,<5.0.0)
-Description-Content-Type: text/markdown
-
-# ObjectNat
-
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
-[![PyPI version](https://img.shields.io/pypi/v/objectnat.svg)](https://pypi.org/project/objectnat/)
-[![CI](https://github.com/DDonnyy/ObjectNat/actions/workflows/ci_pipeline.yml/badge.svg)](https://github.com/DDonnyy/ObjecNat/actions/workflows/ci_pipeline.yml)
-[![codecov](https://codecov.io/gh/DDonnyy/ObjectNat/graph/badge.svg?token=K6JFSJ02GU)](https://codecov.io/gh/DDonnyy/ObjectNat)
-[![License](https://img.shields.io/badge/license-BSD--3--Clause-blue.svg)](https://opensource.org/licenses/MIT)
-
-- [РИДМИ (Russian)](README_ru.md)
-<p align="center">
-<img src="https://github.com/user-attachments/assets/ed0f226e-1728-4659-9e21-b4d499e703cd" alt="logo" width="400">
-</p>
-
-#### **ObjectNat** is an open-source library created for geospatial analysis created by **IDU team**
-
----
-
-## Features and How to Use
-
-Each feature is accompanied by a Jupyter notebook example and full documentation.
-
-1. **[Isochrones and Transport Accessibility](./examples/isochrone_generator.ipynb)**  
-   Analyze areas reachable within a given time along a transport network.  
-   📄 [See documentation](https://ddonnyy.github.io/ObjectNat/latest/usage/isochrones.html)
-
-2. **[Coverage Zones](./examples/coverage_zones.ipynb)**  
-   Build zones of reachability for each point using routing or simple radius.  
-   📄 [See documentation](https://ddonnyy.github.io/ObjectNat/latest/usage/coverage.html)
-
-3. **[Service Provision Analysis](./examples/calculate_provision.ipynb)**  
-   Evaluate service availability and model demand-supply balance.  
-   📄 [See documentation](https://ddonnyy.github.io/ObjectNat/latest/usage/provision.html)
-
-4. **[Visibility Analysis](./examples/visibility_analysis.ipynb)**  
-   Estimate visibility to nearby buildings from selected points.  
-   📄 [See documentation](https://ddonnyy.github.io/ObjectNat/latest/usage/visibility.html)
-
-5. **[Noise Simulation](./examples/noise_simulation.ipynb)**  
-   Simulate noise propagation considering obstacles and environment.  
-   📄 [See documentation](https://ddonnyy.github.io/ObjectNat/latest/usage/noise.html)  
-   🔗 [Detailed theory in the Wiki](https://github.com/DDonnyy/ObjectNat/wiki/Noise-simulation)
-
-6. **[Point Clusterization](./examples/point_clusterization.ipynb)**  
-   Group nearby points into clusters and analyze service composition.  
-   📄 [See documentation](https://ddonnyy.github.io/ObjectNat/latest/usage/clustering.html)
-
----
-
-## City graphs
-
-To ensure optimal performance of ObjectNat's geospatial analysis functions, it's recommended to utilize urban graphs sourced from the [IduEdu](https://github.com/DDonnyy/IduEdu) library.
-**IduEdu** is an open-source Python library designed for the creation and manipulation of complex city networks derived from OpenStreetMap data. 
-
-**IduEdu** can be installed with ``pip``:
-```
-pip install IduEdu
-```
----
-
-## Installation
-
-**ObjectNat** can be installed with ``pip``:
-
-```
-pip install ObjectNat
-```
-
----
-
-### Configuration changes
-
-```python
-from objectnat import config
-
-config.change_logger_lvl('INFO')  # To mute all debug msgs
-config.set_enable_tqdm(False)  # To mute all tqdm's progress bars
-```
-
----
-
-## Contacts
-
-- [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
-
----
-
-## Publications
-
-_Coming soon._

objectnat-1.2.1.dist-info/RECORD

@@ -1,33 +0,0 @@
-objectnat/__init__.py,sha256=VZ0TaIuB73EOl5Tin4Cs6-TCEOgBImCNYozwHD3bI_g,248
-objectnat/_api.py,sha256=tor-BVRvbVeqGUrFlNc3pVJ_N3gpyDgMpxQfHgV5Y1U,725
-objectnat/_config.py,sha256=bt9wohg8Hjwxril5PzotO5fjaIcown9vHq6kvXa3tzo,1353
-objectnat/_version.py,sha256=1ZlkgkmphZGnGYOHAq5WqbnpVdTi39MMaQJd1wOEceI,19
-objectnat/methods/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-objectnat/methods/coverage_zones/__init__.py,sha256=iebp-RbU60GRjIosd0Yvypz8-XNCme7f1Aah2nqynig,164
-objectnat/methods/coverage_zones/graph_coverage.py,sha256=e4seTrhOTqEZ8DhE9xiH_fe-TwPNZXH3ujEq87CuEA0,4190
-objectnat/methods/coverage_zones/radius_voronoi_coverage.py,sha256=A-O6WhgpJTizIHGiJ9JuP882iHbNejh0EW10H493kDM,1631
-objectnat/methods/coverage_zones/stepped_coverage.py,sha256=e-zNE0JP4Q1Crb-JEbIZc0dYFzZXle2LjTxJPGS-7XE,5659
-objectnat/methods/isochrones/__init__.py,sha256=inpyVZ4Mfz53k8HxW1zz3XFAqOE1xOQfpnfsS2f-a58,91
-objectnat/methods/isochrones/isochrone_utils.py,sha256=84OLlj0tbnJAg7H_k0Il3wRHzdFhlMNU4G3w8z1_x6c,7037
-objectnat/methods/isochrones/isochrones.py,sha256=VgpwubX7VEFStXyXM0B58cpFoCn3AboVekIU8GtXWls,11573
-objectnat/methods/noise/__init__.py,sha256=fXlEuZ1z9Pw7cP4YRcbLaQnEgJIRkFdr2dTe2ypMhgg,189
-objectnat/methods/noise/noise_init_data.py,sha256=jMFOqi5T7FYqcKjYg8AOIr_VNYbRZQks9wGULYNaMlw,513
-objectnat/methods/noise/noise_reduce.py,sha256=KuVYLF5-hQGDqki6KU4BtgEufQ8tkOZvBWjFFjgw4m4,7040
-objectnat/methods/noise/noise_simulation.py,sha256=-2pTzV-nShJfhgPg4AejKlMSvlTlnQDBCngLPZhFX8w,22389
-objectnat/methods/noise/noise_simulation_simplified.py,sha256=igj4hI3rPDdKYgabq0aH0Evhy2jg-uTstLSqFjx2VSw,11094
-objectnat/methods/point_clustering/__init__.py,sha256=SLRcjLZ_NyQvKBu5SHZTt7snCWpa0n7HlJqxlACJMyM,62
-objectnat/methods/point_clustering/cluster_points_in_polygons.py,sha256=reY5ekJrAJUdWwVMvvZBp5T34H4K2V4mt3rQuyoUYPQ,5193
-objectnat/methods/provision/__init__.py,sha256=a8h_Md3rBnmXK0o-MuaYiTIMRFMFu0bRZJ7ZP0P2hDQ,81
-objectnat/methods/provision/provision.py,sha256=4NpZiUBllflt1woIOXAf1zh7MAB5Q6DegN67fXpJHu0,4947
-objectnat/methods/provision/provision_exceptions.py,sha256=ofZOEv0jIZRNBgfrwqphkIHUWaGDo2WOa-hf7EuCM1g,1746
-objectnat/methods/provision/provision_model.py,sha256=texAsht4DeBHveJpp6FEvsA4nE13kbf6iYXZD-xK7mw,14866
-objectnat/methods/utils/__init__.py,sha256=1jhuPYwWwlNALtiO6n5IF-5z85nLKX4aC-ZaI85LEMM,53
-objectnat/methods/utils/geom_utils.py,sha256=lCuMayV1iu8WJVVtwbswxfvl4B4dwxAqRcFfF1jd98M,6558
-objectnat/methods/utils/graph_utils.py,sha256=aOtFZbuPAiGhkglMJBi9xcsb8XBbVFW7535DrhjWx1w,12667
-objectnat/methods/utils/math_utils.py,sha256=Gcoi7MOmoWlu0ao5465GLtnP2eW4ZXKsGU9NyvUDR6E,871
-objectnat/methods/visibility/__init__.py,sha256=vgrN4OTnap4fYfqm5GgNi787TZ85GbS9LbGfTIyTg-I,167
-objectnat/methods/visibility/visibility_analysis.py,sha256=nXcDQ9zewpM4FFSXuYophUNsh6wiHSIHjM88vV6Iv_U,20843
-objectnat-1.2.1.dist-info/LICENSE.txt,sha256=gI3AMqmBc4AdVW3_l1YV4pBBhle1fvAqiK62uA543uI,1526
-objectnat-1.2.1.dist-info/METADATA,sha256=8s9EHELAA7LodH5DMtuKTF1JN3NyyBbWINlzqzKDCtw,4510
-objectnat-1.2.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-objectnat-1.2.1.dist-info/RECORD,,