Update app.py

app.py

@@ -3,41 +3,106 @@ import numpy as np
 import gradio as gr
 import os
 import subprocess
+import time
 from pathlib import Path
 
-# ... [Keep apply_anime_filter and get_brush_mask from previous response] ...
+def apply_anime_filter(img, variant):
+    try:
+        # Base smoothing using bilateral filter
+        bilateral = cv2.bilateralFilter(img, 9, 75, 75)
+        if variant == "Vivid Modern":
+            return cv2.convertScaleAbs(bilateral, alpha=1.3, beta=10)
+        elif variant == "90s Retro":
+            retro = cv2.convertScaleAbs(bilateral, alpha=0.9, beta=5)
+            glow = cv2.GaussianBlur(retro, (15, 15), 0)
+            return cv2.addWeighted(retro, 0.7, glow, 0.3, 0)
+        elif variant == "Soft Ghibli":
+            # Requires opencv-contrib-python for detailEnhance
+            detail = cv2.detailEnhance(bilateral, sigma_s=10, sigma_r=0.15)
+            return cv2.convertScaleAbs(detail, alpha=1.1, beta=15)
+        return bilateral
+    except Exception as e:
+        print(f"Filter Error: {e}")
+        return img
+
+def get_brush_mask(length, brush_type):
+    if brush_type == "Sharp Row": return np.zeros(length, dtype=np.int32)
+    elif brush_type == "Flat Brush": return np.random.randint(-5, 6, length)
+    elif brush_type == "Rough Bristle": return np.random.randint(-25, 26, length)
+    elif brush_type == "Fan Brush":
+        x = np.linspace(0, 4 * np.pi, length)
+        return (np.sin(x) * 20).astype(np.int32)
+    return np.zeros(length, dtype=np.int32)
 
 def generate_video(img_path, anime_variant, brush_texture, duration):
     try:
-        # 1. Load and prepare image
         img = cv2.imread(img_path)
-        if img is None: return "Error: Could not read image."
+        if img is None: return None
+        
         img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
         h, w = 1080, 1920
-        img = cv2.resize(img, (w, h))
+        img = cv2.resize(img, (w, h), interpolation=cv2.INTER_LANCZOS4)
         target_img = apply_anime_filter(img, anime_variant)
         
-        # 2. Setup Video Writer
-        video_name = Path(img_path).stem
-        temp_raw = f"raw_{video_name}.mp4"
-        final_mp4 = f"final_{video_name}.mp4"
+        fps = 30
+        total_frames = int(duration * fps)
+        video_name = f"{Path(img_path).stem}_{int(time.time())}"
         
-        # Using 'mp4v' for maximum compatibility
-        video = cv2.VideoWriter(temp_raw, cv2.VideoWriter_fourcc(*'mp4v'), 30, (w, h))
+        # Use absolute paths for Hugging Face containers
+        temp_raw = f"/tmp/raw_{video_name}.mp4"
+        final_output = f"/tmp/{video_name}_anime.mp4"
         
-        # 3. Processing Loop (simplified for speed)
-        for i in range(int(duration * 30)):
-            # ... [Reveal logic here] ...
+        video = cv2.VideoWriter(temp_raw, cv2.VideoWriter_fourcc(*'mp4v'), fps, (w, h))
+        brush_offsets = get_brush_mask(w, brush_texture)
+
+        for i in range(total_frames):
+            progress = i / total_frames
+            zoom = 1 + (0.04 * progress)
+            M = cv2.getRotationMatrix2D((w/2, h/2), 0, zoom)
+            animated_target = cv2.warpAffine(target_img, M, (w, h))
+            
+            frame = np.ones((h, w, 3), dtype=np.uint8) * 255
+            base_h = int(progress * h)
+            
+            for x in range(w):
+                reveal_h = max(0, min(h, base_h + brush_offsets[x]))
+                if reveal_h > 0:
+                    frame[0:reveal_h, x] = animated_target[0:reveal_h, x]
+            
             video.write(cv2.cvtColor(frame, cv2.COLOR_RGB2BGR))
         video.release()
         
-        # 4. Final Encode (The part that usually causes the 'Error')
-        try:
-            subprocess.run(['ffmpeg', '-y', '-i', temp_raw, '-vcodec', 'libx264', '-pix_fmt', 'yuv420p', final_mp4], check=True)
-            return final_mp4
-        except:
-            # Fallback if FFmpeg is missing: return the raw file
-            return temp_raw
+        # Final FFmpeg Encode (Critical step for HF Spaces)
+        subprocess.run(['ffmpeg', '-y', '-i', temp_raw, '-vcodec', 'libx264', '-crf', '18', '-pix_fmt', 'yuv420p', final_output], check=True)
+        
+        if os.path.exists(temp_raw): os.remove(temp_raw)
+        return final_output
             
     except Exception as e:
-        return f"Developer Error: {str(e)}"
+        print(f"Detailed Error: {e}")
+        return None
+
+def batch_process(files, anime_variant, brush, duration):
+    if not files: return [], None
+    results = []
+    for f in files:
+        res = generate_video(f.name, anime_variant, brush, duration)
+        if res: results.append(res)
+    return results, (results[0] if results else None)
+
+with gr.Blocks() as demo:
+    gr.Markdown("# 🎌 Vertical Anime SpeedPaint Master")
+    with gr.Row():
+        with gr.Column():
+            file_input = gr.File(file_count="multiple", label="Upload Multiple Images")
+            variant_opt = gr.Dropdown(["Vivid Modern", "90s Retro", "Soft Ghibli"], value="Vivid Modern", label="Anime Variant")
+            brush_opt = gr.Dropdown(["Sharp Row", "Flat Brush", "Rough Bristle", "Fan Brush"], value="Rough Bristle", label="Brush Texture")
+            dur_slider = gr.Slider(2, 10, value=5, step=1, label="Duration (Seconds)")
+            run_btn = gr.Button("🚀 Generate Batch")
+        with gr.Column():
+            video_preview = gr.Video(label="Preview")
+            file_download = gr.File(label="Download Files")
+
+    run_btn.click(fn=batch_process, inputs=[file_input, variant_opt, brush_opt, dur_slider], outputs=[file_download, video_preview])
+
+demo.launch()