Datasets:

rick003
/

11111

	"""
	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.55 * sector_hole_radii,
	sector_radii * 1.24)
	sector_tip_r = np.maximum(sector_tip_r, geom.center_radius * 2.60)
	sector_tip_r = np.minimum(sector_tip_r, sector_radii * 1.48)
	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.55 * local_hole,
	local_ring * 1.24,
	geom.center_radius * 2.60,
	)
	local_tip = min(local_tip, local_ring * 1.48)
	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.982 if matched_strength >= 0.55 else 0.940)
	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.90 + 0.055 * lobe)
	else:
	radius = prior * (0.84 + 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()