Update video_assembler.py

video_assembler.py

@@ -9,30 +9,37 @@ import tempfile
 import numpy as np
 from PIL import Image, ImageDraw, ImageFont
 from typing import List, Dict, Optional, Tuple
-import imageio
 
 
 class VideoAssembler:
     """Assembles frames into a polished timelapse video."""
 
     def __init__(self):
-        self.font = self._load_font()
+        self.font_cache = {}
+
+    def _load_font(self, size: int = 32) -> ImageFont.FreeTypeFont:
+        """Load a font with caching and fallbacks."""
+        if size in self.font_cache:
+            return self.font_cache[size]
 
-    @staticmethod
-    def _load_font(size: int = 32) -> ImageFont.FreeTypeFont:
-        """Load a font, with fallbacks."""
         font_paths = [
             "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
+            "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
             "/usr/share/fonts/truetype/liberation/LiberationSans-Bold.ttf",
             "/usr/share/fonts/TTF/DejaVuSans-Bold.ttf",
-            "C:/Windows/Fonts/arial.ttf",
         ]
         for path in font_paths:
-            try:
-                return ImageFont.truetype(path, size)
-            except (IOError, OSError):
-                continue
-        return ImageFont.load_default()
+            if os.path.exists(path):
+                try:
+                    font = ImageFont.truetype(path, size)
+                    self.font_cache[size] = font
+                    return font
+                except Exception:
+                    continue
+
+        font = ImageFont.load_default()
+        self.font_cache[size] = font
+        return font
 
     def add_text_overlay(
         self,
@@ -48,15 +55,16 @@ class VideoAssembler:
         img = image.copy().convert("RGBA")
         overlay = Image.new("RGBA", img.size, (0, 0, 0, 0))
         draw = ImageDraw.Draw(overlay)
-
         font = self._load_font(font_size)
 
-        # Calculate text size
-        bbox = draw.textbbox((0, 0), text, font=font)
-        text_w = bbox[2] - bbox[0]
-        text_h = bbox[3] - bbox[1]
+        try:
+            bbox = draw.textbbox((0, 0), text, font=font)
+            text_w = bbox[2] - bbox[0]
+            text_h = bbox[3] - bbox[1]
+        except Exception:
+            text_w = len(text) * font_size // 2
+            text_h = font_size
 
-        # Calculate position
         img_w, img_h = img.size
         if position == "top":
             x = (img_w - text_w) // 2
@@ -70,18 +78,15 @@ class VideoAssembler:
         elif position == "top-right":
             x = img_w - text_w - margin
             y = margin
-        else:  # center
+        else:
             x = (img_w - text_w) // 2
             y = (img_h - text_h) // 2
 
-        # Draw background rectangle
         padding = 8
         draw.rectangle(
             [x - padding, y - padding, x + text_w + padding, y + text_h + padding],
             fill=bg_color,
         )
-
-        # Draw text
         draw.text((x, y), text, fill=text_color, font=font)
 
         result = Image.alpha_composite(img, overlay)
@@ -100,11 +105,10 @@ class VideoAssembler:
         draw = ImageDraw.Draw(img)
         w, h = img.size
 
-        # Background bar
         draw.rectangle([0, h - bar_height, w, h], fill=bg_color)
-        # Progress bar
-        bar_width = int(w * progress)
-        draw.rectangle([0, h - bar_height, bar_width, h], fill=bar_color)
+        bar_width = int(w * min(progress, 1.0))
+        if bar_width > 0:
+            draw.rectangle([0, h - bar_height, bar_width, h], fill=bar_color)
 
         return img
 
@@ -118,34 +122,33 @@ class VideoAssembler:
         add_progress: bool = True,
         add_bookend_labels: bool = True,
     ) -> List[np.ndarray]:
-        """
-        Prepare frames for video export.
-        Each panel image is repeated for hold_seconds duration.
-        """
+        """Prepare frames for video export."""
         frames_per_panel = max(1, int(fps * hold_seconds))
         all_frames = []
 
         for i, img in enumerate(images):
             frame = img.copy()
 
-            # Add text label
             if add_labels and labels and i < len(labels) and labels[i]:
-                frame = self.add_text_overlay(frame, labels[i], position="top-left", font_size=24)
+                frame = self.add_text_overlay(
+                    frame, labels[i], position="top-left", font_size=24
+                )
 
-            # Add BEFORE / AFTER labels
             if add_bookend_labels:
                 if i == 0:
-                    frame = self.add_text_overlay(frame, "BEFORE", position="bottom", font_size=40)
+                    frame = self.add_text_overlay(
+                        frame, "BEFORE", position="bottom", font_size=40
+                    )
                 elif i == len(images) - 1:
-                    frame = self.add_text_overlay(frame, "AFTER", position="bottom", font_size=40)
+                    frame = self.add_text_overlay(
+                        frame, "AFTER", position="bottom", font_size=40
+                    )
 
-            # Add progress bar
             if add_progress:
                 progress = (i + 1) / len(images)
                 frame = self.add_progress_bar(frame, progress)
 
-            # Repeat frame for hold duration
-            frame_array = np.array(frame)
+            frame_array = np.array(frame.convert("RGB"))
             for _ in range(frames_per_panel):
                 all_frames.append(frame_array)
 
@@ -164,16 +167,17 @@ class VideoAssembler:
         fade_in_frames: int = 15,
         fade_out_frames: int = 15,
     ) -> str:
