Update app.py

app.py

@@ -6,20 +6,19 @@ import json
 from datetime import datetime
 import tempfile
 import uuid
+import re
 
 # Install required packages if not already installed
 try:
     import mediapipe as mp
     import cv2
     import numpy as np
-    from googletrans import Translator
 except ImportError:
     print("Installing required packages...")
-    os.system("pip install mediapipe opencv-python numpy googletrans==4.0.0-rc1 --quiet")
+    os.system("pip install mediapipe opencv-python numpy --quiet")
     import mediapipe as mp
     import cv2
     import numpy as np
-    from googletrans import Translator
 
 TITLE = "Multilingual Sign Language Customer Assistant"
 DESCRIPTION = """This app translates English or Arabic text into sign language videos for customer assistance.
@@ -27,18 +26,36 @@ The system automatically detects the input language and generates appropriate si
 
 **Features:**
 - Supports both English and Arabic text
-- Uses SignDict for English sign language vocabulary
-- Uses ArSL for Arabic sign language
+- Uses 3D avatar technology to generate sign language
 - Perfect for customer service and assistance scenarios
 """
 
-# Initialize the translation components
-translator = Translator()
+# Initialize MediaPipe
 mp_hands = mp.solutions.hands
 mp_drawing = mp.solutions.drawing_utils
 mp_drawing_styles = mp.solutions.drawing_styles
 mp_pose = mp.solutions.pose
 
