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

objectnat/__init__.py

@@ -1,13 +1,9 @@
-"""
-ObjectNat
-========
-
-
-ObjectNat is an open-source library created for geospatial analysis created by IDU team.
-
-Homepage https://github.com/DDonnyy/ObjectNat.
-"""
-
-from ._config import config
-from ._api import *
-from ._version import VERSION as __version__
+"""
+ObjectNat is an open-source library created for geospatial analysis created by IDU team.
+
+Homepage https://github.com/DDonnyy/ObjectNat.
+"""
+
+from ._config import config
+from ._api import *
+from ._version import VERSION as __version__

objectnat/_api.py

@@ -1,14 +1,14 @@
-# pylint: disable=unused-import,wildcard-import,unused-wildcard-import
-
-from .methods.coverage_zones import get_graph_coverage, get_radius_coverage, get_stepped_graph_coverage
-from .methods.isochrones import get_accessibility_isochrone_stepped, get_accessibility_isochrones
-from .methods.noise import calculate_simplified_noise_frame, simulate_noise
-from .methods.point_clustering import get_clusters_polygon
-from .methods.provision import clip_provision, get_service_provision, recalculate_links
-from .methods.utils import gdf_to_graph, graph_to_gdf
-from .methods.visibility import (
-    calculate_visibility_catchment_area,
-    get_visibilities_from_points,
-    get_visibility,
-    get_visibility_accurate,
-)
+# pylint: disable=unused-import,wildcard-import,unused-wildcard-import
+
+from .methods.coverage_zones import get_graph_coverage, get_radius_coverage, get_stepped_graph_coverage
+from .methods.isochrones import get_accessibility_isochrone_stepped, get_accessibility_isochrones
+from .methods.noise import calculate_simplified_noise_frame, simulate_noise
+from .methods.point_clustering import get_clusters_polygon
+from .methods.provision import clip_provision, get_service_provision, recalculate_links
+from .methods.utils import gdf_to_graph, graph_to_gdf
+from .methods.visibility import (
+    calculate_visibility_catchment_area,
+    get_visibilities_from_points,
+    get_visibility,
+    get_visibility_accurate,
+)

objectnat/_config.py

@@ -1,47 +1,47 @@
-import sys
-from typing import Literal
-
-from loguru import logger
-
-
-class Config:
-    """
-    A configuration class to manage global settings for the application, such as Overpass API URL,
-    timeouts, and logging options.
-
-    Attributes
-    ----------
-    enable_tqdm_bar : bool
-        Enables or disables progress bars (via tqdm). Defaults to True.
-    logger : Logger
-        Logging instance to handle application logging.
-
-    Methods
-    -------
-    change_logger_lvl(lvl: Literal["TRACE", "DEBUG", "INFO", "WARN", "ERROR"])
-        Changes the logging level to the specified value.
-    set_enable_tqdm(enable: bool)
-        Enables or disables progress bars in the application.
-    """
-
-    def __init__(
-        self,
-        enable_tqdm_bar=True,
-    ):
-        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()
-        self.logger.add(sys.stderr, level=lvl)
-
-    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")
+import sys
+from typing import Literal
+
+from loguru import logger
+
+
+class Config:
+    """
+    A configuration class to manage global settings for the application, such as Overpass API URL,
+    timeouts, and logging options.
+
+    Attributes
+    ----------
+    enable_tqdm_bar : bool
+        Enables or disables progress bars (via tqdm). Defaults to True.
+    logger : Logger
+        Logging instance to handle application logging.
+
+    Methods
+    -------
+    change_logger_lvl(lvl: Literal["TRACE", "DEBUG", "INFO", "WARN", "ERROR"])
+        Changes the logging level to the specified value.
+    set_enable_tqdm(enable: bool)
+        Enables or disables progress bars in the application.
+    """
+
+    def __init__(
+        self,
+        enable_tqdm_bar=True,
+    ):
+        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()
+        self.logger.add(sys.stderr, level=lvl)
+
+    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.0"
+VERSION = "1.2.1"

objectnat/methods/coverage_zones/__init__.py

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

