BERATools 0.3.8__tar.gz → 0.3.9__tar.gz

{beratools-0.3.8 → beratools-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: BERATools
-Version: 0.3.8
+Version: 0.3.9
 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.8 → beratools-0.3.9}/beratools/__init__.py

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

{beratools-0.3.8 → beratools-0.3.9}/beratools/core/algo_seed_line_correction.py

@@ -593,9 +593,7 @@ class SeedLineCorrection:
         return self.get_optimized_lines()
 
     def compute(self):
-        compute_processes = self.processes
-        if self.optimize_internal_vertices and (compute_processes is None or int(compute_processes) <= 0):
-            compute_processes = 1
+        compute_processes = self.processes if self.processes is not None else 0
 
         vertex_grp = bt_base.execute_multiprocessing(
             algo_common.process_single_item,

{beratools-0.3.8 → beratools-0.3.9}/beratools/gui/bt_data.py

@@ -426,6 +426,7 @@ class BTData(object):
         self.show_advanced = BT_SHOW_ADVANCED_OPTIONS
         self.selected_cpu_cores = -1
         self.recent_tool = None
+        self.last_browse_dir = None
         self.ascii_art = ""
         self.get_working_dir()
         self.get_user_folder()
@@ -457,6 +458,10 @@ class BTData(object):
         self.settings = self.settings_manager.settings
         gui_settings = self.settings.get("gui_parameters", {})
         self.recent_tool = gui_settings.get("recent_tool", None)
+        if "last_browse_dir" in gui_settings and gui_settings["last_browse_dir"] is not None:
+            saved_dir = Path(gui_settings["last_browse_dir"]).expanduser()
+            if saved_dir.exists() and saved_dir.is_dir():
+                self.last_browse_dir = saved_dir.as_posix()
         self.load_gui_data()
         self.get_tool_history()
 
@@ -655,6 +660,24 @@ class BTData(object):
                 if not api_result:
                     self.recent_tool = None
 
+            if "last_browse_dir" in gui_settings and gui_settings["last_browse_dir"] is not None:
+                saved_dir = Path(gui_settings["last_browse_dir"]).expanduser()
+                if saved_dir.exists() and saved_dir.is_dir():
+                    self.last_browse_dir = saved_dir.as_posix()
+
+    def set_last_browse_dir(self, path_str):
+        if not path_str:
+            return
+
+        browse_dir = Path(path_str).expanduser()
+        if browse_dir.exists() and browse_dir.is_dir():
+            new_browse_dir = browse_dir.as_posix()
+            self.save_setting("last_browse_dir", new_browse_dir)
+            self.last_browse_dir = new_browse_dir
+
+    def get_last_browse_dir(self):
+        return self.last_browse_dir
+
     def load_gui_data(self):
         gui_settings = {}
         if not self.gui_setting_file.exists():

{beratools-0.3.8 → beratools-0.3.9}/beratools/gui/bt_gui_main.py

@@ -17,6 +17,7 @@ import json
 import os
 import platform
 import shlex
+import signal
 import sys
 import webbrowser
 from pathlib import Path
@@ -211,7 +212,6 @@ class ClickSlider(QtWidgets.QSlider):
         if event.button() == QtCore.Qt.LeftButton:
             val = self.pixel_pos_to_range_value(event.pos())
             self.setValue(val)
-            self.sliderMoved.emit(val)
 
     def pixel_pos_to_range_value(self, pos):
         opt = QtWidgets.QStyleOptionSlider()
@@ -262,12 +262,13 @@ class BTSlider(QtWidgets.QWidget):
         layout.addWidget(self.slider)
         self.setLayout(layout)
 
-        self.slider.sliderMoved.connect(self.slider_moved)
+        self.slider.valueChanged.connect(self.slider_moved)
 
     def slider_moved(self, value):
-        bt.set_selected_cpu_cores(value)
-        QtWidgets.QToolTip.showText(QtGui.QCursor.pos(), f"{value}")
-        self.label.setText(self.generate_label_text())
+        actual_value = int(self.slider.value())
+        bt.set_selected_cpu_cores(actual_value)
+        QtWidgets.QToolTip.showText(QtGui.QCursor.pos(), f"{actual_value}")
+        self.label.setText(self.generate_label_text(actual_value))
 
     def generate_label_text(self, value=None):
         if not value:
@@ -362,7 +363,6 @@ class MainWindow(QtWidgets.QMainWindow):
         self.action_bera_tools_guide = None
         self.action_about_bera_tools = None
         self._create_help_menu()
-        self.working_dir = bt.work_dir
         self.tool_api = None
         self.tool_name = "Centerline"
         self.recent_tool = bt.recent_tool
@@ -435,7 +435,13 @@ class MainWindow(QtWidgets.QMainWindow):
 
         # ToolWidgets
         tool_args = bt.get_bera_tool_args(self.tool_name)
-        self.tool_widget = ToolWidgets(self.recent_tool, tool_args, bt.show_advanced)
+        self.tool_widget = ToolWidgets(self.recent_tool, tool_args, bt.show_advanced, bt_data_obj=bt)
+        self.tool_scroll_area = QtWidgets.QScrollArea()
+        self.tool_scroll_area.setWidgetResizable(True)
+        self.tool_scroll_area.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded)
+        self.tool_scroll_area.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded)
+        self.tool_scroll_area.setFrameShape(QtWidgets.QFrame.NoFrame)
+        self.tool_scroll_area.setWidget(self.tool_widget)
 
         # bottom buttons
         slider = BTSlider(bt.selected_cpu_cores, bt.max_cpu_cores)
