BERATools 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

beratools/core/algo_centerline.py

@@ -10,9 +10,10 @@ Description:
     This script is part of the BERA Tools.
     Webpage: https://github.com/appliedgrg/beratools
 
-    This file is intended to be hosting algorithms and utility functions/classes 
+    This file is intended to be hosting algorithms and utility functions/classes
     for centerline tool.
 """
+
 import enum
 from itertools import compress
 
@@ -30,23 +31,40 @@ import beratools.core.algo_cost as algo_cost
 import beratools.core.algo_dijkstra as bt_dijkstra
 import beratools.core.constants as bt_const
 import beratools.core.tool_base as bt_base
-import beratools.tools.common as bt_common
+import beratools.utility.spatial_common as sp_common
 
 
 class CenterlineParams(float, enum.Enum):
+    """
+    Parameters for centerline generation.
+
+    These parameters are used to control the behavior of centerline generation
+    and should be adjusted based on the specific requirements of the application.
+    """
+
     BUFFER_CLIP = 5.0
     SEGMENTIZE_LENGTH = 1.0
     SIMPLIFY_LENGTH = 0.5
     SMOOTH_SIGMA = 0.8
     CLEANUP_POLYGON_BY_AREA = 1.0
 
+
 @enum.unique
 class CenterlineStatus(enum.IntEnum):
+    """
+    Status of centerline generation.
+
+    This enum is used to indicate the status of centerline generation.
+    It can be used to track the success or failure of the centerline generation process.
+
+    """
+
     SUCCESS = 1
     FAILED = 2
     REGENERATE_SUCCESS = 3
     REGENERATE_FAILED = 4
 
+
 def centerline_is_valid(centerline, input_line):
     """
     Check if centerline is valid.
@@ -66,10 +84,8 @@ def centerline_is_valid(centerline, input_line):
     # centerline length less the half of least cost path
     if (
         centerline.length < input_line.length / 2
-        or centerline.distance(sh_geom.Point(input_line.coords[0]))
-        > bt_const.BT_EPSILON
-        or centerline.distance(sh_geom.Point(input_line.coords[-1]))
-        > bt_const.BT_EPSILON
+        or centerline.distance(sh_geom.Point(input_line.coords[0])) > bt_const.BT_EPSILON
+        or centerline.distance(sh_geom.Point(input_line.coords[-1])) > bt_const.BT_EPSILON
     ):
         return False
 
@@ -80,12 +96,12 @@ def snap_end_to_end(in_line, line_reference):
     if type(in_line) is sh_geom.MultiLineString:
         in_line = sh_ops.linemerge(in_line)
         if type(in_line) is sh_geom.MultiLineString:
-            print(f'algo_centerline: MultiLineString found {in_line.centroid}, pass.')
+            print(f"algo_centerline: MultiLineString found {in_line.centroid}, pass.")
             return None
 
     pts = list(in_line.coords)
     if len(pts) < 2:
-        print('snap_end_to_end: input line invalid.')
+        print("snap_end_to_end: input line invalid.")
         return in_line
 
     line_start = sh_geom.Point(pts[0])
