segfix 0.1.0__py3-none-any.whl

segfix/__init__.py

@@ -0,0 +1,6 @@
+"""segfix — fix instance segmentation of tree point clouds."""
+
+from .model import NOISE, UNASSIGNED, PointCloud
+
+__all__ = ["PointCloud", "UNASSIGNED", "NOISE"]
+__version__ = "0.1.0"

segfix/analysis.py

@@ -0,0 +1,68 @@
+"""Segmentation-quality analysis: spatial neighbour queries.
+
+UI-agnostic, like :mod:`~segfix.operations`.  Point-set distances are
+approximated by sampling each tree down to a few thousand points and querying
+a KD-tree — exact enough for "does this touch?" questions at forest scale,
+and fast enough to run per keypress.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from .model import NOISE, UNASSIGNED, PointCloud
+
+_SAMPLE_CAP = 3000
+
+
+def _sample(rng, idx: np.ndarray, cap: int = _SAMPLE_CAP) -> np.ndarray:
+    if idx.size <= cap:
+        return idx
+    return rng.choice(idx, cap, replace=False)
+
+
+def neighbours_by_points(
+    cloud: PointCloud, tid: int, reach: float, rng=None
+) -> set[int]:
+    """IDs of trees whose points come within ``reach`` metres of tree
+    ``tid``'s points.
+
+    Bounding-box tests massively over-count neighbours in a closed canopy
+    (a tall tree's box spans its whole crown), so boxes are only used as a
+    prefilter; candidates are confirmed by sampled point-to-point distance.
+    """
+    from scipy.spatial import cKDTree
+
+    rng = rng or np.random.default_rng(0)
+    labels, coords = cloud.labels, cloud.coords
+    mine = np.flatnonzero(labels == tid)
+    if mine.size == 0:
+        return set()
+    lo = coords[mine].min(axis=0) - reach
+    hi = coords[mine].max(axis=0) + reach
+    # Per-axis chained test avoids two full (N, 3) boolean temporaries.
+    cx, cy, cz = coords[:, 0], coords[:, 1], coords[:, 2]
+    in_box = (
+        (cx >= lo[0]) & (cx <= hi[0])
+        & (cy >= lo[1]) & (cy <= hi[1])
+        & (cz >= lo[2]) & (cz <= hi[2])
+    )
+    in_box[mine] = False
+    # Everything below works off the in-box points only, so the per-candidate
+    # loop no longer rescans all N labels once per candidate.
+    box_idx = np.flatnonzero(in_box)
+    box_labels = labels[box_idx]
+    cand = np.unique(box_labels)
+    cand = cand[(cand != UNASSIGNED) & (cand != NOISE) & (cand != tid)]
+    if not cand.size:
+        return set()
+    kd = cKDTree(coords[_sample(rng, mine)])
+    out: set[int] = set()
+    for t in cand:
+        theirs = box_idx[box_labels == t]
+        d, _ = kd.query(
+            coords[_sample(rng, theirs)], k=1, distance_upper_bound=reach
+        )
+        if np.isfinite(d).any():
+            out.add(int(t))
+    return out

segfix/app.py

@@ -0,0 +1,280 @@
+"""Command-line entry point.
+
+``segfix`` always opens with a startup dialog to pick a recent project or
+import a new file — there's no way to pass a cloud path directly on the
+command line, so every session goes through the registry. See
+:mod:`registry`/:mod:`startup_ui`.
+
+Once a path is chosen it opens in the one editing mode: a table of every tree
+in the file, where double-clicking a row loads that tree plus its spatial
+neighbours rather than the whole cloud. See :mod:`treecatalog`/:mod:`scene_ui`.
+
+That mode needs to seek to an arbitrary point without parsing everything
+before it, so the accepted formats are the ones that store points as
+fixed-size records at a known offset: binary PLY and uncompressed LAS.
+arbor's ``.laz`` output is decompressed to ``.las`` on import (see
+:mod:`segfix.workspace`). :func:`segfix.io.load` rejects the rest.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+
+def _prefer_discrete_gpu() -> None:
+    """Best-effort: on a hybrid-graphics machine, point OpenGL/Direct3D at
+    the discrete GPU instead of whatever the platform defaults to (often
+    the weaker integrated one — see the "GPU:" status-bar label added by
+    :func:`viewer.add_gpu_status_widget` to confirm which one actually got
+    used). Detects hardware rather than hardcoding one machine's GPU model
+    name, never overrides a preference already set (env var on Linux, the
+    registry key on Windows), and never raises — worst case this is a
+    no-op and the platform default stands.
+
+    Must run before ``import napari`` (like the Wayland workaround below):
+    the Linux/WSL half relies on the underlying GL/EGL libraries not having
+    picked an adapter yet, which happens at first context creation, not at
+    process start — setting the env var any later risks losing the race
+    against whichever import gets there first. The Windows half doesn't
+    have that race (it's a registry key, not an env var) but only takes
+    effect from the *next* launch of this Python executable, not this one:
+    Windows reads a process's GPU preference at process creation, before
+    any of our code has had a chance to run.
+    """
+    try:
+        if sys.platform == "win32":
+            _prefer_discrete_gpu_windows()
+        elif sys.platform == "linux":
+            _prefer_discrete_gpu_linux()
+        # macOS: no per-process lever like the two above. Apple Silicon has
+        # a single GPU anyway; Intel-Mac dual-GPU switching is a system
+        # Energy Saver setting, not something a process can request.
+    except Exception:
+        pass  # detection failing should never block startup
+
+
+def _prefer_discrete_gpu_linux() -> None:
+    import os
+    import shutil
+    import subprocess
+
+    is_wsl = False
+    try:
+        with open("/proc/version", encoding="utf-8") as f:
+            is_wsl = "microsoft" in f.read().lower()
+    except OSError:
+        pass
+    has_nvidia = shutil.which("nvidia-smi") is not None and subprocess.run(
+        ["nvidia-smi", "-L"], capture_output=True, timeout=2
+    ).returncode == 0
+    if not has_nvidia:
+        return
+    if is_wsl:
+        # Mesa's D3D12 backend (the only GL path WSLg offers) matches this
+        # against the adapter names Windows exposes, substring not exact —
+        # so it still works if the discrete card is a different NVIDIA
+        # model than whatever machine this was tested on.
+        os.environ.setdefault("MESA_D3D12_DEFAULT_ADAPTER_NAME", "NVIDIA")
+    else:
+        # Native Linux NVIDIA Optimus/PRIME laptops: ask for the discrete
+        # GPU's GLX vendor lib instead of the integrated one.
+        os.environ.setdefault("__NV_PRIME_RENDER_OFFLOAD", "1")
+        os.environ.setdefault("__GLX_VENDOR_LIBRARY_NAME", "nvidia")
+
+
+def _prefer_discrete_gpu_windows() -> None:
+    """Set this Python executable's GPU preference to "High performance" in
+    the per-app registry key Settings > System > Display > Graphics also
+    writes to — the documented, vendor-agnostic way one process can ask
+    Windows for the discrete GPU without touching any other app's choice.
+    HKEY_CURRENT_USER, so it needs no elevation; keyed by ``sys.executable``,
+    so it only affects this specific Python (e.g. one conda env), not every
+    Python on the machine, and never touches a value already set — by the
+    user via Settings, or by this same call on a previous run.
+    """
+    import winreg
+
+    exe = sys.executable
+    key = winreg.CreateKeyEx(
+        winreg.HKEY_CURRENT_USER,
+        r"Software\Microsoft\DirectX\UserGpuPreferences",
+        0,
+        winreg.KEY_SET_VALUE | winreg.KEY_QUERY_VALUE,
+    )
+    try:
+        try:
+            winreg.QueryValueEx(key, exe)
+            return  # already has a preference (ours or the user's) — leave it
+        except FileNotFoundError:
+            pass
+        winreg.SetValueEx(key, exe, 0, winreg.REG_SZ, "GpuPreference=2;")
+    finally:
+        winreg.CloseKey(key)
+
+
+def main(argv=None) -> int:
+    _prefer_discrete_gpu()
+    parser = argparse.ArgumentParser(
+        prog="segfix",
+        description="GUI tool to fix tree point-cloud instance segmentation.",
+    )
+    parser.add_argument(
+        "--label-field",
+        default=None,
+        help="Name of the per-point tree/instance ID field (auto-detected if omitted)",
+    )
+    parser.add_argument(
+        "--point-size", type=float, default=0.01,
+        help="Render size of points in metres (default: 0.01)",
+    )
+    args = parser.parse_args(argv)
+
+    # Must import napari before any QApplication exists (including the one
+    # the startup dialog below would otherwise create first): napari applies
+    # a Wayland+NVIDIA OpenGL workaround at import time that only works if
+    # nothing has created a Qt application yet. Doing this out of order is a
+    # real, reproduced crash — the app launches but every draw call fails
+    # with "OpenGL.error.GLError: invalid enumerant" / "no valid context".
+    import napari
+
+    from . import registry
+    from .startup_ui import choose_project
+
+    choice = choose_project()
+    if choice is None:
+        return 0
+    open_path, registry_path, kind = choice
+    args.cloud = open_path
+    registry.add_entry(registry_path, kind=kind)
+
+    return _run_scene(napari, args)
+
+
+def _combined_panel(*widgets):
+    """Stack several dock-panel widgets into one scrollable widget.
+
+    Used so scene mode's own tree table sits above the shared segfix editing
+    panel in a single right-hand dock, instead of a separate left dock —
+    everything lives in one place.
+    """
+    from qtpy.QtWidgets import QScrollArea, QVBoxLayout, QWidget
+
+    inner = QWidget()
+    lay = QVBoxLayout(inner)
+    lay.setContentsMargins(4, 4, 4, 4)
+    lay.setSpacing(4)
+    for w in widgets:
+        lay.addWidget(w)
+    lay.addStretch()
+    scroll = QScrollArea()
+    scroll.setWidgetResizable(True)
+    scroll.setWidget(inner)
+    return scroll
+
+
+def _dock_right(viewer, widget):
+    """Dock ``widget`` on the right, sized to fill the full window height.
+
+    ``QtViewerDockWidget.__init__`` (napari) unconditionally sets the docked
+    widget's vertical size policy to ``QSizePolicy.Maximum`` — capped at its
+    sizeHint, regardless of available space — independently of the
+    ``add_vertical_stretch`` option. That leaves a lone right-hand dock sized
+    to a fraction of the window, forcing users to scroll for content that
+    would otherwise fit. Override it to ``Expanding`` so the dock claims the
+    rest of the window height, then nudge it with the oversized-resizeDocks
+    idiom napari itself uses for its own layer-list dock at startup
+    (qt_main_window.py's ``_QtMainWindow.__init__``).
+    """
+    from qtpy.QtCore import Qt
+    from qtpy.QtWidgets import QSizePolicy
+
+    dock = viewer.window.add_dock_widget(widget, name="segfix", area="right")
+    policy = dock.widget().sizePolicy()
+    policy.setVerticalPolicy(QSizePolicy.Policy.Expanding)
+    dock.widget().setSizePolicy(policy)
+    viewer.window._qt_window.resizeDocks([dock], [10000], Qt.Orientation.Vertical)
+    # Qt's default corner ownership gives the top-right corner to the top
+    # dock area, which pushes the right dock's top edge down below it —
+    # leaving a gap of bare canvas in that corner. Give the corner to the
+    # right dock instead so it reaches all the way up to y=0.
+    viewer.window._qt_window.setCorner(
+        Qt.Corner.TopRightCorner, Qt.DockWidgetArea.RightDockWidgetArea
+    )
+    return dock
+
+
+def _dock_top(viewer, panel) -> None:
+    """Dock ``panel.top_bar`` (Interaction / View / Cross section) along the
+    top of the window — it's about the canvas/viewport, not the tree-review
+    workflow the main side panel is organised around."""
+    viewer.window.add_dock_widget(panel.top_bar, name="view", area="top")
+
+
+def _run_scene(napari, args) -> int:
+    """Default mode for a single big cloud (binary PLY or uncompressed LAS):
+    a tree table where picking a row loads that tree plus its neighbours,
+    instead of the whole cloud."""
+    import numpy as np
+
+    from .model import PointCloud
+    from .scene_ui import SceneController, SceneWidget
+    from .treecatalog import open_catalog
+    from .viewer import (
+        add_cloud_layer,
+        add_gpu_status_widget,
+        apply_cloudcompare_controls,
+        busy,
+        strip_ui,
+    )
+    from .widgets import SegFixController, SegFixWidget, bind_shortcuts
+
+    viewer = napari.Viewer(title=f"segfix — {args.cloud}")
+    from .icons import app_icon
+
+    viewer.window._qt_window.setWindowIcon(app_icon())
+    viewer.window._qt_window.showMaximized()
+    # Before any loading: strip_ui/apply_cloudcompare_controls only touch
+    # napari's own built-in chrome (menu bar, default docks, camera), not
+    # anything of ours, so they're safe this early — and doing them now
+    # means the "busy" status repaint below (and the catalog scan) never
+    # flashes the default, unstripped napari GUI first.
+    apply_cloudcompare_controls(viewer)
+    strip_ui(viewer)
+    # An empty Points layer, added before any (potentially slow) loading:
+    # with zero layers, napari shows its own "drag a file here" welcome
+    # screen over the canvas — adding this one, even with no points yet,
+    # dismisses that so the busy status below isn't fighting it for
+    # attention.
+    empty = PointCloud(
+        coords=np.empty((0, 3), np.float32), labels=np.empty(0, np.int32)
+    )
+    layer = add_cloud_layer(viewer, empty, point_size=args.point_size)
+    # After the first layer add, so the GL context exists to read a renderer
+    # string from (see gpu_renderer_info).
+    add_gpu_status_widget(viewer)
+    busy(viewer, f"Scanning trees in {args.cloud}…")
+
+    catalog = open_catalog(args.cloud, label_field=args.label_field)
+
+    seg = SegFixController(viewer, empty, layer)
+    panel = SegFixWidget(seg)
+    scene_ctrl = SceneController(viewer, catalog, seg, point_size=args.point_size)
+    scene_panel = SceneWidget(scene_ctrl)
+    panel.on_done_changed = scene_panel.refresh
+
+    _dock_top(viewer, panel)
+    _dock_right(viewer, _combined_panel(scene_panel, panel))
+    panel.size_spin.setValue(args.point_size)
+    bind_shortcuts(viewer, panel)
+
+    viewer.status = (
+        f"{len(catalog.records)} trees in {args.cloud}. "
+        "Double-click a tree to load it with neighbours."
+    )
+    napari.run()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

