Update app.py

app.py

@@ -57,18 +57,80 @@ def to_dutch_lower(label: str) -> str:
 # In-memory statistieken
 emotion_stats = defaultdict(int)
 
-def visualize(image, det_res, fer_res):
-    """Tekent bbox + NL-lowercase emotielabel op de output."""
+# ---------- Confidence helpers ----------
+def _format_pct(conf):
+    """Format confidence naar '82%' (int). Conf kan in [0,1] of [0,100] of None."""
+    if conf is None:
+        return None
+    try:
+        c = float(conf)
+    except Exception:
+        return None
+    if c <= 1.0:
+        c *= 100.0
+    c = max(0.0, min(100.0, c))
+    return f"{int(round(c))}%"
+
+def _parse_infer_output(result):
+    """
+    Probeer robuust (label_idx, confidence) uit infer-output te halen.
+    Ondersteunt:
+      - (label, score) tuple/list
+      - [probs...] ndarray (neemt argmax + max)
+      - [label] of scalar -> (label, None)
+    """
+    # numpy array?
+    if isinstance(result, np.ndarray):
+        arr = result
+        if arr.ndim == 1 and arr.size > 1:
+            idx = int(np.argmax(arr))
+            conf = float(arr[idx])
+            return idx, conf
+        elif arr.size == 1:
+            return int(arr.flat[0]), None
+        else:
+            # onbekende vorm
+            try:
+                idx = int(arr[0])
+                return idx, None
+            except Exception:
+                return 0, None
+
+    # list/tuple?
+    if isinstance(result, (list, tuple)):
+        if len(result) >= 2 and isinstance(result[1], (float, np.floating, int, np.integer)):
+            try:
+                return int(result[0]), float(result[1])
+            except Exception:
+                pass
+        if len(result) >= 1:
+            try:
+                return int(result[0]), None
+            except Exception:
+                return 0, None
+
+    # scalar label
+    try:
+        return int(result), None
+    except Exception:
+        return 0, None
+# ---------------------------------------
+
+def visualize(image, det_res, labels, confs):
+    """Tekent bbox + NL-lowercase emotielabel + confidence op de output."""
     output = image.copy()
     landmark_color = [(255, 0, 0), (0, 0, 255), (0, 255, 0), (255, 0, 255), (0, 255, 255)]
-    for det, fer_type in zip(det_res, fer_res):
+    for i, (det, lab) in enumerate(zip(det_res, labels)):
         bbox = det[0:4].astype(np.int32)
