update pre-check function

Author: ShengkaiXu

evaluation_function/evaluation.py

@@ -36,16 +36,14 @@
         "fail": "Some parts could not be detected clearly. Please separate the parts and retake the photo.",
     },
     "precheck": {
-        "pass": "Good. The detected setup is consistent. You can proceed.",
-        "count_rule_fail": (
-            "The detected numbers of gears and gear-contact regions are not consistent. "
-            "Please make sure all gears and contact regions are clearly visible, then retake the photo."
+        "report": (
+            "Photo quality reference values:\n"
+            "- brightness: {brightness_mean}\n"
+            "- contrast: {contrast_std}\n"
+            "- sharpness: {sharpness_score}\n"
+            "- lighting uniformity: {illumination_nonuniformity}\n"
+            "These values are provided as reference only and do not determine whether the assembly is correct."
         ),
-        "big_small_inconsistent": (
-            "The detected numbers of big gears and small gears are not consistent. "
-            "Please make sure all gears are clearly visible, then retake the photo."
-        ),
-        "fail": "Please retake the photo. The detected setup is not consistent enough for reliable checking.",
     },
     "single_stage": {
         "pass": (
@@ -125,9 +123,17 @@
             "- driving gear: {driving_gear}\n"
             "- small gear: {smallgear}\n"
             "- big gear: {biggear}\n"
-            "The detected gears and contact regions are not consistent enough for reliable checking. "
-            "Please make sure only the intended gears are visible, that meshing areas can be seen clearly, "
-            "and then retake the photo."
+            "The system cannot reliably evaluate the gear meshing due to unclear or inconsistent detection results. "
+            "Please ensure that only the required gears are visible in the image, and that the gear meshing areas "
+            "are clearly shown before retaking the photo."
+        ),
+        "big_small_inconsistent": (
+            "Detected gears:\n"
+            "- driving gear: {driving_gear}\n"
+            "- small gear: {smallgear}\n"
+            "- big gear: {biggear}\n"
+            "The detected numbers of big gears and small gears are not consistent. "
+            "Please check the gear setup and retake the photo."
         ),
         "mismatch_fail": (
             "Detected gears:\n"
@@ -299,6 +305,7 @@ def keep(e: Dict[str, Any]) -> bool:
                 "E_NO_GEARS",
                 "E_MESH_MISMATCH",
                 "E_GEAR_CONTACT_INCONSISTENT",
+                "E_GEAR_BIG_SMALL_INCONSISTENT",
             }
 
         if task == "mesh_ratio":
@@ -513,25 +520,20 @@ def _build_student_message(
     task_has_error = _has_selected_pipeline_error(selected_errors)
 
     if task == "precheck":
-        codes = {
-            str(e.get("code", "")).upper()
-            for e in selected_errors
-            if isinstance(e, dict)
-        }
-
-        if "E_NO_GEARS" in codes:
-            return False, MESSAGE_POLICY["precheck"]["fail"]
-
-        if "E_PRECHECK_BIG_SMALL_INCONSISTENT" in codes:
-            return False, MESSAGE_POLICY["precheck"]["big_small_inconsistent"]
-
-        if "E_PRECHECK_COUNT_RULE_FAIL" in codes:
-            return False, MESSAGE_POLICY["precheck"]["count_rule_fail"]
-
-        if task_has_error:
-            return False, MESSAGE_POLICY["precheck"]["fail"]
-
-        return True, MESSAGE_POLICY["precheck"]["pass"]
+        quality = out.get("quality", {}) if isinstance(out.get("quality"), dict) else {}
+
+        def qfmt(key: str) -> str:
+            try:
+                return f"{float(quality.get(key, 0.0)):.2f}"
+            except Exception:
+                return str(quality.get(key, "N/A"))
+
+        return True, MESSAGE_POLICY["precheck"]["report"].format(
+            brightness_mean=qfmt("brightness_mean"),
+            contrast_std=qfmt("contrast_std"),
+            sharpness_score=qfmt("sharpness_score"),
+            illumination_nonuniformity=qfmt("illumination_nonuniformity"),
+        )
 
     if task == "single_stage":
         codes = {
@@ -721,6 +723,13 @@ def _build_student_message(
                 biggear=biggear,
             )
 
+        if "E_GEAR_BIG_SMALL_INCONSISTENT" in codes:
+            return False, MESSAGE_POLICY["gear_inventory"]["big_small_inconsistent"].format(
+                driving_gear=driving_gear,
+                smallgear=smallgear,
+                biggear=biggear,
+            )
+
         if "E_GEAR_CONTACT_INCONSISTENT" in codes:
             return False, MESSAGE_POLICY["gear_inventory"]["contact_consistency_fail"].format(
                 driving_gear=driving_gear,

evaluation_function/yolo_pipeline.py

@@ -711,25 +711,33 @@ def get_spacer_counts(spacers: List[Dict[str, Any]]) -> Dict[str, int]:
 # =========================
 # Precheck helpers
 # =========================
-def evaluate_precheck_consistency(
-    gears: List[Dict[str, Any]],
-    mesh_boxes: List[Tuple[float, float, float, float]],
-    mismesh_boxes: List[Tuple[float, float, float, float]],
-) -> Tuple[List[Dict[str, str]], Dict[str, int]]:
-    errs: List[Dict[str, str]] = []
-
-    counts = get_gear_counts(gears)
-
-    if counts["biggear"] != counts["smallgear"]:
-        errs.append({
-            "code": "E_PRECHECK_BIG_SMALL_INCONSISTENT",
-            "message": (
-                f"Precheck failed: biggear={counts['biggear']} and smallgear={counts['smallgear']} "
-                f"are not consistent."
-            ),
-        })
+def compute_image_quality_metrics(img_bgr: np.ndarray) -> Dict[str, float]:
+    gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
+
+    brightness_mean = float(np.mean(gray))
+    contrast_std = float(np.std(gray))
+    sharpness_score = float(cv2.Laplacian(gray, cv2.CV_64F).var())
+
+    h, w = gray.shape
+    block_means: List[float] = []
+    for r in range(4):
+        for c in range(4):
+            y0 = int(r * h / 4)
+            y1 = int((r + 1) * h / 4)
+            x0 = int(c * w / 4)
+            x1 = int((c + 1) * w / 4)
+            patch = gray[y0:y1, x0:x1]
+            if patch.size > 0:
+                block_means.append(float(np.mean(patch)))
+
+    illumination_nonuniformity = float(np.std(block_means)) if block_means else 0.0
 
-    return errs, counts
+    return {
+        "brightness_mean": brightness_mean,
+        "contrast_std": contrast_std,
+        "sharpness_score": sharpness_score,
+        "illumination_nonuniformity": illumination_nonuniformity,
+    }
 
 
 # =========================
@@ -839,6 +847,15 @@ def evaluate_gear_inventory_step(
         })
         return errs, counts
 
+    if counts["biggear"] != counts["smallgear"]:
+        errs.append({
+            "code": "E_GEAR_BIG_SMALL_INCONSISTENT",
+            "message": (
+                f"Gear inventory check failed: biggear={counts['biggear']} and "
+                f"smallgear={counts['smallgear']} are not consistent."
+            ),
+        })
+
     total_contact = len(mesh_boxes) + len(mismesh_boxes)
     gear_count = len(gears)
     expected_contact, ok = expected_contact_boxes_from_gear_count(gear_count)
@@ -2095,11 +2112,9 @@ def _need_shafts() -> bool:
 
     # --- task: precheck ---
     if task == TASK_PRECHECK:
-        errors, counts = evaluate_precheck_consistency(
-            gears=gears,
-            mesh_boxes=mesh_boxes,
-            mismesh_boxes=mismesh_boxes,
-        )
+        quality = compute_image_quality_metrics(img_bgr)
+        counts = get_gear_counts(gears)
+        errors: List[Dict[str, Any]] = []
 
         out = {
             "summary": {
@@ -2111,13 +2126,14 @@ def _need_shafts() -> bool:
                 "stages": 0,
             },
             "counts": counts,
+            "quality": quality,
             "errors": errors,
             "ratio": {"num_stages": 0, "R_total": None, "out_rpm": None, "per_stage": []},
             "cold_start": bool(is_cold_start),
             "task_result": _task_result(
                 TASK_PRECHECK,
                 errors,
-                focus=["precheck"],
+                focus=["photo_quality"],
                 next_task=TASK_SINGLE_STAGE,
             ),
             "timing": {},