segfix/icons.py

@@ -0,0 +1,302 @@
+"""Programmatically drawn icons for the segfix buttons.
+
+Icons are painted with QPainter at runtime rather than shipped as files:
+they stay crisp at any DPI, share one visual style, and adding one is a few
+lines of path code.  All drawing happens in a 32×32 coordinate space; colours
+are chosen for napari's dark theme.
+"""
+
+from __future__ import annotations
+
+from qtpy.QtCore import QPointF, QRectF, Qt
+from qtpy.QtGui import (
+    QColor,
+    QIcon,
+    QPainter,
+    QPainterPath,
+    QPen,
+    QPixmap,
+    QPolygonF,
+)
+
+FG = QColor("#d8d8d8")
+GREEN = QColor("#86c98a")
+RED = QColor("#e08080")
+BLUE = QColor("#7fb3e0")
+AMBER = QColor("#e0c060")
+
+
+def _pen(color=FG, width=2.4, dashed=False) -> QPen:
+    pen = QPen(color)
+    pen.setWidthF(width)
+    pen.setCapStyle(Qt.RoundCap)
+    pen.setJoinStyle(Qt.RoundJoin)
+    if dashed:
+        pen.setStyle(Qt.DashLine)
+    return pen
+
+
+def _arrowhead(p: QPainter, tip, left, right, color=FG) -> None:
+    p.setPen(Qt.NoPen)
+    p.setBrush(color)
+    p.drawPolygon(QPolygonF([QPointF(*tip), QPointF(*left), QPointF(*right)]))
+
+
+def _lasso(p: QPainter) -> None:
+    path = QPainterPath(QPointF(9, 19))
+    path.cubicTo(QPointF(3, 10), QPointF(12, 3), QPointF(19, 5))
+    path.cubicTo(QPointF(28, 7), QPointF(29, 15), QPointF(23, 18))
+    path.cubicTo(QPointF(18, 21), QPointF(12, 22), QPointF(9, 19))
+    p.drawPath(path)
+    p.drawLine(QPointF(9, 19), QPointF(16, 28))  # rope tail
+
+
+def _target(p: QPainter) -> None:
+    p.drawEllipse(QRectF(8, 8, 16, 16))
+    for a, b in [((16, 3), (16, 9)), ((16, 23), (16, 29)),
+                 ((3, 16), (9, 16)), ((23, 16), (29, 16))]:
+        p.drawLine(QPointF(*a), QPointF(*b))
+    p.setPen(Qt.NoPen)
+    p.setBrush(AMBER)
+    p.drawEllipse(QPointF(16, 16), 2.5, 2.5)
+
+
+def _reassign(p: QPainter) -> None:
+    p.drawLine(QPointF(4, 16), QPointF(16, 16))
+    _arrowhead(p, (20, 16), (14, 12), (14, 20))
+    p.setPen(_pen(BLUE))
+    p.setBrush(Qt.NoBrush)
+    p.drawEllipse(QRectF(19, 11, 10, 10))
+
+
+def _new_tree(p: QPainter) -> None:
+    p.setPen(_pen(GREEN))
+    p.drawEllipse(QRectF(6, 6, 20, 20))
+    p.drawLine(QPointF(16, 11), QPointF(16, 21))
+    p.drawLine(QPointF(11, 16), QPointF(21, 16))
+
+
+def _merge(p: QPainter) -> None:
+    p.setPen(_pen(BLUE))
+    p.drawEllipse(QRectF(4, 9, 14, 14))
+    p.drawEllipse(QRectF(14, 9, 14, 14))
+
+
+def _noise(p: QPainter) -> None:
+    p.setPen(_pen(RED, 3.0))
+    p.drawLine(QPointF(9, 9), QPointF(23, 23))
+    p.drawLine(QPointF(23, 9), QPointF(9, 23))
+
+
+def _unassign(p: QPainter) -> None:
+    p.setPen(_pen(dashed=True))
+    p.drawEllipse(QRectF(7, 7, 18, 18))
+
+
+def _split(p: QPainter) -> None:
+    p.setPen(_pen(BLUE))
+    p.drawLine(QPointF(16, 12), QPointF(8, 22))
+    p.drawLine(QPointF(16, 12), QPointF(24, 22))
+    p.setBrush(Qt.NoBrush)
+    p.drawEllipse(QPointF(16, 7), 4, 4)
+    p.drawEllipse(QPointF(7, 25), 4, 4)
+    p.drawEllipse(QPointF(25, 25), 4, 4)
+
+
+def _isolate(p: QPainter) -> None:
+    path = QPainterPath(QPointF(4, 16))
+    path.cubicTo(QPointF(10, 7), QPointF(22, 7), QPointF(28, 16))
+    path.cubicTo(QPointF(22, 25), QPointF(10, 25), QPointF(4, 16))
+    p.drawPath(path)
+    p.setPen(Qt.NoPen)
+    p.setBrush(FG)
+    p.drawEllipse(QPointF(16, 16), 3.5, 3.5)
+
+
+def _seed(p: QPainter) -> None:
+    p.setPen(_pen(GREEN))
+    p.drawLine(QPointF(16, 18), QPointF(16, 9))
+    p.drawLine(QPointF(16, 12), QPointF(11, 7))
+    p.drawLine(QPointF(16, 12), QPointF(21, 7))
+    p.setPen(Qt.NoPen)
+    p.setBrush(AMBER)
+    p.drawEllipse(QPointF(16, 23), 5, 5)
+
+
+def _grow(p: QPainter) -> None:
+    p.setPen(_pen(GREEN))
+    p.drawLine(QPointF(16, 29), QPointF(16, 12))
+    p.drawLine(QPointF(16, 20), QPointF(7, 11))
+    p.drawLine(QPointF(16, 16), QPointF(25, 7))
+
+
+def _clear(p: QPainter) -> None:
+    p.setPen(_pen(width=2.0))
+    p.drawLine(QPointF(11, 11), QPointF(21, 21))
+    p.drawLine(QPointF(21, 11), QPointF(11, 21))
+
+
+def _undo(p: QPainter) -> None:
+    p.drawArc(QRectF(8, 9, 16, 16), 0, 180 * 16)
+    _arrowhead(p, (8, 24), (3, 16), (13, 16))
+
+
+def _redo(p: QPainter) -> None:
+    p.drawArc(QRectF(8, 9, 16, 16), 0, 180 * 16)
+    _arrowhead(p, (24, 24), (19, 16), (29, 16))
+
+
+def _save(p: QPainter) -> None:
+    p.drawLine(QPointF(16, 4), QPointF(16, 15))
+    _arrowhead(p, (16, 20), (11, 13), (21, 13))
+    path = QPainterPath(QPointF(6, 19))
+    path.lineTo(QPointF(6, 27))
+    path.lineTo(QPointF(26, 27))
+    path.lineTo(QPointF(26, 19))
+    p.drawPath(path)
+
+
+def _folder(p: QPainter) -> None:
+    path = QPainterPath(QPointF(5, 25))
+    path.lineTo(QPointF(5, 9))
+    path.lineTo(QPointF(13, 9))
+    path.lineTo(QPointF(15, 12))
+    path.lineTo(QPointF(27, 12))
+    path.lineTo(QPointF(27, 25))
+    path.closeSubpath()
+    p.drawPath(path)
+
+
+def _hide(p: QPainter) -> None:
+    """Crossed-out eye: hide points from view."""
+    p.drawEllipse(QRectF(5, 10, 22, 12))
+    p.setBrush(FG)
+    p.drawEllipse(QRectF(13, 13, 6, 6))
+    p.setBrush(Qt.NoBrush)
+    p.setPen(_pen(RED))
+    p.drawLine(QPointF(7, 27), QPointF(25, 5))
+
+
+def _fade(p: QPainter) -> None:
+    """Faint dashed eye: fade points (still there, still selectable)."""
+    p.setPen(_pen(dashed=True))
+    p.drawEllipse(QRectF(5, 10, 22, 12))
+    p.drawEllipse(QRectF(13, 13, 6, 6))
+
+
+def _move(p: QPainter) -> None:
+    """Four-way arrows: camera/movement mode."""
+    p.drawLine(QPointF(16, 9), QPointF(16, 23))
+    p.drawLine(QPointF(9, 16), QPointF(23, 16))
+    _arrowhead(p, (16, 3), (11, 9), (21, 9))
+    _arrowhead(p, (16, 29), (11, 23), (21, 23))
+    _arrowhead(p, (3, 16), (9, 11), (9, 21))
+    _arrowhead(p, (29, 16), (23, 11), (23, 21))
+
+
+def _next(p: QPainter) -> None:
+    p.drawLine(QPointF(4, 16), QPointF(18, 16))
+    _arrowhead(p, (23, 16), (16, 10), (16, 22))
+    p.drawLine(QPointF(27, 8), QPointF(27, 24))
+
+
+def _prev(p: QPainter) -> None:
+    p.drawLine(QPointF(28, 16), QPointF(14, 16))
+    _arrowhead(p, (9, 16), (16, 10), (16, 22))
+    p.drawLine(QPointF(5, 8), QPointF(5, 24))
+
+
+_DRAW = {
+    "hide": _hide,
+    "fade": _fade,
+    "move": _move,
+    "lasso": _lasso,
+    "prev": _prev,
+    "target": _target,
+    "reassign": _reassign,
+    "new": _new_tree,
+    "merge": _merge,
+    "noise": _noise,
+    "unassign": _unassign,
+    "split": _split,
+    "isolate": _isolate,
+    "seed": _seed,
+    "grow": _grow,
+    "clear": _clear,
+    "undo": _undo,
+    "redo": _redo,
+    "save": _save,
+    "folder": _folder,
+    "next": _next,
+}
+
+_cache: dict[str, QIcon] = {}
+
+
+def icon(name: str) -> QIcon:
+    """Return the named icon, drawing (and caching) it on first use."""
+    if name not in _cache:
+        pix = QPixmap(64, 64)
+        pix.setDevicePixelRatio(2)  # crisp on HiDPI screens
+        pix.fill(Qt.transparent)
+        p = QPainter(pix)
+        p.setRenderHint(QPainter.Antialiasing)
+        p.setPen(_pen())
+        p.setBrush(Qt.NoBrush)
+        _DRAW[name](p)
+        p.end()
+        _cache[name] = QIcon(pix)
+    return _cache[name]
+
+
+_app_icon_cache: QIcon | None = None
+
+
+def app_icon() -> QIcon:
+    """The segfix window/taskbar icon: a canopy split into two colours —
+    one tree wrongly merged into two, or two wrongly merged into one,
+    either way the thing this tool fixes — over a short trunk. Unlike the
+    button icons above this one is filled, not just stroked, so it stays
+    legible at taskbar/dock sizes; several resolutions are baked in so a
+    window manager picks a crisp one instead of scaling a single pixmap.
+    """
+    global _app_icon_cache
+    if _app_icon_cache is not None:
+        return _app_icon_cache
+
+    result = QIcon()
+    for s in (16, 24, 32, 48, 64, 128, 256):
+        pix = QPixmap(s, s)
+        pix.fill(Qt.transparent)
+        p = QPainter(pix)
+        p.setRenderHint(QPainter.Antialiasing)
+
+        canopy_d = s * 0.74
+        cx, cy = s * 0.5, s * 0.44
+        rect = QRectF(cx - canopy_d / 2, cy - canopy_d / 2, canopy_d, canopy_d)
+        p.setPen(Qt.NoPen)
+        p.setBrush(GREEN)
+        p.drawPie(rect, 90 * 16, 180 * 16)  # left half
+        p.setBrush(AMBER)
+        p.drawPie(rect, 270 * 16, 180 * 16)  # right half
+
+        outline = QPen(QColor("#2a2a2a"))
+        outline.setWidthF(max(1.0, s * 0.035))
+        p.setPen(outline)
+        p.setBrush(Qt.NoBrush)
+        p.drawLine(QPointF(cx, cy - canopy_d / 2), QPointF(cx, cy + canopy_d / 2))
+        p.drawEllipse(rect)
+
+        trunk_w = s * 0.11
+        trunk_h = s * 0.30
+        trunk_rect = QRectF(
+            cx - trunk_w / 2, cy + canopy_d / 2 - s * 0.03, trunk_w, trunk_h
+        )
+        p.setPen(Qt.NoPen)
+        p.setBrush(QColor("#8a6a4a"))
+        p.drawRoundedRect(trunk_rect, trunk_w * 0.3, trunk_w * 0.3)
+
+        p.end()
+        result.addPixmap(pix)
+    _app_icon_cache = result
+    return result