BERATools 0.2.0__py3-none-any.whl

beratools/tools/canopycostraster.py

@@ -0,0 +1,222 @@
+import os
+import sys
+import time
+import numpy as np
+from numpy.lib.stride_tricks import as_strided
+
+import rasterio
+import xarray as xr
+from xrspatial import convolution, focal
+from scipy import ndimage
+
+from common import *
+
+
+# TODO: Rolling Statistics for grid data... an alternative
+# by  Dan Patterson
+
+
+def _check(a, r_c, subok=False):
+    """Performs the array checks necessary for stride and block.
+    : in_array   - Array or list.
+    : r_c - tuple/list/array of rows x cols.
+    : subok - from numpy 1.12 added, keep for now
+    :Returns:
+    :------
+    :Attempts will be made to ...
+    :  produce a shape at least (1*c).  For a scalar, the
+    :  minimum shape will be (1*r) for 1D array or (1*c) for 2D
+    :  array if r<c.  Be aware
+    """
+    if isinstance(r_c, (int, float)):
+        r_c = (1, int(r_c))
+
+    r, c = r_c
+    if a.ndim == 1:
+        a = np.atleast_2d(a)
+
+    r, c = r_c = (min(r, a.shape[0]), min(c, a.shape[1]))
+    a = np.array(a, copy=False, subok=subok)
+    return a, r, c, tuple(r_c)
+
+
+def _pad(in_array, kernel):
+    """Pad a sliding array to allow for stats"""
+    pad_x = int(kernel.shape[0] / 2)
+    pad_y = int(kernel.shape[0] / 2)
+    result = np.pad(in_array, pad_width=(pad_x, pad_y), mode="constant", constant_values=(np.NaN, np.NaN))
+
+    return result
+
+
+def stride(a, r_c):
+    """Provide a 2D sliding/moving view of an array.
+    :  There is no edge correction for outputs.
+    :
+    :Requires:
+    :--------
+    : _check(a, r_c) ... Runs the checks on the inputs.
+    : a - array or list, usually a 2D array.  Assumes rows is >=1,
+    :     it is corrected as is the number of columns.
+    : r_c - tuple/list/array of rows x cols.  Attempts  to
+    :     produce a shape at least (1*c).  For a scalar, the
+    :     minimum shape will be (1*r) for 1D array or 2D
+    :     array if r<c.  Be aware
+    """
+    a, r, c, r_c = _check(a, r_c)
+    shape = (a.shape[0] - r + 1, a.shape[1] - c + 1) + r_c
+    strides = a.strides * 2
+    a_s = (as_strided(a, shape=shape, strides=strides)).squeeze()
+    return a_s
+
+
+def normalize_chm(raster):
+    n_raster = np.where(raster >= 0, raster, 0)
+    return n_raster
+
+
+def np_cc_map(out_canopy_r, chm, in_array, min_ht):
+    print('Generating Canopy Closure Raster ...')
+
+    # canopy_ndarray = np.where(in_array >= min_ht, 1., 0.).astype(float)
+    canopy_ndarray = np.ma.where(in_array > min_ht, 1., 0.).astype(float)
+    canopy_ndarray = np.ma.filled(canopy_ndarray, chm.nodata)
+    try:
+        write_canopy = rasterio.open(out_canopy_r, 'w', **chm.profile)
+        write_canopy.write(canopy_ndarray, 1)
+        write_canopy.close()
+        print('Generating Canopy Closure (CC) Raster ... Done')
+    except Exception as e:
+        print(sys.exc_info())
+    del in_array
+    return canopy_ndarray
+
+
+def fs_raster(in_ndarray, kernel):
+    print('Generating Canopy Closure Focal Statistic ...')
+    padded_array = _pad(in_ndarray, kernel)
+    a_s = stride(padded_array, kernel.shape)
+
+    # TODO: np.where on large ndarray fail (allocate memory error)
+    a_s_masked = np.where(kernel == 1, a_s, np.NaN)
+    print("Calculating Canopy Closure's Focal Statistic-Mean ...")
+    mean_result = np.nanmean(a_s_masked, axis=(2, 3))
+    print("Calculating Canopy Closure's Focal Statistic-Stand Deviation Raster ...")
+    stdev_result = np.nanstd(a_s_masked, axis=(2, 3))
+    del a_s
+    return mean_result, stdev_result
+
+
+def fs_raster_stdmean(in_ndarray, kernel, nodata):
+    # This function uses xrspatial whcih can handle large data but slow
+    in_ndarray[in_ndarray == nodata] = np.nan
+    result_ndarray = focal.focal_stats(xr.DataArray(in_ndarray), kernel, stats_funcs=['std', 'mean'])
+
+    # Flattening the array
+    flatten_std_result_ndarray = result_ndarray[0].data.reshape(-1)
+    flatten_mean_result_ndarray = result_ndarray[1].data.reshape(-1)
+
+    # Re-shaping the array
+    reshape_std_ndarray = flatten_std_result_ndarray.reshape(in_ndarray.shape[0], in_ndarray.shape[1])
+    reshape_mean_ndarray = flatten_mean_result_ndarray.reshape(in_ndarray.shape[0], in_ndarray.shape[1])
+    return reshape_std_ndarray, reshape_mean_ndarray
+
+
+def smooth_cost(in_raster, search_dist, sampling):
+    print('Generating Cost Raster ...')
+    from tempfile import mkdtemp
+    import os.path as path
+    import shutil
+
+    euc_dist_array = None
+    row, col = in_raster.shape
+    if row * col >= 30000 * 30000:
+        filename = path.join(mkdtemp(), 'tempmmemap.dat')
+        a_in_mat = np.memmap(filename, in_raster.dtype, 'w+', shape=in_raster.shape)
+        a_in_mat[:] = in_raster[:]
+        a_in_mat.flush()
+        euc_dist_array = ndimage.distance_transform_edt(np.logical_not(a_in_mat), sampling=sampling)
+        del a_in_mat, in_raster
+        shutil.rmtree(path.dirname(filename))
+    else:
+        euc_dist_array = ndimage.distance_transform_edt(np.logical_not(in_raster), sampling=sampling)
+
+    smooth1 = float(search_dist) - euc_dist_array
+    smooth1[smooth1 <= 0.0] = 0.0
+    smooth_cost_array = smooth1 / float(search_dist)
+
+    return smooth_cost_array
+
+
+def np_cost_raster(canopy_ndarray, cc_mean, cc_std, cc_smooth, chm, avoidance, cost_raster_exponent, out_cost_r):
+    print('Generating Smoothed Cost Raster ...')
+    aM1a = (cc_mean - cc_std)
+    aM1b = (cc_mean + cc_std)
+    aM1 = np.divide(aM1a, aM1b, where=aM1b != 0, out=np.zeros(aM1a.shape, dtype=float))
+    aM = (1 + aM1) / 2
+    aaM = (cc_mean + cc_std)
+    bM = np.where(aaM <= 0, 0, aM)
+    cM = bM * (1 - avoidance) + (cc_smooth * avoidance)
+    dM = np.where(canopy_ndarray == 1, 1, cM)
+    eM = np.exp(dM)
+    result = np.power(eM, float(cost_raster_exponent))
+    write_cost = rasterio.open(out_cost_r, 'w+', driver='GTiff', height=chm.shape[0], width=chm.shape[1],
+                               count=1, dtype=chm.read(1).dtype, crs=chm.crs, transform=chm.transform)
+    write_cost.write(result, 1)
+    write_cost.close()
+    print('Generating Smoothed Cost Raster ... Done')
+    return
+
+
+# TODO: deal with NODATA
+def canopy_cost_raster(callback, in_chm, canopy_ht_threshold, tree_radius, max_line_dist,
+                       canopy_avoidance, exponent, out_canopy, out_cost, processes, verbose):
+    canopy_ht_threshold = float(canopy_ht_threshold)
+    tree_radius = float(tree_radius)
+    max_line_dist = float(max_line_dist)
+    canopy_avoidance = float(canopy_avoidance)
+    cost_raster_exponent = float(exponent)
+
+    print('In CHM: ' + in_chm)
+    chm = rasterio.open(in_chm)
+    (cell_x, cell_y) = chm.res
+
+    print('Loading CHM ...')
+    band1_ndarray = chm.read(1, masked=True)
+    print('%{}'.format(10))
+
+    print('Preparing Kernel window ...')
+    kernel = convolution.circle_kernel(cell_x, cell_y, tree_radius)
+    print('%{}'.format(20))
+
+    # Generate Canopy Raster and return the Canopy array
+    canopy_ndarray = np_cc_map(out_canopy, chm, band1_ndarray, canopy_ht_threshold)
+    print('%{}'.format(40))
+    print('Apply focal statistic on raster ...')
+
+    # Calculating focal statistic from canopy raster
+    # Alternative: (only work on large cell size
+    if cell_y > 1 and cell_x > 1:
+        cc_mean, cc_std = fs_raster(canopy_ndarray, kernel)
+    else:
+        cc_std, cc_mean = fs_raster_stdmean(canopy_ndarray, kernel, chm.nodata)
+    print('%{}'.format(60))
+    print('Apply focal statistic on raster ... Done')
+
+    # Smoothing raster
+    cc_smooth = smooth_cost(canopy_ndarray, max_line_dist, [cell_x, cell_y])
+    avoidance = max(min(float(canopy_avoidance), 1), 0)
+    np_cost_raster(canopy_ndarray, cc_mean, cc_std, cc_smooth, chm, avoidance, cost_raster_exponent, out_cost)
+    print('%{}'.format(100))
+
+
+if __name__ == '__main__':
+    in_args, in_verbose = check_arguments()
+
+    start_time = time.time()
+    print('Starting Canopy and Cost Raster processing\n @ {}'
+          .format(time.strftime("%d %b %Y %H:%M:%S", time.localtime())))
+
+    canopy_cost_raster(print, **in_args.input, processes=int(in_args.processes), verbose=in_verbose)
+    print('Canopy and Cost Raster processing is done in {} seconds)'
+          .format(round(time.time() - start_time, 5)))

