ObjectNat 1.2.2__py3-none-any.whl → 1.3.0__py3-none-any.whl

objectnat/methods/utils/__init__.py

@@ -1 +1 @@
-from .graph_utils import gdf_to_graph, graph_to_gdf
+from .graph_utils import gdf_to_graph, graph_to_gdf

objectnat/methods/utils/geom_utils.py

@@ -1,173 +1,173 @@
-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)
-        lines.append(exterior)
-        interior = [LineString(p) 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
-
-
-def distribute_points_on_linestrings(lines: gpd.GeoDataFrame, radius, lloyd_relax_n=2) -> gpd.GeoDataFrame:
-    lines = lines.copy()
-    lines = lines.explode(ignore_index=True)
-    lines = lines[lines.geom_type == "LineString"]
-    original_crs = lines.crs
-    lines = lines.to_crs(crs=lines.estimate_utm_crs())
-    lines = lines.reset_index(drop=True)
-    lines = lines[["geometry"]]
-    radius = radius * 1.1
-    segmentized = lines.geometry.apply(lambda x: x.simplify(radius).segmentize(radius))
-    points = [Point(pt) for line in segmentized for pt in line.coords]
-
-    points = gpd.GeoDataFrame(geometry=points, crs=lines.crs)
-    lines["lines"] = lines.geometry
-    geom_concave = lines.buffer(5, resolution=1).union_all()
-
-    for i in range(lloyd_relax_n):
-        points.geometry = points.voronoi_polygons().clip(geom_concave).centroid
-        points = points.sjoin_nearest(lines, how="left")
-        points = points[~points.index.duplicated(keep="first")]
-        points["geometry"] = points["lines"].interpolate(points["lines"].project(points.geometry))
-        points.drop(columns=["lines", "index_right"], inplace=True)
-
-    return points.dropna().to_crs(original_crs)
-
-
-def distribute_points_on_polygons(
-    polygons: gpd.GeoDataFrame, radius, only_exterior=True, lloyd_relax_n=2
-) -> gpd.GeoDataFrame:
-    polygons = polygons.copy()
-    polygons = polygons.explode(ignore_index=True)
-    polygons = polygons[polygons.geom_type == "Polygon"]
-
-    if only_exterior:
-        polygons.geometry = polygons.geometry.apply(lambda x: LineString(x.exterior))
-    else:
-        polygons = gpd.GeoDataFrame(
-            geometry=list(polygons.geometry.apply(polygons_to_multilinestring)), crs=polygons.crs
-        )
-
-    return distribute_points_on_linestrings(polygons, radius, lloyd_relax_n=lloyd_relax_n)
+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)
+        lines.append(exterior)
+        interior = [LineString(p) 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
+
+
+def distribute_points_on_linestrings(lines: gpd.GeoDataFrame, radius, lloyd_relax_n=2) -> gpd.GeoDataFrame:
+    lines = lines.copy()
+    lines = lines.explode(ignore_index=True)
+    lines = lines[lines.geom_type == "LineString"]
+    original_crs = lines.crs
+    lines = lines.to_crs(crs=lines.estimate_utm_crs())
+    lines = lines.reset_index(drop=True)
+    lines = lines[["geometry"]]
+    radius = radius * 1.1
+    segmentized = lines.geometry.apply(lambda x: x.simplify(radius).segmentize(radius))
+    points = [Point(pt) for line in segmentized for pt in line.coords]
+
+    points = gpd.GeoDataFrame(geometry=points, crs=lines.crs)
+    lines["lines"] = lines.geometry
+    geom_concave = lines.buffer(5, resolution=1).union_all()
+
+    for i in range(lloyd_relax_n):
+        points.geometry = points.voronoi_polygons().clip(geom_concave).centroid
+        points = points.sjoin_nearest(lines, how="left")
+        points = points[~points.index.duplicated(keep="first")]
+        points["geometry"] = points["lines"].interpolate(points["lines"].project(points.geometry))
+        points.drop(columns=["lines", "index_right"], inplace=True)
+
+    return points.dropna().to_crs(original_crs)
+
+
+def distribute_points_on_polygons(
+    polygons: gpd.GeoDataFrame, radius, only_exterior=True, lloyd_relax_n=2
+) -> gpd.GeoDataFrame:
+    polygons = polygons.copy()
+    polygons = polygons.explode(ignore_index=True)
+    polygons = polygons[polygons.geom_type == "Polygon"]
+
+    if only_exterior:
+        polygons.geometry = polygons.geometry.apply(lambda x: LineString(x.exterior))
+    else:
+        polygons = gpd.GeoDataFrame(
+            geometry=list(polygons.geometry.apply(polygons_to_multilinestring)), crs=polygons.crs
+        )
+
+    return distribute_points_on_linestrings(polygons, radius, lloyd_relax_n=lloyd_relax_n)

objectnat/methods/utils/graph_utils.py

@@ -51,7 +51,7 @@ def graph_to_gdf(
     """
     Converts nx graph to gpd.GeoDataFrame as edges.
 
-    Parameters:
+    Args:
         graph (nx.MultiDiGraph):
             The graph to convert.
         edges (bool):
@@ -98,7 +98,7 @@ def gdf_to_graph(
     Intersections are optionally checked and merged. Attributes from the original GeoDataFrame
     can be projected onto the graph edges using spatial matching.
 
-    Parameters:
+    Args:
         gdf (gpd.GeoDataFrame): A GeoDataFrame containing at least one LineString geometry.
         project_gdf_attr (bool): If True, attributes from the input GeoDataFrame will be spatially
             projected onto the resulting graph edges. This can be an expensive operation for large datasets.
@@ -193,7 +193,7 @@ def get_closest_nodes_from_gdf(gdf: gpd.GeoDataFrame, nx_graph: nx.Graph) -> tup
     """
     Finds the closest graph nodes to the geometries in a GeoDataFrame.
 
-    Parameters
+    Args
     ----------
     gdf : gpd.GeoDataFrame
         GeoDataFrame with geometries for which the nearest graph nodes will be found.
@@ -228,7 +228,7 @@ def remove_weakly_connected_nodes(graph: nx.DiGraph) -> nx.DiGraph:
     """
     Removes all nodes that are not part of the largest strongly connected component in the graph.
 
-    Parameters
+    Args
     ----------
     graph : nx.DiGraph
         A directed NetworkX graph.
@@ -275,7 +275,7 @@ def reverse_graph(nx_graph: nx.Graph, weight: str) -> tuple[nx.Graph, nx.DiGraph
     For directed graphs, the function returns a new graph with all edge directions reversed,
     preserving the specified edge weight.
 
-    Parameters
+    Args
     ----------
     nx_graph : nx.Graph
         Input NetworkX graph (can be directed or undirected).

objectnat/methods/utils/math_utils.py

@@ -1,32 +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
+import numpy as np
+
+
+def min_max_normalization(data, new_min=0, new_max=1):
+    """
+    Min-max normalization for a given array of data.
+
+    Args
+    ----------
+    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

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

objectnat/methods/visibility/visibility_analysis.py

@@ -4,7 +4,6 @@ from multiprocessing import cpu_count
 import geopandas as gpd
 import numpy as np
 import pandas as pd
-from pandarallel import pandarallel
 from shapely import LineString, MultiPolygon, Point, Polygon
 from shapely.ops import unary_union
 from tqdm.contrib.concurrent import process_map
@@ -28,7 +27,7 @@ def get_visibility_accurate(
     """
     Function to get accurate visibility from a given point to buildings within a given distance.
 
-    Parameters:
+    Args:
         point_from (Point | gpd.GeoDataFrame):
             The point or GeoDataFrame with 1 point from which the line of sight is drawn.
             If Point is provided it should be in the same crs as obstacles.
@@ -165,7 +164,7 @@ def get_visibility(
     """
     Function to get a quick estimate of visibility from a given point to buildings within a given distance.
 
-    Parameters:
+    Args:
         point_from (Point | gpd.GeoDataFrame):
             The point or GeoDataFrame with 1 point from which the line of sight is drawn.
             If Point is provided it should be in the same crs as obstacles.
@@ -239,7 +238,7 @@ def get_visibilities_from_points(
     """
     Calculate visibility polygons from a set of points considering obstacles within a specified view distance.
 
-    Parameters:
+    Args:
         points (gpd.GeoDataFrame):
             GeoDataFrame containing the points from which visibility is calculated.
         obstacles (gpd.GeoDataFrame):
@@ -297,7 +296,7 @@ def calculate_visibility_catchment_area(
     This function is designed to work with at least 1000 points spaced 10-20 meters apart for optimal results.
     Points can be generated using a road graph.
 
-    Parameters:
+    Args:
         points (gpd.GeoDataFrame): GeoDataFrame containing the points from which visibility is calculated.
         obstacles (gpd.GeoDataFrame): GeoDataFrame containing the obstacles that block visibility.
         view_distance (int | float): The maximum distance from each point within which visibility is calculated.
@@ -313,21 +312,12 @@ def calculate_visibility_catchment_area(
         return x
 
     def calc_group_factor(x):
-        # pylint: disable-next=redefined-outer-name,reimported,import-outside-toplevel
-        import numpy as np
-
         return np.mean(x.new_ratio) * x.count_n
 
     def unary_union_groups(x):
-        # pylint: disable-next=redefined-outer-name,reimported,import-outside-toplevel
-        from shapely import MultiPolygon
-
-        # pylint: disable-next=redefined-outer-name,reimported,import-outside-toplevel
-        from shapely.ops import unary_union
-
         return unary_union(MultiPolygon(list(x["geometry"])).buffer(0))
 
-    pandarallel.initialize(progress_bar=True, verbose=0)
+    raise NotImplementedError("This method is temporarily unsupported.")
 
     local_crs = obstacles.estimate_utm_crs()
     obstacles = obstacles.to_crs(local_crs)
@@ -370,7 +360,7 @@ def calculate_visibility_catchment_area(
     all_in["count_n"] = all_in["index_right"].apply(len)
 
     logger.info("Calculating intersection's parameters")
-    all_in["factor"] = all_in.parallel_apply(calc_group_factor, axis=1)
+    # all_in["factor"] = all_in.parallel_apply(calc_group_factor, axis=1) # TODO replace pandarallel methods
     threshold = all_in["factor"].quantile(0.3)
     all_in = all_in[all_in["factor"] > threshold]
 
@@ -378,7 +368,9 @@ def calculate_visibility_catchment_area(
         min_max_normalization(np.sqrt(all_in["factor"].values), new_min=1, new_max=5)
     ).astype(int)
     logger.info("Calculating normalized groups geometry...")
-    all_in = all_in.groupby("factor_normalized").parallel_apply(unary_union_groups).reset_index()
+    all_in = (
+        all_in.groupby("factor_normalized").parallel_apply(unary_union_groups).reset_index()
+    )  # TODO replace pandarallel methods
     all_in = gpd.GeoDataFrame(data=all_in.rename(columns={0: "geometry"}), geometry="geometry", crs=32636)
 
     all_in = all_in.explode(index_parts=True).reset_index(drop=True)