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

objectnat/methods/utils/geom_utils.py

@@ -1,7 +1,7 @@
 import math
 
 import geopandas as gpd
-from shapely import LineString, MultiLineString, MultiPolygon, Point, Polygon
+from shapely import LineString, MultiPolygon, Point, Polygon
 from shapely.ops import polygonize, unary_union
 
 from objectnat import config
@@ -10,6 +10,9 @@ 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)
@@ -60,12 +63,12 @@ def gdf_to_circle_zones_from_point(
     """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).unary_union
+    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)
-        .unary_union
+        .union_all()
     )
     zones_lines = [LineString([Point(coords1), Point(point_from)]) for coords1 in buffer.exterior.coords[:-1]]
     if explode_multigeom:
@@ -77,3 +80,51 @@ def gdf_to_circle_zones_from_point(
     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,
+)