Update core/visual_engine.py

core/visual_engine.py

@@ -1,175 +1,218 @@
 # core/visual_engine.py
-import tempfile
-import logging
 from PIL import Image, ImageDraw, ImageFont
 from moviepy.editor import ImageClip, concatenate_videoclips
 import os
-
-# Set up logging
-logger = logging.getLogger(__name__)
-logging.basicConfig(level=logging.INFO)
+# For future AI image generation - uncomment and add to requirements.txt when ready
+# import torch
+# from diffusers import StableDiffusionPipeline 
+# import requests # For API-based image generation
 
 class VisualEngine:
-    def __init__(self, output_dir=None):
-        self.output_dir = output_dir or self._create_temp_output_dir()
-        logger.info(f"Using output directory: {self.output_dir}")
+    def __init__(self, output_dir="temp_generated_media"):
+        self.output_dir = output_dir
         os.makedirs(self.output_dir, exist_ok=True)
         
-        # Font configuration
+        # --- Font Setup for Placeholders ---
+        self.font_filename = "arial.ttf" # Or your chosen font (e.g., DejaVuSans.ttf)
+        self.font_path_in_container = f"/usr/local/share/fonts/truetype/mycustomfonts/{self.font_filename}"
         self.font_size_pil = 24
-        self.font = self._load_system_font()
         
-        if self.font:
-            logger.info(f"Using font: {self.font.path if hasattr(self.font, 'path') else 'default'}")
-        else:
-            logger.warning("Could not load any suitable font. Falling back to default font.")
+        try:
+            self.font = ImageFont.truetype(self.font_path_in_container, self.font_size_pil)
+            print(f"Successfully loaded font: {self.font_path_in_container} for placeholders.")
+        except IOError:
+            print(f"Warning: Could not load font from '{self.font_path_in_container}'. "
+                  f"Placeholders will use default font.")
             self.font = ImageFont.load_default()
             self.font_size_pil = 11
 
-    def _create_temp_output_dir(self):
-        """Create a temporary directory with appropriate permissions"""
-        temp_dir = tempfile.mkdtemp(prefix="cinegen_media_")
-        os.chmod(temp_dir, 0o775)
-        return temp_dir
-
-    def _load_system_font(self):
-        """Load the best available system font"""
-        font_names = [
-            "DejaVuSans.ttf",       # Common in Linux
-            "FreeSans.ttf",          # From fonts-freefont-ttf
-            "LiberationSans-Regular.ttf",  # Red Hat font
-            "Arial.ttf",             # Sometimes available
-            "Vera.ttf"               # Bitstream Vera
-        ]
-        
-        # Try to load each font in order
-        for font_name in font_names:
-            try:
-                return ImageFont.truetype(font_name, self.font_size_pil)
-            except IOError:
-                continue
-        
-        # Try system default sans-serif as last resort
-        try:
-            return ImageFont.truetype("sans-serif", self.font_size_pil)
-        except:
-            return None
+        # --- AI Image Generation Model/Client (Conceptual) ---
+        # self.image_generation_pipe = None # For diffusers
+        # self.image_api_client = None # For API clients
+        # self.USE_AI_IMAGE_GENERATION = False # Set to True when implemented
+
+        # Example: Initialize Stable Diffusion (uncomment and configure when ready)
+        # if self.USE_AI_IMAGE_GENERATION and torch.cuda.is_available():
+        #     try:
+        #         print("Attempting to load Stable Diffusion model...")
+        #         self.image_generation_pipe = StableDiffusionPipeline.from_pretrained(
+        #             "runwayml/stable-diffusion-v1-5", 
+        #             torch_dtype=torch.float16,
+        #             # use_safetensors=True # If available for the model
+        #         )
+        #         self.image_generation_pipe.to("cuda")
+        #         print("Stable Diffusion model loaded successfully on GPU.")
+        #     except Exception as e:
+        #         print(f"Error loading Stable Diffusion model: {e}. Will use placeholders.")
+        #         self.USE_AI_IMAGE_GENERATION = False # Fallback
+        # elif self.USE_AI_IMAGE_GENERATION:
+        #     print("CUDA not available. AI Image generation (Stable Diffusion) disabled. Using placeholders.")
+        #     self.USE_AI_IMAGE_GENERATION = False
 
-    def _get_text_dimensions(self, text_content, font_obj):
-        """Get text dimensions with modern Pillow methods"""
-        if not text_content:
-            return 0, self.font_size_pil
 
