Add files using upload-large-folder tool

notebooks/colab_gas_valve_auto_label_train.ipynb

@@ -0,0 +1,970 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4",
+      "toc_visible": true
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python",
+      "version": "3.10.0"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Gas + valve auto-labeling and training\n",
+        "\n",
+        "This notebook expects the HuggingFace dataset repo to contain:\n",
+        "\n",
+        "- `images/train/` and `labels/train/`: existing gas-cylinder labels\n",
+        "- `raw/valve/`: valve images plus bbox `.txt` priors\n",
+        "- `raw/gas_extra/`: extra gas-cylinder images\n",
+        "- `scripts/process_valve_to_polygon.py`: valve polygon auto-label script\n",
+        "\n",
+        "Class mapping:\n",
+        "\n",
+        "- `0`: `gas_cylinder`\n",
+        "- `1`: `valve`"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "---\n",
+        "## Step 1 - Install dependencies"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "cellView": "form"
+      },
+      "outputs": [],
+      "source": [
+        "# @title Step 1 - Install dependencies\n",
+        "\n",
+        "get_ipython().system(\n",
+        "    \"pip install -q ultralytics huggingface_hub opencv-python-headless \"\n",
+        "    \"tqdm pyyaml matplotlib pandas\"\n",
+        ")\n",
+        "\n",
+        "import os\n",
+        "import sys\n",
+        "import time\n",
+        "import shutil\n",
+        "import random\n",
+        "import subprocess\n",
+        "from pathlib import Path\n",
+        "\n",
+        "import cv2\n",
+        "import yaml\n",
+        "import torch\n",
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "from tqdm.notebook import tqdm\n",
+        "from huggingface_hub import (\n",
+        "    HfApi,\n",
+        "    login,\n",
+        "    snapshot_download,\n",
+        "    CommitOperationAdd,\n",
+        ")\n",
+        "\n",
+        "print(\"Dependencies installed\")\n",
+        "print(f\"Python: {sys.version.split()[0]}\")\n",
+        "print(f\"PyTorch: {torch.__version__}\")\n",
+        "print(f\"CUDA available: {torch.cuda.is_available()}\")\n",
+        "if torch.cuda.is_available():\n",
+        "    print(f\"GPU: {torch.cuda.get_device_name(0)}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "---\n",
+        "## Step 2 - HuggingFace authentication"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "cellView": "form"
+      },
+      "outputs": [],
+      "source": [
+        "# @title Step 2 - HuggingFace authentication\n",
+        "# @markdown Token needs write permission if you want to upload generated labels and training results.\n",
+        "\n",
+        "HF_TOKEN = \"\"  # @param {type:\"string\"}\n",
+        "DATASET_REPO = \"rick003/11111\"  # @param {type:\"string\"}\n",
+        "\n",
+        "if not HF_TOKEN:\n",
+        "    from getpass import getpass\n",
+        "\n",
+        "    HF_TOKEN = getpass(\"HuggingFace token: \")\n",
+        "\n",
+        "if not HF_TOKEN:\n",
+        "    raise ValueError(\"HF_TOKEN is required\")\n",
+        "\n",
+        "login(token=HF_TOKEN, add_to_git_credential=False)\n",
+        "api = HfApi()\n",
+        "api.dataset_info(DATASET_REPO, token=HF_TOKEN)\n",
+        "\n",
+        "print(\"HuggingFace authentication OK\")\n",
+        "print(f\"Dataset: https://huggingface.co/datasets/{DATASET_REPO}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "---\n",
+        "## Step 3 - Download required files"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "cellView": "form"
+      },
+      "outputs": [],
+      "source": [
+        "# @title Step 3 - Download required files\n",
+        "# @markdown Downloads only the files needed for joint labeling/training.\n",
+        "\n",
+        "DATASET_LOCAL = \"/content/hf_11111\"  # @param {type:\"string\"}\n",
+        "RAW_VALVE_PREFIX = \"raw/valve\"\n",
+        "RAW_GAS_EXTRA_PREFIX = \"raw/gas_extra\"\n",
+        "PROCESS_SCRIPT_REPO_PATH = \"scripts/process_valve_to_polygon.py\"\n",
+        "FORCE_REDOWNLOAD = False  # @param {type:\"boolean\"}\n",
+        "\n",
+        "base = Path(DATASET_LOCAL)\n",
+        "if FORCE_REDOWNLOAD and base.exists():\n",
+        "    shutil.rmtree(base)\n",
+        "\n",
+        "allow_patterns = [\n",
+        "    \"images/train/**\",\n",
+        "    \"labels/train/**\",\n",
+        "    f\"{RAW_VALVE_PREFIX}/**\",\n",
+        "    f\"{RAW_GAS_EXTRA_PREFIX}/**\",\n",
+        "    PROCESS_SCRIPT_REPO_PATH,\n",
+        "    \"dataset.yaml\",\n",
+        "]\n",
+        "\n",
+        "print(f\"Downloading dataset files to {DATASET_LOCAL}\")\n",
+        "snapshot_download(\n",
+        "    repo_id=DATASET_REPO,\n",
+        "    repo_type=\"dataset\",\n",
+        "    token=HF_TOKEN,\n",
+        "    local_dir=DATASET_LOCAL,\n",
+        "    allow_patterns=allow_patterns,\n",
+        "    ignore_patterns=[\"runs/**\", \"preview/**\", \"*.cache\", \".git/**\"],\n",
+        ")\n",
+        "\n",
+        "RAW_VALVE_DIR = base / RAW_VALVE_PREFIX\n",
+        "RAW_GAS_EXTRA_DIR = base / RAW_GAS_EXTRA_PREFIX\n",
+        "PROCESS_SCRIPT_LOCAL = base / PROCESS_SCRIPT_REPO_PATH\n",
+        "\n",
+        "print(\"Download summary\")\n",
+        "for p in [base / \"images/train\", base / \"labels/train\", RAW_VALVE_DIR, RAW_GAS_EXTRA_DIR]:\n",
+        "    n = len(list(p.glob(\"*\"))) if p.exists() else 0\n",
+        "    print(f\"  {p}: {n} entries\")\n",
+        "\n",
+        "if not RAW_VALVE_DIR.exists():\n",
+        "    raise FileNotFoundError(f\"Missing {RAW_VALVE_PREFIX} in HF dataset\")\n",
+        "if not RAW_GAS_EXTRA_DIR.exists():\n",
+        "    raise FileNotFoundError(f\"Missing {RAW_GAS_EXTRA_PREFIX} in HF dataset\")\n",
+        "if not PROCESS_SCRIPT_LOCAL.exists():\n",
+        "    raise FileNotFoundError(\n",
+        "        f\"Missing {PROCESS_SCRIPT_REPO_PATH}. Upload process_valve_to_polygon.py \"\n",
+        "        \"to this path before running valve auto-labeling.\"\n",
+        "    )"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "---\n",
+        "## Step 4 - Shared helpers"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "cellView": "form"
+      },
+      "outputs": [],
+      "source": [
+        "# @title Step 4 - Shared helpers\n",
+        "\n",
+        "IMG_EXTS = {\".png\", \".jpg\", \".jpeg\", \".bmp\", \".webp\"}\n",
+        "WORK_DIR = Path(\"/content/gas_valve_work\")\n",
+        "LABEL_WORK_DIR = WORK_DIR / \"labels\"\n",
+        "VIS_WORK_DIR = WORK_DIR / \"visual\"\n",
+        "for d in [LABEL_WORK_DIR, VIS_WORK_DIR]:\n",
+        "    d.mkdir(parents=True, exist_ok=True)\n",
+        "\n",
+        "\n",
+        "def list_images(folder: Path) -> list[Path]:\n",
+        "    if not folder.exists():\n",
+        "        return []\n",
+        "    return sorted(\n",
+        "        p for p in folder.iterdir()\n",
+        "        if p.is_file() and p.suffix.lower() in IMG_EXTS\n",
+        "    )\n",
+        "\n",
+        "\n",
+        "def find_image_by_stem(folder: Path, stem: str) -> Path | None:\n",
+        "    for ext in IMG_EXTS:\n",
+        "        p = folder / f\"{stem}{ext}\"\n",
+        "        if p.exists():\n",
+        "            return p\n",
+        "    for p in folder.glob(f\"{stem}.*\"):\n",
+        "        if p.suffix.lower() in IMG_EXTS:\n",
+        "            return p\n",
+        "    return None\n",
+        "\n",
+        "\n",
+        "def read_image(path: Path) -> np.ndarray | None:\n",
+        "    raw = np.fromfile(str(path), dtype=np.uint8)\n",
+        "    if raw.size == 0:\n",
+        "        return None\n",
+        "    return cv2.imdecode(raw, cv2.IMREAD_COLOR)\n",
+        "\n",
+        "\n",
+        "def valid_seg_lines(label_path: Path, allowed_classes: set[int] | None = None) -> list[str]:\n",
+        "    if not label_path.exists():\n",
+        "        return []\n",
+        "    text = label_path.read_text(encoding=\"utf-8\", errors=\"ignore\").strip()\n",
+        "    if not text:\n",
+        "        return []\n",
+        "\n",
+        "    lines: list[str] = []\n",
+        "    for raw_line in text.splitlines():\n",
+        "        parts = raw_line.strip().split()\n",
+        "        if len(parts) < 7:\n",
+        "            continue\n",
+        "        try:\n",
+        "            cls = int(float(parts[0]))\n",
+        "            coords = [float(v) for v in parts[1:]]\n",
+        "        except ValueError:\n",
+        "            continue\n",
+        "        if allowed_classes is not None and cls not in allowed_classes:\n",
+        "            continue\n",
+        "        if len(coords) < 6 or len(coords) % 2 != 0:\n",
+        "            continue\n",
+        "        coords = [min(1.0, max(0.0, v)) for v in coords]\n",
+        "        out = [str(cls)] + [f\"{v:.6f}\" for v in coords]\n",
+        "        lines.append(\" \".join(out))\n",
+        "    return lines\n",
+        "\n",
+        "\n",
+        "def write_lines(path: Path, lines: list[str]) -> None:\n",
+        "    path.parent.mkdir(parents=True, exist_ok=True)\n",
+        "    path.write_text(\"\\n\".join(lines).strip() + (\"\\n\" if lines else \"\"), encoding=\"utf-8\")\n",
+        "\n",
+        "\n",
+        "def class_counts(label_files: list[Path]) -> dict[int, int]:\n",
+        "    counts: dict[int, int] = {}\n",
+        "    for p in label_files:\n",
+        "        for line in p.read_text(encoding=\"utf-8\", errors=\"ignore\").splitlines():\n",
+        "            parts = line.strip().split()\n",
+        "            if not parts:\n",
+        "                continue\n",
+        "            try:\n",
+        "                cls = int(float(parts[0]))\n",
+        "            except ValueError:\n",
+        "                continue\n",
+        "            counts[cls] = counts.get(cls, 0) + 1\n",
+        "    return counts\n",
+        "\n",
+        "\n",
+        "print(f\"Old train images: {len(list_images(base / 'images/train'))}\")\n",
+        "print(f\"Old train labels: {len(list((base / 'labels/train').glob('*.txt')))}\")\n",
+        "print(f\"Raw valve images: {len(list_images(RAW_VALVE_DIR))}\")\n",
+        "print(f\"Raw gas-extra images: {len(list_images(RAW_GAS_EXTRA_DIR))}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "---\n",
+        "## Step 5 - Gas-cylinder auto-labeler"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "cellView": "form"
+      },
+      "outputs": [],
+      "source": [
+        "# @title Step 5 - Gas-cylinder auto-labeler\n",
+        "\n",
+        "\n",
+        "class GasCylinderSegmenter:\n",
+        "    CLASS_WEIGHTS = {\n",
+        "        39: 2.0,   # bottle\n",
+        "        10: 1.0,   # fire hydrant\n",
+        "        71: 1.0,   # sink\n",
+        "        61: 1.0,   # toilet\n",
+        "        41: 0.8,   # cup\n",
+        "        56: 0.8,   # chair\n",
+        "        75: 0.8,   # vase\n",
+        "    }\n",
+        "\n",
+        "    def __init__(self, model_path: str = \"yolo11x-seg.pt\", class_id: int = 0) -> None:\n",
+        "        from ultralytics import YOLO\n",
+        "\n",
+        "        self.device = \"0\" if torch.cuda.is_available() else \"cpu\"\n",
+        "        self.class_id = class_id\n",
+        "        self.model = YOLO(model_path)\n",
+        "        self.conf = 0.01\n",
+        "        self.min_area = 0.03\n",
+        "        self.max_dist = 0.35\n",
+        "        print(f\"Gas label model: {model_path}, device={self.device}, class_id={class_id}\")\n",
+        "\n",
+        "    def annotate(self, img: np.ndarray) -> tuple[str, bool]:\n",
+        "        h, w = img.shape[:2]\n",
+        "        cx, cy = w / 2.0, h / 2.0\n",
+        "        area = float(w * h)\n",
+        "        diag = float(w * w + h * h) ** 0.5\n",
+        "\n",
+        "        result = self.model(img, conf=self.conf, device=self.device, verbose=False)[0]\n",
+        "        candidates = []\n",
+        "\n",
+        "        if result.masks is not None:\n",
+        "            for i in range(len(result.masks.data)):\n",
+        "                cls_id = int(result.boxes.cls[i])\n",
+        "                if cls_id not in self.CLASS_WEIGHTS:\n",
+        "                    continue\n",
+        "\n",
+        "                conf = float(result.boxes.conf[i])\n",
+        "                x1, y1, x2, y2 = result.boxes.xyxy[i].tolist()\n",
+        "                box_cx = (x1 + x2) / 2.0\n",
+        "                box_cy = (y1 + y2) / 2.0\n",
+        "                area_ratio = (x2 - x1) * (y2 - y1) / area\n",
+        "                dist_ratio = ((box_cx - cx) ** 2 + (box_cy - cy) ** 2) ** 0.5 / diag\n",
+        "\n",
+        "                if area_ratio < self.min_area or dist_ratio > self.max_dist:\n",
+        "                    continue\n",
+        "\n",
+        "                centrality_bonus = 1.0 + (1.0 - dist_ratio / self.max_dist)\n",
+        "                score = conf * self.CLASS_WEIGHTS[cls_id] * centrality_bonus\n",
+        "                candidates.append((score, result.masks.xyn[i]))\n",
+        "\n",
+        "        if not candidates:\n",
+        "            return \"\", False\n",
+        "\n",
+        "        _, poly = max(candidates, key=lambda x: x[0])\n",
+        "        if len(poly) < 3:\n",
+        "            return \"\", False\n",
+        "\n",
+        "        tokens = [str(self.class_id)]\n",
+        "        for x, y in poly:\n",
+        "            tokens.append(f\"{float(x):.6f}\")\n",
+        "            tokens.append(f\"{float(y):.6f}\")\n",
+        "        return \" \".join(tokens), True\n",
+        "\n",
+        "\n",
+        "def auto_label_gas_folder(\n",
+        "    segmenter: GasCylinderSegmenter,\n",
+        "    image_dir: Path,\n",
+        "    labels_dir: Path,\n",
+        "    *,\n",
+        "    overwrite: bool = False,\n",
+        "    limit: int = 0,\n",
+        ") -> dict[str, int]:\n",
+        "    labels_dir.mkdir(parents=True, exist_ok=True)\n",
+        "    images = list_images(image_dir)\n",
+        "    if limit > 0:\n",
+        "        images = images[:limit]\n",
+        "\n",
+        "    stats = {\"ok\": 0, \"failed\": 0, \"error\": 0, \"skipped\": 0}\n",
+        "    for image_path in tqdm(images, desc=f\"Gas labels: {image_dir.name}\"):\n",
+        "        label_path = labels_dir / f\"{image_path.stem}.txt\"\n",
+        "        if label_path.exists() and label_path.stat().st_size > 0 and not overwrite:\n",
+        "            stats[\"skipped\"] += 1\n",
+        "            continue\n",
+        "\n",
+        "        img = read_image(image_path)\n",
+        "        if img is None:\n",
+        "            write_lines(label_path, [])\n",
+        "            stats[\"error\"] += 1\n",
+        "            continue\n",
+        "\n",
+        "        try:\n",
+        "            label, ok = segmenter.annotate(img)\n",
+        "            write_lines(label_path, [label] if ok else [])\n",
+        "            stats[\"ok\" if ok else \"failed\"] += 1\n",
+        "        except Exception as exc:\n",
+        "            print(f\"Gas label error: {image_path.name}: {exc}\")\n",
+        "            write_lines(label_path, [])\n",
+        "            stats[\"error\"] += 1\n",
+        "\n",
+        "    print(f\"{image_dir.name}: {stats}\")\n",
+        "    return stats"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "---\n",
+        "## Step 6 - Auto-label new gas data"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "cellView": "form"
+      },
+      "outputs": [],
+      "source": [
+        "# @title Step 6 - Auto-label new gas data\n",
+        "# @markdown Gas labels are generated for both extra gas images and valve images.\n",
+        "# @markdown The valve-image gas labels prevent visible gas cylinders from being treated as background.\n",
+        "\n",
+        "GAS_LABEL_MODEL = \"yolo11x-seg.pt\"  # @param [\"yolo11n-seg.pt\",\"yolo11m-seg.pt\",\"yolo11x-seg.pt\"]\n",
+        "REGENERATE_GAS_LABELS = False  # @param {type:\"boolean\"}\n",
+        "GAS_LABEL_LIMIT = 0  # @param {type:\"integer\"}\n",
+        "\n",
+        "GAS_EXTRA_LABEL_DIR = LABEL_WORK_DIR / \"gas_extra\"\n",
+        "VALVE_GAS_LABEL_DIR = LABEL_WORK_DIR / \"valve_gas\"\n",
+        "\n",
+        "gas_segmenter = GasCylinderSegmenter(GAS_LABEL_MODEL, class_id=0)\n",
+        "gas_extra_stats = auto_label_gas_folder(\n",
+        "    gas_segmenter,\n",
+        "    RAW_GAS_EXTRA_DIR,\n",
+        "    GAS_EXTRA_LABEL_DIR,\n",
+        "    overwrite=REGENERATE_GAS_LABELS,\n",
+        "    limit=GAS_LABEL_LIMIT,\n",
+        ")\n",
+        "valve_gas_stats = auto_label_gas_folder(\n",
+        "    gas_segmenter,\n",
+        "    RAW_VALVE_DIR,\n",
+        "    VALVE_GAS_LABEL_DIR,\n",
+        "    overwrite=REGENERATE_GAS_LABELS,\n",
+        "    limit=GAS_LABEL_LIMIT,\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "---\n",
+        "## Step 7 - Auto-label valve polygons"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "cellView": "form"
+      },
+      "outputs": [],
+      "source": [
+        "# @title Step 7 - Auto-label valve polygons\n",
+        "# @markdown Uses `process_valve_to_polygon.py` and the bbox `.txt` priors in `raw/valve/`.\n",
+        "\n",
+        "VALVE_LABEL_MODEL = \"yolo11x-seg.pt\"  # @param [\"yolo11n-seg.pt\",\"yolo11m-seg.pt\",\"yolo11x-seg.pt\"]\n",
+        "REGENERATE_VALVE_LABELS = False  # @param {type:\"boolean\"}\n",
+        "SAVE_VALVE_VISUALIZATIONS = False  # @param {type:\"boolean\"}\n",
+        "VALVE_LABEL_LIMIT = 0  # @param {type:\"integer\"}\n",
+        "\n",
+        "VALVE_LABEL_DIR = LABEL_WORK_DIR / \"valve\"\n",
+        "VALVE_VIS_DIR = VIS_WORK_DIR / \"valve\"\n",
+        "VALVE_LABEL_DIR.mkdir(parents=True, exist_ok=True)\n",
+        "VALVE_VIS_DIR.mkdir(parents=True, exist_ok=True)\n",
+        "\n",
+        "device = \"0\" if torch.cuda.is_available() else \"cpu\"\n",
+        "cmd = [\n",
+        "    sys.executable,\n",
+        "    str(PROCESS_SCRIPT_LOCAL),\n",
+        "    \"--image-dir\",\n",
+        "    str(RAW_VALVE_DIR),\n",
+        "    \"--labels-dir\",\n",
+        "    str(VALVE_LABEL_DIR),\n",
+        "    \"--vis-dir\",\n",
+        "    str(VALVE_VIS_DIR),\n",
+        "    \"--bbox-dir\",\n",
+        "    str(RAW_VALVE_DIR),\n",
+        "    \"--class-id\",\n",
+        "    \"1\",\n",
+        "    \"--model\",\n",
+        "    VALVE_LABEL_MODEL,\n",
+        "    \"--device\",\n",
+        "    device,\n",
+        "]\n",
+        "if REGENERATE_VALVE_LABELS:\n",
+        "    cmd.append(\"--overwrite\")\n",
+        "if not SAVE_VALVE_VISUALIZATIONS:\n",
+        "    cmd.append(\"--skip-visualizations\")\n",
+        "if VALVE_LABEL_LIMIT > 0:\n",
+        "    cmd.extend([\"--limit\", str(VALVE_LABEL_LIMIT)])\n",
+        "\n",
+        "print(\"Running valve auto-labeler\")\n",
+        "print(\" \".join(cmd))\n",
+        "subprocess.run(cmd, check=True)\n",
+        "\n",
+        "valve_labels = list(VALVE_LABEL_DIR.glob(\"*.txt\"))\n",
+        "print(f\"Valve label files: {len(valve_labels)}\")\n",
+        "print(f\"Valve non-empty labels: {sum(1 for p in valve_labels if p.stat().st_size > 0)}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "---\n",
+        "## Step 8 - Optionally upload generated labels"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "cellView": "form"
+      },
+      "outputs": [],
+      "source": [
+        "# @title Step 8 - Optionally upload generated labels\n",
+        "# @markdown Uploads generated labels under `auto_labels/gas_valve_v1/`.\n",
+        "\n",
+        "UPLOAD_GENERATED_LABELS = True  # @param {type:\"boolean\"}\n",
+        "GENERATED_LABELS_REPO_DIR = \"auto_labels/gas_valve_v1\"  # @param {type:\"string\"}\n",
+        "\n",
+        "if UPLOAD_GENERATED_LABELS:\n",
+        "    print(f\"Uploading generated labels to {GENERATED_LABELS_REPO_DIR}\")\n",
+        "    api.upload_folder(\n",
+        "        repo_id=DATASET_REPO,\n",
+        "        repo_type=\"dataset\",\n",
+        "        token=HF_TOKEN,\n",
+        "        folder_path=str(LABEL_WORK_DIR),\n",
+        "        path_in_repo=GENERATED_LABELS_REPO_DIR,\n",
+        "        commit_message=\"upload_generated_gas_valve_labels\",\n",
+        "    )\n",
+        "    print(\"Generated labels uploaded\")\n",
+        "else:\n",
+        "    print(\"Skipping generated label upload\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "---\n",
+        "## Step 9 - Build the two-class training dataset"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "cellView": "form"
+      },
+      "outputs": [],
+      "source": [
+        "# @title Step 9 - Build the two-class training dataset\n",
+        "\n",
+        "COMBINED_DATASET = Path(\"/content/gas_valve_dataset\")\n",
+        "VAL_RATIO = 0.20  # @param {type:\"number\"}\n",
+        "RANDOM_SEED = 42  # @param {type:\"integer\"}\n",
+        "INCLUDE_OLD_GAS_DATA = True  # @param {type:\"boolean\"}\n",
+        "\n",
+        "if COMBINED_DATASET.exists():\n",
+        "    shutil.rmtree(COMBINED_DATASET)\n",
+        "\n",
+        "for split in [\"train\", \"val\"]:\n",
+        "    (COMBINED_DATASET / f\"images/{split}\").mkdir(parents=True, exist_ok=True)\n",
+        "    (COMBINED_DATASET / f\"labels/{split}\").mkdir(parents=True, exist_ok=True)\n",
+        "\n",
+        "samples: list[dict] = []\n",
+        "\n",
+        "if INCLUDE_OLD_GAS_DATA:\n",
+        "    old_img_dir = base / \"images/train\"\n",
+        "    old_lbl_dir = base / \"labels/train\"\n",
+        "    for lbl_path in sorted(old_lbl_dir.glob(\"*.txt\")):\n",
+        "        lines = valid_seg_lines(lbl_path, {0})\n",
+        "        if not lines:\n",
+        "            continue\n",
+        "        img_path = find_image_by_stem(old_img_dir, lbl_path.stem)\n",
+        "        if img_path is None:\n",
+        "            continue\n",
+        "        samples.append({\n",
+        "            \"image\": img_path,\n",
+        "            \"lines\": lines,\n",
+        "            \"group\": \"gas\",\n",
+        "            \"source\": \"old_gas\",\n",
+        "        })\n",
+        "\n",
+        "for img_path in list_images(RAW_GAS_EXTRA_DIR):\n",
+        "    lines = valid_seg_lines(GAS_EXTRA_LABEL_DIR / f\"{img_path.stem}.txt\", {0})\n",
+        "    if not lines:\n",
+        "        continue\n",
+        "    samples.append({\n",
+        "        \"image\": img_path,\n",
+        "        \"lines\": lines,\n",
+        "        \"group\": \"gas\",\n",
+        "        \"source\": \"gas_extra\",\n",
+        "    })\n",
+        "\n",
+        "for img_path in list_images(RAW_VALVE_DIR):\n",
+        "    valve_lines = valid_seg_lines(VALVE_LABEL_DIR / f\"{img_path.stem}.txt\", {1})\n",
+        "    if not valve_lines:\n",
+        "        continue\n",
+        "    gas_lines = valid_seg_lines(VALVE_GAS_LABEL_DIR / f\"{img_path.stem}.txt\", {0})\n",
+        "    samples.append({\n",
+        "        \"image\": img_path,\n",
+        "        \"lines\": gas_lines + valve_lines,\n",
+        "        \"group\": \"valve\",\n",
+        "        \"source\": \"valve\",\n",
+        "    })\n",
+        "\n",
+        "print(f\"Collected labeled samples: {len(samples)}\")\n",
+        "print(f\"  gas samples: {sum(1 for s in samples if s['group'] == 'gas')}\")\n",
+        "print(f\"  valve samples: {sum(1 for s in samples if s['group'] == 'valve')}\")\n",
+        "\n",
+        "if not any(s[\"group\"] == \"valve\" for s in samples):\n",
+        "    raise RuntimeError(\"No valve samples were collected. Check valve auto-label output.\")\n",
+        "\n",
+        "rng = random.Random(RANDOM_SEED)\n",
+        "train_samples: list[dict] = []\n",
+        "val_samples: list[dict] = []\n",
+        "for group in sorted({s[\"group\"] for s in samples}):\n",
+        "    group_samples = [s for s in samples if s[\"group\"] == group]\n",
+        "    rng.shuffle(group_samples)\n",
+        "    n_val = int(round(len(group_samples) * VAL_RATIO))\n",
+        "    if len(group_samples) >= 5:\n",
+        "        n_val = max(1, n_val)\n",
+        "    val_samples.extend(group_samples[:n_val])\n",
+        "    train_samples.extend(group_samples[n_val:])\n",
+        "\n",
+        "rng.shuffle(train_samples)\n",
+        "rng.shuffle(val_samples)\n",
+        "\n",
+        "\n",
+        "def materialize(split: str, split_samples: list[dict]) -> None:\n",
+        "    for idx, sample in enumerate(split_samples, 1):\n",
+        "        suffix = sample[\"image\"].suffix.lower()\n",
+        "        stem = f\"{sample['source']}_{idx:05d}\"\n",
+        "        dst_img = COMBINED_DATASET / f\"images/{split}/{stem}{suffix}\"\n",
+        "        dst_lbl = COMBINED_DATASET / f\"labels/{split}/{stem}.txt\"\n",
+        "        shutil.copy2(sample[\"image\"], dst_img)\n",
+        "        write_lines(dst_lbl, sample[\"lines\"])\n",
+        "\n",
+        "\n",
+        "materialize(\"train\", train_samples)\n",
+        "materialize(\"val\", val_samples)\n",
+        "\n",
+        "YAML_PATH = COMBINED_DATASET / \"dataset.yaml\"\n",
+        "yaml_content = {\n",
+        "    \"path\": str(COMBINED_DATASET),\n",
+        "    \"train\": \"images/train\",\n",
+        "    \"val\": \"images/val\",\n",
+        "    \"names\": {\n",
+        "        0: \"gas_cylinder\",\n",
+        "        1: \"valve\",\n",
+        "    },\n",
+        "}\n",
+        "YAML_PATH.write_text(\n",
+        "    yaml.safe_dump(yaml_content, allow_unicode=True, sort_keys=False),\n",
+        "    encoding=\"utf-8\",\n",
+        ")\n",
+        "\n",
+        "train_label_files = list((COMBINED_DATASET / \"labels/train\").glob(\"*.txt\"))\n",
+        "val_label_files = list((COMBINED_DATASET / \"labels/val\").glob(\"*.txt\"))\n",
+        "\n",
+        "print(\"Combined dataset built\")\n",
+        "print(f\"  train images: {len(list_images(COMBINED_DATASET / 'images/train'))}\")\n",
+        "print(f\"  train labels: {len(train_label_files)}\")\n",
+        "print(f\"  val images: {len(list_images(COMBINED_DATASET / 'images/val'))}\")\n",
+        "print(f\"  val labels: {len(val_label_files)}\")\n",
+        "print(f\"  train class counts: {class_counts(train_label_files)}\")\n",
+        "print(f\"  val class counts: {class_counts(val_label_files)}\")\n",
+        "print(YAML_PATH.read_text(encoding=\"utf-8\"))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "---\n",
+        "## Step 10 - Visual sanity check"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "cellView": "form"
+      },
+      "outputs": [],
+      "source": [
+        "# @title Step 10 - Visual sanity check\n",
+        "\n",
+        "def draw_label_overlay(img_path: Path, label_path: Path) -> np.ndarray:\n",
+        "    img = read_image(img_path)\n",
+        "    if img is None:\n",
+        "        raise ValueError(f\"Cannot read {img_path}\")\n",
+        "    h, w = img.shape[:2]\n",
+        "    scale = 720 / max(w, h)\n",
+        "    disp = cv2.resize(img, (int(w * scale), int(h * scale)), interpolation=cv2.INTER_AREA)\n",
+        "    dh, dw = disp.shape[:2]\n",
+        "    colors = {\n",
+        "        0: (0, 220, 0),\n",
+        "        1: (255, 80, 0),\n",
+        "    }\n",
+        "\n",
+        "    lines = valid_seg_lines(label_path, {0, 1})\n",
+        "    for line in lines:\n",
+        "        parts = line.split()\n",
+        "        cls = int(parts[0])\n",
+        "        vals = np.array([float(v) for v in parts[1:]], dtype=np.float32).reshape(-1, 2)\n",
+        "        pts = (vals * np.array([dw, dh], dtype=np.float32)).astype(np.int32).reshape(-1, 1, 2)\n",
+        "        color = colors.get(cls, (0, 255, 255))\n",
+        "        overlay = disp.copy()\n",
+        "        cv2.fillPoly(overlay, [pts], color)\n",
+        "        cv2.addWeighted(overlay, 0.25, disp, 0.75, 0, disp)\n",
+        "        cv2.polylines(disp, [pts], True, color, 2)\n",
+        "        x, y = pts[0, 0]\n",
+        "        cv2.putText(disp, str(cls), (int(x), int(y)), cv2.FONT_HERSHEY_SIMPLEX, 0.8, color, 2)\n",
+        "    return cv2.cvtColor(disp, cv2.COLOR_BGR2RGB)\n",
+        "\n",
+        "\n",
+        "preview_imgs = list_images(COMBINED_DATASET / \"images/train\")\n",
+        "preview_imgs = random.sample(preview_imgs, min(6, len(preview_imgs)))\n",
+        "\n",
+        "if preview_imgs:\n",
+        "    fig, axes = plt.subplots(2, 3, figsize=(18, 10))\n",
+        "    axes = axes.flatten()\n",
+        "    for ax, img_path in zip(axes, preview_imgs):\n",
+        "        lbl_path = COMBINED_DATASET / \"labels/train\" / f\"{img_path.stem}.txt\"\n",
+        "        ax.imshow(draw_label_overlay(img_path, lbl_path))\n",
+        "        ax.set_title(img_path.name, fontsize=9)\n",
+        "        ax.axis(\"off\")\n",
+        "    for ax in axes[len(preview_imgs):]:\n",
+        "        ax.axis(\"off\")\n",
+        "    plt.tight_layout()\n",
+        "    plt.show()\n",
+        "else:\n",
+        "    print(\"No preview images found\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "---\n",
+        "## Step 11 - Train YOLO-seg"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "cellView": "form"
+      },
+      "outputs": [],
+      "source": [
+        "# @title Step 11 - Train YOLO-seg\n",
+        "\n",
+        "from ultralytics import YOLO\n",
+        "\n",
+        "TRAIN_MODEL = \"yolo11x-seg.pt\"  # @param [\"yolo11n-seg.pt\",\"yolo11m-seg.pt\",\"yolo11x-seg.pt\"]\n",
+        "EPOCHS = 120  # @param {type:\"integer\"}\n",
+        "IMG_SIZE = 640  # @param {type:\"integer\"}\n",
+        "BATCH = -1  # @param {type:\"integer\"}\n",
+        "PATIENCE = 35  # @param {type:\"integer\"}\n",
+        "RUN_NAME = \"gas_valve_seg_v1\"  # @param {type:\"string\"}\n",
+        "\n",
+        "print(\"Training config\")\n",
+        "print(f\"  model: {TRAIN_MODEL}\")\n",
+        "print(f\"  data: {YAML_PATH}\")\n",
+        "print(f\"  epochs: {EPOCHS}\")\n",
+        "print(f\"  imgsz: {IMG_SIZE}\")\n",
+        "print(f\"  batch: {BATCH}\")\n",
+        "print(f\"  run: {RUN_NAME}\")\n",
+        "\n",
+        "model = YOLO(TRAIN_MODEL)\n",
+        "t_start = time.time()\n",
+        "train_results = model.train(\n",
+        "    data=str(YAML_PATH),\n",
+        "    epochs=EPOCHS,\n",
+        "    imgsz=IMG_SIZE,\n",
+        "    batch=BATCH,\n",
+        "    patience=PATIENCE,\n",
+        "    project=\"/content/runs\",\n",
+        "    name=RUN_NAME,\n",
+        "    device=\"0\" if torch.cuda.is_available() else \"cpu\",\n",
+        "    workers=2,\n",
+        "    amp=True,\n",
+        "    plots=True,\n",
+        "    save=True,\n",
+        "    verbose=True,\n",
+        "    hsv_h=0.015,\n",
+        "    hsv_s=0.7,\n",
+        "    hsv_v=0.4,\n",
+        "    degrees=8.0,\n",
+        "    translate=0.1,\n",
+        "    scale=0.5,\n",
+        "    flipud=0.0,\n",
+        "    fliplr=0.5,\n",
+        "    mosaic=0.8,\n",
+        "    close_mosaic=10,\n",
+        "    copy_paste=0.05,\n",
+        ")\n",
+        "\n",
+        "RUN_DIR = Path(train_results.save_dir)\n",
+        "elapsed = time.time() - t_start\n",
+        "print(f\"Training finished in {elapsed / 60:.1f} min\")\n",
+        "print(f\"Run dir: {RUN_DIR}\")\n",
+        "print(f\"Best weights: {RUN_DIR / 'weights/best.pt'}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "---\n",
+        "## Step 12 - Review results"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "cellView": "form"
+      },
+      "outputs": [],
+      "source": [
+        "# @title Step 12 - Review results\n",
+        "\n",
+        "import pandas as pd\n",
+        "import matplotlib.image as mpimg\n",
+        "\n",
+        "results_csv = RUN_DIR / \"results.csv\"\n",
+        "if results_csv.exists():\n",
+        "    df = pd.read_csv(results_csv)\n",
+        "    df.columns = df.columns.str.strip()\n",
+        "    map_cols = [c for c in df.columns if \"mAP50\" in c]\n",
+        "    if map_cols:\n",
+        "        best_idx = df[map_cols[0]].idxmax()\n",
+        "        print(\"Best row\")\n",
+        "        print(df.iloc[best_idx][[\"epoch\"] + map_cols].to_string())\n",
+        "\n",
+        "for name in [\"results.png\", \"confusion_matrix_normalized.png\", \"confusion_matrix.png\"]:\n",
+        "    p = RUN_DIR / name\n",
+        "    if p.exists():\n",
+        "        plt.figure(figsize=(14, 7))\n",
+        "        plt.imshow(mpimg.imread(str(p)))\n",
+        "        plt.axis(\"off\")\n",
+        "        plt.title(name)\n",
+        "        plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "---\n",
+        "## Step 13 - Upload training results"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "cellView": "form"
+      },
+      "outputs": [],
+      "source": [
+        "# @title Step 13 - Upload training results\n",
+        "\n",
+        "UPLOAD_TRAINING_RESULTS = True  # @param {type:\"boolean\"}\n",
+        "UPLOAD_REPO = DATASET_REPO  # @param {type:\"string\"}\n",
+        "UPLOAD_REPO_TYPE = \"dataset\"  # @param [\"dataset\", \"model\"]\n",
+        "\n",
+        "if UPLOAD_TRAINING_RESULTS:\n",
+        "    upload_items = [\n",
+        "        \"weights/best.pt\",\n",
+        "        \"weights/last.pt\",\n",
+        "        \"results.png\",\n",
+        "        \"results.csv\",\n",
+        "        \"args.yaml\",\n",
+        "        \"confusion_matrix_normalized.png\",\n",
+        "        \"confusion_matrix.png\",\n",
+        "        \"BoxP_curve.png\",\n",
+        "        \"BoxR_curve.png\",\n",
+        "        \"BoxF1_curve.png\",\n",
+        "        \"BoxPR_curve.png\",\n",
+        "        \"MaskP_curve.png\",\n",
+        "        \"MaskR_curve.png\",\n",
+        "        \"MaskF1_curve.png\",\n",
+        "        \"MaskPR_curve.png\",\n",
+        "    ]\n",
+        "\n",
+        "    operations = []\n",
+        "    for rel in upload_items:\n",
+        "        local_file = RUN_DIR / rel\n",
+        "        if not local_file.exists():\n",
+        "            continue\n",
+        "        operations.append(CommitOperationAdd(\n",
+        "            path_in_repo=f\"runs/{RUN_NAME}/{rel}\",\n",
+        "            path_or_fileobj=local_file.read_bytes(),\n",
+        "        ))\n",
+        "        print(f\"Prepared {rel}\")\n",
+        "\n",
+        "    operations.append(CommitOperationAdd(\n",
+        "        path_in_repo=f\"runs/{RUN_NAME}/dataset.yaml\",\n",
+        "        path_or_fileobj=YAML_PATH.read_bytes(),\n",
+        "    ))\n",
+        "\n",
+        "    if operations:\n",
+        "        api.create_commit(\n",
+        "            repo_id=UPLOAD_REPO,\n",
+        "            repo_type=UPLOAD_REPO_TYPE,\n",
+        "            token=HF_TOKEN,\n",
+        "            operations=operations,\n",
+        "            commit_message=f\"Training_results_{RUN_NAME}\",\n",
+        "        )\n",
+        "        print(f\"Uploaded results to https://huggingface.co/datasets/{UPLOAD_REPO}/tree/main/runs/{RUN_NAME}\")\n",
+        "    else:\n",
+        "        print(\"No result files found to upload\")\n",
+        "else:\n",
+        "    print(\"Skipping result upload\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "---\n",
+        "## Done\n",
+        "\n",
+        "The best model is in `RUN_DIR / \"weights/best.pt\"`."
+      ]
+    }
+  ]
+}