@@ -460,7 +466,7 @@ class MainWindow(QtWidgets.QMainWindow):
 
         self.top_right_layout = QtWidgets.QVBoxLayout()
         self.top_right_layout.addLayout(self.btn_layout_top)
-        self.top_right_layout.addWidget(self.tool_widget)
+        self.top_right_layout.addWidget(self.tool_scroll_area)
         self.top_right_layout.addLayout(btn_layout_bottom)
         tool_widget_grp = QtWidgets.QGroupBox("Tool")
         tool_widget_grp.setLayout(self.top_right_layout)
@@ -469,6 +475,8 @@ class MainWindow(QtWidgets.QMainWindow):
         self.text_edit = QtWidgets.QPlainTextEdit()
         self.text_edit.setFont(QtGui.QFont("Consolas", 9))
         self.text_edit.setReadOnly(True)
+        self.text_edit.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
+        self.text_edit.customContextMenuRequested.connect(self._show_log_context_menu)
         self.print_about()
 
         # progress bar
@@ -549,10 +557,11 @@ class MainWindow(QtWidgets.QMainWindow):
         self.btn_layout_top.itemAt(0).widget().setText(self.tool_name)
 
         # update tool widget
-        self.tool_widget = ToolWidgets(self.tool_name, tool_args, bt.show_advanced)
-        widget = self.top_right_layout.itemAt(1).widget()
-        self.top_right_layout.removeWidget(widget)
-        self.top_right_layout.insertWidget(1, self.tool_widget)
+        self.tool_widget = ToolWidgets(self.tool_name, tool_args, bt.show_advanced, bt_data_obj=bt)
+        old_widget = self.tool_scroll_area.takeWidget()
+        if old_widget is not None:
+            old_widget.deleteLater()
+        self.tool_scroll_area.setWidget(self.tool_widget)
         self.top_right_layout.update()
 
     def save_tool_parameter(self):
@@ -629,6 +638,17 @@ class MainWindow(QtWidgets.QMainWindow):
         self.text_edit.insertPlainText(text)
         self.text_edit.moveCursor(QtGui.QTextCursor.End)
 
+    def clear_log_messages(self):
+        self.text_edit.clear()
+
+    def _show_log_context_menu(self, pos):
+        menu = self.text_edit.createStandardContextMenu()
+        menu.addSeparator()
+        clear_action = menu.addAction("Clear Messages")
+        action = menu.exec_(self.text_edit.mapToGlobal(pos))
+        if action == clear_action:
+            self.clear_log_messages()
+
     def print_line_to_output(self, text, tag=None):
         self.text_edit.moveCursor(QtGui.QTextCursor.End)
         self.text_edit.insertPlainText(text + "\n")
@@ -652,6 +672,8 @@ class MainWindow(QtWidgets.QMainWindow):
 
         self.tool_widget.adjustSize()
         self.tool_widget.updateGeometry()
+        self.tool_scroll_area.widget().adjustSize()
+        self.tool_scroll_area.viewport().update()
         self.top_right_layout.activate()
         self.top_right_layout.update()
 
