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

beratools/tools/{line_footprint_fixed.py → ground_footprint.py}

@@ -10,28 +10,38 @@ Description:
     This script is part of the BERA Tools.
     Webpage: https://github.com/appliedgrg/beratools
 
-    This file hosts the line_footprint_fixed tool.
+    This file hosts the ground_footprint tool.
 """
+
+import logging
 import math
-import time
 from itertools import chain
 from pathlib import Path
 
 import geopandas as gpd
 import numpy as np
 import pandas as pd
+import pyogrio.errors
 import shapely.geometry as sh_geom
 import shapely.ops as sh_ops
 
 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.algo_line_grouping import LineGrouping
+from beratools.core.algo_merge_lines import custom_line_merge
 from beratools.core.algo_split_with_lines import LineSplitter
+from beratools.core.logger import Logger
 from beratools.core.tool_base import execute_multiprocessing
+from beratools.utility.tool_args import CallMode
+
+log = Logger("ground_footprint", file_level=logging.INFO)
+logger = log.get_logger()
+print = log.print
 
 FP_FIXED_WIDTH_DEFAULT = 5.0
 
+
 def prepare_line_args(line_gdf, poly_gdf, n_samples, offset, width_percentile):
     """
     Generate arguments for each line in the GeoDataFrame.
@@ -65,14 +75,10 @@ def prepare_line_args(line_gdf, poly_gdf, n_samples, offset, width_percentile):
 
         inter_poly = poly_gdf.loc[spatial_index.query(line)]
         if bt_const.BT_GROUP in inter_poly.columns:
-            inter_poly = inter_poly[
-                inter_poly[bt_const.BT_GROUP] == row[bt_const.BT_GROUP].values[0]
-            ]
+            inter_poly = inter_poly[inter_poly[bt_const.BT_GROUP] == row[bt_const.BT_GROUP].values[0]]
 
         try:
-            line_args.append(
-                [row, inter_poly, n_samples, offset, width_percentile]
-            )
+            line_args.append([row, inter_poly, n_samples, offset, width_percentile])
         except Exception as e:
             print(e)
 
