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

beratools/core/algo_cost.py

@@ -12,6 +12,7 @@ Description:
 
     This file hosts cost raster related functions.
 """
+
 import numpy as np
 import scipy
 
@@ -35,7 +36,7 @@ def cost_raster(
     """
     if len(in_raster.shape) > 2:
         in_raster = np.squeeze(in_raster, axis=0)
-    
+
     # regulate canopy_avoid between 0 and 1
     avoidance = max(0, min(1, canopy_avoid))
     cell_x, cell_y = meta["transform"][0], -meta["transform"][4]
@@ -45,9 +46,7 @@ def cost_raster(
     dyn_canopy_ndarray = dyn_np_cc_map(in_raster, canopy_ht_threshold)
 
     cc_std, cc_mean = cost_focal_stats(dyn_canopy_ndarray, kernel)
-    cc_smooth = cost_norm_dist_transform(
-        dyn_canopy_ndarray, max_line_dist, [cell_x, cell_y]
-    )
+    cc_smooth = cost_norm_dist_transform(dyn_canopy_ndarray, max_line_dist, [cell_x, cell_y])
 
     cost_clip = dyn_np_cost_raster_refactor(
         dyn_canopy_ndarray, cc_mean, cc_std, cc_smooth, avoidance, cost_raster_exponent
@@ -59,62 +58,56 @@ def cost_raster(
 
     return cost_clip, dyn_canopy_ndarray
 
+
 def remove_nan_from_array_refactor(matrix, replacement_value=bt_const.BT_NODATA_COST):
     # Use boolean indexing to replace nan values
     matrix[np.isnan(matrix)] = replacement_value
 
+
 def dyn_np_cc_map(in_chm, canopy_ht_threshold):
     """
     Create a new canopy raster.
 
-    MaskedArray based on the threshold comparison of in_chm (canopy height model) 
-    with canopy_ht_threshold. It assigns 1.0 where the condition is True (canopy) 
+    MaskedArray based on the threshold comparison of in_chm (canopy height model)
+    with canopy_ht_threshold. It assigns 1.0 where the condition is True (canopy)
     and 0.0 where the condition is False (non-canopy).
 
     """
     canopy_ndarray = np.ma.where(in_chm >= canopy_ht_threshold, 1.0, 0.0).astype(float)
     return canopy_ndarray
 
+
 def cost_focal_stats(canopy_ndarray, kernel):
     mask = canopy_ndarray.mask
     in_ndarray = np.ma.where(mask, np.nan, canopy_ndarray)
 
     # Function to compute mean and standard deviation
     def calc_mean(arr):
-        # Check if the array is empty or full of NaNs
-        if arr.size == 0 or np.all(np.isnan(arr)):
-            return np.nan  # Or any other value you'd prefer for empty arrays
         return np.nanmean(arr)
 
     def calc_std(arr):
-        # Check if the array is empty or full of NaNs
-        if arr.size == 0 or np.all(np.isnan(arr)):
-            return np.nan  # Or any other placeholder you prefer
         return np.nanstd(arr)
 
     # Apply the generic_filter function to compute mean and std
-    mean_array = scipy.ndimage.generic_filter(
-        in_ndarray, calc_mean, footprint=kernel, mode="nearest"
-    )
-    std_array = scipy.ndimage.generic_filter(
-        in_ndarray, calc_std, footprint=kernel, mode="nearest"
-    )
+    mean_array = scipy.ndimage.generic_filter(in_ndarray, calc_mean, footprint=kernel, mode="nearest")
+    std_array = scipy.ndimage.generic_filter(in_ndarray, calc_std, footprint=kernel, mode="nearest")
 
     return std_array, mean_array
 
+
 def cost_norm_dist_transform(canopy_ndarray, max_line_dist, sampling):
     """Compute a distance-based cost map based on the proximity of valid data points."""
     # Convert masked array to a regular array and fill the masked areas with np.nan
     in_ndarray = canopy_ndarray.filled(np.nan)
-    
+
     # Compute the Euclidean distance transform (edt) where the valid values are
     euc_dist_array = scipy.ndimage.distance_transform_edt(
         np.logical_not(np.isnan(in_ndarray)), sampling=sampling
     )
-    
+
     # Apply the mask back to set the distances to np.nan
     euc_dist_array[canopy_ndarray.mask] = np.nan
-    
+
     # Calculate the smoothness (cost) array
     normalized_cost = float(max_line_dist) - euc_dist_array
     normalized_cost[normalized_cost <= 0.0] = 0.0
@@ -122,9 +115,8 @@ def cost_norm_dist_transform(canopy_ndarray, max_line_dist, sampling):
 
     return smooth_cost_array
 
-def dyn_np_cost_raster_refactor(
-    canopy_ndarray, cc_mean, cc_std, cc_smooth, avoidance, cost_raster_exponent
-):
+
+def dyn_np_cost_raster_refactor(canopy_ndarray, cc_mean, cc_std, cc_smooth, avoidance, cost_raster_exponent):
     # Calculate the lower and upper bounds for canopy cover (mean ± std deviation)
     lower_bound = cc_mean - cc_std
     upper_bound = cc_mean + cc_std
@@ -158,6 +150,7 @@ def dyn_np_cost_raster_refactor(
 
     return result_cost_raster
 
+
 def circle_kernel_refactor(size, radius):
     """
     Create a circular kernel using Scipy.
@@ -189,4 +182,4 @@ def circle_kernel_refactor(size, radius):
 
     # Create a circular kernel
     kernel = distance <= radius
-    return kernel.astype(float)
+    return kernel.astype(float)

beratools/core/algo_dijkstra.py

@@ -17,7 +17,7 @@ the Free Software Foundation; either version 2 of the License, or
 """
 
 # This will get replaced with a git SHA1 when you do a git archive
-__revision__ = '$Format:%H$'
+__revision__ = "$Format:%H$"
 
 import math
 import queue
@@ -52,9 +52,7 @@ class MinCostPathHelper:
     def create_points_from_path(ras_transform, min_cost_path, start_point, end_point):
         path_points = list(
             map(
-                lambda row_col: MinCostPathHelper._row_col_to_point(
-                    row_col, ras_transform
-                ),
+                lambda row_col: MinCostPathHelper._row_col_to_point(row_col, ras_transform),
                 min_cost_path,
             )
         )
@@ -71,7 +69,7 @@ class MinCostPathHelper:
     @staticmethod
     def block2matrix_numpy(block, nodata):
         contains_negative = False
-        with np.nditer(block, flags=["refs_ok"], op_flags=['readwrite']) as it:
+        with np.nditer(block, flags=["refs_ok"], op_flags=["readwrite"]) as it:
             for x in it:
                 # TODO: this speeds up a lot, but need further inspection
                 # if np.isclose(x, nodata) or np.isnan(x):
@@ -90,8 +88,7 @@ class MinCostPathHelper:
         matrix = [
             [
                 None
-                if np.isclose(block[i][j], nodata)
-                or np.isclose(block[i][j], bt_const.BT_NODATA)
+                if np.isclose(block[i][j], nodata) or np.isclose(block[i][j], bt_const.BT_NODATA)
                 else block[i][j]
                 for j in range(height)
             ]
@@ -129,8 +126,16 @@ def dijkstra(start_tuple, end_tuples, block, find_nearest, feedback=None):
 
         def neighbors(self, id):
             x, y = id
-            results = [(x + 1, y), (x, y - 1), (x - 1, y), (x, y + 1),
-                       (x + 1, y - 1), (x + 1, y + 1), (x - 1, y - 1), (x - 1, y + 1)]
+            results = [
+                (x + 1, y),
+                (x, y - 1),
+                (x - 1, y),
+                (x, y + 1),
+                (x + 1, y - 1),
+                (x + 1, y + 1),
+                (x - 1, y - 1),
+                (x - 1, y + 1),
+            ]
             results = list(filter(self.is_valid, results))
             return results
 
@@ -142,22 +147,15 @@ def dijkstra(start_tuple, end_tuples, block, find_nearest, feedback=None):
 
         @staticmethod
         def min_manhattan(curr_node, end_nodes):
-            return min(
-                map(lambda node: Grid.manhattan_distance(curr_node, node), end_nodes)
-            )
+            return min(map(lambda node: Grid.manhattan_distance(curr_node, node), end_nodes))
 
         @staticmethod
         def max_manhattan(curr_node, end_nodes):
-            return max(
-                map(lambda node: Grid.manhattan_distance(curr_node, node), end_nodes)
-            )
+            return max(map(lambda node: Grid.manhattan_distance(curr_node, node), end_nodes))
 
         @staticmethod
         def all_manhattan(curr_node, end_nodes):
-            return {
-                end_node: Grid.manhattan_distance(curr_node, end_node)
-                for end_node in end_nodes
-            }
+            return {end_node: Grid.manhattan_distance(curr_node, end_node) for end_node in end_nodes}
 
         def simple_cost(self, cur, nex):
             cx, cy = cur
@@ -230,10 +228,7 @@ def dijkstra(start_tuple, end_tuples, block, find_nearest, feedback=None):
                     bound = curr_bound
                     if feedback:
                         feedback.setProgress(
-                            1
-                            + 100
-                            * (1 - bound / total_manhattan)
-                            * (1 - bound / total_manhattan)
+                            1 + 100 * (1 - bound / total_manhattan) * (1 - bound / total_manhattan)
                         )
 
         # destination
@@ -336,6 +331,9 @@ def backtrack(initial_node, desired_node, distances):
         if path[-1][0] == initial_node[0] and path[-1][1] == initial_node[1]:
             break
 
+    if len(path) == 0 or path[-1][0] != initial_node[0] or path[-1][1] != initial_node[1]:
+        return None
+
     return list(reversed(path))
 
 
@@ -371,11 +369,9 @@ def dijkstra_np(start_tuple, end_tuple, matrix):
     return [(path, costs, end_tuple)]
 
 
-def find_least_cost_path(
-    out_image, in_meta, line, find_nearest=True, output_linear_reference=False
-):
+def find_least_cost_path(out_image, in_meta, line, find_nearest=True, output_linear_reference=False):
     default_return = None
-    ras_nodata = in_meta['nodata']
+    ras_nodata = in_meta["nodata"]
 
     pt_start = line.coords[0]
     pt_end = line.coords[-1]
@@ -385,24 +381,22 @@ def find_least_cost_path(
         out_image = np.squeeze(out_image, axis=0)
 
     if USE_NUMPY_FOR_DIJKSTRA:
-        matrix, contains_negative = MinCostPathHelper.block2matrix_numpy(
-            out_image, ras_nodata
-        )
+        matrix, contains_negative = MinCostPathHelper.block2matrix_numpy(out_image, ras_nodata)
     else:
-        matrix, contains_negative = MinCostPathHelper.block2matrix(
-            out_image, ras_nodata
-        )
+        matrix, contains_negative = MinCostPathHelper.block2matrix(out_image, ras_nodata)
 
     if contains_negative:
-        print('ERROR: Raster has negative values.')
+        print("ERROR: Raster has negative values.")
         return default_return
 
-    transformer = rasterio.transform.AffineTransformer(in_meta['transform'])
+    transformer = rasterio.transform.AffineTransformer(in_meta["transform"])
 
-    if (type(pt_start[0]) is tuple or
-            type(pt_start[1]) is tuple or
-            type(pt_end[0]) is tuple or
-            type(pt_end[1]) is tuple):
+    if (
+        type(pt_start[0]) is tuple
+        or type(pt_start[1]) is tuple
+        or type(pt_end[0]) is tuple
+        or type(pt_end[1]) is tuple
+    ):
         print("Point initialization error. Input is tuple.")
         return default_return
 
@@ -446,7 +440,7 @@ def find_least_cost_path(
         return default_return
 
     if len(result) == 0:
-        print('No result returned.')
+        print("No result returned.")
         return default_return
 
     path_points = None
@@ -473,7 +467,7 @@ def find_least_cost_path_skimage(cost_clip, in_meta, seed_line):
     if len(cost_clip.shape) > 2:
         cost_clip = np.squeeze(cost_clip, axis=0)
 
-    out_transform = in_meta['transform']
+    out_transform = in_meta["transform"]
     transformer = rasterio.transform.AffineTransformer(out_transform)
 
     x1, y1 = list(seed_line.coords)[0][:2]
@@ -482,9 +476,7 @@ def find_least_cost_path_skimage(cost_clip, in_meta, seed_line):
     row2, col2 = transformer.rowcol(x2, y2)
 
     try:
-        path_new = sk_graph.route_through_array(
-            cost_clip[0], [row1, col1], [row2, col2]
-        )
+        path_new = sk_graph.route_through_array(cost_clip[0], [row1, col1], [row2, col2])
     except Exception as e:
         print(f"find_least_cost_path_skimage: {e}")
         return None
@@ -495,7 +487,7 @@ def find_least_cost_path_skimage(cost_clip, in_meta, seed_line):
             lc_path_new.append((x, y))
 
     if len(lc_path_new) < 2:
-        print('No least cost path detected, pass.')
+        print("No least cost path detected, pass.")
         return None
     else:
         lc_path_new = sh_geom.LineString(lc_path_new)