Update app.py

app.py

@@ -1,313 +1,322 @@
-import time
 import os
-
 import cv2
-import numpy as np
 import gradio as gr
-import gradio.utils as gr_utils
-from ultralytics import YOLO
-from PIL import Image, ImageDraw, ImageFont
-import arabic_reshaper
-from bidi.algorithm import get_display
-
 import google.generativeai as genai
+from ultralytics import YOLO
+import tempfile
 import torch
 
-# ==========================
-# ⚠️ Gemini API Key
-# ==========================
+# =============================
+# اختيار الجهاز (GPU / CPU)
+# =============================
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+print(f"🚀 Using device: {DEVICE}")
 
-GEMINI_API_KEY = "YOUR_GEMINI_API_KEY_HERE"  # ← حط المفتاح هنا
-genai.configure(api_key=GEMINI_API_KEY)
+# =============================
+# إعداد مفتاح Gemini (مكتوب صريح في الكود)
+# =============================
 
-# ==========================
-# Patch لمشكلة Spaces hot-reload
-# ==========================
+GEMINI_API_KEY = "AIzaSyAvm28ZnTMaZ1Jtg9sYM-EO4qlAN2W4BIQ"
+"
 
-# داخل Hugging Face Spaces، SPACE_ID يكون موجود في الـ env
-if os.getenv("SPACE_ID"):
-    def _no_watchfn_spaces(*args, **kwargs):
-        # نطفي الـ hot-reload اللي يسبب RuntimeError
-        return
-    # نكتب فوق الدالة الأصلية
-    gr_utils.watchfn_spaces = _no_watchfn_spaces
+genai.configure(api_key=GEMINI_API_KEY)
 
-# ==========================
-# إعدادات أداء PyTorch / GPU
-# ==========================
+SYSTEM_PROMPT = (
+    "لدي نص خام عبارة عن حروف عربية متتابعة بدون مسافات "
+    "ومع وجود تكرار بسيط لأنه ناتج من مترجم لغة الإشارة.\n"
+    "مهمتك:\n"
+    "1) إزالة التكرار غير الضروري.\n"
+    "2) إضافة المسافات بين الكلمات.\n"
+    "3) إخراج الجملة الأقرب للمعنى.\n"
+    "أعد النص فقط بدون شرح."
+)
 
-torch.backends.cudnn.benchmark = True  # تسريع الـ conv على GPU
 
-DEVICE = "cuda:0" if torch.cuda.is_available() else "cpu"
-USE_HALF = DEVICE.startswith("cuda")
-print("🔥 Using device:", DEVICE)
+def fix_with_gemini(raw_text: str) -> str:
+    if not raw_text:
+        return ""
+    try:
+        model = genai.GenerativeModel("models/gemini-2.5-flash")
+        prompt = SYSTEM_PROMPT + f"\n\nالنص الخام:\n«{raw_text}»"
+        resp = model.generate_content(prompt)
+        return (resp.text or "").strip()
+    except Exception as e:
+        return f"خطأ في Gemini: {e}"
+
 
-# ==========================
-# إعدادات YOLO + الثوابت
-# ==========================
+# =============================
+# إعدادات YOLO + السرعة
+# =============================
 
 WEIGHTS_PATH = "best.pt"
-IMG_SIZE = 256
-CONF_THRESHOLD = 0.5
+IMG_SIZE = 320
+CONF_THRESHOLD = 0.25  # خفضناها عشان يسوي ديتكشن أسهل
 
-MIN_STABLE_FRAMES = 3
-WARN_BEFORE_RESET = 1.5
-RESET_DELAY = 2.5
+# إعدادات تجميع الحروف
+MIN_STABLE_FRAMES = 1     # اعتبر الحرف من أول مرة للاستكشاف
+FRAME_SKIP = 1            # حلّل كل فريم (مع GPU تقدر تخليه 1)
+MAX_FRAMES = 1000         # حد أقصى للفريمات
+WORD_GAP_FRAMES = 10      # فجوة (بدون حروف) لنهاية الكلمة
 
 arabic_map = {
-    "aleff": "ا", "bb": "ب", "ta": "ت", "thaa": "ث", "jeem": "ج",
-    "haa": "ح", "khaa": "خ", "dal": "د", "thal": "ذ", "ra": "ر",
-    "zay": "ز", "seen": "س", "sheen": "ش", "saad": "ص", "dhad": "ض",
-    "taa": "ط", "dha": "ظ", "ain": "ع", "ghain": "غ", "fa": "ف",
-    "gaaf": "ق", "kaaf": "ك", "laam": "ل", "la": "لا", "meem": "م",
-    "nun": "ن", "ha": "ه", "waw": "و", "ya": "ي", "yaa": "ي",
-    "toot": "ة", "al": "ال"
+    "aleff": "ا",
+    "bb": "ب",
+    "ta": "ت",
+    "taa": "ت",
+    "thaa": "ث",
+    "jeem": "ج",
+    "haa": "ح",
+    "khaa": "خ",
+    "dal": "د",
+    "dha": "ظ",
+    "dhad": "ض",
+    "fa": "ف",
+    "gaaf": "ق",
+    "ghain": "غ",
+    "ha": "ه",
+    "kaaf": "ك",
+    "laam": "ل",
+    "meem": "م",
+    "nun": "ن",
+    "ra": "ر",
+    "saad": "ص",
+    "seen": "س",
+    "sheen": "ش",
+    "thal": "ذ",
+    "toot": "ة",
+    "waw": "و",
+    "ya": "ي",
+    "yaa": "ي",
+    "zay": "ز",
+    "ain": "ع",
+    "al": "ال",
+    "la": "لا",
 }
 
