BERATools 0.2.0__py3-none-any.whl

beratools/tools/rpy_percent_above_dbh.py

@@ -0,0 +1,80 @@
+import os
+import time
+
+from beratools.tools.common import *
+from beratools.tools.r_interface import *
+
+def percentage_aboveDBH(callback, in_las_folder, is_normalized, out_folder, DBH, cell_size, processes, verbose):
+    rprocesses = r_processes(processes)
+
+    # assign R script file to local variable
+    Beratools_R_script = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'Beratools_r_script.r')
+    # Defining the R script and loading the instance in Python
+    r['source'](Beratools_R_script)
+    # Loading the function defined in R script.
+    r_percentage_aboveDBH = robjects.globalenv['percentage_aboveDBH']
+    # Invoking the R function
+    r_percentage_aboveDBH(in_las_folder, is_normalized, out_folder, DBH, cell_size, rprocesses)
+
+
+if __name__ == '__main__':
+    start_time = time.time()
+    print('Finding percentage returns above DBH height process\n @ {}'
+          .format(time.strftime("%d %b %Y %H:%M:%S", time.localtime())))
+
+    packages = ['lidR', 'future', 'terra']
+    check_r_packages_installation(packages)
+
+    print("Checking input parameters ...")
+    in_args, in_verbose = check_arguments()
+    in_las_folder = in_args.input["in_las_folder"]
+
+    try:
+        DBH = float(in_args.input["DBH"])
+        if DBH < 0:
+            raise ValueError
+        else:
+            in_args.input["DBH"] = DBH
+    except ValueError:
+        print("Invalid input of DBH, default value is used")
+        in_args.input["DBH"] = 1.3
+
+    try:
+        is_normalized = bool(in_args.input["is_normalized"])
+
+    except ValueError:
+        print("Invalid input of checking normalized data box, normalize data will be carried")
+        in_args.input["is_normalized"] = False
+
+    try:
+        cell_size = float(in_args.input["cell_size"])
+        in_args.input["cell_size"] = cell_size
+    except ValueError:
+        print("Invalid input of cell size, default value is used")
+        in_args.input["cell_size"] = 5.0
+
+    out_folder = in_args.input["out_folder"]
+
+    if not os.path.exists(in_las_folder):
+        print("Error! Cannot locate Las folder, please check.")
+        exit()
+    else:
+        found = False
+        for files in os.listdir(in_las_folder):
+            if files.endswith(".las") or files.endswith(".laz"):
+                found = True
+                break
+        if not found:
+            print("Error! Cannot locate input LAS file(s), please check!")
+            exit()
+
+    if not os.path.exists(out_folder):
+        print("Warning! Cannot locate output folder, It will be created.")
+        os.makedirs(out_folder)
+
+    print("Checking input parameters ... Done")
+
+    percentage_aboveDBH(print, **in_args.input, processes=int(in_args.processes), verbose=in_verbose)
+
+    print('Finding percentage returns above DBH height process is done in {} seconds)'
+          .format(round(time.time() - start_time, 5)))

beratools/tools/rpy_points2trees.py