-        """
-        Create a complete video from panel images.
-        
-        Returns: path to the output video file.
-        """
+        """Create a complete video from panel images."""
+        import imageio
+
         if output_path is None:
-            output_path = os.path.join(tempfile.gettempdir(), "timelapse_output.mp4")
+            output_path = os.path.join(
+                tempfile.gettempdir(), "timelapse_output.mp4"
+            )
 
         frames = self.prepare_frames(
-            images, fps, hold_seconds, add_labels, labels, add_progress, add_bookend_labels
+            images, fps, hold_seconds, add_labels, labels,
+            add_progress, add_bookend_labels,
         )
 
         if not frames:
@@ -181,16 +185,16 @@ class VideoAssembler:
 
         # Apply fade in
         for i in range(min(fade_in_frames, len(frames))):
-            alpha = i / fade_in_frames
+            alpha = i / max(fade_in_frames, 1)
             frames[i] = (frames[i].astype(np.float32) * alpha).astype(np.uint8)
 
         # Apply fade out
         for i in range(min(fade_out_frames, len(frames))):
             idx = len(frames) - 1 - i
-            alpha = i / fade_out_frames
+            alpha = i / max(fade_out_frames, 1)
             frames[idx] = (frames[idx].astype(np.float32) * alpha).astype(np.uint8)
 
-        # Write video using imageio
+        # Write video
         writer = imageio.get_writer(
             output_path,
             fps=fps,
@@ -212,9 +216,9 @@ class VideoAssembler:
         audio_path: str,
         output_path: Optional[str] = None,
     ) -> str:
-        """Add background audio/music to the video using moviepy."""
+        """Add background audio to the video using moviepy."""
         if output_path is None:
-            output_path = video_path.replace(".mp4", "_with_audio.mp4")
+            output_path = video_path.replace(".mp4", "_audio.mp4")
 
         try:
             from moviepy.editor import VideoFileClip, AudioFileClip
@@ -222,57 +226,44 @@ class VideoAssembler:
             video = VideoFileClip(video_path)
             audio = AudioFileClip(audio_path)
 
-            # Loop or trim audio to match video duration
             if audio.duration < video.duration:
-                # Loop audio
                 from moviepy.editor import concatenate_audioclips
-                loops_needed = int(video.duration / audio.duration) + 1
-                audio = concatenate_audioclips([audio] * loops_needed)
+                loops = int(video.duration / audio.duration) + 1
+                audio = concatenate_audioclips([audio] * loops)
 
             audio = audio.subclip(0, video.duration)
-
-            # Fade audio in and out
-            audio = audio.audio_fadein(2).audio_fadeout(2)
             final = video.set_audio(audio)
-            final.write_videofile(output_path, codec="libx264", audio_codec="aac", logger=None)
-
+            final.write_videofile(
+                output_path, codec="libx264",
+                audio_codec="aac", logger=None,
+            )
             video.close()
-            audio.close()
             return output_path
 
-        except ImportError:
-            print("moviepy not available for audio mixing. Returning video without audio.")
-            return video_path
         except Exception as e:
-            print(f"Audio mixing failed: {e}. Returning video without audio.")
+            print(f"Audio mixing failed: {e}")
             return video_path
 
     def create_comparison_image(
         self,
         first: Image.Image,
         last: Image.Image,
-        orientation: str = "horizontal",
         gap: int = 4,
     ) -> Image.Image:
-        """Create a side-by-side or top-bottom comparison image."""
+        """Create side-by-side comparison image."""
         w, h = first.size
-
-        if orientation == "horizontal":
-            comp = Image.new("RGB", (w * 2 + gap, h), (30, 30, 30))
-            comp.paste(first, (0, 0))
-            comp.paste(last, (w + gap, 0))
-
-            # Add labels
-            comp = self.add_text_overlay(
-                comp, "BEFORE", position="top-left", font_size=28
-            )
-            draw = ImageDraw.Draw(comp)
-            font = self._load_font(28)
+        comp = Image.new("RGB", (w * 2 + gap, h), (30, 30, 30))
+        comp.paste(first.resize((w, h), Image.LANCZOS), (0, 0))
+        comp.paste(last.resize((w, h), Image.LANCZOS), (w + gap, 0))
+
+        comp = self.add_text_overlay(comp, "BEFORE", position="top-left", font_size=28)
+        # Add AFTER on right side
+        draw = ImageDraw.Draw(comp)
+        font = self._load_font(28)
+        try:
             draw.text((w + gap + 10, 10), "AFTER", fill=(255, 255, 255), font=font)
-        else:
-            comp = Image.new("RGB", (w, h * 2 + gap), (30, 30, 30))
-            comp.paste(first, (0, 0))
-            comp.paste(last, (0, h + gap))
+        except Exception:
+            pass
 
         return comp
 
@@ -283,17 +274,16 @@ class VideoAssembler:
         duration_per_frame: int = 500,
         loop: int = 0,
     ) -> str:
-        """Create an animated GIF from the panels."""
+        """Create an animated GIF."""
         if output_path is None:
             output_path = os.path.join(tempfile.gettempdir(), "timelapse.gif")
 
-        # Resize for GIF (smaller file size)
         max_size = (480, 480)
         resized = []
         for img in images:
             r = img.copy()
             r.thumbnail(max_size, Image.LANCZOS)
-            resized.append(r)
+            resized.append(r.convert("RGB"))
 
         resized[0].save(
             output_path,