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

objectnat/methods/provision/provision_model.py

@@ -19,11 +19,10 @@ class Provision:
     Represents the logic for city provision calculations using a gravity or linear model.
 
     Args:
-        services (InstanceOf[gpd.GeoDataFrame]): GeoDataFrame representing the services available in the city.
-        demanded_buildings (InstanceOf[gpd.GeoDataFrame]): GeoDataFrame representing the buildings with demands for services.
-        adjacency_matrix (InstanceOf[pd.DataFrame]): DataFrame representing the adjacency matrix between buildings.
+        services (gpd.GeoDataFrame): GeoDataFrame representing the services available in the city.
+        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,12 +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.\nBuildings CRS:{demanded_buildings.crs}\nServices CRS:{services.crs} \n"
-
     @staticmethod
     def delete_useless_matrix_rows_columns(adjacency_matrix, demanded_buildings, services):
         adjacency_matrix.index = adjacency_matrix.index.astype(int)
@@ -266,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,
@@ -290,11 +291,11 @@ 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 i, loc in destination_matrix.iterrows():
+    for _, loc in destination_matrix.iterrows():
         distances_all = matrix.loc[loc.name]
         distances = distances_all[distances_all <= normative_distance]
         s = matrix.loc[loc.name] <= normative_distance
@@ -308,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()
@@ -327,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")

objectnat/methods/utils/geom_utils.py

@@ -0,0 +1,130 @@
+import math
+
+import geopandas as gpd
+from shapely import LineString, MultiPolygon, Point, Polygon
+from shapely.ops import polygonize, unary_union
+
+from objectnat import config
+
+logger = config.logger
+
+
+def polygons_to_multilinestring(geom: Polygon | MultiPolygon):
+    # pylint: disable-next=redefined-outer-name,reimported,import-outside-toplevel
+    from shapely import LineString, MultiLineString, MultiPolygon
+
+    def convert_polygon(polygon: Polygon):
+        lines = []
+        exterior = LineString(polygon.exterior.coords)
+        lines.append(exterior)
+        interior = [LineString(p.coords) for p in polygon.interiors]
+        lines = lines + interior
+        return lines
+
+    def convert_multipolygon(polygon: MultiPolygon):
+        return MultiLineString(sum([convert_polygon(p) for p in polygon.geoms], []))
+
+    if geom.geom_type == "Polygon":
+        return MultiLineString(convert_polygon(geom))
+    return convert_multipolygon(geom)
+
+
+def explode_linestring(geometry: LineString) -> list[LineString]:
+    """A function to return all segments of a linestring as a list of linestrings"""
+    coords_ext = geometry.coords  # Create a list of all line node coordinates
+    result = [LineString(part) for part in zip(coords_ext, coords_ext[1:])]
+    return result
+
+
+def point_side_of_line(line: LineString, point: Point) -> int:
+    """A positive indicates the left-hand side a negative indicates the right-hand side"""
+    x1, y1 = line.coords[0]
+    x2, y2 = line.coords[-1]
+    x, y = point.coords[0]
+    cross_product = (x2 - x1) * (y - y1) - (y2 - y1) * (x - x1)
+    if cross_product > 0:
+        return 1
+    return -1
+
+
+def get_point_from_a_thorough_b(a: Point, b: Point, dist):
+    """
+    Func to get Point from point a thorough point b on dist
+    """
+    direction = math.atan2(b.y - a.y, b.x - a.x)
+    c_x = a.x + dist * math.cos(direction)
+    c_y = a.y + dist * math.sin(direction)
+    return Point(c_x, c_y)
+
+
+def gdf_to_circle_zones_from_point(
+    gdf: gpd.GeoDataFrame, point_from: Point, zone_radius, resolution=4, explode_multigeom=True
+) -> gpd.GeoDataFrame:
+    """n_segments = 4*resolution,e.g. if resolution = 4 that means there will be 16 segments"""
+    crs = gdf.crs
+    buffer = point_from.buffer(zone_radius, resolution=resolution)
+    gdf_unary = gdf.clip(buffer, keep_geom_type=True).union_all()
+    gdf_geometry = (
+        gpd.GeoDataFrame(geometry=[gdf_unary], crs=crs)
+        .explode(index_parts=True)
+        .geometry.apply(polygons_to_multilinestring)
+        .union_all()
+    )
+    zones_lines = [LineString([Point(coords1), Point(point_from)]) for coords1 in buffer.exterior.coords[:-1]]
+    if explode_multigeom:
+        return (
+            gpd.GeoDataFrame(geometry=list(polygonize(unary_union([gdf_geometry] + zones_lines))), crs=crs)
+            .clip(gdf_unary, keep_geom_type=True)
+            .explode(index_parts=False)
+        )
+    return gpd.GeoDataFrame(geometry=list(polygonize(unary_union([gdf_geometry] + zones_lines))), crs=crs).clip(
+        gdf_unary, keep_geom_type=True
+    )
+
+
+def remove_inner_geom(polygon: Polygon | MultiPolygon):
+    """function to get rid of inner polygons"""
+    if isinstance(polygon, Polygon):
+        return Polygon(polygon.exterior.coords)
+    if isinstance(polygon, MultiPolygon):
+        polys = []
+        for poly in polygon.geoms:
+            polys.append(Polygon(poly.exterior.coords))
+        return MultiPolygon(polys)
+    else:
+        return Polygon()
+
+
+def combine_geometry(gdf: gpd.GeoDataFrame) -> gpd.GeoDataFrame:
+    """
+    Combine geometry of intersecting layers into a single GeoDataFrame.
+    Parameters
+    ----------
+    gdf: gpd.GeoDataFrame
+        A GeoPandas GeoDataFrame
+
+    Returns
+    -------
+    gpd.GeoDataFrame
+        The combined GeoDataFrame with aggregated in lists columns.
+
+    Examples
+    --------
+    >>> gdf = gpd.read_file('path_to_your_file.geojson')
+    >>> result = combine_geometry(gdf)
+    """
+
+    crs = gdf.crs
+
+    enclosures = gpd.GeoDataFrame(
+        geometry=list(polygonize(gdf["geometry"].apply(polygons_to_multilinestring).union_all())), crs=crs
+    )
+    enclosures_points = enclosures.copy()
+    enclosures_points.geometry = enclosures.representative_point()
+    joined = gpd.sjoin(enclosures_points, gdf, how="inner", predicate="within").reset_index()
+    cols = joined.columns.tolist()
+    cols.remove("geometry")
+    joined = joined.groupby("index").agg({column: list for column in cols})
+    joined["geometry"] = enclosures
+    joined = gpd.GeoDataFrame(joined, geometry="geometry", crs=crs)
+    return joined