@@ -152,7 +158,7 @@ def process_single_line(line_arg):
 def generate_fixed_width_footprint(line_gdf, max_width=False):
     """
     Create a buffer around each line.
-     
+
     In the GeoDataFrame using its 'max_width' attribute and
     saves the resulting polygons in a new shapefile.
 
@@ -177,67 +183,50 @@ def generate_fixed_width_footprint(line_gdf, max_width=False):
     if not max_width:
         print("Using quantile 75% width")
         buffer_gdf["geometry"] = line_gdf.apply(
-            lambda row: row.geometry.buffer(row.avg_width / 2)
-            if row.geometry is not None
-            else None,
+            lambda row: row.geometry.buffer(row.avg_width / 2) if row.geometry is not None else None,
             axis=1,
         )
     else:
         print("Using quantile 90% + 20% width")
         buffer_gdf["geometry"] = line_gdf.apply(
-            lambda row: row.geometry.buffer(row.max_width * 1.2 / 2)
-            if row.geometry is not None
-            else None,
+            lambda row: row.geometry.buffer(row.max_width * 1.2 / 2) if row.geometry is not None else None,
             axis=1,
         )
 
     return buffer_gdf
 
 
-def smooth_linestring(line, tolerance=0.5):
-    """
-    Smooths a LineString geometry using the Ramer-Douglas-Peucker algorithm.
-
-    Args:
-    line: The LineString geometry to smooth.
-    tolerance: The maximum distance from a point to a line for the point 
-        to be considered part of the line.
-
-    Returns:
-    The smoothed LineString geometry.
-
-    """
-    simplified_line = line.simplify(tolerance)
-    # simplified_line = line
-    return simplified_line
-
-
 def calculate_average_width(line, in_poly, offset, n_samples):
     """Calculate the average width of a polygon perpendicular to the given line."""
     # Smooth the line
     try:
-        line = smooth_linestring(line, tolerance=0.1)
+        line = line.simplify(0.1)
 
         valid_widths = 0
         sample_points = generate_sample_points(line, n_samples=n_samples)
-        sample_points_pairs = list(
-            zip(sample_points[:-2], sample_points[1:-1], sample_points[2:])
-        )
+        sample_points_pairs = list(zip(sample_points[:-2], sample_points[1:-1], sample_points[2:]))
         widths = np.zeros(len(sample_points_pairs))
         perp_lines = []
         perp_lines_original = []
     except Exception as e:
         print(e)
-        
+
     try:
         for i, points in enumerate(sample_points_pairs):
-            perp_line = algo_common.generate_perpendicular_line_precise(
-                points, offset=offset
-            )
-            perp_lines_original.append(perp_line)
-
-            polygon_intersect = in_poly.iloc[in_poly.sindex.query(perp_line)]
-            intersections = polygon_intersect.intersection(perp_line)
+            try:
+                perp_line = algo_common.generate_perpendicular_line_precise(points, offset=offset)
+                perp_lines_original.append(perp_line)
+            except Exception as e:
+                print(f"Failed to generate perpendicular at index {i}: {e}")
+                perp_lines_original.append(None)
+                continue
+
+            try:
+                polygon_intersect = in_poly.iloc[in_poly.sindex.query(perp_line)]
+                intersections = polygon_intersect.intersection(perp_line)
+            except Exception as e:
+                print(f"Failed intersection at index {i}: {e}")
+                intersections = []
 
             line_list = []
             for inter in intersections:
@@ -262,6 +251,10 @@ def calculate_average_width(line, in_poly, offset, n_samples):
                 widths[i] = max(widths[i], item.length)
                 valid_widths += 1
 
+            # Todo: check missing perpendicular lines
+            # if len(perp_lines_original) < len(sample_points_pairs):
+            #     print(f"Missing perpendicular at index {i}")
+
     except Exception as e:
         print(f"loop: {e}")
 
@@ -273,48 +266,57 @@ def calculate_average_width(line, in_poly, offset, n_samples):
     )
 
 
-def line_footprint_fixed(
+def ground_footprint(
     in_line,
     in_footprint,
     n_samples,
     offset,
     max_width,
     out_footprint,
-    processes,
-    verbose,
-    in_layer=None,
     in_layer_lc_path="least_cost_path",
-    in_layer_fp=None,
-    out_layer=None,
     merge_group=True,
     width_percentile=75,
-    parallel_mode=bt_const.ParallelMode.MULTIPROCESSING
+    trim_output=True,
+    processes=0, call_mode=CallMode.CLI, log_level="INFO"
 ):
+    in_file, in_layer = sp_common.decode_file_layer(in_line)
+    in_fp_file, in_layer_fp = sp_common.decode_file_layer(in_footprint)
+    out_file, out_layer = sp_common.decode_file_layer(out_footprint)
+
     n_samples = int(n_samples)
     offset = float(offset)
-    width_percentile=int(width_percentile)
+    width_percentile = int(width_percentile)
 
     # TODO: refactor this code for better line quality check
-    line_gdf = gpd.read_file(in_line, layer=in_layer)
-    lc_path_gdf = gpd.read_file(in_line, layer=in_layer_lc_path)
+    line_gdf = gpd.read_file(in_file, layer=in_layer)
+    if bt_const.BT_GROUP not in line_gdf.columns:
+        line_gdf[bt_const.BT_GROUP] = range(1, len(line_gdf) + 1)
+
+    use_least_cost_path = True
+    try:
+        lc_path_gdf = gpd.read_file(in_file, layer=in_layer_lc_path)
+    except (ValueError, OSError, pyogrio.errors.DataLayerError):
+        print(f"Layer '{in_layer_lc_path}' not found in {in_file}, skipping least cost path logic.")
+        use_least_cost_path = False
+
     if not merge_group:
-        line_gdf.geometry = line_gdf.line_merge()
-        lc_path_gdf.geometry = lc_path_gdf.line_merge()
-        
+        line_gdf["geometry"] = line_gdf.geometry.apply(custom_line_merge)
+        if use_least_cost_path:
+            lc_path_gdf["geometry"] = lc_path_gdf.geometry.apply(custom_line_merge)
+
     line_gdf = algo_common.clean_line_geometries(line_gdf)
 
     # read footprints and remove holes
-    poly_gdf = gpd.read_file(in_footprint, layer=in_layer_fp)
+    poly_gdf = gpd.read_file(in_fp_file, layer=in_layer_fp)
     poly_gdf["geometry"] = poly_gdf["geometry"].apply(algo_common.remove_holes)
-    
-    # split lines
+
+    # merge group and/or split lines at intersections
     merged_line_gdf = line_gdf.copy(deep=True)
     if merge_group:
         lg = LineGrouping(line_gdf, merge_group)
         lg.run_grouping()
         merged_line_gdf = lg.run_line_merge()
     else:
-        # merge group first, then not merge after splitting
         try:
             lg = LineGrouping(line_gdf, not merge_group)
             lg.run_grouping()
@@ -329,78 +331,99 @@ def line_footprint_fixed(
             )
 
             # least cost path merge and split
-            lg_leastcost = LineGrouping(lc_path_gdf, not merge_group)
-            lg_leastcost.run_grouping()
-            merged_lc_path_gdf = lg_leastcost.run_line_merge()
-            splitter_leastcost = LineSplitter(merged_lc_path_gdf)
-            splitter_leastcost.process(splitter.intersection_gdf)
-
-            splitter_leastcost.save_to_geopackage(
-                out_footprint,
-                line_layer="split_leastcost",
-            )
-
-            lg = LineGrouping(splitter.split_lines_gdf, merge_group)
-            lg.run_grouping()
-            merged_line_gdf = lg.run_line_merge()
+            if use_least_cost_path:
+                lg_leastcost = LineGrouping(lc_path_gdf, not merge_group)
+                lg_leastcost.run_grouping()
+                merged_lc_path_gdf = lg_leastcost.run_line_merge()
+                splitter_leastcost = LineSplitter(merged_lc_path_gdf)
+                splitter_leastcost.process(splitter.intersection_gdf)
+
+                splitter_leastcost.save_to_geopackage(
+                    out_footprint,
+                    line_layer="split_leastcost",
+                )
+
+                lg = LineGrouping(splitter.split_lines_gdf, merge_group)
+                lg.run_grouping()
+                merged_line_gdf = lg.run_line_merge()
         except ValueError as e:
-            print(f"Exception: line_footprint_fixed: {e}")
+            print(f"Exception: ground_footprint: {e}")
 
     # save original merged lines
-    merged_line_gdf.to_file(out_footprint, layer="merged_lines_original")
+    merged_line_gdf.to_file(out_file, layer="merged_lines_original")
 
     # prepare line arguments
-    line_args = prepare_line_args(
-        merged_line_gdf, poly_gdf, n_samples, offset, width_percentile
-    )
+    line_args = prepare_line_args(merged_line_gdf, poly_gdf, n_samples, offset, width_percentile)
 
     out_lines = execute_multiprocessing(
-        process_single_line, line_args, "Fixed footprint", processes, mode=parallel_mode
+        process_single_line, line_args, "Fixed footprint", processes, call_mode
     )
     line_attr = pd.concat(out_lines)
 
-    ############################################
+    # Ensure BT_GROUP is present in line_attr
+    if bt_const.BT_GROUP not in line_attr.columns:
+        raise ValueError("BT_GROUP column is required in line_attr but is missing.")
+
     # update avg_width and max_width by max value of group
-    group_max = line_attr.groupby(bt_const.BT_GROUP).agg({
-        'avg_width': 'max',
-        'max_width': 'max'
-    }).reset_index()
+    if not merge_group:
+        group_max = (
+            line_attr.groupby(bt_const.BT_GROUP).agg({"avg_width": "max", "max_width": "max"}).reset_index()
+        )
 
-    # Step 2: Merge the result back to the original dataframe based on 'group'
-    line_attr = line_attr.merge(group_max, on=bt_const.BT_GROUP, suffixes=('', '_max'))
+        # Merge the result back to the original dataframe based on 'group'
+        line_attr = line_attr.merge(group_max, on=bt_const.BT_GROUP, suffixes=("", "_max"))
 
-    # Step 3: Overwrite the original columns directly with the max values
-    line_attr['avg_width'] = line_attr['avg_width_max']
-    line_attr['max_width'] = line_attr['max_width_max']
+        # Overwrite the original columns directly with the max values
+        line_attr["avg_width"] = line_attr["avg_width_max"]
+        line_attr["max_width"] = line_attr["max_width_max"]
 
-    # Drop the temporary max columns
-    line_attr.drop(columns=['avg_width_max', 'max_width_max'], inplace=True)
-    # Done: updating avg_width and max_width
-    ############################################
+        # Drop the temporary max columns
+        line_attr.drop(columns=["avg_width_max", "max_width_max"], inplace=True)
 
-    # create fixed width footprint
+    # create fixed width footprint (always assign buffer_gdf)
+    print("Step: Generating fixed width footprints")
     buffer_gdf = generate_fixed_width_footprint(line_attr, max_width=max_width)
 
-    # Save the lines with attributes and polygons to a new file
+    # reserve all layers for output
     perp_lines_gdf = buffer_gdf.copy(deep=True)
     perp_lines_original_gdf = buffer_gdf.copy(deep=True)
 
-    # save fixed width footprint
+    # Save untrimmed fixed width footprint
     buffer_gdf = buffer_gdf.drop(columns=["perp_lines"])
     buffer_gdf = buffer_gdf.drop(columns=["perp_lines_original"])
     buffer_gdf = buffer_gdf.set_crs(perp_lines_gdf.crs, allow_override=True)
     buffer_gdf.reset_index(inplace=True, drop=True)
 
+    untrimmed_footprint = "untrimmed_footprint"
+    buffer_gdf.to_file(out_file, layer=untrimmed_footprint)
+    print(f"Untrimmed fixed width footprint saved as '{untrimmed_footprint}'")
+
     # trim lines and footprints
-    lg.run_cleanup(buffer_gdf)
-    lg.save_file(out_footprint)
+    if trim_output:
+        lg.run_cleanup(buffer_gdf)
+
+        # Ensure only polygons are saved in clean_footprint
+        def ensure_polygons(gdf, buffer_width=0.01):
+            gdf["geometry"] = gdf["geometry"].apply(
+                lambda geom: geom.buffer(buffer_width)
+                if geom.geom_type in ["LineString", "MultiLineString"]
+                else geom
+            )
+            gdf = gdf[gdf.geometry.type.isin(["Polygon", "MultiPolygon"])]
+            return gdf
+
+        # Patch: after trimming, ensure polygons in clean_footprint layer
+        if hasattr(lg, "merged_lines_trimmed") and lg.merged_lines_trimmed is not None:
+            lg.merged_lines_trimmed = ensure_polygons(lg.merged_lines_trimmed)
+            print("Step: Saving trimmed outputs")
+            lg.save_file(out_file, out_layer)
+        else:
+            print("Skipping line and footprint trimming per user option.")
 
     # perpendicular lines
     layer = "perp_lines"
-    out_footprint = Path(out_footprint)
-    out_aux_gpkg = out_footprint.with_stem(out_footprint.stem + "_aux").with_suffix(
-        ".gpkg"
-    )
+    out_footprint_path = Path(out_file)
+    out_aux_gpkg = out_footprint_path.with_stem(out_footprint_path.stem + "_aux").with_suffix(".gpkg")
     perp_lines_gdf = perp_lines_gdf.set_geometry("perp_lines")
     perp_lines_gdf = perp_lines_gdf.drop(columns=["perp_lines_original"])
     perp_lines_gdf = perp_lines_gdf.drop(columns=["geometry"])
@@ -408,29 +431,29 @@ def line_footprint_fixed(
     perp_lines_gdf.to_file(out_aux_gpkg.as_posix(), layer=layer)
 
     layer = "perp_lines_original"
-    perp_lines_original_gdf = perp_lines_original_gdf.set_geometry(
-        "perp_lines_original"
-    )
+    perp_lines_original_gdf = perp_lines_original_gdf.set_geometry("perp_lines_original")
     perp_lines_original_gdf = perp_lines_original_gdf.drop(columns=["perp_lines"])
     perp_lines_original_gdf = perp_lines_original_gdf.drop(columns=["geometry"])
-    perp_lines_original_gdf = perp_lines_original_gdf.set_crs(
-        buffer_gdf.crs, allow_override=True
-    )
+    perp_lines_original_gdf = perp_lines_original_gdf.set_crs(buffer_gdf.crs, allow_override=True)
     perp_lines_original_gdf.to_file(out_aux_gpkg.as_posix(), layer=layer)
 
     layer = "centerline_simplified"
+    # Drop perp_lines_original column if present to avoid export warnings
+    if "perp_lines_original" in line_attr.columns:
+        line_attr = line_attr.drop(columns=["perp_lines_original"])
     line_attr = line_attr.drop(columns="perp_lines")
     line_attr.to_file(out_aux_gpkg.as_posix(), layer=layer)
 
     # save footprints without holes
     poly_gdf.to_file(out_aux_gpkg.as_posix(), layer="footprint_no_holes")
+    print("Step: Finished fixed width footprint tool")
 
-    print("Fixed width footprint tool finished.")
 
 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()
-    line_footprint_fixed(
-        **in_args.input, processes=int(in_args.processes), verbose=in_verbose
-    )
+    kwargs = compose_tool_kwargs("ground_footprint")
+    ground_footprint(**kwargs)
     print("Elapsed time: {}".format(time.time() - start_time))

beratools/tools/line_footprint_relative.py

@@ -29,45 +29,74 @@
 # cost corridor method and individual line thresholds.
 #
 # ---------------------------------------------------------------------------
-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.line_footprint_functions import *
+from beratools.core.canopy_threshold_relative import *
+
+
+def line_footprint_relative(
+    in_line,
+    in_chm,
+    max_ln_width,
+    exp_shk_cell,
+    out_footprint,
+    out_centerline,
+    off_ln_dist,
+    canopy_percentile,
+    canopy_thresh_percentage,
+    tree_radius,
+    max_line_dist,
+    canopy_avoidance,
+    exponent,
+    processes,
+    call_mode,
+    log_level,
+):
+
+    verbose = True if call_mode == CallMode.GUI.value else False
 
-from beratools.tools.line_footprint_functions import *
-from beratools.tools.canopy_threshold_relative import *
+    dy_cl_line = main_canopy_threshold_relative(
+        in_line=in_line,
+        in_chm=in_chm,
+        canopy_percentile=int(float(canopy_percentile)),
+        canopy_thresh_percentage=int(float(canopy_thresh_percentage)),
+        full_step=bool(True),
+        processes=int(float(processes)),
+        verbose=bool(verbose),
+    )
 
-if __name__ == '__main__':
+    if not dy_cl_line:
+        print("[error]: main_canopy_threshold_relative did not return a valid path. Aborting footprint step.")
+        return
+
+    main_line_footprint_relative(
+        in_line=dy_cl_line,
+        in_chm=in_chm,
+        max_ln_width=float(max_ln_width),
+        out_footprint=out_footprint or "",
+        out_centerline=out_centerline or "",
+        exp_shk_cell=int(float(exp_shk_cell)),
+        tree_radius=float(tree_radius),
+        max_line_dist=float(max_line_dist),
+        canopy_avoidance=float(canopy_avoidance),
+        exponent=float(exponent),
+        full_step=bool(True),
+        canopy_thresh_percentage=int(float(canopy_thresh_percentage)),
+        processes=int(float(processes)),
+        verbose=bool(verbose),
+    )
+
+if __name__ == "__main__":
+    from beratools.utility.tool_args import CallMode, compose_tool_kwargs
     start_time = time.time()
-    print('Dynamic CC and Footprint processing started')
-    print('Current time: {}'.format(time.strftime("%d %b %Y %H:%M:%S", time.localtime())))
+    print("[info]: Dynamic CC and Footprint processing started")
+    print("[info]: Current time: {}".format(time.strftime("%d %b %Y %H:%M:%S", time.localtime())))
 
-    parser = argparse.ArgumentParser()
-    parser.add_argument('-i', '--input', type=json.loads)
-    parser.add_argument('-p', '--processes')
-    parser.add_argument('-v', '--verbose')
-    args = parser.parse_args()
-    args.input['full_step'] = True
-    del args.input['out_footprint']
-    del args.input['out_centerline']
-    del args.input['exp_shk_cell']
-    del args.input['max_ln_width']
+    args=compose_tool_kwargs("line_footprint_relative")
 
-    verbose = True if args.verbose == 'True' else False
-    dy_cl_line = main_canopy_threshold_relative(print, **args.input, processes=int(args.processes), verbose=verbose)
-    args = parser.parse_args()
-    args.input['full_step'] = True
-    args.input["in_line"] = dy_cl_line
-    del args.input['off_ln_dist']
-    del args.input['canopy_percentile']
-    verbose = True if args.verbose == 'True' else False
-    main_line_footprint_relative(print, **args.input, processes=int(args.processes), verbose=verbose)
+    line_footprint_relative(**args)
 
-    print('%{}'.format(100))
-    print('Dynamic CC and Footprint processes finished')
-    print('Current time: {}'.format(time.strftime("%d %b %Y %H:%M:%S", time.localtime())))
-    print('Total processing time (seconds): {}'.format(round(time.time() - start_time, 3)))
+    print("{}%".format(100))
+    print("[info]: Dynamic CC and Footprint processes finished")
+    print("[info]: Current time: {}".format(time.strftime("%d %b %Y %H:%M:%S", time.localtime())))
+    print("[info]: Total processing time (seconds): {}".format(round(time.time() - start_time, 3)))

beratools/tools/tool_template.py

@@ -7,63 +7,71 @@ See <https://gnu.org/licenses/gpl-3.0> for full license details.
 Author: AUTHOR NAME
 
 Description:
-    This script is part of the BERA Tools.
+    This script is tool template for the BERA Tools. The tool showcases
+    how to create a new tool for the BERA Tools framework. It is a
+    starting point for developers to implement their own tools.
+    It uses the GeoPandas to read and write geospatial data,
+    and the multiprocessing library to process the geospatial data.
+
+    To integrate with GUI, work in the gui/assets/beratools.json is needed.
+    Please see developer's guide for more details.
+
     Webpage: https://github.com/appliedgrg/beratools
 
     The purpose of this script is to provide template for tool.
 """