-        fer_type_str_nl = to_dutch_lower(FacialExpressionRecog.getDesc(fer_type))
+        label_en = FacialExpressionRecog.getDesc(lab)
+        fer_type_str_nl = to_dutch_lower(label_en)
+        pct = _format_pct(confs[i] if i < len(confs) else None)
+        txt = f"{fer_type_str_nl}" + (f" {pct}" if pct else "")
 
         cv.rectangle(output, (bbox[0], bbox[1]), (bbox[0]+bbox[2], bbox[1]+bbox[3]), (0, 255, 0), 2)
         cv.putText(
             output,
-            fer_type_str_nl,
+            txt,
             (bbox[0], max(0, bbox[1] - 10)),
             cv.FONT_HERSHEY_SIMPLEX,
             0.7,
@@ -82,16 +144,73 @@ def visualize(image, det_res, fer_res):
             cv.circle(output, landmark, 2, landmark_color[idx], 2)
     return output
 
-def summarize_emotions(fer_res):
-    """Maakt de grote groene NL-lowercase samenvatting."""
-    if not fer_res:
+def summarize_emotions(labels, confs):
+    """Maakt de grote groene NL-lowercase samenvatting met gemiddelden per emotie."""
+    if not labels:
         return "## **geen gezicht gedetecteerd**"
-    names_nl = [to_dutch_lower(FacialExpressionRecog.getDesc(x)) for x in fer_res]
-    counts = Counter(names_nl).most_common()
-    top = counts[0][0]
-    details = ", ".join([f"{name} ({n})" for name, n in counts])
+
+    names_nl = []
+    for lab in labels:
+        names_nl.append(to_dutch_lower(FacialExpressionRecog.getDesc(lab)))
+
+    # tel per emotie + verzamel confidences
+    counts = Counter(names_nl)
+    conf_bucket = defaultdict(list)
+    for i, name in enumerate(names_nl):
+        if i < len(confs) and confs[i] is not None:
+            conf_bucket[name].append(float(confs[i]))
+
+    # top-emotie op basis van count
+    top = counts.most_common(1)[0][0]
+
+    # details: "blij (2, gem. 79%)"
+    parts = []
+    # sorteer op frequentie aflopend, dan alfabetisch
+    for name, n in sorted(counts.items(), key=lambda kv: (-kv[1], kv[0])):
+        if conf_bucket[name]:
+            avg = sum(conf_bucket[name]) / len(conf_bucket[name])
+            parts.append(f"{name} ({n}, gem. {_format_pct(avg)})")
+        else:
+            parts.append(f"{name} ({n})")
+    details = ", ".join(parts)
+
     return f"# **{top}**\n\n_Gedetecteerde emoties: {details}_"
 
+def process_image(input_image):
+    """Helper: run detectie en retourneer (output_img, labels[int], confs[float|None])."""
+    image = cv.cvtColor(input_image, cv.COLOR_RGB2BGR)
+    h, w, _ = image.shape
+    detect_model.setInputSize([w, h])
+    dets = detect_model.infer(image)
+    if dets is None:
+        return cv.cvtColor(image, cv.COLOR_BGR2RGB), [], [], None
+    labels, confs = [], []
+    for face_points in dets:
+        raw = fer_model.infer(image, face_points[:-1])
+        lab, conf = _parse_infer_output(raw)
+        labels.append(lab)
+        confs.append(conf)
+    output = visualize(image, dets, labels, confs)
+    return cv.cvtColor(output, cv.COLOR_BGR2RGB), labels, confs, dets
+
+def detect_expression(input_image):
+    """Versie die WÉL statistieken bijwerkt (gebruik voor 'Verstuur')."""
+    output_img, labels, confs, _ = process_image(input_image)
+    emotion_md = summarize_emotions(labels, confs)
+    # update stats in NL-lowercase
+    for lab in labels:
+        name_nl = to_dutch_lower(FacialExpressionRecog.getDesc(lab))
+        emotion_stats[name_nl] += 1
+    stats_plot = draw_bar_chart_cv(emotion_stats)
+    return output_img, emotion_md, stats_plot
+
+def detect_expression_no_stats(input_image):
+    """Versie die GEEN statistieken bijwerkt (gebruik voor gr.Examples & caching)."""
+    output_img, labels, confs, _ = process_image(input_image)
+    emotion_md = summarize_emotions(labels, confs)
+    # géén stats update en ook géén stats_image teruggeven
+    return output_img, emotion_md
+
 # --- Staafdiagram tekenen met OpenCV (geen matplotlib nodig) ---
 def draw_bar_chart_cv(stats: dict, width=640, height=320):
     img = np.full((height, width, 3), 255, dtype=np.uint8)
@@ -133,36 +252,6 @@ def draw_bar_chart_cv(stats: dict, width=640, height=320):
 
     return cv.cvtColor(img, cv.COLOR_BGR2RGB)
 
-def process_image(input_image):
-    """Helper: run detectie en retourneer (output_img, fer_res as list[int])."""
-    image = cv.cvtColor(input_image, cv.COLOR_RGB2BGR)
-    h, w, _ = image.shape
-    detect_model.setInputSize([w, h])
-    dets = detect_model.infer(image)
-    if dets is None:
-        return cv.cvtColor(image, cv.COLOR_BGR2RGB), []
-    fer_res = [fer_model.infer(image, face_points[:-1])[0] for face_points in dets]
-    output = visualize(image, dets, fer_res)
-    return cv.cvtColor(output, cv.COLOR_BGR2RGB), fer_res
-
-def detect_expression(input_image):
-    """Versie die WÉL statistieken bijwerkt (gebruik voor 'Verstuur')."""
-    output_img, fer_res = process_image(input_image)
-    emotion_md = summarize_emotions(fer_res)
-    # update stats in NL-lowercase
-    names_nl = [to_dutch_lower(FacialExpressionRecog.getDesc(x)) for x in fer_res]
-    for name in names_nl:
-        emotion_stats[name] += 1
-    stats_plot = draw_bar_chart_cv(emotion_stats)
-    return output_img, emotion_md, stats_plot
-
-def detect_expression_no_stats(input_image):
-    """Versie die GEEN statistieken bijwerkt (gebruik voor gr.Examples & caching)."""
-    output_img, fer_res = process_image(input_image)
-    emotion_md = summarize_emotions(fer_res)
-    # géén stats update en ook géén stats_image teruggeven
-    return output_img, emotion_md
-
 # Voorbeelden automatisch laden
 IMAGE_EXTS = {".jpg", ".jpeg", ".png", ".bmp", ".webp"}
 EXAMPLES_DIR = Path("examples")