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

beratools/tools/tiler.py

@@ -1,206 +1,48 @@
-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_())
+"""
+Copyright (C) 2025 Applied Geospatial Research Group.
+
+This script is licensed under the GNU General Public License v3.0.
+See <https://gnu.org/licenses/gpl-3.0> for full license details.
+
+Author: Richard Zeng
+
+Description:
+    This script is part of the BERA Tools.
+    Webpage: https://github.com/appliedgrg/beratools
+
+    The purpose of this script is to split input vector and raster data into
+    smaller tiles based on a specified tile size and buffer distance.
+"""
+
+import time
+
+import beratools.tools.common as bt_common
+import beratools.core.algo_tiler as bt_tiler
+
+def tiler(
+    in_line,
+    in_raster,
+    out_file,
+    n_clusters,
+    processes,
+    verbose,
+    tile_buffer=50,
+    in_layer=None,
+):
+    clustering = bt_tiler.DensityBasedClustering(
+        in_line=in_line,
+        in_raster=in_raster,
+        out_file=out_file,
+        n_clusters=int(n_clusters),
+        tile_buffer=tile_buffer,
+        layer=in_layer,
+    )
+
+    clustering.run()
+
+
+if __name__ == "__main__":
+    in_args, in_verbose = bt_common.check_arguments()
+    start_time = time.time()
+    tiler(**in_args.input, processes=int(in_args.processes), verbose=in_verbose)
+    print("Elapsed time: {}".format(time.time() - start_time))

beratools/tools/tool_template.py

@@ -1,54 +1,69 @@
-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))
+"""
+Copyright (C) 2025 Applied Geospatial Research Group.
+
+This script is licensed under the GNU General Public License v3.0.
+See <https://gnu.org/licenses/gpl-3.0> for full license details.
+
+Author: AUTHOR NAME
+
+Description:
+    This script is part of the BERA Tools.
+    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 beratools.tools.common as bt_common
+from beratools.core.tool_base import execute_multiprocessing
+
+# 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
+):
+    """
+    Define tool entry point.
+    
+    These arguments are defined in beratools.json file. 
+    execute_multiprocessing is common function to run tasks in parallel.
+    """
+    result = execute_multiprocessing(
+        worker,
+        task_data_list,
+        "tool_template",
+        processes,
+        verbose=verbose
+    )
+    print(len(result))
+
+
+# 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)
+
+    # block for a moment
+    time.sleep(value * 10)
+
+    # return the generated value
+    return value
+
+
+if __name__ == '__main__':
+    in_args, in_verbose = bt_common.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))