app.py

import cv2 as cv
import numpy as np
import gradio as gr
from pathlib import Path
from collections import Counter, defaultdict
from huggingface_hub import hf_hub_download

from facial_fer_model import FacialExpressionRecog
from yunet import YuNet

# Download ONNX-modellen
FD_MODEL_PATH = hf_hub_download(repo_id="opencv/face_detection_yunet", filename="face_detection_yunet_2023mar.onnx")
FER_MODEL_PATH = hf_hub_download(repo_id="opencv/facial_expression_recognition", filename="facial_expression_recognition_mobilefacenet_2022july.onnx")

backend_id = cv.dnn.DNN_BACKEND_OPENCV
target_id = cv.dnn.DNN_TARGET_CPU

fer_model = FacialExpressionRecog(modelPath=FER_MODEL_PATH, backendId=backend_id, targetId=target_id)
detect_model = YuNet(modelPath=FD_MODEL_PATH)

# EN -> NL mapping (lowercase) incl. varianten/typo's
EN_TO_NL = {
    "neutral": "neutraal",

    "happy": "blij",
    "happiness": "blij",

    "sad": "verdrietig",
    "sadness": "verdrietig",

    "surprise": "verrast",
    "surprised": "verrast",
    "supprised": "verrast",   # typo
    "surprized": "verrast",

    "angry": "boos",
    "anger": "boos",

    "disgust": "walging",

    "fear": "angstig",
    "fearful": "angstig",
    "fearfull": "angstig",    # typo

    "contempt": "minachting",

    "unknown": "onbekend",
}

def to_dutch_lower(label: str) -> str:
    """Zet emotielabel om naar NL en lowercase (fallback: originele lowercase)."""
    if not label:
        return "onbekend"
    key = label.strip().lower()
    return EN_TO_NL.get(key, key)

# In-memory statistieken
emotion_stats = defaultdict(int)

def visualize(image, det_res, fer_res):
    """Tekent bbox + NL-lowercase emotielabel 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):
        bbox = det[0:4].astype(np.int32)
        fer_type_str_nl = to_dutch_lower(FacialExpressionRecog.getDesc(fer_type))

        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,
            (bbox[0], max(0, bbox[1] - 10)),
            cv.FONT_HERSHEY_SIMPLEX,
            0.7,
            (0, 0, 255),
            2,
            cv.LINE_AA
        )

        landmarks = det[4:14].astype(np.int32).reshape((5, 2))
        for idx, landmark in enumerate(landmarks):
            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:
        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])
    return f"# **{top}**\n\n_Gedetecteerde emoties: {details}_"

# --- 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)
    cv.putText(img, "Live emotie-statistieken", (12, 28), cv.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 0), 2, cv.LINE_AA)
    if not stats:
        cv.putText(img, "Nog geen statistieken", (12, height//2), cv.FONT_HERSHEY_SIMPLEX, 0.9, (128, 128, 128), 2, cv.LINE_AA)
        return cv.cvtColor(img, cv.COLOR_BGR2RGB)

    left, right, top, bottom = 60, 20, 50, 40
    plot_w = width - left - right
    plot_h = height - top - bottom
    origin = (left, height - bottom)

    cv.line(img, origin, (left + plot_w, height - bottom), (0, 0, 0), 2)            # x-as
    cv.line(img, origin, (left, height - bottom - plot_h), (0, 0, 0), 2)            # y-as

    labels = list(stats.keys())
    values = [stats[k] for k in labels]
    max_val = max(values) if max(values) > 0 else 1

    n = len(labels)
    gap = 12
    bar_w = max(10, int((plot_w - gap * (n + 1)) / max(1, n)))

    for i, (lab, val) in enumerate(zip(labels, values)):
        x1 = left + gap + i * (bar_w + gap)
        x2 = x1 + bar_w
        h_px = int((val / max_val) * (plot_h - 10))
        y1 = height - bottom - h_px
        y2 = height - bottom - 1
        cv.rectangle(img, (x1, y1), (x2, y2), (0, 170, 60), -1)                      # groene balk
        cv.putText(img, str(val), (x1 + 2, y1 - 6), cv.FONT_HERSHEY_SIMPLEX, 0.5, (0, 90, 30), 1, cv.LINE_AA)

        show_lab = lab if len(lab) <= 12 else lab[:11] + "…"
        (tw, th), _ = cv.getTextSize(show_lab, cv.FONT_HERSHEY_SIMPLEX, 0.5, 1)
        tx = x1 + (bar_w - tw) // 2
        ty = height - bottom + th + 12
        cv.putText(img, show_lab, (tx, ty), cv.FONT_HERSHEY_SIMPLEX, 0.5, (40, 40, 40), 1, cv.LINE_AA)

    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")
if EXAMPLES_DIR.exists() and EXAMPLES_DIR.is_dir():
    example_paths = [str(p) for p in sorted(EXAMPLES_DIR.iterdir()) if Path(p).suffix.lower() in IMAGE_EXTS]
else:
    example_paths = []
example_list = [[p] for p in example_paths]
CACHE_EXAMPLES = bool(example_list)

# Uitlegblok (HTML) – netjes opgemaakt
INFO_HTML = """
<div>
  <h3>Hoe werkt deze gezichtsuitdrukking-herkenner?</h3>
  <p>Dit model kan automatisch acht emoties herkennen in een foto van een gezicht:</p>
  <ul>
    <li>neutraal</li>
    <li>blij</li>
    <li>verdrietig</li>
    <li>verrast</li>
    <li>boos</li>
    <li>walging</li>
    <li>angstig</li>
    <li>minachting</li>
  </ul>
  <p>Je kunt hierboven een eigen foto uploaden of een voorbeeld aanklikken. Het systeem doorloopt twee stappen:</p>
  <ol>
    <li><b>Gezichtsdetectie</b> – met <i>YuNet</i> wordt het gezicht in de afbeelding gelokaliseerd.</li>
    <li><b>Emotieherkenning</b> – het gevonden gezicht wordt door <i>MobileFaceNet</i> geanalyseerd om de meest waarschijnlijke emotie te voorspellen.</li>
  </ol>
  <p>Deze modellen zijn getraind met <b>machine learning</b>. Voor dit type taak <b>is supervised training gebruikt</b>:
  er is gewerkt met een grote dataset van gezichten waarbij elke foto een label (zoals “blij” of “boos”) heeft. Tijdens het trainen leert het model welke combinaties van gezichtskenmerken bij welke emotie horen.</p>
  <p>Door heel veel voorbeelden te zien, kan het model ook bij nieuwe foto’s een inschatting maken. Het kijkt niet naar één detail, maar naar patronen in het hele gezicht.</p>
