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

beratools/tools/vertex_optimization.py

@@ -13,49 +13,35 @@ Description:
     The purpose of this script is the public interface for vertex optimization.
 """
 
-import time
+import logging
 
 import beratools.core.algo_vertex_optimization as bt_vo
-import beratools.tools.common as bt_common
-
-
-def vertex_optimization(
-    in_line,
-    in_raster,
-    search_distance,
-    line_radius,
-    out_line,
-    processes,
-    verbose,
-    in_layer=None,
-    out_layer=None,
-):
-    if not bt_common.compare_crs(
-        bt_common.vector_crs(in_line), bt_common.raster_crs(in_raster)
-    ):
+import beratools.utility.spatial_common as sp_common
+from beratools.core.logger import Logger
+from beratools.utility.tool_args import CallMode
+
+log = Logger("vertex_optimization", file_level=logging.INFO)
+logger = log.get_logger()
+print = log.print
+
+
+def vertex_optimization(in_line, in_raster, search_distance, line_radius, out_line, 
+                        processes=0, call_mode=CallMode.CLI, log_level="INFO"):
+    in_file, in_layer = sp_common.decode_file_layer(in_line)
+    if not sp_common.compare_crs(sp_common.vector_crs(in_file), sp_common.raster_crs(in_raster)):
         return
 
-    vg = bt_vo.VertexGrouping(
-        in_line,
-        in_raster,
-        search_distance,
-        line_radius,
-        out_line,
-        processes,
-        verbose,
-        in_layer,
-        out_layer,
-    )
+    vg = bt_vo.VertexGrouping(in_file, in_raster, search_distance, line_radius, processes, call_mode, layer=in_layer)
     vg.create_all_vertex_groups()
     vg.compute()
     vg.update_all_lines()
     vg.save_all_layers(out_line)
 
-
 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()
-    vertex_optimization(
-        **in_args.input, processes=int(in_args.processes), verbose=in_verbose
-    )
+    kwargs = compose_tool_kwargs("vertex_optimization")
+    vertex_optimization(**kwargs)
     print("Elapsed time: {}".format(time.time() - start_time))

beratools/utility/env_checks.py

@@ -0,0 +1,53 @@
+"""Environment validation helpers for BERA Tools."""
+
+from __future__ import annotations
+
+import os
+import sys
+import warnings
+from pathlib import Path
+
+
+def get_gdal_proj_env_warning() -> str | None:
+    """Return a Windows-only GDAL/PROJ environment warning message, or None."""
+    if not sys.platform.startswith("win"):
+        return None
+
+    gdal_data_env = os.environ.get("GDAL_DATA")
+    proj_lib_env = os.environ.get("PROJ_LIB")
+    if not (gdal_data_env or proj_lib_env):
+        return None
+
+    prefix_path = Path(sys.prefix).resolve()
+    mismatches: list[tuple[str, str]] = []
+
+    if gdal_data_env:
+        gdal_path = Path(gdal_data_env).resolve()
+        if not gdal_path.is_relative_to(prefix_path):
+            mismatches.append(("GDAL_DATA", gdal_data_env))
+
+    if proj_lib_env:
+        proj_path = Path(proj_lib_env).resolve()
+        if not proj_path.is_relative_to(prefix_path):
+            mismatches.append(("PROJ_LIB", proj_lib_env))
+
+    if not mismatches:
+        return None
+
+    mismatch_details = "\n".join(
+        f"{env_name:<9}: {env_value}" for env_name, env_value in mismatches
+    )
+
+    return (
+        "[GDAL/PROJ Warning] Potential env mismatch\n"
+        f"Python env: {sys.prefix}\n"
+        f"{mismatch_details}\n"
+        "If you encounter GDAL/PROJ errors, ensure these env paths belong to this Python environment."
+    )
+
+
+def warn_gdal_proj_env() -> None:
+    """Emit a warning for CLI/headless usage if GDAL/PROJ env vars look mismatched."""
+    warning_message = get_gdal_proj_env_warning()
+    if warning_message:
+        warnings.warn(warning_message)

beratools/utility/spatial_common.py

@@ -0,0 +1,210 @@
+"""
+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, Maverick Fong
+
+Description:
+    This script is part of the BERA Tools.
+    Webpage: https://github.com/appliedgrg/beratools
+
+    This file is intended to be hosting common spatial classes/functions for BERA Tools
+"""
+
+import warnings
+
+import geopandas as gpd
+import numpy as np
+import pyproj
+import rasterio
+from osgeo import gdal, osr, version_info
+from pyogrio import set_gdal_config_options
+from rasterio import mask
+
+import beratools.core.constants as bt_const
+
+# suppress pandas UserWarning: Geometry column contains no geometry when splitting lines
+warnings.simplefilter(action="ignore", category=UserWarning)
+
+# restore .shx for shapefile for using GDAL or pyogrio
+gdal.SetConfigOption("SHAPE_RESTORE_SHX", "YES")
+set_gdal_config_options({"SHAPE_RESTORE_SHX": "YES"})  # for pyogrio
+
+
+# suppress all kinds of warnings
+if not bt_const.BT_DEBUGGING:
+    gdal.SetConfigOption("CPL_LOG", "NUL")  # GDAL warning
+    warnings.filterwarnings("ignore")  # suppress warnings
+    warnings.simplefilter(action="ignore", category=UserWarning)  # suppress Pandas UserWarning
+
+
+def clip_raster(
+    in_raster_file,
+    clip_geom,
+    buffer=0.0,
+    out_raster_file=None,
+    default_nodata=bt_const.BT_NODATA,
+):
+    out_meta = None
+    with rasterio.open(in_raster_file) as raster_file:
+        out_meta = raster_file.meta
+        ras_nodata = out_meta["nodata"]
+        if ras_nodata is None:
+            ras_nodata = default_nodata
+
+        clip_geo_buffer = [clip_geom.buffer(buffer)]
+        out_image = None
+        out_image, out_transform = mask.mask(
+            raster_file, clip_geo_buffer, crop=True, nodata=ras_nodata, filled=True
+        )
+        if np.isnan(ras_nodata):
+            out_image[np.isnan(out_image)] = default_nodata
+
+        elif np.isinf(ras_nodata):
+            out_image[np.isinf(out_image)] = default_nodata
+        else:
+            out_image[out_image == ras_nodata] = default_nodata
+
+        out_image = np.ma.masked_where(out_image == default_nodata, out_image)
+        out_image.fill_value = default_nodata
+        ras_nodata = default_nodata
+
+        height, width = out_image.shape[1:]
+
+        out_meta.update(
+            {
+                "driver": "GTiff",
+                "height": height,
+                "width": width,
+                "transform": out_transform,
+                "nodata": ras_nodata,
+            }
+        )
+
+    if out_raster_file:
+        with rasterio.open(out_raster_file, "w", **out_meta) as dest:
+            dest.write(out_image)
+            print("[Clip raster]: data saved to {}.".format(out_raster_file))
+
+    return out_image, out_meta
+
+
+def decode_file_layer(encoded):
+    """
+    Decode encoded file|layer string into file path and layer name.
+
+    Args:
+        encoded (str): Encoded string like "file.shp|" or "C:/path/file.gpkg|layer"
+
+    Returns:
+        tuple: (file_path, layer_name) where layer_name is None if empty
+    """
+    if "|" in encoded:
+        file_path, layer = encoded.rsplit("|", 1)
+        layer_name = layer if layer else None
+    elif "::" in encoded:
+        file_path, layer = encoded.rsplit("::", 1)
+        layer_name = layer if layer else None
+    else:
+        file_path = encoded
+        layer_name = None
+    return file_path, layer_name
+
+
+def vector_crs(in_vector):
+    osr_crs = osr.SpatialReference()
+    from pyproj.enums import WktVersion
+
+    vec_crs = None
+    # open input vector data as GeoDataFrame
+    gpd_vector = gpd.GeoDataFrame.from_file(in_vector)
+    try:
+        if gpd_vector.crs is not None:
+            vec_crs = gpd_vector.crs
+            if version_info.major < 3:
+                osr_crs.ImportFromWkt(vec_crs.to_wkt(WktVersion.WKT1_GDAL))
+            else:
+                osr_crs.ImportFromEPSG(vec_crs.to_epsg())
+            return osr_crs
+        else:
+            print("No CRS found in the input feature, please check!")
+            exit()
+    except Exception as e:
+        print(e)
+        exit()
+
+
+def raster_crs(in_raster):
+    osr_crs = osr.SpatialReference()
+    with rasterio.open(in_raster) as raster_file:
+        from pyproj.enums import WktVersion
+
+        try:
+            if raster_file.crs is not None:
+                vec_crs = raster_file.crs
+                if version_info.major < 3:
+                    osr_crs.ImportFromWkt(vec_crs.to_wkt(WktVersion.WKT1_GDAL))
+                else:
+                    osr_crs.ImportFromEPSG(vec_crs.to_epsg())
+                return osr_crs
+            else:
+                print("No Coordinate Reference System (CRS) find in the input feature, please check!")
+                exit()
+        except Exception as e:
+            print(e)
+            exit()
+
+
+def get_crs_proj_name(crs_norm, label="crs"):
+    import warnings
+
+    if crs_norm.is_compound:
+        op = crs_norm.sub_crs_list[0].coordinate_operation
+        if op is None:
+            warnings.warn(f"{label}.sub_crs_list[0].coordinate_operation is None; using 'unknown'")
+            return "unknown"
+        return op.name
+    elif crs_norm.name == "unnamed":
+        return None
+    else:
+        op = crs_norm.coordinate_operation
+        if op is None:
+            warnings.warn(f"{label}.coordinate_operation is None; using 'unknown'")
+            return "unknown"
+        return op.name
+
+
+def compare_crs(crs_org, crs_dst):
+    if crs_org and crs_dst:
+        if crs_org.IsSameGeogCS(crs_dst):
+            print("Check: Input file Spatial Reference are the same, continue.")
+            return True
+        else:
+            crs_org_norm = pyproj.CRS(crs_org.ExportToWkt())
+            crs_dst_norm = pyproj.CRS(crs_dst.ExportToWkt())
+
+            crs_org_proj = get_crs_proj_name(crs_org_norm, "crs_org_norm")
+            if crs_org_proj is None:
+                return False
+
+            crs_dst_proj = get_crs_proj_name(crs_dst_norm, "crs_dst_norm")
+            if crs_dst_proj is None:
+                return False
+
+            if crs_org_proj == crs_dst_proj:
+                if crs_org_norm.name == crs_dst_norm.name:
+                    print("Input files Spatial Reference are the same, continue.")
+                    return True
+                else:
+                    print(
+                        """Checked: Data are on the same projected Zone but using 
+                        different Spatial Reference. \n Consider to re-project 
+                        all data onto same spatial reference system.\n Process Stop."""
+                    )
+                    exit()
+            else:
+                return False
+
+    return False

beratools/utility/tool_args.py

@@ -0,0 +1,138 @@
+"""Utility functions for tool argument parsing."""
+
+import argparse
+import json
+import os
+import platform
+import sys
+from enum import Enum
+
+
+# TODO: Consider using StrEnum from Python 3.11+
+class StrEnum(str, Enum):
+    pass
+
+class CallMode(StrEnum):
+    CLI = "CLI"
+    GUI = "GUI"
+
+def determine_cpu_core_limit():
+    running_windows = platform.system() == "Windows"
+    core_count = os.cpu_count() or 1
+    max_cores = max(core_count - 1, 1)
+    if running_windows:
+        max_cores = min(max_cores, 60)
+    return max_cores
+
+def compose_tool_kwargs(tool_api):
+    """
+    Auto-detecting argument composer for both CLI and GUI modes.
+
+    - Detects mode from --input presence
+    - GUI: unpacks --input JSON, adds common args from CLI flags
+    - CLI: parses all args from beratools.json definitions with validation
+    - Returns: complete kwargs dict with all parameters
+
+    Note: In CLI mode, argparse automatically prints help and exits
+    if required arguments are missing.
+    """
+    from beratools.gui.bt_data import BTData
+
+    bt_data = BTData()
+    tool_name = bt_data.get_bera_tool_name(tool_api)
+    tool_api_name = tool_api
+
+    mode_parser = argparse.ArgumentParser(add_help=False)
+    mode_parser.add_argument("-i", "--input", type=json.loads, default=None)
+    mode_parser.add_argument("-c", "--call_mode", default=CallMode.CLI.value)
+    mode_parser.add_argument("-p", "--processes", type=int, default=0)
+    mode_parser.add_argument("-l", "--log_level", default="INFO")
+    mode_args, remaining = mode_parser.parse_known_args()
+
+    if mode_args.input is None:
+        from beratools.utility import env_checks
+
+        env_checks.warn_gdal_proj_env()
+
+    if mode_args.input is not None:
+        # GUI MODE: unpack tool params from JSON with TYPE VALIDATION
+        try:
+            kwargs = bt_data.validate_tool_params(tool_name, mode_args.input)
+        except ValueError as e:
+            print(f"ERROR: {str(e)}", file=sys.stderr)
+            sys.exit(1)
+
+    else:
+        # CLI MODE: parse tool params from CLI args with validation
+        # Load parameter definitions from beratools.json
+        tool_params = bt_data.get_bera_tool_params(tool_name)
+
+        # Helper: Separate parameters by type
+        required_params = [
+            p for p in tool_params.get("parameters", []) if p.get("variable") and not p.get("optional", False)
+        ]
+        optional_params = [
+            p for p in tool_params.get("parameters", []) if p.get("variable") and p.get("optional", False)
+        ]
+
+        # Build usage string with only required parameters
+        required_flags = " ".join([f"--{p.get('variable')}" for p in required_params])
+        custom_usage = f"python {tool_api_name}.py {required_flags}" if required_flags else f"python {tool_api_name}.py"
+
+        full_parser = argparse.ArgumentParser(
+            prog=tool_name,
+            usage=custom_usage,
+            description=f"Tool: {tool_name}",
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+        )
+
+        # Create argument groups
+        required_group = full_parser.add_argument_group("Required Parameters")
+        optional_group = full_parser.add_argument_group("Optional Parameters")
+        framework_group = full_parser.add_argument_group("Framework Options")
+
+        # Helper function to add parameters to argument group
+        def add_param_args(group, params, required=False):
+            """Add parameter arguments to argument group."""
+            for param in params:
+                arg_config = {"required": required}
+                if param.get("default_value") is not None and param.get("default_value") != "":
+                    arg_config["default"] = param.get("default_value")
+                if param.get("description"):
+                    # Escape % in help text to prevent argparse formatting errors
+                    arg_config["help"] = param.get("description").replace("%", "%%")
+                group.add_argument(f"--{param.get('variable')}", **arg_config)
+
+        # Add required and optional parameters using helper
+        add_param_args(required_group, required_params, required=True)
+        add_param_args(optional_group, optional_params, required=False)
+
+        # Add framework parameters to their group (with descriptions)
+        framework_group.add_argument(
+            "-p",
+            "--processes",
+            type=int,
+            default=mode_args.processes,
+            help="Number of CPU processes (default: 1)",
+        )
+        framework_group.add_argument(
+            "-c", "--call_mode", default=mode_args.call_mode, help="'CLI' or 'GUI' mode (default: CLI)"
+        )
+        framework_group.add_argument(
+            "-l",
+            "--log_level",
+            default=mode_args.log_level,
+            help="DEBUG, INFO, WARNING, ERROR (default: INFO)",
+        )
+
+        # Parse all arguments
+        # This automatically prints help and exits if required args are missing
+        args = full_parser.parse_args()
+        kwargs = vars(args)
+
+    # Always ensure framework params are set from first pass
+    kwargs.update(
+        {"processes": mode_args.processes, "call_mode": mode_args.call_mode, "log_level": mode_args.log_level}
+    )
+
+    return kwargs

beratools-0.2.5.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: BERATools
+Version: 0.2.5
+Summary: An advanced forest line feature analysis platform
+Project-URL: Homepage, https://github.com/appliedgrg/beratools
+Author-email: AppliedGRG <appliedgrg@gmail.com>, Richard Zeng <richardqzeng@gmail.com>
+License: GPL-3.0-or-later
+License-File: LICENSE
+Keywords: BERA,Line
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Requires-Dist: bera-centerlines
+Requires-Dist: gdal; platform_system != 'Windows'
+Requires-Dist: geopandas
+Requires-Dist: networkit
+Requires-Dist: pyogrio>=0.9.0
+Requires-Dist: pyqt5
+Requires-Dist: rasterio
+Requires-Dist: scikit-image>=0.24.0
+Requires-Dist: tabulate
+Requires-Dist: tqdm
+Requires-Dist: xarray-spatial
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: isort; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pre-commit; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: tox; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Provides-Extra: doc
+Requires-Dist: click==8.2.1; extra == 'doc'
+Requires-Dist: mkdocs; extra == 'doc'
+Requires-Dist: mkdocs-git-revision-date-localized-plugin; extra == 'doc'
+Requires-Dist: mkdocs-material; extra == 'doc'
+Requires-Dist: mkdocstrings; extra == 'doc'
+Requires-Dist: mkdocstrings-python; extra == 'doc'
+Requires-Dist: pymdown-extensions; extra == 'doc'
+Description-Content-Type: text/markdown
+
+# BERA Tools
+
+BERA Tools is successor of [Forest Line Mapper](https://github.com/appliedgrg/flm). It is a toolset for enhanced delineation and attribution of linear disturbances in forests.
+
+<div align="center">
+
+[![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/appliedgrg/beratools/python-tests.yml?branch=main)](https://github.com/appliedgrg/beratools/actions/workflows/python-tests.yml)
+[![Codecov](https://img.shields.io/codecov/c/github/appliedgrg/beratools/main)](https://codecov.io/gh/appliedgrg/beratools)
+[![GitHub Pages](https://img.shields.io/github/deployments/appliedgrg/beratools/github-pages?label=docs)](https://appliedgrg.github.io/beratools/)
+[![Conda Version](https://img.shields.io/conda/v/AppliedGRG/beratools)](https://anaconda.org/AppliedGRG/beratools)
+[![Python Version](https://img.shields.io/badge/python-3.10%2B-blue)](https://www.python.org/downloads/release/python-3100/)
+[![License: GPL-3.0](https://img.shields.io/badge/License-GPL%203.0-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
+
+</div>
+
+## [Quick Start](https://appliedgrg.github.io/beratools)
+
+BERA Tools is built upon open-source Python libraries. Anaconda is used to manage runtime environments.
+
+Ways to install BERA Tools:
+
+- Windows installer
+- Install with Anaconda.
+
+### Windows Installer
+
+Windows installer is provided with releases. Check the [latest release](https://github.com/appliedgrg/beratools/releases/latest) for the up-to-date installer.
+
+### Install with Anaconda
+
+Install with Anaconda works on Windows, macOS, and Linux.
+
+- Install Miniconda. Download Miniconda from [Miniconda](https://docs.anaconda.com/miniconda/) and install on your machine.
+- Download the file [environment.yml](https://raw.githubusercontent.com/appliedgrg/beratools/main/environment.yml
+) and save to local storage. Launch **Anaconda Prompt** or **Miniconda Prompt**.
+- **Change directory** to where environment.yml is saved in the command prompt.
+- Run the following command to create a new environment named **bera**. **BERA Tools** will be installed in the new environment at the same time.
+
+   ```bash
+   $ conda env create -n bera -f environment.yml
+   ```
+
+   Wait until the installation is done.
+- Activate the **bera** environment and launch BERA Tools:
+
+  ```bash
+  $ conda activate bera
+  $ beratools
+  ```
+
+- [Download latest example data](https://github.com/appliedgrg/beratools/releases/latest/download/test_data.zip) to try with BERA Tools.
+- To update BERA Tools when new release is issued, run the following commands:
+
+    ```bash
+    $ conda activate bera
+    $ conda update beratools
+    ```
+
+- To completely remove BERA Tools and its environment, run the following command:
+
+    ```bash
+    $ conda remove -n bera
+    ```
+
+## BERA Tools Guide
+
+Check the online [BERA Tools Guide](https://appliedgrg.github.io/beratools/) for user, developer guides.
+
+## Credits
+
+<table>
+  <tr>
+    <td><img src="docs/files/icons/bera_logo.png" alt="Logos" width="80"></td>
+    <td>
+      <p>
+        This tool is part of the <strong><a href="http://www.beraproject.org/">Boreal Ecosystem Recovery & Assessment (BERA)</a></strong>.
+        It is actively developed by the <a href="https://www.appliedgrg.ca/"><strong>Applied Geospatial Research Group</strong></a>.
+      </p>
+      <p>
+        © 2026 Applied Geospatial Research Group. All rights reserved.
+      </p>
+    </td>
+  </tr>
+</table>

beratools-0.2.5.dist-info/RECORD

@@ -0,0 +1,50 @@
+beratools/__init__.py,sha256=PW8O7ptzcibf-RBahr8etZ5bSyEmBNsj5HhR6zIQ64A,266
+beratools/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+beratools/core/algo_canopy_footprint_exp.py,sha256=IlfwyMo7ySwx_UG9H91aEnHaLYkBoyeHg_4bj8d_IHw,22603
+beratools/core/algo_centerline.py,sha256=HvXViuMwoOt9Xt3i8KX4bvpsZNz4zKv7LvdGIVvbIdA,15627
+beratools/core/algo_common.py,sha256=vMGcjyF_pP79bqjNvjuBN_i9HoebUq2JWyHNyyKOObE,14714
+beratools/core/algo_cost.py,sha256=JFNdy9U4B2-AgUR_o-zKABEINqU8GJLFJIAxFOm05Zw,5934
+beratools/core/algo_dijkstra.py,sha256=_pABOkwTm3Tc9J33G_1or_iW96D4UPuL93iPlg_vK6k,15167
+beratools/core/algo_line_grouping.py,sha256=_VuxMntZE3rAwJfZZwOkvFSUwyhxpi1nFapJ4ZOtT8Q,32998
+beratools/core/algo_merge_lines.py,sha256=EKgGRyuomc7JpliK1nwCrOA8uwepGatmPaicxl0TTH0,7950
+beratools/core/algo_split_with_lines.py,sha256=-k8oMBQ-XM3Xzdxdd9Vhi-YgMaRFHixdW8Ts9lL6dYU,10747
+beratools/core/algo_vertex_optimization.py,sha256=OvvDOt7pi8X0xpaR45JH9e6WQVL-2ycWfBG_R0jMnHc,15380
+beratools/core/canopy_threshold_relative.py,sha256=N5HIJiA6SgLA8qrML6qAbkJlxs3sEEKGnlvkfZ3mdbg,30015
+beratools/core/constants.py,sha256=h4rnXNbKd7HCkyJNIrh01OKBegQb-tQrwavzrbCEUTM,1115
+beratools/core/line_footprint_functions.py,sha256=B5PExYq4xZMMGvvnIwi3vDxhoG25NEwerthI3uOdCYU,31864
+beratools/core/logger.py,sha256=55nhQV3Jjjf3GD-v6hfd-LKc8YyH4Wpe53ImQhLGwfM,2803
+beratools/core/tool_base.py,sha256=dDJPUPf2qmjFRrbkqFR49r0osEEKmTLNrPQ3PbBtj5E,4343
+beratools/gui/bt_data.py,sha256=VebUxYqRVJf68sMcRJLRWovj71ZwE8608RG0gVMYCbA,31024
+beratools/gui/bt_gui_main.py,sha256=X-UGSl90a21OCINzqDysxVm5gWdlgkXejPal8ocoGIE,26877
+beratools/gui/main.py,sha256=6rireFhO1NNuuKlyU89HT7ESq3_zrex5xlloGYQO6WM,482
+beratools/gui/tool_widgets.py,sha256=mCZrudV33uamPxb2JMp1ZU2e8gNBXh5dq85ur8MBm4s,35876
+beratools/gui/assets/BERALogo.ico,sha256=5kNFkKe0FdL-oBXiO2ExVTMHhelO6sB69I3VHPCRQno,107799
+beratools/gui/assets/BERALogo.png,sha256=hnGLSL7Jv2ljDn6Z8ad5ekzH9k1PEuq7xe7Hh8bXZkE,6660
+beratools/gui/assets/BERA_Splash.gif,sha256=4QB5Xua2F59mBeOoeQ1Eoz0t-fZOQbYMTAl62RE2yEU,4377179
+beratools/gui/assets/BERA_WizardImage.png,sha256=IKgbY0h_uZ3Sk2B7-X5oMIs5GkNwLXgbf87JjuealvY,11370
+beratools/gui/assets/beratools.json,sha256=KJzkd5DyXaou_MfOg_glEc7xOfDB6cGItRzOzK9V9VY,18964
+beratools/gui/assets/closed.gif,sha256=T9BBGl286-FdSRYbWVt68HwPRF0geWoowtBzeYsk_bI,592
+beratools/gui/assets/closed.png,sha256=FRSAh3wzASowFUEt88zHhk1BQmwRbjoCs50Ff8KpJNQ,311
+beratools/gui/assets/gui.json,sha256=kRD3Ozim9IotcY8P3fapgs4qqj5vebQHLxmss_SOJdY,329
+beratools/gui/assets/open.gif,sha256=o8LL1OaDNkQ0Gcc9dO-1f1UZFAQ3ALc4svtqiUuWJPY,1062
+beratools/gui/assets/open.png,sha256=v0OOwfTNGMmtdFbffCbxdYLaNZeRC9Cy5whAwi71oVw,524
+beratools/gui/assets/tool.gif,sha256=2KGcUI_b-qFdrJJhgbx9pMZ8pExX7zH8nYvweRiQs6U,555
+beratools/gui/assets/tool.png,sha256=35Txwum2l_aKeazF_I97ZaZAKHsrKQCGG-LZxEIFyZw,714
+beratools/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+beratools/tools/canopy_footprint_absolute.py,sha256=gcQjCDc21vcatcF5IQVUmwVQSUn9drHn09yvnnfYsqI,7865
+beratools/tools/canopy_footprint_exp.py,sha256=91Nh0MCS6J0sTx65tHeR122uXzwEvT1rtaisq8yB1qQ,4185
+beratools/tools/centerline.py,sha256=Zn0iPEL0fki6VMENCDqaPIrM433a-b_9PGjyxEfx3S4,3956
+beratools/tools/check_seed_line.py,sha256=653X2R75zP667VWPylwu5pLjLfiSCI-z6va_NCXa55E,4389
+beratools/tools/common.py,sha256=b_4b3RuBSiQVmtwWSDpXEZvROnBY0vIQzpDT5TW_nfw,11183
+beratools/tools/ground_footprint.py,sha256=VhVdB6ZPBG4zxZCHUWSZnpIn1aq_uB5RebvKVi-ZaRA,16177
+beratools/tools/line_footprint_relative.py,sha256=DJQiS4aQRN-KjOENl04qPDxBQfza4iicS39Xjd7-Zdw,3716
+beratools/tools/tool_template.py,sha256=U4YYGWCXLGQImE96tjR6tx3eUSTTAs2TuGmMbF6zlME,2661
+beratools/tools/vertex_optimization.py,sha256=b8PU5VHFx8Z42lgTl4P7AB5DaoJ8USztHGoU9s-iBW0,1591
+beratools/utility/env_checks.py,sha256=-NBUJc1oh4XzcjNvY-IgvTLs7_zcHS3_KdRjXdYz790,1606
+beratools/utility/spatial_common.py,sha256=GA2FwbxKeqJPfX7jtrnE6LuH9PgBlMujgG-ejoXlOrQ,6732
+beratools/utility/tool_args.py,sha256=If8qGoK-snnTZuWhtPA_xSOVY5DMZPlZ-CGoSuy2-tk,5251
+beratools-0.2.5.dist-info/METADATA,sha256=dYF7hTCCmeryiJX-Y0Nnh4ZcP88bJ02m82E2NJALcuQ,5317
+beratools-0.2.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+beratools-0.2.5.dist-info/entry_points.txt,sha256=wEzv7VVMxnmCmzV3D10B-9DXdqnZgPsBgVWtiIhcdaU,98
+beratools-0.2.5.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+beratools-0.2.5.dist-info/RECORD,,

{beratools-0.2.3.dist-info → beratools-0.2.5.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

beratools-0.2.5.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+BERATools = beratools.gui.main:gui_main
+beratools = beratools.gui.main:gui_main