Add user authentication with Hugging Face Secrets

- Implement auth_fn to restrict access to allowed users only
- Add ALLOWED_USERS environment variable support
- Users authenticate with username/password (both same value)
- Update app.py with authentication integration
- Add Git LFS support for binary files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,2 @@
+# Git LFS tracks all binary files
+# See .gitattributes for tracked file types

LICENSE

@@ -0,0 +1,46 @@
+POLYGOM PROPRIETARY SOFTWARE LICENSE
+
+Copyright (c) 2025 Polygom. All Rights Reserved.
+
+This software and associated documentation files (the "Software") are the
+proprietary property of Polygom and are protected by copyright law.
+
+NO PERMISSION IS GRANTED TO:
+- Use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software
+- Use the Software for any commercial or non-commercial purpose
+- Reverse engineer, decompile, or disassemble the Software
+
+This Software contains proprietary AI technology developed by Polygom.
+Any unauthorized use, reproduction, or distribution is strictly prohibited
+and may result in severe civil and criminal penalties.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED. IN NO EVENT SHALL POLYGOM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE.
+
+For licensing inquiries, please contact Polygom directly.
+
+---
+
+POLYGOM 독점 소프트웨어 라이선스
+
+Copyright (c) 2025 Polygom. 모든 권리 보유.
+
+이 소프트웨어와 관련 문서 파일("소프트웨어")은 Polygom의 독점 자산이며
+저작권법으로 보호됩니다.
+
+다음 행위는 허가되지 않습니다:
+- 소프트웨어의 사용, 복사, 수정, 병합, 게시, 배포, 재라이선스, 판매
+- 상업적 또는 비상업적 목적으로의 소프트웨어 사용
+- 소프트웨어의 역공학, 디컴파일, 역어셈블
+
+이 소프트웨어는 Polygom이 개발한 독점 AI 기술을 포함하고 있습니다.
+무단 사용, 복제 또는 배포는 엄격히 금지되며 심각한 민형사상 처벌을
+받을 수 있습니다.
+
+소프트웨어는 "있는 그대로" 제공되며, 어떠한 명시적 또는 묵시적 보증도
+없습니다. Polygom은 소프트웨어와 관련하여 발생하는 어떠한 청구, 손해
+또는 기타 책임에 대해서도 책임지지 않습니다.
+
+라이선스 문의는 Polygom에 직접 연락하시기 바랍니다.

README.md

@@ -1,13 +1,51 @@
 ---
-title: PixelFree
-emoji: 💻
-colorFrom: blue
-colorTo: purple
+title: PixelFree - AI Image Processing Platform
+emoji: 🎨
+colorFrom: purple
+colorTo: pink
 sdk: gradio
-sdk_version: 5.49.0
+sdk_version: 5.45.0
 app_file: app.py
 pinned: false
-short_description: AI Image Processing
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# PixelFree - AI 이미지 처리 플랫폼
+
+<p align="center">
+  <img src="https://img.shields.io/badge/Python-3.9+-blue.svg" alt="Python">
+  <img src="https://img.shields.io/badge/Gradio-4.0+-orange.svg" alt="Gradio">
+</p>
+
+## 🎯 소개
+
+PixelFree는 **Polygom**의 자체 AI 기술을 활용한 이미지 처리 플랫폼입니다. 배경 제거, 배경 생성, 얼굴 교체 등의 고급 기능을 원클릭으로 제공합니다.
+
+## 📋 주요 기능
+
+### 1. 배경 제거
+- 입력 이미지에서 배경을 자동으로 제거
+- 투명한 PNG 형식으로 결과 반환
+
+### 2. 배경 생성
+- **2단계 프로세스**:
+  1. 자동 배경 제거
+  2. 새로운 배경 생성 및 합성
+- 배경 선택 옵션:
+  - Indoor (실내 배경)
+  - Outdoor (실외 배경)
+  - Custom (사용자 업로드)
+
+### 3. 얼굴 교체
+- 참조 얼굴 선택 옵션:
+  - 남자
+  - 여자
+  - 전체
+  - Custom (사용자 업로드)
+
+⚠️ **참고**: 이 API는 Polygom의 독점 기술이며, 별도의 라이선스 계약이 필요할 수 있습니다.
+
+자세한 내용은 [LICENSE](./LICENSE) 파일을 참조하세요.
+
+---
+
+**Powered by Polygom**

app.py

