Update app.py

app.py

@@ -1,201 +1,101 @@
 
-import os
-import time
-import tempfile
-import random
-import numpy as np
 import gradio as gr
-
-# Optioneel: sneller importeren als torch aanwezig is
-try:
-    import torch
-    HAS_CUDA = torch.cuda.is_available()
-except Exception:
-    HAS_CUDA = False
-
-# Coqui TTS (XTTS-v2)
-from TTS.api import TTS
-
-# Audio post-processing
-import soundfile as sf
-import librosa
-
-MODEL_NAME = "tts_models/multilingual/multi-dataset/xtts_v2"
-
-# Laad model één keer bij startup
-def load_model():
-    # Gebruik GPU als beschikbaar; anders CPU
-    t0 = time.time()
-    tts = TTS(MODEL_NAME, gpu=HAS_CUDA)
-    load_s = f"{time.time() - t0:.1f}s"
-    return tts, load_s
-
-tts, MODEL_LOAD_SECONDS = load_model()
-
-# Beperkte maar praktische set van taal-codes die XTTS goed aankan
-LANGS = [
-    "nl", "en", "de", "fr", "es", "it", "pt", "pl", "tr", "ru", "ja", "ko", "zh"
-]
-
-HELP_MD = """
-### ℹ️ Hoe gebruik je deze Space
-1. **Neem 6–20 seconden referentie-audio op** (of upload een bestaand fragment) van de stem die je wilt klonen.
-2. Kies de **taal** van de **uitvoer** (niet per se de referentietaal).
-3. Vink aan dat je **toestemming** hebt van de stem-eigenaar.
-4. Voer de **tekst** in en klik **Genereer**.
-
-> Gebruik dit alleen met **expliciete toestemming**. De uitvoer is synthetisch; misleiding is verboden.
-"""
-
-EXAMPLE_TEXTS = [
-    "Welkom! Dit is een korte demo van de AI-stemkloner.",
-    "Vandaag bespreken we de roadmap en de belangrijkste prioriteiten.",
-    "Dit is een testzin om te horen hoe de uitspraak klinkt.",
-    "Hallo! Fijn dat je luistert naar deze AI-gegenereerde stem.",
-]
-
-def validate_inputs(text, ref_audio, declare_consent):
-    if not declare_consent:
-        raise gr.Error("Je moet bevestigen dat je toestemming hebt van de stem-eigenaar.")
-    if not text or not text.strip():
-        raise gr.Error("Voer tekst in om uit te spreken.")
-    if ref_audio is None:
-        raise gr.Error("Upload of neem een korte referentie-audio op (ca. 6–20 s).")
-
-def add_silence(wav, sr, pre_ms=0, post_ms=0):
-    pre = np.zeros(int(sr * pre_ms / 1000.0), dtype=wav.dtype)
-    post = np.zeros(int(sr * post_ms / 1000.0), dtype=wav.dtype)
-    if wav.ndim == 1:
-        return np.concatenate([pre, wav, post], axis=0)
-    else:
-        pre = np.tile(pre[:, None], (1, wav.shape[1]))
-        post = np.tile(post[:, None], (1, wav.shape[1]))
-        return np.concatenate([pre, wav, post], axis=0)
-
-def time_stretch_safe(wav, sr, rate=1.0):
-    # Gebruik librosa voor tijdrekken zonder toonhoogte te veranderen
-    if rate == 1.0:
-        return wav
-    # librosa verwacht mono; als stereo -> per kanaal
-    if wav.ndim == 1:
-        return librosa.effects.time_stretch(wav, rate=rate)
-    else:
-        chs = []
-        for ch in range(wav.shape[1]):
-            chs.append(librosa.effects.time_stretch(wav[:, ch], rate=rate))
-        # pad / trim naar gelijke lengte
-        maxlen = max(c.shape[0] for c in chs)
-        chs = [np.pad(c, (0, maxlen - c.shape[0])) for c in chs]
-        return np.stack(chs, axis=1)
-
-def postprocess_audio(path, speed, pre_ms, post_ms):
-    y, sr = librosa.load(path, sr=None, mono=False)
-    y_proc = time_stretch_safe(y, sr, rate=speed)
-    y_proc = add_silence(y_proc, sr, pre_ms=pre_ms, post_ms=post_ms)
-    # Overschrijf of schrijf naar nieuw pad
-    out_path = os.path.join(tempfile.gettempdir(), f"xtts_out_pp_{int(time.time())}.wav")
-    sf.write(out_path, y_proc, sr)
-    return out_path
-
-def tts_clone(text, ref_audio, language, declare_consent, speed, pre_ms, post_ms, seed, progress=gr.Progress(track_tqdm=True)):
-    validate_inputs(text, ref_audio, declare_consent)
-
-    # Seeds instellen voor reproduceerbaarheid (voor zover mogelijk)
-    try:
-        random.seed(seed)
-        np.random.seed(seed % (2**32 - 1))
-        if 'torch' in globals():
-            torch.manual_seed(seed)
-            if HAS_CUDA:
-                torch.cuda.manual_seed_all(seed)
-    except Exception:
-        pass
-
-    progress(0, desc="Controleren van invoer…")
-    # Bestandslimiet check
-    try:
-        size_mb = os.path.getsize(ref_audio) / (1024 * 1024)
-        if size_mb > 5:
-            raise gr.Error("Referentie-audio is groter dan 5 MB. Gebruik een korter fragment (6–20 s).")
-    except Exception:
-        pass
-
-    progress(0.2, desc="Synthese bezig…")
-    raw_out = os.path.join(tempfile.gettempdir(), f"xtts_out_{int(time.time())}.wav")
-
-    try:
-        tts.tts_to_file(
-            text=text,
-            file_path=raw_out,
-            speaker_wav=ref_audio,
-            language=language
-        )
-    except Exception as e:
-        raise gr.Error(f"Er ging iets mis bij synthese: {e}")
-
-    progress(0.7, desc="Post-processing (tempo/pauzes)…")
-    final_out = postprocess_audio(raw_out, speed=float(speed), pre_ms=int(pre_ms), post_ms=int(post_ms))
-
-    progress(0.98, desc="Afronden…")
-    time.sleep(0.1)
-    return final_out, final_out  # audio output + download button value
-
-with gr.Blocks(theme=gr.themes.Soft(), css="footer {visibility: hidden}") as demo:
-    gr.Markdown(
-        f"## 🔊 AI-Stemkloner (XTTS-v2)\n"
-        f"**Model:** `{MODEL_NAME}` – geladen in ~{MODEL_LOAD_SECONDS} • "
-        + ("**GPU** gedetecteerd ✅" if HAS_CUDA else "**CPU** modus 🐢 (langzamer)")
-    )
-
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+from deepface import DeepFace
+
+# Instellingen voor "gewoon werken"
+DETECTOR = "retinaface"   # nauwkeuriger dan 'opencv'
+TAU = 0.65                 # onder deze confidence -> "Onzeker"
+ACTIONS = ["emotion"]
+
+def analyze_batch(files, tau=TAU, show_boxes=True):
+    all_rows = []
+    visuals = []
+
+    for f in files:
+        img = Image.open(f).convert("RGB")
+        np_img = np.array(img)
+
+        try:
+            result = DeepFace.analyze(
+                img_path=np_img,
+                actions=ACTIONS,
+                detector_backend=DETECTOR,
+                enforce_detection=False  # crash niet als er geen gezicht is
+            )
+        except Exception as e:
+            all_rows.append({"file": f.name, "error": str(e)})
+            visuals.append(img)
+            continue
+
+        # DeepFace kan 1 dict of list teruggeven
+        results = result if isinstance(result, list) else [result]
+
+        draw = ImageDraw.Draw(img.copy())
+        try:
+            font = ImageFont.truetype("DejaVuSans.ttf", 16)
+        except:
+            font = None
+
+        rows = []
+        for r in results:
+            region = r.get("region") or {}
+            x, y, w, h = region.get("x",0), region.get("y",0), region.get("w",0), region.get("h",0)
+
+            emotions = r.get("emotion", {})
+            if not emotions or w==0 or h==0:
+                continue
+
+            # Sorteer op score (DeepFace geeft percentages 0..100)
+            sorted_items = sorted(emotions.items(), key=lambda kv: kv[1], reverse=True)
+            top_label, top_score = sorted_items[0][0], float(sorted_items[0][1]) / 100.0
+            final_label = top_label if top_score >= float(tau) else "Onzeker"
+
+            rows.append({
+                "bbox": {"x": x, "y": y, "w": w, "h": h},
+                "top1": top_label,
+                "confidence": round(top_score,3),
+                "label": final_label,
+                "top3": [
+                    {"label": l, "conf": round(s/100.0,3)}
+                    for l, s in sorted_items[:3]
+                ]
+            })
+
+            if show_boxes and w>0 and h>0:
+                draw.rectangle([x, y, x+w, y+h], outline=(0,255,0), width=3)
+                txt = f"{final_label} {int(top_score*100)}%"
+                tw, th = draw.textbbox((0,0), txt, font=font)[2:]
+                draw.rectangle([x, y-(th+6), x+tw+8, y], fill=(0,255,0))
+                draw.text((x+4, y-(th+5)), txt, fill=(0,0,0), font=font)
+
+        all_rows.append({
+            "file": f.name,
+            "faces": rows,
+            "note": "Geen gezichten gevonden." if not rows else f"Gezichten: {len(rows)}"
+        })
+        visuals.append(img if not rows else draw.im)
+
+    return visuals, all_rows
+
+with gr.Blocks(title="Simpel & Betrouwbaar: Emotieherkenning") as demo:
+    gr.Markdown("## 😀 Emotieherkenning (serie foto’s)\n"
+                "- **RetinaFace** detectie + alignment\n"
+                "- Emoties: angry, disgust, fear, happy, sad, surprise, neutral\n"
+                "- Drempel voor **'Onzeker'** om fouten te voorkomen\n"
+                "> Let op: dit is een schatting van **gezichtsuitdrukking** (geen gemoedstoestand/intenties).")
     with gr.Row():
         with gr.Column(scale=1):