@@ -0,0 +1,88 @@
+import os
+import time
+
+from beratools.tools.common import *
+from beratools.tools.r_interface import *
+
+def points2trees(callback, in_las_folder, is_normalized, hmin, cell_size, do_nCHM, out_folder, processes, verbose):
+    rprocesses = r_processes(processes)
+
+    # assign R script file to local variable
+    Beratools_R_script = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'Beratools_r_script.r')
+    # Defining the R script and loading the instance in Python
+    r['source'](Beratools_R_script)
+    # Loading the function defined in R script.
+    r_points2trees = robjects.globalenv['points2trees']
+    r_pd2cellsize = robjects.globalenv['pd2cellsize']
+    # Invoking the R function
+    if do_nCHM:
+        CHMcell_size = r_pd2cellsize(in_las_folder, rprocesses)
+        print("CHM raster output cell size is: {}m".format(CHMcell_size))
+        r_points2trees(in_las_folder, is_normalized, hmin, out_folder, rprocesses, CHMcell_size, cell_size)
+    else:
+        CHMcell_size = -999
+        r_points2trees(in_las_folder, is_normalized, hmin, out_folder, rprocesses, CHMcell_size, cell_size)
+
+
+if __name__ == '__main__':
+    start_time = time.time()
+    print('Starting tree detection from LAS processing\n @ {}'
+          .format(time.strftime("%d %b %Y %H:%M:%S", time.localtime())))
+
+    packages = ['lidR', 'rgrass', 'rlas', 'future', 'terra', 'sp']
+    check_r_packages_installation(packages)
+
+    print("Checking input parameters ...")
+    in_args, in_verbose = check_arguments()
+    in_las_folder = in_args.input["in_las_folder"]
+
+    try:
+        hmin = float(in_args.input["hmin"])
+        if hmin >= 20:
+            print("Invalid input of minimum height (<=20) of a tree, maximum is used")
+            in_args.input["hmin"] = 20.0
+        else:
+            in_args.input["hmin"] = hmin
+    except ValueError:
+        print("Invalid input of minimum height (<=20) of a tree, default is used")
+        in_args.input["hmin"] = 3.0
+
+    try:
+        is_normalized = bool(in_args.input["is_normalized"])
+
+    except ValueError:
+        print("Invalid input of checking normalized data box, normalize data will be carried")
+        in_args.input["is_normalized"] = False
+
+    try:
+        cell_size = float(in_args.input["cell_size"])
+        in_args.input["cell_size"] = cell_size
+    except ValueError:
+        print("Invalid input of minimum height of a tree, default is used")
+        in_args.input["cell_size"] = 5.0
+
+    out_folder = in_args.input["out_folder"]
+
+    if not os.path.exists(in_las_folder):
+        print("Error! Cannot locate Las folder, please check.")
+        exit()
+    else:
+        found = False
+        for files in os.listdir(in_las_folder):
+            if files.endswith(".las") or files.endswith(".laz"):
+                found = True
+                break
+        if not found:
+            print("Error! Cannot locate input LAS file(s), please check!")
+            exit()
+
+    if not os.path.exists(out_folder):
+        print("Warning! Cannot locate output folder, It will be created.")
+        os.makedirs(out_folder)
+
+    print("Checking input parameters ... Done")
+
+    points2trees(print, **in_args.input, processes=int(in_args.processes), verbose=in_verbose)
+
+    print('Tree detection from Lidar data processing is done in {} seconds)'
+          .format(round(time.time() - start_time, 5)))

beratools/tools/rpy_vegcoverage.py

@@ -0,0 +1,94 @@
+import os
+import time
+
+from beratools.tools.common import *
+from beratools.tools.r_interface import *
+
+def veg_cover_percentage(callback, in_las_folder, is_normalized, out_folder, hmin, hmax, cell_size, processes, verbose):
+    rprocesses = r_processes(processes)
+
+    # assign R script file to local variable
+    Beratools_R_script = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'Beratools_r_script.r')
+    # Defining the R script and loading the instance in Python
+    r['source'](Beratools_R_script)
+    # Loading the function defined in R script.
+    r_veg_metrics = robjects.globalenv['veg_cover_percentage']
+    # Invoking the R function
+    r_veg_metrics(in_las_folder, is_normalized, out_folder, hmin, hmax, cell_size, rprocesses)
+
+
+if __name__ == '__main__':
+    start_time = time.time()
+    print('Finding Vegetation Coverage from Lidar data process\n @ {}'
+          .format(time.strftime("%d %b %Y %H:%M:%S", time.localtime())))
+
+    packages = ['lidR', 'future', 'terra']
+    check_r_packages_installation(packages)
+
+    print("Checking input parameters ...")
+    in_args, in_verbose = check_arguments()
+    in_las_folder = in_args.input["in_las_folder"]
+
+    try:
+        hmin = float(in_args.input["hmin"])
+        if hmin < 0:
+            raise ValueError
+        else:
+            in_args.input["hmin"] = hmin
+    except ValueError:
+        print("Invalid input of minimum height of a tree, default value is used")
+        in_args.input["hmin"] = 3.0
+
+    try:
+        hmax = float(in_args.input["hmax"])
+        if hmax <= hmin:
+            raise ValueError
+        else:
+            in_args.input["hmax"] = hmax
+    except ValueError:
+        print("Invalid input of maximum height of a tree, default value is used")
+        if hmin < 10:
+            in_args.input["hmax"] = 10.0
+        else:
+            in_args.input["hmin"] = 3.0
+            in_args.input["hmax"] = 10.0
+
+    try:
+        is_normalized = bool(in_args.input["is_normalized"])
+
+    except ValueError:
+        print("Invalid input of checking normalized data box, normalize data will be carried")
+        in_args.input["is_normalized"] = False
+
+    try:
+        cell_size = float(in_args.input["cell_size"])
+        in_args.input["cell_size"] = cell_size
+    except ValueError:
+        print("Invalid input of cell size, default value is used")
+        in_args.input["cell_size"] = 5.0
+
+    out_folder = in_args.input["out_folder"]
+
+    if not os.path.exists(in_las_folder):
+        print("Error! Cannot locate Las folder, please check.")
+        exit()
+    else:
+        found = False
+        for files in os.listdir(in_las_folder):
+            if files.endswith(".las") or files.endswith(".laz"):
+                found = True
+                break
+        if not found:
+            print("Error! Cannot locate input LAS file(s), please check!")
+            exit()
+
+    if not os.path.exists(out_folder):
+        print("Warning! Cannot locate output folder, It will be created.")
+        os.makedirs(out_folder)
+
+    print("Checking input parameters ... Done")
+
+    veg_cover_percentage(print, **in_args.input, processes=int(in_args.processes), verbose=in_verbose)
+
+    print('Finding Vegetation Coverage from Lidar data process is done in {} seconds)'
+          .format(round(time.time() - start_time, 5)))

