Update core/visual_engine.py

core/visual_engine.py

@@ -1,27 +1,26 @@
 # core/visual_engine.py
-from PIL import Image, ImageDraw, ImageFont # Pillow should be >= 10.0.0
+from PIL import Image, ImageDraw, ImageFont
 from moviepy.editor import (ImageClip, concatenate_videoclips, TextClip, 
                             CompositeVideoClip)
-import moviepy.video.fx.all as vfx # For effects like resize, fadein, fadeout
+import moviepy.video.fx.all as vfx 
 import numpy as np
 import os
 import openai
 import requests
 import io
+import time # For adding slight delay if API rate limits are hit
 
 class VisualEngine:
-    def __init__(self, output_dir="temp_generated_media"):
+    def __init__(self, output_dir="temp_cinegen_media"):
         self.output_dir = output_dir
         os.makedirs(self.output_dir, exist_ok=True)
         
         self.font_filename = "arial.ttf" 
         self.font_path_in_container = f"/usr/local/share/fonts/truetype/mycustomfonts/{self.font_filename}"
-        self.font_size_pil = 24 
-        self.video_overlay_font_size = 36 
+        self.font_size_pil = 20 # Slightly smaller for placeholder text to fit more
+        self.video_overlay_font_size = 32 
         self.video_overlay_font_color = 'white'
-        # For video overlays, TextClip will use ImageMagick. 'Arial' is a common system font name.
-        # If issues, use self.font_path_in_container (if ImageMagick can access it via moviepy)
-        self.video_overlay_font = 'Arial' 
+        self.video_overlay_font = 'Arial-Bold' # Try specific variant; ensure ImageMagick can find it or use full path
 
         try:
             self.font = ImageFont.truetype(self.font_path_in_container, self.font_size_pil)
@@ -29,236 +28,183 @@ class VisualEngine:
         except IOError:
             print(f"Warning: Could not load font from '{self.font_path_in_container}'. Placeholders will use default font.")
             self.font = ImageFont.load_default()
-            self.font_size_pil = 11
+            self.font_size_pil = 10 # Default font size estimate
 
         self.openai_api_key = None
         self.USE_AI_IMAGE_GENERATION = False
         self.dalle_model = "dall-e-3" 
-        self.image_size = "1024x1024" # DALL-E 3 output size
-        # Target video frame size (e.g., 16:9 aspect ratio)
-        # DALL-E 3 images (1024x1024) will be letter/pillar-boxed to fit this.
-        self.video_frame_size = (1280, 720) 
+        # DALL-E 3 standard size for highest quality generally. Other options: "1792x1024", "1024x1792"
+        self.image_size_dalle3 = "1792x1024" # Landscape, good for cinematic
+        self.video_frame_size = (1280, 720) # 16:9 aspect ratio for video output
 
     def set_openai_api_key(self, api_key):
         if api_key:
             self.openai_api_key = api_key
             self.USE_AI_IMAGE_GENERATION = True
-            print("OpenAI API key set. AI Image Generation Enabled with DALL-E.")
+            print(f"OpenAI API key set. AI Image Generation Enabled with {self.dalle_model}.")
         else:
             self.USE_AI_IMAGE_GENERATION = False
             print("OpenAI API key not provided. AI Image Generation Disabled. Using placeholders.")
 
-    def _get_text_dimensions(self, text_content, font_obj):
-        if text_content == "" or text_content is None:
-            return 0, self.font_size_pil 
+    def _get_text_dimensions(self, text_content, font_obj): # Remains the same
+        if not text_content: return 0, self.font_size_pil 
         try:
-            if hasattr(font_obj, 'getbbox'): # Pillow >= 8.0.0
-                bbox = font_obj.getbbox(text_content)
-                width = bbox[2] - bbox[0]
-                height = bbox[3] - bbox[1]
+            if hasattr(font_obj, 'getbbox'):
+                bbox = font_obj.getbbox(text_content); width = bbox[2] - bbox[0]; height = bbox[3] - bbox[1]
                 return width, height if height > 0 else self.font_size_pil
-            elif hasattr(font_obj, 'getsize'): # Older Pillow
+            elif hasattr(font_obj, 'getsize'):
                 width, height = font_obj.getsize(text_content)
                 return width, height if height > 0 else self.font_size_pil
             else: 
