Upgrade Art Reels: AI stick figure with TTS, remove Bangla, use openai/gpt-oss-120b model

modules/art_reels/router.py

@@ -131,35 +131,102 @@ async def generate_drawing_video(job_id: str, subject: str, style: str, colors:
 
 
 async def generate_stick_figure_video(job_id: str, script: str, voice: str):
-    """Background task to generate stick figure motivation video"""
+    """Background task to generate stick figure motivation video with TTS"""
     temp_dir = f"temp/art_{job_id}"
+    os.makedirs(temp_dir, exist_ok=True)
     
     try:
+        update_job(job_id, "processing", 5)
+        logger.info(f"Starting stick figure video with TTS for job {job_id}")
+        
+        # Import TTS, Whisper, and AI Stick Figure
+        from ..story_reels.services.srt_parser import SRTParser
+        from .services.ai_stick_figure import AIStickFigure
+        
+        # Get TTS client from app
+        import sys
+        app_module = sys.modules.get('app')
+        tts_client = getattr(app_module, 'tts_client', None) if app_module else None
+        whisper_client = getattr(app_module, 'whisper_client', None) if app_module else None
+        
+        if not tts_client or not whisper_client:
+            # Fallback: try to get from story_reels module
+            try:
+                from modules.story_reels import get_clients
+                tts_client, whisper_client = get_clients()
+            except:
+                raise Exception("TTS and Whisper clients not available")
+        
         update_job(job_id, "processing", 10)
         
-        # Parse script into scenes (simple keyword matching)
-        scenes = parse_script_to_scenes(script)
+        # Step 1: Generate TTS audio from script
+        logger.info(f"Generating TTS audio for job {job_id}")
+        audio_path = os.path.join(temp_dir, "voice.mp3")
+        await asyncio.to_thread(
+            tts_client.generate,
+            text=script,
+            voice=voice,
+            output_path=audio_path
+        )
+        
+        if not os.path.exists(audio_path):
+            raise Exception("TTS audio generation failed")
         
         update_job(job_id, "processing", 30)
         
-        # Generate frames
+        # Step 2: Get timestamps with Whisper
+        logger.info(f"Transcribing audio for job {job_id}")
+        captions = await asyncio.to_thread(whisper_client.transcribe, audio_path)
+        
+        # Step 3: Create 2-second chunks
+        from moviepy.editor import AudioFileClip
+        audio_clip = AudioFileClip(audio_path)
+        audio_duration = audio_clip.duration
+        audio_clip.close()
+        
+        srt_parser = SRTParser()
+        chunks = srt_parser.create_2s_chunks(captions, audio_duration)
+        
+        logger.info(f"Created {len(chunks)} 2-second chunks for job {job_id}")
+        
+        update_job(job_id, "processing", 45)
+        
+        # Step 4: Generate scenes with AI
+        ai_stick = AIStickFigure()
+        scenes = ai_stick.generate_scenes_with_ai(chunks)
+        
+        # Calculate durations for each chunk
+        chunk_durations = []
+        for i, chunk in enumerate(chunks):
+            if i < len(chunks) - 1:
+                duration = chunks[i + 1].get("start_time", 2.0) - chunk.get("start_time", 0)
+            else:
+                duration = audio_duration - chunk.get("start_time", 0)
+            chunk_durations.append(max(0.5, duration))
+        
+        update_job(job_id, "processing", 60)
+        
+        # Step 5: Generate frames
         logger.info(f"Generating stick figure frames for job {job_id}")
-        frame_paths = stick_figure.generate_motivation_frames(
+        frame_paths = ai_stick.generate_frames_from_scenes(
             scenes=scenes,
-            output_dir=temp_dir
+            chunk_durations=chunk_durations,
+            output_dir=temp_dir,
+            fps=30
         )
         
-        update_job(job_id, "processing", 60)
+        update_job(job_id, "processing", 80)
         
-        # Compose video
-        logger.info(f"Composing video for job {job_id}")
+        # Step 6: Compose video with audio
+        logger.info(f"Composing video with audio for job {job_id}")
         video_path = video_composer.compose_video(
             frame_paths=frame_paths,
+            audio_path=audio_path,
             output_name=f"stick_{job_id}.mp4",
             fps=30
         )
         
-        update_job(job_id, "processing", 90)
+        update_job(job_id, "processing", 95)
         
         # Cleanup
         video_composer.cleanup_frames(frame_paths)
@@ -167,10 +234,12 @@ async def generate_stick_figure_video(job_id: str, script: str, voice: str):
             shutil.rmtree(temp_dir)
         
         update_job(job_id, "ready", 100, video_url=f"/api/art/video/{job_id}")
-        logger.info(f"Stick figure video ready: {job_id}")
+        logger.info(f"Stick figure video with TTS ready: {job_id}")
         
     except Exception as e:
         logger.error(f"Error generating stick figure video: {e}")
+        import traceback
+        logger.error(traceback.format_exc())
         update_job(job_id, "failed", error=str(e))
 
 

modules/art_reels/services/ai_stick_figure.py

@@ -0,0 +1,663 @@
+"""
+AI Stick Figure Generator - AI-Powered Stick Figure Animation with TTS
+Uses Groq AI for scene generation, Kokoro TTS for voice, Whisper for timing
+"""
+import logging
+import os
+import json
+import math
+from PIL import Image, ImageDraw, ImageFont
+from typing import List, Tuple, Dict, Optional
+from groq import Groq
+
+logger = logging.getLogger(__name__)
+
+
+# System prompt for AI scene generation
+SCENE_GENERATION_PROMPT = """You are an AI that converts text into stick figure animation scenes.
+
+For each 2-second chunk of narration, generate a scene description.
+
+OUTPUT FORMAT (JSON array):
+[
+  {
+    "chunk_id": 0,
+    "pose": "standing|walking|running|sitting|sleeping|waving|thinking|jumping|celebrating",
+    "props": ["crown", "money", "book", "phone", "laptop", "coffee", "bed"],
+    "text_overlay": null or "important quote here",
+    "emotion": "happy|sad|thinking|excited|tired|angry",
+    "action": "brief action description"
+  }
+]
+
+RULES:
+1. Match the pose and props to the MEANING of the text
+2. Use text_overlay ONLY for important quotes or key phrases
+3. Be creative with emotions and actions
+4. Keep it simple - stick figures should be expressive but minimal
+
+EXAMPLES:
+- "A rich businessman" → pose: "standing", props: ["money", "suit"], emotion: "happy"
+- "He woke up from sleep" → pose: "sleeping", props: ["bed"], emotion: "tired"
+- "Get ready for success" → pose: "celebrating", props: [], text_overlay: "GET READY!"
+- "Walk like a king" → pose: "walking", props: ["crown"], emotion: "happy"
+"""
+
+
+class AIStickFigure:
+    """
+    AI-Powered Stick Figure Animation Generator.
+    
+    Pipeline:
+    1. Text → TTS → Audio
+    2. Audio → Whisper → 2-second chunks
+    3. Chunks → Groq AI → Scene descriptions
+    4. Scenes → Python Drawing → Frames
+    5. Frames + Audio → Video
+    """
+    
+    # Video dimensions (9:16 portrait)
+    WIDTH = 1080
+    HEIGHT = 1920
+    
+    # Stick figure size
+    HEAD_RADIUS = 50
+    BODY_LENGTH = 150
+    ARM_LENGTH = 100
+    LEG_LENGTH = 120
+    LINE_WIDTH = 10
+    
+    # Colors
+    BG_COLOR = (255, 255, 255)  # White
+    FIGURE_COLOR = (30, 30, 30)  # Near black
+    ACCENT_COLOR = (255, 87, 51)  # Orange accent
+    
+    def __init__(self, groq_api_key: str = None):
+        self.groq_api_key = groq_api_key or os.environ.get("GROQ_API_KEY")
+        if self.groq_api_key:
+            self.groq = Groq(api_key=self.groq_api_key)
+        else:
+            self.groq = None
+            logger.warning("Groq API key not found - AI scene generation disabled")
+    
+    def generate_scenes_with_ai(self, chunks: List[Dict]) -> List[Dict]:
+        """
+        Use Groq AI to generate scene descriptions from text chunks.
+        
+        Args:
+            chunks: List of {chunk_id, text} from Whisper
+            
+        Returns:
+            List of scene descriptions with pose, props, etc.
+        """
+        if not self.groq:
+            # Fallback to keyword-based generation
+            return self._generate_scenes_keyword(chunks)
+        
+        try:
+            # Prepare user prompt
+            chunk_texts = "\n".join([
+                f"Chunk {c['chunk_id']}: \"{c['text']}\""
+                for c in chunks
+            ])
+            
+            user_prompt = f"""Generate stick figure scenes for these narration chunks:
+
+{chunk_texts}
+
+Generate exactly {len(chunks)} scenes, one for each chunk.
+Return ONLY valid JSON array, no other text."""
+
+            response = self.groq.chat.completions.create(
+                model="openai/gpt-oss-120b",
+                messages=[
+                    {"role": "system", "content": SCENE_GENERATION_PROMPT},
+                    {"role": "user", "content": user_prompt}
+                ],
+                temperature=0.7,
+                max_tokens=2000
+            )
+            
+            content = response.choices[0].message.content.strip()
+            
+            # Parse JSON
+            if content.startswith("```"):
+                content = content.split("```")[1]
+                if content.startswith("json"):
+                    content = content[4:]
+            
+            scenes = json.loads(content)
+            logger.info(f"AI generated {len(scenes)} scenes")
+            return scenes
+            
+        except Exception as e:
+            logger.error(f"AI scene generation failed: {e}, using keyword fallback")
+            return self._generate_scenes_keyword(chunks)
+    
+    def _generate_scenes_keyword(self, chunks: List[Dict]) -> List[Dict]:
+        """Fallback keyword-based scene generation"""
+        scenes = []
+        
+        keyword_mapping = {
+            # Poses
+            "sleep": ("sleeping", [], "tired"),
+            "wake": ("sleeping", [], "tired"),
+            "run": ("running", [], "excited"),
+            "running": ("running", [], "excited"),
+            "walk": ("walking", [], "happy"),
+            "walking": ("walking", [], "happy"),
+            "sit": ("sitting", [], "thinking"),
+            "sitting": ("sitting", [], "thinking"),
+            "think": ("thinking", [], "thinking"),
+            "thinking": ("thinking", [], "thinking"),
+            "jump": ("jumping", [], "excited"),
+            "celebrate": ("celebrating", [], "happy"),
+            "success": ("celebrating", [], "excited"),
+            # Props
+            "king": ("standing", ["crown"], "happy"),
+            "queen": ("standing", ["crown"], "happy"),
+            "rich": ("standing", ["money"], "happy"),
+            "wealthy": ("standing", ["money"], "happy"),
+            "money": ("standing", ["money"], "happy"),
+            "dollar": ("standing", ["money"], "happy"),
+            "book": ("sitting", ["book"], "thinking"),
+            "read": ("sitting", ["book"], "thinking"),
+            "phone": ("standing", ["phone"], "happy"),
+            "coffee": ("standing", ["coffee"], "happy"),
+        }
+        
+        for chunk in chunks:
+            text = chunk.get("text", "").lower()
+            pose = "standing"
+            props = []
+            emotion = "happy"
+            text_overlay = None
+            
+            for keyword, (p, pr, em) in keyword_mapping.items():
+                if keyword in text:
+                    pose = p
+                    props = pr
+                    emotion = em
+                    break
+            
+            # Check for text overlay triggers
+            triggers = ["get ready", "remember", "important", "key", "ready", "success"]
+            for trigger in triggers:
+                if trigger in text:
+                    text_overlay = text[:30].upper() if len(text) > 30 else text.upper()
+                    break
+            
+            scenes.append({
+                "chunk_id": chunk.get("chunk_id", 0),
+                "pose": pose,
+                "props": props,
+                "emotion": emotion,
+                "text_overlay": text_overlay,
+                "action": f"Scene for: {text[:50]}"
+            })
+        
+        return scenes
+    
+    def draw_stick_figure(
+        self,
+        draw: ImageDraw,
+        x: int,
+        y: int,
+        pose: str = "standing",
+        emotion: str = "happy",
+        props: List[str] = None,
+        scale: float = 1.0
+    ):
+        """Draw an expressive stick figure"""
+        props = props or []
+        
+        # Scale dimensions
+        head_r = int(self.HEAD_RADIUS * scale)
+        body_len = int(self.BODY_LENGTH * scale)
+        arm_len = int(self.ARM_LENGTH * scale)
+        leg_len = int(self.LEG_LENGTH * scale)
+        line_w = max(4, int(self.LINE_WIDTH * scale))
+        
+        # Pose-specific drawing
+        pose_methods = {
+            "standing": self._draw_standing,
+            "walking": self._draw_walking,
+            "running": self._draw_running,
+            "sitting": self._draw_sitting,
+            "sleeping": self._draw_sleeping,
+            "waving": self._draw_waving,
+            "thinking": self._draw_thinking,
+            "jumping": self._draw_jumping,
+            "celebrating": self._draw_celebrating,
+        }
+        
+        draw_method = pose_methods.get(pose, self._draw_standing)
+        draw_method(draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion)
+        
+        # Draw props
+        for prop in props:
+            self._draw_prop(draw, x, y - body_len - head_r, head_r, prop, scale)
+    
+    def _draw_face(self, draw, x, y, head_r, emotion, line_w):
+        """Draw expressive face"""
+        # Eyes
+        eye_y = y - head_r // 4
+        eye_offset = head_r // 3
+        eye_size = head_r // 5
+        
+        if emotion == "happy":
+            # Happy eyes (curved)
+            draw.arc([x - eye_offset - eye_size, eye_y - eye_size, 
+                     x - eye_offset + eye_size, eye_y + eye_size],
+                    0, 180, fill=self.FIGURE_COLOR, width=line_w//2)
+            draw.arc([x + eye_offset - eye_size, eye_y - eye_size, 
+                     x + eye_offset + eye_size, eye_y + eye_size],
+                    0, 180, fill=self.FIGURE_COLOR, width=line_w//2)
+            # Smile
+            draw.arc([x - head_r//2, y - head_r//4, x + head_r//2, y + head_r//2],
+                    0, 180, fill=self.FIGURE_COLOR, width=line_w//2)
+        elif emotion == "sad":
+            # Sad eyes
+            draw.ellipse([x - eye_offset - eye_size, eye_y - eye_size,
+                         x - eye_offset + eye_size, eye_y + eye_size],
+                        fill=self.FIGURE_COLOR)
+            draw.ellipse([x + eye_offset - eye_size, eye_y - eye_size,
+                         x + eye_offset + eye_size, eye_y + eye_size],
+                        fill=self.FIGURE_COLOR)
+            # Frown
+            draw.arc([x - head_r//2, y, x + head_r//2, y + head_r//2],
+                    180, 360, fill=self.FIGURE_COLOR, width=line_w//2)
+        elif emotion == "thinking":
+            # Thinking eyes (looking up)
+            draw.ellipse([x - eye_offset - eye_size, eye_y - eye_size - 5,
+                         x - eye_offset + eye_size, eye_y + eye_size - 5],
+                        fill=self.FIGURE_COLOR)
+            draw.ellipse([x + eye_offset - eye_size, eye_y - eye_size - 5,
+                         x + eye_offset + eye_size, eye_y + eye_size - 5],
+                        fill=self.FIGURE_COLOR)
+            # Neutral mouth
+            draw.line([x - head_r//3, y + head_r//4, x + head_r//3, y + head_r//4],
+                     fill=self.FIGURE_COLOR, width=line_w//2)
+        elif emotion == "excited":
+            # Big excited eyes
+            big_eye = eye_size * 2
+            draw.ellipse([x - eye_offset - big_eye, eye_y - big_eye,
+                         x - eye_offset + big_eye, eye_y + big_eye],
+                        fill=self.FIGURE_COLOR)
+            draw.ellipse([x + eye_offset - big_eye, eye_y - big_eye,
+                         x + eye_offset + big_eye, eye_y + big_eye],
+                        fill=self.FIGURE_COLOR)
+            # Big smile
+            draw.arc([x - head_r//2, y - head_r//3, x + head_r//2, y + head_r//2],
+                    0, 180, fill=self.FIGURE_COLOR, width=line_w)
+        else:
+            # Default neutral
+            draw.ellipse([x - eye_offset - eye_size, eye_y - eye_size,
+                         x - eye_offset + eye_size, eye_y + eye_size],
+                        fill=self.FIGURE_COLOR)
+            draw.ellipse([x + eye_offset - eye_size, eye_y - eye_size,
+                         x + eye_offset + eye_size, eye_y + eye_size],
+                        fill=self.FIGURE_COLOR)
+            draw.line([x - head_r//3, y + head_r//4, x + head_r//3, y + head_r//4],
+                     fill=self.FIGURE_COLOR, width=line_w//2)
+    
+    def _draw_standing(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
+        """Draw standing pose with expression"""
+        head_y = y - body_len - head_r
+        
+        # Head circle
+        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r],
+                    outline=self.FIGURE_COLOR, width=line_w)
+        self._draw_face(draw, x, head_y, head_r, emotion, line_w)
+        
+        # Body
+        body_top = head_y + head_r
+        body_bottom = body_top + body_len
+        draw.line([x, body_top, x, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
+        
+        # Arms
+        arm_y = body_top + body_len // 4
+        draw.line([x, arm_y, x - arm_len, arm_y + arm_len//3], fill=self.FIGURE_COLOR, width=line_w)
+        draw.line([x, arm_y, x + arm_len, arm_y + arm_len//3], fill=self.FIGURE_COLOR, width=line_w)
+        
+        # Legs
+        draw.line([x, body_bottom, x - leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
+        draw.line([x, body_bottom, x + leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
+    
+    def _draw_walking(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
+        """Draw walking pose"""
+        head_y = y - body_len - head_r
+        
+        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r],
+                    outline=self.FIGURE_COLOR, width=line_w)
+        self._draw_face(draw, x, head_y, head_r, emotion, line_w)
+        
+        body_top = head_y + head_r
+        body_bottom = body_top + body_len
+        draw.line([x, body_top, x + 10, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
+        
+        arm_y = body_top + body_len // 4
+        draw.line([x, arm_y, x - arm_len//2, arm_y + arm_len], fill=self.FIGURE_COLOR, width=line_w)
+        draw.line([x, arm_y, x + arm_len, arm_y - arm_len//3], fill=self.FIGURE_COLOR, width=line_w)
+        
+        draw.line([x + 10, body_bottom, x - leg_len, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
+        draw.line([x + 10, body_bottom, x + leg_len, body_bottom + leg_len//2], fill=self.FIGURE_COLOR, width=line_w)
+    
+    def _draw_running(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
+        """Draw running pose"""
+        head_y = y - body_len - head_r
+        
+        draw.ellipse([x + 20 - head_r, head_y - head_r, x + 20 + head_r, head_y + head_r],
+                    outline=self.FIGURE_COLOR, width=line_w)
+        self._draw_face(draw, x + 20, head_y, head_r, "excited", line_w)
+        
+        body_top = head_y + head_r
+        body_bottom = body_top + body_len
+        draw.line([x + 20, body_top, x + 40, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
+        
+        arm_y = body_top + body_len // 4 + 20
+        draw.line([x + 20, arm_y, x - arm_len, arm_y + arm_len//3], fill=self.FIGURE_COLOR, width=line_w)
+        draw.line([x + 20, arm_y, x + arm_len + 30, arm_y - arm_len//2], fill=self.FIGURE_COLOR, width=line_w)
+        
+        draw.line([x + 40, body_bottom, x - leg_len - 20, body_bottom + leg_len//2], fill=self.FIGURE_COLOR, width=line_w)
+        draw.line([x + 40, body_bottom, x + leg_len + 40, body_bottom + leg_len//3], fill=self.FIGURE_COLOR, width=line_w)
+    
+    def _draw_sitting(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
+        """Draw sitting pose"""
+        y_offset = leg_len // 2
+        head_y = y - body_len - head_r + y_offset
+        
+        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r],
+                    outline=self.FIGURE_COLOR, width=line_w)
+        self._draw_face(draw, x, head_y, head_r, emotion, line_w)
+        
+        body_top = head_y + head_r
+        body_bottom = body_top + body_len // 2
+        draw.line([x, body_top, x, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
+        
+        arm_y = body_top + body_len // 6
+        draw.line([x, arm_y, x - arm_len // 2, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
+        draw.line([x, arm_y, x + arm_len // 2, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
+        
+        # Chair/ground
+        draw.line([x - leg_len, body_bottom, x + leg_len, body_bottom], fill=self.FIGURE_COLOR, width=line_w//2)
+        draw.line([x, body_bottom, x - leg_len//2, body_bottom + leg_len//2], fill=self.FIGURE_COLOR, width=line_w)
+        draw.line([x, body_bottom, x + leg_len//2, body_bottom + leg_len//2], fill=self.FIGURE_COLOR, width=line_w)
+    
+    def _draw_sleeping(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
+        """Draw horizontal sleeping pose"""
+        # Horizontal figure
+        draw.ellipse([x - body_len - head_r, y - head_r, x - body_len + head_r, y + head_r],
+                    outline=self.FIGURE_COLOR, width=line_w)
+        
+        # Closed eyes (lines)
+        draw.line([x - body_len - head_r//2, y - head_r//4, x - body_len - head_r//4, y - head_r//4],
+                 fill=self.FIGURE_COLOR, width=line_w//2)
+        draw.line([x - body_len + head_r//4, y - head_r//4, x - body_len + head_r//2, y - head_r//4],
+                 fill=self.FIGURE_COLOR, width=line_w//2)
+        
+        # Body
+        draw.line([x - body_len + head_r, y, x, y], fill=self.FIGURE_COLOR, width=line_w)
+        
+        # Legs
+        draw.line([x, y, x + leg_len, y + 10], fill=self.FIGURE_COLOR, width=line_w)
+        draw.line([x, y, x + leg_len, y - 10], fill=self.FIGURE_COLOR, width=line_w)
+        
+        # Zzz
+        try:
+            font = ImageFont.truetype("arial.ttf", 40)
+        except:
+            font = ImageFont.load_default()
+        draw.text((x - body_len, y - head_r - 50), "Zzz", fill=(100, 100, 100), font=font)
+        
+        # Bed
+        draw.rectangle([x - body_len - head_r - 20, y + head_r, x + leg_len + 20, y + head_r + 20],
+                      fill=(139, 90, 43))
+    
+    def _draw_waving(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
+        """Draw waving pose"""
+        head_y = y - body_len - head_r
+        
+        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r],
+                    outline=self.FIGURE_COLOR, width=line_w)
+        self._draw_face(draw, x, head_y, head_r, "happy", line_w)
+        
+        body_top = head_y + head_r
+        body_bottom = body_top + body_len
+        draw.line([x, body_top, x, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
+        
+        arm_y = body_top + body_len // 4
+        draw.line([x, arm_y, x - arm_len, arm_y + arm_len//2], fill=self.FIGURE_COLOR, width=line_w)
+        # Waving arm up
+        draw.line([x, arm_y, x + arm_len//2, arm_y - arm_len], fill=self.FIGURE_COLOR, width=line_w)
+        # Hand wave lines
+        draw.line([x + arm_len//2 - 10, arm_y - arm_len - 30, x + arm_len//2 + 10, arm_y - arm_len - 20],
+                 fill=self.ACCENT_COLOR, width=3)
+        draw.line([x + arm_len//2 + 15, arm_y - arm_len - 25, x + arm_len//2 + 35, arm_y - arm_len - 15],
+                 fill=self.ACCENT_COLOR, width=3)
+        
+        draw.line([x, body_bottom, x - leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
+        draw.line([x, body_bottom, x + leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
+    
+    def _draw_thinking(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
+        """Draw thinking pose with thought bubble"""
+        head_y = y - body_len - head_r
+        
+        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r],
+                    outline=self.FIGURE_COLOR, width=line_w)
+        self._draw_face(draw, x, head_y, head_r, "thinking", line_w)
+        
+        body_top = head_y + head_r
+        body_bottom = body_top + body_len
+        draw.line([x, body_top, x, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
+        
+        arm_y = body_top + body_len // 4
+        draw.line([x, arm_y, x - arm_len, arm_y + arm_len//2], fill=self.FIGURE_COLOR, width=line_w)
+        # Hand on chin
+        draw.line([x, arm_y, x + arm_len//3, arm_y - arm_len//3], fill=self.FIGURE_COLOR, width=line_w)
+        draw.line([x + arm_len//3, arm_y - arm_len//3, x + head_r//2, head_y + head_r],
+                 fill=self.FIGURE_COLOR, width=line_w)
+        
+        draw.line([x, body_bottom, x - leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
+        draw.line([x, body_bottom, x + leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
+        
+        # Thought bubble
+        draw.ellipse([x + head_r + 30, head_y - head_r - 100, x + head_r + 150, head_y - head_r - 20],
+                    outline=self.FIGURE_COLOR, width=3)
+        draw.ellipse([x + head_r + 10, head_y - head_r - 20, x + head_r + 30, head_y - head_r],
+                    fill=self.FIGURE_COLOR)
+    
+    def _draw_jumping(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
+        """Draw jumping pose"""
+        y_offset = -80  # Jump up
+        head_y = y - body_len - head_r + y_offset
+        
+        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r],
+                    outline=self.FIGURE_COLOR, width=line_w)
+        self._draw_face(draw, x, head_y, head_r, "excited", line_w)
+        
+        body_top = head_y + head_r
+        body_bottom = body_top + body_len
+        draw.line([x, body_top, x, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
+        
+        # Arms up
+        arm_y = body_top + body_len // 4
+        draw.line([x, arm_y, x - arm_len, arm_y - arm_len//2], fill=self.FIGURE_COLOR, width=line_w)
+        draw.line([x, arm_y, x + arm_len, arm_y - arm_len//2], fill=self.FIGURE_COLOR, width=line_w)
+        
+        # Legs spread
+        draw.line([x, body_bottom, x - leg_len, body_bottom + leg_len//2], fill=self.FIGURE_COLOR, width=line_w)
+        draw.line([x, body_bottom, x + leg_len, body_bottom + leg_len//2], fill=self.FIGURE_COLOR, width=line_w)
+        
+        # Jump lines
+        draw.line([x - 30, body_bottom + leg_len + 30, x + 30, body_bottom + leg_len + 30],
+                 fill=(200, 200, 200), width=4)
+    
+    def _draw_celebrating(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
+        """Draw celebrating pose with confetti"""
+        head_y = y - body_len - head_r
+        
+        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r],
+                    outline=self.FIGURE_COLOR, width=line_w)
+        self._draw_face(draw, x, head_y, head_r, "excited", line_w)
+        
+        body_top = head_y + head_r
+        body_bottom = body_top + body_len
+        draw.line([x, body_top, x, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
+        
+        # Both arms up
+        arm_y = body_top + body_len // 4
+        draw.line([x, arm_y, x - arm_len, arm_y - arm_len], fill=self.FIGURE_COLOR, width=line_w)
+        draw.line([x, arm_y, x + arm_len, arm_y - arm_len], fill=self.FIGURE_COLOR, width=line_w)
+        
+        draw.line([x, body_bottom, x - leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
+        draw.line([x, body_bottom, x + leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
+        
+        # Confetti
+        import random
+        colors = [(255, 87, 51), (255, 195, 0), (76, 175, 80), (33, 150, 243)]
+        for _ in range(10):
+            cx = x + random.randint(-150, 150)
+            cy = head_y + random.randint(-150, 50)
+            color = random.choice(colors)
+            draw.ellipse([cx - 5, cy - 5, cx + 5, cy + 5], fill=color)
+    
+    def _draw_prop(self, draw, x, head_y, head_r, prop: str, scale: float):
+        """Draw props on the figure"""
+        if prop == "crown":
+            crown_y = head_y - head_r - 20
+            points = [
+                (x - 40, crown_y),
+                (x - 25, crown_y - 40),
+                (x, crown_y - 20),
+                (x + 25, crown_y - 40),
+                (x + 40, crown_y)
+            ]
+            draw.polygon(points, fill=(255, 215, 0), outline=(200, 170, 0), width=2)
+        elif prop == "money":
+            bag_x = x + 100
+            bag_y = head_y + 150
+            draw.ellipse([bag_x, bag_y, bag_x + 60, bag_y + 70], fill=(34, 139, 34), outline=(20, 100, 20), width=2)
+            try:
+                font = ImageFont.truetype("arial.ttf", 30)
+            except:
+                font = ImageFont.load_default()
+            draw.text((bag_x + 20, bag_y + 20), "$", fill=(255, 255, 255), font=font)
+        elif prop == "book":
+            book_x = x + 80
+            book_y = head_y + 130
+            draw.rectangle([book_x, book_y, book_x + 50, book_y + 70], fill=(139, 69, 19), outline=(100, 50, 10), width=2)
+            draw.line([book_x + 25, book_y, book_x + 25, book_y + 70], fill=(80, 40, 10), width=2)
+        elif prop == "phone":
+            phone_x = x + 90
+            phone_y = head_y + 100
+            draw.rectangle([phone_x, phone_y, phone_x + 30, phone_y + 50], fill=(50, 50, 50), outline=(30, 30, 30), width=2)
+            draw.rectangle([phone_x + 3, phone_y + 5, phone_x + 27, phone_y + 40], fill=(100, 150, 200))
+        elif prop == "coffee":
+            cup_x = x + 100
+            cup_y = head_y + 120
+            draw.rectangle([cup_x, cup_y, cup_x + 40, cup_y + 50], fill=(255, 255, 255), outline=(200, 200, 200), width=2)
+            draw.arc([cup_x + 30, cup_y + 10, cup_x + 50, cup_y + 40], -90, 90, fill=(200, 200, 200), width=3)
+            # Steam
+            draw.arc([cup_x + 10, cup_y - 20, cup_x + 20, cup_y], 0, 180, fill=(200, 200, 200), width=2)
+            draw.arc([cup_x + 20, cup_y - 25, cup_x + 30, cup_y - 5], 180, 360, fill=(200, 200, 200), width=2)
+    
+    def add_text_overlay(
+        self,
+        img: Image.Image,
+        text: str,
+        position: str = "bottom"
+    ) -> Image.Image:
+        """Add stylish text overlay"""
+        draw = ImageDraw.Draw(img)
+        
+        try:
+            font = ImageFont.truetype("arial.ttf", 70)
+        except:
+            font = ImageFont.load_default()
+        
+        bbox = draw.textbbox((0, 0), text, font=font)
+        text_width = bbox[2] - bbox[0]
+        text_height = bbox[3] - bbox[1]
+        
+        if position == "center":
+            pos = ((self.WIDTH - text_width) // 2, (self.HEIGHT - text_height) // 2)
+        elif position == "top":
+            pos = ((self.WIDTH - text_width) // 2, 150)
+        else:  # bottom
+            pos = ((self.WIDTH - text_width) // 2, self.HEIGHT - 200)
+        
+        # Background box
+        padding = 20
+        draw.rectangle([
+            pos[0] - padding, pos[1] - padding,
+            pos[0] + text_width + padding, pos[1] + text_height + padding
+        ], fill=(0, 0, 0, 180))
+        
+        # Text
+        draw.text(pos, text, fill=(255, 255, 255), font=font,
+                 stroke_width=2, stroke_fill=(0, 0, 0))
+        
+        return img
+    
+    def create_scene_frame(self, scene: Dict) -> Image.Image:
+        """Create a single frame from scene description"""
+        img = Image.new('RGB', (self.WIDTH, self.HEIGHT), self.BG_COLOR)
+        draw = ImageDraw.Draw(img)
+        
+        # Draw figure
+        pose = scene.get("pose", "standing")
+        props = scene.get("props", [])
+        emotion = scene.get("emotion", "happy")
+        
+        self.draw_stick_figure(draw, self.WIDTH // 2, self.HEIGHT // 2 + 150,
+                               pose=pose, emotion=emotion, props=props, scale=1.5)
+        
+        # Add text overlay if present
+        text_overlay = scene.get("text_overlay")
+        if text_overlay:
+            self.add_text_overlay(img, text_overlay)
+        
+        return img
+    
+    def generate_frames_from_scenes(
+        self,
+        scenes: List[Dict],
+        chunk_durations: List[float],
+        output_dir: str,
+        fps: int = 30
+    ) -> List[str]:
+        """
+        Generate frames for all scenes with correct timing.
+        
+        Args:
+            scenes: List of scene descriptions
+            chunk_durations: Duration of each chunk in seconds
+            output_dir: Directory to save frames
+            fps: Frames per second
+            
+        Returns:
+            List of frame file paths
+        """
+        os.makedirs(output_dir, exist_ok=True)
+        frame_paths = []
+        frame_num = 0
+        
+        for i, scene in enumerate(scenes):
+            duration = chunk_durations[i] if i < len(chunk_durations) else 2.0
+            num_frames = int(duration * fps)
+            
+            logger.info(f"Generating {num_frames} frames for scene {i}")
+            
+            # Create scene frame
+            frame = self.create_scene_frame(scene)
+            
+            # Save frames for duration
+            for _ in range(num_frames):
+                frame_path = os.path.join(output_dir, f"frame_{frame_num:05d}.png")
+                frame.save(frame_path)
+                frame_paths.append(frame_path)
+                frame_num += 1
+        
+        logger.info(f"Generated {len(frame_paths)} total frames")
+        return frame_paths

static/index.html

@@ -645,9 +645,9 @@
                 </p>
                 <form id="stickForm">
                     <div class="form-group">
-                        <label>Script (Keywords: রাজা, বড়লোক, ঘুম, দৌড়, etc.)</label>
+                        <label>Script (Keywords: king, rich, sleep, run, walk, think, etc.)</label>
                         <textarea id="stickScript" rows="4"
-                            placeholder="একজন বড়লোক মানুষ সকালে ঘুম থেকে উঠল। সে মনে মনে ভাবল আজকে কি করব। Get ready for success!"></textarea>
+                            placeholder="A rich man woke up from sleep. He thought about what to do today. Get ready for success!"></textarea>
                     </div>
                     <button type="submit" class="submit-btn">🎭 Generate Stick Figure Video</button>
                 </form>