@@ -807,4 +829,14 @@ def runner():
                 pass
 
     QtCore.QTimer.singleShot(100, signal_ready)
+
+    # Allow Ctrl+C in the terminal to quit the application.
+    # Qt overrides Python's SIGINT handler; use a custom handler that
+    # calls app.quit() and a timer to let Python process signals.
+    signal.signal(signal.SIGINT, lambda *_: app.quit())
+    timer = QtCore.QTimer(app)
+    timer.start(500)
+    timer.timeout.connect(lambda: None)
+    app.aboutToQuit.connect(timer.stop)
+
     app.exec_()

{beratools-0.3.8 → beratools-0.3.9}/beratools/gui/tool_widgets.py

@@ -30,6 +30,8 @@ from beratools.gui.geometry_types import (
 )
 
 BT_LABEL_MIN_WIDTH = 130
+BT_WIDGET_MIN_HEIGHT = 36
+BT_NUMERIC_BOX_WIDTH = 160
 
 
 class ToolWidgets(QtWidgets.QWidget):
@@ -37,12 +39,13 @@ class ToolWidgets(QtWidgets.QWidget):
 
     signal_save_tool_params = QtCore.pyqtSignal(object)
 
-    def __init__(self, tool_name, tool_args, show_advanced, parent=None):
+    def __init__(self, tool_name, tool_args, show_advanced, bt_data_obj=None, parent=None):
         super(ToolWidgets, self).__init__(parent)
 
         self.tool_name = tool_name
         self.show_advanced = show_advanced
         self.current_tool_api = ""
+        self.bt_data = bt_data_obj
         self.widget_list = []
         self.ui_widget_list = []
         self.widgets_by_variable = {}
@@ -52,8 +55,14 @@ class ToolWidgets(QtWidgets.QWidget):
 
         self.create_widgets(tool_args)
         layout = QtWidgets.QVBoxLayout()
+        layout.setAlignment(QtCore.Qt.AlignTop)
+        layout.setSpacing(8)
 
         for item in self.ui_widget_list:
+            item_layout = self._get_widget_layout(item)
+            if item_layout is not None:
+                m = item_layout.contentsMargins()
+                item_layout.setContentsMargins(m.left(), 0, m.right(), 0)
             layout.addWidget(item)
 
         self.save_button = QtWidgets.QPushButton("Save Parameters")
@@ -92,7 +101,7 @@ class ToolWidgets(QtWidgets.QWidget):
             widget = None
 
             if "ExistingFile" in pt or "NewFile" in pt or "Directory" in pt:
-                widget = FileSelector(json_str, None)
+                widget = FileSelector(json_str, None, bt_data_obj=self.bt_data)
             elif "FileList" in pt:
                 widget = MultiFileSelector(json_str, None)
             elif "Boolean" in pt:
@@ -135,6 +144,7 @@ class ToolWidgets(QtWidgets.QWidget):
 
             # hide optional widgets
             if widget:
+                widget.setMinimumHeight(BT_WIDGET_MIN_HEIGHT)
                 self._set_widget_tooltip(widget)
                 widget.depends_on = p.get("depends_on")
                 widget.unit = p.get("unit", "")
@@ -214,7 +224,6 @@ class ToolWidgets(QtWidgets.QWidget):
         self.ui_widget_list = [widget for widget in self.widget_list if widget]
         self._depends_on_specs = {}
         self._inline_controllers = {}
-        inline_controller_widgets = []
 
         for widget in self.widget_list:
             if not widget:
@@ -266,43 +275,61 @@ class ToolWidgets(QtWidgets.QWidget):
                     )
                 elif self._attach_inline_widget(controller_widgets[0], widget):
                     self._inline_controllers[controller_vars[0]] = widget.variable
-                    inline_controller_widgets.append(controller_widgets[0])
                     if widget in self.ui_widget_list:
                         self.ui_widget_list.remove(widget)
-
             self._depends_on_specs[widget.variable] = depends_on
             for controller_widget in controller_widgets:
                 self._connect_widget_change_signal(controller_widget, self._update_dependency_states)
 
-        self._align_inline_controller_checkboxes(inline_controller_widgets)
+        self._align_all_labels()
         self._update_dependency_states()
 