@@ -123,17 +139,15 @@ def find_centerline(poly, input_line):
     """
     default_return = input_line, CenterlineStatus.FAILED
     if not poly:
-        print('find_centerline: No polygon found')
+        print("find_centerline: No polygon found")
         return default_return
 
-    poly = shapely.segmentize(
-        poly, max_segment_length=CenterlineParams.SEGMENTIZE_LENGTH
-    )
+    poly = shapely.segmentize(poly, max_segment_length=CenterlineParams.SEGMENTIZE_LENGTH)
 
     # buffer to reduce MultiPolygons
-    poly = poly.buffer(bt_const.SMALL_BUFFER)  
+    poly = poly.buffer(bt_const.SMALL_BUFFER)
     if type(poly) is sh_geom.MultiPolygon:
-        print('sh_geom.MultiPolygon encountered, skip.')
+        print("sh_geom.MultiPolygon encountered, skip.")
         return default_return
 
     exterior_pts = list(poly.exterior.coords)
@@ -146,16 +160,8 @@ def find_centerline(poly, input_line):
     line_coords = list(input_line.coords)
 
     # TODO add more code to filter Voronoi vertices
-    src_geom = (
-        sh_geom.Point(line_coords[0])
-        .buffer(CenterlineParams.BUFFER_CLIP * 3)
-        .intersection(poly)
-    )
-    dst_geom = (
-        sh_geom.Point(line_coords[-1])
-        .buffer(CenterlineParams.BUFFER_CLIP * 3)
-        .intersection(poly)
-    )
+    src_geom = sh_geom.Point(line_coords[0]).buffer(CenterlineParams.BUFFER_CLIP * 3).intersection(poly)
+    dst_geom = sh_geom.Point(line_coords[-1]).buffer(CenterlineParams.BUFFER_CLIP * 3).intersection(poly)
     src_geom = None
     dst_geom = None
 
@@ -171,7 +177,7 @@ def find_centerline(poly, input_line):
             dst_geom=dst_geom,
         )
     except Exception as e:
-        print(f'find_centerline: {e}')
+        print(f"find_centerline: {e}")
         return default_return
 
     if not centerline:
@@ -189,14 +195,10 @@ def find_centerline(poly, input_line):
     cl_coords = list(centerline.coords)
 
     # trim centerline at two ends
-    head_buffer = sh_geom.Point(cl_coords[0]).buffer(
-        CenterlineParams.BUFFER_CLIP
-    )
+    head_buffer = sh_geom.Point(cl_coords[0]).buffer(CenterlineParams.BUFFER_CLIP)
     centerline = centerline.difference(head_buffer)
 
-    end_buffer = sh_geom.Point(cl_coords[-1]).buffer(
-        CenterlineParams.BUFFER_CLIP
-    )
+    end_buffer = sh_geom.Point(cl_coords[-1]).buffer(CenterlineParams.BUFFER_CLIP)
     centerline = centerline.difference(end_buffer)
 
     # No centerline detected, use input line instead.
@@ -207,18 +209,18 @@ def find_centerline(poly, input_line):
         if centerline.is_empty:
             return default_return
     except Exception as e:
-        print(f'find_centerline: {e}')
+        print(f"find_centerline: {e}")
 
     centerline = snap_end_to_end(centerline, input_line)
 
     # Check centerline. If valid, regenerate by splitting polygon into two halves.
     if not centerline_is_valid(centerline, input_line):
         try:
-            print('Regenerating line ...')
+            print("Regenerating line ...")
             centerline = regenerate_centerline(poly, input_line)
             return centerline, CenterlineStatus.REGENERATE_SUCCESS
         except Exception as e:
-            print(f'find_centerline: {e}')
+            print(f"find_centerline: {e}")
             return input_line, CenterlineStatus.REGENERATE_FAILED
 
     return centerline, CenterlineStatus.SUCCESS
@@ -231,9 +233,7 @@ def find_corridor_polygon(corridor_thresh, in_transform, line_gpd):
         corridor_thresh_cl = corridor_thresh_cl.astype(np.int32)
 
     corridor_mask = np.where(1 == corridor_thresh_cl, True, False)
-    poly_generator = rasterio.features.shapes(
-        corridor_thresh_cl, mask=corridor_mask, transform=in_transform
-    )
+    poly_generator = rasterio.features.shapes(corridor_thresh_cl, mask=corridor_mask, transform=in_transform)
     corridor_polygon = []
 
     try:
@@ -244,7 +244,7 @@ def find_corridor_polygon(corridor_thresh, in_transform, line_gpd):
         print(f"find_corridor_polygon: {e}")
 
     if corridor_polygon:
-        corridor_polygon = (sh_ops.unary_union(corridor_polygon))
+        corridor_polygon = sh_ops.unary_union(corridor_polygon)
         if type(corridor_polygon) is sh_geom.MultiPolygon:
             poly_list = shapely.get_parts(corridor_polygon)
             merge_poly = poly_list[0]
@@ -283,7 +283,7 @@ def process_single_centerline(row_and_path):
 
     poly = row.geometry.iloc[0]
     centerline, status = find_centerline(poly, lc_path)
-    row['centerline'] = centerline
+    row["centerline"] = centerline
 
     return row
 
@@ -295,14 +295,14 @@ def find_centerlines(poly_gpd, line_seg, processes):
     try:
         for i in poly_gpd.index:
             row = poly_gpd.loc[[i]]
-            if 'OLnSEG' in line_seg.columns:
-                line_id, Seg_id = row['OLnFID'].iloc[0], row['OLnSEG'].iloc[0]
-                lc_path = line_seg.loc[
-                    (line_seg.OLnFID == line_id) & (line_seg.OLnSEG == Seg_id)
-                ]["geometry"].iloc[0]
+            if "OLnSEG" in line_seg.columns:
+                line_id, Seg_id = row["OLnFID"].iloc[0], row["OLnSEG"].iloc[0]
+                lc_path = line_seg.loc[(line_seg.OLnFID == line_id) & (line_seg.OLnSEG == Seg_id)][
+                    "geometry"
+                ].iloc[0]
             else:
-                line_id = row['OLnFID'].iloc[0]
-                lc_path = line_seg.loc[(line_seg.OLnFID == line_id)]['geometry'].iloc[0]
+                line_id = row["OLnFID"].iloc[0]
+                lc_path = line_seg.loc[(line_seg.OLnFID == line_id)]["geometry"].iloc[0]
 
             rows_and_paths.append((row, lc_path))
     except Exception as e:
@@ -326,12 +326,8 @@ def regenerate_centerline(poly, input_line):
         sh_geom.MultiLineString
 
     """