-import time
-from multiprocessing.pool import Pool
-from random import random
 
-import numpy as np
+import geopandas as gpd
+import pandas as pd
 
-import beratools.tools.common as bt_common
+import beratools.utility.spatial_common as sp_common
 from beratools.core.tool_base import execute_multiprocessing
+from beratools.utility.tool_args import CallMode
 
-# Example task_data as a list of numpy ndarrays
-task_data_list = [
-    np.array([1, 2, 3]),
-    np.array([4, 5, 6]),
-    np.array([7, 8, 9])
-]
 
-def tool_name(
-    in_line, in_cost_raster, line_radius, out_line, processes, verbose
-):
+def tool_template(in_feature, buffer_dist, out_feature, 
+                  processes=0, call_mode=CallMode.CLI, log_level="INFO"):
     """
     Define tool entry point.
-    
-    These arguments are defined in beratools.json file. 
-    execute_multiprocessing is common function to run tasks in parallel.
+
+    Args:
+        in_feature: input feature (encoded as "file:layer")
+        buffer_dist: buffer for input lines
+        out_feature: output feature (encoded as "file:layer")
+        processes: number of processes to use
+        verbose: verbosity level
+
+    These arguments are defined in beratools.json file. Whenever possible,
+    use execute_multiprocessing to run tasks in parallel to speedup.
+
     """