-    @staticmethod
-    def _align_inline_controller_checkboxes(controller_widgets):
-        unique_widgets = []
-        seen_ids = set()
-        for widget in controller_widgets:
-            widget_id = id(widget)
-            if widget_id in seen_ids:
-                continue
-            seen_ids.add(widget_id)
-            unique_widgets.append(widget)
-
-        if not unique_widgets:
-            return
+    def _align_all_labels(self):
+        """Set every widget's label (QLabel or QCheckBox) to the same fixed width
+        so that all input controls start at the same horizontal position.
+        Inline widgets are skipped — their label is hidden and alignment is
+        governed by the controller checkbox they are embedded in."""
+        inlined_vars = set(self._inline_controllers.values())
+        anchor_width = BT_LABEL_MIN_WIDTH
+        checkbox_indicator_overhead = 0
 
-        max_width = 0
-        for controller in unique_widgets:
-            if isinstance(controller, BooleanInput):
-                max_width = max(max_width, controller.checkbox.sizeHint().width())
+        # First pass: measure natural widths of all labels (skip inlined widgets)
+        for widget in self.widget_list:
+            if not widget or widget.variable in inlined_vars:
+                continue
+            label = getattr(widget, "label", None)
+            if label is None:
+                continue
 
-        if max_width <= 0:
-            return
+            if isinstance(widget, BooleanInput):
+                text_width = widget.checkbox.fontMetrics().horizontalAdvance(
+                    widget.checkbox.text()
+                )
+                if not checkbox_indicator_overhead:
+                    style = widget.checkbox.style()
+                    opt = QtWidgets.QStyleOptionButton()
+                    opt.initFrom(widget.checkbox)
+                    checkbox_indicator_overhead = (
+                        style.pixelMetric(
+                            QtWidgets.QStyle.PM_IndicatorWidth, opt, widget.checkbox
+                        )
+                        + style.pixelMetric(
+                            QtWidgets.QStyle.PM_CheckBoxLabelSpacing, opt, widget.checkbox
+                        )
+                    )
+                anchor_width = max(anchor_width, text_width + checkbox_indicator_overhead + 8)
+            elif isinstance(label, QtWidgets.QLabel):
+                anchor_width = max(anchor_width, label.sizeHint().width())
 
-        aligned_width = max_width + 8
-        for controller in unique_widgets:
-            if isinstance(controller, BooleanInput):
-                controller.checkbox.setMinimumWidth(aligned_width)
+        # Second pass: apply the uniform width (skip inlined widgets)
+        for widget in self.widget_list:
+            if not widget or widget.variable in inlined_vars:
+                continue
+            label = getattr(widget, "label", None)
+            if label is None:
+                continue
+            label.setMinimumWidth(anchor_width)
+            label.setMaximumWidth(anchor_width)
 
     def _attach_inline_widget(self, controller_widget, dependent_widget):
         controller_layout = self._get_widget_layout(controller_widget)
@@ -310,12 +337,15 @@ class ToolWidgets(QtWidgets.QWidget):
             return False
 
         dependent_widget.set_inline_mode(getattr(dependent_widget, "unit", ""))
+        controller_layout.setAlignment(QtCore.Qt.AlignVCenter)
+        # Remove trailing stretch so the inline widget can expand to fill available space
         insert_index = controller_layout.count()
         if insert_index > 0:
             last_item = controller_layout.itemAt(insert_index - 1)
             if last_item and last_item.spacerItem() is not None:
+                controller_layout.removeItem(last_item)
                 insert_index -= 1
-        controller_layout.insertWidget(insert_index, dependent_widget)
+        controller_layout.insertWidget(insert_index, dependent_widget, 1)
         return True
 
     @staticmethod
@@ -452,8 +482,9 @@ class FileSelector(QtWidgets.QWidget):
                     return True
         return False
 
-    def __init__(self, json_str, parent=None):
+    def __init__(self, json_str, parent=None, bt_data_obj=None):
         super(FileSelector, self).__init__(parent)
+        self.bt_data = bt_data_obj
         self.selected_layer = ""
         self.parse_params(json_str)
         self.initialize_values()
@@ -774,8 +805,10 @@ class FileSelector(QtWidgets.QWidget):
         dialog.setViewMode(QtWidgets.QFileDialog.Detail)
         # Handle both string and dict values (for vector files)
         path_value = self.value.get("path", "") if isinstance(self.value, dict) else self.value
