Added Flask AnimeGAN app

app.py

@@ -0,0 +1,163 @@
+import gradio as gr
+import torch
+import cv2
+import numpy as np
+import torchvision.transforms as transforms
+from PIL import Image
+import random
+import os
+
+# 🚀 Load the AnimeGANv2 model with GPU support
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print(f"🔹 Using device: {device}")
+
+# Load the AnimeGANv2 model (choose a style)
+model = torch.hub.load("bryandlee/animegan2-pytorch:main", "generator", pretrained="paprika").to(device)
+model.eval()
+
+model2 = torch.hub.load("bryandlee/animegan2-pytorch:main", "generator", pretrained="face_paint_512_v2").to(device)
+model2.eval()
+
+# Define image transformation function
+transform = transforms.Compose([
+    transforms.ToTensor(),
+    transforms.Normalize((0.5,), (0.5,)),  # Normalize to [-1, 1]
+])
+
+def process_frame(frame):
+    """Convert a video frame to anime style using GPU"""
+    img = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+    img_tensor = transform(img).unsqueeze(0).to(device)  # Move to GPU
+
+    with torch.no_grad():
+        output = model(img_tensor)  # Apply model
+
+    # Convert output tensor to NumPy image
+    output = output.squeeze(0).cpu().numpy()  # Move back to CPU
+    output = np.transpose(output, (1, 2, 0))
+    output = (output + 1) / 2  # Normalize to [0, 1]
+    output_img = (output * 255).astype(np.uint8)
+
+    img_tensor2 = transform(output_img).unsqueeze(0).to(device)  # Move to GPU
+    
+    with torch.no_grad():
+        output2 = model2(img_tensor2)  # Apply model
+
+    # Convert output tensor to NumPy image
+    output2 = output2.squeeze(0).cpu().numpy()  # Move back to CPU
+    output2 = np.transpose(output2, (1, 2, 0))
+    output2 = (output2 + 1) / 2  # Normalize to [0, 1]
+    output2_img = (output2 * 255).astype(np.uint8)
+    
+    return cv2.cvtColor(output2_img, cv2.COLOR_RGB2BGR)
+
+def apply_motion_blur(frame, kernel_size=25):
+    """Applies motion blur to simulate page flip transition"""
+    kernel = np.zeros((kernel_size, kernel_size))
+    kernel[int((kernel_size - 1) / 2), :] = np.ones(kernel_size)
+    kernel /= kernel_size
+    return cv2.filter2D(frame, -1, kernel)
+
+def apply_random_transformations(frame):
+    """Applies small changes to make video unique"""
+    
+    # Slightly change brightness and contrast
+    alpha = random.uniform(0.9, 1.1)  # Contrast
+    beta = random.randint(-10, 10)  # Brightness
+    frame = cv2.convertScaleAbs(frame, alpha=alpha, beta=beta)
+
+    return frame
+
+def apply_color_modifications(frame):
+    """Applies slight hue shift, saturation change, and noise to make video unique"""
+
+    # Convert frame to HSV
+    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV).astype(np.float32)
+
+    # 🎨 Random Hue Shift (1-5 degrees)
+    hue_shift = random.randint(-5, 5)
+    hsv[:, :, 0] = (hsv[:, :, 0] + hue_shift) % 180
+
+    # 🔥 Random Saturation Boost (0.9x - 1.1x)
+    sat_scale = random.uniform(0.9, 1.1)
+    hsv[:, :, 1] = np.clip(hsv[:, :, 1] * sat_scale, 0, 255)
+
+    # 🎭 Convert back to BGR
+    frame = cv2.cvtColor(hsv.astype(np.uint8), cv2.COLOR_HSV2BGR)
+
+    return frame
+
+def process_video(input_video_path, speed_factor=1, skipping_factor=2):
+    output_video_path = "anime_video.mp4"
+
+    # Open the input video
+    cap = cv2.VideoCapture(input_video_path)
+
+    # Get video properties
+    frame_width = int(cap.get(3))
+    frame_height = int(cap.get(4))
+
+    original_fps = int(cap.get(cv2.CAP_PROP_FPS))
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+
+    # Adjust FPS based on speed factor
+    new_fps = max(1, int(original_fps * speed_factor))  # Ensure FPS doesn't drop to 0
+
+    # Define video writer
+    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+    out = cv2.VideoWriter(output_video_path, fourcc, new_fps, (frame_width, frame_height))
+
+    frame_count = 0
+    print("🎥 Processing video with Smooth Book Flip effect...")
+
+    previous_anime_frame = None
+
+    # Process video frame-by-frame
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break  # End of video
+        
+        if frame_count % skipping_factor == 0:
+            # Skip some frames randomly to alter video signature
+            if random.random() > 0.95:  # Skip 5% of frames randomly
+                frame_count += 1
+                continue
+
+            anime_frame = process_frame(frame)
+            anime_frame = apply_random_transformations(anime_frame)
+            anime_frame = apply_color_modifications(anime_frame)
+
+            out.write(anime_frame)  # Write stylized frame
+
+            # Add motion-blurred transition frame instead of white screen
+            if previous_anime_frame is not None:
+                blurred_transition = apply_motion_blur(anime_frame, kernel_size=20)
+                out.write(blurred_transition)
+
+            previous_anime_frame = anime_frame  # Store last processed frame
+
+        frame_count += 1
+        print(f"Processing frame {frame_count}/{total_frames}", end="\r")
+
+    # Release resources
+    cap.release()
+    out.release()
+
+    os.remove(input_video_path)
+    return output_video_path
+
+demo = gr.Interface(
+    fn=process_video,
+    inputs=[
+        gr.Video(label="Upload your video"), 
+        gr.Slider(0.25, 1.5, value=1, step=0.05, label="Speed Factor (Lower = Slower, Higher = Faster)"),
+        gr.Slider(1, 10, value=2, step=1, label="Frames skipping Factor (Lower = Less, Higher = More)"),
+    ],
+    outputs=gr.Video(),
+    title="AnimeGAN Video Styler",
+    description="Upload a video and get an anime-stylized version!"
+)
+
+if __name__ == "__main__":
+    demo.launch(share=True)

requirements.txt

@@ -0,0 +1,7 @@
+flask
+torch
+torchvision
+opencv-python
+numpy
+pillow
+gradio