-SYSTEM_PROMPT = (
-    "أنت مساعد ذكي يستقبل كلمات أو جمل قصيرة قادمة من مترجم لغة "
-    "الإشارة العربية، ودورك أن تعيد صياغتها كنص عربي واضح ومفهوم، "
-    "أو تشرح معناها باختصار إذا كانت كلمة واحدة."
-)
+print("🔹 Loading YOLO model...")
+model = YOLO(WEIGHTS_PATH)
 
-# ==========================
-# إعداد خط عربي مرة وحدة
-# ==========================
+# ننقل الموديل إلى كرت الشاشة لو موجود
+try:
+    model.to(DEVICE)
+    print("✅ YOLO model moved to", DEVICE)
+except Exception as e:
+    print("⚠️ تعذر نقل الموديل إلى الجهاز:", e)
 
-DEFAULT_FONT_SIZE = 24
-DEFAULT_FONT_PATH = "NotoNaskhArabic-VariableFont_wght.ttf"
+print("📚 Classes:", model.names)
 
-try:
-    FONT_AR = ImageFont.truetype(DEFAULT_FONT_PATH, DEFAULT_FONT_SIZE)
-except Exception:
-    FONT_AR = ImageFont.load_default()
 
+# =============================
+# ضغط الفيديو قبل المعالجة (دقة 360p تقريباً + تقليل FPS)
+# =============================
+
+def preprocess_video(input_path: str, target_width: int = 640, target_fps: int = 8) -> str:
+    """
+    يقلل دقة الفيديو والـ FPS عشان نخلي البروسيس أسرع.
+    يرجّع مسار فيديو خفيف جديد.
+    """
+    cap = cv2.VideoCapture(input_path)
+    if not cap.isOpened():
+        print("[preprocess] تعذر فتح الفيديو، سنستخدم الملف الأصلي كما هو.")
+        return input_path  # fallback
+
+    orig_fps = cap.get(cv2.CAP_PROP_FPS)
+    w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+
+    if orig_fps <= 0:
+        frame_step = 1
+        out_fps = float(target_fps)
+    else:
+        frame_step = max(1, int(round(orig_fps / target_fps)))
+        out_fps = orig_fps / frame_step
+
+    # ارتفاع النسخة 360p تقريباً حسب نسبة الأبعاد
+    target_height = int(target_width * h / w)
 
-def prepare_arabic(text: str) -> str:
-    reshaped = arabic_reshaper.reshape(text)
-    bidi_text = get_display(reshaped)
-    return bidi_text
+    fd, tmp_path = tempfile.mkstemp(suffix=".mp4")
+    os.close(fd)
 
-# ==========================
-# رسم الديتكشن بشكل سريع
-# ==========================
+    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+    out = cv2.VideoWriter(tmp_path, fourcc, out_fps, (target_width, target_height))
+
+    frame_idx = 0
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        # نأخذ كل frame_step فريم واحد فقط
+        if frame_idx % frame_step == 0:
+            resized = cv2.resize(frame, (target_width, target_height), interpolation=cv2.INTER_AREA)
+            out.write(resized)
+
+        frame_idx += 1
+
+    cap.release()
+    out.release()
+    print(f"[preprocess] original_fps={orig_fps:.2f}, new_fps={out_fps:.2f}, saved={tmp_path}")
+    return tmp_path
+
+
+# =============================
+# معالجة فريم واحد (YOLO على GPU)
+# =============================
+
+def detect_frame(frame_bgr):
+    frame_rgb = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2RGB)
+    result = model.predict(
+        frame_rgb,
+        conf=CONF_THRESHOLD,
+        imgsz=IMG_SIZE,
+        verbose=False,
+        device=DEVICE  # هنا نحدد إنه يشتغل على cuda لو متوفر
+    )[0]
 