-        if path_value:
-            dialog.setDirectory(str(Path(path_value).parent))
+        start_dir, start_dir_source = self._resolve_dialog_start_directory(path_value)
+        if start_dir:
+            dialog.setDirectory(str(start_dir))
+        if path_value and start_dir_source == "path_value":
             dialog.selectFile(Path(path_value).name)
         dialog.setNameFilter(file_types)
         if "ExistingFile" in self.parameter_type:
@@ -784,6 +817,36 @@ class FileSelector(QtWidgets.QWidget):
             dialog.setFileMode(QtWidgets.QFileDialog.AnyFile)
         return dialog
 
+    def _resolve_dialog_start_directory(self, path_value):
+        if self.bt_data:
+            last_browse_dir = self.bt_data.get_last_browse_dir()
+            if last_browse_dir:
+                browse_dir = Path(last_browse_dir).expanduser()
+                if browse_dir.exists() and browse_dir.is_dir():
+                    return browse_dir, "last_browse"
+
+        if path_value:
+            current_path = Path(path_value).expanduser()
+            if current_path.exists():
+                if current_path.is_dir():
+                    return current_path, "path_value"
+                return current_path.parent, "path_value"
+
+            parent_dir = current_path.parent
+            if parent_dir.exists() and parent_dir.is_dir():
+                return parent_dir, "path_value"
+
+        return Path.home(), "home"
+
+    def _save_last_browse_dir(self, selected_path):
+        if not self.bt_data:
+            return
+
+        selected = Path(selected_path).expanduser()
+        browse_dir = selected if selected.is_dir() else selected.parent
+        if browse_dir.exists() and browse_dir.is_dir():
+            self.bt_data.set_last_browse_dir(str(browse_dir))
+
     def process_selected_file(self, result, dialog):
         """Handle file name modification, extension adding, and GeoPackage logic."""
         base_name = str(Path(result).with_suffix(""))
@@ -829,6 +892,7 @@ class FileSelector(QtWidgets.QWidget):
                 return
             result = file_names[0]
             result = self.process_selected_file(result, dialog)
+            self._save_last_browse_dir(result)
             self.handle_gpkg_selection(result)
         except Exception as e:
             print(e)
@@ -1066,13 +1130,17 @@ class OptionsInput(QtWidgets.QWidget):
         self.combobox.addItems(self.option_list)
         self.combobox.setCurrentIndex(default_index)
 
+        self.combobox.setFixedWidth(BT_NUMERIC_BOX_WIDTH)
         self.layout = QtWidgets.QHBoxLayout()
+        self.layout.setAlignment(QtCore.Qt.AlignLeft)
         self.layout.addWidget(self.label)
         self.layout.addWidget(self.combobox)
         self.setLayout(self.layout)
 
     def set_inline_mode(self, unit=""):
         self.label.setVisible(False)
+        self.label.setMinimumWidth(0)
+        self.label.setMaximumWidth(0)
         self.layout.setContentsMargins(0, 0, 0, 0)
 
     def selection_change(self, i):
@@ -1146,7 +1214,10 @@ class NumericInput(QtWidgets.QWidget):
             except (ValueError, TypeError):
                 self.data_input.setValue(0)
             self.data_input.valueChanged.connect(self.update_value)
+            self.data_input.setSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed)
+            self.data_input.setFixedWidth(BT_NUMERIC_BOX_WIDTH)
         self.layout = QtWidgets.QHBoxLayout()
+        self.layout.setAlignment(QtCore.Qt.AlignLeft)
         self.layout.addWidget(self.label)
         self.layout.addWidget(self.data_input)
         self.layout.addWidget(self.unit_label)
@@ -1157,7 +1228,10 @@ class NumericInput(QtWidgets.QWidget):
 
     def set_inline_mode(self, unit=""):
         self.label.setVisible(False)
+        self.label.setMinimumWidth(0)
+        self.label.setMaximumWidth(0)
         self.layout.setContentsMargins(0, 0, 0, 0)
+        self.layout.setAlignment(QtCore.Qt.AlignLeft)
         if unit:
             self.unit = unit
             self.unit_label.setText(unit)

{beratools-0.3.8 → beratools-0.3.9}/beratools/tools/check_seed_line.py