-    result = execute_multiprocessing(
-        worker,
-        task_data_list,
-        "tool_template",
-        processes,
-        verbose=verbose
-    )
-    print(len(result))
+    in_file, in_layer = sp_common.decode_file_layer(in_feature)
+    out_file, out_layer = sp_common.decode_file_layer(out_feature)
 
+    buffer_dist = float(buffer_dist)
+    gdf = gpd.read_file(in_file, layer=in_layer)
+    gdf_list = [(gdf.iloc[[i]], buffer_dist) for i in range(len(gdf))]
 
-# task executed in a worker process
-def worker(task_data):
-    # report a message
-    value = np.mean(task_data)
-    print(f'Task with {value} executed', flush=True)
+    # Set verbose based on log_level
+    results = execute_multiprocessing(buffer_worker, gdf_list, "tool_template", processes, call_mode)
+
+    buffered_gdf = gpd.GeoDataFrame(pd.concat(results, ignore_index=True), crs=gdf.crs)
+    buffered_gdf.to_file(out_file, layer=out_layer)
 
-    # block for a moment
-    time.sleep(value * 10)
 
-    # return the generated value
-    return value
+# task executed in a worker process
+def buffer_worker(in_args):
+    buffered = in_args[0].copy()
+    buffer_dist = in_args[1]
+    buffered["geometry"] = buffered.geometry.buffer(buffer_dist)
+    return buffered
+
 
+if __name__ == "__main__":
+    import time
 
-if __name__ == '__main__':
-    in_args, in_verbose = bt_common.check_arguments()
+    from beratools.utility.tool_args import compose_tool_kwargs
     start_time = time.time()
-    tool_name(
-        print, **in_args.input, processes=int(in_args.processes), verbose=in_verbose
-    )
+    kwargs = compose_tool_kwargs("tool_template")
+    tool_template(**kwargs)
     print("Elapsed time: {}".format(time.time() - start_time))