beratools/tools/centerline.py

@@ -0,0 +1,176 @@
+import logging
+import time
+
+import sys
+from pathlib import Path
+from inspect import getsourcefile
+
+if __name__ == "__main__":
+    current_file = Path(getsourcefile(lambda: 0)).resolve()
+    btool_dir = current_file.parents[2]
+    sys.path.insert(0, btool_dir.as_posix())
+
+from beratools.core.logger import Logger
+from beratools.core.algo_centerline import *
+from beratools.core.dijkstra_algorithm import *
+from beratools.core.constants import *
+from common import *
+
+log = Logger('centerline', file_level=logging.INFO)
+logger = log.get_logger()
+print = log.print
+
+
+def process_single_line(line_args):
+    line = line_args[0][0]
+    prop = line_args[0][1]
+    line_radius = line_args[1]
+    in_raster = line_args[2]
+    line_id = line_args[3]
+    seed_line = shape(line)  # LineString
+    line_radius = float(line_radius)
+
+    default_return = (seed_line, seed_line, prop, None)
+
+    cost_clip, out_meta = clip_raster(in_raster, seed_line, line_radius)
+
+    if not HAS_COST_RASTER:
+        cost_clip, _ = cost_raster(cost_clip, out_meta)
+
+    lc_path = line
+    try:
+        if CL_USE_SKIMAGE_GRAPH:
+            # skimage shortest path
+            lc_path = find_least_cost_path_skimage(cost_clip, out_meta, seed_line)
+        else:
+            lc_path = find_least_cost_path(cost_clip, out_meta, seed_line)
+    except Exception as e:
+        print(e)
+        return default_return
+
+    if lc_path:
+        lc_path_coords = lc_path.coords
+    else:
+        lc_path_coords = []
+
+    # search for centerline
+    if len(lc_path_coords) < 2:
+        print('No least cost path detected, use input line.')
+        prop['status'] = CenterlineStatus.FAILED.value
+        return default_return
+
+    # get corridor raster
+    lc_path = LineString(lc_path_coords)
+    cost_clip, out_meta = clip_raster(in_raster, lc_path, line_radius * 0.9)
+    if not HAS_COST_RASTER:
+        cost_clip, _ = cost_raster(cost_clip, out_meta)
+
+    out_transform = out_meta['transform']
+    transformer = rasterio.transform.AffineTransformer(out_transform)
+    cell_size = (out_transform[0], -out_transform[4])
+
+    x1, y1 = lc_path_coords[0]
+    x2, y2 = lc_path_coords[-1]
+    source = [transformer.rowcol(x1, y1)]
+    destination = [transformer.rowcol(x2, y2)]
+    corridor_thresh_cl = corridor_raster(cost_clip, out_meta, source, destination,
+                                         cell_size, FP_CORRIDOR_THRESHOLD)
+
+    # 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)
+    prop['status'] = status.value
+
+    print(" Searching centerline: line {} ".format(line_id), flush=True)
+    return center_line, lc_path, prop, corridor_poly_gpd
+
+
+def centerline(callback, in_line, in_raster, line_radius,
+               proc_segments, out_line, processes, verbose):
+    if not compare_crs(vector_crs(in_line), raster_crs(in_raster)):
+        print("Line and CHM have different spatial references, please check.")
+        return
+
+    # Read input line features
+    layer_crs = None
+    schema = None
+    input_lines = []
+
+    with fiona.open(in_line) as open_line_file:
+        layer_crs = open_line_file.crs
+        schema = open_line_file.meta['schema']
+        for line in open_line_file:
+            if line.geometry:
+                if line.geometry['type'] != 'MultiLineString':
+                    input_lines.append([line.geometry, line.properties])
+                else:
+                    print('MultiLineString found.')
+                    geoms = shape(line['geometry']).geoms
+                    for item in geoms:
+                        line_part = fiona.Geometry.from_dict(item)
+                        if line_part:
+                            input_lines.append([line_part, line.properties])
+            else:
+                print(f'Line {line.id} has empty geometry.')
+
+    if proc_segments:
+        # split line segments at vertices
+        input_lines_temp = []
+        for line in input_lines:
+            line_seg = line[0]
+            line_prop = line[1]
+            line_segs = segments(line_seg.coordinates)
+            line_feats = [(line, line_prop) for line in line_segs]
+            if line_segs:
+                input_lines_temp.extend(line_feats)
+
+        input_lines = input_lines_temp
+
+    # Process lines
+    all_lines = []
+    i = 0
+    for line in input_lines:
+        all_lines.append((line, line_radius, in_raster, i))
+        i += 1
+
+    print('{} lines to be processed.'.format(len(all_lines)))
+
+    lc_path_geoms = []
+    feat_props = []
+    center_line_geoms = []
+    corridor_poly_list = []
+    result = execute_multiprocessing(process_single_line, all_lines, 'Centerline',
+                                     processes, 1, verbose=verbose)
+
+    for item in result:
+        center_line = item[0]
+        lc_path = item[1]
+        prop = item[2]
+        corridor_poly = item[3]
+
+        if lc_path and prop:
+            lc_path_geoms.append(lc_path)
+            feat_props.append(prop)
+            center_line_geoms.append(center_line)
+            corridor_poly_list.append(corridor_poly)
+
+    out_centerline_path = Path(out_line)
+    schema['properties']['status'] = 'int'
+    save_features_to_shapefile(out_centerline_path.as_posix(), layer_crs, center_line_geoms, feat_props, schema)
+
+    out_least_cost_path = out_centerline_path.with_stem(out_centerline_path.stem + '_least_cost_path')
+    save_features_to_shapefile(out_least_cost_path.as_posix(), layer_crs, lc_path_geoms, feat_props, schema)
+
+    # save corridor polygons
+    corridor_polys = pd.concat(corridor_poly_list)
+    out_corridor_poly_path = Path(out_line)
+    out_corridor_poly_path = out_corridor_poly_path.with_stem(out_corridor_poly_path.stem + '_corridor_poly')
+    corridor_polys.to_file(out_corridor_poly_path.as_posix())
+
+
+if __name__ == '__main__':
+    in_args, in_verbose = check_arguments()
+    start_time = time.time()
+    centerline(print, **in_args.input, processes=int(in_args.processes), verbose=in_verbose)
+    print('Elapsed time: {}'.format(time.time() - start_time))