objectnat/methods/coverage_zones/graph_coverage.py

@@ -1,108 +1,98 @@
-from typing import Literal
-
-import geopandas as gpd
-import networkx as nx
-import pandas as pd
-from pyproj.exceptions import CRSError
-from shapely import Point, concave_hull
-
-from objectnat.methods.utils.graph_utils import get_closest_nodes_from_gdf, reverse_graph
-
-
-def get_graph_coverage(
-    gdf_to: gpd.GeoDataFrame,
-    nx_graph: nx.Graph,
-    weight_type: Literal["time_min", "length_meter"],
-    weight_value_cutoff: float = None,
-    zone: gpd.GeoDataFrame = None,
-):
-    """
-    Calculate coverage zones from source points through a graph network using Dijkstra's algorithm
-    and Voronoi diagrams.
-
-    The function works by:
-    1. Finding nearest graph nodes for each input point
-    2. Calculating all reachable nodes within cutoff distance using Dijkstra
-    3. Creating Voronoi polygons around graph nodes
-    4. Combining reachability information with Voronoi cells
-    5. Clipping results to specified zone boundary
-
-    Parameters
-    ----------
-    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_value_cutoff : float, optional
-        Maximum weight value for path calculations (e.g., max travel time/distance).
-    zone : gpd.GeoDataFrame, optional
-        Boundary polygon to clip the resulting coverage zones. If None, concave hull of reachable nodes will be used.
-
-    Returns
-    -------
-    gpd.GeoDataFrame
-        GeoDataFrame with coverage zones polygons, each associated with its source point, returns in the same CRS as
-        original gdf_from.
-
-    Notes
-    -----
-    - The graph must have a valid CRS attribute in its graph properties
-    - MultiGraph/MultiDiGraph inputs will be converted to simple Graph/DiGraph
-
-    Examples
-    --------
-    >>> from iduedu import get_intermodal_graph # pip install iduedu to get OSM city network graph
-    >>> points = gpd.read_file('points.geojson')
-    >>> graph = get_intermodal_graph(osm_id=1114252)
-    >>> coverage = get_graph_coverage(points, graph, "time_min", 15)
-    """
-    original_crs = gdf_to.crs
-    try:
-        local_crs = nx_graph.graph["crs"]
-    except KeyError as exc:
-        raise ValueError("Graph does not have crs attribute") from exc
-
-    try:
-        points = gdf_to.copy()
-        points.to_crs(local_crs, inplace=True)
-    except CRSError as e:
-        raise CRSError(f"Graph crs ({local_crs}) has invalid format.") from e
-
-    nx_graph, reversed_graph = reverse_graph(nx_graph, weight_type)
-
-    points.geometry = points.representative_point()
-
-    _, nearest_nodes = get_closest_nodes_from_gdf(points, nx_graph)
-
-    points["nearest_node"] = nearest_nodes
-
-    nearest_paths = nx.multi_source_dijkstra_path(
-        reversed_graph, nearest_nodes, weight=weight_type, cutoff=weight_value_cutoff
-    )
-    reachable_nodes = list(nearest_paths.keys())
-    graph_points = pd.DataFrame(
-        data=[{"node": node, "geometry": Point(data["x"], data["y"])} for node, data in nx_graph.nodes(data=True)]
-    ).set_index("node")
-    nearest_nodes = pd.DataFrame(
-        data=[path[0] for path in nearest_paths.values()], index=reachable_nodes, columns=["node_to"]
-    )
-    graph_nodes_gdf = gpd.GeoDataFrame(
-        graph_points.merge(nearest_nodes, left_index=True, right_index=True, how="left"),
-        geometry="geometry",
-        crs=local_crs,
-    )
-    graph_nodes_gdf["node_to"] = graph_nodes_gdf["node_to"].fillna("non_reachable")
-    voronois = gpd.GeoDataFrame(geometry=graph_nodes_gdf.voronoi_polygons(), crs=local_crs)
-    graph_nodes_gdf = graph_nodes_gdf[graph_nodes_gdf["node_to"] != "non_reachable"]
-    zone_coverages = voronois.sjoin(graph_nodes_gdf).dissolve(by="node_to").reset_index().drop(columns=["node"])
-    zone_coverages = zone_coverages.merge(
-        points.drop(columns="geometry"), left_on="node_to", right_on="nearest_node", how="inner"
-    ).reset_index(drop=True)
-    zone_coverages.drop(columns=["node_to", "nearest_node"], inplace=True)
-    if zone is None:
-        zone = concave_hull(graph_nodes_gdf[~graph_nodes_gdf["node_to"].isna()].union_all(), ratio=0.5)
-    else:
-        zone = zone.to_crs(local_crs)
-    return zone_coverages.clip(zone).to_crs(original_crs)
+from typing import Literal
+
+import geopandas as gpd
+import networkx as nx
+import pandas as pd
+from pyproj.exceptions import CRSError
+from shapely import Point, concave_hull
+
+from objectnat.methods.utils.graph_utils import get_closest_nodes_from_gdf, reverse_graph
+
+
+def get_graph_coverage(
+    gdf_to: gpd.GeoDataFrame,
+    nx_graph: nx.Graph,
+    weight_type: Literal["time_min", "length_meter"],
+    weight_value_cutoff: float = None,
+    zone: gpd.GeoDataFrame = None,
+):
+    """
+    Calculate coverage zones from source points through a graph network using Dijkstra's algorithm
+    and Voronoi diagrams.
+
+    The function works by:
+        1. Finding nearest graph nodes for each input point
+        2. Calculating all reachable nodes within cutoff distance using Dijkstra
+        3. Creating Voronoi polygons around graph nodes
+        4. Combining reachability information with Voronoi cells
+        5. Clipping results to specified zone boundary
+
+    Parameters:
+        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_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):
+            GeoDataFrame with coverage zones polygons, each associated with its source point, returns in the same CRS
+            as original gdf_from.
+
+    Notes:
+        - The graph must have a valid CRS attribute in its graph properties
+        - MultiGraph/MultiDiGraph inputs will be converted to simple Graph/DiGraph
+    """
+    original_crs = gdf_to.crs
+    try:
+        local_crs = nx_graph.graph["crs"]
+    except KeyError as exc:
+        raise ValueError("Graph does not have crs attribute") from exc
+
+    try:
+        points = gdf_to.copy()
+        points.to_crs(local_crs, inplace=True)
+    except CRSError as e:
+        raise CRSError(f"Graph crs ({local_crs}) has invalid format.") from e
+
+    nx_graph, reversed_graph = reverse_graph(nx_graph, weight_type)
+
+    points.geometry = points.representative_point()
+
+    _, nearest_nodes = get_closest_nodes_from_gdf(points, nx_graph)
+
+    points["nearest_node"] = nearest_nodes
+
+    nearest_paths = nx.multi_source_dijkstra_path(
+        reversed_graph, nearest_nodes, weight=weight_type, cutoff=weight_value_cutoff
+    )
+    reachable_nodes = list(nearest_paths.keys())
+    graph_points = pd.DataFrame(
+        data=[{"node": node, "geometry": Point(data["x"], data["y"])} for node, data in nx_graph.nodes(data=True)]
+    ).set_index("node")
+    nearest_nodes = pd.DataFrame(
+        data=[path[0] for path in nearest_paths.values()], index=reachable_nodes, columns=["node_to"]
+    )
+    graph_nodes_gdf = gpd.GeoDataFrame(
+        graph_points.merge(nearest_nodes, left_index=True, right_index=True, how="left"),
+        geometry="geometry",
+        crs=local_crs,
+    )
+    graph_nodes_gdf["node_to"] = graph_nodes_gdf["node_to"].fillna("non_reachable")
+    voronois = gpd.GeoDataFrame(geometry=graph_nodes_gdf.voronoi_polygons(), crs=local_crs)
+    graph_nodes_gdf = graph_nodes_gdf[graph_nodes_gdf["node_to"] != "non_reachable"]
+    zone_coverages = voronois.sjoin(graph_nodes_gdf).dissolve(by="node_to").reset_index().drop(columns=["node"])
+    zone_coverages = zone_coverages.merge(
+        points.drop(columns="geometry"), left_on="node_to", right_on="nearest_node", how="inner"
+    ).reset_index(drop=True)
+    zone_coverages.drop(columns=["node_to", "nearest_node"], inplace=True)
+    if zone is None:
+        zone = concave_hull(graph_nodes_gdf[~graph_nodes_gdf["node_to"].isna()].union_all(), ratio=0.5)
+    else:
+        zone = zone.to_crs(local_crs)
+    return zone_coverages.clip(zone).to_crs(original_crs)