objectnat/methods/utils/graph_utils.py

@@ -0,0 +1,127 @@
+import geopandas as gpd
+import networkx as nx
+import numpy as np
+import pandas as pd
+from loguru import logger
+from scipy.spatial import KDTree
+from shapely import LineString
+from shapely.geometry.point import Point
+
+
+def _edges_to_gdf(graph: nx.Graph, crs) -> gpd.GeoDataFrame:
+    """
+    Converts nx graph to gpd.GeoDataFrame as edges.
+    """
+    graph_df = pd.DataFrame(list(graph.edges(data=True)), columns=["u", "v", "data"])
+    edge_data_expanded = pd.json_normalize(graph_df["data"])
+    graph_df = pd.concat([graph_df.drop(columns=["data"]), edge_data_expanded], axis=1)
+    graph_df = gpd.GeoDataFrame(graph_df, geometry="geometry", crs=crs).set_index(["u", "v"])
+    graph_df["geometry"] = graph_df["geometry"].fillna(LineString())
+    return graph_df
+
+
+def _nodes_to_gdf(graph: nx.Graph, crs: int) -> gpd.GeoDataFrame:
+    """
+    Converts nx graph to gpd.GeoDataFrame as nodes.
+    """
+
+    ind, data = zip(*graph.nodes(data=True))
+    node_geoms = (Point(d["x"], d["y"]) for d in data)
+    gdf_nodes = gpd.GeoDataFrame(data, index=ind, crs=crs, geometry=list(node_geoms))
+
+    return gdf_nodes
+
+
+def _restore_edges_geom(nodes_gdf, edges_gdf) -> gpd.GeoDataFrame:
+    edges_wout_geom = edges_gdf[edges_gdf["geometry"].is_empty].reset_index()
+    edges_wout_geom["geometry"] = [
+        LineString((s, e))
+        for s, e in zip(
+            nodes_gdf.loc[edges_wout_geom["u"], "geometry"], nodes_gdf.loc[edges_wout_geom["v"], "geometry"]
+        )
+    ]
+    edges_wout_geom.set_index(["u", "v"], inplace=True)
+    edges_gdf.update(edges_wout_geom)
+    return edges_gdf
+
+
+def graph_to_gdf(
+    graph: nx.MultiDiGraph | nx.Graph | nx.DiGraph, edges: bool = True, nodes: bool = True, restore_edge_geom=False
+) -> gpd.GeoDataFrame | tuple[gpd.GeoDataFrame, gpd.GeoDataFrame]:
+    """
+    Converts nx graph to gpd.GeoDataFrame as edges.
+
+    Parameters
+    ----------
+    graph : nx.MultiDiGraph
+        The graph to convert.
+    edges: bool, default to True
+        Keep edges in GoeDataFrame.
+    nodes: bool, default to True
+        Keep nodes in GoeDataFrame.
+    restore_edge_geom: bool, default to False
+        if True, will try to restore edge geometry from nodes.
+    Returns
+    -------
+    gpd.GeoDataFrame | tuple[gpd.GeoDataFrame, gpd.GeoDataFrame]
+        Graph representation in GeoDataFrame format, either nodes or nodes,or tuple of them nodes,edges.
+    """
+    try:
+        crs = graph.graph["crs"]
+    except KeyError as exc:
+        raise ValueError("Graph does not have crs attribute") from exc
+    if not edges and not nodes:
+        raise AttributeError("Neither edges or nodes were selected")
+    if nodes and not edges:
+        nodes_gdf = _nodes_to_gdf(graph, crs)
+        return nodes_gdf
+    if not nodes and edges:
+        edges_gdf = _edges_to_gdf(graph, crs)
+        if restore_edge_geom:
+            nodes_gdf = _nodes_to_gdf(graph, crs)
+            edges_gdf = _restore_edges_geom(nodes_gdf, edges_gdf)
+        return edges_gdf
+
+    nodes_gdf = _nodes_to_gdf(graph, crs)
+    edges_gdf = _edges_to_gdf(graph, crs)
+    if restore_edge_geom:
+        edges_gdf = _restore_edges_geom(nodes_gdf, edges_gdf)
+    return nodes_gdf, edges_gdf
+
+
+def get_closest_nodes_from_gdf(gdf: gpd.GeoDataFrame, nx_graph: nx.Graph) -> tuple:
+    nodes_with_data = list(nx_graph.nodes(data=True))
+    try:
+        coordinates = np.array([(data["x"], data["y"]) for node, data in nodes_with_data])
+    except KeyError as e:
+        raise ValueError("Graph does not have coordinates attribute") from e
+    tree = KDTree(coordinates)
+    target_coord = [(p.x, p.y) for p in gdf.representative_point()]
+    distances, indices = tree.query(target_coord)
+    nearest_nodes = [nodes_with_data[idx][0] for idx in indices]
+    return distances, nearest_nodes
+
+
+def remove_weakly_connected_nodes(graph: nx.DiGraph) -> nx.DiGraph:
+    graph = graph.copy()
+
+    weakly_connected_components = list(nx.weakly_connected_components(graph))
+    if len(weakly_connected_components) > 1:
+        logger.warning(
+            f"Found {len(weakly_connected_components)} disconnected subgraphs in the network. "
+            f"These are isolated groups of nodes with no connections between them. "
+            f"Size of components: {[len(c) for c in weakly_connected_components]}"
+        )
+
+    all_scc = sorted(nx.strongly_connected_components(graph), key=len)
+    nodes_to_del = set().union(*all_scc[:-1])
+
+    if nodes_to_del:
+        logger.warning(
+            f"Removing {len(nodes_to_del)} nodes that form {len(all_scc) - 1} trap components. "
+            f"These are groups where you can enter but can't exit (or vice versa). "
+            f"Keeping the largest strongly connected component ({len(all_scc[-1])} nodes)."
+        )
+        graph.remove_nodes_from(nodes_to_del)
+
+    return graph

objectnat/methods/utils/math_utils.py

@@ -0,0 +1,32 @@
+import numpy as np
+
+
+def min_max_normalization(data, new_min=0, new_max=1):
+    """
+    Min-max normalization for a given array of data.
+
+    Parameters
+    ----------
+    data: numpy.ndarray
+        Input data to be normalized.
+    new_min: float, optional
+        New minimum value for normalization. Defaults to 0.
+    new_max: float, optional
+        New maximum value for normalization. Defaults to 1.
+
+    Returns
+    -------
+    numpy.ndarray
+        Normalized data.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> data = np.array([1, 2, 3, 4, 5])
+    >>> normalized_data = min_max_normalization(data, new_min=0, new_max=1)
+    """
+
+    min_value = np.min(data)
+    max_value = np.max(data)
+    normalized_data = (data - min_value) / (max_value - min_value) * (new_max - new_min) + new_min
+    return normalized_data

objectnat/methods/visibility/__init__.py

@@ -0,0 +1,6 @@
+from .visibility_analysis import (
+    calculate_visibility_catchment_area,
+    get_visibilities_from_points,
+    get_visibility,
+    get_visibility_accurate,
+)