Major upgrade: Professional stick figure with multi-character, backgrounds, title screens, thought bubbles, visual metaphors, styled captions

modules/art_reels/router.py

@@ -139,9 +139,9 @@ async def generate_stick_figure_video(job_id: str, script: str, voice: str):
         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
+        # Import TTS, Whisper, and Professional Stick Figure
         from ..story_reels.services.srt_parser import SRTParser
-        from .services.ai_stick_figure import AIStickFigure
+        from .services.professional_stick_figure import ProfessionalStickFigure
         
         # Get TTS client from app
         import sys
@@ -191,9 +191,9 @@ async def generate_stick_figure_video(job_id: str, script: str, voice: str):
         
         update_job(job_id, "processing", 45)
         
-        # Step 4: Generate scenes with AI
-        ai_stick = AIStickFigure()
-        scenes = ai_stick.generate_scenes_with_ai(chunks)
+        # Step 4: Generate scenes with AI (Professional)
+        pro_stick = ProfessionalStickFigure()
+        scenes = pro_stick.generate_scenes_with_ai(chunks)
         
         # Calculate durations for each chunk
         chunk_durations = []
@@ -208,7 +208,7 @@ async def generate_stick_figure_video(job_id: str, script: str, voice: str):
         
         # Step 5: Generate frames
         logger.info(f"Generating stick figure frames for job {job_id}")