@@ -0,0 +1,1219 @@
+"""
+PixelFree - AI Image Processing Service
+HuggingFace Spaces용 Gradio 애플리케이션
+Polygom API를 활용한 이미지 처리 서비스
+
+Features:
+- 배경 제거 (Background Removal)
+- 배경 생성 (Background Generation) 
+- 얼굴 교체 (Face Swap)
+
+Version: 3.0.0
+Version 3: Simplified Multi-Mode Workflow
+Author: PixelFree Team
+"""
+
+import gradio as gr
+import requests
+import base64
+import io
+import logging
+import tempfile
+from PIL import Image
+from typing import Optional, Tuple
+from datetime import datetime
+from collections import OrderedDict
+import time
+import os
+
+# ===== Configuration =====
+API_BASE_URL = os.environ.get("API_BASE_URL")
+API_ENDPOINTS = {
+    "background_removal": os.environ.get("BACKGROUND_REMOVAL_ENDPOINT"),
+    "background_generation": os.environ.get("BACKGROUND_GENERATION_ENDPOINT"),
+    "face_swap": os.environ.get("FACE_SWAP_ENDPOINT"),
+    "video_generation": os.environ.get("VIDEO_GEN"),
+}
+VIDEO_PROMPT = os.environ.get("VIDEO_PROMPT", "환하게 웃으며 눈을 깜빡인다.")
+
+# 허용된 사용자 목록 (Hugging Face Secrets에서 가져오기)
+ALLOWED_USERS = os.environ.get("ALLOWED_USERS", "").split(",")
+ALLOWED_USERS = [user.strip() for user in ALLOWED_USERS if user.strip()]
+
+IMAGE_HEIGHT = 500
+GALLERY_COLUMNS = 3
+GALLERY_ROWS = 3
+logging.basicConfig(level=logging.WARNING)
+logger = logging.getLogger(__name__)
+
+IMAGE_CACHE_LIMIT = 24
+image_cache: "OrderedDict[str, Image.Image]" = OrderedDict()
+
+
+def cache_image(path: str, image: Image.Image) -> None:
+    """Add image to global cache with simple LRU eviction."""
+    if path in image_cache:
+        image_cache.move_to_end(path)
+    image_cache[path] = image
+    while len(image_cache) > IMAGE_CACHE_LIMIT:
+        image_cache.popitem(last=False)
+
+output_history = []
+
+
+def ensure_png_image(image: Optional[Image.Image]) -> Optional[Image.Image]:
+    """Ensure provided PIL image is stored as a PNG image (returns copy)."""
+    if image is None:
+        return None
+
+    working_image = image
+    if working_image.mode not in ("RGB", "RGBA"):
+        working_image = working_image.convert("RGBA")
+
+    buffer = io.BytesIO()
+    # Convert to PNG while preserving alpha when present
+    target_mode = "RGBA" if working_image.mode == "RGBA" else "RGB"
+    working_image.convert(target_mode).save(buffer, format="PNG")
+    buffer.seek(0)
+    with Image.open(buffer) as png_image:
+        return png_image.convert("RGBA").copy()
+
+
+def make_thumbnail_image(image: Optional[Image.Image], size: Tuple[int, int] = (256, 256), *, fill_color=(255, 255, 255, 0)) -> Optional[Image.Image]:
+    """Create a thumbnail copy of the provided image for gallery previews."""
+    base_image = ensure_png_image(image)
+    if base_image is None:
+        return None
+
+    preview = base_image.copy()
+    try:
+        preview.thumbnail(size, Image.Resampling.LANCZOS)
+    except AttributeError:
+        preview.thumbnail(size)
+    canvas = Image.new("RGBA", size, fill_color)
+    offset = ((size[0] - preview.width) // 2, (size[1] - preview.height) // 2)
+    canvas.paste(preview, offset, preview if preview.mode == "RGBA" else None)
+    return canvas
+
+
+def add_to_history(image: Optional[Image.Image], workspace: str) -> Optional[str]:
+    """Append processed image to history gallery with descriptive PNG name."""
+    if image is None:
+        return None
+
+    png_image = ensure_png_image(image)
+    if png_image is None:
+        return None
+
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    prefix_map = {
+        "bg_remove": "background_removed",
+        "bg_gen": "background_generated",
+        "face_swap": "face_swap",
+        "video": "video_generated",
+    }
+    prefix = prefix_map.get(workspace, "result")
+    file_name = f"{prefix}_{timestamp}.png"
+
+    output_history.append((png_image, file_name))
+    if len(output_history) > 20:
+        del output_history[:-20]
+
+    return file_name
+
+
+def get_history_items(limit: Optional[int] = None):
+    """Return history items (image, filename) with newest first."""
+    if limit is None:
+        data = output_history[:]
+    elif limit <= 0:
+        return []
+    else:
+        data = output_history[-limit:]
+    return list(reversed(data))
+
+
+
+class ImageProcessor:
+    """Wrapper around PixelFree backend APIs."""
+
+    def __init__(self) -> None:
+        self.session = requests.Session()
+        adapter = requests.adapters.HTTPAdapter(
+            pool_connections=10,
+            pool_maxsize=20,
+            max_retries=3,
+        )
+        self.session.mount("http://", adapter)
+        self.session.mount("https://", adapter)
+        self.session.headers.update({"accept": "application/json"})
+
+    def image_to_bytes(self, image: Image.Image, format: str = "PNG", preserve_alpha: bool = False) -> bytes:
+        buffer = io.BytesIO()
+        img = image
+        if not preserve_alpha and img.mode in ("RGBA", "P"):
+            img = img.convert("RGB")
+        elif preserve_alpha and img.mode != "RGBA":
+            img = img.convert("RGBA")
+        img.save(buffer, format=format)
+        buffer.seek(0)
+        return buffer.getvalue()
+
+    def base64_to_image(self, base64_str: str) -> Optional[Image.Image]:
+        try:
+            if base64_str.startswith("http"):
+                logger.error("Refusing to download image from URL: %s", base64_str)
+                return None
+            if "," in base64_str:
+                base64_str = base64_str.split(",", 1)[1]
+            img_data = base64.b64decode(base64_str)
+            return Image.open(io.BytesIO(img_data))
+        except Exception as exc:
+            logger.error("Failed to decode image: %s", exc)
+            return None
+
+    def call_api(self, endpoint: Optional[str], files: dict, data: dict) -> Optional[dict]:
+        if not endpoint or not API_BASE_URL:
+            logger.error("API endpoint or base URL missing")
+            return None
+        url = f"{API_BASE_URL}{endpoint}"
+        try:
+            response = self.session.post(url, files=files, data=data, timeout=300)
+            logger.info("API response %s: %s", endpoint, response.status_code)
+            response.raise_for_status()
+            return response.json()
+        except Exception as exc:
+            logger.error("API call failed (%s): %s", endpoint, exc)
+            return None
+
+    def remove_background(self, image: Image.Image) -> Tuple[Optional[Image.Image], str]:
+        start_time = time.time()
+        files = {
+            "file": ("input.png", self.image_to_bytes(image, preserve_alpha=True), "image/png")
+        }
+        result = self.call_api(API_ENDPOINTS.get("background_removal"), files, {})
+        total = time.time() - start_time
+        if result and result.get("success") and result.get("data"):
+            b64 = result["data"].get("result_base64")
+            image_obj = self.base64_to_image(b64) if b64 else None
+            if image_obj:
+                return image_obj, f"✅ 배경 제거 완료! (처리 시간: {total:.1f}초)"
+        return None, f"❌ 배경 제거 실패 (시도 시간: {total:.1f}초)"
+
+    def generate_background(
+        self,
+        image: Image.Image,
+        bg_image: Image.Image,
+        hq_mode: bool = False,
+    ) -> Tuple[Optional[Image.Image], str]:
+        start_time = time.time()
+        files = {
+            "image": ("input.png", self.image_to_bytes(image, preserve_alpha=True), "image/png"),
+            "bg_image": ("background.png", self.image_to_bytes(bg_image), "image/png"),
+        }
+        data = {
+            "jobId": f"job_{int(time.time() * 1000)}",
+            "hq_mode": "true" if hq_mode else "false",
+        }
+        result = self.call_api(API_ENDPOINTS.get("background_generation"), files, data)
+        total = time.time() - start_time
+        mode_text = "고품질" if hq_mode else "일반"
+        if result and result.get("success") and result.get("data"):
+            payload = result["data"]
+            if payload.get("imageData"):
+                image_obj = self.base64_to_image(payload["imageData"])
+                if image_obj:
+                    return image_obj, f"✅ 배경 생성 완료! (처리 시간: {total:.1f}초, 모드: {mode_text})"
+            if payload.get("rawDataUrl"):
+                logger.error("Ignoring rawDataUrl field for security reasons.")
+        return None, f"❌ 배경 생성 실패 (시도 시간: {total:.1f}초, 모드: {mode_text})"
+
+    def swap_face(self, source: Image.Image, target: Image.Image) -> Tuple[Optional[Image.Image], str]:
+        start_time = time.time()
+        files = {
+            "image": ("image.png", self.image_to_bytes(source), "image/png"),
+            "targetFaceImage": ("targetFace.png", self.image_to_bytes(target), "image/png"),
+        }
+        data = {
+            "jobId": f"face_swap_{int(time.time() * 1000)}"
+        }
+        result = self.call_api(API_ENDPOINTS.get("face_swap"), files, data)
+        total = time.time() - start_time
+        if result and result.get("success") and result.get("data"):
+            payload = result["data"]
+            if payload.get("imageData"):
+                image_obj = self.base64_to_image(payload["imageData"])
+                if image_obj:
+                    api_time = payload.get("processingTime", 0)
+                    return image_obj, f"✅ 얼굴 교체 완료! (전체: {total:.1f}초, API: {api_time:.1f}초)"
+            if payload.get("rawDataUrl"):
+                logger.error("Ignoring rawDataUrl field for security reasons.")
+        return None, f"❌ 얼굴 교체 실패 (시도 시간: {total:.1f}초)"
+
+    def generate_video(self, image: Optional[Image.Image]) -> Tuple[Optional[str], str]:
+        if image is None:
+            return None, "입력 이미지가 필요합니다."
+
+        start_time = time.time()
+        files = {
+            "image": ("image.png", self.image_to_bytes(image, preserve_alpha=True), "image/png"),
+        }
+        data = {
+            "jobId": f"video_{int(time.time() * 1000)}",
+            "prompt": VIDEO_PROMPT,
+            "duration": "5",
+        }
+        result = self.call_api(API_ENDPOINTS.get("video_generation"), files, data)
+        total = time.time() - start_time
+        if result and result.get("success") and result.get("data"):
+            payload = result["data"]
+            video_base64 = payload.get("videoData")
+            if video_base64:
+                if "," in video_base64:
+                    video_base64 = video_base64.split(",", 1)[1]
+                try:
+                    video_bytes = base64.b64decode(video_base64)
+                    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as temp_video:
+                        temp_video.write(video_bytes)
+                        temp_path = temp_video.name
+                except Exception as exc:
+                    logger.error("Failed to decode video: %s", exc)
+                else:
+                    api_time = payload.get("processingTime", 0)
+                    return temp_path, f"✅ 영상 생성 완료! (전체: {total:.1f}초, API: {api_time:.1f}초)"
+            if payload.get("rawDataUrl"):
+                logger.error("Ignoring rawDataUrl field for security reasons.")
+        return None, f"❌ 영상 생성 실패 (시도 시간: {total:.1f}초)"
+
+processor = ImageProcessor()
+
+# 인증 함수
+def auth_fn(username: str, password: str) -> bool:
+    """
+    사용자 인증 함수
+    - username이 허용된 사용자 목록에 있고
+    - username과 password가 같으면 인증 성공
+    """
+    return username == password and username in ALLOWED_USERS
+
+# 배경 이미지 로드
+def load_background_images():
+    """배경 이미지를 assets 폴더에서 로드 (Lazy loading)"""
+    backgrounds = {
+        "indoor": [],
+        "outdoor": [],
+        "indoor_paths": [],
+        "outdoor_paths": [],
+        "indoor_pil": [],
+        "outdoor_pil": []
+    }
+
+    cwd = os.getcwd()
+    
+    # Indoor 이미지 경로 저장
+    indoor_path = os.path.join(cwd, "assets", "indoor")
+    if os.path.exists(indoor_path):
+        files = sorted([f for f in os.listdir(indoor_path) if f.endswith('.png')])
+        for img_file in files:
+            img_path = os.path.join(indoor_path, img_file)
+            try:
+                backgrounds["indoor_paths"].append(img_path)
+                # 갤러리용 썸네일만 생성
+                with Image.open(img_path) as img:
+                    img = img.convert('RGBA' if 'A' in img.getbands() else 'RGB')
+                    thumb = img.copy()
+                    thumb.thumbnail((240, 240), Image.Resampling.LANCZOS)
+                backgrounds["indoor"].append(thumb)
+                backgrounds["indoor_pil"].append(img_path)  # 경로 저장
+            except Exception:
+                pass
+    
+    # Outdoor 이미지 로드
+    outdoor_path = os.path.join(cwd, "assets", "outdoor")
+    if os.path.exists(outdoor_path):
+        files = sorted([f for f in os.listdir(outdoor_path) if f.endswith('.png')])
+        for img_file in files:
+            img_path = os.path.join(outdoor_path, img_file)
+            try:
+                backgrounds["outdoor_paths"].append(img_path)
+                with Image.open(img_path) as img:
+                    img = img.convert('RGBA' if 'A' in img.getbands() else 'RGB')
+                    thumb = img.copy()
+                    thumb.thumbnail((240, 240), Image.Resampling.LANCZOS)
+                backgrounds["outdoor"].append(thumb)
+                backgrounds["outdoor_pil"].append(img_path)
+            except Exception:
+                pass
+    
+    # 이미지가 없는 경우 더미 이미지 생성
+    if len(backgrounds['indoor']) == 0:
+        dummy = Image.new('RGB', (240, 240), color=(200, 200, 200))
+        backgrounds["indoor"].append(dummy)
+        backgrounds["indoor_pil"].append(None)
+
+    if len(backgrounds['outdoor']) == 0:
+        dummy = Image.new('RGB', (240, 240), color=(150, 200, 150))
+        backgrounds["outdoor"].append(dummy)
+        backgrounds["outdoor_pil"].append(None)
+
+    return backgrounds
+
+bg_images = load_background_images()
+
+# 얼굴 이미지 로드
+def load_face_images():
+    """얼굴 이미지들을 로드 - PIL 이미지로 직접 로드하여 갤러리에 전달"""
+    faces = {
+        "man_pil": [],
+        "woman_pil": [],
+        "all_pil": [],
+        "man_paths": [],
+        "woman_paths": [],
+        "all_paths": []
+    }
+    
+    cwd = os.getcwd()
+    
+    # Man 이미지 로드
+    man_path = os.path.join(cwd, "assets", "faces", "man")
+    if os.path.exists(man_path):
+        files = sorted([f for f in os.listdir(man_path) if f.endswith(('.png', '.jpg', '.jpeg'))])
+        for img_file in files:
+            img_path = os.path.join(man_path, img_file)
+            try:
+                with Image.open(img_path) as img:
+                    img = img.convert('RGBA' if 'A' in img.getbands() else 'RGB')
+                    thumb = img.copy()
+                    thumb.thumbnail((240, 240), Image.Resampling.LANCZOS)
+                faces["man_pil"].append(thumb)
+                faces["man_paths"].append(img_path)
+            except Exception:
+                pass
+    
+    # Woman 이미지 로드
+    woman_path = os.path.join(cwd, "assets", "faces", "woman")
+    if os.path.exists(woman_path):
+        files = sorted([f for f in os.listdir(woman_path) if f.endswith(('.png', '.jpg', '.jpeg'))])
+        for img_file in files:
+            img_path = os.path.join(woman_path, img_file)
+            try:
+                with Image.open(img_path) as img:
+                    img = img.convert('RGBA' if 'A' in img.getbands() else 'RGB')
+                    thumb = img.copy()
+                    thumb.thumbnail((240, 240), Image.Resampling.LANCZOS)
+                faces["woman_pil"].append(thumb)
+                faces["woman_paths"].append(img_path)
+            except Exception:
+                pass
+    
+    # 이미지가 없는 경우 더미 이미지 생성
+    if len(faces['man_pil']) == 0:
+        for _ in range(3):
+            dummy = Image.new('RGB', (240, 240), color=(200, 200, 250))
+            faces["man_pil"].append(dummy)
+            faces["man_paths"].append(None)
+
+    if len(faces['woman_pil']) == 0:
+        for _ in range(3):
+            dummy = Image.new('RGB', (240, 240), color=(250, 200, 200))
+            faces["woman_pil"].append(dummy)
+            faces["woman_paths"].append(None)
+
+    # all 리스트 재구성
+    faces["all_pil"] = faces["man_pil"] + faces["woman_pil"]
+    faces["all_paths"] = faces["man_paths"] + faces["woman_paths"]
+    
+    return faces
+
+face_images = load_face_images()
+logger.info(f"Face images loaded - Total: {len(face_images.get('all_pil', []))}, Man: {len(face_images.get('man_pil', []))}, Woman: {len(face_images.get('woman_pil', []))}")
+
+# 이미지를 실제로 로드하는 헬퍼 함수
+def load_full_image(path_or_image):
+    """경로에서 전체 크기 이미지를 로드 (캐싱 포함)"""
+    if isinstance(path_or_image, str):
+        cached = image_cache.get(path_or_image)
+        if cached is not None:
+            image_cache.move_to_end(path_or_image)
+            return cached
+
+        try:
+            with Image.open(path_or_image) as img:
+                mode = 'RGBA' if 'A' in img.getbands() else 'RGB'
+                loaded = img.convert(mode).copy()
+        except Exception as exc:
+            logger.error(f"Failed to load image {path_or_image}: {exc}")
+            return None
+
+        cache_image(path_or_image, loaded)
+        return loaded
+    else:
+        return path_or_image
+
+
+def create_app():
+    """PixelFree Gradio UI (v3.0.0)."""
+
+    # CSS for history gallery image display
+    custom_css = """
+    #history-gallery img {
+        object-fit: contain !important;
+        height: 100% !important;
+        width: 100% !important;
+    }
+
+    #history-gallery .thumbnail-item {
+        height: 150px !important;
+    }
+
+    #history-gallery .grid-wrap {
+        gap: 10px !important;
+    }
+    """
+
+    with gr.Blocks(title="PixelFree v3.0.0", theme=gr.themes.Soft(), css=custom_css) as demo:
+
+        # 메인 헤더
+        gr.Markdown("# 🎨 PixelFree Studio")
+
+        # 입력 섹션
+        gr.Markdown("## 📸 입력 이미지")
+
+        input_state = gr.State(None)
+        bg_removed_state = gr.State(None)
+        selected_bg_state = gr.State(None)
+        selected_face_state = gr.State(None)
+        last_output_state = gr.State(None)
+
+        input_image = gr.Image(label="입력 이미지", type="pil", height=540)
+
+        # 결과 섹션
+        gr.Markdown("## ✨ 결과 이미지")
+        output_image = gr.Image(label="처리된 이미지", type="pil", height=500, interactive=False)
+        download_btn = gr.DownloadButton(
+            "📥 사진 다운로드",
+            value=None,
+            interactive=False
+        )
+
+        # 비디오 생성 섹션
+        gr.Markdown("## 🎬 AI 비디오 생성")
+        with gr.Row():
+            video_output = gr.Video(
+                label="생성된 영상",
+                height=360,
+                interactive=False,
+                autoplay=True,
+            )
+            with gr.Column():
+                gr.Markdown("최근 이미지 결과를 기반으로 짧은 클립을 생성합니다.")
+                generate_video_btn = gr.Button(
+                    "🎬 영상 생성하기",
+                    variant="primary",
+                    size="lg",
+                    interactive=False,
+                )
+
+        # 배경 제거 섹션
+        gr.Markdown("## 🎯 AI 배경 제거")
+        remove_bg_btn = gr.Button("🚀 배경 제거 실행", variant="primary", size="lg", interactive=False)
+
+        # AI 생성 기능 섹션
+        gr.Markdown("## 🎨 AI 생성 기능")
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### 🏞️ 배경 생성")
+                with gr.Tabs():
+                    with gr.Tab("🏠 실내"):
+                        indoor_gallery = gr.Gallery(
+                            value=bg_images["indoor"],
+                            columns=4,
+                            show_label=False, interactive=False,
+                            allow_preview=False,
+                            object_fit="contain"
+                        )
+                    with gr.Tab("🌳 아웃도어"):
+                        outdoor_gallery = gr.Gallery(
+                            value=bg_images["outdoor"],
+                            columns=4,
+                            rows=4, show_label=False, interactive=False,
+                            allow_preview=False,
+                            object_fit="contain"
+                        )
+                hq_checkbox = gr.Checkbox(label="✨ 고품질 모드", value=False)
+                generate_bg_btn = gr.Button("🎨 배경 생성하기", variant="secondary", interactive=False, size="lg")
+            with gr.Column():
+                gr.Markdown("### 👤 얼굴 교체")
+                with gr.Tabs():
+                    with gr.Tab("👨 남성"):
+                        man_gallery = gr.Gallery(
+                            value=face_images["man_pil"],
+                            columns=4,
+                            rows=2, show_label=False, interactive=False,
+                            allow_preview=False,
+                            object_fit="contain"
+                        )
+                    with gr.Tab("👩 여성"):
+                        woman_gallery = gr.Gallery(
+                            value=face_images["woman_pil"],
+                            columns=4,
+                            rows=2, show_label=False, interactive=False,
+                            allow_preview=False,
+                            object_fit="contain"
+                        )
+                swap_face_btn = gr.Button("🔄 얼굴 교체 적용", variant="secondary", interactive=False, size="lg")
+        # Collapsible history section with image grid
+        with gr.Accordion("📜 작업 히스토리", open=False):
+            # History gallery with preview enabled
+            history_gallery = gr.Gallery(
+                value=[img for img, _ in get_history_items(20)],
+                label=None,
+                show_label=False,
+                columns=5,
+                rows=4,
+                height=500,
+                object_fit="contain",
+                allow_preview=True,
+                elem_id="history-gallery",
+                interactive=False
+            )
+
+        def make_download_update(image: Optional[Image.Image], prefix: str = "pixelfree_output"):
+            if image is None:
+                return gr.update(value=None, interactive=False)
+            filename = f"{prefix}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png"
+            temp_path = f"/tmp/{filename}"
+            image.save(temp_path, "PNG")
+            return gr.update(value=temp_path, interactive=True)
+
+        def history_update():
+            """Update history gallery with original images."""
+            items = get_history_items(20)
+            images = [img for img, _ in items]
+            return gr.update(value=images)
+
+        def disable_all_buttons():
+            disabled = gr.update(interactive=False)
+            return disabled, disabled, disabled, disabled
+
+        def compute_button_states(
+            input_img: Optional[Image.Image],
+            last_output: Optional[Image.Image],
+            bg_removed: Optional[Image.Image],
+            selected_bg: Optional[Image.Image],
+            selected_face: Optional[Image.Image],
+        ):
+            remove_ready = gr.update(interactive=input_img is not None)
+            video_ready = gr.update(interactive=input_img is not None)
+            bg_ready = gr.update(interactive=(bg_removed is not None and selected_bg is not None))
+            swap_ready = gr.update(
+                interactive=(selected_face is not None and ((last_output is not None) or (input_img is not None)))
+            )
+            return remove_ready, video_ready, bg_ready, swap_ready
+
+
+        def on_upload(new_image: Optional[Image.Image]):
+            if new_image is None:
+                gr.Warning("입력 이미지를 업로드해주세요.")
+                remove_ready, video_ready, bg_ready, swap_ready = disable_all_buttons()
+                return (
+                    None,
+                    None,
+                    None,
+                    None,
+                    None,
+                    gr.update(value=None),
+                    make_download_update(None),
+                    gr.update(value=None),
+                    remove_ready,
+                    video_ready,
+                    bg_ready,
+                    swap_ready,
+                    history_update(),
+                )
+
+            gr.Info("입력 이미지를 불러왔습니다.")
+            remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
+                new_image,
+                None,
+                None,
+                None,
+                None,
+            )
+            return (
+                new_image,
+                None,
+                None,
+                None,
+                None,
+                gr.update(value=None),
+                make_download_update(None),
+                gr.update(value=None),
+                remove_ready,
+                video_ready,
+                bg_ready,
+                swap_ready,
+                history_update(),
+            )
+
+        def handle_remove_background(
+            input_img: Optional[Image.Image],
+            current_bg_removed: Optional[Image.Image],
+            selected_bg: Optional[Image.Image],
+            current_output: Optional[Image.Image],
+            selected_face: Optional[Image.Image],
+        ):
+            if input_img is None:
+                gr.Warning("입력 이미지를 먼저 업로드해주세요.")
+                remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
+                    input_img,
+                    current_output,
+                    current_bg_removed,
+                    selected_bg,
+                    selected_face,
+                )
+                yield (
+                    current_bg_removed,
+                    current_output,
+                    gr.update(),
+                    make_download_update(current_output),
+                    bg_ready,
+                    swap_ready,
+                    remove_ready,
+                    video_ready,
+                    history_update(),
+                )
+                return
+
+            remove_disabled, video_disabled, bg_disabled, swap_disabled = disable_all_buttons()
+            yield (
+                current_bg_removed,
+                current_output,
+                gr.update(),
+                make_download_update(current_output),
+                bg_disabled,
+                swap_disabled,
+                remove_disabled,
+                video_disabled,
+                history_update(),
+            )
+
+            removed, message = processor.remove_background(input_img)
+            if removed is None:
+                gr.Warning(message)
+                remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
+                    input_img,
+                    current_output,
+                    current_bg_removed,
+                    selected_bg,
+                    selected_face,
+                )
+                yield (
+                    current_bg_removed,
+                    current_output,
+                    gr.update(value=current_output),
+                    make_download_update(current_output),
+                    bg_ready,
+                    swap_ready,
+                    remove_ready,
+                    video_ready,
+                    history_update(),
+                )
+                return
+
+            gr.Info(message)
+            add_to_history(removed, "bg_remove")
+            remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
+                input_img,
+                removed,
+                removed,
+                selected_bg,
+                selected_face,
+            )
+            yield (
+                removed,
+                removed,
+                gr.update(value=removed),
+                make_download_update(removed, "background_removed"),
+                bg_ready,
+                swap_ready,
+                remove_ready,
+                video_ready,
+                history_update(),
+            )
+
+        def on_generate_video(
+            last_output: Optional[Image.Image],
+            input_img: Optional[Image.Image],
+            current_bg_removed: Optional[Image.Image],
+            selected_bg: Optional[Image.Image],
+            selected_face: Optional[Image.Image],
+        ):
+            base_image = last_output or input_img
+            if base_image is None:
+                gr.Warning("입력 이미지를 먼저 업로드해주세요.")
+                remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
+                    input_img,
+                    last_output,
+                    current_bg_removed,
+                    selected_bg,
+                    selected_face,
+                )
+                yield (
+                    gr.update(value=None),
+                    history_update(),
+                    remove_ready,
+                    video_ready,
+                    bg_ready,
+                    swap_ready,
+                )
+                return
+
+            remove_disabled, video_disabled, bg_disabled, swap_disabled = disable_all_buttons()
+            yield (
+                gr.update(),
+                history_update(),
+                remove_disabled,
+                video_disabled,
+                bg_disabled,
+                swap_disabled,
+            )
+
+            video_path, message = processor.generate_video(base_image)
+            if video_path is None:
+                gr.Warning(message)
+                remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
+                    input_img,
+                    last_output,
+                    current_bg_removed,
+                    selected_bg,
+                    selected_face,
+                )
+                yield (
+                    gr.update(value=None),
+                    history_update(),
+                    remove_ready,
+                    video_ready,
+                    bg_ready,
+                    swap_ready,
+                )
+                return
+
+            gr.Info(message)
+            add_to_history(base_image, "video")
+            remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
+                input_img,
+                last_output,
+                current_bg_removed,
+                selected_bg,
+                selected_face,
+            )
+            yield (
+                gr.update(value=video_path),
+                history_update(),
+                remove_ready,
+                video_ready,
+                bg_ready,
+                swap_ready,
+            )
+
+        def load_background_image(category: str, index: int) -> Optional[Image.Image]:
+            key = f"{category}_pil"
+            paths = bg_images.get(key, [])
+            if 0 <= index < len(paths):
+                path = paths[index]
+                return load_full_image(path)
+            return None
+
+        def on_select_background(
+            evt: gr.SelectData,
+            category: str,
+            bg_removed: Optional[Image.Image],
+        ):
+            index = getattr(evt, "index", None)
+            if index is None:
+                gr.Warning("선택 정보를 확인할 수 없습니다.")
+                return None, gr.update(interactive=False)
+            image = load_background_image(category, index)
+            if image is None:
+                gr.Warning("선택한 배경 이미지를 불러오지 못했습니다.")
+                return None, gr.update(interactive=False)
+            gr.Info("배경 이미지를 선택했습니다.")
+            ready = gr.update(interactive=bg_removed is not None)
+            return image, ready
+
+        def on_generate_background(
+            last_output: Optional[Image.Image],
+            selected_bg: Optional[Image.Image],
+            hq_mode: bool,
+            input_img: Optional[Image.Image],
+            current_bg_removed: Optional[Image.Image],
+            selected_face: Optional[Image.Image],
+        ):
+            if last_output is None:
+                gr.Warning("먼저 배경 제거를 실행해주세요.")
+                remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
+                    input_img,
+                    last_output,
+                    current_bg_removed,
+                    selected_bg,
+                    selected_face,
+                )
+                yield (
+                    last_output,
+                    gr.update(value=last_output),
+                    make_download_update(last_output),
+                    history_update(),
+                    remove_ready,
+                    video_ready,
+                    bg_ready,
+                    swap_ready,
+                )
+                return
+
+            if selected_bg is None:
+                gr.Warning("사용할 배경 이미지를 선택해주세요.")
+                remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
+                    input_img,
+                    last_output,
+                    current_bg_removed,
+                    selected_bg,
+                    selected_face,
+                )
+                yield (
+                    last_output,
+                    gr.update(value=last_output),
+                    make_download_update(last_output),
+                    history_update(),
+                    remove_ready,
+                    video_ready,
+                    bg_ready,
+                    swap_ready,
+                )
+                return
+
+            remove_disabled, video_disabled, bg_disabled, swap_disabled = disable_all_buttons()
+            yield (
+                last_output,
+                gr.update(value=last_output),
+                make_download_update(last_output),
+                history_update(),
+                remove_disabled,
+                video_disabled,
+                bg_disabled,
+                swap_disabled,
+            )
+
+            generated, message = processor.generate_background(last_output, selected_bg, hq_mode)
+            if generated is None:
+                gr.Warning(message)
+                remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
+                    input_img,
+                    last_output,
+                    current_bg_removed,
+                    selected_bg,
+                    selected_face,
+                )
+                yield (
+                    last_output,
+                    gr.update(value=last_output),
+                    make_download_update(last_output),
+                    history_update(),
+                    remove_ready,
+                    video_ready,
+                    bg_ready,
+                    swap_ready,
+                )
+                return
+
+            gr.Info(message)
+            add_to_history(generated, "bg_gen")
+            remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
+                input_img,
+                generated,
+                current_bg_removed,
+                selected_bg,
+                selected_face,
+            )
+            yield (
+                generated,
+                gr.update(value=generated),
+                make_download_update(generated, "background_generated"),
+                history_update(),
+                remove_ready,
+                video_ready,
+                bg_ready,
+                swap_ready,
+            )
+
+        def load_face_image(category: str, index: int) -> Optional[Image.Image]:
+            key = f"{category}_paths"
+            paths = face_images.get(key, [])
+            if 0 <= index < len(paths):
+                path = paths[index]
+                return load_full_image(path)
+            return None
+
+        def on_select_face(
+            evt: gr.SelectData,
+            category: str,
+            last_output: Optional[Image.Image],
+            input_img: Optional[Image.Image],
+        ):
+            base_image = last_output or input_img
+            index = getattr(evt, "index", None)
+            if index is None:
+                gr.Warning("선택 정보를 확인할 수 없습니다.")
+                return None, gr.update(interactive=False)
+            image = load_face_image(category, index)
+            if image is None:
+                gr.Warning("선택한 얼굴 이미지를 불러오지 못했습니다.")
+                return None, gr.update(interactive=False)
+            gr.Info("얼굴 이미지를 선택했습니다.")
+            ready = gr.update(interactive=base_image is not None)
+            return image, ready
+
+        def on_swap_face(
+            last_output: Optional[Image.Image],
+            input_img: Optional[Image.Image],
+            selected_face: Optional[Image.Image],
+            current_bg_removed: Optional[Image.Image],
+            selected_bg: Optional[Image.Image],
+        ):
+            base_image = last_output or input_img
+            if base_image is None:
+                gr.Warning("입력 이미지를 먼저 업로드해주세요.")
+                remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
+                    input_img,
+                    last_output,
+                    current_bg_removed,
+                    selected_bg,
+                    selected_face,
+                )
+                yield (
+                    last_output,
+                    gr.update(),
+                    make_download_update(last_output),
+                    history_update(),
+                    remove_ready,
+                    video_ready,
+                    bg_ready,
+                    swap_ready,
+                )
+                return
+
+            if selected_face is None:
+                gr.Warning("사용할 얼굴 이미지를 선택해주세요.")
+                remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
+                    input_img,
+                    last_output,
+                    current_bg_removed,
+                    selected_bg,
+                    selected_face,
+                )
+                yield (
+                    last_output,
+                    gr.update(value=base_image),
+                    make_download_update(last_output),
+                    history_update(),
+                    remove_ready,
+                    video_ready,
+                    bg_ready,
+                    swap_ready,
+                )
+                return
+
+            remove_disabled, video_disabled, bg_disabled, swap_disabled = disable_all_buttons()
+            yield (
+                last_output,
+                gr.update(value=base_image),
+                make_download_update(last_output),
+                history_update(),
+                remove_disabled,
+                video_disabled,
+                bg_disabled,
+                swap_disabled,
+            )
+
+            swapped, message = processor.swap_face(base_image, selected_face)
+            if swapped is None:
+                gr.Warning(message)
+                remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
+                    input_img,
+                    last_output,
+                    current_bg_removed,
+                    selected_bg,
+                    selected_face,
+                )
+                yield (
+                    last_output,
+                    gr.update(value=base_image),
+                    make_download_update(last_output),
+                    history_update(),
+                    remove_ready,
+                    video_ready,
+                    bg_ready,
+                    swap_ready,
+                )
+                return
+
+            gr.Info(message)
+            add_to_history(swapped, "face_swap")
+            remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
+                input_img,
+                swapped,
+                current_bg_removed,
+                selected_bg,
+                selected_face,
+            )
+            yield (
+                swapped,
+                gr.update(value=swapped),
+                make_download_update(swapped, "face_swap"),
+                history_update(),
+                remove_ready,
+                video_ready,
+                bg_ready,
+                swap_ready,
+            )
+
+        input_image.change(
+            on_upload,
+            inputs=[input_image],
+            outputs=[
+                input_state,
+                bg_removed_state,
+                selected_bg_state,
+                selected_face_state,
+                last_output_state,
+                output_image,
+                download_btn,
+                video_output,
+                remove_bg_btn,
+                generate_video_btn,
+                generate_bg_btn,
+                swap_face_btn,
+                history_gallery,
+            ],
+        )
+
+        remove_bg_btn.click(
+            handle_remove_background,
+            inputs=[
+                input_state,
+                bg_removed_state,
+                selected_bg_state,
+                last_output_state,
+                selected_face_state,
+            ],
+            outputs=[
+                bg_removed_state,
+                last_output_state,
+                output_image,
+                download_btn,
+                generate_bg_btn,
+                swap_face_btn,
+                remove_bg_btn,
+                generate_video_btn,
+                history_gallery,
+            ],
+        )
+
+        generate_video_btn.click(
+            on_generate_video,
+            inputs=[
+                last_output_state,
+                input_state,
+                bg_removed_state,
+                selected_bg_state,
+                selected_face_state,
+            ],
+            outputs=[
+                video_output,
+                history_gallery,
+                remove_bg_btn,
+                generate_video_btn,
+                generate_bg_btn,
+                swap_face_btn,
+            ],
+        )
+
+        indoor_gallery.select(
+            on_select_background,
+            inputs=[gr.State("indoor"), bg_removed_state],
+            outputs=[selected_bg_state, generate_bg_btn],
+        )
+
+        outdoor_gallery.select(
+            on_select_background,
+            inputs=[gr.State("outdoor"), bg_removed_state],
+            outputs=[selected_bg_state, generate_bg_btn],
+        )
+
+        generate_bg_btn.click(
+            on_generate_background,
+            inputs=[
+                last_output_state,
+                selected_bg_state,
+                hq_checkbox,
+                input_state,
+                bg_removed_state,
+                selected_face_state,
+            ],
+            outputs=[
+                last_output_state,
+                output_image,
+                download_btn,
+                history_gallery,
+                remove_bg_btn,
+                generate_video_btn,
+                generate_bg_btn,
+                swap_face_btn,
+            ],
+        )
+
+        man_gallery.select(
+            on_select_face,
+            inputs=[gr.State("man"), last_output_state, input_state],
+            outputs=[selected_face_state, swap_face_btn],
+        )
+
+        woman_gallery.select(
+            on_select_face,
+            inputs=[gr.State("woman"), last_output_state, input_state],
+            outputs=[selected_face_state, swap_face_btn],
+        )
+
+        swap_face_btn.click(
+            on_swap_face,
+            inputs=[
+                last_output_state,
+                input_state,
+                selected_face_state,
+                bg_removed_state,
+                selected_bg_state,
+            ],
+            outputs=[
+                last_output_state,
+                output_image,
+                download_btn,
+                history_gallery,
+                remove_bg_btn,
+                generate_video_btn,
+                generate_bg_btn,
+                swap_face_btn,
+            ],
+        )
+
+
+    return demo
+
+if __name__ == "__main__":
+    app = create_app()
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True,
+        auth=auth_fn
+    )

assets/POLYGOM_VIDEO_ver2_original.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7d042e834dac52034113fd56d3e9d950bfb3a85c1386dccfd84d6b3e88c80957
+size 14848608