-    line_1 = sh_ops.substring(
-        input_line, start_dist=0.0, end_dist=input_line.length / 2
-    )
-    line_2 = sh_ops.substring(
-        input_line, start_dist=input_line.length / 2, end_dist=input_line.length
-    )
+    line_1 = sh_ops.substring(input_line, start_dist=0.0, end_dist=input_line.length / 2)
+    line_2 = sh_ops.substring(input_line, start_dist=input_line.length / 2, end_dist=input_line.length)
 
     pts = shapely.force_2d(
         [
@@ -358,9 +354,7 @@ def regenerate_centerline(poly, input_line):
 
         poly = sh_geom.Polygon(poly_geoms[0])
 
-    poly_exterior = sh_geom.Polygon(
-        poly.buffer(bt_const.SMALL_BUFFER).exterior
-    )
+    poly_exterior = sh_geom.Polygon(poly.buffer(bt_const.SMALL_BUFFER).exterior)
     poly_split = sh_ops.split(poly_exterior, perp)
 
     if len(poly_split.geoms) < 2:
@@ -400,6 +394,7 @@ def regenerate_centerline(poly, input_line):
     print("Centerline is regenerated.")
     return sh_ops.linemerge(sh_geom.MultiLineString([center_line_1, center_line_2]))
 
+
 class SeedLine:
     """Class to store seed line and least cost path."""
 
@@ -416,24 +411,19 @@ class SeedLine:
         line_radius = self.line_radius
         in_raster = self.raster
         seed_line = line  # LineString
-        default_return = (seed_line, seed_line, None)
 
-        ras_clip, out_meta = bt_common.clip_raster(in_raster, seed_line, line_radius)
+        ras_clip, out_meta = sp_common.clip_raster(in_raster, seed_line, line_radius)
         cost_clip, _ = algo_cost.cost_raster(ras_clip, out_meta)
 
         lc_path = line
         try:
             if bt_const.CenterlineFlags.USE_SKIMAGE_GRAPH:
-                lc_path = bt_dijkstra.find_least_cost_path_skimage(
-                    cost_clip, out_meta, seed_line
-                )
+                lc_path = bt_dijkstra.find_least_cost_path_skimage(cost_clip, out_meta, seed_line)
             else:
-                lc_path = bt_dijkstra.find_least_cost_path(
-                    cost_clip, out_meta, seed_line
-                )
+                lc_path = bt_dijkstra.find_least_cost_path(cost_clip, out_meta, seed_line)
         except Exception as e:
             print(e)
-            return default_return
+            return
 
         if lc_path:
             lc_path_coords = lc_path.coords
@@ -445,14 +435,12 @@ class SeedLine:
         # search for centerline
         if len(lc_path_coords) < 2:
             print("No least cost path detected, use input line.")
-            self.line["status"] = CenterlineStatus.FAILED.value
-            return default_return
+            self.line["cl_status"] = CenterlineStatus.FAILED.value
+            return
 
         # get corridor raster
         lc_path = sh_geom.LineString(lc_path_coords)
-        ras_clip, out_meta = bt_common.clip_raster(
-            in_raster, lc_path, line_radius * 0.9
-        )
+        ras_clip, out_meta = sp_common.clip_raster(in_raster, lc_path, line_radius * 0.9)
         cost_clip, _ = algo_cost.cost_raster(ras_clip, out_meta)
 
         out_transform = out_meta["transform"]
@@ -474,13 +462,9 @@ class SeedLine:
 
         # find contiguous corridor polygon and extract centerline
         df = gpd.GeoDataFrame(geometry=[seed_line], crs=out_meta["crs"])
-        corridor_poly_gpd = find_corridor_polygon(
-            corridor_thresh_cl, out_transform, df
-        )
-        center_line, status = find_centerline(
-            corridor_poly_gpd.geometry.iloc[0], lc_path
-        )
-        self.line["status"] = status.value
+        corridor_poly_gpd = find_corridor_polygon(corridor_thresh_cl, out_transform, df)
+        center_line, status = find_centerline(corridor_poly_gpd.geometry.iloc[0], lc_path)
+        self.line["cl_status"] = status.value
 
         self.lc_path = self.line.copy()
         self.lc_path.geometry = [lc_path]
@@ -488,4 +472,4 @@ class SeedLine:
         self.centerline = self.line.copy()
         self.centerline.geometry = [center_line]
 
-        self.corridor_poly_gpd = corridor_poly_gpd
+        self.corridor_poly_gpd = corridor_poly_gpd

beratools/core/algo_common.py

@@ -13,6 +13,7 @@ Description:
     The purpose of this script is to provide common algorithms
     and utility functions/classes.
 """
+
 import math
 import tempfile
 from pathlib import Path
@@ -32,8 +33,10 @@ from scipy import ndimage
 import beratools.core.algo_cost as algo_cost
 import beratools.core.constants as bt_const
 
+gpd.options.io_engine = "pyogrio"
 DISTANCE_THRESHOLD = 2  # 1 meter for intersection neighborhood
 
+
 def process_single_item(cls_obj):
     """
     Process a class object for universal multiprocessing.
@@ -45,8 +48,16 @@ def process_single_item(cls_obj):
         cls_obj: Class object after processing
 
     """
-    cls_obj.compute()
-    return cls_obj
+    try:
+        cls_obj.compute()
+        return cls_obj
+    except Exception as e:
+        import traceback
+
+        print(f"❌ Exception during compute() for object: {e}")
+        traceback.print_exc()
+        return None
+
 
 def read_geospatial_file(file_path, layer=None):
     """
@@ -64,12 +75,11 @@ def read_geospatial_file(file_path, layer=None):
 
     """
     try:
-        if layer is None:
-            # Read the file without specifying a layer
-            gdf = gpd.read_file(file_path)
-        else:
-            # Read the file with the specified layer
-            gdf = gpd.read_file(file_path, layer=layer)
+        kwargs = {}
+        if layer is not None:
+            kwargs['layer'] = layer
+
+        gdf = gpd.read_file(file_path, **kwargs)
 
         # Clean the geometries in the GeoDataFrame
         gdf = clean_geometries(gdf)
@@ -80,12 +90,14 @@ def read_geospatial_file(file_path, layer=None):
         print(f"Error reading file {file_path}: {e}")
         return None
 
+
 def has_multilinestring(gdf):
     """Check if any geometry is a MultiLineString."""
     # Filter out None values (invalid geometries) from the GeoDataFrame
     valid_geometries = gdf.geometry
     return any(isinstance(geom, sh_geom.MultiLineString) for geom in valid_geometries)
 
+
 def clean_geometries(gdf):
     """
     Remove rows with invalid, None, or empty geometries from the GeoDataFrame.
@@ -101,26 +113,23 @@ def clean_geometries(gdf):
     # Remove rows where the geometry is invalid, None, or empty
     gdf = gdf[gdf.geometry.is_valid]  # Only keep valid geometries
     gdf = gdf[~gdf.geometry.isna()]  # Remove rows with None geometries
-    gdf = gdf[
-        gdf.geometry.apply(lambda geom: not geom.is_empty)
-    ]  # Remove empty geometries
+    gdf = gdf[gdf.geometry.apply(lambda geom: not geom.is_empty)]  # Remove empty geometries
     return gdf
 
+
 def clean_line_geometries(line_gdf):
     """Clean line geometries in the GeoDataFrame."""
     if line_gdf is None:
         return line_gdf
-    
+
     if line_gdf.empty:
         return line_gdf
-    
-    line_gdf = line_gdf[
-        ~line_gdf.geometry.isna()
-        & ~line_gdf.geometry.is_empty
-    ]
+
+    line_gdf = line_gdf[~line_gdf.geometry.isna() & ~line_gdf.geometry.is_empty]
     line_gdf = line_gdf[line_gdf.geometry.length > bt_const.SMALL_BUFFER]
     return line_gdf
 
+
 def prepare_lines_gdf(file_path, layer=None, proc_segments=True):
     """
     Split lines at vertices or return original rows.
@@ -149,22 +158,14 @@ def prepare_lines_gdf(file_path, layer=None, proc_segments=True):
                 segment = sh_geom.LineString([coords[i], coords[i + 1]])
 
                 # Copy over all non-geometry columns (excluding 'geometry')
-                attributes = {
-                    col: getattr(row, col) for col in gdf.columns if col != "geometry"
-                }
-                single_row_gdf = gpd.GeoDataFrame(
-                    [attributes], geometry=[segment], crs=gdf.crs
-                )
+                attributes = {col: getattr(row, col) for col in gdf.columns if col != "geometry"}
+                single_row_gdf = gpd.GeoDataFrame([attributes], geometry=[segment], crs=gdf.crs)
                 split_gdf_list.append(single_row_gdf)
 
         else:
             # If not proc_segment, add the original row as a single-row GeoDataFrame
-            attributes = {
-                col: getattr(row, col) for col in gdf.columns if col != "geometry"
-            }
-            single_row_gdf = gpd.GeoDataFrame(
-                [attributes], geometry=[line], crs=gdf.crs
-            )
+            attributes = {col: getattr(row, col) for col in gdf.columns if col != "geometry"}
+            single_row_gdf = gpd.GeoDataFrame([attributes], geometry=[line], crs=gdf.crs)
             split_gdf_list.append(single_row_gdf)
 
     return split_gdf_list
@@ -180,15 +181,11 @@ def morph_raster(corridor_thresh, canopy_raster, exp_shk_cell, cell_size_x):
         # Process: Expand
         # FLM original Expand equivalent
         cell_size = int(exp_shk_cell * 2 + 1)
-        expanded = ndimage.grey_dilation(
-            raster_class, size=(cell_size, cell_size)
-        )
+        expanded = ndimage.grey_dilation(raster_class, size=(cell_size, cell_size))
 
         # Process: Shrink
         # FLM original Shrink equivalent
-        file_shrink = ndimage.grey_erosion(
-            expanded, size=(cell_size, cell_size)
-        )
+        file_shrink = ndimage.grey_erosion(expanded, size=(cell_size, cell_size))
 
     else:
         if bt_const.BT_DEBUGGING:
@@ -250,6 +247,7 @@ def intersection_of_lines(line_1, line_2):
 
     return inter
 
+
 def get_angle(line, vertex_index):
     """
     Calculate the angle of the first or last segment.
@@ -287,15 +285,14 @@ def get_angle(line, vertex_index):
 
     return angle
 
+
 def points_are_close(pt1, pt2):
-    if (
-        abs(pt1.x - pt2.x) < DISTANCE_THRESHOLD
-        and abs(pt1.y - pt2.y) < DISTANCE_THRESHOLD
-    ):
+    if abs(pt1.x - pt2.x) < DISTANCE_THRESHOLD and abs(pt1.y - pt2.y) < DISTANCE_THRESHOLD:
         return True
     else:
         return False
 
+
 def generate_raster_footprint(in_raster, latlon=True):
     inter_img = "image_overview.tif"
 
@@ -331,6 +328,7 @@ def generate_raster_footprint(in_raster, latlon=True):
 
     return geom
 
+
 def save_raster_to_file(in_raster_mem, in_meta, out_raster_file):
     """
     Save raster matrix in memory to file.
@@ -344,6 +342,7 @@ def save_raster_to_file(in_raster_mem, in_meta, out_raster_file):
     with rasterio.open(out_raster_file, "w", **in_meta) as dest:
         dest.write(in_raster_mem, indexes=1)
 
+
 def generate_perpendicular_line_precise(points, offset=20):
     """
     Generate a perpendicular line to the input line at the given point.
@@ -359,7 +358,7 @@ def generate_perpendicular_line_precise(points, offset=20):
     # Compute the angle of the line
     if len(points) not in [2, 3]:
         return None
-    
+
     center = points[1]
     perp_line = None
 
@@ -379,9 +378,7 @@ def generate_perpendicular_line_precise(points, offset=20):
         start = [center.x + offset / 2.0, center.y]
         end = [center.x - offset / 2.0, center.y]
         line = sh_geom.LineString([start, end])
-        perp_line = sh_aff.rotate(
-            line, angle + math.pi / 2.0, origin=center, use_radians=True
-        )
+        perp_line = sh_aff.rotate(line, angle + math.pi / 2.0, origin=center, use_radians=True)
     elif len(points) == 3:
         head = points[0]
         tail = points[2]
@@ -397,15 +394,9 @@ def generate_perpendicular_line_precise(points, offset=20):
             head_new = shapely.force_3d(head_new)
         try:
             perp_seg_1 = sh_geom.LineString([center, head_new])
-            perp_seg_1 = sh_aff.rotate(
-                perp_seg_1, angle_diff, origin=center, use_radians=True
-            )
-            perp_seg_2 = sh_aff.rotate(
-                perp_seg_1, math.pi, origin=center, use_radians=True
-            )
-            perp_line = sh_geom.LineString(
-                [list(perp_seg_1.coords)[1], list(perp_seg_2.coords)[1]]
-            )
+            perp_seg_1 = sh_aff.rotate(perp_seg_1, angle_diff, origin=center, use_radians=True)
+            perp_seg_2 = sh_aff.rotate(perp_seg_1, math.pi, origin=center, use_radians=True)
+            perp_line = sh_geom.LineString([list(perp_seg_1.coords)[1], list(perp_seg_2.coords)[1]])
         except Exception as e:
             print(e)
 
@@ -426,9 +417,8 @@ def _line_angle(point_1, point_2):
     angle = math.atan2(delta_y, delta_x)
     return angle
 
-def corridor_raster(
-    raster_clip, out_meta, source, destination, cell_size, corridor_threshold
-):
+
+def corridor_raster(raster_clip, out_meta, source, destination, cell_size, corridor_threshold):
     """
     Calculate corridor raster.
 
@@ -442,7 +432,7 @@ def corridor_raster(
 
     Returns:
     corridor raster
-    
+
     """
     try:
         # change all nan to BT_NODATA_COST for workaround
@@ -481,6 +471,7 @@ def corridor_raster(
 
     return corridor_thresh_cl
 
+
 def remove_holes(geom):
     if geom.geom_type == "Polygon":
         if geom.interiors:
@@ -494,4 +485,4 @@ def remove_holes(geom):
             else:
                 new_polygons.append(polygon)
         return sh_geom.MultiPolygon(new_polygons)
-    return geom  # Return other geometry types as is
+    return geom  # Return other geometry types as is