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

objectnat/methods/isochrones/isochrones.py

@@ -0,0 +1,325 @@
+from typing import Literal
+
+import geopandas as gpd
+import networkx as nx
+import numpy as np
+from shapely.ops import polygonize
+
+from objectnat import config
+from objectnat.methods.isochrones.isochrone_utils import (
+    _calculate_distance_matrix,
+    _create_isochrones_gdf,
+    _prepare_graph_and_nodes,
+    _process_pt_data,
+    _validate_inputs,
+)
+from objectnat.methods.utils.geom_utils import polygons_to_multilinestring, remove_inner_geom
+from objectnat.methods.utils.graph_utils import graph_to_gdf
+
+logger = config.logger
+
+
+def get_accessibility_isochrone_stepped(
+    isochrone_type: Literal["radius", "ways", "separate"],
+    point: gpd.GeoDataFrame,
+    weight_value: float,
+    weight_type: Literal["time_min", "length_meter"],
+    nx_graph: nx.Graph,
+    step: float = None,
+    **kwargs,
+) -> tuple[gpd.GeoDataFrame, gpd.GeoDataFrame | None, gpd.GeoDataFrame | None]:
+    """
+    Calculate stepped accessibility isochrones for a single point with specified intervals.
+
+    Parameters
+    ----------
+    isochrone_type : Literal["radius", "ways", "separate"]
+        Visualization method for stepped isochrones:
+        - "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"]
+        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 buffer 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 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)
+
+    Examples
+    --------
+    >>> from iduedu import get_intermodal_graph # pip install iduedu to get OSM city network graph
+    >>> graph = get_intermodal_graph(polygon=my_territory_polygon)
+    >>> point = gpd.GeoDataFrame(geometry=[Point(30.33, 59.95)], crs=4326)
+    >>> # Stepped radius isochrones with 5-minute intervals
+    >>> radius_stepped, stops, _ = get_accessibility_isochrone_stepped(
+    ...     "radius", point, 30, "time_min", graph, step=5
+    ... )
+    >>> # Stepped road isochrones with 200m intervals
+    >>> ways_stepped, _, routes = get_accessibility_isochrone_stepped(
+    ...     "ways", point, 1000, "length_meter", graph, step=200
+    ... )
+    >>> # Voronoi-based stepped isochrones
+    >>> separate_stepped, stops, _ = get_accessibility_isochrone_stepped(
+    ...     "separate", point, 15, "time_min", graph
+    ... )
+    """
+    buffer_params = {
+        "buffer_factor": 0.7,
+        "road_buffer_size": 5,
+    }
+
+    buffer_params.update(kwargs)
+    original_crs = point.crs
+    point = point.copy()
+    if len(point) > 1:
+        logger.warning(
+            f"This method processes only single point. The GeoDataFrame contains {len(point)} points - "
+            "only the first geometry will be used for isochrone calculation. "
+        )
+        point = point.iloc[[0]]
+
+    local_crs, graph_type = _validate_inputs(point, weight_value, weight_type, nx_graph)
+
+    if step is None:
+        if weight_type == "length_meter":
+            step = 100
+        else:
+            step = 1
+    nx_graph, points, dist_nearest, speed = _prepare_graph_and_nodes(
+        point, nx_graph, graph_type, weight_type, weight_value
+    )
+
+    dist_matrix, subgraph = _calculate_distance_matrix(
+        nx_graph, points["nearest_node"].values, weight_type, weight_value, dist_nearest
+    )
+
+    logger.info("Building isochrones geometry...")
+    nodes, edges = graph_to_gdf(subgraph)
+    nodes.loc[dist_matrix.columns, "dist"] = dist_matrix.iloc[0]
+    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
+
+    if isochrone_type == "separate":
+        for i in range(len(steps) - 1):
+            min_dist = steps[i]
+            max_dist = steps[i + 1]
+            nodes_in_step = nodes["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 - nodes.loc[nodes_in_step, "dist"]) * 0.7
+                if weight_type == "time_min":
+                    buffer_size = buffer_size * speed
+                nodes.loc[nodes_in_step, "buffer_size"] = buffer_size
+        nodes.geometry = nodes.geometry.buffer(nodes["buffer_size"])
+        nodes["dist"] = np.round(nodes["dist"], 0)
+        nodes = nodes.dissolve(by="dist", as_index=False)
+        polygons = gpd.GeoDataFrame(
+            geometry=list(polygonize(nodes.geometry.apply(polygons_to_multilinestring).union_all())),
+            crs=local_crs,
+        )
+        polygons_points = polygons.copy()
+        polygons_points.geometry = polygons.representative_point()
+
+        stepped_iso = polygons_points.sjoin(nodes, predicate="within").reset_index()
+        stepped_iso = stepped_iso.groupby("index").agg({"dist": "mean"})
+        stepped_iso["geometry"] = polygons
+        stepped_iso = gpd.GeoDataFrame(stepped_iso, geometry="geometry", crs=local_crs).reset_index(drop=True)
+    else:
+        if isochrone_type == "radius":
+            isochrone_geoms = _build_radius_isochrones(
+                dist_matrix, weight_value, weight_type, speed, nodes, buffer_params["buffer_factor"]
+            )
+        else:  # isochrone_type == 'ways':
+            if graph_type in ["intermodal", "walk"]:
+                isochrone_edges = edges[edges["type"] == "walk"]
+            else:
+                isochrone_edges = edges.copy()
+            all_isochrones_edges = isochrone_edges.buffer(buffer_params["road_buffer_size"], resolution=1).union_all()
+            all_isochrones_edges = gpd.GeoDataFrame(geometry=[all_isochrones_edges], crs=local_crs)
+            isochrone_geoms = _build_ways_isochrones(
+                dist_matrix=dist_matrix,
+                weight_value=weight_value,
+                weight_type=weight_type,
+                speed=speed,
+                nodes=nodes,
+                all_isochrones_edges=all_isochrones_edges,
+                buffer_factor=buffer_params["buffer_factor"],
+            )
+        nodes = nodes.clip(isochrone_geoms[0], keep_geom_type=True)
+        nodes["dist"] = np.minimum(np.ceil(nodes["dist"] / step) * step, weight_value)
+        voronois = gpd.GeoDataFrame(geometry=nodes.voronoi_polygons(), crs=local_crs)
+        stepped_iso = (
+            voronois.sjoin(nodes[["dist", "geometry"]]).dissolve(by="dist", as_index=False).drop(columns="index_right")
+        )
+        stepped_iso = stepped_iso.clip(isochrone_geoms[0], keep_geom_type=True)
+
+    pt_nodes, pt_edges = _process_pt_data(nodes, edges, graph_type)
+    if pt_nodes is not None:
+        pt_nodes.to_crs(original_crs, inplace=True)
+    if pt_edges is not None:
+        pt_edges.to_crs(original_crs, inplace=True)
+    return stepped_iso.to_crs(original_crs), pt_nodes, pt_edges
+
+
+def get_accessibility_isochrones(
+    isochrone_type: Literal["radius", "ways"],
+    points: gpd.GeoDataFrame,
+    weight_value: float,
+    weight_type: Literal["time_min", "length_meter"],
+    nx_graph: nx.Graph,
+    **kwargs,
+) -> tuple[gpd.GeoDataFrame, gpd.GeoDataFrame | None, gpd.GeoDataFrame | None]:
+    """
+    Calculate accessibility isochrones from input points based on the provided city graph.
+
+    Supports two types of isochrones:
+    - 'radius': Circular buffer-based isochrones
+    - 'ways': Road network-based isochrones
+
+    Parameters
+    ----------
+    isochrone_type : Literal["radius", "ways"]
+        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"]
+        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 buffer 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 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)
+
+    Examples
+    --------
+    >>> from iduedu import get_intermodal_graph # pip install iduedu to get OSM city network graph
+    >>> graph = get_intermodal_graph(polygon=my_territory_polygon)
+    >>> points = gpd.GeoDataFrame(geometry=[Point(30.33, 59.95)], crs=4326)
+    >>> # Radius isochrones
+    >>> radius_iso, stops, routes = get_accessibility_isochrones(
+    ...     "radius", points, 15, "time_min", graph, buffer_factor=0.8
+    ... )
+    >>> # Road network isochrones
+    >>> ways_iso, stops, routes = get_accessibility_isochrones(
+    ...     "ways", points, 1000, "length_meter", graph, road_buffer_size=7
+    ... )
+    """
+
+    buffer_params = {
+        "buffer_factor": 0.7,
+        "road_buffer_size": 5,
+    }
+    original_crs = points.crs
+    buffer_params.update(kwargs)
+
+    points = points.copy()
+    local_crs, graph_type = _validate_inputs(points, weight_value, weight_type, nx_graph)
+
+    nx_graph, points, dist_nearest, speed = _prepare_graph_and_nodes(
+        points, nx_graph, graph_type, weight_type, weight_value
+    )
+
+    weight_cutoff = (
+        weight_value + (100 if weight_type == "length_meter" else 1) if isochrone_type == "ways" else weight_value
+    )
+
+    dist_matrix, subgraph = _calculate_distance_matrix(
+        nx_graph, points["nearest_node"].values, weight_type, weight_cutoff, dist_nearest
+    )
+
+    logger.info("Building isochrones geometry...")
+    nodes, edges = graph_to_gdf(subgraph)
+    if isochrone_type == "radius":
+        isochrone_geoms = _build_radius_isochrones(
+            dist_matrix, weight_value, weight_type, speed, nodes, buffer_params["buffer_factor"]
+        )
+    else:  # isochrone_type == 'ways':
+        if graph_type in ["intermodal", "walk"]:
+            isochrone_edges = edges[edges["type"] == "walk"]
+        else:
+            isochrone_edges = edges.copy()
+        all_isochrones_edges = isochrone_edges.buffer(buffer_params["road_buffer_size"], resolution=1).union_all()
+        all_isochrones_edges = gpd.GeoDataFrame(geometry=[all_isochrones_edges], crs=local_crs)
+        isochrone_geoms = _build_ways_isochrones(
+            dist_matrix=dist_matrix,
+            weight_value=weight_value,
+            weight_type=weight_type,
+            speed=speed,
+            nodes=nodes,
+            all_isochrones_edges=all_isochrones_edges,
+            buffer_factor=buffer_params["buffer_factor"],
+        )
+    isochrones = _create_isochrones_gdf(points, isochrone_geoms, dist_matrix, local_crs, weight_type, weight_value)
+    pt_nodes, pt_edges = _process_pt_data(nodes, edges, graph_type)
+    if pt_nodes is not None:
+        pt_nodes.to_crs(original_crs, inplace=True)
+    if pt_edges is not None:
+        pt_edges.to_crs(original_crs, inplace=True)
+    return isochrones.to_crs(original_crs), pt_nodes, pt_edges
+
+
+def _build_radius_isochrones(dist_matrix, weight_value, weight_type, speed, nodes, buffer_factor):
+    results = []
+    for source in dist_matrix.index:
+        buffers = (weight_value - dist_matrix.loc[source]) * buffer_factor
+        if weight_type == "time_min":
+            buffers = buffers * speed
+        buffers = nodes.merge(buffers, left_index=True, right_index=True)
+        buffers.geometry = buffers.geometry.buffer(buffers[source], resolution=8)
+        results.append(buffers.union_all())
+    return results
+
+
+def _build_ways_isochrones(dist_matrix, weight_value, weight_type, speed, nodes, all_isochrones_edges, buffer_factor):
+    results = []
+    for source in dist_matrix.index:
+        reachable_nodes = dist_matrix.loc[source]
+        reachable_nodes = reachable_nodes[reachable_nodes <= weight_value]
+        reachable_nodes = (weight_value - reachable_nodes) * buffer_factor
+        if weight_type == "time_min":
+            reachable_nodes = reachable_nodes * speed
+        reachable_nodes = nodes.merge(reachable_nodes, left_index=True, right_index=True)
+        clip_zone = reachable_nodes.buffer(reachable_nodes[source], resolution=4).union_all()
+
+        isochrone_edges = all_isochrones_edges.clip(clip_zone, keep_geom_type=True).explode(ignore_index=True)
+        geom_to_keep = isochrone_edges.sjoin(reachable_nodes, how="inner").index.unique()
+        isochrone = remove_inner_geom(isochrone_edges.loc[geom_to_keep].union_all())
+        results.append(isochrone)
+    return results

objectnat/methods/noise/__init__.py

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

objectnat/methods/noise/noise_sim.py

@@ -11,14 +11,14 @@ from shapely.ops import polygonize, unary_union
 from tqdm import tqdm
 
 from objectnat import config
-from objectnat.methods.noise.noise_reduce import dist_to_target_db, green_noise_reduce_db
 from objectnat.methods.noise.noise_exceptions import InvalidStepError
+from objectnat.methods.noise.noise_reduce import dist_to_target_db, green_noise_reduce_db
 from objectnat.methods.utils.geom_utils import (
     gdf_to_circle_zones_from_point,
     get_point_from_a_thorough_b,
     polygons_to_multilinestring,
 )
-from objectnat.methods.visibility_analysis import get_visibility_accurate
+from objectnat.methods.visibility.visibility_analysis import get_visibility_accurate
 
 logger = config.logger
 
@@ -87,10 +87,14 @@ def simulate_noise(
     db_sim_step = kwargs.get("db_sim_step", 1)
     reflection_n = kwargs.get("reflection_n", 3)
     dead_area_r = kwargs.get("dead_area_r", 5)
+
+    original_crs = source_points.crs
+
     div_ = (source_noise_db - target_noise_db) % db_sim_step
     if div_ != 0:
         raise InvalidStepError(source_noise_db, target_noise_db, db_sim_step, div_)
     # Choosing crs and simplifying obs if any
+    source_points = source_points.copy()
     if len(obstacles) > 0:
         obstacles = obstacles.copy()
         obstacles.geometry = obstacles.geometry.simplify(tolerance=1)
@@ -99,7 +103,6 @@ def simulate_noise(
         source_points.to_crs(local_crs, inplace=True)
     else:
         local_crs = source_points.estimate_utm_crs()
-        source_points = source_points.copy()
         source_points.to_crs(local_crs, inplace=True)
         source_points.reset_index(drop=True)
         source_points.geometry = source_points.centroid
@@ -158,7 +161,7 @@ def simulate_noise(
 
         noise_gdf = gpd.GeoDataFrame(pd.concat(noise_gdf, ignore_index=True), crs=local_crs)
         polygons = gpd.GeoDataFrame(
-            geometry=list(polygonize(noise_gdf.geometry.apply(polygons_to_multilinestring).unary_union)), crs=local_crs
+            geometry=list(polygonize(noise_gdf.geometry.apply(polygons_to_multilinestring).union_all())), crs=local_crs
         )
         polygons_points = polygons.copy()
         polygons_points.geometry = polygons.representative_point()
@@ -171,10 +174,10 @@ def simulate_noise(
         sim_result["source_point_ind"] = ind
         all_p_res.append(sim_result)
 
-    return gpd.GeoDataFrame(pd.concat(all_p_res, ignore_index=True), crs=local_crs)
+    return gpd.GeoDataFrame(pd.concat(all_p_res, ignore_index=True), crs=local_crs).to_crs(original_crs)
 
 
-def _noise_from_point_task(task, **kwargs) -> tuple[gpd.GeoDataFrame, list[tuple] | None]:
+def _noise_from_point_task(task, **kwargs) -> tuple[gpd.GeoDataFrame, list[tuple] | None]:  # pragma: no cover
     # Unpacking task
     point_from, obstacles, trees_orig, passed_dist, deep, dist_db = task
 
@@ -207,7 +210,7 @@ def _noise_from_point_task(task, **kwargs) -> tuple[gpd.GeoDataFrame, list[tuple
     if len(obstacles) == 0:
         obstacles_union = Polygon()
     else:
-        obstacles_union = obstacles.unary_union
+        obstacles_union = obstacles.union_all()
 
     vis_poly, max_view_dist = get_visibility_accurate(point_from, obstacles, dist, return_max_view_dist=True)
 
@@ -332,7 +335,7 @@ def _noise_from_point_task(task, **kwargs) -> tuple[gpd.GeoDataFrame, list[tuple
     vis_poly_points = gpd.GeoDataFrame(geometry=vis_poly_points, crs=local_crs)
 
     # Generating reflection points
-    vis_poly_points["point"] = vis_poly_points.geometry
+    vis_poly_points["point"] = vis_poly_points["geometry"].copy()
     vis_poly_points.geometry = vis_poly_points.geometry.buffer(1, resolution=1)
     vis_poly_points = vis_poly_points.sjoin(obstacles, predicate="intersects").drop(columns="index_right")
     vis_poly_points = vis_poly_points[~vis_poly_points.index.duplicated(keep="first")]
@@ -346,7 +349,7 @@ def _noise_from_point_task(task, **kwargs) -> tuple[gpd.GeoDataFrame, list[tuple
         return noise_from_point, None
     vis_poly_points = vis_poly_points[~vis_poly_points.is_empty]
     vis_poly_points = vis_poly_points[vis_poly_points.area >= 0.01]
-    vis_poly_points.geometry = vis_poly_points["point"]
+    vis_poly_points["geometry"] = vis_poly_points["point"]
     vis_poly_points["dist"] = vis_poly_points.distance(point_from)
     vis_poly_points = vis_poly_points[vis_poly_points["dist"] < max_dist - 5]
     vis_poly_points = vis_poly_points.sjoin(noise_from_point, predicate="intersects", how="left")
@@ -359,6 +362,8 @@ def _noise_from_point_task(task, **kwargs) -> tuple[gpd.GeoDataFrame, list[tuple
     # Creating new reflection tasks
     new_tasks = []
     for _, loc in vis_poly_points.iterrows():
+        if not isinstance(loc.geometry, Point):
+            continue
         new_passed_dist = round(loc.dist + passed_dist, 2)
         dist_last = max_dist - new_passed_dist
         if dist_last > 1:

objectnat/methods/point_clustering/__init__.py

@@ -0,0 +1 @@
+from .cluster_points_in_polygons import get_clusters_polygon

objectnat/methods/{cluster_points_in_polygons.py → point_clustering/cluster_points_in_polygons.py}

@@ -37,7 +37,7 @@ def get_clusters_polygon(
 ) -> tuple[gpd.GeoDataFrame, gpd.GeoDataFrame]:
     """
     Generate cluster polygons for given points based on a specified minimum distance and minimum points per cluster.
-    Optionally, calculate the relative ratio between types of services within the clusters.
+    Optionally, calculate the relative ratio between types of points within the clusters.
 
     Parameters
     ----------
@@ -56,22 +56,12 @@ def get_clusters_polygon(
     -------
     tuple[gpd.GeoDataFrame, gpd.GeoDataFrame]
         A tuple containing the clustered polygons GeoDataFrame and the original points GeoDataFrame with cluster labels.
-
-    Examples
-    --------
-    >>> import geopandas as gpd
-    >>> from shapely.geometry import Point
-
-    >>> points = gpd.GeoDataFrame({
-    ...     'geometry': [Point(0, 0), Point(1, 1), Point(2, 2)],
-    ...     'service_code': [1, 1, 2]
-    ... }, crs=4326)
-
-    >>> clusters, services = get_clusters_polygon(points, min_dist=50, min_point=2)
     """
     if method not in ["DBSCAN", "HDBSCAN"]:
         raise ValueError("Method must be either 'DBSCAN' or 'HDBSCAN'")
-
+    original_crs = points.crs
+    local_crs = points.estimate_utm_crs()
+    points = points.to_crs(local_crs)
     services_select = _get_cluster(points, min_dist, min_point, method)
 
     if service_code_column not in points.columns:
@@ -80,43 +70,47 @@ def get_clusters_polygon(
         )
         points[service_code_column] = service_code_column
 
-    services_normal = services_select[services_select["cluster"] != -1]
-    services_outlier = services_select[services_select["cluster"] == -1]
+    points_normal = services_select[services_select["cluster"] != -1].copy()
+    points_outlier = services_select[services_select["cluster"] == -1].copy()
 
-    if len(services_normal) > 0:
-        cluster_service = services_normal.groupby("cluster", group_keys=True).apply(
+    if len(points_normal) > 0:
+        cluster_service = points_normal.groupby("cluster", group_keys=True).apply(
             _get_service_ratio, service_code_column=service_code_column
         )
         if isinstance(cluster_service, pd.Series):
             cluster_service = cluster_service.unstack(level=1, fill_value=0)
 
-        polygons_normal = services_normal.dissolve("cluster").concave_hull(ratio=0.7, allow_holes=False)
+        polygons_normal = points_normal.dissolve("cluster").concave_hull(ratio=0.1, allow_holes=True)
         df_clusters_normal = pd.concat([cluster_service, polygons_normal.rename("geometry")], axis=1)
         cluster_normal = df_clusters_normal.index.max()
+        points_normal["outlier"] = False
+        df_clusters_normal["outlier"] = False
     else:
         df_clusters_normal = None
         cluster_normal = 0
 
-    if len(services_outlier) > 0:
+    if len(points_outlier) > 0:
         clusters_outlier = cluster_normal + 1
-        new_clusters = list(range(clusters_outlier, clusters_outlier + len(services_outlier)))
-        services_outlier.loc[:, "cluster"] = new_clusters
+        new_clusters = list(range(clusters_outlier, clusters_outlier + len(points_outlier)))
+        points_outlier.loc[:, "cluster"] = new_clusters
 
-        cluster_service = services_outlier.groupby("cluster", group_keys=True).apply(
+        cluster_service = points_outlier.groupby("cluster", group_keys=True).apply(
             _get_service_ratio, service_code_column=service_code_column
         )
         if isinstance(cluster_service, pd.Series):
             cluster_service = cluster_service.unstack(level=1, fill_value=0)
 
-        df_clusters_outlier = cluster_service.join(services_outlier.set_index("cluster")["geometry"])
+        df_clusters_outlier = cluster_service.join(points_outlier.set_index("cluster")["geometry"])
+        points_outlier["outlier"] = True
+        df_clusters_outlier["outlier"] = True
     else:
-        services_outlier = None
+        points_outlier = None
         df_clusters_outlier = None
 
     df_clusters = pd.concat([df_clusters_normal, df_clusters_outlier]).fillna(0).set_geometry("geometry")
     df_clusters["geometry"] = df_clusters["geometry"].buffer(min_dist / 2)
-    df_clusters = df_clusters.rename(columns={"index": "cluster_id"})
+    df_clusters = df_clusters.reset_index().rename(columns={"index": "cluster"})
 
-    services = pd.concat([services_normal, services_outlier])
+    points = pd.concat([points_normal, points_outlier])
 
-    return df_clusters, services
+    return df_clusters.to_crs(original_crs), points.to_crs(original_crs)

objectnat/methods/provision/__init__.py

@@ -0,0 +1 @@
+from .provision import clip_provision, get_service_provision, recalculate_links

objectnat/methods/provision/provision.py

@@ -61,7 +61,7 @@ def clip_provision(
     links = links.copy()
     services = services.copy()
 
-    s = buildings.intersects(selection_zone.unary_union)
+    s = buildings.intersects(selection_zone.union_all())
     buildings = buildings.loc[s[s].index]
     links = links[links["building_index"].isin(buildings.index.tolist())]
     services_to_keep = set(links["service_index"].tolist())
@@ -88,14 +88,14 @@ def recalculate_links(
     )
     free_demand["demand"] = free_demand["demand"].apply(sum)
     free_demand = free_demand.reindex(buildings.index, fill_value=0)
-    new_sum_time = (buildings["supplyed_demands_within"] + buildings["supplyed_demands_without"]) * buildings[
+    new_sum_time = (buildings["supplied_demands_within"] + buildings["supplied_demands_without"]) * buildings[
         "avg_dist"
     ] - free_demand["distance"]
 
     buildings["demand_left"] = buildings["demand_left"] + free_demand["demand"]
-    buildings["supplyed_demands_without"] = buildings["supplyed_demands_without"] - free_demand["demand"]
+    buildings["supplied_demands_without"] = buildings["supplied_demands_without"] - free_demand["demand"]
     buildings["avg_dist"] = new_sum_time / (
-        buildings["supplyed_demands_without"] + buildings["supplyed_demands_within"]
+        buildings["supplied_demands_without"] + buildings["supplied_demands_within"]
     )
     buildings["avg_dist"] = buildings.apply(
         lambda x: np.nan if (x["demand"] == x["demand_left"]) else round(x["avg_dist"], 2), axis=1

objectnat/methods/provision/provision_model.py

@@ -23,7 +23,6 @@ class Provision:
         demanded_buildings (gpd.GeoDataFrame): GeoDataFrame representing the buildings with demands for services.
         adjacency_matrix (pd.DataFrame): DataFrame representing the adjacency matrix between buildings.
         threshold (int): Threshold value for the provision calculations.
-        calculation_type (str, optional): Type of calculation ("gravity" or "linear"). Defaults to "gravity".
 
     Returns:
         Provision: The CityProvision object.
@@ -48,7 +47,7 @@ class Provision:
             adjacency_matrix.copy(), demanded_buildings, services
         ).copy()
         self.threshold = threshold
-        self.check_crs(self.demanded_buildings, self.services)
+        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
@@ -65,14 +64,6 @@ class Provision:
         v["capacity_left"] = v["capacity"]
         return v
 
-    @staticmethod
-    def check_crs(demanded_buildings, services):
-        assert demanded_buildings.crs == services.crs, (
-            f"\nThe CRS in the provided geodataframes are different."
-            f"\nBuildings CRS:{demanded_buildings.crs}"
-            f"\nServices CRS:{services.crs}"
-        )
-
     @staticmethod
     def delete_useless_matrix_rows_columns(adjacency_matrix, demanded_buildings, services):
         adjacency_matrix.index = adjacency_matrix.index.astype(int)
@@ -268,7 +259,15 @@ def _calc_links(
     flat_matrix = destination_matrix.transpose().apply(lambda x: subfunc(x[x > 0]), result_type="reduce")
 
     distribution_links = gpd.GeoDataFrame(data=[item for sublist in list(flat_matrix) for item in sublist])
-
+    if distribution_links.empty:
+        logger.warning(
+            "Unable to create distribution links - no demand could be matched with service locations. "
+            "This is likely because either: "
+            "1) The demand column in buildings contains zero values, or "
+            "2) The capacity column in services contains zero values, or "
+            "3) There are no service locations within the maximum allowed distance"
+        )
+        return distribution_links
     distribution_links["distance"] = distribution_links.apply(
         lambda x: distance_matrix.loc[x["service_index"]][x["building_index"]],
         axis=1,
@@ -292,8 +291,8 @@ def _additional_options(
     normative_distance,
 ):
     buildings["avg_dist"] = 0
-    buildings["supplyed_demands_within"] = 0
-    buildings["supplyed_demands_without"] = 0
+    buildings["supplied_demands_within"] = 0
+    buildings["supplied_demands_without"] = 0
     services["carried_capacity_within"] = 0
     services["carried_capacity_without"] = 0
     for _, loc in destination_matrix.iterrows():
@@ -310,8 +309,8 @@ def _additional_options(
             .add(distances_all.multiply(without, fill_value=0), fill_value=0)
         )
         buildings["demand_left"] = buildings["demand_left"].sub(within.add(without, fill_value=0), fill_value=0)
-        buildings["supplyed_demands_within"] = buildings["supplyed_demands_within"].add(within, fill_value=0)
-        buildings["supplyed_demands_without"] = buildings["supplyed_demands_without"].add(without, fill_value=0)
+        buildings["supplied_demands_within"] = buildings["supplied_demands_within"].add(within, fill_value=0)
+        buildings["supplied_demands_without"] = buildings["supplied_demands_without"].add(without, fill_value=0)
 
         services.at[loc.name, "capacity_left"] = (
             services.at[loc.name, "capacity_left"] - within.add(without, fill_value=0).sum()
@@ -329,10 +328,10 @@ def _additional_options(
     buildings["avg_dist"] = buildings.apply(
         lambda x: np.nan if (x["demand"] == x["demand_left"]) else round(x["avg_dist"], 2), axis=1
     )
-    buildings["provison_value"] = (buildings["supplyed_demands_within"] / buildings["demand"]).astype(float).round(2)
+    buildings["provision_value"] = (buildings["supplied_demands_within"] / buildings["demand"]).astype(float).round(2)
     services["service_load"] = (services["capacity"] - services["capacity_left"]).astype(np.uint16)
-    buildings["supplyed_demands_within"] = buildings["supplyed_demands_within"].astype(np.uint16)
-    buildings["supplyed_demands_without"] = buildings["supplyed_demands_without"].astype(np.uint16)
+    buildings["supplied_demands_within"] = buildings["supplied_demands_within"].astype(np.uint16)
+    buildings["supplied_demands_without"] = buildings["supplied_demands_without"].astype(np.uint16)
     services["carried_capacity_within"] = services["carried_capacity_within"].astype(np.uint16)
     services["carried_capacity_without"] = services["carried_capacity_without"].astype(np.uint16)
     logger.debug("Done adding additional options")