BERATools 0.3.10__tar.gz → 0.4.0__tar.gz

{beratools-0.3.10 → beratools-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: BERATools
-Version: 0.3.10
+Version: 0.4.0
 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>

{beratools-0.3.10 → beratools-0.4.0}/beratools/__init__.py

@@ -1,6 +1,6 @@
 __author__ = """Applied Geospatial Research Group"""
 __email__ = 'appliedgrg@gmail.com'
-__version__ = '0.3.10'
+__version__ = '0.4.0'
 __license__ = "GPL-3.0-or-later"
 __copyright__ = "Copyright (c) AppliedGRG"
 __status__ = "Pre-Alpha"

{beratools-0.3.10 → beratools-0.4.0}/beratools/core/algo_centerline.py

@@ -99,7 +99,10 @@ def snap_end_to_end(in_line, line_reference, max_snap_dist=None):
     if type(in_line) is sh_geom.MultiLineString:
         in_line = sh_ops.linemerge(in_line)
         if type(in_line) is sh_geom.MultiLineString:
-            print(f"algo_centerline: MultiLineString found {in_line.centroid}, pass.")
+            algo_common.log_file_only(
+                f"algo_centerline: MultiLineString found {in_line.centroid}, pass.",
+                logger_name=__name__,
+            )
             return None
 
     pts = list(in_line.coords)
@@ -218,7 +221,7 @@ def find_centerline(poly, input_line, guided_strategy="main_route"):
     effective_strategy = guided_strategy
 
     if not poly:
-        print("find_centerline: No polygon found")
+        algo_common.log_file_only("find_centerline: No polygon found")
         return default_return
 
     poly = shapely.segmentize(poly, max_segment_length=CenterlineParams.SEGMENTIZE_LENGTH)
@@ -252,11 +255,18 @@ def find_centerline(poly, input_line, guided_strategy="main_route"):
             guided_strategy,
         )
     except Exception as e:
-        print(f"find_centerline: {e}")
+        error_msg = str(e)
+        if error_msg == "endpoint-guided extraction failed for provided endpoints":
+            algo_common.log_file_only(f"find_centerline: {error_msg}")
+        else:
+            print(f"find_centerline: {e}")
         centerline = None
 
     if not centerline and guided_strategy in {"pairwise", "virtual_nodes", "direct_insert"}:
-        print(f"find_centerline: {guided_strategy} guidance failed, retrying main_route")
+        if guided_strategy == "pairwise":
+            algo_common.log_file_only("find_centerline: pairwise guidance failed, retrying main_route")
+        else:
+            print(f"find_centerline: {guided_strategy} guidance failed, retrying main_route")
         try:
             centerline = _extract_centerline_from_polygon(
                 poly,
@@ -305,7 +315,7 @@ def find_centerline(poly, input_line, guided_strategy="main_route"):
     # Check centerline. If valid, regenerate by splitting polygon into two halves.
     if not centerline_is_valid(centerline, input_line):
         try:
-            print("Regenerating line ...")
+            algo_common.log_file_only("Regenerating line ...", logger_name=__name__)
             centerline = regenerate_centerline(poly, input_line)
             return centerline, CenterlineStatus.REGENERATE_SUCCESS
         except Exception as e:
@@ -447,7 +457,9 @@ def regenerate_centerline(poly, input_line):
     poly_split = sh_ops.split(poly_exterior, perp)
 
     if len(poly_split.geoms) < 2:
-        print("regenerate_centerline: polygon sh_ops.split failed, pass.")
+        algo_common.log_file_only(
+            "regenerate_centerline: polygon sh_ops.split failed, pass.", logger_name=__name__
+        )
         return None
 
     poly_1 = poly_split.geoms[0]
@@ -480,7 +492,7 @@ def regenerate_centerline(poly, input_line):
     except Exception as e:
         print(f"regenerate_centerline: {e}")
 
-    print("Centerline is regenerated.")
+    algo_common.log_file_only("Centerline is regenerated.", logger_name=__name__)
     return sh_ops.linemerge(sh_geom.MultiLineString([center_line_1, center_line_2]))
 
 
@@ -531,7 +543,7 @@ class SeedLine:
 
         # search for centerline
         if len(lc_path_coords) < 2:
-            print("No least cost path detected, use input line.")
+            algo_common.log_file_only("No least cost path detected, use input line.", logger_name=__name__)
             self.line["cl_status"] = CenterlineStatus.FAILED.value
             return
 

{beratools-0.3.10 → beratools-0.4.0}/beratools/core/algo_check_seed_line.py

@@ -11,6 +11,7 @@ import shapely.geometry as sh_geom
 
 import beratools.core.constants as bt_const
 import beratools.core.algo_common as algo_common
+import beratools.utility.unit_conversion as unit_conversion
 
 try:
     import rasterio
@@ -227,53 +228,19 @@ def _normalize_to_lines(gdf):
 
 
 def _require_crs(gdf, parameter_label):
-    crs = pyproj.CRS.from_user_input(gdf.crs) if gdf.crs else None
-    if crs is None:
-        raise ValueError(f"Input line CRS is missing; cannot apply '{parameter_label}'.")
-    return crs
+    return unit_conversion.require_crs(gdf, parameter_label)
 
 
 def _build_linear_unit_context(crs, reference_geom):
-    if crs.is_geographic:
-        if reference_geom is None or reference_geom.is_empty:
-            raise ValueError("Unable to determine reference geometry for geographic CRS unit conversion.")
-        ref_point = reference_geom.representative_point()
-        metric_crs = pyproj.CRS.from_proj4(
-            f"+proj=aeqd +lat_0={ref_point.y} +lon_0={ref_point.x} +datum=WGS84 +units=m +no_defs"
-        )
-        to_metric = pyproj.Transformer.from_crs(crs, metric_crs, always_xy=True)
-        to_source = pyproj.Transformer.from_crs(metric_crs, crs, always_xy=True)
-        return {
-            "is_geographic": True,
-            "to_metric": to_metric,
-            "to_source": to_source,
-            "unit_factor": None,
-        }
-
-    unit_factor = crs.axis_info[0].unit_conversion_factor if crs.axis_info else None
-    if unit_factor is None or unit_factor <= 0:
-        raise ValueError("Unable to determine projected CRS linear units.")
-    return {
-        "is_geographic": False,
-        "to_metric": None,
-        "to_source": None,
-        "unit_factor": unit_factor,
-    }
+    return unit_conversion.build_linear_unit_context(crs, reference_geom)
 
 
 def _meters_to_native_units(distance_m, unit_ctx):
-    if unit_ctx["is_geographic"]:
-        return float(distance_m)
-    return float(distance_m) / float(unit_ctx["unit_factor"])
+    return unit_conversion.meters_to_native_units(distance_m, unit_ctx)
 
 
 def _geometry_length_meters(geom, unit_ctx):
-    if geom is None or geom.is_empty:
-        return 0.0
-    if unit_ctx["is_geographic"]:
-        geom_metric = sh_ops.transform(unit_ctx["to_metric"].transform, geom)
-        return float(geom_metric.length)
-    return float(geom.length) * float(unit_ctx["unit_factor"])
+    return unit_conversion.geometry_length_meters(geom, unit_ctx)
 
 
 def _geographic_raster_cell_size_m(src, crs, x_res, y_res):
@@ -844,4 +811,3 @@ def qc_split_lines_at_intersections(gdf):
             return splitter.split_lines_gdf.reset_index(drop=True)
         return splitter.split_lines_gdf
     return gdf.reset_index(drop=True)
-

beratools-0.4.0/beratools/core/algo_check_seed_line_validate.py

@@ -0,0 +1,388 @@
+"""Final validation pass on check_seed_line outputs to detect remaining issues."""
+
+import geopandas as gpd
+from shapely.geometry import GeometryCollection, LineString, MultiLineString, MultiPoint, Point
+
+import beratools.core.constants as bt_const
+import beratools.utility.unit_conversion as unit_conversion
+
+
+ISSUE_COLUMNS = [
+    "issue_type",
+    "description",
+    "line_id",
+    "line_id_2",
+    "value",
+    "threshold",
+    "geometry",
+]
+
+
+def _iter_line_parts(geom):
+    if geom is None or geom.is_empty:
+        return []
+    if geom.geom_type == "LineString":
+        return [geom]
+    if geom.geom_type == "MultiLineString":
+        return [part for part in geom.geoms if part is not None and not part.is_empty]
+    if geom.geom_type == "GeometryCollection":
+        parts = []
+        for item in geom.geoms:
+            parts.extend(_iter_line_parts(item))
+        return parts
+    return []
+
+
+def _build_unit_ctx(gdf):
+    crs = unit_conversion.require_crs(gdf, "QC report checks")
+    reference_geom = None if gdf.empty else gdf.unary_union.envelope
+    return unit_conversion.build_linear_unit_context(crs, reference_geom)
+
+
+def _point_distance_m(point_a, point_b, unit_ctx):
+    if unit_ctx["is_geographic"]:
+        point_a_m = Point(unit_ctx["to_metric"].transform(point_a.x, point_a.y))
+        point_b_m = Point(unit_ctx["to_metric"].transform(point_b.x, point_b.y))
+        return float(point_a_m.distance(point_b_m))
+    return float(point_a.distance(point_b)) * float(unit_ctx["unit_factor"])
+
+
+def _segment_length_m(coord_a, coord_b, unit_ctx):
+    seg = LineString([coord_a, coord_b])
+    return unit_conversion.geometry_length_meters(seg, unit_ctx)
+
+
+def _intersection_points(geom):
+    if geom is None or geom.is_empty:
+        return []
+    if isinstance(geom, Point):
+        return [geom]
+    if isinstance(geom, MultiPoint):
+        return [pt for pt in geom.geoms if pt is not None and not pt.is_empty]
+    if isinstance(geom, LineString):
+        if geom.length <= bt_const.SMALL_BUFFER:
+            return []
+        return [geom.interpolate(0.5, normalized=True)]
+    if isinstance(geom, MultiLineString):
+        points = []
+        for part in geom.geoms:
+            points.extend(_intersection_points(part))
+        return points
+    if isinstance(geom, GeometryCollection):
+        points = []
+        for part in geom.geoms:
+            points.extend(_intersection_points(part))
+        return points
+    if hasattr(geom, "representative_point"):
+        return [geom.representative_point()]
+    return []
+
+
+def _overlap_midpoints_and_lengths(geom, unit_ctx):
+    if geom is None or geom.is_empty:
+        return []
+
+    items = []
+    if isinstance(geom, LineString):
+        length_m = unit_conversion.geometry_length_meters(geom, unit_ctx)
+        if length_m > bt_const.SMALL_BUFFER:
+            items.append((geom.interpolate(0.5, normalized=True), float(length_m)))
+        return items
+
+    if isinstance(geom, MultiLineString):
+        for part in geom.geoms:
+            items.extend(_overlap_midpoints_and_lengths(part, unit_ctx))
+        return items
+
+    if isinstance(geom, GeometryCollection):
+        for part in geom.geoms:
+            items.extend(_overlap_midpoints_and_lengths(part, unit_ctx))
+        return items
+
+    return items
+
+
+def _dedupe_records(records, precision=9):
+    deduped = []
+    seen = set()
+    for rec in records:
+        pt = rec["geometry"]
+        key = (
+            rec["issue_type"],
+            int(rec["line_id"]),
+            -1 if rec["line_id_2"] is None else int(rec["line_id_2"]),
+            round(float(pt.x), precision),
+            round(float(pt.y), precision),
+            round(float(rec["value"]), 6),
+            round(float(rec["threshold"]), 6),
+        )
+        if key in seen:
+            continue
+        seen.add(key)
+        deduped.append(rec)
+    return deduped
+
+
+def check_short_lines(gdf, min_length_m, unit_ctx):
+    threshold = float(min_length_m)
+    records = []
+    for line_id, geom in enumerate(gdf.geometry):
+        for part in _iter_line_parts(geom):
+            length_m = unit_conversion.geometry_length_meters(part, unit_ctx)
+            if length_m < threshold:
+                records.append(
+                    {
+                        "issue_type": "short_line",
+                        "description": f"Line length {length_m:.3f}m is below minimum {threshold:.3f}m",
+                        "line_id": int(line_id),
+                        "line_id_2": None,
+                        "value": float(length_m),
+                        "threshold": threshold,
+                        "geometry": part.interpolate(0.5, normalized=True),
+                    }
+                )
+    return _dedupe_records(records)
+
+
+def check_close_vertices(gdf, close_distance_m, unit_ctx):
+    threshold = float(close_distance_m)
+    records = []
+    for line_id, geom in enumerate(gdf.geometry):
+        for part in _iter_line_parts(geom):
+            coords = list(part.coords)
+            if len(coords) < 2:
+                continue
+            for i in range(1, len(coords)):
+                dist_m = _segment_length_m(coords[i - 1], coords[i], unit_ctx)
+                if bt_const.SMALL_BUFFER < dist_m <= threshold:
+                    records.append(
+                        {
+                            "issue_type": "close_vertices",
+                            "description": (
+                                f"Consecutive vertices are {dist_m:.3f}m apart; threshold {threshold:.3f}m"
+                            ),
+                            "line_id": int(line_id),
+                            "line_id_2": None,
+                            "value": float(dist_m),
+                            "threshold": threshold,
+                            "geometry": Point(coords[i]),
+                        }
+                    )
+    return _dedupe_records(records)
+
+
+def check_unsnapped_endpoints(gdf, snap_tolerance_m, unit_ctx):
+    threshold = float(snap_tolerance_m)
+    records = []
+
+    endpoints = []
+    for line_id, geom in enumerate(gdf.geometry):
+        for part in _iter_line_parts(geom):
+            coords = list(part.coords)
+            if len(coords) < 2:
+                continue
+            endpoints.append({"line_id": int(line_id), "point": Point(coords[0])})
+            endpoints.append({"line_id": int(line_id), "point": Point(coords[-1])})
+
+    if len(endpoints) < 2:
+        return records
+
+    if unit_ctx["is_geographic"]:
+        candidates = [
+            (i, j)
+            for i in range(len(endpoints))
+            for j in range(i + 1, len(endpoints))
+            if endpoints[i]["line_id"] != endpoints[j]["line_id"]
+        ]
+    else:
+        threshold_native = unit_conversion.meters_to_native_units(threshold, unit_ctx)
+        points = gpd.GeoSeries([ep["point"] for ep in endpoints], crs=gdf.crs)
+        sindex = points.sindex
+        candidates = []
+        for i, ep in enumerate(endpoints):
+            bounds = ep["point"].buffer(threshold_native).bounds
+            for j in sindex.intersection(bounds):
+                if j <= i:
+                    continue
+                if ep["line_id"] == endpoints[j]["line_id"]:
+                    continue
+                candidates.append((i, int(j)))
+
+    for i, j in candidates:
+        ep_a = endpoints[i]
+        ep_b = endpoints[j]
+        dist_m = _point_distance_m(ep_a["point"], ep_b["point"], unit_ctx)
+        if dist_m <= bt_const.SMALL_BUFFER or dist_m > threshold:
+            continue
+
+        line_id_a = min(ep_a["line_id"], ep_b["line_id"])
+        line_id_b = max(ep_a["line_id"], ep_b["line_id"])
+        records.append(
+            {
+                "issue_type": "unsnapped_endpoint",
+                "description": (
+                    f"Endpoints are close ({dist_m:.3f}m) but not snapped (threshold {threshold:.3f}m)"
+                ),
+                "line_id": int(line_id_a),
+                "line_id_2": int(line_id_b),
+                "value": float(dist_m),
+                "threshold": threshold,
+                "geometry": ep_a["point"],
+            }
+        )
+
+    return _dedupe_records(records)
+
+
+def check_self_crossing(gdf):
+    records = []
+    threshold = 0.0
+    for line_id, geom in enumerate(gdf.geometry):
+        for part in _iter_line_parts(geom):
+            if part.is_simple:
+                continue
+
+            coords = list(part.coords)
+            if len(coords) < 4:
+                continue
+
+            segments = []
+            for i in range(len(coords) - 1):
+                seg = LineString([coords[i], coords[i + 1]])
+                if seg.length > bt_const.SMALL_BUFFER:
+                    segments.append((i, seg))
+
+            seg_count = len(segments)
+            for i in range(seg_count):
+                idx_a, seg_a = segments[i]
+                for j in range(i + 1, seg_count):
+                    idx_b, seg_b = segments[j]
+
+                    if abs(idx_a - idx_b) <= 1:
+                        continue
+                    if idx_a == 0 and idx_b == len(coords) - 2 and Point(coords[0]).equals(Point(coords[-1])):
+                        continue
+
+                    inter = seg_a.intersection(seg_b)
+                    if inter is None or inter.is_empty:
+                        continue
+
+                    for pt in _intersection_points(inter):
+                        records.append(
+                            {
+                                "issue_type": "self_crossing",
+                                "description": "Line has self-crossing or self-touching segments",
+                                "line_id": int(line_id),
+                                "line_id_2": None,
+                                "value": 0.0,
+                                "threshold": threshold,
+                                "geometry": pt,
+                            }
+                        )
+
+    return _dedupe_records(records)
+
+
+def check_overlapping_lines(gdf):
+    records = []
+    threshold = 0.0
+
+    lines = []
+    for line_id, geom in enumerate(gdf.geometry):
+        for part in _iter_line_parts(geom):
+            lines.append({"line_id": int(line_id), "geometry": part})
+
+    if len(lines) < 2:
+        return records
+
+    unit_ctx = _build_unit_ctx(gdf)
+
+    line_gdf = gpd.GeoDataFrame(lines, geometry="geometry", crs=gdf.crs)
+    sindex = line_gdf.sindex
+
+    for i, row in line_gdf.iterrows():
+        geom_i = row.geometry
+        for j in sindex.intersection(geom_i.bounds):
+            j = int(j)
+            if j <= i:
+                continue
+            other = line_gdf.iloc[j]
+            if int(other["line_id"]) == int(row["line_id"]):
+                continue
+
+            inter = geom_i.intersection(other.geometry)
+            if inter is None or inter.is_empty:
+                continue
+
+            for pt, overlap_len_m in _overlap_midpoints_and_lengths(inter, unit_ctx):
+                line_id_a = min(int(row["line_id"]), int(other["line_id"]))
+                line_id_b = max(int(row["line_id"]), int(other["line_id"]))
+                records.append(
+                    {
+                        "issue_type": "overlap",
+                        "description": f"Lines share an overlapping segment ({overlap_len_m:.3f}m)",
+                        "line_id": line_id_a,
+                        "line_id_2": line_id_b,
+                        "value": float(overlap_len_m),
+                        "threshold": threshold,
+                        "geometry": pt,
+                    }
+                )
+
+    return _dedupe_records(records)
+
+
+def generate_qc_report(gdf, min_length_m, close_distance_m, snap_tolerance_m):
+    if gdf is None:
+        gdf = gpd.GeoDataFrame(geometry=[])
+
+    gdf = gdf.reset_index(drop=True)
+    if gdf.empty:
+        issues_gdf = gpd.GeoDataFrame(
+            {col: [] for col in ISSUE_COLUMNS if col != "geometry"},
+            geometry=gpd.GeoSeries([], crs=gdf.crs),
+            crs=gdf.crs,
+        )
+        summary = {
+            "short_line": 0,
+            "close_vertices": 0,
+            "unsnapped_endpoint": 0,
+            "self_crossing": 0,
+            "overlap": 0,
+            "total": 0,
+        }
+        return issues_gdf, summary
+
+    unit_ctx = _build_unit_ctx(gdf)
+
+    short_line = check_short_lines(gdf, min_length_m=min_length_m, unit_ctx=unit_ctx)
+    close_vertices = check_close_vertices(gdf, close_distance_m=close_distance_m, unit_ctx=unit_ctx)
+    unsnapped_endpoint = check_unsnapped_endpoints(
+        gdf,
+        snap_tolerance_m=snap_tolerance_m,
+        unit_ctx=unit_ctx,
+    )
+    self_crossing = check_self_crossing(gdf)
+    overlap = check_overlapping_lines(gdf)
+
+    all_issues = short_line + close_vertices + unsnapped_endpoint + self_crossing + overlap
+
+    if all_issues:
+        issues_gdf = gpd.GeoDataFrame(all_issues, columns=ISSUE_COLUMNS, geometry="geometry", crs=gdf.crs)
+    else:
+        issues_gdf = gpd.GeoDataFrame(
+            {col: [] for col in ISSUE_COLUMNS if col != "geometry"},
+            geometry=gpd.GeoSeries([], crs=gdf.crs),
+            crs=gdf.crs,
+        )
+
+    summary = {
+        "short_line": len(short_line),
+        "close_vertices": len(close_vertices),
+        "unsnapped_endpoint": len(unsnapped_endpoint),
+        "self_crossing": len(self_crossing),
+        "overlap": len(overlap),
+    }
+    summary["total"] = int(sum(summary.values()))
+
+    return issues_gdf, summary

{beratools-0.3.10 → beratools-0.4.0}/beratools/core/algo_common.py

@@ -39,6 +39,30 @@ DISTANCE_THRESHOLD = 2  # 1 meter for intersection neighborhood
 logger = logging.getLogger(__name__)
 
 
+def log_file_only(message, level=logging.INFO, logger_name=None):
+    """Log a message to file handlers only, skipping console/gui handlers."""
+    target_logger = logging.getLogger(logger_name) if logger_name else logging.getLogger(__name__)
+    record = target_logger.makeRecord(
+        name=target_logger.name,
+        level=level,
+        fn="",
+        lno=0,
+        msg=message,
+        args=(),
+        exc_info=None,
+    )
+
+    root_logger = logging.getLogger()
+    wrote_to_file = False
+    for handler in root_logger.handlers:
+        if isinstance(handler, logging.FileHandler):
+            handler.handle(record)
+            wrote_to_file = True
+
+    if not wrote_to_file:
+        target_logger.log(level, message)
+
+
 def process_single_item(cls_obj):
     """
     Process a class object for universal multiprocessing.

{beratools-0.3.10 → beratools-0.4.0}/beratools/core/logger.py

@@ -66,6 +66,7 @@ class Logger(object):
         if flush:
             for handler in self.logger.handlers:
                 handler.flush()
+            sys.stdout.flush()
 
     def setup_logger(self):
         # Change root logger level from WARNING (default) to NOTSET

beratools-0.4.0/beratools/core/tool_geo_simplify.py

@@ -0,0 +1,89 @@
+"""Tooling helpers for invoking geo-simplify binaries."""
+
+from __future__ import annotations
+
+import os
+import platform
+import stat
+import subprocess
+import tempfile
+from pathlib import Path
+
+
+def validate_diameter(value):
+    try:
+        diameter = float(value)
+    except (TypeError, ValueError):
+        raise ValueError("simplify_diameter must be a number >= 0.")
+
+    if diameter < 0:
+        raise ValueError("simplify_diameter must be >= 0.")
+
+    return diameter
+
+
+def build_temp_output_same_folder(out_file, suffix=".gpkg", prefix="centerline_tmp_"):
+    out_path = Path(out_file)
+    out_dir = out_path.parent if out_path.parent else Path(".")
+    out_dir.mkdir(parents=True, exist_ok=True)
+    fd, temp_path = tempfile.mkstemp(prefix=prefix, suffix=suffix, dir=out_dir)
+    os.close(fd)
+    return Path(temp_path)
+
+
+def run_reduce_bend(input_file, in_layer, output_file, out_layer, diameter, smooth_line=True):
+    binary_path = _geo_simplify_resolve_binary_path()
+    command = [
+        str(binary_path),
+        "reduce-bend",
+        "--input",
+        str(input_file),
+        "--in-layer",
+        in_layer,
+        "--output",
+        output_file,
+        "--diameter",
+        str(diameter),
+    ]
+
+    if smooth_line:
+        command.append("--smooth-line")
+
+    if out_layer:
+        command.extend(["--out-layer", out_layer])
+
+    result = subprocess.run(command, capture_output=True, text=True)
+    if result.returncode != 0:
+        raise RuntimeError(
+            "geo-simplify reduce-bend failed "
+            f"(exit code {result.returncode})\n"
+            f"Command: {' '.join(command)}\n"
+            f"stdout:\n{result.stdout}\n"
+            f"stderr:\n{result.stderr}"
+        )
+
+
+def _geo_simplify_resolve_binary_path():
+    external_dir = Path(__file__).resolve().parents[1] / "external" / "geo_simplify"
+    system_name = platform.system()
+
+    if system_name == "Windows":
+        binary_path = external_dir / "geo-simplify-win-x64.exe"
+    elif system_name == "Linux":
+        binary_path = external_dir / "geo-simplify-linux-x64"
+    else:
+        raise RuntimeError(f"Centerline simplify is not supported on OS: {system_name}")
+
+    if not binary_path.exists():
+        raise FileNotFoundError(f"Missing geo-simplify binary: {binary_path}")
+
+    if system_name == "Linux":
+        _geo_simplify_ensure_executable(binary_path)
+
+    return binary_path
+
+
+def _geo_simplify_ensure_executable(binary_path):
+    mode = binary_path.stat().st_mode
+    if not (mode & stat.S_IXUSR):
+        binary_path.chmod(mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)