-                avg_char_width = self.font_size_pil * 0.6 
-                height_estimate = self.font_size_pil * 1.2
-                return int(len(text_content) * avg_char_width), int(height_estimate if height_estimate > 0 else self.font_size_pil)
-        except Exception as e:
-            print(f"Warning: Error getting text dimensions for '{text_content}': {e}. Using estimates.")
-            avg_char_width = self.font_size_pil * 0.6
-            height_estimate = self.font_size_pil * 1.2
-            return int(len(text_content) * avg_char_width), int(height_estimate if height_estimate > 0 else self.font_size_pil)
+                return int(len(text_content) * self.font_size_pil*0.6), int(self.font_size_pil*1.2 if self.font_size_pil*1.2 > 0 else self.font_size_pil)
+        except Exception: return int(len(text_content) * self.font_size_pil*0.6), int(self.font_size_pil*1.2)
 
-    def _create_placeholder_image_content(self, text_description, filename, size=(1024, 576)): # Default placeholder size
-        img = Image.new('RGB', size, color=(30, 30, 60))
+    def _create_placeholder_image_content(self, text_description, filename, size=(1280, 720)): # Default to video_frame_size
+        img = Image.new('RGB', size, color=(20, 20, 40)) # Darker
         draw = ImageDraw.Draw(img)
-        padding = 30 
+        padding = 25 
         max_text_width = size[0] - (2 * padding)
         lines = []
-        if not text_description: text_description = "(No description provided for placeholder)"
+        if not text_description: text_description = "(Placeholder: No prompt provided)"
+        # Simplified text wrapping for placeholder
         words = text_description.split()
         current_line = ""
         for word in words:
-            test_line_candidate = current_line + word + " "
-            line_width, _ = self._get_text_dimensions(test_line_candidate.strip(), self.font)
-            if line_width <= max_text_width and current_line != "": current_line = test_line_candidate
-            elif line_width <= max_text_width and current_line == "": current_line = test_line_candidate
-            elif current_line != "":
-                lines.append(current_line.strip())
-                current_line = word + " "
+            test_line = current_line + word + " "
+            if self._get_text_dimensions(test_line, self.font)[0] <= max_text_width:
+                current_line = test_line
             else:
-                temp_word = word
-                while self._get_text_dimensions(temp_word, self.font)[0] > max_text_width and len(temp_word) > 0: temp_word = temp_word[:-1]
-                lines.append(temp_word)
-                current_line = ""
-        if current_line.strip(): lines.append(current_line.strip())
-        if not lines: lines.append("(Text error in placeholder)")
-        _, single_line_height = self._get_text_dimensions("Tg", self.font)
-        if single_line_height == 0: single_line_height = self.font_size_pil 
-        line_spacing_factor = 1.3
-        estimated_line_block_height = len(lines) * single_line_height * line_spacing_factor
-        y_text = (size[1] - estimated_line_block_height) / 2.0
-        if y_text < padding: y_text = float(padding)
-        for line_idx, line in enumerate(lines):
-            if line_idx >= 7 and len(lines) > 8: 
-                draw.text(xy=(float(padding), y_text), text="...", fill=(200, 200, 130), font=self.font)
-                break
+                if current_line: lines.append(current_line.strip())
+                current_line = word + " "
+        if current_line: lines.append(current_line.strip())
+        if not lines: lines.append("(Text too long or unrenderable for placeholder)")
+
+        _, single_line_height = self._get_text_dimensions("Ay", self.font)
+        if single_line_height == 0: single_line_height = self.font_size_pil + 2
+        
+        num_lines_to_display = min(len(lines), (size[1] - 2 * padding) // (single_line_height + 2)) # Max lines based on height
+        
+        y_text = padding + (size[1] - 2*padding - num_lines_to_display * (single_line_height + 2)) / 2.0
+
+        for i in range(num_lines_to_display):
+            line = lines[i]
             line_width, _ = self._get_text_dimensions(line, self.font)
             x_text = (size[0] - line_width) / 2.0
-            if x_text < padding: x_text = float(padding)
-            draw.text(xy=(x_text, y_text), text=line, fill=(220, 220, 150), font=self.font)
-            y_text += single_line_height * line_spacing_factor
+            draw.text((x_text, y_text), line, font=self.font, fill=(200, 200, 180))
+            y_text += single_line_height + 2 # Line spacing
+            if i == 6 and num_lines_to_display > 7: # Show ellipsis if more text
+                draw.text((x_text, y_text), "...", font=self.font, fill=(200, 200, 180))
+                break
         filepath = os.path.join(self.output_dir, filename)
-        try:
-            img.save(filepath)
-        except Exception as e:
-            print(f"Error saving placeholder image {filepath}: {e}")
-            return None
-        return filepath
+        try: img.save(filepath); return filepath
+        except Exception as e: print(f"Error saving placeholder: {e}"); return None
 
     def generate_image_visual(self, image_prompt_text, scene_identifier_filename):
         filepath = os.path.join(self.output_dir, scene_identifier_filename)
         if self.USE_AI_IMAGE_GENERATION and self.openai_api_key:
-            try:
-                print(f"Generating DALL-E ({self.dalle_model}) image for: {image_prompt_text[:100]}...")
-                client = openai.OpenAI(api_key=self.openai_api_key)
-                response = client.images.generate(
-                    model=self.dalle_model, prompt=image_prompt_text, n=1,
-                    size=self.image_size, quality="standard", response_format="url" 
-                    # style="vivid" # or "natural" for DALL-E 3, optional
-                )
-                image_url = response.data[0].url
-                revised_prompt_dalle3 = getattr(response.data[0], 'revised_prompt', None) # Safely access
-                if revised_prompt_dalle3: print(f"DALL-E 3 revised prompt: {revised_prompt_dalle3[:150]}...")
-                
-                image_response = requests.get(image_url, timeout=60)
-                image_response.raise_for_status()
-                
-                img_data = Image.open(io.BytesIO(image_response.content))
-                if img_data.mode == 'RGBA': # Ensure RGB for consistency, PNG can be RGBA
-                    img_data = img_data.convert('RGB')
-                
-                # Save the AI generated image (typically 1024x1024 from DALL-E)
-                img_data.save(filepath) 
-                print(f"AI Image (DALL-E) saved: {filepath}")
-                return filepath
-            except openai.APIError as e: 
-                print(f"OpenAI API Error: {e}")
-            except requests.exceptions.RequestException as e:
-                print(f"Requests Error downloading DALL-E image: {e}")
-            except Exception as e:
-                print(f"Generic error during DALL-E image generation: {e}")
+            max_retries = 2
+            for attempt in range(max_retries):
+                try:
+                    print(f"Attempt {attempt+1}: DALL-E ({self.dalle_model}) for: {image_prompt_text[:120]}...")
+                    client = openai.OpenAI(api_key=self.openai_api_key, timeout=60.0) # Timeout for client
+                    
+                    response = client.images.generate(
+                        model=self.dalle_model,
+                        prompt=image_prompt_text,
+                        n=1,
+                        size=self.image_size_dalle3, 
+                        quality="hd", # Use "hd" for DALL-E 3 for better detail, "standard" for faster/cheaper
+                        response_format="url",
+                        style="vivid" # "vivid" or "natural" for DALL-E 3
+                    )
+                    image_url = response.data[0].url
+                    revised_prompt = getattr(response.data[0], 'revised_prompt', None)
+                    if revised_prompt: print(f"DALL-E 3 revised_prompt: {revised_prompt[:100]}...")
+
+                    image_response = requests.get(image_url, timeout=90) # Increased download timeout
+                    image_response.raise_for_status()
+                    
+                    img_data = Image.open(io.BytesIO(image_response.content))
+                    if img_data.mode != 'RGB': img_data = img_data.convert('RGB')
+                    
+                    img_data.save(filepath) 
+                    print(f"AI Image (DALL-E) saved: {filepath}")
+                    return filepath 
+                except openai.RateLimitError as e:
+                    print(f"OpenAI Rate Limit Error: {e}. Retrying after delay...")
+                    if attempt < max_retries - 1: time.sleep(5 * (attempt + 1)); continue
+                    else: print("Max retries reached for RateLimitError."); break
+                except openai.APIError as e: print(f"OpenAI API Error: {e}"); break 
+                except requests.exceptions.RequestException as e: print(f"Requests Error (DALL-E image download): {e}"); break
+                except Exception as e: print(f"Generic error (DALL-E image gen): {e}"); break
             
-            print("Falling back to placeholder image due to DALL-E error.")
-            # Fallback uses video_frame_size to match what video expects if AI fails
+            print("DALL-E generation failed after retries. Falling back to placeholder.")
             return self._create_placeholder_image_content(
-                f"[DALL-E Failed] Prompt: {image_prompt_text[:150]}...", 
+                f"[AI Gen Failed] Prompt: {image_prompt_text[:100]}...", 
                 scene_identifier_filename, size=self.video_frame_size
             )
-        else: # AI not enabled or key missing
-            # print(f"AI image generation not enabled/ready. Creating placeholder.")
-            # Placeholder also uses video_frame_size for consistency in video pipeline
+        else:
             return self._create_placeholder_image_content(
                 image_prompt_text, scene_identifier_filename, size=self.video_frame_size
             )
 
-    def create_video_from_images(self, image_data_list, output_filename="final_video.mp4", fps=24, duration_per_image=3):
-        if not image_data_list:
-            print("No image data provided to create video.")
-            return None
-        
-        print(f"Attempting to create video from {len(image_data_list)} images.")
+    def create_video_from_images(self, image_data_list, output_filename="final_video.mp4", fps=24, duration_per_image=4):
+        if not image_data_list: return None
+        print(f"Creating video from {len(image_data_list)} image sets.")
         processed_clips = []
 
         for i, data in enumerate(image_data_list):
-            img_path = data.get('path')
-            scene_num = data.get('scene_num', i + 1)
-            key_action = data.get('key_action', '')
-
+            img_path, scene_num, key_action = data.get('path'), data.get('scene_num', i+1), data.get('key_action', '')
             if not (img_path and os.path.exists(img_path)):
-                print(f"Image path invalid or not found: {img_path}. Skipping for video.")
-                continue
+                print(f"Image not found: {img_path}. Skipping."); continue
             try:
-                pil_image_original = Image.open(img_path)
+                pil_img_orig = Image.open(img_path)
+                if pil_img_orig.mode != 'RGB': pil_img_orig = pil_img_orig.convert('RGB')
+
+                # Resize and letterbox/pillarbox to video_frame_size
+                img_for_frame = pil_img_orig.copy()
+                img_for_frame.thumbnail(self.video_frame_size, Image.Resampling.LANCZOS)
+                canvas = Image.new('RGB', self.video_frame_size, (0,0,0))
+                x_offset = (self.video_frame_size[0] - img_for_frame.width) // 2
+                y_offset = (self.video_frame_size[1] - img_for_frame.height) // 2
+                canvas.paste(img_for_frame, (x_offset, y_offset))
                 
-                if pil_image_original.mode != 'RGB': # Ensure RGB for video
-                    pil_image_original = pil_image_original.convert('RGB')
-
-                # Create a copy to resize (thumbnail modifies in-place)
-                pil_image_for_frame = pil_image_original.copy()
-                # Resize image to fit within self.video_frame_size, maintaining aspect ratio
-                pil_image_for_frame.thumbnail(self.video_frame_size, Image.Resampling.LANCZOS)
-
-                # Create a background canvas of the exact video_frame_size (e.g., 1280x720)
-                # This will letterbox/pillarbox the image if its aspect ratio differs from video_frame_size
-                background_canvas = Image.new('RGB', self.video_frame_size, (0,0,0)) # Black background
-                paste_x = (self.video_frame_size[0] - pil_image_for_frame.width) // 2
-                paste_y = (self.video_frame_size[1] - pil_image_for_frame.height) // 2
-                background_canvas.paste(pil_image_for_frame, (paste_x, paste_y))
-                
-                frame_np = np.array(background_canvas) # Convert final PIL image to numpy array
-                
-                # Base image clip
+                frame_np = np.array(canvas)
                 img_clip = ImageClip(frame_np).set_duration(duration_per_image)
 
-                # Ken Burns Effect (Simple Zoom In)
-                end_scale = 1.08 # Zoom to 108% of original size by the end
-                img_clip = img_clip.fx(vfx.resize, lambda t: 1 + (end_scale - 1) * (t / duration_per_image))
-                img_clip = img_clip.set_position('center') # Keep centered during zoom
+                # Ken Burns: zoom from 100% to 110%
+                img_clip = img_clip.fx(vfx.resize, lambda t: 1 + 0.1 * (t / duration_per_image))
+                img_clip = img_clip.set_position('center')
 
                 # Text Overlay
-                overlay_text = f"Scene {scene_num}: {key_action}"
-                # Ensure font path is used if 'Arial' isn't found by ImageMagick/MoviePy
-                # For TextClip, moviepy relies on ImageMagick which has its own font discovery.
-                # Using a common font name like 'Arial' is often okay if mscorefonts are installed.
-                # If not, you might need to point to self.font_path_in_container
-                # Check if ImageMagick is installed in Docker, moviepy might need it for TextClip.
-                # `apt-get install imagemagick` in Dockerfile if TextClip has issues.
-                txt_clip = TextClip(
-                    overlay_text, 
-                    fontsize=self.video_overlay_font_size, 
-                    color=self.video_overlay_font_color,
-                    font=self.video_overlay_font, # Or self.font_path_in_container
-                    bg_color='rgba(0,0,0,0.6)', 
-                    size=(self.video_frame_size[0] * 0.9, None), # Width 90% of video, height auto
-                    method='caption', 
-                    align='West',
-                    kerning=-1 
-                ).set_duration(duration_per_image - 0.5).set_start(0.25) # Start after 0.25s, end 0.25s before clip end
-                
-                txt_clip = txt_clip.set_position(('center', 0.88), relative=True) # Position near bottom
-
-                video_with_text_overlay = CompositeVideoClip([img_clip, txt_clip], size=self.video_frame_size)
-                processed_clips.append(video_with_text_overlay)
-
-            except Exception as e_clip:
-                print(f"Error processing image/creating clip for {img_path}: {e_clip}. Skipping.")
+                if key_action:
+                    overlay_text = f"Scene {scene_num}\n{key_action}"
+                    txt_clip = TextClip(overlay_text, fontsize=self.video_overlay_font_size, 
+                                        color=self.video_overlay_font_color, font=self.video_overlay_font,
+                                        bg_color='rgba(0,0,0,0.7)', method='caption', align='West',
+                                        size=(self.video_frame_size[0]*0.85, None), kerning=-1, stroke_color='black', stroke_width=0.5
+                                       ).set_duration(duration_per_image - 1.0).set_start(0.5) # Show for duration-1s, slight delay
+                    txt_clip = txt_clip.set_position(('center', 0.88), relative=True)
+                    final_scene_clip = CompositeVideoClip([img_clip, txt_clip], size=self.video_frame_size)
+                else:
+                    final_scene_clip = img_clip
+                processed_clips.append(final_scene_clip)
+            except Exception as e: print(f"Error processing clip for {img_path}: {e}. Skipping.")
+        
+        if not processed_clips: print("No clips processed for video."); return None
+        
+        transition_duration = 0.75 # Crossfade duration
+        final_video = concatenate_videoclips(processed_clips, padding=-transition_duration, method="compose")
+        if final_video.duration > transition_duration*2: # Ensure enough duration for fades
+            final_video = final_video.fx(vfx.fadein, transition_duration).fx(vfx.fadeout, transition_duration)
         
-        if not processed_clips:
-            print("No clips could be processed for the video.")
-            return None
-            
-        # Concatenate with crossfade (0.5s)
-        final_video_clip = concatenate_videoclips(processed_clips, padding=-0.5, method="compose")
-        # Add fade in/out for the whole video
-        if final_video_clip.duration > 1: # Ensure video is long enough for fades
-            final_video_clip = final_video_clip.fx(vfx.fadein, 0.5).fx(vfx.fadeout, 0.5)
-
         output_path = os.path.join(self.output_dir, output_filename)
-        print(f"Writing final video to: {output_path}")
         try:
-            final_video_clip.write_videofile(
-                output_path, fps=fps, codec='libx264', audio_codec='aac',
-                temp_audiofile=os.path.join(self.output_dir, f'temp-audio-{os.urandom(4).hex()}.m4a'), 
-                remove_temp=True, threads=os.cpu_count() or 2, logger='bar'
-            )
-            print(f"Video successfully created: {output_path}")
-            return output_path
-        except Exception as e:
-            print(f"Error writing final video file: {e}")
-            return None
-        finally: 
-            for clip_item in processed_clips: 
-                if hasattr(clip_item, 'close'): clip_item.close()
-            if hasattr(final_video_clip, 'close'): final_video_clip.close()
+            final_video.write_videofile(output_path, fps=fps, codec='libx264', preset='medium', audio_codec='aac',
+                                        temp_audiofile=os.path.join(self.output_dir, f'temp-audio-{os.urandom(4).hex()}.m4a'), 
+                                        remove_temp=True, threads=os.cpu_count() or 2, logger='bar')
+            print(f"Video created: {output_path}"); return output_path
+        except Exception as e: print(f"Error writing video file: {e}"); return None
+        finally:
+            for clip in processed_clips: clip.close()
+            if hasattr(final_video, 'close'): final_video.close()