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

beratools/tools/__init__.py

@@ -1,7 +0,0 @@
-# -*- coding: utf-8 -*-
-
-# import os
-# import sys
-# sys.path.append(os.path.dirname(os.path.realpath(__file__)))
-
-name = 'tools'

beratools/tools/{line_footprint_absolute.py → canopy_footprint_absolute.py}

@@ -13,20 +13,28 @@ Description:
     The purpose of this script is to provide main interface for canopy footprint tool.
     The tool is used to generate the footprint of a line based on absolute threshold.
 """
+
+import logging
 import time
 
 import geopandas as gpd
 import numpy as np
 import pandas as pd
-import rasterio
-import shapely
+from rasterio import features
+from rasterio.transform import rowcol
+from shapely.geometry import MultiPolygon, Polygon, shape
 
 import beratools.core.algo_centerline as algo_cl
 import beratools.core.algo_common as algo_common
 import beratools.core.algo_cost as algo_cost
-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
+from beratools.core.logger import Logger
+from beratools.utility.tool_args import CallMode
+
+log = Logger("canopy_footprint_abs", file_level=logging.INFO)
+logger = log.get_logger()
+print = log.print
 
 
 class FootprintAbsolute:
@@ -63,8 +71,10 @@ class FootprintAbsolute:
             if corridor_thresh < 0.0:
                 corridor_thresh = 3.0
         except ValueError as e:
-            print(f"process_single_line_segment: {e}")
+            print(f"FootprintAbsolute.compute: ValueError {e}")
             corridor_thresh = 3.0
+        except Exception as e:
+            print(f"FootprintAbsolute.compute: exception {e}")
 
         segment_list = []
         feat = self.line_seg.geometry[0]
@@ -77,7 +87,7 @@ class FootprintAbsolute:
 
         # Buffer around line and clip cost raster and canopy raster
         # TODO: deal with NODATA
-        clip_cost, out_meta = bt_common.clip_raster(in_chm, feat, max_ln_width)
+        clip_cost, out_meta = sp_common.clip_raster(in_chm, feat, max_ln_width)
         out_transform = out_meta["transform"]
         cell_size_x = out_transform[0]
         cell_size_y = -out_transform[4]
@@ -88,9 +98,8 @@ class FootprintAbsolute:
         if len(clip_canopy.shape) > 2:
             clip_canopy = np.squeeze(clip_canopy, axis=0)
 
-        transformer = rasterio.transform.AffineTransformer(out_transform)
-        source = [transformer.rowcol(x1, y1)]
-        destination = [transformer.rowcol(x2, y2)]
+        source = [rowcol(out_transform, x1, y1)]
+        destination = [rowcol(out_transform, x2, y2)]
 
         corridor_thresh = algo_common.corridor_raster(
             clip_cost,
@@ -101,9 +110,7 @@ class FootprintAbsolute:
             corridor_thresh,
         )
 
-        clean_raster = algo_common.morph_raster(
-            corridor_thresh, clip_canopy, exp_shk_cell, cell_size_x
-        )
+        clean_raster = algo_common.morph_raster(corridor_thresh, clip_canopy, exp_shk_cell, cell_size_x)
 
         # create mask for non-polygon area
         msk = np.where(clean_raster == 1, True, False)
@@ -111,33 +118,56 @@ class FootprintAbsolute:
             clean_raster = clean_raster.astype(np.int32)
 
         # Process: ndarray to shapely Polygon
-        out_polygon = rasterio.features.shapes(
-            clean_raster, mask=msk, transform=out_transform
-        )
+        out_polygon = features.shapes(clean_raster, mask=msk, transform=out_transform)
 
         # create a shapely multipolygon
         multi_polygon = []
         for shp, value in out_polygon:
-            multi_polygon.append(shapely.geometry.shape(shp))
-        poly = shapely.geometry.MultiPolygon(multi_polygon)
+            multi_polygon.append(shape(shp))
+        poly = MultiPolygon(multi_polygon)
 
         # create a pandas dataframe for the footprint
-        footprint = gpd.GeoDataFrame(geometry=[poly], crs=self.line_seg.crs)
+        # Ensure CRS is a string
+        crs_str = None
+        if hasattr(self.line_seg, "crs") and self.line_seg.crs:
+            if hasattr(self.line_seg.crs, "to_string"):
+                crs_str = self.line_seg.crs.to_string()
+            else:
+                crs_str = str(self.line_seg.crs)
+        else:
+            crs_str = "EPSG:4326"
+        # Ensure poly is a valid shapely geometry
+        if not isinstance(poly, (Polygon, MultiPolygon)):
+            poly = MultiPolygon([poly]) if poly else None
+
+        # Fallback CRS if invalid
+        if not crs_str or not isinstance(crs_str, str) or not crs_str.startswith("EPSG"):
+            crs_str = "EPSG:4326"
+
+        # Only create GeoDataFrame if poly is not None
+        if poly is not None and isinstance(poly, (Polygon, MultiPolygon)):
+            geometry_list = [poly]
+        else:
+            geometry_list = []
+
+        import pandas as pd
+
+        self.footprint = gpd.GeoDataFrame({"geometry": geometry_list})
+        self.footprint.set_crs(crs_str, inplace=True)
 
         # find contiguous corridor polygon for centerline
-        corridor_poly_gpd = algo_cl.find_corridor_polygon(
-            corridor_thresh, out_transform, line_gpd
-        )
-        centerline, status = algo_cl.find_centerline(
-            corridor_poly_gpd.geometry.iloc[0], feat
-        )
+        corridor_poly_gpd = algo_cl.find_corridor_polygon(corridor_thresh, out_transform, line_gpd)
+        centerline, status = algo_cl.find_centerline(corridor_poly_gpd.geometry.iloc[0], feat)
 
-        self.footprint = footprint
         self.corridor_poly_gpd = corridor_poly_gpd
         self.centerline = centerline
 
+
 def process_single_line(line_footprint):
-    line_footprint.compute()
+    try:
+        line_footprint.compute()
+    except Exception as e:
+        print(f"process_single_line: exception {e}")
     return line_footprint
 
 
@@ -153,26 +183,17 @@ def generate_line_class_list(
     line_list = algo_common.prepare_lines_gdf(in_line, in_layer, proc_segments=False)
 
     for line in line_list:
-        line_classes.append(
-            FootprintAbsolute(line, in_chm, corridor_thresh, max_ln_width, exp_shk_cell)
-        )
+        line_classes.append(FootprintAbsolute(line, in_chm, corridor_thresh, max_ln_width, exp_shk_cell))
 
     return line_classes
 
 
-def line_footprint_abs(
-    in_line,
-    in_chm,
-    corridor_thresh,
-    max_ln_width,
-    exp_shk_cell,
-    out_footprint,
-    processes,
-    verbose,
-    in_layer=None,
-    out_layer=None,
-    parallel_mode=bt_const.ParallelMode.MULTIPROCESSING
-):
+def canopy_footprint_abs(
+    in_line, in_chm, corridor_thresh, max_ln_width, exp_shk_cell, out_footprint, 
+    processes=0, call_mode=CallMode.CLI, log_level="INFO"):
+    in_file, in_layer = sp_common.decode_file_layer(in_line)
+    out_file, out_layer = sp_common.decode_file_layer(out_footprint)
+
     max_ln_width = float(max_ln_width)
     exp_shk_cell = int(exp_shk_cell)
 
@@ -180,7 +201,7 @@ def line_footprint_abs(
     poly_list = []
 
     line_class_list = generate_line_class_list(
-        in_line, in_chm, corridor_thresh, max_ln_width, exp_shk_cell, in_layer
+        in_file, in_chm, corridor_thresh, max_ln_width, exp_shk_cell, in_layer
     )
 
     feat_list = bt_base.execute_multiprocessing(
@@ -188,26 +209,30 @@ def line_footprint_abs(
         line_class_list,
         "Line footprint",
         processes,
-        1,
-        verbose=verbose,
+        call_mode
     )
 
     if feat_list:
         for i in feat_list:
-            footprint_list.append(i.footprint)
-            poly_list.append(i.corridor_poly_gpd)
+            if i.footprint is not None:
+                footprint_list.append(i.footprint)
+            if i.corridor_poly_gpd is not None:
+                poly_list.append(i.corridor_poly_gpd)
 
-    results = gpd.GeoDataFrame(pd.concat(footprint_list))
-    results = results.reset_index(drop=True)
-    results.to_file(out_footprint, layer=out_layer)
+    if footprint_list:
+        results = gpd.GeoDataFrame(pd.concat(footprint_list))
+        results = results.reset_index(drop=True)
+        layer_name = out_layer if out_layer else "canopy_footprint"
+        results.to_file(out_file, layer=layer_name)
+        print(f"Saved footprint to {out_file}, layer: {layer_name}")
+    else:
+        print("Warning: No footprints generated. Output file not written.")
 
 
 if __name__ == "__main__":
+    from beratools.utility.tool_args import compose_tool_kwargs
     start_time = time.time()
     print("Footprint processing started")
-
-    in_args, in_verbose = bt_common.check_arguments()
-    line_footprint_abs(
-        **in_args.input, processes=int(in_args.processes), verbose=in_verbose
-    )
-    print('Elapsed time: {}'.format(time.time() - start_time))
+    kwargs = compose_tool_kwargs("canopy_footprint_absolute")
+    canopy_footprint_abs(**kwargs)
+    print("Elapsed time: {}".format(time.time() - start_time))

beratools/tools/canopy_footprint_exp.py

@@ -0,0 +1,113 @@
+"""Canopy footprint tool with exception handling."""
+
+from pathlib import Path
+from tabnanny import verbose
+
+import beratools.utility.spatial_common as sp_common
+from beratools.core.algo_canopy_footprint_exp import FootprintCanopy
+from beratools.utility.tool_args import CallMode
+
+
+def line_footprint_exp(
+    in_line,
+    in_chm,
+    out_footprint,
+    max_ln_width=32,
+    tree_radius=1.5,
+    max_line_dist=1.5,
+    canopy_avoidance=0.0,
+    exponent=1.0,
+    canopy_thresh_percentage=50,
+    processes=0,
+    call_mode=CallMode.CLI,
+    log_level="INFO",
+):
+    """Safe version of relative canopy footprint tool."""
+    try:
+        footprint = FootprintCanopy(in_line, in_chm)
+    except Exception as e:
+        print(f"Failed to initialize FootprintCanopy: {e}")
+        return
+
+    try:
+        footprint.compute(processes)
+    except Exception as e:
+        print(f"Error in compute(): {e}")
+        import traceback
+
+        traceback.print_exc()
+        return
+
+    # Save only if footprints were actually generated
+    out_file, out_layer = sp_common.decode_file_layer(out_footprint)
+    if (
+        hasattr(footprint, "footprints")
+        and footprint.footprints is not None
+        and hasattr(footprint.footprints, "empty")
+        and not footprint.footprints.empty
+    ):
+        try:
+            footprint.save_footprint(out_file, out_layer)
+            print(f"Footprint saved to {out_footprint}")
+        except Exception as e:
+            print(f"Failed to save footprint: {e}")
+    else:
+        print("No valid footprints to save.")
+
+    # Optionally save percentile lines (if needed)
+    if (
+        hasattr(footprint, "lines_percentile")
+        and footprint.lines_percentile is not None
+        and hasattr(footprint.lines_percentile, "empty")
+        and not footprint.lines_percentile.empty
+    ):
+        out_file_path = Path(out_file)
+        out_file_aux = out_file_path.with_stem(out_file_path.stem + "_aux")
+        try:
+            footprint.save_line_percentile(out_file_aux.as_posix())
+            if verbose:
+                print(f"Line percentile saved to {out_file_aux}")
+        except Exception as e:
+            print(f"Failed to save line percentile: {e}")
+
+def parse_cli_args():
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Canopy footprint tool with exception handling.",
+        usage="%(prog)s in_line in_chm out_footprint [options]"
+    )
+    parser.add_argument("in_line", help="Input line file")
+    parser.add_argument("in_chm", help="Input CHM file")
+    parser.add_argument("out_footprint", help="Output footprint file")
+    parser.add_argument("--max-ln-width", type=float, default=32, help="Maximum line width (default: 32)")
+    parser.add_argument("--tree-radius", type=float, default=1.5, help="Tree radius (default: 1.5)")
+    parser.add_argument("--max-line-dist", type=float, default=1.5, help="Maximum line distance (default: 1.5)")
+    parser.add_argument("--canopy-avoidance", type=float, default=0.0, help="Canopy avoidance (default: 0.0)")
+    parser.add_argument("--exponent", type=float, default=1.0, help="Exponent (default: 1.0)")
+    parser.add_argument("--canopy-thresh-percentage", type=float, default=50, help="Canopy threshold percentage (default: 50)")
+    parser.add_argument("--processes", type=int, default=0, help="Number of processes (default: 0)")
+    parser.add_argument("--log-level", type=str, default="INFO", help="Log level (default: INFO)")
+
+    args = parser.parse_args()
+    return {
+        "in_line": args.in_line,
+        "in_chm": args.in_chm,
+        "out_footprint": args.out_footprint,
+        "max_ln_width": args.max_ln_width,
+        "tree_radius": args.tree_radius,
+        "max_line_dist": args.max_line_dist,
+        "canopy_avoidance": args.canopy_avoidance,
+        "exponent": args.exponent,
+        "canopy_thresh_percentage": args.canopy_thresh_percentage,
+        "processes": args.processes,
+        "log_level": args.log_level,
+    }
+
+if __name__ == "__main__":
+    import time
+
+    start_time = time.time()
+    kwargs = parse_cli_args()
+    line_footprint_exp(**kwargs)
+    print("Elapsed time: {}".format(time.time() - start_time))

beratools/tools/centerline.py

@@ -14,32 +14,28 @@ Description:
 """
 
 import logging