+    def _get_text_dimensions(self, text_content, font_obj):
+        if text_content == "" or text_content is None:
+            return 0, self.font_size_pil 
         try:
             if hasattr(font_obj, 'getbbox'):
                 bbox = font_obj.getbbox(text_content)
-                return bbox[2] - bbox[0], bbox[3] - bbox[1]
+                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'):
-                return font_obj.getsize(text_content)
+                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:
-            logger.warning(f"Error measuring text: {str(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)
+
+
+    def _create_placeholder_image_content(self, text_description, filename, size=(1024, 576)): # Common 16:9 aspect
+        # This is the actual placeholder drawing logic, kept separate
+        img = Image.new('RGB', size, color=(30, 30, 60))
+        draw = ImageDraw.Draw(img)
+        padding = 30 # Reduced padding for smaller image
+        max_text_width = size[0] - (2 * padding)
+        lines = []
+        if not text_description: text_description = "(No description provided 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 + " "
+            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)")
         
-        # Fallback calculation
-        avg_char_width = self.font_size_pil * 0.6
-        return int(len(text_content) * avg_char_width), self.font_size_pil
+        _, 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: # Limit lines displayed on placeholder if too many
+                draw.text(xy=(float(padding), y_text), text="...", fill=(200, 200, 130), font=self.font)
+                break
+            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
 
-    def create_placeholder_image(self, text_description, filename, size=(1280, 720)):
-        """Create placeholder image with wrapped text"""
+        filepath = os.path.join(self.output_dir, filename)
         try:
-            img = Image.new('RGB', size, color=(30, 30, 60))
-            draw = ImageDraw.Draw(img)
-            
-            if not text_description:
-                text_description = "No description provided"
-                
-            # Create text with wrapping
-            lines = self._wrap_text(text_description, size[0] - 80)
-            
-            # Calculate vertical position to center text
-            _, line_height = self._get_text_dimensions("Tg", self.font)
-            total_height = len(lines) * line_height * 1.3
-            y_pos = max(40, (size[1] - total_height) / 2)
-            
-            # Draw each line
-            for line in lines:
-                line_width, _ = self._get_text_dimensions(line, self.font)
-                x_pos = (size[0] - line_width) / 2
-                draw.text((x_pos, y_pos), line, fill=(220, 220, 150), font=self.font)
-                y_pos += line_height * 1.3
-                
-            # Save to output directory
-            output_path = os.path.join(self.output_dir, filename)
-            img.save(output_path)
-            return output_path
-            
+            img.save(filepath)
         except Exception as e:
-            logger.error(f"Error creating placeholder image: {str(e)}")
+            print(f"Error saving placeholder image {filepath}: {e}")
             return None
+        return filepath
 
-    def _wrap_text(self, text, max_width):
-        """Wrap text to fit within specified width"""
-        if not text:
-            return ["(No text)"]
-            
-        words = text.split()
-        lines = []
-        current_line = []
-        
-        for word in words:
-            test_line = ' '.join(current_line + [word])
-            test_width, _ = self._get_text_dimensions(test_line, self.font)
-            
-            if test_width <= max_width:
-                current_line.append(word)
-            else:
-                if current_line:
-                    lines.append(' '.join(current_line))
-                current_line = [word]
-                
-                # Handle very long words
-                if self._get_text_dimensions(word, self.font)[0] > max_width:
-                    while current_line and self._get_text_dimensions(''.join(current_line), self.font)[0] > max_width:
-                        current_line[0] = current_line[0][:-1]
+
+    def generate_image_visual(self, image_prompt_text, scene_identifier_filename):
+        """
+        Generates an image visual. Tries AI generation if enabled, 
+        otherwise falls back to a placeholder.
+        image_prompt_text: The detailed prompt from Gemini for image generation.
+        scene_identifier_filename: A unique filename for this image (e.g., "scene_1_visual.png").
+        """
+        filepath = os.path.join(self.output_dir, scene_identifier_filename)
+
+        # --- UNCOMMENT AND IMPLEMENT ONE OF THESE SECTIONS WHEN READY ---
+        # if self.USE_AI_IMAGE_GENERATION and self.image_generation_pipe: # Example for Diffusers
+        #     try:
+        #         print(f"Generating AI image (Diffusers) for: {image_prompt_text[:100]}...")
+        #         # Add parameters like negative_prompt, guidance_scale, num_inference_steps
+        #         ai_image = self.image_generation_pipe(image_prompt_text).images[0]
+        #         ai_image = ai_image.resize((1024, 576)) # Resize to a standard display size
+        #         ai_image.save(filepath)
+        #         print(f"AI Image (Diffusers) saved: {filepath}")
+        #         return filepath
+        #     except Exception as e:
+        #         print(f"Error generating AI image with Diffusers: {e}. Creating placeholder.")
+        #         return self._create_placeholder_image_content(image_prompt_text, scene_identifier_filename)
+
+        # elif self.USE_AI_IMAGE_GENERATION and self.image_api_client: # Example for an API
+        #     try:
+        #         print(f"Generating AI image (API) for: {image_prompt_text[:100]}...")
+        #         # --- Replace with your actual API call logic ---
+        #         # response = self.image_api_client.generate(prompt=image_prompt_text, ...) 
+        #         # image_data = response.get_image_data() 
+        #         # with open(filepath, 'wb') as f:
+        #         #    f.write(image_data)
+        #         # --- End of API call logic ---
+        #         print(f"AI Image (API) saved: {filepath}")
+        #         return filepath
+        #     except Exception as e:
+        #         print(f"Error generating AI image with API: {e}. Creating placeholder.")
+        #         return self._create_placeholder_image_content(image_prompt_text, scene_identifier_filename)
         
