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

objectnat/_api.py

@@ -1,14 +1,11 @@
 # pylint: disable=unused-import,wildcard-import,unused-wildcard-import
-from iduedu import *
 
-from .methods.balanced_buildings import get_balanced_buildings
-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.coverage_zones import get_graph_coverage, get_radius_coverage
+from .methods.isochrones import get_accessibility_isochrone_stepped, get_accessibility_isochrones
 from .methods.noise import simulate_noise
-from .methods.provision.provision import clip_provision, get_service_provision, recalculate_links
-from .methods.visibility_analysis import (
+from .methods.point_clustering import get_clusters_polygon
+from .methods.provision import clip_provision, get_service_provision, recalculate_links
+from .methods.visibility import (
     calculate_visibility_catchment_area,
     get_visibilities_from_points,
     get_visibility,

objectnat/_config.py

@@ -1,7 +1,6 @@
 import sys
 from typing import Literal
 
-from iduedu import config as iduedu_config
 from loguru import logger
 
 
@@ -12,10 +11,6 @@ class Config:
 
     Attributes
     ----------
-    overpass_url : str
-        URL for accessing the Overpass API. Defaults to "http://lz4.overpass-api.de/api/interpreter".
-    timeout : int or None
-        Timeout in seconds for API requests. If None, no timeout is applied.
     enable_tqdm_bar : bool
         Enables or disables progress bars (via tqdm). Defaults to True.
     logger : Logger
@@ -25,43 +20,24 @@ class Config:
     -------
     change_logger_lvl(lvl: Literal["TRACE", "DEBUG", "INFO", "WARN", "ERROR"])
         Changes the logging level to the specified value.
-    set_overpass_url(url: str)
-        Sets a new Overpass API URL.
-    set_timeout(timeout: int)
-        Sets the timeout for API requests.
     set_enable_tqdm(enable: bool)
         Enables or disables progress bars in the application.
     """
 
     def __init__(
         self,
-        overpass_url="http://lz4.overpass-api.de/api/interpreter",
-        timeout=None,
         enable_tqdm_bar=True,
     ):
-        self.overpass_url = overpass_url
-        self.timeout = timeout
         self.enable_tqdm_bar = enable_tqdm_bar
         self.logger = logger
-        self.iduedu_config = iduedu_config
         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)
-        self.iduedu_config.change_logger_lvl(lvl)
-
-    def set_overpass_url(self, url: str):
-        self.overpass_url = url
-        self.iduedu_config.set_overpass_url(url)
-
-    def set_timeout(self, timeout: int):
-        self.timeout = timeout
-        self.iduedu_config.set_timeout(timeout)
 
     def set_enable_tqdm(self, enable: bool):
         self.enable_tqdm_bar = enable
-        self.iduedu_config.set_enable_tqdm(enable)
 
     def set_pandarallel_use_file_system(self, enable: bool):
         self.pandarallel_use_file_system = enable

objectnat/_version.py

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

objectnat/methods/coverage_zones/__init__.py

@@ -0,0 +1,2 @@
+from .graph_coverage import get_graph_coverage
+from .radius_voronoi import get_radius_coverage

objectnat/methods/coverage_zones/graph_coverage.py

@@ -0,0 +1,118 @@
+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, remove_weakly_connected_nodes
+
+
+def get_graph_coverage(
+    gdf_from: 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_from : gpd.GeoDataFrame
+        Source points from 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_from.crs
+    try:
+        local_crs = nx_graph.graph["crs"]
+    except KeyError as exc:
+        raise ValueError("Graph does not have crs attribute") from exc
+
+    try:
+        points = gdf_from.copy()
+        points.to_crs(local_crs, inplace=True)
+    except CRSError as e:
+        raise CRSError(f"Graph crs ({local_crs}) has invalid format.") from e
+
+    if nx_graph.is_multigraph():
+        if nx_graph.is_directed():
+            nx_graph = nx.DiGraph(nx_graph)
+        else:
+            nx_graph = nx.Graph(nx_graph)
+    nx_graph = remove_weakly_connected_nodes(nx_graph)
+    sparse_matrix = nx.to_scipy_sparse_array(nx_graph, weight=weight_type)
+    transposed_matrix = sparse_matrix.transpose()
+    reversed_graph = nx.from_scipy_sparse_array(
+        transposed_matrix, edge_attribute=weight_type, create_using=type(nx_graph)
+    )
+
+    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(
+        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.py

@@ -0,0 +1,45 @@
+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)

objectnat/methods/isochrones/__init__.py

@@ -0,0 +1 @@
+from .isochrones import get_accessibility_isochrones, get_accessibility_isochrone_stepped

objectnat/methods/isochrones/isochrone_utils.py

@@ -0,0 +1,130 @@
+from typing import Literal
+
+import geopandas as gpd
+import networkx as nx
+import numpy as np
+import pandas as pd
+from pyproj.exceptions import CRSError
+
+from objectnat import config
+from objectnat.methods.utils.graph_utils import get_closest_nodes_from_gdf, remove_weakly_connected_nodes
+
+logger = config.logger
+
+
+def _validate_inputs(
+    points: gpd.GeoDataFrame, weight_value: float, weight_type: Literal["time_min", "length_meter"], nx_graph: nx.Graph
+) -> tuple[str, str]:
+    """Validate common inputs for accessibility functions."""
+    if weight_value <= 0:
+        raise ValueError("Weight value must be greater than 0")
+    if weight_type not in ["time_min", "length_meter"]:
+        raise UserWarning("Weight type should be either 'time_min' or 'length_meter'")
+
+    try:
+        local_crs = nx_graph.graph["crs"]
+    except KeyError as exc:
+        raise ValueError("Graph does not have crs attribute") from exc
+    try:
+        graph_type = nx_graph.graph["type"]
+    except KeyError as exc:
+        raise ValueError("Graph does not have type attribute") from exc
+
+    try:
+        points.to_crs(local_crs, inplace=True)
+    except CRSError as e:
+        raise CRSError(f"Graph crs ({local_crs}) has invalid format.") from e
+
+    return local_crs, graph_type
+
+
+def _prepare_graph_and_nodes(
+    points: gpd.GeoDataFrame, nx_graph: nx.Graph, graph_type: str, weight_type: str, weight_value: float
+) -> tuple[nx.Graph, gpd.GeoDataFrame, pd.DataFrame, float]:
+    """Prepare graph and calculate nearest nodes with distances."""
+    nx_graph = remove_weakly_connected_nodes(nx_graph)
+    distances, nearest_nodes = get_closest_nodes_from_gdf(points, nx_graph)
+    points["nearest_node"] = nearest_nodes
+
+    dist_nearest = pd.DataFrame(data=distances, index=nearest_nodes, columns=["dist"]).drop_duplicates()
+
+    # Calculate speed adjustment if needed
+    speed = 0
+    if graph_type in ["walk", "intermodal"] and weight_type == "time_min":
+        try:
+            speed = nx_graph.graph["walk_speed"]
+        except KeyError:
+            logger.warning("There is no walk_speed in graph, set to the default speed - 83.33 m/min")
+            speed = 83.33
+        dist_nearest = dist_nearest / speed
+    elif weight_type == "time_min":
+        speed = 20 * 1000 / 60
+        dist_nearest = dist_nearest / speed
+
+    if (dist_nearest > weight_value).all().all():
+        raise RuntimeError(
+            "The point(s) lie further from the graph than weight_value, it's impossible to "
+            "construct isochrones. Check the coordinates of the point(s)/their projection"
+        )
+
+    return nx_graph, points, dist_nearest, speed
+
+
+def _process_pt_data(
+    nodes: gpd.GeoDataFrame, edges: gpd.GeoDataFrame, graph_type: str
+) -> tuple[gpd.GeoDataFrame, gpd.GeoDataFrame] | tuple[None, None]:
+    """Process public transport data if available."""
+    if "desc" in nodes.columns and "stop" in nodes["desc"].unique():
+        pt_nodes = nodes[nodes["desc"] == "stop"]
+        if graph_type == "intermodal":
+            edges = edges[~edges["type"].isin(["walk", "boarding"])]
+        pt_nodes = pt_nodes[["desc", "route", "geometry"]]
+        edges = edges[["type", "route", "geometry"]]
+        return pt_nodes, edges
+    return None, None
+
+
+def _calculate_distance_matrix(
+    nx_graph: nx.Graph,
+    nearest_nodes: np.ndarray,
+    weight_type: str,
+    weight_value: float,
+    dist_nearest: pd.DataFrame,
+) -> tuple[pd.DataFrame, nx.Graph]:
+    """Calculate distance matrix from nearest nodes."""
+
+    data = {}
+    for source in nearest_nodes:
+        dist = nx.single_source_dijkstra_path_length(nx_graph, source, weight=weight_type, cutoff=weight_value)
+        data.update({source: dist})
+
+    dist_matrix = pd.DataFrame.from_dict(data, orient="index")
+    dist_matrix = dist_matrix.add(dist_nearest.dist, axis=0)
+    dist_matrix = dist_matrix.mask(dist_matrix > weight_value, np.nan)
+    dist_matrix.dropna(how="all", inplace=True)
+    dist_matrix.dropna(how="all", axis=1, inplace=True)
+
+    subgraph = nx_graph.subgraph(dist_matrix.columns.to_list())
+
+    return dist_matrix, subgraph
+
+
+def _create_isochrones_gdf(
+    points: gpd.GeoDataFrame,
+    results: list,
+    dist_matrix: pd.DataFrame,
+    local_crs: str,
+    weight_type: str,
+    weight_value: float,
+) -> gpd.GeoDataFrame:
+    """Create final isochrones GeoDataFrame."""
+    isochrones = gpd.GeoDataFrame(geometry=results, index=dist_matrix.index, crs=local_crs)
+    isochrones = (
+        points.drop(columns="geometry")
+        .merge(isochrones, left_on="nearest_node", right_index=True, how="left")
+        .drop(columns="nearest_node")
+    )
+    isochrones = gpd.GeoDataFrame(isochrones, geometry="geometry", crs=local_crs)
+    isochrones["weight_type"] = weight_type
+    isochrones["weight_value"] = weight_value
+    return isochrones