-import time
 from pathlib import Path
 
 import pandas as pd
 
 import beratools.core.algo_centerline as algo_centerline
 import beratools.core.algo_common as algo_common
-import beratools.core.constants as bt_const
-import beratools.tools.common as bt_common
+import beratools.utility.spatial_common as sp_common
 from beratools.core.logger import Logger
 from beratools.core.tool_base import execute_multiprocessing
+from beratools.utility.tool_args import CallMode
 
 log = Logger("centerline", file_level=logging.INFO)
 logger = log.get_logger()
 print = log.print
 
-def generate_line_class_list(
-    in_vector, in_raster, line_radius, layer=None, proc_segments=True
-) -> list:
+
+def generate_line_class_list(in_vector, in_raster, line_radius, layer=None, proc_segments=True) -> list:
     line_classes = []
     line_list = algo_common.prepare_lines_gdf(in_vector, layer, proc_segments)
 
     for item in line_list:
-        line_classes.append(
-            algo_centerline.SeedLine(item, in_raster, proc_segments, line_radius)
-        )
+        line_classes.append(algo_centerline.SeedLine(item, in_raster, proc_segments, line_radius))
 
     return line_classes
 
@@ -55,20 +51,20 @@ def centerline(
     line_radius,
     proc_segments,
     out_line,
-    processes,
-    verbose,
-    in_layer=None,
-    out_layer=None,
-    parallel_mode=bt_const.ParallelMode.MULTIPROCESSING
+    use_angle_grouping=True,
+    processes=0,
+    call_mode=CallMode.CLI,
+    log_level="INFO",
 ):