notebooks/colab_gas_valve_auto_label_train.py

@@ -0,0 +1,823 @@
+# ============================================================
+# Gas + valve YOLO-seg Colab pipeline
+#
+# Flow:
+# 1. Authenticate HuggingFace
+# 2. Download old gas dataset + raw valve/gas-extra folders
+# 3. Auto-label new gas images and gas regions in valve images
+# 4. Auto-label valve polygons with process_valve_to_polygon.py
+# 5. Build a two-class YOLO-seg dataset
+# 6. Train and upload results
+# ============================================================
+
+
+# %% [markdown]
+# # Gas + valve auto-labeling and training
+#
+# This notebook expects the HuggingFace dataset repo to contain:
+#
+# - `images/train/` and `labels/train/`: existing gas-cylinder labels
+# - `raw/valve/`: valve images plus bbox `.txt` priors
+# - `raw/gas_extra/`: extra gas-cylinder images
+# - `scripts/process_valve_to_polygon.py`: valve polygon auto-label script
+#
+# Class mapping:
+#
+# - `0`: `gas_cylinder`
+# - `1`: `valve`
+
+
+# %% [markdown]
+# ---
+# ## Step 1 - Install dependencies
+
+
+# %%
+# @title Step 1 - Install dependencies
+
+get_ipython().system(
+    "pip install -q ultralytics huggingface_hub opencv-python-headless "
+    "tqdm pyyaml matplotlib pandas"
+)
+
+import os
+import sys
+import time
+import shutil
+import random
+import subprocess
+from pathlib import Path
+
+import cv2
+import yaml
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+
+from tqdm.notebook import tqdm
+from huggingface_hub import (
+    HfApi,
+    login,
+    snapshot_download,
+    CommitOperationAdd,
+)
+
+print("Dependencies installed")
+print(f"Python: {sys.version.split()[0]}")
+print(f"PyTorch: {torch.__version__}")
+print(f"CUDA available: {torch.cuda.is_available()}")
+if torch.cuda.is_available():
+    print(f"GPU: {torch.cuda.get_device_name(0)}")
+
+
+# %% [markdown]
+# ---
+# ## Step 2 - HuggingFace authentication
+
+
+# %%
+# @title Step 2 - HuggingFace authentication
+# @markdown Token needs write permission if you want to upload generated labels and training results.
+
+HF_TOKEN = ""  # @param {type:"string"}
+DATASET_REPO = "rick003/11111"  # @param {type:"string"}
+
+if not HF_TOKEN:
+    from getpass import getpass
+
+    HF_TOKEN = getpass("HuggingFace token: ")
+
+if not HF_TOKEN:
+    raise ValueError("HF_TOKEN is required")
+
+login(token=HF_TOKEN, add_to_git_credential=False)
+api = HfApi()
+api.dataset_info(DATASET_REPO, token=HF_TOKEN)
+
+print("HuggingFace authentication OK")
+print(f"Dataset: https://huggingface.co/datasets/{DATASET_REPO}")
+
+
+# %% [markdown]
+# ---
+# ## Step 3 - Download required files
+
+
+# %%
+# @title Step 3 - Download required files
+# @markdown Downloads only the files needed for joint labeling/training.
+
+DATASET_LOCAL = "/content/hf_11111"  # @param {type:"string"}
+RAW_VALVE_PREFIX = "raw/valve"
+RAW_GAS_EXTRA_PREFIX = "raw/gas_extra"
+PROCESS_SCRIPT_REPO_PATH = "scripts/process_valve_to_polygon.py"
+FORCE_REDOWNLOAD = False  # @param {type:"boolean"}
+
+base = Path(DATASET_LOCAL)
+if FORCE_REDOWNLOAD and base.exists():
+    shutil.rmtree(base)
+
+allow_patterns = [
+    "images/train/**",
+    "labels/train/**",
+    f"{RAW_VALVE_PREFIX}/**",
+    f"{RAW_GAS_EXTRA_PREFIX}/**",
+    PROCESS_SCRIPT_REPO_PATH,
+    "dataset.yaml",
+]
+
+print(f"Downloading dataset files to {DATASET_LOCAL}")
+snapshot_download(
+    repo_id=DATASET_REPO,
+    repo_type="dataset",
+    token=HF_TOKEN,
+    local_dir=DATASET_LOCAL,
+    allow_patterns=allow_patterns,
+    ignore_patterns=["runs/**", "preview/**", "*.cache", ".git/**"],
+)
+
+RAW_VALVE_DIR = base / RAW_VALVE_PREFIX
+RAW_GAS_EXTRA_DIR = base / RAW_GAS_EXTRA_PREFIX
+PROCESS_SCRIPT_LOCAL = base / PROCESS_SCRIPT_REPO_PATH
+
+print("Download summary")
+for p in [base / "images/train", base / "labels/train", RAW_VALVE_DIR, RAW_GAS_EXTRA_DIR]:
+    n = len(list(p.glob("*"))) if p.exists() else 0
+    print(f"  {p}: {n} entries")
+
+if not RAW_VALVE_DIR.exists():
+    raise FileNotFoundError(f"Missing {RAW_VALVE_PREFIX} in HF dataset")
+if not RAW_GAS_EXTRA_DIR.exists():
+    raise FileNotFoundError(f"Missing {RAW_GAS_EXTRA_PREFIX} in HF dataset")
+if not PROCESS_SCRIPT_LOCAL.exists():
+    raise FileNotFoundError(
+        f"Missing {PROCESS_SCRIPT_REPO_PATH}. Upload process_valve_to_polygon.py "
+        "to this path before running valve auto-labeling."
+    )
+
+
+# %% [markdown]
+# ---
+# ## Step 4 - Shared helpers
+
+
+# %%
+# @title Step 4 - Shared helpers
+
+IMG_EXTS = {".png", ".jpg", ".jpeg", ".bmp", ".webp"}
+WORK_DIR = Path("/content/gas_valve_work")
+LABEL_WORK_DIR = WORK_DIR / "labels"
+VIS_WORK_DIR = WORK_DIR / "visual"
+for d in [LABEL_WORK_DIR, VIS_WORK_DIR]:
+    d.mkdir(parents=True, exist_ok=True)
+
+
+def list_images(folder: Path) -> list[Path]:
+    if not folder.exists():
+        return []
+    return sorted(
+        p for p in folder.iterdir()
+        if p.is_file() and p.suffix.lower() in IMG_EXTS
+    )
+
+
+def find_image_by_stem(folder: Path, stem: str) -> Path | None:
+    for ext in IMG_EXTS:
+        p = folder / f"{stem}{ext}"
+        if p.exists():
+            return p
+    for p in folder.glob(f"{stem}.*"):
+        if p.suffix.lower() in IMG_EXTS:
+            return p
+    return None
+
+
+def read_image(path: Path) -> np.ndarray | None:
+    raw = np.fromfile(str(path), dtype=np.uint8)
+    if raw.size == 0:
+        return None
+    return cv2.imdecode(raw, cv2.IMREAD_COLOR)
+
+
+def valid_seg_lines(label_path: Path, allowed_classes: set[int] | None = None) -> list[str]:
+    if not label_path.exists():
+        return []
+    text = label_path.read_text(encoding="utf-8", errors="ignore").strip()
+    if not text:
+        return []
+
+    lines: list[str] = []
+    for raw_line in text.splitlines():
+        parts = raw_line.strip().split()
+        if len(parts) < 7:
+            continue
+        try:
+            cls = int(float(parts[0]))
+            coords = [float(v) for v in parts[1:]]
+        except ValueError:
+            continue
+        if allowed_classes is not None and cls not in allowed_classes:
+            continue
+        if len(coords) < 6 or len(coords) % 2 != 0:
+            continue
+        coords = [min(1.0, max(0.0, v)) for v in coords]
+        out = [str(cls)] + [f"{v:.6f}" for v in coords]
+        lines.append(" ".join(out))
+    return lines
+
+
+def write_lines(path: Path, lines: list[str]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text("\n".join(lines).strip() + ("\n" if lines else ""), encoding="utf-8")
+
+
+def class_counts(label_files: list[Path]) -> dict[int, int]:
+    counts: dict[int, int] = {}
+    for p in label_files:
+        for line in p.read_text(encoding="utf-8", errors="ignore").splitlines():
+            parts = line.strip().split()
+            if not parts:
+                continue
+            try:
+                cls = int(float(parts[0]))
+            except ValueError:
+                continue
+            counts[cls] = counts.get(cls, 0) + 1
+    return counts
+
+
+print(f"Old train images: {len(list_images(base / 'images/train'))}")
+print(f"Old train labels: {len(list((base / 'labels/train').glob('*.txt')))}")
+print(f"Raw valve images: {len(list_images(RAW_VALVE_DIR))}")
+print(f"Raw gas-extra images: {len(list_images(RAW_GAS_EXTRA_DIR))}")
+
+
+# %% [markdown]
+# ---
+# ## Step 5 - Gas-cylinder auto-labeler
+
+
+# %%
+# @title Step 5 - Gas-cylinder auto-labeler
+
+
+class GasCylinderSegmenter:
+    CLASS_WEIGHTS = {
+        39: 2.0,   # bottle
+        10: 1.0,   # fire hydrant
+        71: 1.0,   # sink
+        61: 1.0,   # toilet
+        41: 0.8,   # cup
+        56: 0.8,   # chair
+        75: 0.8,   # vase
+    }
+
+    def __init__(self, model_path: str = "yolo11x-seg.pt", class_id: int = 0) -> None:
+        from ultralytics import YOLO
+
+        self.device = "0" if torch.cuda.is_available() else "cpu"
+        self.class_id = class_id
+        self.model = YOLO(model_path)
+        self.conf = 0.01
+        self.min_area = 0.03
+        self.max_dist = 0.35
+        print(f"Gas label model: {model_path}, device={self.device}, class_id={class_id}")
+
+    def annotate(self, img: np.ndarray) -> tuple[str, bool]:
+        h, w = img.shape[:2]
+        cx, cy = w / 2.0, h / 2.0
+        area = float(w * h)
+        diag = float(w * w + h * h) ** 0.5
+
+        result = self.model(img, conf=self.conf, device=self.device, verbose=False)[0]
+        candidates = []
+
+        if result.masks is not None:
+            for i in range(len(result.masks.data)):
+                cls_id = int(result.boxes.cls[i])
+                if cls_id not in self.CLASS_WEIGHTS:
+                    continue
+
+                conf = float(result.boxes.conf[i])
+                x1, y1, x2, y2 = result.boxes.xyxy[i].tolist()
+                box_cx = (x1 + x2) / 2.0
+                box_cy = (y1 + y2) / 2.0
+                area_ratio = (x2 - x1) * (y2 - y1) / area
+                dist_ratio = ((box_cx - cx) ** 2 + (box_cy - cy) ** 2) ** 0.5 / diag
+
+                if area_ratio < self.min_area or dist_ratio > self.max_dist:
+                    continue
+
+                centrality_bonus = 1.0 + (1.0 - dist_ratio / self.max_dist)
+                score = conf * self.CLASS_WEIGHTS[cls_id] * centrality_bonus
+                candidates.append((score, result.masks.xyn[i]))
+
+        if not candidates:
+            return "", False
+
+        _, poly = max(candidates, key=lambda x: x[0])
+        if len(poly) < 3:
+            return "", False
+
+        tokens = [str(self.class_id)]
+        for x, y in poly:
+            tokens.append(f"{float(x):.6f}")
+            tokens.append(f"{float(y):.6f}")
+        return " ".join(tokens), True
+
+
+def auto_label_gas_folder(
+    segmenter: GasCylinderSegmenter,
+    image_dir: Path,
+    labels_dir: Path,
+    *,
+    overwrite: bool = False,
+    limit: int = 0,
+) -> dict[str, int]:
+    labels_dir.mkdir(parents=True, exist_ok=True)
+    images = list_images(image_dir)
+    if limit > 0:
+        images = images[:limit]
+
+    stats = {"ok": 0, "failed": 0, "error": 0, "skipped": 0}
+    for image_path in tqdm(images, desc=f"Gas labels: {image_dir.name}"):
+        label_path = labels_dir / f"{image_path.stem}.txt"
+        if label_path.exists() and label_path.stat().st_size > 0 and not overwrite:
+            stats["skipped"] += 1
+            continue
+
+        img = read_image(image_path)
+        if img is None:
+            write_lines(label_path, [])
+            stats["error"] += 1
+            continue
+
+        try:
+            label, ok = segmenter.annotate(img)
+            write_lines(label_path, [label] if ok else [])
+            stats["ok" if ok else "failed"] += 1
+        except Exception as exc:
+            print(f"Gas label error: {image_path.name}: {exc}")
+            write_lines(label_path, [])
+            stats["error"] += 1
+
+    print(f"{image_dir.name}: {stats}")
+    return stats
+
+
+# %% [markdown]
+# ---
+# ## Step 6 - Auto-label new gas data
+
+
+# %%
+# @title Step 6 - Auto-label new gas data
+# @markdown Gas labels are generated for both extra gas images and valve images.
+# @markdown The valve-image gas labels prevent visible gas cylinders from being treated as background.
+
+GAS_LABEL_MODEL = "yolo11x-seg.pt"  # @param ["yolo11n-seg.pt","yolo11m-seg.pt","yolo11x-seg.pt"]
+REGENERATE_GAS_LABELS = False  # @param {type:"boolean"}
+GAS_LABEL_LIMIT = 0  # @param {type:"integer"}
+
+GAS_EXTRA_LABEL_DIR = LABEL_WORK_DIR / "gas_extra"
+VALVE_GAS_LABEL_DIR = LABEL_WORK_DIR / "valve_gas"
+
+gas_segmenter = GasCylinderSegmenter(GAS_LABEL_MODEL, class_id=0)
+gas_extra_stats = auto_label_gas_folder(
+    gas_segmenter,
+    RAW_GAS_EXTRA_DIR,
+    GAS_EXTRA_LABEL_DIR,
+    overwrite=REGENERATE_GAS_LABELS,
+    limit=GAS_LABEL_LIMIT,
+)
+valve_gas_stats = auto_label_gas_folder(
+    gas_segmenter,
+    RAW_VALVE_DIR,
+    VALVE_GAS_LABEL_DIR,
+    overwrite=REGENERATE_GAS_LABELS,
+    limit=GAS_LABEL_LIMIT,
+)
+
+
+# %% [markdown]
+# ---
+# ## Step 7 - Auto-label valve polygons
+
+
+# %%
+# @title Step 7 - Auto-label valve polygons
+# @markdown Uses `process_valve_to_polygon.py` and the bbox `.txt` priors in `raw/valve/`.
+
+VALVE_LABEL_MODEL = "yolo11x-seg.pt"  # @param ["yolo11n-seg.pt","yolo11m-seg.pt","yolo11x-seg.pt"]
+REGENERATE_VALVE_LABELS = False  # @param {type:"boolean"}
+SAVE_VALVE_VISUALIZATIONS = False  # @param {type:"boolean"}
+VALVE_LABEL_LIMIT = 0  # @param {type:"integer"}
+
+VALVE_LABEL_DIR = LABEL_WORK_DIR / "valve"
+VALVE_VIS_DIR = VIS_WORK_DIR / "valve"
+VALVE_LABEL_DIR.mkdir(parents=True, exist_ok=True)
+VALVE_VIS_DIR.mkdir(parents=True, exist_ok=True)
+
+device = "0" if torch.cuda.is_available() else "cpu"
+cmd = [
+    sys.executable,
+    str(PROCESS_SCRIPT_LOCAL),
+    "--image-dir",
+    str(RAW_VALVE_DIR),
+    "--labels-dir",
+    str(VALVE_LABEL_DIR),
+    "--vis-dir",
+    str(VALVE_VIS_DIR),
+    "--bbox-dir",
+    str(RAW_VALVE_DIR),
+    "--class-id",
+    "1",
+    "--model",
+    VALVE_LABEL_MODEL,
+    "--device",
+    device,
+]
+if REGENERATE_VALVE_LABELS:
+    cmd.append("--overwrite")
+if not SAVE_VALVE_VISUALIZATIONS:
+    cmd.append("--skip-visualizations")
+if VALVE_LABEL_LIMIT > 0:
+    cmd.extend(["--limit", str(VALVE_LABEL_LIMIT)])
+
+print("Running valve auto-labeler")
+print(" ".join(cmd))
+subprocess.run(cmd, check=True)
+
+valve_labels = list(VALVE_LABEL_DIR.glob("*.txt"))
+print(f"Valve label files: {len(valve_labels)}")
+print(f"Valve non-empty labels: {sum(1 for p in valve_labels if p.stat().st_size > 0)}")
+
+
+# %% [markdown]
+# ---
+# ## Step 8 - Optionally upload generated labels
+
+
+# %%
+# @title Step 8 - Optionally upload generated labels
+# @markdown Uploads generated labels under `auto_labels/gas_valve_v1/`.
+
+UPLOAD_GENERATED_LABELS = True  # @param {type:"boolean"}
+GENERATED_LABELS_REPO_DIR = "auto_labels/gas_valve_v1"  # @param {type:"string"}
+
+if UPLOAD_GENERATED_LABELS:
+    print(f"Uploading generated labels to {GENERATED_LABELS_REPO_DIR}")
+    api.upload_folder(
+        repo_id=DATASET_REPO,
+        repo_type="dataset",
+        token=HF_TOKEN,
+        folder_path=str(LABEL_WORK_DIR),
+        path_in_repo=GENERATED_LABELS_REPO_DIR,
+        commit_message="upload_generated_gas_valve_labels",
+    )
+    print("Generated labels uploaded")
+else:
+    print("Skipping generated label upload")
+
+
+# %% [markdown]
+# ---
+# ## Step 9 - Build the two-class training dataset
+
+
+# %%
+# @title Step 9 - Build the two-class training dataset
+
+COMBINED_DATASET = Path("/content/gas_valve_dataset")
+VAL_RATIO = 0.20  # @param {type:"number"}
+RANDOM_SEED = 42  # @param {type:"integer"}
+INCLUDE_OLD_GAS_DATA = True  # @param {type:"boolean"}
+
+if COMBINED_DATASET.exists():
+    shutil.rmtree(COMBINED_DATASET)
+
+for split in ["train", "val"]:
+    (COMBINED_DATASET / f"images/{split}").mkdir(parents=True, exist_ok=True)
+    (COMBINED_DATASET / f"labels/{split}").mkdir(parents=True, exist_ok=True)
+
+samples: list[dict] = []
+
+if INCLUDE_OLD_GAS_DATA:
+    old_img_dir = base / "images/train"
+    old_lbl_dir = base / "labels/train"
+    for lbl_path in sorted(old_lbl_dir.glob("*.txt")):
+        lines = valid_seg_lines(lbl_path, {0})
+        if not lines:
+            continue
+        img_path = find_image_by_stem(old_img_dir, lbl_path.stem)
+        if img_path is None:
+            continue
+        samples.append({
+            "image": img_path,
+            "lines": lines,
+            "group": "gas",
+            "source": "old_gas",
+        })
+
+for img_path in list_images(RAW_GAS_EXTRA_DIR):
+    lines = valid_seg_lines(GAS_EXTRA_LABEL_DIR / f"{img_path.stem}.txt", {0})
+    if not lines:
+        continue
+    samples.append({
+        "image": img_path,
+        "lines": lines,
+        "group": "gas",
+        "source": "gas_extra",
+    })
+
+for img_path in list_images(RAW_VALVE_DIR):
+    valve_lines = valid_seg_lines(VALVE_LABEL_DIR / f"{img_path.stem}.txt", {1})
+    if not valve_lines:
+        continue
+    gas_lines = valid_seg_lines(VALVE_GAS_LABEL_DIR / f"{img_path.stem}.txt", {0})
+    samples.append({
+        "image": img_path,
+        "lines": gas_lines + valve_lines,
+        "group": "valve",
+        "source": "valve",
+    })
+
+print(f"Collected labeled samples: {len(samples)}")
+print(f"  gas samples: {sum(1 for s in samples if s['group'] == 'gas')}")
+print(f"  valve samples: {sum(1 for s in samples if s['group'] == 'valve')}")
+
+if not any(s["group"] == "valve" for s in samples):
+    raise RuntimeError("No valve samples were collected. Check valve auto-label output.")
+
+rng = random.Random(RANDOM_SEED)
+train_samples: list[dict] = []
+val_samples: list[dict] = []
+for group in sorted({s["group"] for s in samples}):
+    group_samples = [s for s in samples if s["group"] == group]
+    rng.shuffle(group_samples)
+    n_val = int(round(len(group_samples) * VAL_RATIO))
+    if len(group_samples) >= 5:
+        n_val = max(1, n_val)
+    val_samples.extend(group_samples[:n_val])
+    train_samples.extend(group_samples[n_val:])
+
+rng.shuffle(train_samples)
+rng.shuffle(val_samples)
+
+
+def materialize(split: str, split_samples: list[dict]) -> None:
+    for idx, sample in enumerate(split_samples, 1):
+        suffix = sample["image"].suffix.lower()
+        stem = f"{sample['source']}_{idx:05d}"
+        dst_img = COMBINED_DATASET / f"images/{split}/{stem}{suffix}"
+        dst_lbl = COMBINED_DATASET / f"labels/{split}/{stem}.txt"
+        shutil.copy2(sample["image"], dst_img)
+        write_lines(dst_lbl, sample["lines"])
+
+
+materialize("train", train_samples)
+materialize("val", val_samples)
+
+YAML_PATH = COMBINED_DATASET / "dataset.yaml"
+yaml_content = {
+    "path": str(COMBINED_DATASET),
+    "train": "images/train",
+    "val": "images/val",
+    "names": {
+        0: "gas_cylinder",
+        1: "valve",
+    },
+}
+YAML_PATH.write_text(
+    yaml.safe_dump(yaml_content, allow_unicode=True, sort_keys=False),
+    encoding="utf-8",
+)
+
+train_label_files = list((COMBINED_DATASET / "labels/train").glob("*.txt"))
+val_label_files = list((COMBINED_DATASET / "labels/val").glob("*.txt"))
+
+print("Combined dataset built")
+print(f"  train images: {len(list_images(COMBINED_DATASET / 'images/train'))}")
+print(f"  train labels: {len(train_label_files)}")
+print(f"  val images: {len(list_images(COMBINED_DATASET / 'images/val'))}")
+print(f"  val labels: {len(val_label_files)}")
+print(f"  train class counts: {class_counts(train_label_files)}")
+print(f"  val class counts: {class_counts(val_label_files)}")
+print(YAML_PATH.read_text(encoding="utf-8"))
+
+
+# %% [markdown]
+# ---
+# ## Step 10 - Visual sanity check
+
+
+# %%
+# @title Step 10 - Visual sanity check
+
+def draw_label_overlay(img_path: Path, label_path: Path) -> np.ndarray:
+    img = read_image(img_path)
+    if img is None:
+        raise ValueError(f"Cannot read {img_path}")
+    h, w = img.shape[:2]
+    scale = 720 / max(w, h)
+    disp = cv2.resize(img, (int(w * scale), int(h * scale)), interpolation=cv2.INTER_AREA)
+    dh, dw = disp.shape[:2]
+    colors = {
+        0: (0, 220, 0),
+        1: (255, 80, 0),
+    }
+
+    lines = valid_seg_lines(label_path, {0, 1})
+    for line in lines:
+        parts = line.split()
+        cls = int(parts[0])
+        vals = np.array([float(v) for v in parts[1:]], dtype=np.float32).reshape(-1, 2)
+        pts = (vals * np.array([dw, dh], dtype=np.float32)).astype(np.int32).reshape(-1, 1, 2)
+        color = colors.get(cls, (0, 255, 255))
+        overlay = disp.copy()
+        cv2.fillPoly(overlay, [pts], color)
+        cv2.addWeighted(overlay, 0.25, disp, 0.75, 0, disp)
+        cv2.polylines(disp, [pts], True, color, 2)
+        x, y = pts[0, 0]
+        cv2.putText(disp, str(cls), (int(x), int(y)), cv2.FONT_HERSHEY_SIMPLEX, 0.8, color, 2)
+    return cv2.cvtColor(disp, cv2.COLOR_BGR2RGB)
+
+
+preview_imgs = list_images(COMBINED_DATASET / "images/train")
+preview_imgs = random.sample(preview_imgs, min(6, len(preview_imgs)))
+
+if preview_imgs:
+    fig, axes = plt.subplots(2, 3, figsize=(18, 10))
+    axes = axes.flatten()
+    for ax, img_path in zip(axes, preview_imgs):
+        lbl_path = COMBINED_DATASET / "labels/train" / f"{img_path.stem}.txt"
+        ax.imshow(draw_label_overlay(img_path, lbl_path))
+        ax.set_title(img_path.name, fontsize=9)
+        ax.axis("off")
+    for ax in axes[len(preview_imgs):]:
+        ax.axis("off")
+    plt.tight_layout()
+    plt.show()
+else:
+    print("No preview images found")
+
+
+# %% [markdown]
+# ---
+# ## Step 11 - Train YOLO-seg
+
+
+# %%
+# @title Step 11 - Train YOLO-seg
+
+from ultralytics import YOLO
+
+TRAIN_MODEL = "yolo11x-seg.pt"  # @param ["yolo11n-seg.pt","yolo11m-seg.pt","yolo11x-seg.pt"]
+EPOCHS = 120  # @param {type:"integer"}
+IMG_SIZE = 640  # @param {type:"integer"}
+BATCH = -1  # @param {type:"integer"}
+PATIENCE = 35  # @param {type:"integer"}
+RUN_NAME = "gas_valve_seg_v1"  # @param {type:"string"}
+
+print("Training config")
+print(f"  model: {TRAIN_MODEL}")
+print(f"  data: {YAML_PATH}")
+print(f"  epochs: {EPOCHS}")
+print(f"  imgsz: {IMG_SIZE}")
+print(f"  batch: {BATCH}")
+print(f"  run: {RUN_NAME}")
+
+model = YOLO(TRAIN_MODEL)
+t_start = time.time()
+train_results = model.train(
+    data=str(YAML_PATH),
+    epochs=EPOCHS,
+    imgsz=IMG_SIZE,
+    batch=BATCH,
+    patience=PATIENCE,
+    project="/content/runs",
+    name=RUN_NAME,
+    device="0" if torch.cuda.is_available() else "cpu",
+    workers=2,
+    amp=True,
+    plots=True,
+    save=True,
+    verbose=True,
+    hsv_h=0.015,
+    hsv_s=0.7,
+    hsv_v=0.4,
+    degrees=8.0,
+    translate=0.1,
+    scale=0.5,
+    flipud=0.0,
+    fliplr=0.5,
+    mosaic=0.8,
+    close_mosaic=10,
+    copy_paste=0.05,
+)
+
+RUN_DIR = Path(train_results.save_dir)
+elapsed = time.time() - t_start
+print(f"Training finished in {elapsed / 60:.1f} min")
+print(f"Run dir: {RUN_DIR}")
+print(f"Best weights: {RUN_DIR / 'weights/best.pt'}")
+
+
+# %% [markdown]
+# ---
+# ## Step 12 - Review results
+
+
+# %%
+# @title Step 12 - Review results
+
+import pandas as pd
+import matplotlib.image as mpimg
+
+results_csv = RUN_DIR / "results.csv"
+if results_csv.exists():
+    df = pd.read_csv(results_csv)
+    df.columns = df.columns.str.strip()
+    map_cols = [c for c in df.columns if "mAP50" in c]
+    if map_cols:
+        best_idx = df[map_cols[0]].idxmax()
+        print("Best row")
+        print(df.iloc[best_idx][["epoch"] + map_cols].to_string())
+
+for name in ["results.png", "confusion_matrix_normalized.png", "confusion_matrix.png"]:
+    p = RUN_DIR / name
+    if p.exists():
+        plt.figure(figsize=(14, 7))
+        plt.imshow(mpimg.imread(str(p)))
+        plt.axis("off")
+        plt.title(name)
+        plt.show()
+
+
+# %% [markdown]
+# ---
+# ## Step 13 - Upload training results
+
+
+# %%
+# @title Step 13 - Upload training results
+
+UPLOAD_TRAINING_RESULTS = True  # @param {type:"boolean"}
+UPLOAD_REPO = DATASET_REPO  # @param {type:"string"}
+UPLOAD_REPO_TYPE = "dataset"  # @param ["dataset", "model"]
+
+if UPLOAD_TRAINING_RESULTS:
+    upload_items = [
+        "weights/best.pt",
+        "weights/last.pt",
+        "results.png",
+        "results.csv",
+        "args.yaml",
+        "confusion_matrix_normalized.png",
+        "confusion_matrix.png",
+        "BoxP_curve.png",
+        "BoxR_curve.png",
+        "BoxF1_curve.png",
+        "BoxPR_curve.png",
+        "MaskP_curve.png",
+        "MaskR_curve.png",
+        "MaskF1_curve.png",
+        "MaskPR_curve.png",
+    ]
+
+    operations = []
+    for rel in upload_items:
+        local_file = RUN_DIR / rel
+        if not local_file.exists():
+            continue
+        operations.append(CommitOperationAdd(
+            path_in_repo=f"runs/{RUN_NAME}/{rel}",
+            path_or_fileobj=local_file.read_bytes(),
+        ))
+        print(f"Prepared {rel}")
+
+    operations.append(CommitOperationAdd(
+        path_in_repo=f"runs/{RUN_NAME}/dataset.yaml",
+        path_or_fileobj=YAML_PATH.read_bytes(),
+    ))
+
+    if operations:
+        api.create_commit(
+            repo_id=UPLOAD_REPO,
+            repo_type=UPLOAD_REPO_TYPE,
+            token=HF_TOKEN,
+            operations=operations,
+            commit_message=f"Training_results_{RUN_NAME}",
+        )
+        print(f"Uploaded results to https://huggingface.co/datasets/{UPLOAD_REPO}/tree/main/runs/{RUN_NAME}")
+    else:
+        print("No result files found to upload")
+else:
+    print("Skipping result upload")
+
+
+# %% [markdown]
+# ---
+# ## Done
+#
+# The best model is in `RUN_DIR / "weights/best.pt"`.

raw/valve/Pic_阀门_1.txt

@@ -0,0 +1 @@
+1 0.653809 0.549333 0.338867 0.454667

raw/valve/Pic_阀门_10.txt

@@ -0,0 +1 @@
+1 0.643921 0.526167 0.346436 0.471667

raw/valve/Pic_阀门_100.txt

@@ -0,0 +1 @@
+1 0.613525 0.585000 0.377930 0.488667

raw/valve/Pic_阀门_101.txt

@@ -0,0 +1 @@
+1 0.531372 0.563833 0.356201 0.485667

raw/valve/Pic_阀门_102.txt

@@ -0,0 +1 @@
+1 0.245972 0.618167 0.452393 0.697000

raw/valve/Pic_阀门_103.txt

@@ -0,0 +1 @@
+1 0.321411 0.547167 0.461182 0.493667

raw/valve/Pic_阀门_104.txt

@@ -0,0 +1 @@
+1 0.433716 0.536833 0.530518 0.522333

raw/valve/Pic_阀门_105.txt

@@ -0,0 +1 @@
+1 0.440796 0.504167 0.488525 0.524333

raw/valve/Pic_阀门_106.txt

@@ -0,0 +1 @@
+1 0.297852 0.506000 0.490723 0.518000

raw/valve/Pic_阀门_107.txt

@@ -0,0 +1 @@
+1 0.365967 0.551167 0.476074 0.665000

raw/valve/Pic_阀门_108.txt

@@ -0,0 +1 @@
+1 0.636963 0.620500 0.365234 0.497000

raw/valve/Pic_阀门_11.txt

@@ -0,0 +1 @@
+1 0.356079 0.519167 0.458740 0.475667

raw/valve/Pic_阀门_110.txt

@@ -0,0 +1 @@
+1 0.513550 0.496167 0.397705 0.527000

raw/valve/Pic_阀门_111.txt

@@ -0,0 +1 @@
+1 0.453125 0.542667 0.403809 0.506667

raw/valve/Pic_阀门_112.txt

@@ -0,0 +1 @@
+1 0.622803 0.541833 0.375977 0.504333

raw/valve/Pic_阀门_113.txt

@@ -0,0 +1 @@
+1 0.440674 0.491667 0.487793 0.589333

raw/valve/Pic_阀门_114.txt

@@ -0,0 +1 @@
+1 0.347046 0.539167 0.441650 0.493667

raw/valve/Pic_阀门_115.txt

@@ -0,0 +1 @@
+1 0.346558 0.518333 0.475830 0.510667

raw/valve/Pic_阀门_116.txt

@@ -0,0 +1 @@
+1 0.437744 0.505667 0.498535 0.531333

raw/valve/Pic_阀门_117.txt

@@ -0,0 +1 @@
+1 0.646362 0.554000 0.379639 0.510667

raw/valve/Pic_阀门_118.txt

@@ -0,0 +1 @@
+1 0.467529 0.555167 0.426758 0.511000

raw/valve/Pic_阀门_119.txt

@@ -0,0 +1 @@
+1 0.402954 0.578833 0.473877 0.509000

raw/valve/Pic_阀门_12.txt

@@ -0,0 +1 @@
+1 0.635376 0.516500 0.352295 0.474333

raw/valve/Pic_阀门_120.txt

@@ -0,0 +1 @@
+1 0.513794 0.648333 0.521729 0.634667

raw/valve/Pic_阀门_121.txt

@@ -0,0 +1 @@
+1 0.412720 0.522000 0.483643 0.566000

raw/valve/Pic_阀门_122.txt

@@ -0,0 +1 @@
+1 0.300293 0.643500 0.486816 0.647000

raw/valve/Pic_阀门_123.txt

@@ -0,0 +1 @@
+1 0.516968 0.545000 0.500244 0.538667

raw/valve/Pic_阀门_124.txt

@@ -0,0 +1 @@
+1 0.640137 0.636167 0.575195 0.665667

raw/valve/Pic_阀门_13.txt

@@ -0,0 +1 @@
+1 0.420776 0.505500 0.451904 0.480333

raw/valve/Pic_阀门_14.txt

@@ -0,0 +1 @@
+1 0.540771 0.505167 0.494629 0.480333

raw/valve/Pic_阀门_15.txt

@@ -0,0 +1 @@
+1 0.379028 0.501667 0.496826 0.485333

raw/valve/Pic_阀门_16.txt

@@ -0,0 +1 @@
+1 0.523926 0.501833 0.502441 0.475667

raw/valve/Pic_阀门_17.txt

@@ -0,0 +1 @@
+1 0.322876 0.495500 0.569580 0.493667

raw/valve/Pic_阀门_18.txt

@@ -0,0 +1 @@
+1 0.493774 0.492167 0.481201 0.488333

raw/valve/Pic_阀门_19.txt

@@ -0,0 +1 @@
+1 0.366211 0.498500 0.460938 0.521000

raw/valve/Pic_阀门_2.txt

@@ -0,0 +1 @@
+1 0.400635 0.502000 0.448730 0.552667

raw/valve/Pic_阀门_20.txt

@@ -0,0 +1 @@
+1 0.654663 0.512833 0.354736 0.479667

raw/valve/Pic_阀门_21.txt

@@ -0,0 +1 @@
+1 0.526367 0.544000 0.384277 0.484667

raw/valve/Pic_阀门_22.txt

@@ -0,0 +1 @@
+1 0.691406 0.548167 0.366211 0.471000

raw/valve/Pic_阀门_23.txt

@@ -0,0 +1 @@
+1 0.490479 0.598000 0.465820 0.625333

raw/valve/Pic_阀门_24.txt

@@ -0,0 +1 @@
+1 0.710083 0.673000 0.353271 0.475333

raw/valve/Pic_阀门_25.txt

@@ -0,0 +1 @@
+1 0.469727 0.624000 0.494629 0.508000

raw/valve/Pic_阀门_26.txt

@@ -0,0 +1 @@
+1 0.706421 0.636833 0.356201 0.478333

raw/valve/Pic_阀门_27.txt

@@ -0,0 +1 @@
+1 0.525024 0.597500 0.400635 0.479000

raw/valve/Pic_阀门_28.txt

@@ -0,0 +1 @@
+1 0.604736 0.595500 0.469238 0.483000

raw/valve/Pic_阀门_29.txt

@@ -0,0 +1 @@
+1 0.464355 0.572833 0.477539 0.489000

raw/valve/Pic_阀门_3.txt

@@ -0,0 +1 @@
+1 0.679443 0.574833 0.353027 0.459667

scripts/process_valve_to_polygon.py

@@ -0,0 +1,2381 @@
+"""
+Auto-label valve handwheels as polygon segmentation masks.
+
+Design notes
+------------
+The valve is the WHITE 5-petal handwheel on top of the gas cylinder.
+Pure YOLO (open-vocabulary / YOLO-World) does not know this specific
+object well and tends to box the whole cylinder, so we use a two-stage
+hybrid pipeline that mirrors ``process_E_to_F.py`` for the gas cylinder:
+
+  Stage 1 (coarse)   : YOLO11x-seg locates the gas cylinder region and
+                       returns a polygon mask. This restricts the valve
+                       search to the cylinder body and avoids spurious
+                       white pixels from walls / ceiling / backlight.
+
+  Stage 2 (fine)     : Inside the cylinder mask, we threshold the L
+                       channel of CIE-LAB with an adaptive (Otsu) cut
+                       to isolate bright pixels. A morphological close
+                       fuses the 5 petals (and their inner holes + the
+                       central bolt hole) into one solid blob, then we
+                       pick the blob that is central, large enough and
+                       not too elongated. Its external contour is the
+                       valve edge label.
+
+Output
+------
+- YOLO-seg label files next to each image (``<class_id> x1 y1 x2 y2 ...``,
+  normalized polygon coordinates). ``class_id`` defaults to 1 so the
+  labels combine cleanly with the gas-cylinder labels (class 0).
+- Optional visualization images with the detected cylinder outlined in
+  blue and the valve polygon filled + outlined in green (same style as
+  ``process_E_to_F.py``).
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+import cv2
+import numpy as np
+
+
+# ----------------------------------------------------------------------
+# Defaults
+# ----------------------------------------------------------------------
+DEFAULT_IMAGE_DIR = Path(r"D:\biyesheji\famen\阀门\阀门")
+DEFAULT_VIS_DIR = Path(r"D:\biyesheji\famen\阀门\valve_poly_visualized")
+DEFAULT_DEBUG_DIR = Path(r"D:\biyesheji\famen\阀门\valve_poly_debug")
+DEFAULT_MODEL = "yolo11x-seg.pt"
+IMAGE_SUFFIXES = {".png", ".jpg", ".jpeg", ".bmp", ".webp"}
+
+# COCO class weights for the coarse cylinder locator, kept identical to
+# process_E_to_F.py / auto_label_final_robust.py so behaviour matches.
+CYLINDER_CLASS_WEIGHTS = {
+    39: 2.0,   # bottle  (best match)
+    71: 1.0,   # sink
+    61: 1.0,   # toilet
+    41: 0.8,   # cup
+    56: 0.8,   # chair
+    10: 1.0,   # fire hydrant
+    75: 0.8,   # vase
+}
+
+
+# ----------------------------------------------------------------------
+# Data classes
+# ----------------------------------------------------------------------
+@dataclass
+class CylinderROI:
+    mask: np.ndarray            # uint8 HxW, 255 inside cylinder
+    bbox: tuple[int, int, int, int]  # x1,y1,x2,y2 in original image
+    cls_name: str
+    conf: float
+    polygon_norm: np.ndarray    # Nx2 normalized polygon vertices
+
+
+@dataclass
+class ValveCandidate:
+    contour: np.ndarray         # (N,1,2) int32, image pixel coords
+    area: float
+    perimeter: float
+    circularity: float
+    aspect: float
+    centrality: float
+    dark_center_ratio: float
+    score: float
+
+
+@dataclass
+class FivePetalGeometry:
+    center: tuple[float, float]
+    center_radius: float
+    sector_angles: np.ndarray
+    sector_radii: np.ndarray
+    sector_hole_radii: np.ndarray
+    sector_matched: np.ndarray
+    ring_radius: float
+    hole_radius: float
+    matched_outer: int
+    inner_spots: int
+    score: float
+
+
+# ----------------------------------------------------------------------
+# I/O helpers (unicode-safe for Chinese paths)
+# ----------------------------------------------------------------------
+def imread_unicode(path: Path) -> np.ndarray | None:
+    try:
+        raw = np.fromfile(str(path), dtype=np.uint8)
+    except Exception:
+        return None
+    if raw.size == 0:
+        return None
+    return cv2.imdecode(raw, cv2.IMREAD_COLOR)
+
+
+def read_yolo_bbox(
+    label_path: Path,
+    img_w: int,
+    img_h: int,
+    class_id: int = 1,
+) -> tuple[int, int, int, int] | None:
+    """Read the first matching bbox (class, cx, cy, w, h) from a YOLO
+    label file and return it in ``(x1, y1, x2, y2)`` pixel coords.
+    Returns ``None`` if the file is missing / empty / has no bbox for
+    the given class. Lines that appear to be segmentation labels
+    (more than 5 fields) are ignored so the function doesn't confuse
+    a polygon output with a bbox prior.
+    """
+    if not label_path.exists():
+        return None
+    try:
+        text = label_path.read_text(encoding="utf-8")
+    except Exception:
+        return None
+    for line in text.splitlines():
+        parts = line.strip().split()
+        # Proper YOLO bbox lines have exactly 5 fields.
+        if len(parts) != 5:
+            continue
+        try:
+            cls = int(float(parts[0]))
+        except ValueError:
+            continue
+        if cls != class_id:
+            continue
+        try:
+            cx, cy, bw, bh = (float(p) for p in parts[1:5])
+        except ValueError:
+            continue
+        x1 = int(round((cx - bw / 2.0) * img_w))
+        y1 = int(round((cy - bh / 2.0) * img_h))
+        x2 = int(round((cx + bw / 2.0) * img_w))
+        y2 = int(round((cy + bh / 2.0) * img_h))
+        x1 = max(0, min(img_w - 1, x1))
+        y1 = max(0, min(img_h - 1, y1))
+        x2 = max(0, min(img_w, x2))
+        y2 = max(0, min(img_h, y2))
+        if x2 - x1 < 5 or y2 - y1 < 5:
+            return None
+        return (x1, y1, x2, y2)
+    return None
+
+
+def imwrite_unicode(path: Path, image: np.ndarray) -> bool:
+    suffix = path.suffix.lower()
+    ext = ".jpg" if suffix in {".jpg", ".jpeg"} else ".png"
+    ok, buf = cv2.imencode(ext, image)
+    if not ok:
+        return False
+    path.parent.mkdir(parents=True, exist_ok=True)
+    buf.tofile(str(path))
+    return True
+
+
+# ----------------------------------------------------------------------
+# Stage 1 — cylinder locator (YOLO11x-seg)
+# ----------------------------------------------------------------------
+class CylinderLocator:
+    """Locate the gas cylinder to restrict the valve search area."""
+
+    def __init__(self, model_path: str, device: str = "cpu") -> None:
+        from ultralytics import YOLO
+
+        print(f"[Cylinder] Loading {model_path} on device={device} ...", flush=True)
+        self.model = YOLO(model_path)
+        self.device = device
+        self.conf_threshold = 0.01
+        self.min_area_ratio = 0.03
+        self.max_dist_ratio = 0.35
+
+    def locate(self, img: np.ndarray) -> CylinderROI | None:
+        h, w = img.shape[:2]
+        cx, cy = w / 2.0, h / 2.0
+        diag = float(w * w + h * h) ** 0.5
+        total_area = float(w * h)
+
+        result = self.model(
+            img,
+            conf=self.conf_threshold,
+            device=self.device,
+            verbose=False,
+        )[0]
+
+        if result.masks is None:
+            return None
+
+        best: CylinderROI | None = None
+        best_score = -1.0
+
+        for i in range(len(result.masks.data)):
+            cls_id = int(result.boxes.cls[i])
+            if cls_id not in CYLINDER_CLASS_WEIGHTS:
+                continue
+
+            conf = float(result.boxes.conf[i])
+            x1, y1, x2, y2 = result.boxes.xyxy[i].tolist()
+
+            box_area = (x2 - x1) * (y2 - y1)
+            area_ratio = box_area / total_area
+            if area_ratio < self.min_area_ratio:
+                continue
+
+            bcx = (x1 + x2) / 2.0
+            bcy = (y1 + y2) / 2.0
+            dist_ratio = ((bcx - cx) ** 2 + (bcy - cy) ** 2) ** 0.5 / diag
+            if dist_ratio > self.max_dist_ratio:
+                continue
+
+            centrality_bonus = 1.0 + (1.0 - dist_ratio / self.max_dist_ratio)
+            score = conf * CYLINDER_CLASS_WEIGHTS[cls_id] * centrality_bonus
+            if score <= best_score:
+                continue
+
+            poly_norm = result.masks.xyn[i]
+            if len(poly_norm) < 3:
+                continue
+
+            pts = (poly_norm * np.array([w, h])).astype(np.int32).reshape(-1, 1, 2)
+            mask = np.zeros((h, w), dtype=np.uint8)
+            cv2.fillPoly(mask, [pts], 255)
+
+            best = CylinderROI(
+                mask=mask,
+                bbox=(int(x1), int(y1), int(x2), int(y2)),
+                cls_name=result.names[cls_id],
+                conf=conf,
+                polygon_norm=poly_norm,
+            )
+            best_score = score
+
+        return best
+
+
+# ----------------------------------------------------------------------
+# Stage 2 — white handwheel detector
+# ----------------------------------------------------------------------
+def _compute_bright_mask(
+    img: np.ndarray,
+    percentile: float,
+    min_thresh: int,
+    neutral_tol: int,
+) -> tuple[np.ndarray, np.ndarray, int]:
+    """Threshold the L channel (LAB) to isolate bright, colour-neutral
+    pixels globally. Returns ``(bright_mask, L, threshold)``."""
+    lab = cv2.cvtColor(img, cv2.COLOR_BGR2LAB)
+    L, A, B = cv2.split(lab)
+
+    # Exclude extreme overexposed pixels (often from the direct light
+    # source) so they do not dominate the percentile computation.
+    L_for_stats = L[(L > 30) & (L < 252)]
+    if L_for_stats.size == 0:
+        L_for_stats = L.reshape(-1)
+
+    pct_val = float(np.percentile(L_for_stats, percentile))
+    thresh_val = int(max(pct_val, min_thresh))
+
+    # Neutral-colour check: LAB a,b channels are stored offset by 128,
+    # so a neutral grey/white has |a-128|+|b-128| small. A warm wall has
+    # a noticeable yellow tint (b > 128 → diff > 0). The valve itself
+    # is largely neutral even under warm lighting because its white
+    # surface reflects the dominant light colour but with less hue.
+    a_diff = np.abs(A.astype(np.int16) - 128)
+    b_diff = np.abs(B.astype(np.int16) - 128)
+    neutral = (a_diff + b_diff) < neutral_tol
+
+    bright = ((L > thresh_val) & neutral).astype(np.uint8) * 255
+    return bright, L, thresh_val
+
+
+def _find_dark_spots(
+    gray: np.ndarray,
+    min_radius: int,
+    max_radius: int,
+) -> list[tuple[int, int, int]]:
+    """Find small dark circular blobs using SimpleBlobDetector.
+
+    Returns a list of (x, y, radius) in image coords. These correspond
+    to the valve's central bolt and its 5 petal-holes.
+    """
+    params = cv2.SimpleBlobDetector_Params()
+    params.filterByColor = True
+    params.blobColor = 0  # dark blobs on light background
+    params.filterByArea = True
+    params.minArea = float(np.pi * min_radius * min_radius)
+    params.maxArea = float(np.pi * max_radius * max_radius)
+    params.filterByCircularity = True
+    params.minCircularity = 0.45  # loosened to catch slightly-ellipsoidal holes
+    params.filterByConvexity = True
+    params.minConvexity = 0.70
+    params.filterByInertia = True
+    params.minInertiaRatio = 0.25
+    params.minThreshold = 20
+    params.maxThreshold = 220
+    params.thresholdStep = 10
+
+    detector = cv2.SimpleBlobDetector_create(params)
+    kps = detector.detect(gray)
+    return [(int(k.pt[0]), int(k.pt[1]), int(k.size / 2.0)) for k in kps]
+
+
+def _filter_spots_on_bright_surface(
+    spots: list[tuple[int, int, int]],
+    L: np.ndarray,
+    min_surround_L: int,
+    ring_radius_scale: float = 2.2,
+) -> list[tuple[int, int, int]]:
+    """Keep only spots whose immediate surroundings are bright.
+
+    The valve bolt / petal-holes sit on a white handwheel; chain links
+    and dark text on grey cylinder sit on a darker surface. Testing the
+    mean L of a ring just outside the spot reliably separates them.
+    """
+    h, w = L.shape[:2]
+    kept: list[tuple[int, int, int]] = []
+    for (x, y, r) in spots:
+        check_r = int(max(r, 6) * ring_radius_scale)
+        y1 = max(0, y - check_r)
+        y2 = min(h, y + check_r + 1)
+        x1 = max(0, x - check_r)
+        x2 = min(w, x + check_r + 1)
+        patch = L[y1:y2, x1:x2]
+        if patch.size == 0:
+            continue
+        yi, xi = np.ogrid[y1:y2, x1:x2]
+        dist2 = (yi - y) ** 2 + (xi - x) ** 2
+        ring = dist2 > (r * 1.4) ** 2
+        if not ring.any():
+            continue
+        surround_mean = float(patch[ring].mean())
+        if surround_mean >= min_surround_L:
+            kept.append((x, y, r))
+    return kept
+
+
+def _cluster_spots(
+    spots: list[tuple[int, int, int]],
+    max_gap: float,
+    min_cluster_size: int,
+    max_diameter: float | None = None,
+) -> list[list[tuple[int, int, int]]]:
+    """Single-link clustering by proximity, with an optional diameter
+    cap. Two spots belong to the same cluster if their centres are
+    within ``max_gap`` pixels. Clusters whose furthest-pair distance
+    exceeds ``max_diameter`` are split by dropping outliers until they
+    shrink below the cap (this handles cases where a wire bridges
+    valve-hole spots with unrelated background spots).
+    """
+    n = len(spots)
+    if n == 0:
+        return []
+
+    parent = list(range(n))
+
+    def find(x: int) -> int:
+        while parent[x] != x:
+            parent[x] = parent[parent[x]]
+            x = parent[x]
+        return x
+
+    def union(a: int, b: int) -> None:
+        ra, rb = find(a), find(b)
+        if ra != rb:
+            parent[ra] = rb
+
+    for i in range(n):
+        xi, yi, _ = spots[i]
+        for j in range(i + 1, n):
+            xj, yj, _ = spots[j]
+            d = ((xi - xj) ** 2 + (yi - yj) ** 2) ** 0.5
+            if d <= max_gap:
+                union(i, j)
+
+    buckets: dict[int, list[tuple[int, int, int]]] = {}
+    for i in range(n):
+        r = find(i)
+        buckets.setdefault(r, []).append(spots[i])
+
+    raw_clusters = [c for c in buckets.values() if len(c) >= min_cluster_size]
+
+    if max_diameter is None:
+        return raw_clusters
+
+    def cluster_diameter(pts: list[tuple[int, int, int]]) -> float:
+        xs = np.array([s[0] for s in pts], dtype=np.float32)
+        ys = np.array([s[1] for s in pts], dtype=np.float32)
+        cx, cy = float(xs.mean()), float(ys.mean())
+        dists = np.sqrt((xs - cx) ** 2 + (ys - cy) ** 2)
+        return float(dists.max() * 2.0) if dists.size else 0.0
+
+    compact: list[list[tuple[int, int, int]]] = []
+    for cluster in raw_clusters:
+        # Iteratively drop the spot farthest from the centroid until the
+        # cluster is compact enough, or it shrinks below min size.
+        current = list(cluster)
+        while len(current) >= min_cluster_size:
+            xs = np.array([s[0] for s in current], dtype=np.float32)
+            ys = np.array([s[1] for s in current], dtype=np.float32)
+            cx, cy = float(xs.mean()), float(ys.mean())
+            dists = np.sqrt((xs - cx) ** 2 + (ys - cy) ** 2)
+            if float(dists.max() * 2.0) <= max_diameter:
+                break
+            # Drop the farthest spot and try again
+            worst = int(np.argmax(dists))
+            current.pop(worst)
+        if len(current) >= min_cluster_size:
+            if cluster_diameter(current) <= max_diameter:
+                compact.append(current)
+
+    return compact
+
+
+def _wrap_angle(angle: float) -> float:
+    return float((angle + np.pi) % (2.0 * np.pi) - np.pi)
+
+
+def _build_five_petal_mask(
+    shape: tuple[int, int],
+    spots: list[tuple[int, int, int]],
+    center_hint: tuple[float, float],
+    radius_hint: float,
+) -> tuple[np.ndarray, float, int, int] | None:
+    if len(spots) < 3:
+        return None
+
+    cx0, cy0 = center_hint
+    keep_r = max(18.0, radius_hint * 1.35)
+    keep_r2 = keep_r * keep_r
+    local: list[tuple[int, int, int]] = []
+    seen: set[tuple[int, int, int]] = set()
+    for x, y, r in spots:
+        key = (int(x), int(y), int(r))
+        if key in seen:
+            continue
+        seen.add(key)
+        if (key[0] - cx0) ** 2 + (key[1] - cy0) ** 2 <= keep_r2:
+            local.append(key)
+
+    if len(local) < 5:
+        local = list(seen)
+    if len(local) < 3:
+        return None
+
+    d0 = np.array([
+        ((x - cx0) ** 2 + (y - cy0) ** 2) ** 0.5 for (x, y, _) in local
+    ], dtype=np.float32)
+    nearest_idx = int(np.argmin(d0))
+    cx, cy = cx0, cy0
+    if float(d0[nearest_idx]) <= max(8.0, radius_hint * 0.22):
+        cx = 0.80 * cx0 + 0.20 * float(local[nearest_idx][0])
+        cy = 0.80 * cy0 + 0.20 * float(local[nearest_idx][1])
+
+    polar: list[tuple[int, int, int, float, float]] = []
+    for x, y, r in local:
+        dist = float(((x - cx) ** 2 + (y - cy) ** 2) ** 0.5)
+        if dist <= keep_r * 1.05:
+            polar.append((x, y, r, dist, float(np.arctan2(y - cy, x - cx))))
+    if len(polar) < 3:
+        return None
+
+    dvals = np.array([p[3] for p in polar], dtype=np.float32)
+    max_d = float(dvals.max()) if dvals.size else 0.0
+    outer_min = max(radius_hint * 0.22, max_d * 0.35)
+    outer = [p for p in polar if p[3] >= outer_min]
+    if len(outer) < 3:
+        outer = sorted(polar, key=lambda item: item[3], reverse=True)[: min(5, len(polar))]
+    if len(outer) < 3:
+        return None
+
+    inner_limit = max(radius_hint * 0.34, max_d * 0.32)
+    inner_spots = sum(1 for p in polar if p[3] <= inner_limit)
+    step = 2.0 * np.pi / 5.0
+    outer_angles = np.array([p[4] for p in outer], dtype=np.float32)
+    best_base = float(outer_angles[0])
+    best_cost = float("inf")
+    for ang in outer_angles:
+        for k in range(5):
+            base = _wrap_angle(float(ang - step * k))
+            cost = 0.0
+            for obs in outer_angles:
+                cost += min(
+                    abs(_wrap_angle(float(obs - (base + step * j))))
+                    for j in range(5)
+                )
+            if cost < best_cost:
+                best_cost = cost
+                best_base = base
+
+    sector_angles = np.array([
+        _wrap_angle(best_base + step * k) for k in range(5)
+    ], dtype=np.float32)
+    sector_points: list[list[tuple[int, int, int, float, float]]] = [[] for _ in range(5)]
+    ang_errors: list[float] = []
+    max_ang_err = step * 0.42
+    for item in outer:
+        diffs = np.array([
+            abs(_wrap_angle(float(item[4] - ang))) for ang in sector_angles
+        ], dtype=np.float32)
+        idx = int(np.argmin(diffs))
+        if float(diffs[idx]) <= max_ang_err:
+            sector_points[idx].append(item)
+            ang_errors.append(float(diffs[idx]))
+
+    matched_outer = sum(1 for pts in sector_points if pts)
+    if matched_outer < 3:
+        return None
+
+    observed_radii = [
+        float(max(pts, key=lambda item: item[3])[3])
+        for pts in sector_points if pts
+    ]
+    if not observed_radii:
+        return None
+
+    petal_hole_r = float(np.median(np.array(observed_radii, dtype=np.float32)))
+    tip_r = max(petal_hole_r * 1.55, radius_hint * 1.00)
+    tip_r = min(tip_r, max(radius_hint * 1.28, petal_hole_r * 1.75))
+    valley_r = max(petal_hole_r * 1.12, tip_r * 0.76)
+    valley_r = min(valley_r, tip_r * 0.87)
+    shoulder_r = tip_r * 0.95
+    shoulder_delta = (np.pi / 5.0) * 0.55
+
+    pts: list[list[int]] = []
+    for ang in sector_angles:
+        pts.append([
+            int(round(cx + shoulder_r * np.cos(float(ang - shoulder_delta)))),
+            int(round(cy + shoulder_r * np.sin(float(ang - shoulder_delta)))),
+        ])
+        pts.append([
+            int(round(cx + tip_r * np.cos(float(ang)))),
+            int(round(cy + tip_r * np.sin(float(ang)))),
+        ])
+        pts.append([
+            int(round(cx + shoulder_r * np.cos(float(ang + shoulder_delta)))),
+            int(round(cy + shoulder_r * np.sin(float(ang + shoulder_delta)))),
+        ])
+        mid = float(ang + np.pi / 5.0)
+        pts.append([
+            int(round(cx + valley_r * np.cos(mid))),
+            int(round(cy + valley_r * np.sin(mid))),
+        ])
+
+    poly = np.array(pts, dtype=np.int32).reshape(-1, 1, 2)
+    mask = np.zeros(shape, dtype=np.uint8)
+    cv2.fillPoly(mask, [poly], 255)
+
+    mean_ang_err = float(np.mean(ang_errors)) if ang_errors else step
+    angular_score = max(0.0, 1.0 - mean_ang_err / (step * 0.45))
+    if len(observed_radii) >= 2:
+        radii_arr = np.array(observed_radii, dtype=np.float32)
+        radius_score = max(0.0, 1.0 - float(radii_arr.std()) / max(1.0, float(radii_arr.mean())))
+    else:
+        radius_score = 0.5
+    inner_score = min(1.0, inner_spots / 2.0)
+    score = min(1.0, 0.60 * (matched_outer / 5.0) + 0.20 * angular_score + 0.10 * radius_score + 0.10 * inner_score)
+    return mask, float(score), int(matched_outer), int(inner_spots)
+
+
+def _fit_five_petal_geometry(
+    spots: list[tuple[int, int, int]],
+    shape: tuple[int, int],
+) -> FivePetalGeometry | None:
+    if len(spots) < 4:
+        return None
+
+    short = float(min(shape))
+    max_spot_radius = max(float(s[2]) for s in spots)
+    centre_candidates = sorted(spots, key=lambda item: item[2], reverse=True)[: min(6, len(spots))]
+    best: FivePetalGeometry | None = None
+    best_score = -1.0
+    step = 2.0 * np.pi / 5.0
+
+    for cx_i, cy_i, cr_i in centre_candidates:
+        cx = float(cx_i)
+        cy = float(cy_i)
+        cr = float(cr_i)
+        polar: list[tuple[int, int, int, float, float]] = []
+        for x, y, r in spots:
+            if x == cx_i and y == cy_i and r == cr_i:
+                continue
+            dist = float(((x - cx) ** 2 + (y - cy) ** 2) ** 0.5)
+            if dist <= max(18.0, cr * 0.75):
+                continue
+            if dist >= short * 0.60:
+                continue
+            polar.append((x, y, r, dist, float(np.arctan2(y - cy, x - cx))))
+
+        if len(polar) < 3:
+            continue
+
+        ordered = sorted(polar, key=lambda item: item[3])
+        seed_d = np.array([p[3] for p in ordered[: min(5, len(ordered))]], dtype=np.float32)
+        ring_seed = float(np.median(seed_d))
+        outer_min = max(ring_seed * 0.55, cr * 1.25)
+        outer_max = ring_seed * 1.55
+        outer = [p for p in polar if outer_min <= p[3] <= outer_max]
+        if len(outer) < 3:
+            outer_min = max(ring_seed * 0.42, cr * 1.10)
+            outer = [p for p in polar if outer_min <= p[3] <= outer_max]
+        if len(outer) < 3:
+            continue
+
+        outer_angles = np.array([p[4] for p in outer], dtype=np.float32)
+        best_base = float(outer_angles[0])
+        best_cost = float("inf")
+        for ang in outer_angles:
+            for k in range(5):
+                base = _wrap_angle(float(ang - step * k))
+                cost = 0.0
+                for obs in outer_angles:
+                    cost += min(
+                        abs(_wrap_angle(float(obs - (base + step * j))))
+                        for j in range(5)
+                    )
+                if cost < best_cost:
+                    best_cost = cost
+                    best_base = base
+
+        sector_angles = np.array([
+            _wrap_angle(best_base + step * k) for k in range(5)
+        ], dtype=np.float32)
+        sector_points: list[list[tuple[int, int, int, float, float]]] = [[] for _ in range(5)]
+        ang_errors: list[float] = []
+        for item in outer:
+            diffs = np.array([
+                abs(_wrap_angle(float(item[4] - ang))) for ang in sector_angles
+            ], dtype=np.float32)
+            idx = int(np.argmin(diffs))
+            if float(diffs[idx]) <= step * 0.43:
+                sector_points[idx].append(item)
+                ang_errors.append(float(diffs[idx]))
+
+        matched_outer = sum(1 for pts in sector_points if pts)
+        if matched_outer < 3:
+            continue
+
+        outer_radius_ref = float(np.median(np.array([p[3] for p in outer], dtype=np.float32)))
+        outer_hole_ref = float(np.median(np.array([p[2] for p in outer], dtype=np.float32)))
+
+        def pick_sector_point(
+            pts: list[tuple[int, int, int, float, float]],
+            sector_idx: int,
+            radius_ref: float,
+        ) -> tuple[int, int, int, float, float]:
+            radius_ref = max(1.0, float(radius_ref))
+            hole_ref = max(1.0, outer_hole_ref)
+            sector_ang = float(sector_angles[sector_idx])
+            return min(
+                pts,
+                key=lambda item: (
+                    abs(float(item[3]) - radius_ref) / radius_ref
+                    + 0.16 * abs(_wrap_angle(float(item[4] - sector_ang))) / (step * 0.43)
+                    - 0.025 * min(2.0, float(item[2]) / hole_ref)
+                ),
+            )
+
+        observed = [
+            pick_sector_point(pts, idx, outer_radius_ref)
+            for idx, pts in enumerate(sector_points) if pts
+        ]
+        observed_r = np.array([p[3] for p in observed], dtype=np.float32)
+        ring_radius = float(np.median(observed_r))
+        hole_radius = float(np.median(np.array([p[2] for p in observed], dtype=np.float32)))
+        sector_radii = np.full(5, ring_radius, dtype=np.float32)
+        sector_hole_radii = np.full(5, hole_radius, dtype=np.float32)
+        sector_angles_refined = sector_angles.copy()
+        sector_matched = np.zeros(5, dtype=bool)
+        accepted_radii: list[float] = []
+        for idx, pts in enumerate(sector_points):
+            if not pts:
+                continue
+            picked = pick_sector_point(pts, idx, ring_radius)
+            if picked[3] < ring_radius * 0.72 or picked[3] > ring_radius * 1.32:
+                continue
+            sector_radii[idx] = float(picked[3])
+            sector_hole_radii[idx] = float(picked[2])
+            sector_matched[idx] = True
+            accepted_radii.append(float(picked[3]))
+            angle_delta = _wrap_angle(float(picked[4] - sector_angles[idx]))
+            blend = 0.55 if abs(angle_delta) <= step * 0.30 else 0.25
+            sector_angles_refined[idx] = _wrap_angle(float(sector_angles[idx] + blend * angle_delta))
+        sector_angles = sector_angles_refined
+        sector_radii = np.clip(sector_radii, ring_radius * 0.80, ring_radius * 1.25)
+        sector_hole_radii = np.clip(sector_hole_radii, hole_radius * 0.85, hole_radius * 1.20)
+        matched_outer = int(sector_matched.sum())
+        if matched_outer < 3:
+            continue
+        inner_spots = 1 + sum(
+            1 for p in polar
+            if p[3] <= max(cr * 1.80, ring_radius * 0.48)
+        )
+        mean_ang_err = float(np.mean(ang_errors)) if ang_errors else step
+        angular_score = max(0.0, 1.0 - mean_ang_err / (step * 0.45))
+        radius_values = np.array(accepted_radii, dtype=np.float32)
+        radius_score = max(0.0, 1.0 - float(radius_values.std()) / max(1.0, float(radius_values.mean())))
+        centre_score = min(1.0, cr / max(1.0, max_spot_radius * 0.85))
+        score = min(
+            1.0,
+            0.44 * (matched_outer / 5.0)
+            + 0.18 * angular_score
+            + 0.12 * radius_score
+            + 0.10 * min(1.0, inner_spots / 2.0)
+            + 0.16 * centre_score,
+        )
+        if cr < max_spot_radius * 0.75 and matched_outer <= 3:
+            score *= 0.84
+        if score > best_score:
+            best_score = score
+            best = FivePetalGeometry(
+                center=(cx, cy),
+                center_radius=cr,
+                sector_angles=sector_angles,
+                sector_radii=sector_radii,
+                sector_hole_radii=sector_hole_radii,
+                sector_matched=sector_matched,
+                ring_radius=ring_radius,
+                hole_radius=hole_radius,
+                matched_outer=matched_outer,
+                inner_spots=inner_spots,
+                score=float(score),
+            )
+
+    return best
+
+
+def _build_radial_five_petal_contour(
+    bright: np.ndarray,
+    geom: FivePetalGeometry,
+    samples: int = 120,
+) -> np.ndarray | None:
+    h, w = bright.shape[:2]
+    cx, cy = geom.center
+    step = 2.0 * np.pi / 5.0
+    sector_radii = np.asarray(geom.sector_radii, dtype=np.float32)
+    sector_hole_radii = np.asarray(geom.sector_hole_radii, dtype=np.float32)
+    sector_matched = np.asarray(geom.sector_matched, dtype=bool)
+    if sector_radii.size != 5:
+        sector_radii = np.full(5, geom.ring_radius, dtype=np.float32)
+    if sector_hole_radii.size != 5:
+        sector_hole_radii = np.full(5, geom.hole_radius, dtype=np.float32)
+    if sector_matched.size != 5:
+        sector_matched = np.ones(5, dtype=bool)
+    sector_tip_r = np.maximum(sector_radii + 2.20 * sector_hole_radii,
+                              sector_radii * 1.16)
+    sector_tip_r = np.maximum(sector_tip_r, geom.center_radius * 2.45)
+    sector_tip_r = np.minimum(sector_tip_r, sector_radii * 1.42)
+    min_r = max(geom.center_radius * 1.15, float(sector_radii.min()) * 0.35)
+    max_r = float(sector_tip_r.max()) * 1.18
+
+    src = (bright > 0).astype(np.uint8) * 255
+    if cv2.countNonZero(src) < 50:
+        return None
+    raw_src = src.copy()
+    mk = max(3, int(0.006 * min(h, w)))
+    mk = mk if mk % 2 == 1 else mk + 1
+    morph_kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (mk, mk))
+    src = cv2.morphologyEx(src, cv2.MORPH_CLOSE, morph_kernel)
+    src_cnts, _ = cv2.findContours(src, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+    if not src_cnts:
+        return None
+    solid = np.zeros_like(src)
+    cv2.drawContours(solid, src_cnts, -1, 255, thickness=cv2.FILLED)
+
+    angles = np.linspace(-np.pi, np.pi, samples, endpoint=False, dtype=np.float32)
+    radii: list[float] = []
+    priors: list[float] = []
+    caps: list[float] = []
+    floors: list[float] = []
+    evidences: list[float] = []
+    lobes: list[float] = []
+    radial_grid = np.arange(min_r, max_r + 2.0, 2.0, dtype=np.float32)
+    for theta in angles:
+        diffs = np.array([
+            abs(_wrap_angle(float(theta - sec))) for sec in geom.sector_angles
+        ], dtype=np.float32)
+        weights = np.exp(-((diffs / (step * 0.72)) ** 2))
+        wsum = float(weights.sum())
+        if wsum <= 1e-6:
+            weights = np.ones(5, dtype=np.float32)
+            wsum = 5.0
+        local_ring = float(np.dot(weights, sector_radii) / wsum)
+        local_hole = float(np.dot(weights, sector_hole_radii) / wsum)
+        matched_strength = float(
+            np.dot(weights, sector_matched.astype(np.float32)) / wsum
+        )
+        local_tip = max(
+            local_ring + 2.20 * local_hole,
+            local_ring * 1.16,
+            geom.center_radius * 2.45,
+        )
+        local_tip = min(local_tip, local_ring * 1.42)
+        local_valley = max(local_ring * 0.70, local_tip * 0.58)
+        local_valley = min(local_valley, local_tip * 0.82)
+        diff = float(diffs.min())
+        lobe = max(0.0, float(np.cos(diff * 2.5)))
+        prior = local_valley + (local_tip - local_valley) * (lobe ** 0.55)
+        priors.append(prior)
+        rs = radial_grid[radial_grid <= min(max_r, prior * 1.08)]
+        xs = np.round(cx + rs * np.cos(float(theta))).astype(np.int32)
+        ys = np.round(cy + rs * np.sin(float(theta))).astype(np.int32)
+        valid = (xs >= 0) & (xs < w) & (ys >= 0) & (ys < h)
+        cap = prior * (0.965 if matched_strength >= 0.55 else 0.920)
+        floor = local_valley * (0.74 if matched_strength >= 0.55 else 0.66)
+        if lobe >= 0.60 and matched_strength >= 0.55:
+            floor = max(floor, prior * 0.74)
+        if matched_strength >= 0.55 and lobe >= 0.35:
+            floor = max(floor, prior * (0.74 + 0.14 * lobe))
+        if matched_strength >= 0.55:
+            radius = prior * (0.88 + 0.05 * lobe)
+        else:
+            radius = prior * (0.82 + 0.05 * lobe)
+        evidence = 0.0
+        if np.any(valid):
+            rs_v = rs[valid]
+            raw_vals = raw_src[ys[valid], xs[valid]] > 0
+            solid_vals = solid[ys[valid], xs[valid]] > 0
+            raw_fg = raw_vals & (rs_v >= prior * 0.42)
+            solid_fg = solid_vals & (rs_v >= prior * 0.42)
+            tail = (rs_v >= prior * 0.78) & (rs_v <= prior * 1.06)
+            raw_tail_density = (
+                float(raw_vals[tail].sum()) / float(max(1, int(tail.sum())))
+                if np.any(tail) else 0.0
+            )
+            solid_tail_density = (
+                float(solid_vals[tail].sum()) / float(max(1, int(tail.sum())))
+                if np.any(tail) else 0.0
+            )
+            raw_idxs = np.array([], dtype=np.int64)
+            if np.any(raw_fg):
+                raw_support = np.convolve(
+                    raw_fg.astype(np.uint8), np.ones(5, dtype=np.uint8),
+                    mode="same",
+                )
+                raw_idxs = np.flatnonzero((raw_support >= 2) & (rs_v >= prior * 0.48))
+            solid_idxs = np.array([], dtype=np.int64)
+            if np.any(solid_fg):
+                solid_support = np.convolve(
+                    solid_fg.astype(np.uint8), np.ones(5, dtype=np.uint8),
+                    mode="same",
+                )
+                solid_idxs = np.flatnonzero((solid_support >= 2) & (rs_v >= prior * 0.48))
+            if raw_idxs.size:
+                measured = float(rs_v[raw_idxs[-1]])
+                strong_raw_edge = raw_tail_density >= max(0.26, 0.42 - 0.18 * lobe)
+                evidence = max(evidence, raw_tail_density, 0.42 if measured >= prior * 0.78 else 0.20)
+                if measured >= prior * 0.95:
+                    edge_cap = prior * (0.980 if strong_raw_edge else 0.925)
+                    radius = min(measured, edge_cap)
+                    if strong_raw_edge:
+                        evidence = max(evidence, 0.64)
+                elif solid_idxs.size and measured < prior * (0.82 if lobe >= 0.45 else 0.74):
+                    filled = float(rs_v[solid_idxs[-1]])
+                    if matched_strength >= 0.50 and solid_tail_density >= 0.20:
+                        target = min(filled, prior * (0.935 if lobe >= 0.45 else 0.875))
+                        blend = min(0.62, 0.32 + 0.30 * matched_strength)
+                        radius = (1.0 - blend) * measured + blend * target
+                        evidence = max(evidence, solid_tail_density, 0.34)
+                    else:
+                        radius = measured
+                else:
+                    radius = measured
+            elif solid_idxs.size:
+                measured = float(rs_v[solid_idxs[-1]])
+                if matched_strength >= 0.55 and solid_tail_density >= 0.24:
+                    radius = min(measured, prior * (0.940 if lobe >= 0.45 else 0.860))
+                    evidence = max(evidence, solid_tail_density, 0.32)
+                elif measured < prior * 0.72:
+                    radius = 0.42 * prior + 0.58 * measured
+                    evidence = max(evidence, solid_tail_density * 0.60)
+                else:
+                    radius = min(measured, prior * 0.900)
+                    evidence = max(evidence, solid_tail_density * 0.50)
+        radius = max(floor, min(cap, radius))
+        caps.append(cap)
+        floors.append(floor)
+        evidences.append(evidence)
+        lobes.append(lobe)
+        radii.append(radius)
+
+    radii_arr = np.array(radii, dtype=np.float32)
+    prior_arr = np.array(priors, dtype=np.float32)
+    cap_arr = np.array(caps, dtype=np.float32)
+    floor_arr = np.array(floors, dtype=np.float32)
+    evidence_arr = np.array(evidences, dtype=np.float32)
+    lobe_arr = np.array(lobes, dtype=np.float32)
+    offsets = np.array([-4, -3, -2, -1, 1, 2, 3, 4], dtype=np.int32)
+    for _ in range(2):
+        filled_arr = radii_arr.copy()
+        for i in range(samples):
+            if evidence_arr[i] >= 0.22 or lobe_arr[i] < 0.32:
+                continue
+            idx = np.mod(i + offsets, samples)
+            good = evidence_arr[idx] >= 0.32
+            if int(good.sum()) < 3:
+                continue
+            candidate = float(np.median(radii_arr[idx][good]))
+            max_fill = prior_arr[i] * (0.925 if lobe_arr[i] >= 0.50 else 0.880)
+            if candidate > radii_arr[i] * 1.08:
+                filled_arr[i] = max(radii_arr[i], min(candidate * 0.96, max_fill, cap_arr[i]))
+                evidence_arr[i] = max(evidence_arr[i], 0.24)
+        radii_arr = np.maximum(floor_arr, np.minimum(cap_arr, filled_arr))
+    for _ in range(2):
+        median_arr = np.array([
+            float(np.median(np.take(radii_arr, np.arange(i - 2, i + 3), mode="wrap")))
+            for i in range(samples)
+        ], dtype=np.float32)
+        radii_arr = np.minimum(radii_arr, median_arr * 1.07)
+        radii_arr = np.maximum(radii_arr, np.minimum(median_arr * 0.88, prior_arr * 0.70))
+        radii_arr = (
+            np.roll(radii_arr, 1) * 0.22
+            + radii_arr * 0.56
+            + np.roll(radii_arr, -1) * 0.22
+        )
+        radii_arr = np.maximum(floor_arr, np.minimum(cap_arr, radii_arr))
+    radii_arr = np.maximum(floor_arr, np.minimum(cap_arr, radii_arr))
+    pts = np.stack([
+        np.round(cx + radii_arr * np.cos(angles)).astype(np.int32),
+        np.round(cy + radii_arr * np.sin(angles)).astype(np.int32),
+    ], axis=1)
+    pts[:, 0] = np.clip(pts[:, 0], 0, w - 1)
+    pts[:, 1] = np.clip(pts[:, 1], 0, h - 1)
+
+    mask = np.zeros((h, w), dtype=np.uint8)
+    cv2.fillPoly(mask, [pts.reshape(-1, 1, 2)], 255)
+    centre_pt = (int(round(cx)), int(round(cy)))
+    cv2.circle(mask, centre_pt, max(3, int(round(geom.center_radius * 1.25))), 255, -1)
+    for idx in range(5):
+        if not bool(sector_matched[idx]):
+            continue
+        hx = int(round(cx + float(sector_radii[idx]) * np.cos(float(geom.sector_angles[idx]))))
+        hy = int(round(cy + float(sector_radii[idx]) * np.sin(float(geom.sector_angles[idx]))))
+        if hx < 0 or hx >= w or hy < 0 or hy >= h:
+            continue
+        hole_r = max(3, int(round(float(sector_hole_radii[idx]) * 1.35)))
+        cv2.line(mask, centre_pt, (hx, hy), 255, max(3, int(round(hole_r * 1.15))))
+        cv2.circle(mask, (hx, hy), hole_r, 255, -1)
+    cnts, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+    if not cnts:
+        return None
+    return max(cnts, key=cv2.contourArea)
+
+
+def _find_valve_polygon_in_bbox(
+    img: np.ndarray,
+    bbox: tuple[int, int, int, int],
+    *,
+    bbox_expand_ratio: float = 0.08,
+    neutral_tol: int = 90,
+    close_kernel_ratio: float = 0.09,   # relative to bbox short edge
+    open_kernel_ratio: float = 0.012,
+    bridge_erode_ratio: float = 0.030,  # larger erosion to break wall bridges
+    min_area_ratio_of_bbox: float = 0.03,
+    max_area_ratio_of_bbox: float = 1.30,
+    require_dark_spots: bool = True,
+    min_dark_spots_inside: int = 3,
+    dark_spot_min_radius_ratio: float = 0.010,  # relative to bbox short edge
+    dark_spot_max_radius_ratio: float = 0.15,
+    debug_out: Path | None = None,
+) -> ValveCandidate | None:
+    """Find the valve polygon *inside* a given bounding box.
+
+    This is the primary detection path when a valve bbox prior is
+    available (from a pre-existing YOLO bbox label). It is much more
+    accurate than a global search because:
+
+      1. It crops the image to ``bbox`` (plus a small margin) so
+         unrelated bright regions in the scene cannot compete.
+      2. It finds bright, colour-neutral pixels, morph-closes them so
+         the 5 petals fuse into a single blob, and picks the largest
+         connected component.
+      3. It *validates* that component by requiring 3+ dark circular
+         spots (valve bolt + petal holes) inside it. If the validation
+         fails, we return ``None`` so the caller can fall back to the
+         spot-seeded global detector.
+
+    All pixel parameters are scaled by the bbox short edge so the
+    method works at any image resolution / valve size.
+    """
+    h_img, w_img = img.shape[:2]
+    x1, y1, x2, y2 = bbox
+    bw, bh = x2 - x1, y2 - y1
+    if bw < 20 or bh < 20:
+        return None
+
+    # Expand bbox slightly so the valve outer rim isn't clipped.
+    ex = int(bbox_expand_ratio * bw)
+    ey = int(bbox_expand_ratio * bh)
+    cx1 = max(0, x1 - ex)
+    cy1 = max(0, y1 - ey)
+    cx2 = min(w_img, x2 + ex)
+    cy2 = min(h_img, y2 + ey)
+
+    crop = img[cy1:cy2, cx1:cx2]
+    ch, cw = crop.shape[:2]
+    short = min(cw, ch)
+    if short < 30:
+        return None
+
+    # Scale-aware morphology.
+    ck = max(9, int(close_kernel_ratio * short))
+    ok = max(3, int(open_kernel_ratio * short))
+    ck = ck if ck % 2 == 1 else ck + 1
+    ok = ok if ok % 2 == 1 else ok + 1
+    kernel_close = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (ck, ck))
+    kernel_open = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (ok, ok))
+
+    lab = cv2.cvtColor(crop, cv2.COLOR_BGR2LAB)
+    L, A, B = cv2.split(lab)
+    a_diff = np.abs(A.astype(np.int16) - 128)
+    b_diff = np.abs(B.astype(np.int16) - 128)
+    # Relax neutrality: warm studio lighting tints the white valve
+    # slightly yellow/orange, so a strict neutral filter can reject
+    # half the petals. Saturation ~ a_diff + b_diff ; we keep pixels
+    # whose colour is at least "not vivid".
+    neutral = (a_diff + b_diff) < neutral_tol
+
+    neutral_L = L[neutral & (L < 252)]
+    if neutral_L.size < 200:
+        return None
+    # Initial coarse threshold from percentiles. This is only used when
+    # the dark-spot cluster localization fails and we need a global
+    # threshold across the whole bbox.
+    q45 = float(np.percentile(neutral_L, 45))
+    q70 = float(np.percentile(neutral_L, 70))
+    local_thresh = int(max(110.0, (q45 + q70) / 2.0 - 5))
+
+    bright = ((L > local_thresh) & neutral).astype(np.uint8) * 255
+
+    # --------------------------------------------------------------
+    # Localize the valve centre using dark circular spots (bolt + petal
+    # holes). The cluster of small dark circles is an extremely strong
+    # valve signature, much more reliable than bright-pixel geometry.
+    # We then constrain the bright-valve search to a small disk around
+    # the cluster centroid so adjacent walls / background cannot be
+    # picked up even when they are bright-connected to the valve.
+    # --------------------------------------------------------------
+    gray = cv2.cvtColor(crop, cv2.COLOR_BGR2GRAY)
+    gray_blur = cv2.GaussianBlur(gray, (5, 5), 0)
+    spot_min_r = max(3, int(dark_spot_min_radius_ratio * short))
+    spot_max_r = max(6, int(dark_spot_max_radius_ratio * short))
+    all_spots = _find_dark_spots(gray_blur, spot_min_r, spot_max_r)
+
+    # Keep only spots that lie inside the (unexpanded) input bbox. The
+    # bbox margin may contain non-valve dark spots (fixture bolts /
+    # text) we must ignore.
+    inner_x1, inner_y1 = x1 - cx1, y1 - cy1
+    inner_x2, inner_y2 = x2 - cx1, y2 - cy1
+    spots_in_bbox = [
+        (x, y, r) for (x, y, r) in all_spots
+        if inner_x1 <= x < inner_x2 and inner_y1 <= y < inner_y2
+    ]
+
+    # Adaptive surround-brightness threshold: instead of a hard-coded
+    # value (which fails on shadowed valves), require each spot's
+    # surrounding ring to be at least as bright as the 45-th percentile
+    # of neutral pixels inside the bbox. This is automatically calibrated
+    # per-image so shadowed valves still pass.
+    surround_L = int(max(80, min(160, q45 - 10)))
+    spots_on_white = _filter_spots_on_bright_surface(
+        spots_in_bbox, L, min_surround_L=surround_L,
+    )
+
+    # Cluster the surviving spots. For a valve we expect 3+ spots in a
+    # compact cluster (diameter ~ 15-30% of bbox short).
+    clusters = _cluster_spots(
+        spots_on_white,
+        max_gap=0.18 * short,
+        min_cluster_size=3,
+        max_diameter=0.40 * short,
+    )
+
+    spot_centre: tuple[float, float] | None = None
+    spot_radius_hint: float = 0.18 * short
+    n_cluster_spots = 0
+    best = None
+    five_petal_geom = _fit_five_petal_geometry(spots_on_white, bright.shape)
+    five_petal_score = five_petal_geom.score if five_petal_geom is not None else 0.0
+    five_petal_outer = five_petal_geom.matched_outer if five_petal_geom is not None else 0
+    five_petal_inner = five_petal_geom.inner_spots if five_petal_geom is not None else 0
+    use_five_petal_radial = (
+        five_petal_geom is not None
+        and five_petal_geom.score >= 0.62
+        and (
+            five_petal_geom.matched_outer >= 4
+            or (
+                five_petal_geom.matched_outer >= 3
+                and five_petal_geom.inner_spots >= 1
+            )
+        )
+    )
+    if use_five_petal_radial and five_petal_geom is not None:
+        spot_centre = five_petal_geom.center
+        n_cluster_spots = len(spots_on_white)
+        spot_radius_hint = min(
+            0.34 * short,
+            max(
+                0.12 * short,
+                (five_petal_geom.ring_radius + 2.90 * five_petal_geom.hole_radius) * 1.08,
+            ),
+        )
+    if clusters and not use_five_petal_radial:
+        # Pick the cluster whose centroid is closest to bbox centre.
+        bcx_crop = (inner_x1 + inner_x2) / 2.0
+        bcy_crop = (inner_y1 + inner_y2) / 2.0
+        best_d = float("inf")
+        for c in clusters:
+            xs = np.array([s[0] for s in c], dtype=np.float32)
+            ys = np.array([s[1] for s in c], dtype=np.float32)
+            cx_c = float(xs.mean())
+            cy_c = float(ys.mean())
+            d = ((cx_c - bcx_crop) ** 2 + (cy_c - bcy_crop) ** 2) ** 0.5
+            if d < best_d:
+                best_d = d
+                best = (cx_c, cy_c, c)
+        if best is not None:
+            cx_c, cy_c, c = best
+            n_cluster_spots = len(c)
+            xs = np.array([s[0] for s in c], dtype=np.float32)
+            ys = np.array([s[1] for s in c], dtype=np.float32)
+            # The *bbox centre* is usually closer to the true valve
+            # geometric centre than the cluster centroid (which can be
+            # pulled sideways when one half of the petals is in shadow
+            # and a few dark-spot detections are missed). We blend
+            # heavily toward the bbox centre.
+            cx_final = 0.35 * cx_c + 0.65 * bcx_crop
+            cy_final = 0.35 * cy_c + 0.65 * bcy_crop
+            # Use the cluster extent relative to the blended centre so
+            # the radius fully covers every detected petal-hole, then
+            # pad out by ~2.0x to reach the petal tips.
+            dists_final = np.sqrt((xs - cx_final) ** 2 +
+                                  (ys - cy_final) ** 2)
+            max_d = float(dists_final.max()) if dists_final.size else 0.0
+            avg_r = float(np.mean([s[2] for s in c])) if c else 10.0
+            # Petal-holes sit at ~60% of the valve radius. Enlarge by
+            # ~2.0x to comfortably enclose every petal tip. Clamp to a
+            # safe band so we never reach into background.
+            spot_radius_hint = min(
+                0.22 * short,
+                max(0.10 * short, (max_d + avg_r) * 2.0),
+            )
+            spot_centre = (cx_final, cy_final)
+
+    # --------------------------------------------------------------
+    # Build the bright-valve mask. When a dark-spot cluster was found,
+    # compute a *local* Otsu threshold on a disk around the cluster
+    # centroid (this handles uneven illumination: one half of the valve
+    # can be in shadow with half the luminance of the lit half). Then
+    # only keep bright pixels within ``spot_radius_hint`` of the
+    # centroid. Otherwise fall back to the erode / edge-removal trick.
+    # --------------------------------------------------------------
+    if spot_centre is not None:
+        Ycoord, Xcoord = np.ogrid[:ch, :cw]
+        radial = (Xcoord - spot_centre[0]) ** 2 + (Ycoord - spot_centre[1]) ** 2
+        # Inner seed disk: very tight around cluster; any bright
+        # component that overlaps this disk is presumed to belong to
+        # the valve and is kept entirely (even petals that extend
+        # outside ``spot_radius_hint``).
+        seed_r = max(0.05 * short, spot_radius_hint * 0.55)
+        seed_disk = (radial <= seed_r ** 2)
+        # Outer reject disk: anything entirely outside this radius is
+        # background and is dropped. Kept close to spot_radius_hint so
+        # wall / ceiling blobs cannot extend far into the mask.
+        outer_r = spot_radius_hint * 1.10
+        outer_disk = (radial <= outer_r ** 2)
+
+        # Local Otsu threshold on the outer disk: separates valve
+        # petals (bright) from the darker cylinder body / deep shadow.
+        local_L_vals = L[outer_disk]
+        if local_L_vals.size >= 200:
+            lv = local_L_vals[(local_L_vals > 20) & (local_L_vals < 252)]
+            if lv.size >= 100:
+                otsu_thr, _ = cv2.threshold(
+                    lv.astype(np.uint8), 0, 255,
+                    cv2.THRESH_BINARY + cv2.THRESH_OTSU,
+                )
+                local_thresh = int(max(90, min(240, otsu_thr)))
+
+        valve_mask = ((L > local_thresh) & neutral).astype(np.uint8) * 255
+
+        # Break thin bright bridges that may connect the valve to the
+        # surrounding wall / ceiling (the bolt region often spills
+        # into background through single-pixel-thin links).
+        _ok = max(3, int(0.010 * short))
+        _ok = _ok if _ok % 2 == 1 else _ok + 1
+        _open_k = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (_ok, _ok))
+        valve_mask_clean = cv2.morphologyEx(valve_mask, cv2.MORPH_OPEN,
+                                            _open_k)
+
+        # Intersect with the outer disk, then keep only connected
+        # components that are *well centred* on the seed disk. We
+        # measure this by: fraction of component area inside the tight
+        # spot_radius_hint. Components that are mostly wall/ceiling
+        # (i.e. reach far beyond the hint) are rejected even when they
+        # happen to overlap the seed disk by a few pixels.
+        valve_mask_outer = valve_mask_clean * outer_disk.astype(np.uint8)
+        num_lb, labs = cv2.connectedComponents(valve_mask_outer)
+        if num_lb > 1:
+            tight_disk = (radial <= spot_radius_hint ** 2)
+            keep = np.zeros_like(valve_mask_outer, dtype=bool)
+            for lbl in range(1, num_lb):
+                comp = (labs == lbl)
+                area = int(comp.sum())
+                if area == 0:
+                    continue
+                # Require overlap with seed disk.
+                if not np.any(comp & seed_disk):
+                    continue
+                # Require that at least 55% of the component lies
+                # inside the tight spot_radius_hint. Big walls fail
+                # this because only a small tongue reaches the seed.
+                inside = int((comp & tight_disk).sum())
+                if inside / float(area) < 0.55:
+                    continue
+                keep |= comp
+            if keep.any():
+                bright_interior = keep.astype(np.uint8) * 255
+            else:
+                # Nothing survived; fall back to the tight disk mask.
+                bright_interior = valve_mask_clean * tight_disk.astype(np.uint8)
+        else:
+            bright_interior = valve_mask_clean * outer_disk.astype(np.uint8)
+    else:
+        # Fallback: erode bright, remove border-connected, dilate back.
+        erode_k = max(3, int(bridge_erode_ratio * short))
+        erode_k = erode_k if erode_k % 2 == 1 else erode_k + 1
+        bridge_kernel = cv2.getStructuringElement(
+            cv2.MORPH_ELLIPSE, (erode_k, erode_k),
+        )
+        bright_eroded = cv2.erode(bright, bridge_kernel, iterations=1)
+
+        num_b, labels_b = cv2.connectedComponents(bright_eroded)
+        edge_mask = np.zeros_like(bright_eroded, dtype=bool)
+        edge_mask[0, :] = True
+        edge_mask[-1, :] = True
+        edge_mask[:, 0] = True
+        edge_mask[:, -1] = True
+        edge_labels = np.unique(labels_b[edge_mask & (labels_b > 0)])
+        if edge_labels.size > 0:
+            keep_mask = ~np.isin(labels_b, edge_labels)
+            bright_eroded = (bright_eroded * keep_mask.astype(np.uint8))
+
+        bright_interior = cv2.dilate(bright_eroded, bridge_kernel, iterations=1)
+        if bright_interior.sum() < 100:
+            bright_interior = bright
+
+    bbox_area = float(bw * bh)
+
+    if use_five_petal_radial and five_petal_geom is not None:
+        edge_bright = ((L > local_thresh) & neutral).astype(np.uint8) * 255
+        if cv2.countNonZero(bright_interior) >= 200:
+            edge_bright = bright_interior
+        cnt_local_radial = _build_radial_five_petal_contour(
+            edge_bright, five_petal_geom,
+        )
+        if cnt_local_radial is not None:
+            spots_inside = 0
+            if require_dark_spots:
+                for (sx, sy, sr) in all_spots:
+                    if cv2.pointPolygonTest(
+                        cnt_local_radial, (float(sx), float(sy)), False,
+                    ) >= 0:
+                        spots_inside += 1
+                if spots_inside < min_dark_spots_inside:
+                    cnt_local_radial = None
+            if cnt_local_radial is not None:
+                cnt_global = cnt_local_radial.copy()
+                cnt_global[:, 0, 0] += cx1
+                cnt_global[:, 0, 1] += cy1
+                area_global = float(cv2.contourArea(cnt_global))
+                perimeter = float(cv2.arcLength(cnt_global, True))
+                circularity = (4.0 * np.pi * area_global / (perimeter ** 2)
+                               if perimeter > 0 else 0.0)
+                _, _, gbw, gbh = cv2.boundingRect(cnt_global)
+                aspect = max(gbw, gbh) / max(1, min(gbw, gbh))
+                bbox_cx = (x1 + x2) / 2.0
+                bbox_cy = (y1 + y2) / 2.0
+                gcx = five_petal_geom.center[0] + cx1
+                gcy = five_petal_geom.center[1] + cy1
+                d_centre = ((gcx - bbox_cx) ** 2 + (gcy - bbox_cy) ** 2) ** 0.5
+                max_centre_d = 0.5 * (bw ** 2 + bh ** 2) ** 0.5
+                centrality = max(0.0, 1.0 - d_centre / max_centre_d) if max_centre_d > 0 else 0.0
+                score = (
+                    0.18 * centrality
+                    + 0.22 * min(1.0, area_global / max(1.0, bbox_area))
+                    + 0.24 * min(1.0, spots_inside / 7.0)
+                    + 0.36 * min(1.0, five_petal_geom.score)
+                )
+                if debug_out is not None:
+                    radial_mask = np.zeros_like(edge_bright)
+                    cv2.drawContours(
+                        radial_mask, [cnt_local_radial], -1, 255,
+                        thickness=cv2.FILLED,
+                    )
+                    _dump_bbox_debug(
+                        crop, edge_bright, bright_interior, radial_mask,
+                        cnt_local_radial, all_spots, local_thresh, bbox_area,
+                        -2,
+                        f"OK radial5 area={int(area_global)} "
+                        f"spots_in={spots_inside} geom={five_petal_geom.score:.2f}",
+                        debug_out,
+                    )
+                return ValveCandidate(
+                    contour=cnt_global,
+                    area=area_global,
+                    perimeter=perimeter,
+                    circularity=circularity,
+                    aspect=aspect,
+                    centrality=centrality,
+                    dark_center_ratio=min(
+                        1.0,
+                        float(max(spots_inside, five_petal_outer + five_petal_inner)) / 7.0,
+                    ),
+                    score=float(min(1.0, score)),
+                )
+
+    closed = cv2.morphologyEx(bright_interior, cv2.MORPH_CLOSE, kernel_close)
+    cleaned = cv2.morphologyEx(closed, cv2.MORPH_OPEN, kernel_open)
+
+    # Fill interior holes so the 5 petals + bolt pocket form a solid shape.
+    cnts_all, _ = cv2.findContours(cleaned, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+    if not cnts_all:
+        return None
+    filled = np.zeros_like(cleaned)
+    cv2.drawContours(filled, cnts_all, -1, 255, thickness=cv2.FILLED)
+
+    # Pick the connected component whose centroid is nearest to the
+    # bbox centre AND whose area is within bounds.
+    num_labels, labels_img, stats, centroids = cv2.connectedComponentsWithStats(
+        filled, 8,
+    )
+    if num_labels < 2:
+        return None
+
+    min_area = min_area_ratio_of_bbox * bbox_area
+    max_area = max_area_ratio_of_bbox * bbox_area
+    # Bbox centre in crop coords.
+    bcx_crop = (x1 + x2) / 2.0 - cx1
+    bcy_crop = (y1 + y2) / 2.0 - cy1
+
+    best_label = -1
+    best_score = -1.0
+    for i in range(1, num_labels):
+        area = float(stats[i, cv2.CC_STAT_AREA])
+        if area < min_area or area > max_area:
+            continue
+        ccx, ccy = centroids[i]
+        dist = ((ccx - bcx_crop) ** 2 + (ccy - bcy_crop) ** 2) ** 0.5
+        # Prefer components whose centroid is close to the bbox centre
+        # AND whose area is a sensible fraction of the bbox.
+        norm_dist = dist / (0.5 * (bw ** 2 + bh ** 2) ** 0.5)
+        area_score = min(area / bbox_area, 1.0)
+        score = (1.0 - norm_dist) * 0.7 + area_score * 0.3
+        if score > best_score:
+            best_score = score
+            best_label = i
+
+    if best_label < 0:
+        return None
+
+    comp_mask = (labels_img == best_label).astype(np.uint8) * 255
+
+    # Ensure the mask unambiguously contains every detected cluster
+    # spot (bolt + petal holes). Luminance thresholding sometimes
+    # produces a C-shape that excludes the bolt; drawing filled disks
+    # for the *chosen cluster's* spots patches these gaps so the
+    # resulting contour wraps around the whole valve. We only patch
+    # cluster spots (not every bright-surround spot in the crop) to
+    # avoid latching onto fixture bolts or text.
+    if spot_centre is not None and n_cluster_spots > 0:
+        # ``best`` holds the chosen cluster's (cx, cy, [(x, y, r)]).
+        cluster_spots = best[2] if best is not None else []
+        for (sx, sy, sr) in cluster_spots:
+            cv2.circle(comp_mask, (int(sx), int(sy)),
+                       int(sr * 1.3), 255, -1)
+
+    # Hard-clip to a disk around the blended valve centre. This
+    # guarantees the final polygon cannot extend into background
+    # through thin bright bridges (valve stem / neck / lit wall) that
+    # survived the morphology. The clip radius is ~5% past the
+    # petal-tip hint so valve tips aren't truncated but wall bleed is
+    # bounded.
+    if spot_centre is not None:
+        clip_mask = np.zeros_like(comp_mask)
+        cv2.circle(clip_mask,
+                   (int(round(spot_centre[0])), int(round(spot_centre[1]))),
+                   int(round(spot_radius_hint * 1.05)),
+                   255, -1)
+        comp_mask = cv2.bitwise_and(comp_mask, clip_mask)
+
+    if spot_centre is not None:
+        five_petal = _build_five_petal_mask(
+            comp_mask.shape,
+            spots_in_bbox,
+            spot_centre,
+            spot_radius_hint,
+        )
+        if five_petal is not None:
+            five_petal_mask, five_petal_score, five_petal_outer, five_petal_inner = five_petal
+            geometry_ready = (
+                five_petal_mask is not None
+                and five_petal_score >= 0.50
+                and five_petal_outer >= 3
+                and five_petal_inner >= 1
+            )
+            prior_overlap = float(
+                cv2.countNonZero(cv2.bitwise_and(comp_mask, five_petal_mask))
+            ) / max(1.0, float(cv2.countNonZero(five_petal_mask)))
+            if five_petal_score >= 0.58 and five_petal_outer >= 4:
+                constrain_k = max(5, int(0.018 * short))
+                constrain_k = constrain_k if constrain_k % 2 == 1 else constrain_k + 1
+                constrain_kernel = cv2.getStructuringElement(
+                    cv2.MORPH_ELLIPSE, (constrain_k, constrain_k),
+                )
+                prior_band = cv2.dilate(five_petal_mask, constrain_kernel, iterations=1)
+                comp_mask = cv2.bitwise_and(comp_mask, prior_band)
+                if prior_overlap >= 0.20:
+                    comp_mask = cv2.bitwise_or(comp_mask, five_petal_mask)
+
+    cnts, _ = cv2.findContours(comp_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+    if not cnts:
+        return None
+    cnt_local = max(cnts, key=cv2.contourArea)
+
+    # If the contour has a large concavity such that >15% of its
+    # convex-hull area lies OUTSIDE the contour, the valve outline is
+    # likely C-shaped due to a missing lit petal. Replace with the
+    # convex hull to restore a rounded flower-shape.
+    hull_local = cv2.convexHull(cnt_local)
+    cnt_area = float(cv2.contourArea(cnt_local))
+    hull_area = float(cv2.contourArea(hull_local))
+    strong_five_petal = (five_petal_score >= 0.58 and five_petal_outer >= 4)
+    if (not strong_five_petal and hull_area > 0
+            and (hull_area - cnt_area) / hull_area > 0.15):
+        cnt_local = hull_local
+
+    # Translate contour back to full-image coordinates.
+    cnt_global = cnt_local.copy()
+    cnt_global[:, 0, 0] += cx1
+    cnt_global[:, 0, 1] += cy1
+
+    # Validate: the valve should contain dark circular spots
+    # (bolt + petal holes). This rejects bright but wrong blobs.
+    # We reuse ``all_spots`` detected above.
+    spots_inside = 0
+    if require_dark_spots:
+        for (sx, sy, sr) in all_spots:
+            if cv2.pointPolygonTest(cnt_local, (float(sx), float(sy)), False) >= 0:
+                spots_inside += 1
+        if spots_inside < min_dark_spots_inside:
+            if debug_out is not None:
+                _dump_bbox_debug(
+                    crop, bright, cleaned, filled, cnt_local, all_spots,
+                    local_thresh, bbox_area, best_label,
+                    "REJ: spots<{} (have {})".format(
+                        min_dark_spots_inside, spots_inside,
+                    ),
+                    debug_out,
+                )
+            return None
+
+    # Compute shape metrics.
+    area_global = float(cv2.contourArea(cnt_global))
+    perimeter = float(cv2.arcLength(cnt_global, True))
+    circularity = (4.0 * np.pi * area_global / (perimeter ** 2)
+                   if perimeter > 0 else 0.0)
+    _, _, gbw, gbh = cv2.boundingRect(cnt_global)
+    aspect = max(gbw, gbh) / max(1, min(gbw, gbh))
+    bbox_cx = (x1 + x2) / 2.0
+    bbox_cy = (y1 + y2) / 2.0
+    M = cv2.moments(cnt_global)
+    if M["m00"] > 0:
+        gcx = M["m10"] / M["m00"]
+        gcy = M["m01"] / M["m00"]
+    else:
+        gcx, gcy = bbox_cx, bbox_cy
+    d_centre = ((gcx - bbox_cx) ** 2 + (gcy - bbox_cy) ** 2) ** 0.5
+    max_centre_d = 0.5 * (bw ** 2 + bh ** 2) ** 0.5
+    centrality = max(0.0, 1.0 - d_centre / max_centre_d) if max_centre_d > 0 else 0.0
+    score = 0.44 * centrality + 0.18 * min(1.0, area_global / bbox_area) \
+            + 0.18 * min(1.0, spots_inside / 7.0) \
+            + 0.20 * min(1.0, five_petal_score)
+
+    if debug_out is not None:
+        _dump_bbox_debug(
+            crop, bright, cleaned, filled, cnt_local, all_spots,
+            local_thresh, bbox_area, best_label,
+            f"OK area={int(area_global)} circ={circularity:.2f} "
+            f"spots_in={spots_inside} cluster_n={n_cluster_spots}",
+            debug_out,
+        )
+
+    return ValveCandidate(
+        contour=cnt_global,
+        area=area_global,
+        perimeter=perimeter,
+        circularity=circularity,
+        aspect=aspect,
+        centrality=centrality,
+        dark_center_ratio=min(1.0, float(max(spots_inside, five_petal_outer + five_petal_inner)) / 7.0),
+        score=float(min(1.0, score)),
+    )
+
+
+def _dump_bbox_debug(
+    crop: np.ndarray,
+    bright: np.ndarray,
+    cleaned: np.ndarray,
+    filled: np.ndarray,
+    cnt_local: np.ndarray,
+    spots: list[tuple[int, int, int]],
+    local_thresh: int,
+    bbox_area: float,
+    best_label: int,
+    status: str,
+    debug_out: Path,
+) -> None:
+    """Save a 2x2 debug panel for the bbox-guided detector."""
+    to_bgr = lambda g: cv2.cvtColor(g, cv2.COLOR_GRAY2BGR)
+
+    panel_crop = crop.copy()
+    for (sx, sy, sr) in spots:
+        cv2.circle(panel_crop, (sx, sy), max(sr, 4), (0, 140, 255), 2)
+    cv2.drawContours(panel_crop, [cnt_local], -1, (0, 255, 0), 3)
+    cv2.putText(panel_crop, f"{status} thr={local_thresh}",
+                (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 255), 2)
+
+    def resize_for_panel(im: np.ndarray) -> np.ndarray:
+        h_, w_ = im.shape[:2]
+        scale = 640.0 / max(h_, w_)
+        if scale >= 1.0:
+            return im
+        return cv2.resize(im, (int(w_ * scale), int(h_ * scale)))
+
+    top = np.hstack([resize_for_panel(panel_crop),
+                     resize_for_panel(to_bgr(bright))])
+    bot = np.hstack([resize_for_panel(to_bgr(cleaned)),
+                     resize_for_panel(to_bgr(filled))])
+    # pad to same width if needed
+    if top.shape[1] != bot.shape[1]:
+        wmax = max(top.shape[1], bot.shape[1])
+        top = cv2.copyMakeBorder(top, 0, 0, 0, wmax - top.shape[1],
+                                 cv2.BORDER_CONSTANT, value=(0, 0, 0))
+        bot = cv2.copyMakeBorder(bot, 0, 0, 0, wmax - bot.shape[1],
+                                 cv2.BORDER_CONSTANT, value=(0, 0, 0))
+    panel = np.vstack([top, bot])
+    imwrite_unicode(debug_out, panel)
+
+
+def _find_valve_contour(
+    img: np.ndarray,
+    roi: CylinderROI | None,
+    bright_percentile: float = 55.0,
+    min_luminance: int = 135,
+    neutral_tol: int = 90,
+    # Scale-aware pixel params: relative to min(h, w). Tuned for any
+    # image size from 640 up to 4K+.
+    close_kernel_ratio: float = 0.035,
+    open_kernel_ratio: float = 0.0035,
+    min_area_ratio: float = 0.003,
+    max_area_ratio: float = 0.14,
+    max_aspect: float = 2.2,
+    min_density: float = 0.25,
+    border_margin: int = 3,
+    dark_spot_min_radius_ratio: float = 0.0020,
+    dark_spot_max_radius_ratio: float = 0.028,
+    min_dark_spots_cluster: int = 3,
+    spot_cluster_gap_ratio: float = 0.14,
+    spot_cluster_max_diameter_ratio: float = 0.30,
+    seed_growth_radius: float = 1.7,
+    spot_bright_surround_L: int = 130,
+    debug_out: Path | None = None,
+) -> ValveCandidate | None:
+    """Locate the white 5-petal valve using a spot-seeded approach:
+
+      1. Detect small dark *circular* spots (bolt + petal holes) and
+         keep only those whose immediate surroundings are bright (so
+         that dark spots on a chain / wire / dark body are removed).
+      2. Cluster these spots by proximity. A valve shows 3~6 spots in
+         a tight cluster. Walls / background / cables produce no such
+         cluster after the "on bright surface" filter.
+      3. Each valid cluster seeds a circular ROI. Inside the ROI we
+         isolate the bright petals with a LOCALLY-ADAPTIVE threshold.
+      4. Morph-close so the 5 petals fuse into one contour which is
+         the valve edge we label.
+
+    All pixel-scale parameters are expressed as a ratio of
+    ``min(height, width)`` so the method works at any image resolution.
+    """
+    h, w = img.shape[:2]
+    short_edge = float(min(w, h))
+    img_diag = float(w * w + h * h) ** 0.5
+    img_cx, img_cy = w / 2.0, h / 2.0
+    img_area = float(w * h)
+
+    # Resolve all scale-aware parameters to concrete pixel values.
+    dark_spot_min_radius = max(3, int(dark_spot_min_radius_ratio * short_edge))
+    dark_spot_max_radius = max(dark_spot_min_radius + 2,
+                                int(dark_spot_max_radius_ratio * short_edge))
+    spot_cluster_gap = max(40.0, spot_cluster_gap_ratio * short_edge)
+    close_kernel = max(9, int(close_kernel_ratio * short_edge))
+    open_kernel = max(3, int(open_kernel_ratio * short_edge))
+    min_abs_area = int(min_area_ratio * img_area)
+    max_area_ratio_eff = max_area_ratio if roi is not None else min(max_area_ratio, 0.08)
+    max_abs_area = int(max_area_ratio_eff * img_area)
+
+    # ---- 0. dark spot detection & clustering -----------------------
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    gray_blur = cv2.GaussianBlur(gray, (5, 5), 0)
+    dark_spots_raw = _find_dark_spots(
+        gray_blur, dark_spot_min_radius, dark_spot_max_radius,
+    )
+
+    # Pre-compute LAB once (needed both for spot filter and threshold).
+    lab = cv2.cvtColor(img, cv2.COLOR_BGR2LAB)
+    L, A, B = cv2.split(lab)
+    a_diff = np.abs(A.astype(np.int16) - 128)
+    b_diff = np.abs(B.astype(np.int16) - 128)
+    neutral = (a_diff + b_diff) < neutral_tol
+
+    # Keep only spots that sit on a bright surface (the white handwheel).
+    dark_spots = _filter_spots_on_bright_surface(
+        dark_spots_raw, L, spot_bright_surround_L,
+    )
+
+    spot_cluster_max_diameter = spot_cluster_max_diameter_ratio * short_edge
+    clusters = _cluster_spots(
+        dark_spots, spot_cluster_gap, min_dark_spots_cluster,
+        max_diameter=spot_cluster_max_diameter,
+    )
+
+    # Cylinder hint centroid (if available) - rewards clusters near it.
+    if roi is not None:
+        rx1, ry1, rx2, ry2 = roi.bbox
+        hint_cx = (rx1 + rx2) / 2.0
+        hint_cy = (ry1 + ry2) / 2.0
+    else:
+        hint_cx, hint_cy = img_cx, img_cy
+
+    candidates: list[ValveCandidate] = []
+    rejects: list[tuple[np.ndarray, str]] = []
+    bright_total = np.zeros_like(L, dtype=np.uint8)  # for debug only
+    filled_total = np.zeros_like(L, dtype=np.uint8)
+
+    ck = close_kernel if close_kernel % 2 == 1 else close_kernel + 1
+    ok = open_kernel if open_kernel % 2 == 1 else open_kernel + 1
+    kernel_close = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (ck, ck))
+    kernel_open = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (ok, ok))
+
+    global_thresh_val = 0
+
+    for cluster in clusters:
+        xs = np.array([s[0] for s in cluster], dtype=np.float32)
+        ys = np.array([s[1] for s in cluster], dtype=np.float32)
+        cx_c = float(xs.mean())
+        cy_c = float(ys.mean())
+        five_petal_mask = None
+        five_petal_score = 0.0
+        five_petal_outer = 0
+        five_petal_inner = 0
+
+        # Cluster extent: max spot-to-centre distance.
+        dists = np.sqrt((xs - cx_c) ** 2 + (ys - cy_c) ** 2)
+        max_dist = float(dists.max()) if dists.size > 0 else 10.0
+        avg_spot_r = float(np.mean([s[2] for s in cluster])) if cluster else 10.0
+        min_seed_r = 0.03 * short_edge  # absolute minimum ROI radius
+        seed_r = max(min_seed_r, seed_growth_radius * max(max_dist + avg_spot_r, min_seed_r * 0.6))
+        seed_r = min(seed_r, 0.30 * short_edge)
+        five_petal = _build_five_petal_mask(
+            (h, w), dark_spots, (cx_c, cy_c), seed_r,
+        )
+        if five_petal is not None:
+            five_petal_mask, five_petal_score, five_petal_outer, five_petal_inner = five_petal
+        geometry_ready = (
+            roi is not None
+            and five_petal_mask is not None
+            and five_petal_score >= 0.50
+            and five_petal_outer >= 3
+            and five_petal_inner >= 1
+        )
+
+        # Build seed ROI mask (circular) and compute local threshold on it.
+        roi_mask = np.zeros_like(L, dtype=np.uint8)
+        cv2.circle(roi_mask, (int(cx_c), int(cy_c)), int(seed_r), 255, -1)
+        inside = L[roi_mask > 0]
+        if inside.size < 500:
+            continue
+
+        # Local luminance threshold: we want a value that separates the
+        # bright valve petals from the surrounding cylinder body. Use
+        # the LOWER quartile + margin so the threshold is never higher
+        # than the petal brightness even when the ROI happens to
+        # include a lot of over-exposed wall.
+        inside_clipped = inside[inside < 252]  # drop overexposed pixels
+        if inside_clipped.size < 100:
+            inside_clipped = inside
+        q25 = float(np.percentile(inside_clipped, 25))
+        q70 = float(np.percentile(inside_clipped, 70))
+        # Aim for a threshold 15-25 above the local median that is still
+        # lower than the petal brightness (~q70).
+        local_thresh = int(min(
+            max(min_luminance, q25 + 18),
+            q70 - 3,
+        ))
+        global_thresh_val = max(global_thresh_val, local_thresh)
+
+        bright_local = ((L > local_thresh) & neutral & (roi_mask > 0)).astype(np.uint8) * 255
+
+        # Close within ROI so petals fuse.
+        closed = cv2.morphologyEx(bright_local, cv2.MORPH_CLOSE, kernel_close)
+        cleaned = cv2.morphologyEx(closed, cv2.MORPH_OPEN, kernel_open)
+
+        # Fill internal holes.
+        cnts_all, _ = cv2.findContours(cleaned, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+        filled = np.zeros_like(cleaned)
+        cv2.drawContours(filled, cnts_all, -1, 255, thickness=cv2.FILLED)
+
+        # Update debug totals.
+        bright_total = cv2.bitwise_or(bright_total, bright_local)
+        filled_total = cv2.bitwise_or(filled_total, filled)
+
+        # Pick the component that contains the cluster centroid.
+        num_labels, labels_img, stats, centroids = cv2.connectedComponentsWithStats(
+            filled, connectivity=8
+        )
+        selected_label = -1
+        cx_i, cy_i = int(cx_c), int(cy_c)
+        if 0 <= cy_i < h and 0 <= cx_i < w:
+            candidate_label = int(labels_img[cy_i, cx_i])
+            if candidate_label > 0:
+                selected_label = candidate_label
+        if selected_label < 0:
+            # Fallback: largest component inside roi.
+            best = -1
+            best_area = 0
+            for lbl in range(1, num_labels):
+                a = stats[lbl, cv2.CC_STAT_AREA]
+                if a > best_area:
+                    best_area = a
+                    best = lbl
+            selected_label = best
+
+        if selected_label <= 0:
+            rejects.append((np.array([[[cx_i, cy_i]]], dtype=np.int32),
+                            "no_component"))
+            continue
+
+        comp_mask = (labels_img == selected_label).astype(np.uint8) * 255
+        if geometry_ready:
+            prior_overlap = float(
+                cv2.countNonZero(cv2.bitwise_and(comp_mask, five_petal_mask))
+            ) / max(1.0, float(cv2.countNonZero(five_petal_mask)))
+            constrain_k = max(5, int(0.014 * short_edge))
+            constrain_k = constrain_k if constrain_k % 2 == 1 else constrain_k + 1
+            constrain_kernel = cv2.getStructuringElement(
+                cv2.MORPH_ELLIPSE, (constrain_k, constrain_k),
+            )
+            prior_band = cv2.dilate(five_petal_mask, constrain_kernel, iterations=1)
+            comp_mask = cv2.bitwise_and(comp_mask, prior_band)
+            if prior_overlap >= 0.20:
+                comp_mask = cv2.bitwise_or(comp_mask, five_petal_mask)
+        comp_cnts, _ = cv2.findContours(comp_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+        if not comp_cnts:
+            continue
+        cnt = max(comp_cnts, key=cv2.contourArea)
+
+        area = float(cv2.contourArea(cnt))
+        if area < min_abs_area:
+            rejects.append((cnt, f"A<{min_abs_area}"))
+            continue
+        if area > max_abs_area:
+            rejects.append((cnt, f"A>{max_abs_area}"))
+            continue
+
+        bx, by, bw_c, bh_c = cv2.boundingRect(cnt)
+        if (bx <= border_margin or by <= border_margin
+                or bx + bw_c >= w - border_margin
+                or by + bh_c >= h - border_margin):
+            rejects.append((cnt, "border"))
+            continue
+
+        aspect = max(bw_c, bh_c) / max(1, min(bw_c, bh_c))
+        if aspect > max_aspect:
+            rejects.append((cnt, f"asp={aspect:.1f}"))
+            continue
+
+        density = area / float(bw_c * bh_c + 1)
+        if density < min_density:
+            rejects.append((cnt, f"dens={density:.2f}"))
+            continue
+
+        perimeter = float(cv2.arcLength(cnt, True))
+        if perimeter <= 0:
+            continue
+        circularity = 4.0 * np.pi * area / (perimeter * perimeter)
+
+        # Dark-delta signal (bolt darker than ring).
+        cmask = np.zeros((h, w), dtype=np.uint8)
+        cv2.drawContours(cmask, [cnt], -1, 255, -1)
+        er_k = max(5, int(min(bw_c, bh_c) * 0.35))
+        er_k = er_k if er_k % 2 == 1 else er_k + 1
+        eroded = cv2.erode(
+            cmask, cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (er_k, er_k))
+        )
+        ring_mask = cv2.subtract(cmask, eroded)
+        dark_delta = 0.0
+        if (eroded > 0).any() and (ring_mask > 0).any():
+            L_inner = float(L[eroded > 0].mean())
+            L_ring = float(L[ring_mask > 0].mean())
+            dark_delta = L_ring - L_inner
+
+        # Centrality
+        M = cv2.moments(cnt)
+        if M["m00"] == 0:
+            continue
+        cnt_cx = M["m10"] / M["m00"]
+        cnt_cy = M["m01"] / M["m00"]
+        d_img = ((cnt_cx - img_cx) ** 2 + (cnt_cy - img_cy) ** 2) ** 0.5 / img_diag
+        d_hint = ((cnt_cx - hint_cx) ** 2 + (cnt_cy - hint_cy) ** 2) ** 0.5 / img_diag
+        img_cent = max(0.0, 1.0 - d_img / 0.55)
+        hint_cent = max(0.0, 1.0 - d_hint / 0.45)
+        hub_dist = min(
+            float(((sx - cnt_cx) ** 2 + (sy - cnt_cy) ** 2) ** 0.5)
+            for (sx, sy, _) in cluster
+        )
+        eq_r = float((area / np.pi) ** 0.5) if area > 0 else 0.0
+        hub_score = max(0.0, 1.0 - hub_dist / max(8.0, eq_r * 0.42))
+        cluster_radii = np.array([s[2] for s in cluster], dtype=np.float32)
+        median_spot_r = float(np.median(cluster_radii)) if cluster_radii.size > 0 else 0.0
+        hub_spots = [
+            (sx, sy, sr)
+            for (sx, sy, sr) in cluster
+            if ((sx - cnt_cx) ** 2 + (sy - cnt_cy) ** 2) ** 0.5 <= max(10.0, eq_r * 0.28)
+        ]
+        outer_ring_spots = sum(
+            1
+            for (sx, sy, _) in cluster
+            if max(10.0, eq_r * 0.32) <= ((sx - cnt_cx) ** 2 + (sy - cnt_cy) ** 2) ** 0.5 <= max(14.0, eq_r * 0.95)
+        )
+        hub_radius = max((float(sr) for (_, _, sr) in hub_spots), default=0.0)
+        if roi is None and (
+            hub_radius < max(float(dark_spot_min_radius) * 1.05, median_spot_r * 1.12)
+            or outer_ring_spots < 3
+        ):
+            rejects.append((cnt.copy(), "weak_hub"))
+            continue
+
+        circ_score = max(0.20, 1.0 - abs(circularity - 0.58) / 0.58)
+        aspect_score = 1.0 if aspect <= 1.55 else max(0.4, 1.75 - 0.60 * aspect)
+        spots_score = max(
+            min(1.0, len(cluster) / 5.0),
+            min(1.0, (five_petal_outer + min(2, five_petal_inner)) / 7.0)
+            if geometry_ready else 0.0,
+        )
+        dark_score = min(1.0, max(0.0, dark_delta) / 40.0)
+        geometry_score = min(1.0, five_petal_score) if geometry_ready else 0.0
+
+        score = (
+            0.22 * spots_score
+            + 0.16 * geometry_score
+            + 0.12 * circ_score
+            + 0.12 * aspect_score
+            + 0.14 * img_cent
+            + 0.08 * hint_cent
+            + 0.10 * dark_score
+            + 0.06 * hub_score
+        )
+
+        candidates.append(ValveCandidate(
+            contour=cnt,
+            area=area,
+            perimeter=perimeter,
+            circularity=circularity,
+            aspect=aspect,
+            centrality=img_cent,
+            dark_center_ratio=min(1.0, float(max(len(cluster), five_petal_outer + five_petal_inner)) / 7.0),
+            score=score,
+        ))
+
+    if debug_out is not None:
+        _dump_debug(
+            img, roi, bright_total, filled_total, filled_total,
+            candidates, rejects, global_thresh_val, dark_spots, debug_out,
+        )
+
+    if not candidates:
+        return None
+
+    candidates.sort(key=lambda c: c.score, reverse=True)
+    return candidates[0]
+
+
+# ----------------------------------------------------------------------
+# YOLO-seg label formatting
+# ----------------------------------------------------------------------
+def contour_to_yolo_seg(
+    contour: np.ndarray,
+    image_w: int,
+    image_h: int,
+    class_id: int,
+    simplify_eps: float = 0.002,
+    max_points: int = 120,
+) -> tuple[str, np.ndarray]:
+    perimeter = cv2.arcLength(contour, True)
+    eps = max(1.5, simplify_eps * perimeter)
+    simplified = cv2.approxPolyDP(contour, eps, True)
+
+    # If still too many points, increase eps until under max_points.
+    step = 0
+    while len(simplified) > max_points and step < 6:
+        eps *= 1.4
+        simplified = cv2.approxPolyDP(contour, eps, True)
+        step += 1
+
+    if len(simplified) < 3:
+        simplified = contour
+
+    tokens: list[str] = [str(class_id)]
+    for pt in simplified.reshape(-1, 2):
+        nx = float(pt[0]) / float(image_w)
+        ny = float(pt[1]) / float(image_h)
+        nx = min(1.0, max(0.0, nx))
+        ny = min(1.0, max(0.0, ny))
+        tokens.append(f"{nx:.6f}")
+        tokens.append(f"{ny:.6f}")
+
+    return " ".join(tokens), simplified
+
+
+# ----------------------------------------------------------------------
+# Visualization helpers
+# ----------------------------------------------------------------------
+def draw_main_visualization(
+    img: np.ndarray,
+    roi: CylinderROI | None,
+    valve: ValveCandidate | None,
+    simplified_contour: np.ndarray | None,
+    thresh_val: int | None,
+) -> np.ndarray:
+    vis = img.copy()
+    h, w = vis.shape[:2]
+
+    # Cylinder outline (light blue).
+    if roi is not None:
+        pts = (roi.polygon_norm * np.array([w, h])).astype(np.int32).reshape(-1, 1, 2)
+        cv2.polylines(vis, [pts], True, (255, 180, 0), 2)
+        cv2.putText(
+            vis, f"cylinder:{roi.cls_name} {roi.conf:.2f}",
+            (pts[0][0][0], max(30, int(pts[0][0][1]) - 10)),
+            cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 180, 0), 2,
+        )
+
+    # Valve polygon (green fill + thick green outline).
+    if valve is not None and simplified_contour is not None:
+        overlay = vis.copy()
+        cv2.fillPoly(overlay, [simplified_contour], (0, 255, 0))
+        cv2.addWeighted(overlay, 0.35, vis, 0.65, 0, vis)
+        cv2.polylines(vis, [simplified_contour], True, (0, 255, 0), 3)
+
+        bx, by, bw, bh = cv2.boundingRect(simplified_contour)
+        label = (
+            f"valve score={valve.score:.2f} "
+            f"circ={valve.circularity:.2f} "
+            f"area={valve.area / (w * h):.3f}"
+        )
+        cv2.putText(
+            vis, label, (bx, max(30, by - 12)),
+            cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2,
+        )
+    else:
+        msg = "NO VALVE DETECTED"
+        cv2.putText(
+            vis, msg, (30, 60),
+            cv2.FONT_HERSHEY_SIMPLEX, 1.2, (0, 0, 255), 3,
+        )
+
+    if thresh_val is not None:
+        cv2.putText(
+            vis, f"L_thresh={thresh_val}", (30, h - 30),
+            cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2,
+        )
+
+    return vis
+
+
+def _dump_debug(
+    img: np.ndarray,
+    roi: CylinderROI | None,
+    bright: np.ndarray,
+    cleaned: np.ndarray,
+    filled: np.ndarray,
+    candidates: list[ValveCandidate],
+    rejects: list[tuple[np.ndarray, str]],
+    thresh_val: int,
+    dark_spots: list[tuple[int, int, int]],
+    out_path: Path,
+) -> None:
+    """Save a 2x2 debug panel (input / bright / morphed / candidates)."""
+    h, w = img.shape[:2]
+
+    def to_bgr(gray: np.ndarray) -> np.ndarray:
+        return cv2.cvtColor(gray, cv2.COLOR_GRAY2BGR)
+
+    panel_img = img.copy()
+    if roi is not None:
+        cv2.polylines(
+            panel_img,
+            [(roi.polygon_norm * np.array([w, h])).astype(np.int32).reshape(-1, 1, 2)],
+            True, (255, 180, 0), 2,
+        )
+    # Show the dark spots we found (= candidate bolt + petal holes).
+    for (sx, sy, sr) in dark_spots:
+        cv2.circle(panel_img, (sx, sy), max(sr, 3), (0, 140, 255), 2)
+    cv2.putText(
+        panel_img, f"Lthr={thresh_val}  spots={len(dark_spots)}", (30, 40),
+        cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 255), 2,
+    )
+
+    cand_img = img.copy()
+    # Draw rejected blobs in red with their reason.
+    for cnt, reason in rejects:
+        cv2.drawContours(cand_img, [cnt], -1, (60, 60, 255), 1)
+        bx, by, _, _ = cv2.boundingRect(cnt)
+        cv2.putText(
+            cand_img, reason, (bx, max(15, by - 4)),
+            cv2.FONT_HERSHEY_SIMPLEX, 0.45, (60, 60, 255), 1,
+        )
+    for i, c in enumerate(candidates):
+        color = (0, 255, 0) if i == 0 else (0, 200, 220)
+        thick = 3 if i == 0 else 2
+        cv2.drawContours(cand_img, [c.contour], -1, color, thick)
+        bx, by, _, _ = cv2.boundingRect(c.contour)
+        cv2.putText(
+            cand_img,
+            f"s={c.score:.2f} c={c.circularity:.2f}",
+            (bx, max(20, by - 5)),
+            cv2.FONT_HERSHEY_SIMPLEX, 0.6, color, 2,
+        )
+
+    def resize_for_panel(im: np.ndarray) -> np.ndarray:
+        scale = 640.0 / max(im.shape[:2])
+        return cv2.resize(im, (int(im.shape[1] * scale), int(im.shape[0] * scale)))
+
+    p1 = resize_for_panel(panel_img)
+    p2 = resize_for_panel(to_bgr(bright))
+    p3 = resize_for_panel(to_bgr(cleaned))
+    p4 = resize_for_panel(cand_img)
+
+    for tile, txt in [(p1, "input+cylinder"), (p2, "bright+neutral"),
+                       (p3, "morphed"), (p4, "candidates/rejects")]:
+        cv2.putText(
+            tile, txt, (10, 25),
+            cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 255), 2,
+        )
+
+    row1 = np.hstack([p1, p2])
+    row2 = np.hstack([p3, p4])
+    panel = np.vstack([row1, row2])
+    imwrite_unicode(out_path, panel)
+
+
+# ----------------------------------------------------------------------
+# Main driver
+# ----------------------------------------------------------------------
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(
+        description=(
+            "Auto-label valve handwheels as YOLO polygon segmentation "
+            "labels (class_id=1 by default)."
+        )
+    )
+    p.add_argument("--image-dir", type=Path, default=DEFAULT_IMAGE_DIR)
+    p.add_argument("--labels-dir", type=Path, default=None,
+                   help="Where to write .txt labels (default: next to images).")
+    p.add_argument("--vis-dir", type=Path, default=DEFAULT_VIS_DIR,
+                   help="Where to save visualization overlays.")
+    p.add_argument("--debug-dir", type=Path, default=DEFAULT_DEBUG_DIR,
+                   help="Where to save 2x2 debug panels (--debug).")
+    p.add_argument("--model", default=DEFAULT_MODEL)
+    p.add_argument("--device", default="cpu",
+                   help="Ultralytics device string, e.g. cpu or 0.")
+    p.add_argument("--class-id", type=int, default=1)
+    p.add_argument("--limit", type=int, default=0,
+                   help="If > 0, only process the first N images (useful for quick check).")
+    p.add_argument("--names", nargs="*", default=None,
+                   help="Only process images whose stem is in this list.")
+    p.add_argument("--debug", action="store_true",
+                   help="Save a 4-panel debug image per processed image.")
+    p.add_argument("--overwrite", action="store_true",
+                   help="Overwrite existing non-empty labels.")
+    p.add_argument("--skip-visualizations", action="store_true")
+    # Tuning knobs (all ratios are relative to min(image width, height)):
+    p.add_argument("--min-luminance", type=int, default=135)
+    p.add_argument("--neutral-tol", type=int, default=90,
+                   help="|a-128|+|b-128| limit; smaller = stricter 'white'.")
+    p.add_argument("--close-kernel-ratio", type=float, default=0.035,
+                   help="Morph-close kernel as fraction of min(H,W).")
+    p.add_argument("--open-kernel-ratio", type=float, default=0.0035)
+    p.add_argument("--min-area-ratio", type=float, default=0.003,
+                   help="Min valve area as fraction of image area.")
+    p.add_argument("--max-area-ratio", type=float, default=0.14)
+    p.add_argument("--max-aspect", type=float, default=2.2)
+    p.add_argument("--min-density", type=float, default=0.25)
+    p.add_argument("--dark-spot-min-radius-ratio", type=float, default=0.0020)
+    p.add_argument("--dark-spot-max-radius-ratio", type=float, default=0.028)
+    p.add_argument("--min-dark-spots", type=int, default=3,
+                   help="Min dark spots in one cluster to be a valve candidate.")
+    p.add_argument("--spot-cluster-gap-ratio", type=float, default=0.14,
+                   help="Max spot-pair distance, as fraction of min(H,W).")
+    p.add_argument("--spot-cluster-max-diameter-ratio", type=float, default=0.30,
+                   help="Max cluster diameter, as fraction of min(H,W). "
+                        "Rejects diffuse clusters on cables/wires.")
+    p.add_argument("--seed-growth-radius", type=float, default=1.7,
+                   help="Multiplier for seed-ROI radius around spot cluster.")
+    p.add_argument("--spot-bright-surround-L", type=int, default=130,
+                   help="Min mean L of a ring around each dark spot for "
+                        "it to count (rejects spots on chains/wires).")
+    p.add_argument("--no-yolo", action="store_true",
+                   help="Skip the YOLO cylinder hint stage (faster).")
+    # Bbox-prior mode (primary path when bbox labels are present):
+    p.add_argument("--bbox-dir", type=Path, default=None,
+                   help="Directory containing YOLO-format *bbox* labels "
+                        "(class cx cy w h) used as a prior. Defaults to "
+                        "--image-dir when omitted.")
+    p.add_argument("--no-bbox-prior", action="store_true",
+                   help="Ignore any existing bbox labels and run the "
+                        "global spot-seeded detector on every image.")
+    p.add_argument("--bbox-expand-ratio", type=float, default=0.08,
+                   help="Extra margin added around the input bbox before "
+                        "cropping, as a fraction of the bbox size.")
+    p.add_argument("--bbox-require-spots", type=int, default=3,
+                   help="Min dark circular spots (bolt + petal holes) "
+                        "that must fall inside the polygon for it to be "
+                        "accepted. Set 0 to disable validation.")
+    return p.parse_args()
+
+
+def should_skip_label(label_path: Path, overwrite: bool) -> bool:
+    if overwrite:
+        return False
+    if not label_path.exists():
+        return False
+    return label_path.stat().st_size > 0
+
+
+def main() -> None:
+    args = parse_args()
+
+    image_dir: Path = args.image_dir
+    labels_dir: Path = args.labels_dir if args.labels_dir is not None else image_dir
+    bbox_dir: Path = args.bbox_dir if args.bbox_dir is not None else image_dir
+    vis_dir: Path = args.vis_dir
+    debug_dir: Path = args.debug_dir
+
+    if not image_dir.exists():
+        raise FileNotFoundError(f"Image folder not found: {image_dir}")
+
+    labels_dir.mkdir(parents=True, exist_ok=True)
+    if not args.skip_visualizations:
+        vis_dir.mkdir(parents=True, exist_ok=True)
+    if args.debug:
+        debug_dir.mkdir(parents=True, exist_ok=True)
+
+    files = sorted(
+        p for p in image_dir.iterdir()
+        if p.is_file() and p.suffix.lower() in IMAGE_SUFFIXES
+    )
+    if args.names:
+        name_set = {n for n in args.names}
+        files = [p for p in files if p.stem in name_set]
+    if args.limit > 0:
+        files = files[: args.limit]
+
+    if not files:
+        print(f"No images found in: {image_dir}", flush=True)
+        return
+
+    # Device auto-upgrade if CUDA available and user left default cpu.
+    device = args.device
+    try:
+        import torch
+        if torch.cuda.is_available() and device == "cpu":
+            device = "0"
+            print(f"Using GPU: {torch.cuda.get_device_name(0)}", flush=True)
+        elif device == "cpu":
+            print("Using CPU (no GPU detected)", flush=True)
+    except Exception:
+        pass
+
+    print("Initializing valve auto-labeler (polygon mode)...", flush=True)
+    print(f"  image-dir  : {image_dir}", flush=True)
+    print(f"  labels-dir : {labels_dir}", flush=True)
+    print(f"  vis-dir    : {vis_dir}", flush=True)
+    print(f"  model      : {args.model if not args.no_yolo else '(skipped)'}", flush=True)
+    print(f"  device     : {device}", flush=True)
+    print(f"  class-id   : {args.class_id}", flush=True)
+    print(f"  images     : {len(files)}", flush=True)
+
+    locator = None
+    if not args.no_yolo:
+        try:
+            locator = CylinderLocator(args.model, device=device)
+        except Exception as e:
+            print(f"[Cylinder] Failed to load YOLO ({e}); continuing without hint.",
+                  flush=True)
+            locator = None
+
+    n_ok = 0
+    n_hint_missing = 0
+    n_valve_fail = 0
+    n_read_fail = 0
+    n_skip = 0
+    n_bbox_prior_used = 0
+    n_bbox_prior_fallback = 0
+    t_start = time.time()
+    failures: list[str] = []
+
+    for idx, image_path in enumerate(files, 1):
+        label_path = labels_dir / f"{image_path.stem}.txt"
+        if should_skip_label(label_path, args.overwrite):
+            print(f"[{idx}/{len(files)}] SKIP {image_path.name}", flush=True)
+            n_skip += 1
+            continue
+
+        img = imread_unicode(image_path)
+        if img is None:
+            print(f"[{idx}/{len(files)}] READ-FAIL {image_path.name}", flush=True)
+            n_read_fail += 1
+            failures.append(image_path.name)
+            continue
+
+        h, w = img.shape[:2]
+
+        # Stage 0 (primary path): try the bbox prior if available.
+        bbox_prior: tuple[int, int, int, int] | None = None
+        if not args.no_bbox_prior:
+            bbox_label_path = bbox_dir / f"{image_path.stem}.txt"
+            bbox_prior = read_yolo_bbox(
+                bbox_label_path, w, h, class_id=args.class_id,
+            )
+
+        bbox_debug = (debug_dir / f"{image_path.stem}_bbox.png"
+                      if args.debug else None)
+        spot_debug = (debug_dir / f"{image_path.stem}.png"
+                      if args.debug else None)
+
+        valve: ValveCandidate | None = None
+        mode_tag = ""
+
+        if bbox_prior is not None:
+            valve = _find_valve_polygon_in_bbox(
+                img, bbox_prior,
+                bbox_expand_ratio=args.bbox_expand_ratio,
+                neutral_tol=args.neutral_tol,
+                min_dark_spots_inside=args.bbox_require_spots,
+                require_dark_spots=args.bbox_require_spots > 0,
+                debug_out=bbox_debug,
+            )
+            if valve is not None:
+                mode_tag = "bbox"
+                n_bbox_prior_used += 1
+            else:
+                n_bbox_prior_fallback += 1
+
+        # Stage 1 (optional) & Stage 2 fallback: cylinder hint + spot-seeded
+        # global search. Only used when the bbox-prior path was unavailable
+        # or failed validation.
+        roi: CylinderROI | None = None
+        if valve is None:
+            if locator is not None:
+                roi = locator.locate(img)
+            if roi is None:
+                n_hint_missing += 1
+
+            valve = _find_valve_contour(
+                img, roi,
+                min_luminance=args.min_luminance,
+                neutral_tol=args.neutral_tol,
+                close_kernel_ratio=args.close_kernel_ratio,
+                open_kernel_ratio=args.open_kernel_ratio,
+                min_area_ratio=args.min_area_ratio,
+                max_area_ratio=args.max_area_ratio,
+                max_aspect=args.max_aspect,
+                min_density=args.min_density,
+                dark_spot_min_radius_ratio=args.dark_spot_min_radius_ratio,
+                dark_spot_max_radius_ratio=args.dark_spot_max_radius_ratio,
+                min_dark_spots_cluster=args.min_dark_spots,
+                spot_cluster_gap_ratio=args.spot_cluster_gap_ratio,
+                spot_cluster_max_diameter_ratio=args.spot_cluster_max_diameter_ratio,
+                seed_growth_radius=args.seed_growth_radius,
+                spot_bright_surround_L=args.spot_bright_surround_L,
+                debug_out=spot_debug,
+            )
+            if valve is not None:
+                mode_tag = "spot"
+
+        roi_tag = (
+            f"bbox=prior" if mode_tag == "bbox"
+            else (f"cyl={roi.cls_name}:{roi.conf:.2f}" if roi else "cyl=none")
+        )
+
+        if valve is None:
+            n_valve_fail += 1
+            label_path.write_text("", encoding="utf-8")
+            failures.append(image_path.name)
+            print(f"[{idx}/{len(files)}] FAIL {image_path.name} ({roi_tag})",
+                  flush=True)
+            if not args.skip_visualizations:
+                vis = draw_main_visualization(img, roi, None, None, None)
+                imwrite_unicode(vis_dir / image_path.name, vis)
+            continue
+
+        label_line, simplified = contour_to_yolo_seg(
+            valve.contour, w, h, args.class_id,
+        )
+        label_path.write_text(label_line + "\n", encoding="utf-8")
+
+        if not args.skip_visualizations:
+            vis = draw_main_visualization(img, roi, valve, simplified, None)
+            imwrite_unicode(vis_dir / image_path.name, vis)
+
+        n_ok += 1
+        area_frac = valve.area / float(w * h)
+        print(
+            f"[{idx}/{len(files)}] OK   {image_path.name} "
+            f"mode={mode_tag} score={valve.score:.2f} "
+            f"circ={valve.circularity:.2f} area/img={area_frac:.3f} "
+            f"pts={len(simplified)} ({roi_tag})",
+            flush=True,
+        )
+
+    elapsed = time.time() - t_start
+    print("", flush=True)
+    print("=" * 60, flush=True)
+    print("Valve auto-label finished.", flush=True)
+    print(f"  success         : {n_ok}", flush=True)
+    print(f"    via bbox prior : {n_bbox_prior_used}", flush=True)
+    print(f"    via spot search: {n_ok - n_bbox_prior_used}", flush=True)
+    print(f"  bbox prior rejected (fell back): {n_bbox_prior_fallback}",
+          flush=True)
+    print(f"  valve not found : {n_valve_fail}", flush=True)
+    print(f"  cylinder hint missing : {n_hint_missing}", flush=True)
+    print(f"  read failures   : {n_read_fail}", flush=True)
+    print(f"  skipped         : {n_skip}", flush=True)
+    print(f"  elapsed         : {elapsed/60:.1f} min ({elapsed:.1f} s)", flush=True)
+    print("=" * 60, flush=True)
+
+    if failures:
+        print("Images needing attention:", flush=True)
+        for n in failures[:40]:
+            print(f"  - {n}", flush=True)
+        if len(failures) > 40:
+            print(f"  ... {len(failures) - 40} more", flush=True)
+
+
+if __name__ == "__main__":
+    main()