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

beratools/__init__.py

@@ -1,3 +1,8 @@
-__author__ = """AppliedGRG"""
-__email__ = 'appliedgrg@gmail.com'
-__version__ = '0.2.2'
+__author__ = """AppliedGRG"""
+__email__ = 'appliedgrg@gmail.com'
+__version__ = '0.1.0'
+__license__ = "GPL-3.0-or-later"
+__copyright__ = "Copyright (c) AppliedGRG"
+__status__ = "Pre-Alpha"
+__url__ = "https://github.com/appliedgrg/beratools"
+__all__ = ["tools", "gui"]

beratools/core/{algo_footprint_rel.py → algo_canopy_footprint_exp.py}

@@ -10,12 +10,12 @@ 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 canopy footprint tool.
-    The tool is used to generate the footprint of a line based on relative threshold.
+    The purpose of this script is to provide main interface for experimental canopy footprint tool.
+    The tool is used to generate the canopy footprint of a line based on relative threshold.
 """
+
 import math
-import time
-from enum import StrEnum
+from enum import Enum
 
 import geopandas as gpd
 import numpy as np
@@ -30,47 +30,79 @@ 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
 
 
-class Side(StrEnum):
+class Side(Enum):
     """Constants for left and right side."""
 
     left = "left"
     right = "right"
 
+
 class FootprintCanopy:
     """Relative canopy footprint class."""
 
-    def __init__(self, in_geom, in_chm, in_layer=None):
-        data = gpd.read_file(in_geom, layer=in_layer)
+    def __init__(self, in_geom, in_chm):
+        in_file, in_layer = sp_common.decode_file_layer(in_geom)
+        data = gpd.read_file(in_file, layer=in_layer)
         self.lines = []
 
         for idx in data.index:
             line = LineInfo(data.iloc[[idx]], in_chm)
             self.lines.append(line)
 
-    def compute(self, processes, parallel_mode=bt_const.ParallelMode.MULTIPROCESSING):
+    def compute(self, processes):
         result = bt_base.execute_multiprocessing(
             algo_common.process_single_item,
             self.lines,
             "Canopy Footprint",
             processes,
-            1,
-            parallel_mode,
         )
 
-        fp = [item.footprint for item in result]
-        self.footprints = pd.concat(fp)
+        fp = []
+        percentile = []
+        try:
+            for item in result:
+                if item.footprint is not None:
+                    fp.append(item.footprint)
+                else:
+                    print("Footprint is None for one of the lines.")
+                    continue  # Skip failed line
+
+            if fp:
+                self.footprints = pd.concat(fp)
+            else:
+                print("No valid footprints to save.")
+                self.footprints = None
+
+            for item in result:
+                if item.lines_percentile is not None:
+                    percentile.append(item.lines_percentile)
+                else:
+                    print("lines_percentile is None for one of the lines.")
+                    continue  # Skip failed line
 
-        percentile = [item.line for item in result]
-        self.lines_percentile = pd.concat(percentile)
+            if percentile:
+                self.lines_percentile = pd.concat(percentile)
+            else:
+                print("No valid lines_percentile to save.")
+                self.lines_percentile = None
+        except Exception as e:
+            print(f"Error during processing: {e}")
 
     def save_footprint(self, out_footprint, layer=None):
-        self.footprints.to_file(out_footprint, layer=layer)
+        if self.footprints is not None and isinstance(self.footprints, gpd.GeoDataFrame):
+            self.footprints.to_file(out_footprint, layer=layer)
+        else:
+            print("No footprints to save (None or not a GeoDataFrame).")
 
     def save_line_percentile(self, out_percentile):
-        self.lines_percentile.to_file(out_percentile)
+        if self.lines_percentile is not None and isinstance(self.lines_percentile, gpd.GeoDataFrame):
+            self.lines_percentile.to_file(out_percentile)
+        else:
+            print("No lines_percentile to save (None or not a GeoDataFrame).")
+
 
 class BufferRing:
     """Buffer ring class."""
@@ -81,28 +113,27 @@ class BufferRing:
         self.percentile = 0.5
         self.Dyn_Canopy_Threshold = 0.05
 
+
 class LineInfo:
     """Class to store line information."""
 
-    def __init__(self, 
-                 line_gdf, in_chm, 
-                 max_ln_width=32,
-                 tree_radius=1.5,
-                 max_line_dist=1.5,
-                 canopy_avoidance=0.0,
-                 exponent=1.0,
-                 canopy_thresh_percentage=50):
+    def __init__(
+        self,
+        line_gdf,
+        in_chm,
+        max_ln_width=32,
+        tree_radius=1.5,
+        max_line_dist=1.5,
+        canopy_avoidance=0.0,
+        exponent=1.0,
+        canopy_thresh_percentage=50,
+    ):
         self.line = line_gdf
         self.in_chm = in_chm
-        self.line_simp = self.line.geometry.simplify(
-            tolerance=0.5, preserve_topology=True
-        )
+        self.line_simp = self.line.geometry.simplify(tolerance=0.5, preserve_topology=True)
 
         self.canopy_percentile = 50
         self.DynCanTh = np.nan
-        # chk_df_multipart
-        # if proc_segments:
-        # line_seg = split_into_segments(line_seg)
 
         self.buffer_rings = []
 
@@ -127,16 +158,38 @@ class LineInfo:
         self.buffer_right = None
         self.footprint = None
 
+        self.lines_percentile = None
+
     def compute(self):
         self.prepare_ring_buffer()
 
         ring_list = []
         for item in self.buffer_rings:
             ring = self.cal_percentileRing(item)
-            ring_list.append(ring)
+            if ring is not None:
+                ring_list.append(ring)
+            else:
+                # print("Skipping invalid ring.")
+                # TODO: handle None rings appropriately
+                pass
 
         self.buffer_rings = ring_list
 
+        # Aggregate percentiles and geometries for lines_percentile
+        percentile_records = []
+        for ring in self.buffer_rings:
+            if ring is not None and hasattr(ring, "geometry") and hasattr(ring, "percentile"):
+                percentile_records.append(
+                    {"geometry": ring.geometry, "percentile": ring.percentile, "side": ring.side.value}
+                )
+        if percentile_records:
+            self.lines_percentile = gpd.GeoDataFrame(percentile_records)
+            self.lines_percentile.set_geometry("geometry", inplace=True)
+            if self.line.crs:
+                self.lines_percentile = self.lines_percentile.set_crs(self.line.crs, allow_override=True)
+        else:
+            self.lines_percentile = None
+
         self.rate_of_change(self.get_percentile_array(Side.left), Side.left)
         self.rate_of_change(self.get_percentile_array(Side.right), Side.right)
 
@@ -152,14 +205,35 @@ class LineInfo:
 
         fp_left = self.process_single_footprint(Side.left)
         fp_right = self.process_single_footprint(Side.right)
-        fp_left.geometry = fp_left.buffer(0.005)
-        fp_right.geometry = fp_right.buffer(0.005)
-        self.footprint = pd.concat([fp_left, fp_right])
-        self.footprint = self.footprint.dissolve()
-        self.footprint.geometry = self.footprint.buffer(-0.005)
-
-        # transfer group value to footprint
-        # TODO: lines and footprint can match by index
+
+        # Check if footprints are valid
+        if fp_left is None or fp_right is None:
+            print("One or both footprints are None in LineInfo.")
+            self.footprint = None
+            return
+
+        try:
+            # Buffer cleanup for validity
+            fp_left.geometry = fp_left.geometry.buffer(0)
+            fp_right.geometry = fp_right.geometry.buffer(0)
+
+            fp_combined = pd.concat([fp_left, fp_right])
+
+            if fp_combined.empty or not isinstance(fp_combined, gpd.GeoDataFrame):
+                print("Combined footprint is invalid or empty.")
+                self.footprint = None
+                return
+
+            fp_combined = fp_combined.dissolve()
+            fp_combined.geometry = fp_combined.geometry.buffer(-0.005)
+
+            self.footprint = fp_combined
+        except Exception as e:
+            print(f"Error combining footprints: {e}")
+            self.footprint = None
+            return
+
+        # Transfer group value to footprint if present
         if bt_const.BT_GROUP in self.line.columns:
             self.footprint[bt_const.BT_GROUP] = self.line[bt_const.BT_GROUP].iloc[0]
 
@@ -183,27 +257,25 @@ class LineInfo:
                 print("Empty buffer ring")
 
     def cal_percentileRing(self, ring):
+        line_buffer = None
         try:
             line_buffer = ring.geometry
             if line_buffer.is_empty or shapely.is_missing(line_buffer):
                 return None
             if line_buffer.has_z:
-                line_buffer = sh_ops.transform(
-                    lambda x, y, z=None: (x, y), line_buffer
-                )
+                line_buffer = sh_ops.transform(lambda x, y, z=None: (x, y), line_buffer)
 
         except Exception as e:
             print(f"cal_percentileRing: {e}")
+            return None
 
         # TODO: temporary workaround for exception causing not percentile defined
         try:
-            clipped_raster, _ = bt_common.clip_raster(self.in_chm, line_buffer, 0)
+            clipped_raster, _ = sp_common.clip_raster(self.in_chm, line_buffer, 0)
             clipped_raster = np.squeeze(clipped_raster, axis=0)
 
             # mask all -9999 (nodata) value cells
-            masked_raster = np.ma.masked_where(
-                clipped_raster == bt_const.BT_NODATA, clipped_raster
-            )
+            masked_raster = np.ma.masked_where(clipped_raster == bt_const.BT_NODATA, clipped_raster)
             filled_raster = np.ma.filled(masked_raster, np.nan)
 
             # Calculate the percentile
@@ -288,7 +360,7 @@ class LineInfo:
         except IndexError:
             pass
 
-        # if still no result found, lower to 10% (1.1), 
+        # if still no result found, lower to 10% (1.1),
         # if no result found then default is used
         if not found:
             if 0.5 >= median_percentile:
@@ -318,31 +390,25 @@ class LineInfo:
         """
         Buffers an input DataFrames geometry nring (number of rings) times.
 