-    if not bt_common.compare_crs(
-        bt_common.vector_crs(in_line), bt_common.raster_crs(in_raster)
-    ):
+    in_file, in_layer = sp_common.decode_file_layer(in_line)
+    out_file, out_layer = sp_common.decode_file_layer(out_line)
+
+    if not sp_common.compare_crs(sp_common.vector_crs(in_file), sp_common.raster_crs(in_raster)):
         print("Line and CHM have different spatial references, please check.")
         return
 
     line_class_list = generate_line_class_list(
-        in_line,
+        in_file,
         in_raster,
         line_radius=float(line_radius),
         layer=in_layer,
@@ -85,12 +81,11 @@ def centerline(
         line_class_list,
         "Centerline",
         processes,
-        verbose=verbose,
-        mode=parallel_mode,
+        call_mode,
     )
     if not result:
         print("No centerlines found.")
-        return
+        return 1
 
     for item in result:
         lc_path_list.append(item.lc_path)
@@ -98,11 +93,7 @@ def centerline(
         corridor_poly_list.append(item.corridor_poly_gpd)
 
     # Concatenate the lists of GeoDataFrames into single GeoDataFrames
-    if (
-        len(lc_path_list) == 0
-        or len(centerline_list) == 0
-        or len(corridor_poly_list) == 0
-    ):
+    if len(lc_path_list) == 0 or len(centerline_list) == 0 or len(corridor_poly_list) == 0:
         print("No centerline generated.")
         return 1
 
@@ -111,26 +102,28 @@ def centerline(
     corridor_polys = pd.concat(corridor_poly_list, ignore_index=True)
 
     # Save the concatenated GeoDataFrames to the shapefile/gpkg
-    centerline_list.to_file(out_line, layer=out_layer)
+    centerline_list.to_file(out_file, layer=out_layer)
+    print(f"Saved centerlines to: {out_file}")
 
     # Check if the output file is a shapefile
-    out_line_path = Path(out_line)
+    out_line_path = Path(out_file)
 
-    if out_line_path.suffix == ".shp":
-        # Generate the new file name for the GeoPackage with '_aux' appended
-        aux_file = out_line_path.with_name(out_line_path.stem + "_aux.gpkg")
-        print(f"Saved auxiliary data to: {aux_file}")
-    else:
-        aux_file = out_line  # continue using out_line (gpkg)
+    # Generate the new file name for the GeoPackage with '_aux' appended
+    aux_file = out_line_path.with_name(out_line_path.stem + "_aux.gpkg")
+    print(f"Saved auxiliary data to: {aux_file}")
 
     # Save lc_path_list and corridor_polys to the new GeoPackage with '_aux' suffix
     lc_path_list.to_file(aux_file, layer="least_cost_path")
     corridor_polys.to_file(aux_file, layer="corridor_polygon")
 
+    return 0
+
 
-# TODO: fix geometries when job done
 if __name__ == "__main__":
-    in_args, in_verbose = bt_common.check_arguments()
+    import time
+
+    from beratools.utility.tool_args import compose_tool_kwargs
     start_time = time.time()
-    centerline(**in_args.input, processes=int(in_args.processes), verbose=in_verbose)
+    kwargs = compose_tool_kwargs("centerline")
+    centerline(**kwargs)
     print("Elapsed time: {}".format(time.time() - start_time))

beratools/tools/check_seed_line.py

@@ -0,0 +1,127 @@
+"""
+Copyright (C) 2025 Applied Geospatial Research Group.
+
+This script is licensed under the GNU General Public License v3.0.
+See <https://gnu.org/licenses/gpl-3.0> for full license details.
+
+Author: Richard Zeng
+
+Description:
+    This script is part of the BERA Tools.
+    Webpage: https://github.com/appliedgrg/beratools
+
+    The purpose of this script is to provide main interface for line grouping tool.
+"""
+
+import logging
+
+import geopandas as gpd
+
+import beratools.utility.spatial_common as sp_common
+from beratools.core.logger import Logger
+from beratools.utility.tool_args import CallMode
+
+log = Logger("check_seed_line", file_level=logging.INFO)
+logger = log.get_logger()
+print = log.print
+
+
+def qc_merge_multilinestring(gdf):
+    """
+    QC step: Merge MultiLineStrings if possible, else split into LineStrings.
+
+    Args:
+        gdf (GeoDataFrame): Input GeoDataFrame.
+
+    Returns:
+        GeoDataFrame: Cleaned GeoDataFrame with only LineStrings.
+    """
+    from shapely.geometry.base import BaseGeometry
+
+    from beratools.core.algo_merge_lines import custom_line_merge
+    
+    records = []
+    for idx, row in gdf.iterrows():
+        geom = row.geometry
+        if geom is None:
+            continue
+        row_dict = row.to_dict()
+        # Try to merge MultiLineString
+        if geom.geom_type == "MultiLineString":
+            merged = custom_line_merge(geom)
+            if merged.geom_type == "MultiLineString":
+                # Could not merge, split into LineStrings
+                for part in merged.geoms:
+                    new_row = row_dict.copy()
+                    new_row["geometry"] = part
+                    if part.geom_type == "LineString":
+                        records.append(new_row)
+            elif merged.geom_type == "LineString":
+                new_row = row_dict.copy()
+                new_row["geometry"] = merged
+                records.append(new_row)
+            else:
+                # Unexpected geometry, keep as is
+                new_row = row_dict.copy()
+                new_row["geometry"] = merged
+                if hasattr(merged, "geom_type") and merged.geom_type == "LineString":
+                    records.append(new_row)
+        elif geom.geom_type == "LineString":
+            records.append(row_dict)
+        # else: skip non-LineString geometries
+
+    # Build new GeoDataFrame
+    valid_records = [rec for rec in records if isinstance(rec.get("geometry", None), BaseGeometry)]
+    out_gdf = gpd.GeoDataFrame.from_records(valid_records, columns=gdf.columns)
+    out_gdf.set_crs(gdf.crs, inplace=True)
+    out_gdf = out_gdf.reset_index(drop=True)
+    return out_gdf
+
+
+def qc_split_lines_at_intersections(gdf):
+    """
+    QC step: Split lines at intersections so each segment becomes a separate line object.
+
+    Args:
+        gdf (GeoDataFrame): Input GeoDataFrame of LineStrings.
+
+    Returns:
+        GeoDataFrame: New GeoDataFrame with lines split at all intersection points.
+    """
+    from beratools.core.algo_split_with_lines import LineSplitter
+    
+    splitter = LineSplitter(gdf)
+    splitter.process()
+    if splitter.split_lines_gdf is not None:
+        if isinstance(splitter.split_lines_gdf, gpd.GeoDataFrame):
+            return splitter.split_lines_gdf.reset_index(drop=True)
+        else:
+            return splitter.split_lines_gdf
+    else:
+        return gdf.reset_index(drop=True)
+
+
+def check_seed_line(in_line, out_line, use_angle_grouping=True, 
+                    processes=0, call_mode=CallMode.CLI, log_level="INFO"):
+    from beratools.core.algo_line_grouping import LineGrouping
+    
+    in_file, in_layer = sp_common.decode_file_layer(in_line)
+    out_file, out_layer = sp_common.decode_file_layer(out_line)
+
+    in_line_gdf = gpd.read_file(in_file, layer=in_layer)
+    in_line_gdf = qc_merge_multilinestring(in_line_gdf)
+    in_line_gdf = qc_split_lines_at_intersections(in_line_gdf)
+    lg = LineGrouping(in_line_gdf, use_angle_grouping=use_angle_grouping)
+    lg.run_grouping()
+    lg.lines.to_file(out_file, layer=out_layer)
+    print(f"Output saved to file: {out_file}, layer: {out_layer}")
+
+
+if __name__ == "__main__":
+    import time
+
+    from beratools.utility.tool_args import compose_tool_kwargs
+    start_time = time.time()
+    kwargs = compose_tool_kwargs("check_seed_line")
+    check_seed_line(**kwargs)
+    print("Elapsed time: {}".format(time.time() - start_time))