beratools/tools/tiler.py

@@ -0,0 +1,206 @@
+import os
+from qtpy.QtWidgets import QApplication, QDialog
+
+from shapely.geometry import Polygon
+from beratools.tools.common import *
+from beratools.gui.map_window import MapWindow
+
+
+class Tiler:
+    def __init__(self, callback, in_line, in_chm, tile_size,
+                 tile_buffer, out_project, processes, verbose):
+
+        self.in_line = in_line
+        self.in_chm = in_chm
+        self.boundary = None
+        self.tile_size = float(tile_size)
+        self.tile_buffer = float(tile_buffer)
+        self.out_project = out_project
+        self.processes = processes
+        self.verbose = verbose
+        self.clip_data = []
+        self.proj_path = ''
+        self.in_crs = None
+        self.out_crs = None
+
+    def create_out_file_name(self):
+        # prepare path
+        # TODO: more formats later, now only tiff and shp are considered
+        path_chm = Path(self.in_chm)
+        path_line = Path(self.in_line)
+        self.proj_path = path_chm.parent
+        path_root = self.proj_path.joinpath('cells')
+
+        if not path_root.exists():
+            path_root.mkdir()
+
+        item_count = len(self.clip_data)
+        str_len = len(str(item_count))
+        for i, item in enumerate(self.clip_data):
+            cell_num = str(i).zfill(str_len)
+            self.clip_data[i]['raster'] = path_root.joinpath(path_chm.stem + '_' + cell_num + '.tif')
+            self.clip_data[i]['line'] = path_root.joinpath(path_line.stem + '_' + cell_num + '.shp')
+
+    def save_clip_files(self):
+        project_data = {'tool_api': 'tiler'}
+        tasks_list = []
+        step = 0
+
+        print('Generating {} tiles ...'.format(len(self.clip_data)))
+        for item in self.clip_data:
+            return_lines = clip_lines(item['geometry'], self.tile_buffer, self.in_line, item['line'])
+            return_raster = clip_raster(self.in_chm, item['geometry'], self.tile_buffer, item['raster'])
+
+            if not return_lines.empty and return_raster:
+                cell_data = {
+                    'in_line': item['line'].as_posix(),
+                    'in_chm': item['raster'].as_posix()
+                }
+                tasks_list.append(cell_data)
+                step += 1
+                print('%{}'.format(step / len(self.clip_data) * 100))
+
+        project_data['tasks'] = tasks_list
+        with open(self.out_project, 'w') as project_file:
+            json.dump(project_data, project_file, indent=4)
+
+    def generate_cells(self):
+        part_x = 0
+        part_y = 0
+        width = 0
+        height = 0
+
+        with(rasterio.open(self.in_chm)) as raster:
+            self.boundary = raster.bounds
+            width = raster.width
+            height = raster.height
+            self.in_crs = raster.crs
+
+        if self.boundary:
+            part_x = math.ceil(width / self.tile_size)
+            part_y = math.ceil(height / self.tile_size)
+            min_x, min_y, max_x, max_y = self.boundary
+            polygon_bound = Polygon([(min_x, min_y), (min_x, max_y), (max_x, max_y), (max_x, min_y)])
+
+            step_x = (max_x - min_x) / part_x
+            step_y = (max_y - min_y) / part_y
+            cells = []
+            for i in range(part_x):
+                for j in range(part_y):
+                    cells.append(Polygon([(min_x + i * step_x, min_y + j * step_y),
+                                          (min_x + (i + 1) * step_x, min_y + j * step_y),
+                                          (min_x + (i + 1) * step_x, min_y + (j + 1) * step_y),
+                                          (min_x + i * step_x, min_y + (j + 1) * step_y)]))
+
+            # remove polygons not in boundary
+            for cell in cells:
+                if not polygon_bound.disjoint(cell):
+                    self.clip_data.append({'geometry': cell})
+
+            return True
+
+        return False
+
+    def generate_tiles_info(self):
+        tiles_info = {'count': len(self.clip_data), 'dimension': self.tile_size}
+        return tiles_info
+
+    def cells_to_coord_list(self):
+        self.out_crs = CRS('EPSG:4326')
+        transformer = Transformer.from_crs(self.in_crs, self.out_crs)
+        coords_list = []
+        if self.clip_data:
+            for item in self.clip_data:
+                geom = item['geometry']
+                coords = mapping(geom)['coordinates']
+                if len(coords) > 0:
+                    wgs84_coords = list(transformer.itransform(coords[0]))
+                    wgs84_coords = [list(pt) for pt in wgs84_coords]
+                    coords_list.append(wgs84_coords)
+
+        # find bounds
+        x = [pt[0] for polygon in coords_list for pt in polygon]
+        y = [pt[1] for polygon in coords_list for pt in polygon]
+        x_min = min(x)
+        x_max = max(x)
+        y_min = min(y)
+        y_max = max(y)
+
+        center = [(x_min + x_max) / 2, (y_min + y_max) / 2]
+
+        return coords_list, [[x_min, y_min], [x_max, y_max]], center
+
+    def shapefile_to_coord_list(self):
+        lines = read_geoms_from_shapefile(self.in_line)
+        line_coords = []
+
+        coords_list = []
+        for line in lines:
+            coords = line['coordinates']
+            for pt in coords:
+                coords_list.append(list(pt))
+
+            line_coords.append(coords_list)
+
+        return line_coords
+
+    def execute(self):
+        if self.generate_cells():
+            coords_list, bounds, center = self.cells_to_coord_list()
+            map_window = MapWindow()
+
+            # add lines to map
+            # lines = self.shapefile_to_coord_list()
+            # map_window.add_polylines_to_map(lines, 'gray')
+
+            # generate raster footprint and add to the map
+            footprint = generate_raster_footprint(self.in_chm)
+
+            # add AOI polygon and tile polygons
+            map_window.set_tiles_info(self.generate_tiles_info())
+            map_window.add_polygons_to_map('cells', coords_list, 'magenta')
+            map_window.add_polygons_to_map('base', footprint, 'green')
+            map_window.set_view(center, 10)
+            # bounds = [[56.143426823080134, 111.1130415762259], [56.26141944093645, 110.63627702636289]]
+            flag = map_window.exec()
+
+            if flag != QDialog.Accepted:
+                return
+
+            self.create_out_file_name()
+            self.save_clip_files()
+
+            # save polygons to shapefile
+            out_cells_file = self.proj_path.joinpath('cells.shp')
+            schema = {
+                'geometry': 'Polygon'
+            }
+            driver = 'ESRI Shapefile'
+            with fiona.open(out_cells_file, 'w', driver, schema, self.in_crs) as out_line_file:
+                for item in self.clip_data:
+                    feature = {
+                        'geometry': mapping(item['geometry'])
+                    }
+                    out_line_file.write(feature)
+
+            return
+
+
+if __name__ == '__main__':
+    # supress web engine logging
+    os.environ["QTWEBENGINE_CHROMIUM_FLAGS"] = "--enable-logging --log-level=3"
+
+    app = QApplication(sys.argv)
+
+    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()
+
+    verbose = True if args.verbose == 'True' else False
+
+    tiling = Tiler(print, **args.input, processes=int(args.processes), verbose=verbose)
+    tiling.execute()
+
+    sys.exit(app.exec_())