</div>
"""

# CSS (groene emotietekst + uitlegblok styling)
custom_css = """
#emotie-uitslag { color: #16a34a; }
#emotie-uitslag h1, #emotie-uitslag h2, #emotie-uitslag h3 { margin: 0.25rem 0; }

/* Uitlegblok onder de mugshots */
#uitleg-blok {
  background: #f3f4f6;        /* lichtgrijs */
  border: 1px solid #e5e7eb;  /* subtiele rand */
  border-radius: 10px;
  padding: 12px 14px;
}
#uitleg-blok h3 { margin: 6px 0 8px 0; }
#uitleg-blok p  { margin: 6px 0; }
#uitleg-blok ul { margin: 6px 0 6px 18px; }
#uitleg-blok ol { margin: 6px 0 6px 18px; }
"""

with gr.Blocks(css=custom_css) as demo:
    gr.Markdown("## Herkenning van gezichtsuitdrukkingen (FER) met OpenCV DNN")
    gr.Markdown("Detecteert gezichten en herkent gezichtsuitdrukkingen met YuNet + MobileFaceNet (ONNX).")

    # Rij 1: Links upload/knoppen, Rechts output + emotie
    with gr.Row():
        with gr.Column():
            input_image = gr.Image(type="numpy", label="Afbeelding uploaden")
            with gr.Row():
                submit_btn = gr.Button("Verstuur", variant="primary")
                clear_btn = gr.Button("Wissen")
        with gr.Column():
            output_image = gr.Image(type="numpy", label="Resultaat gezichtsuitdrukking")
            emotion_md = gr.Markdown("## **Nog geen resultaat**", elem_id="emotie-uitslag")

    # Rij 2: Links mugshots (Examples + uitleg), Rechts statistieken
    with gr.Row():
        with gr.Column():
            gr.Markdown("**Voorbeelden (klik om te testen):**")
            gr.Examples(
                examples=example_list,
                inputs=input_image,
                outputs=[output_image, emotion_md],   # <- 2 outputs
                fn=detect_expression_no_stats,        # <- geeft 2 outputs terug
                examples_per_page=20,
                cache_examples=CACHE_EXAMPLES
            )
            # Uitlegblok onder de mugshots
            gr.HTML(INFO_HTML, elem_id="uitleg-blok")

        with gr.Column():
            stats_image = gr.Image(
                label="Statistieken",
                type="numpy",
                value=draw_bar_chart_cv(emotion_stats)  # start met lege/actuele chart
            )

    # Clear-helpers
    def clear_all_on_new():
        return None, "## **Nog geen resultaat**"

    def clear_all_button():
        # reset inputs/outputs; statistieken blijven behouden
        return None, None, "## **Nog geen resultaat**", draw_bar_chart_cv(emotion_stats)

    # Nieuwe upload wist output + emotietekst (grafiek blijft staan)
    input_image.change(fn=clear_all_on_new, outputs=[output_image, emotion_md])
    # Verwerken
    submit_btn.click(fn=detect_expression, inputs=input_image, outputs=[output_image, emotion_md, stats_image])
    # Wissen-knop: ook grafiek opnieuw tekenen (maar stats niet resetten)
    clear_btn.click(fn=clear_all_button, outputs=[input_image, output_image, emotion_md, stats_image])

if __name__ == "__main__":
    demo.launch()