Update engine.py

engine.py

@@ -1,70 +1,105 @@
 import numpy as np
 from rembg import remove
-from PIL import Image, ImageFilter
+from PIL import Image, ImageFilter, ImageOps, ImageColor
 from moviepy.editor import ImageClip, CompositeVideoClip
 import os
-import uuid
+import math # Switched from numpy to math for safer scalar operations
 
 class IconAnimator:
     def __init__(self, input_path, output_path):
         self.input_path = input_path
         self.output_path = output_path
         
-    def process_image(self):
+    def hex_to_rgb(self, hex_color):
+        return ImageColor.getcolor(hex_color, "RGB")
+
+    def process_image(self, icon_color_hex="#FFFFFF"):
         # 1. Remove Background
         with open(self.input_path, 'rb') as i:
             input_data = i.read()
             output_data = remove(input_data)
         
-        # Save temp byte stream to PIL Image
+        # Load into PIL
         from io import BytesIO
         img = Image.open(BytesIO(output_data)).convert("RGBA")
         
-        # 2. Make Icon White (Fill Effect)
+        # 2. Recolor the Icon (Fill non-transparent pixels with chosen color)
         r, g, b, a = img.split()
-        white_bg = Image.new("RGB", img.size, (255, 255, 255))
-        img_white = Image.merge("RGBA", (*white_bg.split(), a))
         
-        return img_white
+        # 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):
-        # Add padding to canvas so glow doesn't get cut off
-        padding = 50
+    def create_glow_layer(self, img, blur_radius, color_hex):
+        # Create padding
+        padding = 60
         new_size = (img.width + padding*2, img.height + padding*2)
         canvas = Image.new("RGBA", new_size, (0, 0, 0, 0))
         canvas.paste(img, (padding, padding), img)
         
-        # Blur
-        glow = canvas.filter(ImageFilter.GaussianBlur(radius=blur_radius))
+        # Extract Alpha to create the glow shape
+        r, g, b, a = canvas.split()
+        
+        # Create solid color for glow
+        target_r, target_g, target_b = self.hex_to_rgb(color_hex)
+        glow_base = Image.new("RGB", new_size, (target_r, target_g, target_b))
+        glow_shape = Image.merge("RGBA", (*glow_base.split(), a))
+        
+        # Apply Blur
+        glow = glow_shape.filter(ImageFilter.GaussianBlur(radius=blur_radius))
         return glow, padding
 
-    def generate_animation(self):
-        # Prepare Images
-        base_pil = self.process_image()
+    def generate_animation(self, icon_color="#FFFFFF", glow_color="#00ffc8", speed=2.0, intensity=1.0):
+        # 1. Prepare Base Image
+        base_pil = self.process_image(icon_color)
         
-        # Create Glows (Layering approach)
-        glow_small, pad = self.create_glow_layer(base_pil, blur_radius=8) 
-        glow_large, _ = self.create_glow_layer(base_pil, blur_radius=25) 
+        # 2. Create Glow Layers
+        # Small intense glow (inner)
+        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)
 
-        # Duration of animation loop
-        duration = 2.0
+        # 3. Create 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)
+        
+        def pulse_small(t):
+            # Oscillates between 0.6 and 1.0 (modified by intensity)
+            val = 0.6 + 0.4 * math.sin(2 * math.pi * t / speed)
+            return min(max(val * intensity, 0), 1)
 
-        # Create Clips
-        base_clip = ImageClip(np.array(base_pil)).set_duration(duration).set_position("center")
-        glow_s_clip = ImageClip(np.array(glow_small)).set_duration(duration)
-        glow_l_clip = ImageClip(np.array(glow_large)).set_duration(duration)
+        def pulse_large(t):
+            # Oscillates between 0.3 and 0.7 (modified by intensity)
+            val = 0.4 + 0.3 * math.sin(2 * math.pi * t / speed)
+            return min(max(val * intensity, 0), 1)
 
-        # Pulse Logic (Sine Wave)
-        # Opacity oscillates between 0.6 and 1.0
-        glow_s_clip = glow_s_clip.set_opacity(lambda t: 0.6 + 0.4 * np.sin(2 * np.pi * t / duration))
-        glow_l_clip = glow_l_clip.set_opacity(lambda t: 0.4 + 0.2 * np.sin(2 * np.pi * t / duration))
+        glow_s_clip = glow_s_clip.set_opacity(pulse_small)
+        glow_l_clip = glow_l_clip.set_opacity(pulse_large)
 
-        # Composite
-        final = CompositeVideoClip([glow_l_clip, glow_s_clip, base_clip], size=(final_w, final_h))
+        # 5. Composite
+        final = CompositeVideoClip([
+            glow_l_clip,   # Background atmosphere
+            glow_s_clip,   # Rim light
+            base_clip      # Sharp Icon
+        ], size=(final_w, final_h))
 
-        # Export (Optimized for Web)
+        # 6. Export
         final.write_gif(self.output_path, fps=15, program='ffmpeg', opt='OptimizeTransparency')
         return self.output_path