@@ -521,12 +521,14 @@ def _choose_anchor(endpoint_a, endpoint_b):
     line_id_b = _parse_line_id(endpoint_b.get("line_id"))
 
     score_a = (
+        -int(endpoint_a.get("degree", 0)),
         -endpoint_a["line_length"],
         0 if line_id_a is not None else 1,
         line_id_a if line_id_a is not None else float("inf"),
         endpoint_a["discovery_order"],
     )
     score_b = (
+        -int(endpoint_b.get("degree", 0)),
         -endpoint_b["line_length"],
         0 if line_id_b is not None else 1,
         line_id_b if line_id_b is not None else float("inf"),
@@ -584,7 +586,7 @@ def _snap_close_endpoints(gdf, tolerance):
     if len(endpoints) < 2:
         return gdf
 
-    candidate_pairs = []
+    neighbor_graph = {idx: set() for idx in range(len(endpoints))}
     for i in range(len(endpoints)):
         for j in range(i + 1, len(endpoints)):
             ep_i = endpoints[i]
@@ -605,34 +607,55 @@ def _snap_close_endpoints(gdf, tolerance):
             if dist <= close_threshold:
                 continue
             if dist <= snap_threshold:
-                candidate_pairs.append((dist, ep_i, ep_j))
+                neighbor_graph[i].add(j)
+                neighbor_graph[j].add(i)
 
-    candidate_pairs.sort(
-        key=lambda x: (
-            x[0],
-            min(x[1]["discovery_order"], x[2]["discovery_order"]),
-            max(x[1]["discovery_order"], x[2]["discovery_order"]),
-        )
-    )
+    if not any(neighbor_graph.values()):
+        return gdf
 
-    updates = {}
-    moved_keys = set()
-    anchor_locked_keys = set()
-    for _, ep_i, ep_j in candidate_pairs:
-        anchor, mover = _choose_anchor(ep_i, ep_j)
-        anchor_key = (anchor["gdf_index"], anchor["endpoint_idx"])
-        mover_key = (mover["gdf_index"], mover["endpoint_idx"])
-
-        if mover_key in moved_keys:
-            continue
-        if mover_key in anchor_locked_keys:
-            continue
-        if anchor_key in moved_keys:
+    for idx, endpoint in enumerate(endpoints):
+        endpoint["degree"] = len(neighbor_graph[idx])
+
+    visited = set()
+    components = []
+    active_nodes = [idx for idx, neighbors in neighbor_graph.items() if neighbors]
+    for node in active_nodes:
+        if node in visited:
             continue
+        stack = [node]
+        component = []
+        while stack:
+            curr = stack.pop()
+            if curr in visited:
+                continue
+            visited.add(curr)
+            component.append(curr)
+            for neighbor in neighbor_graph[curr]:
+                if neighbor not in visited:
+                    stack.append(neighbor)
+
+        if len(component) > 1:
+            components.append(component)
+
+    if not components:
+        return gdf
 
-        updates[mover_key] = tuple(anchor["point"].coords[0])
-        moved_keys.add(mover_key)
-        anchor_locked_keys.add(anchor_key)
+    updates = {}
+    for component in components:
+        anchor_endpoint = endpoints[component[0]]
+        for idx in component[1:]:
+            candidate = endpoints[idx]
+            anchor_endpoint, _ = _choose_anchor(anchor_endpoint, candidate)
+
+        anchor_coord = tuple(anchor_endpoint["point"].coords[0])
+        anchor_key = (anchor_endpoint["gdf_index"], anchor_endpoint["endpoint_idx"])
+
+        for idx in component:
+            endpoint = endpoints[idx]
+            endpoint_key = (endpoint["gdf_index"], endpoint["endpoint_idx"])
+            if endpoint_key == anchor_key:
+                continue
+            updates[endpoint_key] = anchor_coord
 
     if not updates:
         return gdf
@@ -1038,6 +1061,8 @@ def check_seed_line(
             raise ValueError("Input line and raster CRS do not match.")
 
     gdf = gpd.read_file(in_file, layer=in_layer)
+    if config.clip_to_chm_footprint and in_raster and not _seedlines_within_chm_footprint(gdf, in_raster):
+        raise ValueError("Input line(s) do not overlap input raster.")
     if "fid" in gdf.columns:
         gdf = gdf.rename(columns={"fid": "orig_fid"})
     input_count = len(gdf)