Update engine.py

engine.py

@@ -1,9 +1,9 @@
 import numpy as np
 from rembg import remove
-from PIL import Image, ImageFilter, ImageOps, ImageColor
+from PIL import Image, ImageFilter, ImageColor
 from moviepy.editor import ImageClip, CompositeVideoClip
 import os
-import math # Switched from numpy to math for safer scalar operations
+import math
 
 class IconAnimator:
     def __init__(self, input_path, output_path):
@@ -11,7 +11,11 @@ class IconAnimator:
         self.output_path = output_path
         
     def hex_to_rgb(self, hex_color):
-        return ImageColor.getcolor(hex_color, "RGB")
+        # Converts hex string (e.g., "#00ffc8") to RGB tuple
+        try:
+            return ImageColor.getcolor(hex_color, "RGB")
+        except:
+            return (255, 255, 255) # Fallback to white
 
     def process_image(self, icon_color_hex="#FFFFFF"):
         # 1. Remove Background
@@ -23,22 +27,16 @@ class IconAnimator:
         from io import BytesIO
         img = Image.open(BytesIO(output_data)).convert("RGBA")
         
-        # 2. Recolor the Icon (Fill non-transparent pixels with chosen color)
+        # 2. Recolor the Icon Body
         r, g, b, a = img.split()
-        
-        # Get target RGB
         target_r, target_g, target_b = self.hex_to_rgb(icon_color_hex)
-        
-        # Create solid color block
         solid_color = Image.new("RGB", img.size, (target_r, target_g, target_b))
-        
-        # Merge using the original alpha channel as a mask
         img_colored = Image.merge("RGBA", (*solid_color.split(), a))
         
         return img_colored
 
     def create_glow_layer(self, img, blur_radius, color_hex):
-        # Create padding
+        # Create padding so glow isn't cut off
         padding = 60
         new_size = (img.width + padding*2, img.height + padding*2)
         canvas = Image.new("RGBA", new_size, (0, 0, 0, 0))
@@ -60,44 +58,41 @@ class IconAnimator:
         # 1. Prepare Base Image
         base_pil = self.process_image(icon_color)
         
-        # 2. Create Glow Layers
-        # Small intense glow (inner)
+        # 2. Create Glow Layers (Inner and Outer)
         glow_small, pad = self.create_glow_layer(base_pil, blur_radius=10, color_hex=glow_color) 
-        # Large soft glow (outer)
         glow_large, _ = self.create_glow_layer(base_pil, blur_radius=30, color_hex=glow_color) 
         
         w, h = base_pil.size
         final_w, final_h = w + (pad*2), h + (pad*2)
 
-        # 3. Create Clips
+        # 3. Create MoviePy Clips
         # Center the base icon
         base_clip = ImageClip(np.array(base_pil)).set_duration(speed).set_position("center")
-        
         glow_s_clip = ImageClip(np.array(glow_small)).set_duration(speed)
         glow_l_clip = ImageClip(np.array(glow_large)).set_duration(speed)
 
-        # 4. Apply Animation (Pulse)
-        # We use math.sin instead of np.sin to prevent the "function * float" error
-        # Intensity scales the opacity (0.0 to 1.0)
+        # 4. Apply Animation (THE FIX)
+        # Instead of set_opacity(func), we modify the mask directly using fl()
         
         def pulse_small(t):
-            # Oscillates between 0.6 and 1.0 (modified by intensity)
+            # Oscillates between 0.6 and 1.0
             val = 0.6 + 0.4 * math.sin(2 * math.pi * t / speed)
-            return min(max(val * intensity, 0), 1)
+            return max(0.0, min(val * intensity, 1.0))
 
         def pulse_large(t):
-            # Oscillates between 0.3 and 0.7 (modified by intensity)
+            # Oscillates between 0.4 and 0.7
             val = 0.4 + 0.3 * math.sin(2 * math.pi * t / speed)
-            return min(max(val * intensity, 0), 1)
+            return max(0.0, min(val * intensity, 1.0))
 
-        glow_s_clip = glow_s_clip.set_opacity(pulse_small)
-        glow_l_clip = glow_l_clip.set_opacity(pulse_large)
+        # We multiply the existing mask frame (gf(t)) by the pulse value
+        glow_s_clip.mask = glow_s_clip.mask.fl(lambda gf, t: gf(t) * pulse_small(t))
+        glow_l_clip.mask = glow_l_clip.mask.fl(lambda gf, t: gf(t) * pulse_large(t))
 
         # 5. Composite
         final = CompositeVideoClip([
-            glow_l_clip,   # Background atmosphere
-            glow_s_clip,   # Rim light
-            base_clip      # Sharp Icon
+            glow_l_clip,   # Outer glow (Background)
+            glow_s_clip,   # Inner glow (Rim light)
+            base_clip      # Sharp Icon (Foreground)
         ], size=(final_w, final_h))
 
         # 6. Export