ObjectNat 1.3.3__py3-none-any.whl

objectnat/__init__.py

@@ -0,0 +1,9 @@
+"""
+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

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

objectnat/_config.py

@@ -0,0 +1,43 @@
+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
+
+    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
+
+
+config = Config()
+config.change_logger_lvl("INFO")

objectnat/_version.py

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

objectnat/methods/coverage_zones/__init__.py

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

objectnat/methods/coverage_zones/graph_coverage.py

@@ -0,0 +1,105 @@
+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
+
+    Args:
+        gdf_to (gpd.GeoDataFrame):
+            Source points to which coverage is calculated.
+
+        nx_graph (nx.Graph):
+            NetworkX graph representing the transportation network.
+
+        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:
+            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

@@ -0,0 +1,39 @@
+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.
+
+    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:
+            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)

objectnat/methods/coverage_zones/stepped_coverage.py

@@ -0,0 +1,136 @@
+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 shapely import Point, concave_hull
+
+from objectnat.methods.isochrones.isochrone_utils import create_separated_dist_polygons
+from objectnat.methods.utils.graph_utils import get_closest_nodes_from_gdf, reverse_graph
+
+
+def get_stepped_graph_coverage(
+    gdf_to: gpd.GeoDataFrame,
+    nx_graph: nx.Graph,
+    weight_type: Literal["time_min", "length_meter"],
+    step_type: Literal["voronoi", "separate"],
+    weight_value_cutoff: float = None,
+    zone: gpd.GeoDataFrame = None,
+    step: float = None,
+):
+    """
+    Calculate stepped coverage zones from source points through a graph network using Dijkstra's algorithm
+    and Voronoi-based or buffer-based isochrone steps.
+
+    This function combines graph-based accessibility with stepped isochrone logic. It:
+        1. Finds nearest graph nodes for each input point
+        2. Computes reachability for increasing weights (e.g. time or distance) in defined steps
+        3. Generates Voronoi-based or separate buffer zones around network nodes
+        4. Aggregates zones into stepped coverage layers
+        5. Optionally clips results to a boundary zone
+
+    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:
+            Type of edge weight to use for path calculation:
+
+            - ``"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
+
+        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
+
+    Returns:
+        gpd.GeoDataFrame:
+            GeoDataFrame with polygons representing stepped coverage zones for each input point,
+            annotated by step range.
+
+    Notes:
+        - Input graph must have a valid CRS defined.
+        - MultiGraph or MultiDiGraph inputs will be simplified to Graph/DiGraph.
+        - Designed for accessibility and spatial equity analyses over multimodal networks.
+    """
+    if step is None:
+        if weight_type == "length_meter":
+            step = 100
+        else:
+            step = 1
+    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()
+
+    distances, nearest_nodes = get_closest_nodes_from_gdf(points, nx_graph)
+
+    points["nearest_node"] = nearest_nodes
+    points["distance"] = distances
+
+    dist = nx.multi_source_dijkstra_path_length(
+        reversed_graph, nearest_nodes, weight=weight_type, cutoff=weight_value_cutoff
+    )
+
+    graph_points = pd.DataFrame(
+        data=[{"node": node, "geometry": Point(data["x"], data["y"])} for node, data in nx_graph.nodes(data=True)]
+    )
+
+    nearest_nodes = pd.DataFrame.from_dict(dist, orient="index", columns=["dist"]).reset_index()
+
+    graph_nodes_gdf = gpd.GeoDataFrame(
+        graph_points.merge(nearest_nodes, left_on="node", right_on="index", how="left").reset_index(drop=True),
+        geometry="geometry",
+        crs=local_crs,
+    )
+    graph_nodes_gdf.drop(columns=["index", "node"], inplace=True)
+    if weight_value_cutoff is None:
+        weight_value_cutoff = max(nearest_nodes["dist"])
+    if step_type == "voronoi":
+        graph_nodes_gdf["dist"] = np.minimum(np.ceil(graph_nodes_gdf["dist"] / step) * step, weight_value_cutoff)
+        voronois = gpd.GeoDataFrame(geometry=graph_nodes_gdf.voronoi_polygons(), crs=local_crs)
+        zone_coverages = voronois.sjoin(graph_nodes_gdf).dissolve(by="dist", as_index=False, dropna=False)
+        zone_coverages = zone_coverages[["dist", "geometry"]].explode(ignore_index=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)
+        zone_coverages = zone_coverages.clip(zone).to_crs(original_crs)
+    else:  # step_type == 'separate':
+        speed = 83.33  # TODO HARDCODED WALK SPEED
+        weight_value = weight_value_cutoff
+        zone_coverages = create_separated_dist_polygons(graph_nodes_gdf, weight_value, weight_type, step, speed)
+        if zone is not None:
+            zone = zone.to_crs(local_crs)
+            zone_coverages = zone_coverages.clip(zone).to_crs(original_crs)
+    return zone_coverages

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,167 @@
+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 shapely.ops import polygonize
+
+from objectnat import config
+from objectnat.methods.utils.geom_utils import polygons_to_multilinestring
+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 "type" in nodes.columns and "platform" in nodes["type"].unique():
+        pt_nodes = nodes[(nodes["type"] != "platform") & (~nodes["type"].isna())]
+        if graph_type == "intermodal":
+            edges = edges[~edges["type"].isin(["walk", "boarding"])]
+        pt_nodes = pt_nodes[["type", "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
+
+
+def create_separated_dist_polygons(
+    points: gpd.GeoDataFrame, weight_value, weight_type, step, speed
+) -> gpd.GeoDataFrame:
+    points["dist"] = points["dist"].clip(lower=0.1)
+    steps = np.arange(0, weight_value + step, step)
+    if steps[-1] > weight_value:
+        steps[-1] = weight_value  # Ensure last step doesn't exceed weight_value
+    for i in range(len(steps) - 1):
+        min_dist = steps[i]
+        max_dist = steps[i + 1]
+        nodes_in_step = points["dist"].between(min_dist, max_dist, inclusive="left")
+        nodes_in_step = nodes_in_step[nodes_in_step].index
+        if not nodes_in_step.empty:
+            buffer_size = (max_dist - points.loc[nodes_in_step, "dist"]) * 0.7
+            if weight_type == "time_min":
+                buffer_size = buffer_size * speed
+            points.loc[nodes_in_step, "buffer_size"] = buffer_size
+    points.geometry = points.geometry.buffer(points["buffer_size"])
+    points["dist"] = np.minimum(np.ceil(points["dist"] / step) * step, weight_value)
+    points = points.dissolve(by="dist", as_index=False)
+    polygons = gpd.GeoDataFrame(
+        geometry=list(polygonize(points.geometry.apply(polygons_to_multilinestring).union_all())),
+        crs=points.crs,
+    )
+    polygons_points = polygons.copy()
+    polygons_points.geometry = polygons.representative_point()
+    stepped_polygons = polygons_points.sjoin(points, predicate="within").reset_index()
+    stepped_polygons = stepped_polygons.groupby("index").agg({"dist": "mean"})
+    stepped_polygons["dist"] = np.minimum(np.floor(stepped_polygons["dist"] / step) * step, weight_value)
+    stepped_polygons["geometry"] = polygons
+    stepped_polygons = gpd.GeoDataFrame(stepped_polygons, geometry="geometry", crs=points.crs).reset_index(drop=True)
+    stepped_polygons = stepped_polygons.dissolve(by="dist", as_index=False).explode(ignore_index=True)
+    return stepped_polygons