-        if current_line:
-            lines.append(' '.join(current_line))
-            
-        return lines or ["(Text rendering error)"]
+        # else: # Fallback to placeholder if AI generation is not enabled or failed initialization
+        print(f"AI image generation not enabled/ready. Creating placeholder for: {image_prompt_text[:70]}...")
+        return self._create_placeholder_image_content(image_prompt_text, scene_identifier_filename)
+
 
     def create_video_from_images(self, image_paths, output_filename="final_video.mp4", fps=1, duration_per_image=3):
-        """Create video from sequence of images"""
         if not image_paths:
-            logger.error("No images provided for video creation")
+            print("No images provided to create video.")
             return None
-            
-        valid_paths = [p for p in image_paths if p and os.path.exists(p)]
-        if not valid_paths:
-            logger.error("No valid image paths found")
+        valid_image_paths = [p for p in image_paths if p and os.path.exists(p)]
+        if not valid_image_paths:
+            print("No valid image paths found to create video.")
             return None
-            
+        print(f"Attempting to create video from {len(valid_image_paths)} images.")
+
         try:
-            clips = [ImageClip(img_path).set_duration(duration_per_image) for img_path in valid_paths]
-            video = concatenate_videoclips(clips, method="compose")
+            clips = []
+            for m_path in valid_image_paths:
+                try:
+                    # Ensure image is a reasonable size for video, MoviePy can struggle with huge images
+                    img_for_clip = Image.open(m_path)
+                    if img_for_clip.width > 1920 or img_for_clip.height > 1080:
+                        img_for_clip.thumbnail((1920, 1080)) # Resize if too large
+                        # Save back to a temp path or directly use the PIL image object if ImageClip supports it well
+                        # For simplicity, let's assume ImageClip handles PIL Image objects
+                    
+                    clip = ImageClip(m_path).set_duration(duration_per_image) # Using path directly for now
+                    # clip = ImageClip(np.array(img_for_clip)).set_duration(duration_per_image) # If using PIL image
+                    clips.append(clip)
+                except Exception as e_clip:
+                    print(f"Error creating ImageClip for {m_path}: {e_clip}. Skipping.")
+            
+            if not clips:
+                print("Could not create any ImageClips.")
+                return None
+                
+            video_clip = concatenate_videoclips(clips, method="compose")
             output_path = os.path.join(self.output_dir, output_filename)
             
-            video.write_videofile(
-                output_path,
-                fps=fps,
-                codec='libx264',
-                audio_codec='aac',
-                temp_audiofile=os.path.join(self.output_dir, 'temp_audio.m4a'),
-                remove_temp=True,
-                threads=os.cpu_count() or 2,
-                logger=None
+            print(f"Writing video to: {output_path}")
+            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'
             )
-            
-            # Clean up resources
-            for clip in clips:
-                clip.close()
-            video.close()
-            
+            for clip_to_close in clips: clip_to_close.close()
+            if hasattr(video_clip, 'close'): video_clip.close()
+            print(f"Video successfully created: {output_path}")
             return output_path
-            
         except Exception as e:
-            logger.error(f"Video creation failed: {str(e)}")
+            print(f"Error during video creation: {e}")
             return None