-            gr.Markdown(HELP_MD)
-            lang = gr.Dropdown(choices=LANGS, value="nl", label="Taal van de uitvoer")
-            consent = gr.Checkbox(
-                label="Ik heb expliciete toestemming van de stem-eigenaar.",
-                value=False
-            )
-            ref = gr.Audio(
-                sources=["microphone", "upload"],
-                type="filepath",
-                label="Referentie-stem (6–20 s, .wav/.mp3)",
-            )
-            text = gr.Textbox(
-                label="Tekst om uit te spreken",
-                placeholder="Typ hier je tekst…",
-                lines=4,
-                value=EXAMPLE_TEXTS[0]
-            )
-
-            with gr.Accordion("Geavanceerd", open=False):
-                speed = gr.Slider(0.5, 1.5, value=1.0, step=0.05, label="Tempo (0.5–1.5×)")
-                pre_ms = gr.Slider(0, 2000, value=0, step=50, label="Pauze vóór (ms)")
-                post_ms = gr.Slider(0, 2000, value=0, step=50, label="Pauze ná (ms)")
-                seed = gr.Number(value=42, precision=0, label="Seed (reproduceerbaarheid)")
-
-            with gr.Row():
-                btn = gr.Button("Genereer", variant="primary")
-                clear = gr.Button("Wissen")
-
+            files = gr.File(label="Upload meerdere foto’s", file_count="multiple", type="filepath")
+            tau = gr.Slider(0.5, 0.9, value=TAU, step=0.01, label="Drempel τ voor 'Onzeker'")
+            show_boxes = gr.Checkbox(True, label="Toon kaders & labels")
+            btn = gr.Button("Analyseer")
         with gr.Column(scale=1):
-            out = gr.Audio(label="Uitvoer", type="filepath")
-            download = gr.DownloadButton(label="Download WAV", value=None)
-            gr.Markdown(
-                "#### Tips\n"
-                "- Beste kwaliteit: een **stille, heldere** referentie-opname.\n"
-                "- Praat natuurlijk; 10–15 seconden werkt meestal prima.\n"
-                "- **Kies de juiste uitvoertaal** voor betere uitspraak.\n"
-                "- Geavanceerd: pas **tempo** en **stilte** aan, gebruik een **seed** om variatie te fixeren.\n"
-            )
+            gallery = gr.Gallery(label="Resultaat (met labels)").style(grid=2, height="auto")
+    out_json = gr.JSON(label="Details (per foto en gezicht)")
 
-    # Wiring
-    btn.click(
-        fn=tts_clone,
-        inputs=[text, ref, lang, consent, speed, pre_ms, post_ms, seed],
-        outputs=[out, download],
-        api_name="clone"
-    )
-    clear.click(lambda: (None, None), outputs=[out, download])
+    btn.click(analyze_batch, [files, tau, show_boxes], [gallery, out_json])
 
 if __name__ == "__main__":
     demo.launch()