Update app.py

app.py

@@ -1,71 +1,76 @@
 import gradio as gr
-import cv2
+from PIL import Image, ImageEnhance, ImageOps, ImageFilter
 import numpy as np
 
-def apply_filter(image, filter_type, intensity):
-    # 강도를 0.0에서 1.0 사이로 정규화
-    normalized_intensity = intensity / 100.0
+def apply_filter(image, filter_name, intensity):
+    if filter_name == "Soft Glow":
+        glow = image.filter(ImageFilter.GaussianBlur(intensity))
+        enhanced_image = Image.blend(image, glow, 0.5)
+        return enhanced_image
 
-    if filter_type == "Grayscale":
-        return convert_to_grayscale(image)
-    elif filter_type == "Soft Glow":
-        gaussian = cv2.GaussianBlur(image, (15, 15), 0)
-        soft_glow = cv2.addWeighted(image, 1 - normalized_intensity, gaussian, normalized_intensity, 0)
-        return soft_glow
-    elif filter_type == "Portrait Enhancer":
-        # Step 1: Detail Enhance 적용 (다소 강하게)
-        enhanced = cv2.detailEnhance(image, sigma_s=10, sigma_r=0.1 + 0.1 * normalized_intensity)
-        
-        # Step 2: Gaussian Blur 적용 (강도 조정)
-        blurred = cv2.GaussianBlur(enhanced, (5, 5), 0)
-        
-        # Step 3: Bilateral Filter 적용 (약하게, 경계 보존)
-        smoothed = cv2.bilateralFilter(blurred, d=5, sigmaColor=50, sigmaSpace=50)
-        
-        # Step 4: 원본 이미지와 혼합하여 선명함 유지
-        final_image = cv2.addWeighted(enhanced, 0.7, smoothed, 0.3, 0)
-        
-        return final_image
-    elif filter_type == "Warm Tone":
-        increase_red = np.array([[1.0 + 0.2 * normalized_intensity, 0.0, 0.0],
-                                 [0.0, 1.0, 0.0],
-                                 [0.0, 0.0, 1.0 - 0.2 * normalized_intensity]])
-        warm_image = cv2.transform(image, increase_red)
-        return warm_image
-    elif filter_type == "Cold Tone":
-        increase_blue = np.array([[1.0 - 0.2 * normalized_intensity, 0.0, 0.0],
-                                  [0.0, 1.0, 0.0],
-                                  [0.0, 0.0, 1.0 + 0.2 * normalized_intensity]])
-        cold_image = cv2.transform(image, increase_blue)
-        return cold_image
-    elif filter_type == "High-Key":
-        high_key = cv2.convertScaleAbs(image, alpha=1.0 + 0.2 * normalized_intensity, beta=30)
+    elif filter_name == "Portrait Enhancer":
+        enhancer = ImageEnhance.Sharpness(image)
+        image = enhancer.enhance(1 + 0.1 * intensity)
+        enhancer = ImageEnhance.Color(image)
+        image = enhancer.enhance(1 + 0.1 * intensity)
+        return image
+
+    elif filter_name == "Warm Tone":
+        warm_tone = ImageEnhance.Color(image).enhance(1 + 0.1 * intensity)
+        return warm_tone
+
+    elif filter_name == "Cold Tone":
+        blue_overlay = Image.new('RGB', image.size, (173, 216, 230))
+        blended_image = Image.blend(image, blue_overlay, 0.05 * intensity)
+        enhancer = ImageEnhance.Sharpness(blended_image)
+        sharpened_image = enhancer.enhance(1 + 0.3 * intensity)
+        return sharpened_image
+
+    elif filter_name == "High-Key":
+        enhancer = ImageEnhance.Brightness(image)
+        high_key = enhancer.enhance(1 + 0.1 * intensity)
+        enhancer = ImageEnhance.Contrast(high_key)
+        high_key = enhancer.enhance(0.8 + 0.02 * intensity)
         return high_key
-    elif filter_type == "Low-Key":
-        low_key = cv2.convertScaleAbs(image, alpha=1.0 - 0.3 * normalized_intensity, beta=-30)
+
+    elif filter_name == "Low-Key":
+        enhancer = ImageEnhance.Contrast(image)
+        low_key = enhancer.enhance(1 + 0.1 * intensity)
+        enhancer = ImageEnhance.Brightness(low_key)
+        low_key = enhancer.enhance(1 - 0.05 * intensity)
         return low_key
-    elif filter_type == "Haze":
-        haze = cv2.addWeighted(image, 1.0 - 0.3 * normalized_intensity, np.full(image.shape, 255, dtype=np.uint8), 0.3 * normalized_intensity, 0)
+
+    elif filter_name == "Haze":
+        haze = image.filter(ImageFilter.GaussianBlur(2 * intensity))
+        enhancer = ImageEnhance.Brightness(haze)
+        haze = enhancer.enhance(1 + 0.05 * intensity)
         return haze
-    else:
-        return image
+
+    elif filter_name == "Monochrome":
+        mono = image.convert("L")
+        mono = ImageOps.colorize(mono, black="black", white="white")
+        enhancer = ImageEnhance.Contrast(mono)
+        mono = enhancer.enhance(1 + 0.1 * intensity)
+        return mono
+
+    return image
 
 def convert_to_grayscale(image):
-    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    gray_image = ImageOps.grayscale(image)
     return gray_image
 
 def convert_and_save(image, filter_type, intensity):
     filtered_image = apply_filter(image, filter_type, intensity)
     output_path = "output.jpg"
-    cv2.imwrite(output_path, filtered_image)
+    filtered_image.save(output_path)
     return filtered_image, output_path
 
 iface = gr.Interface(
     fn=convert_and_save, 
     inputs=[
-        "image", 
+        gr.Image(type="pil", label="이미지 업로드"), 
         gr.Radio(
-            ["Grayscale", "Soft Glow", "Portrait Enhancer", "Warm Tone", "Cold Tone", "High-Key", "Low-Key", "Haze"], 
+            ["Grayscale", "Soft Glow", "Portrait Enhancer", "Warm Tone", "Cold Tone", "High-Key", "Low-Key", "Haze", "Monochrome"], 
             label="필터 선택"
         ),
         gr.Slider(minimum=1, maximum=100, value=50, label="필터 강도")