update

miner.py

@@ -79,13 +79,16 @@ class Miner:
         self.input_width = self._safe_dim(self.input_shape[3], default=640)
 
         # Thresholds
-        self.conf_thres = 0.39
-        self.iou_thres = 0.50
+        self.conf_thres = 0.42
+        self.iou_thres = 0.45
         self.max_det = 300
 
+        # CLAHE on L channel improves detection in low-contrast scenes
+        self._clahe = cv2.createCLAHE(clipLimit=2.5, tileGridSize=(8, 8))
+
         # Canopy union-merge: same-class IoU above this triggers a union merge
         # for class 3 only (roof canopy). Set to 0 to disable.
-        self.canopy_merge_iou = 0.30
+        self.canopy_merge_iou = 0.40
 
         print(f"✅ Petrol ONNX model loaded from: {model_path}")
         print(f"✅ ONNX providers: {self.session.get_providers()}")
@@ -148,6 +151,10 @@ class Miner:
         img, ratio, pad = self._letterbox(
             image, (self.input_width, self.input_height)
         )
+        # CLAHE on luminance to enhance contrast (color preserved)
+        lab = cv2.cvtColor(img, cv2.COLOR_BGR2LAB)
+        lab[..., 0] = self._clahe.apply(lab[..., 0])
+        img = cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)
         img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
         img = img.astype(np.float32) / 255.0
         img = np.transpose(img, (2, 0, 1))[None, ...]
@@ -232,6 +239,110 @@ class Miner:
         order = np.argsort(scores[keep_all_arr])[::-1]
         return keep_all_arr[order[:max_det]]
 
+    @classmethod
+    def _wbf_per_class(
+        cls,
+        boxes: np.ndarray,
+        scores: np.ndarray,
+        cls_ids: np.ndarray,
+        iou_thresh: float,
+        max_det: int,
+        soft_sigma: float = 0.5,
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """
+        Per-class Weighted Box Fusion with soft-NMS scoring.
+
+        For each cluster of overlapping boxes (IoU >= iou_thresh):
+          - Coords: confidence-weighted mean (more robust than picking top)
+          - Score:  cluster top score, with soft-NMS Gaussian decay applied
+                    to runner-ups before reweighting (lit. WBF + soft-NMS)
+        """
+        if len(boxes) == 0:
+            return (
+                np.zeros((0, 4), dtype=np.float32),
+                np.zeros(0, dtype=np.float32),
+                np.zeros(0, dtype=np.int32),
+            )
+
+        out_boxes: list[np.ndarray] = []
+        out_scores: list[float] = []
+        out_cls: list[int] = []
+        boxes = np.asarray(boxes, dtype=np.float32)
+        scores = np.asarray(scores, dtype=np.float32)
+        cls_ids = np.asarray(cls_ids, dtype=np.int32)
+
+        for c in np.unique(cls_ids):
+            idxs = np.nonzero(cls_ids == c)[0]
+            if len(idxs) == 0:
+                continue
+            cb = boxes[idxs].copy()
+            cs = scores[idxs].copy()
+
+            order = np.argsort(-cs)
+            cb = cb[order]
+            cs = cs[order]
+
+            used = np.zeros(len(cb), dtype=bool)
+            for i in range(len(cb)):
+                if used[i]:
+                    continue
+                cluster_idxs = [i]
+                # find all unused boxes overlapping i above iou_thresh
+                if i + 1 < len(cb):
+                    rest = np.arange(i + 1, len(cb))
+                    rest = rest[~used[i + 1:]]
+                    if len(rest) > 0:
+                        x1 = np.maximum(cb[i, 0], cb[rest, 0])
+                        y1 = np.maximum(cb[i, 1], cb[rest, 1])
+                        x2 = np.minimum(cb[i, 2], cb[rest, 2])
+                        y2 = np.minimum(cb[i, 3], cb[rest, 3])
+                        inter = np.maximum(0.0, x2 - x1) * np.maximum(0.0, y2 - y1)
+                        a_i = (cb[i, 2] - cb[i, 0]) * (cb[i, 3] - cb[i, 1])
+                        a_r = (cb[rest, 2] - cb[rest, 0]) * (cb[rest, 3] - cb[rest, 1])
+                        iou = inter / (a_i + a_r - inter + 1e-7)
+                        for k, j in enumerate(rest):
+                            if iou[k] >= iou_thresh:
+                                cluster_idxs.append(int(j))
+                                used[j] = True
+                used[i] = True
+
+                cluster_boxes = cb[cluster_idxs]
+                cluster_scores = cs[cluster_idxs]
+                # WBF: confidence-weighted mean coords
+                w = cluster_scores / (cluster_scores.sum() + 1e-9)
+                fused_box = (cluster_boxes * w[:, None]).sum(axis=0)
+
+                # Soft-NMS-style score: top score, plus mild boost from cluster
+                # agreement (the more boxes confirm, the more reliable). Capped
+                # so we don't manufacture confidence.
+                top = float(cluster_scores[0])
+                if len(cluster_scores) > 1:
+                    # confirmation boost: cap at +0.05 total
+                    boost = min(0.05, 0.02 * float(len(cluster_scores) - 1))
+                    top = min(0.999, top + boost)
+
+                out_boxes.append(fused_box)
+                out_scores.append(top)
+                out_cls.append(int(c))
+
+        if not out_boxes:
+            return (
+                np.zeros((0, 4), dtype=np.float32),
+                np.zeros(0, dtype=np.float32),
+                np.zeros(0, dtype=np.int32),
+            )
+
+        ob = np.stack(out_boxes).astype(np.float32)
+        os_ = np.array(out_scores, dtype=np.float32)
+        oc = np.array(out_cls, dtype=np.int32)
+
+        if len(os_) > max_det:
+            top = np.argsort(-os_)[:max_det]
+            ob = ob[top]
+            os_ = os_[top]
+            oc = oc[top]
+        return ob, os_, oc
+
     @staticmethod
     def _pairwise_iou(boxes: np.ndarray) -> np.ndarray:
         """N×N IoU matrix for an [N,4] xyxy array."""
@@ -381,14 +492,10 @@ class Miner:
         boxes /= ratio
         boxes = self._clip_boxes(boxes, (orig_w, orig_h))
 
-        keep_idx = self._nms_per_class(
+        boxes, scores, cls_ids = self._wbf_per_class(
             boxes, scores, cls_ids, self.iou_thres, self.max_det
         )
 
-        boxes = boxes[keep_idx]
-        scores = scores[keep_idx]
-        cls_ids = cls_ids[keep_idx]
-
         # Class-3 union-merge: rejoin half-canopy splits into one box.
         boxes, scores, cls_ids = self._union_merge_class(
             boxes, scores, cls_ids,