-def draw_detections(result, frame, names):
     boxes = result.boxes
-    detected_labels = []
 
     if boxes is None or len(boxes) == 0:
-        return frame, detected_labels
-
-    label_infos = []
+        return [], frame_bgr
 
+    labels = []
     for box in boxes:
         x1, y1, x2, y2 = map(int, box.xyxy[0])
         cls_id = int(box.cls[0])
 
-        if isinstance(names, dict):
-            eng_label = names.get(cls_id, str(cls_id))
+        if isinstance(model.names, dict):
+            eng = model.names.get(cls_id, str(cls_id))
         else:
-            eng_label = names[cls_id] if cls_id < len(names) else str(cls_id)
-
-        ar_label = arabic_map.get(eng_label, eng_label)
-        detected_labels.append(ar_label)
-
-        # box
-        cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
-
-        label_bg_y1 = max(0, y1 - 35)
-        label_bg_y2 = y1
-        cv2.rectangle(
-            frame,
-            (x1, label_bg_y1),
-            (x1 + 140, label_bg_y2),
+            eng = model.names[cls_id] if cls_id < len(model.names) else str(cls_id)
+
+        letter = arabic_map.get(eng, eng)
+        labels.append(letter)
+
+        cv2.rectangle(frame_bgr, (x1, y1), (x2, y2), (0, 255, 0), 2)
+        cv2.putText(
+            frame_bgr,
+            letter,
+            (x1, y1 - 10),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            0.7,
             (0, 255, 0),
-            -1,
+            2,
         )
 
-        label_infos.append(
-            (
-                prepare_arabic(ar_label),
-                x1 + 5,
-                label_bg_y1 + 5,
-            )
-        )
+    return labels, frame_bgr
 
-    img_pil = Image.fromarray(frame)
-    draw = ImageDraw.Draw(img_pil)
 
-    for bidi_text, tx, ty in label_infos:
-        draw.text((tx, ty), bidi_text, font=FONT_AR, fill=(0, 0, 0))
+# =============================
+# VIDEO → RAW TEXT + OUTPUT VIDEO
+# =============================
 
-    return np.array(img_pil), detected_labels
+def extract_and_render(video_path: str):
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        return "", None
 
-# ==========================
-# تحميل YOLO على GPU + half
-# ==========================
+    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+    out_path = "processed_output.mp4"
 
-print("🔹 Loading YOLO model...")
-model = YOLO(WEIGHTS_PATH)
-model.to(DEVICE)
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
 
-if USE_HALF:
-    try:
-        model.model.half()
-        print("⚡ Using half precision for YOLO on GPU")
-    except Exception as e:
-        print("⚠️ Could not enable half precision:", e)
+    if fps <= 0:
+        fps = 8.0  # fallback
 
-print("📚 Classes:", model.names)
+    out = cv2.VideoWriter(out_path, fourcc, fps, (width, height))
 
-# ==========================
-# Gemini API Call
-# ==========================
+    word = ""
+    words = []
+    last_label = None
+    last_added = None
+    stable = 0
+    last_seen = None
+    frame_index = 0
 
-def call_gemini_on_word(word: str) -> str:
-    if not word:
-        return ""
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
 
-    try:
-        model_g = genai.GenerativeModel("gemini-1.5-flash")
+        frame_index += 1
+        if frame_index > MAX_FRAMES:
+            break
 
-        prompt = (
-            SYSTEM_PROMPT
-            + f"\n\nالنص القادم من مترجم لغة الإشارة هو: «{word}».\n"
-            + "اكتب جملة قصيرة أو شرحًا بسيطًا بالعربية اعتمادًا على هذا النص."
-        )
+        if FRAME_SKIP > 1 and frame_index % FRAME_SKIP != 0:
+            continue
 
-        response = model_g.generate_content(prompt)
-        return (response.text or "").strip()
-    except Exception as e:
-        return f"خطأ Gemini: {e}"
-
-# ==========================
-# معالجة الفريم
-# ==========================
-
-def process_frame(
-    frame,
-    current_word="",
-    last_label=None,
-    stable_count=0,
-    last_letter_time=None,
-    chat_history=None,
-):
-    if chat_history is None:
-        chat_history = []
-
-    frame_bgr = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
-    frame_bgr = cv2.flip(frame_bgr, 1)
-
-    results = model.predict(
-        frame_bgr,
-        conf=CONF_THRESHOLD,
-        imgsz=IMG_SIZE,
-        verbose=False,
-        device=DEVICE,
-        half=USE_HALF,
-    )[0]
+        frame = cv2.flip(frame, 1)
+        labels, rendered = detect_frame(frame)
+        out.write(rendered)
 
-    annotated, labels = draw_detections(results, frame_bgr, model.names)
+        if labels:
+            label = labels[0]
+            last_seen = frame_index
 
-    if labels:
-        current_label = labels[0]
-        if current_label == last_label:
-            stable_count += 1
+            if label == last_label:
+                stable += 1
+            else:
+                last_label = label
+                stable = 1
+
+            if stable >= MIN_STABLE_FRAMES:
+                if label != last_added:
+                    word += label
+                    last_added = label
+                stable = 0
         else:
-            last_label = current_label
-            stable_count = 1
+            if word and last_seen and (frame_index - last_seen >= WORD_GAP_FRAMES):
+                words.append(word)
+                word = ""
+                last_label = None
+                last_added = None
+                stable = 0
+                last_seen = None
 
-        if stable_count >= MIN_STABLE_FRAMES:
-            current_word += current_label
-            last_letter_time = time.time()
-            stable_count = 0
+    cap.release()
+    out.release()
 
-    status_text = ""
+    if word:
+        words.append(word)
 
-    if current_word and last_letter_time is not None:
-        elapsed = time.time() - last_letter_time
+    raw_text = " ".join(words).strip()
+    return raw_text, out_path
 
-        if elapsed > RESET_DELAY:
-            final_text = current_word
 
-            chat_history.append(["🖐️ من الإشارات", final_text])
+# =============================
+# Gradio واجهة كاملة
+# =============================
 
-            gpt_reply = call_gemini_on_word(final_text)
+def run(file):
+    if file is None:
+        return "لم يتم رفع فيديو", "", None
 
-            if gpt_reply:
-                chat_history.append(["🤖 المساعد", gpt_reply])
+    video_path = file.name
 
-            current_word = ""
-            last_label = None
-            stable_count = 0
-            last_letter_time = None
+    # خطوة تسريع الفيديو قبل التحليل (360p + ~8fps)
+    light_path = preprocess_video(video_path, target_width=640, target_fps=8)
 
-        elif elapsed > WARN_BEFORE_RESET:
-            status_text = f"الكلمة الحالية: {current_word} (سيتم إنهاؤها قريبًا)"
-        else:
-            status_text = f"الكلمة الحالية: {current_word}"
+    raw, processed_path = extract_and_render(light_path)
+    pretty = fix_with_gemini(raw) if raw else ""
 
-    annotated_rgb = cv2.cvtColor(annotated, cv2.COLOR_BGR2RGB)
+    if not raw:
+        raw = "لم يتم التعرف على أي نص من الإشارات."
 
-    return (
-        annotated_rgb,
-        status_text,
-        current_word,
-        last_label,
-        stable_count,
-        last_letter_time,
-        chat_history,
-        chat_history,
-    )
+    return raw, pretty, processed_path
 
-# ==========================
-# واجهة Gradio
-# ==========================
 
 with gr.Blocks() as demo:
-    gr.Markdown("## ASL → Arabic Chat (YOLO + Gemini)")
-
-    with gr.Row():
-        cam = gr.Image(
-            sources=["webcam"],
-            streaming=True,
-            type="numpy",
-            label="الكاميرا",
-        )
-        video_out = gr.Image(label="النتيجة")
-
-    word_status = gr.Markdown()
-    chatbox = gr.Chatbot(label="الشات (إشارة → نص)")
-
-    state_current_word = gr.State("")
-    state_last_label = gr.State(None)
-    state_stable_count = gr.State(0)
-    state_last_letter_time = gr.State(None)
-    state_chat_history = gr.State([])
-
-    cam.stream(
-        fn=process_frame,
-        inputs=[
-            cam,
-            state_current_word,
-            state_last_label,
-            state_stable_count,
-            state_last_letter_time,
-            state_chat_history,
-        ],
-        outputs=[
-            video_out,
-            word_status,
-            state_current_word,
-            state_last_label,
-            state_stable_count,
-            state_last_letter_time,
-            state_chat_history,
-            chatbox,
-        ],
-    )
-
-# في Spaces ما نحتاج نحدد port غالباً
+    gr.Markdown("## 🤟 ASL → Arabic (YOLO + Gemini) مع إعادة فيديو المعالجة 🎥 — نسخة GPU")
+
+    inp = gr.File(label="ارفع فيديو الإشارة")
+    raw = gr.Textbox(label="النص الخام", lines=3)
+    pretty = gr.Textbox(label="النص المحسن (Gemini)", lines=3)
+    video_out = gr.Video(label="الفيديو بعد البروسيس")
+
+    btn = gr.Button("ابدأ المعالجة")
+
+    btn.click(run, inputs=[inp], outputs=[raw, pretty, video_out])
+
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(server_name="0.0.0.0", server_port=7860)