objectnat/methods/coverage_zones/radius_voronoi_coverage.py

@@ -1,45 +1,37 @@
-import geopandas as gpd
-import numpy as np
-
-
-def get_radius_coverage(gdf_from: gpd.GeoDataFrame, radius: float, resolution: int = 32):
-    """
-    Calculate radius-based coverage zones using Voronoi polygons.
-
-    Parameters
-    ----------
-    gdf_from : gpd.GeoDataFrame
-        Source points for which coverage zones are calculated.
-    radius : float
-        Maximum coverage radius in meters.
-    resolution : int, optional
-        Number of segments used to approximate quarter-circle in buffer (default=32).
-
-    Returns
-    -------
-    gpd.GeoDataFrame
-        GeoDataFrame with smoothed coverage zone polygons in the same CRS as original gdf_from.
-
-    Notes
-    -----
-    - Automatically converts to local UTM CRS for accurate distance measurements
-    - Final zones are slightly contracted then expanded for smoothing effect
-
-    Examples
-    --------
-    >>> facilities = gpd.read_file('healthcare.shp')
-    >>> coverage = get_radius_coverage(facilities, radius=500)
-    """
-    original_crs = gdf_from.crs
-    local_crs = gdf_from.estimate_utm_crs()
-    gdf_from = gdf_from.to_crs(local_crs)
-    bounds = gdf_from.buffer(radius).union_all()
-    coverage_polys = gpd.GeoDataFrame(geometry=gdf_from.voronoi_polygons().clip(bounds, keep_geom_type=True))
-    coverage_polys = coverage_polys.sjoin(gdf_from)
-    coverage_polys["area"] = coverage_polys.area
-    coverage_polys["buffer"] = np.pow(coverage_polys["area"], 1 / 3)
-    coverage_polys.geometry = coverage_polys.buffer(-coverage_polys["buffer"], resolution=1, join_style="mitre").buffer(
-        coverage_polys["buffer"] * 0.9, resolution=resolution
-    )
-    coverage_polys.drop(columns=["buffer", "area"], inplace=True)
-    return coverage_polys.to_crs(original_crs)
+import geopandas as gpd
+import numpy as np
+
+
+def get_radius_coverage(gdf_from: gpd.GeoDataFrame, radius: float, resolution: int = 32):
+    """
+    Calculate radius-based coverage zones using Voronoi polygons.
+
+    Parameters:
+        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):
+            GeoDataFrame with smoothed coverage zone polygons in the same CRS as original gdf_from.
+
+    Notes:
+        - Automatically converts to local UTM CRS for accurate distance measurements
+        - Final zones are slightly contracted then expanded for smoothing effect
+    """
+    original_crs = gdf_from.crs
+    local_crs = gdf_from.estimate_utm_crs()
+    gdf_from = gdf_from.to_crs(local_crs)
+    bounds = gdf_from.buffer(radius).union_all()
+    coverage_polys = gpd.GeoDataFrame(geometry=gdf_from.voronoi_polygons().clip(bounds, keep_geom_type=True))
+    coverage_polys = coverage_polys.sjoin(gdf_from)
+    coverage_polys["area"] = coverage_polys.area
+    coverage_polys["buffer"] = np.pow(coverage_polys["area"], 1 / 3)
+    coverage_polys.geometry = coverage_polys.buffer(-coverage_polys["buffer"], resolution=1, join_style="mitre").buffer(
+        coverage_polys["buffer"] * 0.9, resolution=resolution
+    )
+    coverage_polys.drop(columns=["buffer", "area"], inplace=True)
+    return coverage_polys.to_crs(original_crs)