-        Compute with a distance between rings of ringdist and returns 
+        Compute with a distance between rings of ringdist and returns
         a list of non overlapping buffers
         """
         rings = []  # A list to hold the individual buffers
         line = df.geometry.iloc[0]
         # For each ring (1, 2, 3, ..., nrings)
-        for ring in np.arange(0, ringdist, nrings):  
+        for ring in np.arange(0, ringdist, nrings):
             big_ring = line.buffer(
                 nrings + ring, single_sided=True, cap_style="flat"
             )  # Create one big buffer
-            small_ring = line.buffer(
-                ring, single_sided=True, cap_style="flat"
-            )  # Create one smaller one
-            the_ring = big_ring.difference(
-                small_ring
-            )  # Difference the big with the small to create a ring
+            small_ring = line.buffer(ring, single_sided=True, cap_style="flat")  # Create one smaller one
+            the_ring = big_ring.difference(small_ring)  # Difference the big with the small to create a ring
             if (
                 ~shapely.is_empty(the_ring)
                 or ~shapely.is_missing(the_ring)
                 or not None
                 or ~the_ring.area == 0
             ):
-                if isinstance(the_ring, sh_geom.MultiPolygon) or isinstance(
-                    the_ring, shapely.Polygon
-                ):
+                if isinstance(the_ring, sh_geom.MultiPolygon) or isinstance(the_ring, shapely.Polygon):
                     rings.append(the_ring)  # Append the ring to the rings list
                 else:
                     if isinstance(the_ring, shapely.GeometryCollection):
@@ -379,40 +445,32 @@ class LineInfo:
 
     def dyn_canopy_cost_raster(self, side):
         in_chm_raster = self.in_chm
-        # tree_radius = self.tree_radius
-        # max_line_dist = self.max_line_dist
-        # canopy_avoid = self.canopy_avoidance
-        # exponent = self.exponent
         line_df = self.line
         out_meta = self.out_meta
 
         canopy_thresh_percentage = self.canopy_thresh_percentage / 100
 
+        Cut_Dist = None
+        line_buffer = None
         if side == Side.left:
-            canopy_ht_threshold = line_df.CL_CutHt * canopy_thresh_percentage
+            canopy_ht_threshold = line_df.CL_CutHt.iloc[0] * canopy_thresh_percentage
             Cut_Dist = self.LDist_Cut
             line_buffer = self.buffer_left
         elif side == Side.right:
-            canopy_ht_threshold = line_df.CR_CutHt * canopy_thresh_percentage
+            canopy_ht_threshold = line_df.CR_CutHt.iloc[0] * canopy_thresh_percentage
             Cut_Dist = self.RDist_Cut
             line_buffer = self.buffer_right
         else:
             canopy_ht_threshold = 0.5
+            Cut_Dist = 1.0
+            line_buffer = None
 
         canopy_ht_threshold = float(canopy_ht_threshold)
         if canopy_ht_threshold <= 0:
             canopy_ht_threshold = 0.5
 
-        # get the round up integer number for tree search radius
-        # tree_radius = float(tree_radius)
-        # max_line_dist = float(max_line_dist)
-        # canopy_avoid = float(canopy_avoid)
-        # cost_raster_exponent = float(exponent)
-
         try:
-            clipped_rasterC, out_meta = bt_common.clip_raster(
-                in_chm_raster, line_buffer, 0
-            )
+            clipped_rasterC, out_meta = sp_common.clip_raster(in_chm_raster, line_buffer, 0)
             negative_cost_clip, dyn_canopy_ndarray = algo_cost.cost_raster(
                 clipped_rasterC,
                 out_meta,
@@ -431,13 +489,21 @@ class LineInfo:
 
     def process_single_footprint(self, side):
         # this will change segment content, and parameters will be changed
-        in_canopy_r, in_cost_r, in_meta, Cut_Dist = self.dyn_canopy_cost_raster(side)
+        result = self.dyn_canopy_cost_raster(side)
+        if result is None:
+            return None
+        in_canopy_r, in_cost_r, in_meta, Cut_Dist = result
+
+        if in_canopy_r is None or in_cost_r is None or in_meta is None or Cut_Dist is None:
+            return None
 
         if np.isnan(in_canopy_r).all():
             print("Canopy raster empty")
+            return None
 
         if np.isnan(in_cost_r).all():
             print("Cost raster empty")
+            return None
 
         exp_shk_cell = self.exponent  # TODO: duplicate vars
         no_data = self.nodata
@@ -448,8 +514,13 @@ class LineInfo:
         segment_list = []
 
         feat = self.line.geometry.iloc[0]
-        for coord in feat.coords:
-            segment_list.append(coord)
+        if hasattr(feat, "geoms"):
+            for geom in feat.geoms:
+                for coord in geom.coords:
+                    segment_list.append(coord)
+        else:
+            for coord in feat.coords:
+                segment_list.append(coord)
 
         cell_size_x = in_transform[0]
         cell_size_y = -in_transform[4]
@@ -465,9 +536,7 @@ class LineInfo:
             # generate 1m interval points along line
             distance_delta = 1
             distances = np.arange(0, feat.length, distance_delta)
-            multipoint_along_line = [
-                feat.interpolate(distance) for distance in distances
-            ]
+            multipoint_along_line = [feat.interpolate(distance) for distance in distances]
             multipoint_along_line.append(sh_geom.Point(segment_list[-1]))
             # Rasterize points along line
             rasterized_points_Alongln = ras_feat.rasterize(
@@ -481,12 +550,8 @@ class LineInfo:
             points_Alongln = np.transpose(np.nonzero(rasterized_points_Alongln))
 
             # Find minimum cost paths through an N-d costs array.
-            mcp_flexible1 = MCP_Flexible(
-                in_cost_r, sampling=(cell_size_x, cell_size_y), fully_connected=True
-            )
-            flex_cost_alongLn, flex_back_alongLn = mcp_flexible1.find_costs(
-                starts=points_Alongln
-            )
+            mcp_flexible1 = MCP_Flexible(in_cost_r, sampling=(cell_size_x, cell_size_y), fully_connected=True)
+            flex_cost_alongLn, flex_back_alongLn = mcp_flexible1.find_costs(starts=points_Alongln)
 
             # Generate corridor
             corridor = flex_cost_alongLn
@@ -507,9 +572,7 @@ class LineInfo:
                 corridor_th_value = bt_const.FP_CORRIDOR_THRESHOLD / cell_size_x
 
             corridor_thresh = np.ma.where(corridor_norm >= corridor_th_value, 1.0, 0.0)
-            clean_raster = algo_common.morph_raster(
-                corridor_thresh, in_canopy_r, exp_shk_cell, cell_size_x
-            )
+            clean_raster = algo_common.morph_raster(corridor_thresh, in_canopy_r, exp_shk_cell, cell_size_x)
 
             # create mask for non-polygon area
             mask = np.where(clean_raster == 1, True, False)
@@ -517,61 +580,35 @@ class LineInfo:
                 clean_raster = clean_raster.astype(np.int32)
 
             # Process: ndarray to shapely Polygon
-            out_polygon = ras_feat.shapes(
-                clean_raster, mask=mask, transform=in_transform
-            )
+            out_polygon = ras_feat.shapes(clean_raster, mask=mask, transform=in_transform)
 
             # create a shapely MultiPolygon
             multi_polygon = []
-            for poly, value in out_polygon:
-                multi_polygon.append(sh_geom.shape(poly))
-            poly = sh_geom.MultiPolygon(multi_polygon)
-
-            # create a pandas DataFrame for the FP
-            out_data = pd.DataFrame(
-                {
-                    "CorriThresh": [corridor_th_value],
-                    "geometry": [poly]
-                }
-            )
-            out_gdata = gpd.GeoDataFrame(
-                out_data, geometry="geometry", crs=shapefile_proj
-            )
+            if out_polygon is not None:
+                try:
+                    for poly, value in out_polygon:
+                        multi_polygon.append(sh_geom.shape(poly))
+                except TypeError:
+                    pass
+
+            if not multi_polygon:
+                print("No polygons generated from raster. Returning None.")
+                return None
+
+            poly = sh_geom.MultiPolygon(multi_polygon) if multi_polygon else None
+
+            # create GeoDataFrame directly from dictionary
+            out_gdata = gpd.GeoDataFrame({"CorriThresh": [corridor_th_value], "geometry": [poly]})
+            out_gdata.set_geometry("geometry", inplace=True)
+            if shapefile_proj:
+                out_gdata = out_gdata.set_crs(shapefile_proj, allow_override=True)
+
+            if out_gdata is None or out_gdata.empty or out_gdata.geometry.isnull().all():
+                print("Empty GeoDataFrame from process_single_footprint.")
+                return None
 
             return out_gdata
 
         except Exception as e:
             print("Exception: {}".format(e))
-
-def line_footprint_rel(
-    in_line,
-    in_chm,
-    out_footprint,
-    processes,
-    verbose=True,
-    in_layer=None,
-    out_layer=None,
-    max_ln_width=32,
-    tree_radius=1.5,
-    max_line_dist=1.5,
-    canopy_avoidance=0.0,
-    exponent=1.0,
-    canopy_thresh_percentage=50,
-    parallel_mode=bt_const.ParallelMode.MULTIPROCESSING,
-):
-    """Another version of relative canopy footprint tool."""
-    footprint = FootprintCanopy(in_line, in_chm, in_layer)
-    footprint.compute(processes, parallel_mode)
-
-    # footprint.save_line_percentile(out_file_percentile)
-    footprint.save_footprint(out_footprint, out_layer)
-
-if __name__ == "__main__":
-    """This part is to be another version of relative canopy footprint tool."""
-    in_args, in_verbose = bt_common.check_arguments()
-    start_time = time.time()
-    line_footprint_rel(
-        **in_args.input, processes=int(in_args.processes), verbose=in_verbose
-    )
-
-    print("Elapsed time: {}".format(time.time() - start_time))
+            return None