+# Dictionary of translations for common customer service phrases
+TRANSLATIONS = {
+    "hello": "مرحبا",
+    "welcome": "أهلا وسهلا",
+    "thank you": "شكرا",
+    "help": "مساعدة",
+    "yes": "نعم",
+    "no": "لا",
+    "please": "من فضلك",
+    "wait": "انتظر",
+    "sorry": "آسف",
+    "how can i help you": "كيف يمكنني مساعدتك",
+    "customer": "عميل",
+    "service": "خدمة",
+    "support": "دعم",
+    "information": "معلومات",
+    "question": "سؤال",
+    "answer": "إجابة",
+}
+
 # SignDict - dictionary of common signs in both languages
 # In a production app, these would link to pre-recorded videos or 3D animations
 SIGN_DICT = {
@@ -109,6 +126,28 @@ def detect_language(text):
     else:
         return "unknown"
 
+def translate_text(text, source_lang, target_lang):
+    """Simple dictionary-based translation"""
+    if source_lang == target_lang:
+        return text
+    
+    # Convert to lowercase for matching
+    text_lower = text.lower()
+    
+    # For English to Arabic
+    if source_lang == "en" and target_lang == "ar":
+        for eng, ar in TRANSLATIONS.items():
+            text_lower = text_lower.replace(eng, ar)
+        return text_lower
+    
+    # For Arabic to English
+    if source_lang == "ar" and target_lang == "en":
+        for eng, ar in TRANSLATIONS.items():
+            text_lower = text_lower.replace(ar, eng)
+        return text_lower
+    
+    return text  # Return original if no translation path
+
 def tokenize_text(text, language):
     """Split text into tokens that can be matched to signs"""
     if language == "ar":
@@ -150,18 +189,6 @@ def tokenize_text(text, language):
                 i += 1
         return phrases
 
-def translate_if_needed(text, source_lang, target_lang):
-    """Translate text if it's not already in the target language"""
-    if source_lang == target_lang:
-        return text
-    
-    try:
-        translation = translator.translate(text, src=source_lang, dest=target_lang)
-        return translation.text
-    except Exception as e:
-        print(f"Translation error: {str(e)}")
-        return text
-
 def generate_default_sign_video(text, output_path, language="en"):
     """Generate a simple video with the text when no sign is available"""
     # Create a black frame with text
@@ -193,11 +220,8 @@ def generate_default_sign_video(text, output_path, language="en"):
     video.release()
     return output_path
 
-def create_avatar_animation(text, output_path, language="en"):
+def create_avatar_animation(text, output_path, language="en", style="3D"):
     """Create a 3D avatar animation for the sign (simplified version)"""
-    # In a real implementation, this would use a 3D avatar system
-    # Here we'll just simulate it with a basic animation
-    
     width, height = 640, 480
     fps = 30
     duration = 3  # seconds
@@ -209,32 +233,72 @@ def create_avatar_animation(text, output_path, language="en"):
     # Create a simple animation with hands
     frames = fps * duration
     for i in range(frames):
-        # Create a dark blue background
-        frame = np.ones((height, width, 3), dtype=np.uint8) * np.array([100, 60, 20], dtype=np.uint8)
-        
-        # Draw a simple avatar body
-        cv2.rectangle(frame, (width//2-50, height//2-100), (width//2+50, height//2+100), (200, 200, 200), -1)
-        cv2.circle(frame, (width//2, height//2-150), 50, (200, 200, 200), -1)
-        
-        # Animate hands based on frame number
-        t = i / frames
-        # Left hand movement
-        x1 = int(width//2 - 100 - 50 * np.sin(t * 2 * np.pi))
-        y1 = int(height//2 - 50 * np.cos(t * 2 * np.pi))
-        # Right hand movement
-        x2 = int(width//2 + 100 + 50 * np.sin(t * 2 * np.pi))
-        y2 = int(height//2 - 50 * np.cos(t * 2 * np.pi))
+        # Create a background based on style
+        if style == "3D":
+            # Create a gradient background
+            frame = np.zeros((height, width, 3), dtype=np.uint8)
+            for y in range(height):
+                for x in range(width):
+                    frame[y, x] = [
+                        int(100 + 50 * (x / width)),
+                        int(60 + 30 * (y / height)),
+                        int(120 + 40 * ((x+y) / (width+height)))
+                    ]
+        else:
+            # Simple solid background for 2D
+            frame = np.ones((height, width, 3), dtype=np.uint8) * np.array([240, 240, 240], dtype=np.uint8)
         
-        # Draw hands
-        cv2.circle(frame, (x1, y1), 20, (200, 200, 200), -1)
-        cv2.circle(frame, (x2, y2), 20, (200, 200, 200), -1)
+        # Draw a simple avatar
+        if style == "3D":
+            # 3D-style avatar
+            # Body
+            cv2.rectangle(frame, (width//2-50, height//2-100), (width//2+50, height//2+100), (200, 200, 200), -1)
+            # Head
+            cv2.circle(frame, (width//2, height//2-150), 50, (200, 200, 200), -1)
+            
+            # Animate hands based on frame number
+            t = i / frames
+            # Left hand movement
+            x1 = int(width//2 - 100 - 50 * np.sin(t * 2 * np.pi))
+            y1 = int(height//2 - 50 * np.cos(t * 2 * np.pi))
+            # Right hand movement
+            x2 = int(width//2 + 100 + 50 * np.sin(t * 2 * np.pi))
+            y2 = int(height//2 - 50 * np.cos(t * 2 * np.pi))
+            
+            # Draw hands
+            cv2.circle(frame, (x1, y1), 20, (200, 200, 200), -1)
+            cv2.circle(frame, (x2, y2), 20, (200, 200, 200), -1)
+        else:
+            # 2D-style signing
+            # Drawing a simplified 2D signer
+            cv2.line(frame, (width//2, height//2-100), (width//2, height//2+50), (0, 0, 0), 3)  # Body
+            cv2.circle(frame, (width//2, height//2-120), 20, (0, 0, 0), 2)  # Head
+            
+            # Animated hands for signing
+            t = i / frames
+            angle1 = t * 2 * np.pi
+            angle2 = t * 2 * np.pi + np.pi/2
+            
+            # Left arm
+            x1 = int(width//2)
+            y1 = int(height//2 - 70)
+            x2 = int(x1 - 60 * np.cos(angle1))
+            y2 = int(y1 + 60 * np.sin(angle1))
+            cv2.line(frame, (x1, y1), (x2, y2), (0, 0, 0), 2)
+            
+            # Right arm
+            x3 = int(width//2)
+            y3 = int(height//2 - 70)
+            x4 = int(x3 + 60 * np.cos(angle2))
+            y4 = int(y3 + 60 * np.sin(angle2))
+            cv2.line(frame, (x3, y3), (x4, y4), (0, 0, 0), 2)
         
         # Add text with current sign
         font = cv2.FONT_HERSHEY_SIMPLEX
-        cv2.putText(frame, text, (width//2-100, height-50), font, 1, (255, 255, 255), 2)
+        cv2.putText(frame, text, (width//2-100, height-50), font, 1, (0, 0, 0), 2)
         if language == "ar":
             # Right-to-left indicator
-            cv2.putText(frame, "RTL", (width-70, 30), font, 0.7, (255, 255, 255), 1)
+            cv2.putText(frame, "RTL", (width-70, 30), font, 0.7, (0, 0, 0), 1)
         
         video.write(frame)
     
@@ -249,13 +313,16 @@ def generate_sign_video(tokens, language, output_format="3D"):
     
     # In a real implementation, this would concatenate actual sign videos
     # For this demo, we'll create a simple animation
-    if language in SIGN_DICT and tokens[0] in SIGN_DICT[language]:
+    if language in SIGN_DICT and tokens and tokens[0] in SIGN_DICT[language]:
         # In a real implementation, this would load the video file
         # For demo purposes, we'll create an animation
-        create_avatar_animation(tokens[0], output_path, language)
+        create_avatar_animation(tokens[0], output_path, language, output_format)
     else:
         # Generate a default video with text
-        generate_default_sign_video(tokens[0], output_path, language)
+        if tokens:
+            create_avatar_animation(tokens[0], output_path, language, output_format)
+        else:
+            create_avatar_animation("No tokens", output_path, language, output_format)
     
     return output_path
 
@@ -330,16 +397,16 @@ with gr.Blocks(title=TITLE) as demo:
     # Examples in both languages
     gr.Examples(
         examples=[
-            ["Hello, how can I help you today?"],
-            ["Please wait while I check your account."],
-            ["Thank you for your patience."],
-            ["مرحبا، كيف يمكنني مساعدتك اليوم؟"],
-            ["من فضلك انتظر بينما أتحقق من حسابك."],
-            ["شكرا لصبرك."]
+            ["Hello, how can I help you today?", "3D"],
+            ["Please wait while I check your account.", "3D"],
+            ["Thank you for your patience.", "3D"],
+            ["مرحبا�� كيف يمكنني مساعدتك اليوم؟", "3D"],
+            ["من فضلك انتظر بينما أتحقق من حسابك.", "3D"],
+            ["شكرا لصبرك.", "3D"]
         ],
-        inputs=[text_input],
+        inputs=[text_input, format_dropdown],
         outputs=[video_output, status_output],
-        fn=lambda text: translate_to_sign(text)
+        fn=translate_to_sign
     )
     
     # Event handlers
@@ -357,4 +424,4 @@ with gr.Blocks(title=TITLE) as demo:
 
 # Launch the app
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()