beratools/tools/tool_template.py

@@ -0,0 +1,54 @@
+from random import random
+import time
+from multiprocessing.pool import Pool
+from numpy import mean
+
+from common import *
+
+
+class OperationCancelledException(Exception):
+    pass
+
+
+def tool_name(callback, in_line, in_cost_raster, line_radius, process_segments, out_center_line):
+    execute_multiprocessing()
+    callback('tool_template tool done.')
+
+
+# task executed in a worker process
+def worker(task_data):
+    # report a message
+    value = mean(task_data)
+    print(f'Task {len(task_data)} with {value} executed', flush=True)
+
+    # block for a moment
+    time.sleep(value * 10)
+
+    # return the generated value
+    return value
+
+
+# protect the entry point
+def execute_multiprocessing():
+    # create and configure the process pool
+    data = [[random() for n in range(100)] for i in range(300)]
+    try:
+        total_steps = 300
+        with Pool() as pool:
+            step = 0
+            # execute tasks in order, process results out of order
+            for result in pool.imap_unordered(worker, data):
+                print(f'Got result: {result}', flush=True)
+                step += 1
+                print(step)
+                print('%{}'.format(step / total_steps * 100))
+
+    except OperationCancelledException:
+        print("Operation cancelled")
+
+
+if __name__ == '__main__':
+    in_args, in_verbose = check_arguments()
+    start_time = time.time()
+    tool_name(print, **in_args.input, processes=int(in_args.processes), verbose=in_verbose)
+    print('Elapsed time: {}'.format(time.time() - start_time))