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

beratools/tools/canopycostraster.py

@@ -1,222 +0,0 @@
-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/fl_regen_csf.py

@@ -1,428 +0,0 @@
-import math
-import time
-import pandas
-import geopandas
-import numpy
-import scipy
-import os
-import pyogrio
-import shapely
-from shapely.ops import unary_union, split
-from rasterio import mask
-import argparse
-import json
-from multiprocessing.pool import Pool
-
-from common import *
-
-
-class OperationCancelledException(Exception):
-    pass
-
-
-def regen_csf(line_args):
-    # (result_identity,attr_seg_lines, area_analysis, change_analysis, in_change,in_tree_shp)
-    attr_seg_line = line_args[0]
-    result_identity = line_args[1]
-
-    area_analysis = line_args[2]
-    change_analysis = line_args[3]
-    in_change = line_args[4]
-    in_tree = line_args[5]
-
-    has_footprint = True
-    if type(result_identity) is geopandas.geodataframe.GeoDataFrame:
-        if result_identity.empty:
-            has_footprint = False
-        else:
-            # merge result_identity
-            result_identity = result_identity.dissolve()
-
-    elif not result_identity:
-        has_footprint = False
-
-    # Check if query result is not empty, if empty input identity footprint will be skipped
-    if attr_seg_line.empty:
-        return None
-
-    if "AvgWidth" in attr_seg_line.columns.array:
-        max_ln_width = math.ceil(attr_seg_line["AvgWidth"])
-        if not max_ln_width >= 1.0:
-            max_ln_width = 0.5
-    else:
-        if has_footprint:
-            # estimate width= (Perimeter -Sqrt(Perimeter^2-16*Area))/4
-            # for long and skinny: estimate width = 2*Area / Perimeter
-            P = float(result_identity.geometry.length)
-            A = float(result_identity.geometry.area)
-            max_ln_width = math.ceil((2 * A) / P)
-            if not max_ln_width >= 1.0:
-                max_ln_width = 0.5
-        else:
-            max_ln_width = 0.5
-    index = 0
-
-    if change_analysis and has_footprint:  # with change raster and footprint
-
-        fp = result_identity.iloc[0].geometry
-        line_feat = attr_seg_line.iloc[0].geometry
-
-        # if the selected seg do not have identity footprint geometry
-        if shapely.is_empty(fp):
-            # use the buffer from the segment line
-            line_buffer = shapely.buffer(line_feat, float(max_ln_width) / 4)
-        else:
-            # if identity footprint has geometry, use as a buffer area
-            line_buffer = fp
-            # check trees
-        with rasterio.open(in_change) as in_change_file:
-            cell_size_x = in_change_file.transform[0]
-            cell_size_y = -in_change_file.transform[4]
-            # clipped the change base on polygon of line buffer or footprint
-            clipped_change, out_transform = rasterio.mask.mask(in_change_file, [line_buffer], crop=True)
-
-            # drop the ndarray to 2D ndarray
-            clipped_change = numpy.squeeze(clipped_change, axis=0)
-
-            # masked all NoData value cells
-            clean_change = numpy.ma.masked_where(clipped_change == in_change_file.nodata, clipped_change)
-
-            # Calculate the summary statistics from the clipped change
-            change_mean = numpy.nanmean(clean_change)
-        # count trees within FP area
-        trees_counts = len(in_tree[in_tree.within(line_buffer)])
-        trees_density = trees_counts / line_buffer.area
-        if trees_density >= 0.6:
-            reg_class = "Advanced"
-        elif 0.2 < trees_density < 0.6:
-            reg_class = "Regenerating"
-        else:  # 0-60 trees counts
-            if change_mean > 0.06:
-                reg_class = "Regenerating"
-            else:
-                reg_class = "Arrested"
-
-    elif change_analysis and not has_footprint:  # with change raster but no footprint
-
-        line_feat = attr_seg_line.geometry.iloc[0]
-        line_buffer = shapely.buffer(line_feat, float(max_ln_width))
-
-        with rasterio.open(in_change) as in_change_file:
-            cell_size_x = in_change_file.transform[0]
-            cell_size_y = -in_change_file.transform[4]
-            # Calculate the mean changes
-            # clipped the change base on polygon of line buffer or footprint
-            clipped_change, out_transform = rasterio.mask.mask(in_change_file, [line_buffer], crop=True)
-
-            # drop the ndarray to 2D ndarray
-            clipped_change = numpy.squeeze(clipped_change, axis=0)
-
-            # masked all NoData value cells
-            clean_change = numpy.ma.masked_where(clipped_change == in_change_file.nodata, clipped_change)
-
-            # Calculate the summary statistics from the clipped change
-            change_mean = numpy.nanmean(clean_change)
-        # count trees within FP area
-        trees_counts = len(in_tree[in_tree.within(line_buffer)])
-        trees_density = trees_counts / line_buffer.area
-        if trees_density >= 0.6:
-            reg_class = "Advanced"
-        elif 0.2 < trees_density < 0.6:
-            reg_class = "Regenerating"
-        else:  # 0-60 trees counts
-            if change_mean > 0.06:
-                reg_class = "Regenerating"
-            else:
-                reg_class = "Arrested"
-    elif not change_analysis or not has_footprint:  # Either no change_analysis or no footprint
-        line_feat = attr_seg_line.geometry.iloc[0]
-
-        # if the selected seg do not have identity footprint geometry
-        line_buffer = shapely.buffer(line_feat, float(max_ln_width))
-
-        # count trees within FP area
-        trees_counts = len(in_tree[in_tree.within(line_buffer)])
-        trees_density = trees_counts / line_buffer.area
-        if trees_density >= 0.6:
-            reg_class = "Advanced"
-        elif 0.2 < trees_density < 0.6:
-            reg_class = "Regenerating"
-        else:
-            reg_class = "Not Available"
-
-        change_mean = numpy.nan
-    elif not change_analysis and not has_footprint:  # no change raster and no footprint
-        reg_class = "Not Available"
-        change_mean = numpy.nan
-        trees_counts = numpy.nan
-        trees_density = numpy.nan
-
-    attr_seg_line["AveChanges"] = change_mean
-    attr_seg_line["Num_trees"] = trees_counts
-    attr_seg_line["trees_density"] = trees_density
-    attr_seg_line["Reg_Class"] = reg_class
-    return attr_seg_line
-
-
-def identity_polygon(line_args):
-    line = line_args[0]
-    in_touched_fp = line_args[1][['geometry', 'OLnFID', 'OLnSEG']]
-    in_search_polygon = line_args[2]
-    if 'OLnSEG' not in in_search_polygon.columns.array:
-        in_search_polygon = in_search_polygon.assign(OLnSEG=0)
-    if 'OLnFID' not in in_search_polygon.columns.array:
-        in_search_polygon = in_search_polygon.assign(OLnFID=in_search_polygon['OLnFID'].index)
-    identity = None
-    try:
-        # TODO: determine when there is empty polygon
-        # TODO: this will produce empty identity
-        if not in_search_polygon.empty:
-            identity = in_search_polygon.overlay(in_touched_fp, how='identity')
-            identity = identity.dropna(subset=['OLnSEG_2', 'OLnFID_2'])
-            identity = identity.drop(columns=['OLnSEG_1', 'OLnFID_2'])
-            identity = identity.rename(columns={'OLnFID_1': 'OLnFID', 'OLnSEG_2': 'OLnSEG'})
-    except Exception as e:
-        print(e)
-
-    return line, identity
-
-
-def execute_multiprocessing_identity(line_args, processes):
-    # Multiprocessing identity polygon
-    try:
-        total_steps = len(line_args)
-        features = []
-        with Pool(processes) as pool:
-            step = 0
-            # execute tasks in order, process results out of order
-            for result in pool.imap_unordered(identity_polygon, line_args):
-                if BT_DEBUGGING:
-                    print('Got result: {}'.format(result), flush=True)
-                features.append(result)
-                step += 1
-                print('%{}'.format(step / total_steps * 100))
-
-    except OperationCancelledException:
-        print("Operation cancelled")
-        exit()
-
-    print("Identifies are done.")
-    return features
-
-
-def execute_multiprocessing_csf(line_args, processes):
-    try:
-        total_steps = len(line_args)
-        features = []
-        with Pool(processes) as pool:
-            step = 0
-            # execute tasks in order, process results out of order
-            for result in pool.imap_unordered(regen_csf, line_args):
-                if BT_DEBUGGING:
-                    print('Got result: {}'.format(result), flush=True)
-                    print('Line processed: {}'.format(step))
-
-                features.append(result)
-                step += 1
-                print('%{}'.format(step / total_steps * 100))
-
-    except OperationCancelledException:
-        print("Operation cancelled")
-        exit()
-
-    return features
-
-
-def fl_restration_csf(callback, in_line, in_footprint, in_trees, in_change, proc_segments, out_line, processes,
-                      verbose):
-    # assign Tool arguments
-    BT_DEBUGGING = False
-    in_cl = in_line
-    in_fp = in_footprint
-
-    print("Checking input parameters ...")
-
-    try:
-        print("loading shapefile(s) ...")
-        in_line_shp = pyogrio.read_dataframe(in_line)
-        in_tree_shp = pyogrio.read_dataframe(in_trees)
-        in_fp_shp = pyogrio.read_dataframe(in_footprint)
-    except SystemError:
-        print("Invalid input feature, please check!")
-        exit()
-
-    # Check datum, at this stage only check input data against NAD 83 datum
-    print("Checking datum....")
-    sameDatum = False
-    for shp in [in_line_shp, in_tree_shp, in_fp_shp]:
-        if shp.crs.datum.name in NADDatum:
-            sameDatum = True
-        else:
-            sameDatum = False
-    try:
-        # Check projection zone among input data with NAD 83 datum
-        if sameDatum:
-            if in_line_shp.crs.utm_zone != in_tree_shp.crs.utm_zone != in_fp_shp.crs.utm_zone:
-                print("Input shapefiles are on different project Zone, please check.")
-                exit()
-        else:
-            print("Input shapefiles are not on supported Datum, please check.")
-            exit()
-    except Exception as error_in_shapefiles:
-        print("Input shapefiles are invalid: {} , please check.".format(error_in_shapefiles))
-        exit()
-
-    if not os.path.exists(os.path.dirname(out_line)):
-        os.makedirs(os.path.dirname(out_line))
-    else:
-        pass
-    print("Checking input parameters ... Done")
-
-    in_fields = list(in_line_shp.columns)
-
-    # check coordinate systems between line and raster features
-    try:
-        # Check projection zone among input raster with input vector data
-        with rasterio.open(in_change) as in_raster:
-            if not in_raster.crs.to_epsg() in [in_fp_shp.crs.to_epsg(), in_line_shp.crs.to_epsg(),
-                                               in_tree_shp.crs.to_epsg(), 2956]:
-                print("Line and raster spatial references are different , please check.")
-                exit()
-            else:
-                change_analysis = True
-    except Exception as error_in_raster:
-
-        print("Invalid input raster: {}, please check!".format(error_in_raster))
-        change_analysis = False
-        exit()
-
-    HasOLnFID = False
-
-    # determine to do area or/and height analysis
-    if len(in_fp_shp) == 0:
-        print('No footprints provided, buffer of the input lines will be used instead')
-        area_analysis = False
-    else:
-        area_analysis = True
-
-    print("Preparing line segments...")
-
-    # Segment lines
-    # Return split lines with two extra columns:['OLnFID','OLnSEG']
-    # or return whole input line
-    print("Input_Lines: {}".format(in_cl))
-    if not 'OLnFID' in in_line_shp.columns.array:
-        print(
-            "Cannot find {} column in input line data.\n '{}' column will be create".format('OLnFID', 'OLnFID'))
-        in_line_shp['OLnFID'] = in_line_shp.index
-    if proc_segments:
-        attr_seg_lines = line_split2(in_line_shp, 10)
-    else:
-        # copy original line input to another Geodataframe
-        attr_seg_lines = geopandas.GeoDataFrame.copy(in_line_shp)
-        if not "OLnSEG" in attr_seg_lines.columns.array:
-            if proc_segments:
-                attr_seg_lines["OLnSEG"] = int(attr_seg_lines["OLnSEG"])
-            else:
-                attr_seg_lines["OLnSEG"] = 0
-    print('%{}'.format(10))
-
-    print("Line segments preparation done.")
-    print("{} footprints to be identified by {} segments ...".format(len(in_fp_shp.index), len(attr_seg_lines)))
-
-    # Prepare line parameters for multiprocessing
-    line_args = []
-
-    # prepare line args: list of line, line buffer and footprint polygon
-    # footprint spatial searching
-    footprint_sindex = in_fp_shp.sindex
-
-    for i in attr_seg_lines.index:
-        line = attr_seg_lines.iloc[[i]]
-        line_buffer = line.copy()
-        if proc_segments:
-            line_buffer['geometry'] = line.simplify(tolerance=1, preserve_topology=True).buffer(10,
-                                                                                                cap_style=shapely.BufferCapStyle.flat)
-        else:
-            line_buffer['geometry'] = line.buffer(10, cap_style=shapely.BufferCapStyle.flat)
-        fp_touched = in_fp_shp.iloc[
-            footprint_sindex.query(line_buffer.iloc[0].geometry, predicate="overlaps", sort=True)]
-        if not "OLnFID" in fp_touched.columns.array:
-            fp_touched["OLnFID"] = int(line["OLnFID"])
-        if not "OLnSEG" in fp_touched.columns.array:
-            if proc_segments:
-                fp_touched["OLnSEG"] = int(line["OLnSEG"])
-            else:
-                fp_touched["OLnSEG"] = 0
-        fp_intersected = fp_touched.dissolve()
-        fp_intersected.geometry = fp_intersected.geometry.clip(line_buffer)
-        fp_intersected['geometry'] = fp_intersected.geometry.map(lambda x: unary_union(x))
-        list_item = [line, fp_touched, fp_intersected]
-
-        line_args.append(list_item)
-    print("Identifying footprint.... ")
-    # multiprocessing of identity polygons
-    features = []
-    if not BT_DEBUGGING:
-        features = execute_multiprocessing_identity(line_args, processes)
-    else:
-        # Debug use
-        for index in range(0, len(line_args)):
-            result = (identity_polygon(line_args[index]))
-            if not len(result) == 0:
-                features.append(result)
-
-    print("Prepare for classify ...")
-
-    # prepare list of result_identity, Att_seg_lines, areaAnalysis, heightAnalysis, args.input
-    AOI_trees = in_tree_shp
-    line_args = []
-    for index in range(0, len(features)):
-        list_item = [features[index][0], features[index][1], area_analysis, change_analysis, in_change, AOI_trees]
-        line_args.append(list_item)
-
-        # Linear attributes
-    print("Classify lines ...")
-    print('%{}'.format(60))
-
-    # Multiprocessing regeneration classifying
-    features = []
-    BT_DEBUGGING = True
-    if not BT_DEBUGGING:
-        features = execute_multiprocessing_csf(line_args, processes)
-    else:
-        # Debug use
-        for index in range(0, len(line_args) - 1):
-            result = (regen_csf(line_args[index]))
-            if not len(result) == 0:
-                features.append(result)
-                print(result)
-
-    # Combine identity polygons into once geodataframe
-    if len(features) == 0:
-        print('No lines found.')
-        exit()
-    print('Appending output ...')
-    result_attr = geopandas.GeoDataFrame(pandas.concat(features, ignore_index=True))
-    result_attr.reset_index()
-
-    print('%{}'.format(90))
-    print('Saving output ...')
-
-    # Save attributed lines, was output_att_line
-    geopandas.GeoDataFrame.to_file(result_attr, out_line)
-
-    print('%{}'.format(100))
-
-
-if __name__ == '__main__':
-    start_time = time.time()
-    print('Line regeneration classify started at {}'.format(time.strftime("%b %Y %H:%M:%S", time.localtime())))
-
-    # Get tool arguments
-
-    in_args, in_verbose = check_arguments()
-    fl_restration_csf(print, **in_args.input, processes=int(in_args.processes), verbose=in_verbose)
-
-    print('Current time: {}'.format(time.strftime("%d %b %Y %H:%M:%S", time.localtime())))
-    print('Line regeneration classify done in {} seconds'.format(round(time.time() - start_time, 5)))