-        frame_paths = ai_stick.generate_frames_from_scenes(
+        frame_paths = pro_stick.generate_frames_from_scenes(
             scenes=scenes,
             chunk_durations=chunk_durations,
             output_dir=temp_dir,

modules/art_reels/services/professional_stick_figure.py

@@ -0,0 +1,1024 @@
+"""
+Professional Stick Figure Animation System
+Whiteboard-style animation with multiple characters, backgrounds, and visual metaphors
+"""
+import logging
+import os
+import json
+import math
+import random
+from PIL import Image, ImageDraw, ImageFont
+from typing import List, Tuple, Dict, Optional
+from groq import Groq
+
+logger = logging.getLogger(__name__)
+
+
+# Enhanced AI System Prompt for professional scene generation
+PROFESSIONAL_SCENE_PROMPT = """You are an AI that creates professional whiteboard animation scenes.
+
+For each 2-second narration chunk, generate a detailed scene description.
+
+SCENE TYPES:
+- "title": Text on white background (for introductions, key terms)
+- "single": One character doing something
+- "dual": Two characters interacting
+- "multi": 3+ characters in a scene
+- "metaphor": Visual metaphor (bridge, rope, handshake)
+- "chart": Show a simple graph or comparison
+
+BACKGROUNDS:
+- "white": Default clean background
+- "blackboard": Teacher/education scene
+- "office": Work/business scene
+- "outdoor": Nature, street, park
+- "room": Indoor with furniture
+
+POSES: standing, walking, running, sitting, sleeping, waving, thinking, jumping, celebrating, pointing, talking
+
+EMOTIONS: happy, sad, thinking, excited, tired, angry, surprised, confused
+
+INTERACTIONS (for dual/multi scenes):
+- "handshake": Agreement/cooperation
+- "tug_of_war": Conflict/competition
+- "conversation": Talking to each other
+- "helping": One helping another
+- "fighting": Conflict
+
+OUTPUT FORMAT (JSON array):
+[
+  {
+    "chunk_id": 0,
+    "scene_type": "title|single|dual|multi|metaphor|chart",
+    "background": "white|blackboard|office|outdoor|room",
+    "title_text": "Main Title Here" or null,
+    "subtitle_text": "Subtitle here" or null,
+    "characters": [
+      {
+        "position": "left|center|right",
+        "pose": "standing|walking|etc",
+        "emotion": "happy|sad|etc",
+        "props": ["crown", "book", etc],
+        "thought_bubble": "What they are thinking" or null,
+        "label": "Teacher" or null
+      }
+    ],
+    "metaphor": "bridge|rope|scale|chart" or null,
+    "metaphor_state": "intact|breaking|balanced" or null,
+    "caption": "Short caption text for this scene"
+  }
+]
+
+RULES:
+1. Match scenes to narration MEANING - use visual metaphors
+2. Use title scenes for new concepts (like "Prisoner's Dilemma")
+3. Use dual scenes for comparisons and interactions
+4. Add thought bubbles for internal decisions
+5. Always include a short caption summarizing the scene
+6. Be creative with visual storytelling
+
+EXAMPLES:
+- "Game theory explained" -> title scene with "GAME THEORY" as title
+- "Two prisoners are questioned" -> dual scene with jail background, both sitting
+- "They must decide to cooperate or betray" -> dual with thought bubbles "Silent?" vs "Betray?"
+- "One cuts the bridge" -> metaphor scene with bridge breaking
+"""
+
+
+class ProfessionalStickFigure:
+    """
+    Professional Whiteboard Animation System.
+    
+    Features:
+    - Multiple characters with positions
+    - Scene backgrounds
+    - Title screens
+    - Thought bubbles
+    - Visual metaphors
+    - Captions with proper styling
+    """
+    
+    # Video dimensions (9:16 portrait)
+    WIDTH = 1080
+    HEIGHT = 1920
+    
+    # Stick figure dimensions
+    HEAD_RADIUS = 40
+    BODY_LENGTH = 120
+    ARM_LENGTH = 80
+    LEG_LENGTH = 100
+    LINE_WIDTH = 8
+    
+    # Professional color scheme (black & white with accents)
+    BG_COLOR = (255, 255, 255)          # White
+    FIGURE_COLOR = (30, 30, 30)          # Near black
+    ACCENT_COLOR = (41, 128, 185)        # Professional blue
+    TITLE_COLOR = (44, 62, 80)           # Dark blue-gray
+    CAPTION_BG = (0, 0, 0)               # Black
+    CAPTION_TEXT = (255, 255, 255)       # White
+    THOUGHT_BG = (245, 245, 245)         # Light gray
+    HIGHLIGHT = (231, 76, 60)            # Red for emphasis
+    
+    # Character positions (x coordinates)
+    POSITIONS = {
+        "left": 270,
+        "center": 540,
+        "right": 810
+    }
+    
+    # Character Y base
+    CHARACTER_Y = 1100
+    
+    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")
+        
+        # Load fonts
+        self._load_fonts()
+    
+    def _load_fonts(self):
+        """Load fonts with fallbacks"""
+        try:
+            self.font_title = ImageFont.truetype("arial.ttf", 72)
+            self.font_subtitle = ImageFont.truetype("arial.ttf", 48)
+            self.font_caption = ImageFont.truetype("arial.ttf", 42)
+            self.font_thought = ImageFont.truetype("arial.ttf", 32)
+            self.font_label = ImageFont.truetype("arial.ttf", 28)
+        except:
+            self.font_title = ImageFont.load_default()
+            self.font_subtitle = ImageFont.load_default()
+            self.font_caption = ImageFont.load_default()
+            self.font_thought = ImageFont.load_default()
+            self.font_label = ImageFont.load_default()
+    
+    # ==========================================
+    # AI SCENE GENERATION
+    # ==========================================
+    
+    def generate_scenes_with_ai(self, chunks: List[Dict]) -> List[Dict]:
+        """Generate professional scene descriptions using AI"""
+        if not self.groq:
+            return self._generate_fallback_scenes(chunks)
+        
+        try:
+            chunk_texts = "\n".join([
+                f"Chunk {c.get('chunk_id', i)}: \"{c.get('text', '')}\""
+                for i, c in enumerate(chunks)
+            ])
+            
+            user_prompt = f"""Create professional whiteboard animation scenes for:
+
+{chunk_texts}
+
+Generate exactly {len(chunks)} scenes. Return ONLY valid JSON array."""
+
+            response = self.groq.chat.completions.create(
+                model="openai/gpt-oss-120b",
+                messages=[
+                    {"role": "system", "content": PROFESSIONAL_SCENE_PROMPT},
+                    {"role": "user", "content": user_prompt}
+                ],
+                temperature=0.7,
+                max_tokens=4000
+            )
+            
+            content = response.choices[0].message.content.strip()
+            
+            # Parse JSON
+            if "```" in content:
+                content = content.split("```")[1]
+                if content.startswith("json"):
+                    content = content[4:]
+            
+            scenes = json.loads(content)
+            logger.info(f"AI generated {len(scenes)} professional scenes")
+            return scenes
+            
+        except Exception as e:
+            logger.error(f"AI scene generation failed: {e}")
+            return self._generate_fallback_scenes(chunks)
+    
+    def _generate_fallback_scenes(self, chunks: List[Dict]) -> List[Dict]:
+        """Fallback scene generation"""
+        scenes = []
+        for i, chunk in enumerate(chunks):
+            text = chunk.get("text", "").lower()
+            
+            # Detect scene type
+            scene_type = "single"
+            if any(word in text for word in ["vs", "versus", "compare", "between", "both", "two"]):
+                scene_type = "dual"
+            elif any(word in text for word in ["introduce", "what is", "explained", "definition"]):
+                scene_type = "title"
+            
+            scenes.append({
+                "chunk_id": i,
+                "scene_type": scene_type,
+                "background": "white",
+                "title_text": text[:30].upper() if scene_type == "title" else None,
+                "characters": [
+                    {"position": "center", "pose": "standing", "emotion": "happy", "props": []}
+                ] if scene_type != "title" else [],
+                "caption": text[:50] + "..." if len(text) > 50 else text
+            })
+        
+        return scenes
+    
+    # ==========================================
+    # BACKGROUND DRAWING
+    # ==========================================
+    
+    def draw_background(self, draw: ImageDraw, bg_type: str = "white"):
+        """Draw scene background"""
+        if bg_type == "blackboard":
+            # Green chalkboard
+            draw.rectangle([0, 0, self.WIDTH, self.HEIGHT], fill=(34, 49, 39))
+            # Frame
+            draw.rectangle([30, 200, self.WIDTH - 30, 900], 
+                          outline=(139, 90, 43), width=15)
+            draw.rectangle([40, 210, self.WIDTH - 40, 890], 
+                          fill=(40, 68, 50))
+        
+        elif bg_type == "office":
+            # Light gray wall
+            draw.rectangle([0, 0, self.WIDTH, self.HEIGHT], fill=(240, 240, 240))
+            # Floor
+            draw.rectangle([0, 1400, self.WIDTH, self.HEIGHT], fill=(180, 150, 120))
+            # Simple desk
+            draw.rectangle([200, 1200, 880, 1250], fill=(139, 90, 43))
+            draw.rectangle([250, 1250, 300, 1400], fill=(100, 65, 30))
+            draw.rectangle([780, 1250, 830, 1400], fill=(100, 65, 30))
+        
+        elif bg_type == "outdoor":
+            # Sky gradient (simplified)
+            draw.rectangle([0, 0, self.WIDTH, 600], fill=(135, 206, 235))
+            # Ground
+            draw.rectangle([0, 1400, self.WIDTH, self.HEIGHT], fill=(76, 153, 0))
+            # Sun
+            draw.ellipse([850, 100, 1000, 250], fill=(255, 223, 0))
+        
+        elif bg_type == "room":
+            # Wall
+            draw.rectangle([0, 0, self.WIDTH, self.HEIGHT], fill=(255, 248, 240))
+            # Floor
+            draw.rectangle([0, 1400, self.WIDTH, self.HEIGHT], fill=(139, 119, 101))
+        
+        # Default white - no additional drawing needed
+    
+    # ==========================================
+    # TITLE SCREEN
+    # ==========================================
+    
+    def draw_title_screen(
+        self,
+        img: Image.Image,
+        title: str,
+        subtitle: str = None
+    ):
+        """Draw professional title screen"""
+        draw = ImageDraw.Draw(img)
+        
+        # Main title
+        bbox = draw.textbbox((0, 0), title, font=self.font_title)
+        title_width = bbox[2] - bbox[0]
+        title_x = (self.WIDTH - title_width) // 2
+        title_y = self.HEIGHT // 2 - 100
+        
+        # Draw title with underline
+        draw.text((title_x, title_y), title, fill=self.TITLE_COLOR, font=self.font_title)
+        
+        # Underline
+        draw.line([title_x, title_y + 90, title_x + title_width, title_y + 90],
+                 fill=self.ACCENT_COLOR, width=4)
+        
+        # Subtitle if provided
+        if subtitle:
+            bbox = draw.textbbox((0, 0), subtitle, font=self.font_subtitle)
+            sub_width = bbox[2] - bbox[0]
+            sub_x = (self.WIDTH - sub_width) // 2
+            draw.text((sub_x, title_y + 120), subtitle, 
+                     fill=(100, 100, 100), font=self.font_subtitle)
+    
+    # ==========================================
+    # CAPTION (Bottom Bar)
+    # ==========================================
+    
+    def draw_caption(
+        self,
+        img: Image.Image,
+        caption: str,
+        position: str = "bottom"
+    ):
+        """Draw professional caption bar"""
+        if not caption:
+            return
+        
+        draw = ImageDraw.Draw(img)
+        
+        # Caption background
+        caption_height = 120
+        if position == "bottom":
+            caption_y = self.HEIGHT - caption_height - 50
+        else:
+            caption_y = 50
+        
+        # Semi-transparent background
+        draw.rectangle([40, caption_y, self.WIDTH - 40, caption_y + caption_height],
+                      fill=(0, 0, 0), outline=None)
+        
+        # Text
+        bbox = draw.textbbox((0, 0), caption, font=self.font_caption)
+        text_width = bbox[2] - bbox[0]
+        text_x = (self.WIDTH - text_width) // 2
+        text_y = caption_y + (caption_height - 42) // 2
+        
+        draw.text((text_x, text_y), caption, fill=self.CAPTION_TEXT, font=self.font_caption)
+    
+    # ==========================================
+    # THOUGHT BUBBLE
+    # ==========================================
+    
+    def draw_thought_bubble(
+        self,
+        draw: ImageDraw,
+        x: int,
+        y: int,
+        text: str,
+        direction: str = "right"
+    ):
+        """Draw thought bubble with text"""
+        # Bubble dimensions
+        padding = 20
+        bbox = draw.textbbox((0, 0), text, font=self.font_thought)
+        text_width = bbox[2] - bbox[0]
+        text_height = bbox[3] - bbox[1]
+        
+        bubble_width = text_width + padding * 2
+        bubble_height = text_height + padding * 2
+        
+        # Position bubble
+        if direction == "right":
+            bubble_x = x + 30
+        else:
+            bubble_x = x - bubble_width - 30
+        bubble_y = y - 150
+        
+        # Draw bubble (ellipse)
+        draw.ellipse([bubble_x, bubble_y, bubble_x + bubble_width, bubble_y + bubble_height],
+                    fill=self.THOUGHT_BG, outline=self.FIGURE_COLOR, width=2)
+        
+        # Small circles leading to head
+        for i, offset in enumerate([(15, 40), (8, 60), (3, 75)]):
+            size = 12 - i * 3
+            cx = x + (offset[0] if direction == "right" else -offset[0])
+            cy = y - 80 + offset[1]
+            draw.ellipse([cx - size, cy - size, cx + size, cy + size],
+                        fill=self.THOUGHT_BG, outline=self.FIGURE_COLOR, width=2)
+        
+        # Text
+        draw.text((bubble_x + padding, bubble_y + padding), text,
+                 fill=self.FIGURE_COLOR, font=self.font_thought)
+    
+    # ==========================================
+    # STICK FIGURE DRAWING
+    # ==========================================
+    
+    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,
+        facing: str = "front"  # front, left, right
+    ):
+        """Draw 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))
+        
+        # Draw based on pose
+        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,
+            "pointing": self._draw_pointing,
+            "talking": self._draw_talking,
+        }
+        
+        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"""
+        eye_y = y - head_r // 4
+        eye_offset = head_r // 3
+        eye_size = head_r // 5
+        
+        if emotion == "happy":
+            # Happy curved eyes
+            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":
+            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":
+            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
+            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_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)
+            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)
+        
+        elif emotion == "surprised":
+            # Wide eyes
+            draw.ellipse([x - eye_offset - eye_size*2, eye_y - eye_size*2,
+                         x - eye_offset + eye_size*2, eye_y + eye_size*2],
+                        outline=self.FIGURE_COLOR, width=line_w//2)
+            draw.ellipse([x + eye_offset - eye_size*2, eye_y - eye_size*2,
+                         x + eye_offset + eye_size*2, eye_y + eye_size*2],
+                        outline=self.FIGURE_COLOR, width=line_w//2)
+            # O mouth
+            draw.ellipse([x - head_r//4, y + head_r//8, x + head_r//4, y + head_r//2],
+                        outline=self.FIGURE_COLOR, width=line_w//2)
+        
+        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"""
+        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, 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//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)
+        
+        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
+        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 sleeping pose (horizontal)"""
+        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
+        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)
+        
+        draw.line([x - body_len + head_r, y, x, y], fill=self.FIGURE_COLOR, width=line_w)
+        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
+        draw.text((x - body_len, y - head_r - 50), "Zzz", fill=(150, 150, 150), font=self.font_label)
+        
+        # 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)
+        draw.line([x, arm_y, x + arm_len//2, arm_y - arm_len], fill=self.FIGURE_COLOR, width=line_w)
+        
+        # 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, 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"""
+        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)
+    
+    def _draw_jumping(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
+        """Draw jumping pose"""
+        y_offset = -80
+        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)
+        
+        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)
+        
+        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 line
+        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"""
+        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)
+        
+        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
+        colors = [(255, 87, 51), (255, 195, 0), (76, 175, 80), (33, 150, 243)]
+        for _ in range(8):
+            cx = x + random.randint(-120, 120)
+            cy = head_y + random.randint(-120, 40)
+            color = random.choice(colors)
+            draw.ellipse([cx - 4, cy - 4, cx + 4, cy + 4], fill=color)
+    
+    def _draw_pointing(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
+        """Draw pointing 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, 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//3], fill=self.FIGURE_COLOR, width=line_w)
+        # Pointing arm
+        draw.line([x, arm_y, x + arm_len + 20, arm_y - arm_len//2], 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)
+    
+    def _draw_talking(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
+        """Draw talking pose with speech lines"""
+        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)
+        
+        # Open mouth
+        eye_y = head_y - head_r // 4
+        eye_offset = head_r // 3
+        eye_size = head_r // 5
+        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)
+        # Talking mouth
+        draw.ellipse([x - head_r//3, head_y + head_r//6, x + head_r//3, head_y + head_r//2],
+                    outline=self.FIGURE_COLOR, width=line_w//2)
+        
+        # Speech lines
+        for i in range(3):
+            sx = x + head_r + 10 + i * 15
+            sy = head_y - 10 + i * 5
+            draw.line([sx, sy, sx + 20, sy], fill=(150, 150, 150), width=3)
+        
+        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//4], fill=self.FIGURE_COLOR, width=line_w)
+        draw.line([x, arm_y, x + arm_len, arm_y + arm_len//4], 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)
+    
+    # ==========================================
+    # PROPS DRAWING
+    # ==========================================
+    
+    def _draw_prop(self, draw, x, head_y, head_r, prop: str, scale: float):
+        """Draw props"""
+        if prop == "crown":
+            crown_y = head_y - head_r - 15
+            points = [
+                (x - 35, crown_y),
+                (x - 20, crown_y - 35),
+                (x, crown_y - 15),
+                (x + 20, crown_y - 35),
+                (x + 35, crown_y)
+            ]
+            draw.polygon(points, fill=(255, 215, 0), outline=(200, 170, 0), width=2)
+        
+        elif prop == "glasses":
+            glass_y = head_y - head_r // 4
+            # Left lens
+            draw.ellipse([x - head_r//2 - 15, glass_y - 12, x - head_r//2 + 15, glass_y + 12],
+                        outline=self.FIGURE_COLOR, width=3)
+            # Right lens
+            draw.ellipse([x + head_r//2 - 15, glass_y - 12, x + head_r//2 + 15, glass_y + 12],
+                        outline=self.FIGURE_COLOR, width=3)
+            # Bridge
+            draw.line([x - head_r//2 + 15, glass_y, x + head_r//2 - 15, glass_y],
+                     fill=self.FIGURE_COLOR, width=2)
+        
+        elif prop == "money":
+            bag_x = x + 80
+            bag_y = head_y + 120
+            draw.ellipse([bag_x, bag_y, bag_x + 50, bag_y + 60], 
+                        fill=(34, 139, 34), outline=(20, 100, 20), width=2)
+            draw.text((bag_x + 18, bag_y + 15), "$", fill=(255, 255, 255), font=self.font_label)
+        
+        elif prop == "book":
+            book_x = x + 70
+            book_y = head_y + 100
+            draw.rectangle([book_x, book_y, book_x + 40, book_y + 55], 
+                          fill=(139, 69, 19), outline=(100, 50, 10), width=2)
+            draw.line([book_x + 20, book_y, book_x + 20, book_y + 55], fill=(80, 40, 10), width=2)
+        
+        elif prop == "briefcase":
+            bc_x = x + 70
+            bc_y = head_y + 130
+            draw.rectangle([bc_x, bc_y, bc_x + 50, bc_y + 35], 
+                          fill=(60, 40, 30), outline=(40, 25, 15), width=2)
+            draw.rectangle([bc_x + 15, bc_y - 8, bc_x + 35, bc_y + 5], 
+                          fill=(60, 40, 30), outline=(40, 25, 15), width=2)
+        
+        elif prop == "phone":
+            phone_x = x + 75
+            phone_y = head_y + 80
+            draw.rectangle([phone_x, phone_y, phone_x + 25, phone_y + 40], 
+                          fill=(50, 50, 50), outline=(30, 30, 30), width=2)
+            draw.rectangle([phone_x + 3, phone_y + 5, phone_x + 22, phone_y + 32], 
+                          fill=(100, 150, 200))
+    
+    # ==========================================
+    # VISUAL METAPHORS
+    # ==========================================
+    
+    def draw_metaphor(
+        self,
+        draw: ImageDraw,
+        metaphor: str,
+        state: str = "intact",
+        y_pos: int = None
+    ):
+        """Draw visual metaphors"""
+        y = y_pos or self.HEIGHT // 2 + 200
+        
+        if metaphor == "bridge":
+            self._draw_bridge(draw, y, state)
+        elif metaphor == "rope":
+            self._draw_rope(draw, y, state)
+        elif metaphor == "scale":
+            self._draw_scale(draw, y, state)
+        elif metaphor == "handshake":
+            self._draw_handshake(draw, y)
+    
+    def _draw_bridge(self, draw, y, state):
+        """Draw bridge metaphor"""
+        bridge_y = y
+        
+        if state == "intact":
+            # Full bridge
+            draw.rectangle([200, bridge_y, 880, bridge_y + 30], 
+                          fill=(139, 90, 43), outline=(100, 65, 30), width=2)
+            # Supports
+            draw.rectangle([200, bridge_y + 30, 250, bridge_y + 150], fill=(100, 65, 30))
+            draw.rectangle([830, bridge_y + 30, 880, bridge_y + 150], fill=(100, 65, 30))
+        
+        elif state == "breaking":
+            # Left part
+            draw.polygon([
+                (200, bridge_y), (500, bridge_y), (520, bridge_y + 80),
+                (200, bridge_y + 30)
+            ], fill=(139, 90, 43), outline=(100, 65, 30))
+            # Right part
+            draw.polygon([
+                (560, bridge_y + 60), (880, bridge_y), (880, bridge_y + 30),
+                (580, bridge_y + 90)
+            ], fill=(139, 90, 43), outline=(100, 65, 30))
+            # Supports
+            draw.rectangle([200, bridge_y + 30, 250, bridge_y + 150], fill=(100, 65, 30))
+            draw.rectangle([830, bridge_y + 30, 880, bridge_y + 150], fill=(100, 65, 30))
+    
+    def _draw_rope(self, draw, y, state):
+        """Draw rope/tug-of-war metaphor"""
+        rope_y = y
+        
+        # Rope
+        if state == "tense":
+            # Straight tense rope
+            draw.line([200, rope_y, 880, rope_y], fill=(139, 90, 43), width=8)
+        else:
+            # Slight curve
+            for i in range(20):
+                x1 = 200 + i * 34
+                x2 = x1 + 34
+                y1 = rope_y + math.sin(i * 0.5) * 10
+                y2 = rope_y + math.sin((i + 1) * 0.5) * 10
+                draw.line([x1, y1, x2, y2], fill=(139, 90, 43), width=8)
+        
+        # Center marker
+        draw.rectangle([530, rope_y - 15, 550, rope_y + 15], fill=self.HIGHLIGHT)
+    
+    def _draw_scale(self, draw, y, state):
+        """Draw balance scale metaphor"""
+        center_x = self.WIDTH // 2
+        base_y = y + 100
+        
+        # Base
+        draw.polygon([
+            (center_x - 50, base_y), (center_x + 50, base_y),
+            (center_x + 30, base_y + 40), (center_x - 30, base_y + 40)
+        ], fill=(139, 90, 43))
+        
+        # Pole
+        draw.rectangle([center_x - 5, y - 50, center_x + 5, base_y], fill=(100, 65, 30))
+        
+        # Beam
+        if state == "balanced":
+            draw.rectangle([center_x - 150, y - 55, center_x + 150, y - 45], fill=(100, 65, 30))
+            # Plates
+            draw.ellipse([center_x - 180, y - 30, center_x - 100, y], fill=(180, 150, 120))
+            draw.ellipse([center_x + 100, y - 30, center_x + 180, y], fill=(180, 150, 120))
+        else:
+            # Tilted beam
+            draw.polygon([
+                (center_x - 150, y - 30), (center_x + 150, y - 70),
+                (center_x + 150, y - 60), (center_x - 150, y - 20)
+            ], fill=(100, 65, 30))
+    
+    def _draw_handshake(self, draw, y):
+        """Draw handshake"""
+        center_x = self.WIDTH // 2
+        
+        # Left hand
+        draw.line([center_x - 100, y, center_x - 20, y], fill=self.FIGURE_COLOR, width=10)
+        draw.ellipse([center_x - 40, y - 15, center_x, y + 15], fill=self.FIGURE_COLOR)
+        
+        # Right hand
+        draw.line([center_x + 100, y, center_x + 20, y], fill=self.FIGURE_COLOR, width=10)
+        draw.ellipse([center_x, y - 15, center_x + 40, y + 15], fill=self.FIGURE_COLOR)
+        
+        # Grip
+        draw.ellipse([center_x - 15, y - 10, center_x + 15, y + 10], fill=self.FIGURE_COLOR)
+    
+    # ==========================================
+    # SCENE RENDERING
+    # ==========================================
+    
+    def create_scene_frame(self, scene: Dict) -> Image.Image:
+        """Create a complete scene frame"""
+        img = Image.new('RGB', (self.WIDTH, self.HEIGHT), self.BG_COLOR)
+        draw = ImageDraw.Draw(img)
+        
+        scene_type = scene.get("scene_type", "single")
+        background = scene.get("background", "white")
+        
+        # Draw background
+        self.draw_background(draw, background)
+        
+        # Title scene
+        if scene_type == "title":
+            title = scene.get("title_text", "")
+            subtitle = scene.get("subtitle_text")
+            if title:
+                self.draw_title_screen(img, title, subtitle)
+        
+        # Character scenes
+        else:
+            characters = scene.get("characters", [])
+            for char in characters:
+                pos = char.get("position", "center")
+                x = self.POSITIONS.get(pos, self.POSITIONS["center"])
+                y = self.CHARACTER_Y
+                
+                pose = char.get("pose", "standing")
+                emotion = char.get("emotion", "happy")
+                props = char.get("props", [])
+                
+                self.draw_stick_figure(draw, x, y, pose, emotion, props, scale=1.2)
+                
+                # Thought bubble
+                thought = char.get("thought_bubble")
+                if thought:
+                    direction = "right" if pos == "left" else "left"
+                    head_y = y - self.BODY_LENGTH * 1.2 - self.HEAD_RADIUS * 1.2
+                    self.draw_thought_bubble(draw, x, int(head_y), thought, direction)
+                
+                # Label
+                label = char.get("label")
+                if label:
+                    bbox = draw.textbbox((0, 0), label, font=self.font_label)
+                    label_width = bbox[2] - bbox[0]
+                    draw.text((x - label_width // 2, y + 130), label,
+                             fill=(100, 100, 100), font=self.font_label)
+        
+        # Draw metaphor
+        metaphor = scene.get("metaphor")
+        if metaphor:
+            state = scene.get("metaphor_state", "intact")
+            self.draw_metaphor(draw, metaphor, state)
+        
+        # Draw caption
+        caption = scene.get("caption")
+        if caption:
+            self.draw_caption(img, caption)
+        
+        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"""
+        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}: {scene.get('scene_type', 'unknown')}")
+            
+            frame = self.create_scene_frame(scene)
+            
+            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