feat: 사용자에게 표시되는 모든 정보 메시지를 한국어로 번역했습니다.

README.md

@@ -13,13 +13,12 @@ pinned: false
 
 ## ✨ 기능
 
-- **텍스트-이미지 생성**: 프롬프트를 입력하여 이미지 생성
-- **다양한 애니메이션 모델**: 7가지 인기 모델 지원
+- **텍스트 → 이미지 (txt2img)**: 프롬프트를 입력하여 이미지 생성
+- **이미지 → 이미지 (img2img)**: 기존 이미지를 애니메이션 스타일로 변환
+- **다양한 애니메이션 모델**: 8가지 인기 모델 지원
 - **네거티브 프롬프트**: 원하지 않는 요소 제외
-- **이미지 크기 조절**: 256x256 ~ 768x768
-- **스텝 수 조절**: 생성 품질 조절
-- **가이던스 스케일**: 프롬프트 준수 정도 조절
-- **시드 설정**: 재현 가능한 결과
+- **변환 강도 조절**: img2img에서 원본 유지 정도 조절
+- **REST API 지원**: 외부 앱에서 API 호출 가능
 
 ## 🤖 지원 모델
 
@@ -55,10 +54,91 @@ cherry blossoms, masterpiece, best quality, detailed
 - 첫 실행 시 모델 다운로드로 추가 시간이 필요합니다
 - GPU 스페이스를 사용하면 훨씬 빠른 생성이 가능합니다
 
+## 🔌 REST API 사용법
+
+이 프로젝트는 웹 인터페이스뿐만 아니라 REST API도 제공합니다.
+
+### 1. 텍스트 → 이미지 API (txt2img)
+- **엔드포인트**: `POST /api/generate`
+- **본문 구조 (JSON)**:
+```json
+{
+  "prompt": "생성할 프롬프트 (필수)",
+  "negative_prompt": "제외할 태그 (선택)",
+  "model_name": "사용할 모델 이름 (선택)",
+  "width": 512,
+  "height": 512,
+  "num_inference_steps": 25,
+  "guidance_scale": 7.5,
+  "seed": -1
+}
+```
+
+### 2. 이미지 → 이미지 API (img2img)
+- **엔드포인트**: `POST /api/img2img`
+- **본문 구조 (JSON)**:
+```json
+{
+  "image_base64": "Base64로 인코딩된 입력 이미지 (필수)",
+  "prompt": "변환할 스타일 프롬프트 (필수)",
+  "negative_prompt": "제외할 태그 (선택)",
+  "model_name": "사용할 모델 이름 (선택)",
+  "strength": 0.75,
+  "num_inference_steps": 25,
+  "guidance_scale": 7.5,
+  "seed": -1
+}
+```
+
+### 3. Python 호출 예제 (txt2img)
+```python
+import requests
+import base64
+
+url = "https://your-space.hf.space/api/generate"
+payload = {
+    "prompt": "1girl, anime, long hair, masterpiece",
+    "negative_prompt": "bad anatomy, blurry",
+}
+
+response = requests.post(url, json=payload)
+data = response.json()
+
+if data["success"]:
+    with open("output.png", "wb") as f:
+        f.write(base64.b64decode(data["image_base64"]))
+```
+
+### 4. Python 호출 예제 (img2img)
+```python
+import requests
+import base64
+
+# 이미지를 Base64로 인코딩
+with open("input.jpg", "rb") as f:
+    image_base64 = base64.b64encode(f.read()).decode("utf-8")
+
+url = "https://your-space.hf.space/api/img2img"
+payload = {
+    "image_base64": image_base64,
+    "prompt": "anime style, colorful, masterpiece",
+    "strength": 0.75
+}
+
+response = requests.post(url, json=payload)
+data = response.json()
+
+if data["success"]:
+    with open("output.png", "wb") as f:
+        f.write(base64.b64decode(data["image_base64"]))
+```
+
+
 ## 🛠️ 기술 스택
 
-- **Diffusers** - 허깅페이스 디퓨전 라이브러리
+- **FastAPI / Uvicorn** - REST API 서버
 - **Gradio** - 웹 인터페이스
+- **Diffusers** - 허깅페이스 디퓨전 라이브러리
 - **Docker** - 컨테이너 환경
 - **PyTorch** - 딥러닝 프레임워크
 

app.py

@@ -1,11 +1,11 @@
 """
 스테이블 디퓨전 WebUI - 허깅페이스 스페이스용
-Gradio 인터페이스 + REST API를 통한 이미지 생성 (애니메이션 모델 지원)
+Gradio 인터페이스 + REST API를 통한 이미지 생성 (txt2img + img2img 지원)
 """
 
 import gradio as gr
 import torch
-from diffusers import StableDiffusionPipeline, DPMSolverMultistepScheduler
+from diffusers import StableDiffusionPipeline, StableDiffusionImg2ImgPipeline, DPMSolverMultistepScheduler
 from PIL import Image
 import os
 import gc
@@ -13,6 +13,7 @@ import io
 import base64
 from typing import Optional
 from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel, Field
 
 # 사용 가능한 모델 목록
@@ -35,6 +36,7 @@ print(f"🚀 디바이스: {DEVICE}, 데이터 타입: {DTYPE}")
 
 # 현재 로드된 모델 정보
 current_model_id = None
+current_pipeline_type = None  # "txt2img" 또는 "img2img"
 pipe = None
 
 def clear_memory():
@@ -47,31 +49,47 @@ def clear_memory():
     if torch.cuda.is_available():
         torch.cuda.empty_cache()
 
-def load_model(model_name: str):
-    """모델 로드 함수"""
-    global pipe, current_model_id
+def load_model(model_name: str, pipeline_type: str = "txt2img"):
+    """
+    모델 로드 함수
+    
+    Args:
+        model_name: 모델 이름
+        pipeline_type: "txt2img" 또는 "img2img"
+    """
+    global pipe, current_model_id, current_pipeline_type
     
     model_id = MODELS.get(model_name)
     if model_id is None:
         return None, f"❌ 알 수 없는 모델: {model_name}"
     
-    # 이미 같은 모델이 로드되어 있으면 스킵
-    if current_model_id == model_id and pipe is not None:
-        return pipe, f"✅ {model_name} 이미 로드됨"
+    # 이미 같은 모델과 파이프라인 타입이 로드되어 있으면 스킵
+    if current_model_id == model_id and current_pipeline_type == pipeline_type and pipe is not None:
+        return pipe, f"✅ {model_name} 이미 로드됨 ({pipeline_type})"
     
     # 기존 모델 정리
     clear_memory()
     
-    print(f"📥 모델 로딩 중: {model_name}...")
+    print(f"📥 모델 로딩 중: {model_name} ({pipeline_type})...")
     
     try:
-        pipe = StableDiffusionPipeline.from_pretrained(
-            model_id,
-            torch_dtype=DTYPE,
-            safety_checker=None,
-            requires_safety_checker=False,
-            use_safetensors=False  # .bin 파일도 로드할 수 있도록 설정 (safetensors 없는 모델 지원)
-        )
+        # 파이프라인 타입에 따라 다른 클래스 사용
+        if pipeline_type == "img2img":
+            pipe = StableDiffusionImg2ImgPipeline.from_pretrained(
+                model_id,
+                torch_dtype=DTYPE,
+                safety_checker=None,
+                requires_safety_checker=False,
+                use_safetensors=False
+            )
+        else:
+            pipe = StableDiffusionPipeline.from_pretrained(
+                model_id,
+                torch_dtype=DTYPE,
+                safety_checker=None,
+                requires_safety_checker=False,
+                use_safetensors=False
+            )
         
         # 빠른 스케줄러 사용
         pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
@@ -85,14 +103,18 @@ def load_model(model_name: str):
             pipe.enable_vae_slicing()
         
         current_model_id = model_id
-        print(f"✅ 모델 로딩 완료: {model_name}")
+        current_pipeline_type = pipeline_type
+        print(f"✅ 모델 로딩 완료: {model_name} ({pipeline_type})")
         return pipe, f"✅ {model_name} 로딩 완료!"
     
     except Exception as e:
         print(f"❌ 모델 로딩 실패: {e}")
         return None, f"❌ 모델 로딩 실패: {str(e)}"
 
-def generate_image(
+# 기본 네거티브 프롬프트
+DEFAULT_NEGATIVE = "lowres, bad anatomy, bad hands, text, error, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, username, blurry"
+
+def generate_txt2img(
     model_name: str,
     prompt: str,
     negative_prompt: str = "",
@@ -103,22 +125,7 @@ def generate_image(
     seed: int = -1,
     progress=gr.Progress()
 ):
-    """
-    이미지 생성 함수
-    
-    Args:
-        model_name: 사용할 모델 이름
-        prompt: 이미지 생성 프롬프트
-        negative_prompt: 네거티브 프롬프트
-        num_inference_steps: 추론 스텝 수
-        guidance_scale: 가이던스 스케일
-        width: 이미지 너비
-        height: 이미지 높이
-        seed: 시드 값 (-1이면 랜덤)
-    
-    Returns:
-        생성된 이미지, 상태 메시지
-    """
+    """텍스트 → 이미지 생성 함수"""
     
     global pipe
     
@@ -127,17 +134,15 @@ def generate_image(
     
     # 모델 로드
     progress(0.1, desc="모델 로딩 중...")
-    pipe, status = load_model(model_name)
+    pipe, status = load_model(model_name, "txt2img")
     if pipe is None:
         return None, status
     
-    # 애니메이션 모델용 기본 네거티브 프롬프트
-    default_negative = "lowres, bad anatomy, bad hands, text, error, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, username, blurry"
-    
+    # 네거티브 프롬프트 설정
     if negative_prompt.strip():
-        full_negative = f"{negative_prompt}, {default_negative}"
+        full_negative = f"{negative_prompt}, {DEFAULT_NEGATIVE}"
     else:
-        full_negative = default_negative
+        full_negative = DEFAULT_NEGATIVE
     
     # 시드 설정
     if seed == -1:
@@ -147,9 +152,8 @@ def generate_image(
     
     try:
         progress(0.3, desc="이미지 생성 중...")
-        print(f"🎨 이미지 생성 중... 프롬프트: {prompt[:50]}...")
+        print(f"🎨 [txt2img] 이미지 생성 중... 프롬프트: {prompt[:50]}...")
         
-        # 이미지 생성
         result = pipe(
             prompt=prompt,
             negative_prompt=full_negative,
@@ -162,14 +166,90 @@ def generate_image(
         
         image = result.images[0]
         progress(1.0, desc="완료!")
-        print("✅ 이미지 생성 완료!")
+        print("✅ [txt2img] 이미지 생성 완료!")
         
         return image, f"✅ 생성 완료! (시드: {seed})"
     
     except Exception as e:
-        print(f"❌ 이미지 생성 실패: {e}")
+        print(f"❌ [txt2img] 이미지 생성 실패: {e}")
         return None, f"❌ 이미지 생성 실패: {str(e)}"
 
+def generate_img2img(
+    model_name: str,
+    input_image: Image.Image,
+    prompt: str,
+    negative_prompt: str = "",
+    strength: float = 0.75,
+    num_inference_steps: int = 25,
+    guidance_scale: float = 7.5,
+    seed: int = -1,
+    progress=gr.Progress()
+):
+    """이미지 → 이미지 변환 함수"""
+    
+    global pipe
+    
+    if input_image is None:
+        return None, "⚠️ 이미지를 업로드해주세요!"
+    
+    if not prompt.strip():
+        return None, "⚠️ 프롬프트를 입력해주세요!"
+    
+    # 모델 로드 (img2img 파이프라인)
+    progress(0.1, desc="모델 로딩 중...")
+    pipe, status = load_model(model_name, "img2img")
+    if pipe is None:
+        return None, status
+    
+    # 네거티브 프롬프트 설정
+    if negative_prompt.strip():
+        full_negative = f"{negative_prompt}, {DEFAULT_NEGATIVE}"
+    else:
+        full_negative = DEFAULT_NEGATIVE
+    
+    # 시드 설정
+    if seed == -1:
+        seed = torch.randint(0, 2**32 - 1, (1,)).item()
+    
+    generator = torch.Generator(device=DEVICE).manual_seed(int(seed))
+    
+    try:
+        progress(0.3, desc="이미지 변환 중...")
+        print(f"🖼️ [img2img] 이미지 변환 중... 프롬프트: {prompt[:50]}...")
+        
+        # 입력 이미지를 RGB로 변환하고 크기 조정
+        input_image = input_image.convert("RGB")
+        
+        # 이미지 크기를 64의 배수로 조정 (SD 요구사항)
+        w, h = input_image.size
+        w = (w // 64) * 64
+        h = (h // 64) * 64
+        if w == 0:
+            w = 512
+        if h == 0:
+            h = 512
+        input_image = input_image.resize((w, h), Image.LANCZOS)
+        
+        result = pipe(
+            prompt=prompt,
+            image=input_image,
+            negative_prompt=full_negative,
+            strength=strength,
+            num_inference_steps=num_inference_steps,
+            guidance_scale=guidance_scale,
+            generator=generator
+        )
+        
+        image = result.images[0]
+        progress(1.0, desc="완료!")
+        print("✅ [img2img] 이미지 변환 완료!")
+        
+        return image, f"✅ 변환 완료! (시드: {seed}, 강도: {strength})"
+    
+    except Exception as e:
+        print(f"❌ [img2img] 이미지 변환 실패: {e}")
+        return None, f"❌ 이미지 변환 실패: {str(e)}"
+
 # Gradio 인터페이스 생성
 def create_interface():
     """Gradio 웹 인터페이스 생성"""
@@ -237,136 +317,153 @@ def create_interface():
         # 헤더
         gr.HTML("""
             <div class="title">🌸 Anime Diffusion WebUI</div>
-            <div class="subtitle">애니메이션 스타일 이미지 생성기 | AI Art Generator</div>
+            <div class="subtitle">애니메이션 스타일 이미지 생성기 | Text-to-Image & Image-to-Image</div>
         """)
         
-        with gr.Row():
-            # 왼쪽: 입력 패널
-            with gr.Column(scale=1):
-                # 모델 선택
-                model_dropdown = gr.Dropdown(
-                    label="🤖 모델 선택 (Model)",
-                    choices=list(MODELS.keys()),
-                    value="🎨 Mistoon Anime V3 (카툰풍 애니메이션)",
-                    elem_classes=["model-dropdown"]
-                )
+        # 탭으로 txt2img / img2img 분리
+        with gr.Tabs():
+            # ============================================
+            # 탭 1: 텍스트 → 이미지 (txt2img)
+            # ============================================
+            with gr.TabItem("🎨 텍스트 → 이미지"):
+                with gr.Row():
+                    # 왼쪽: 입력 패널
+                    with gr.Column(scale=1):
+                        txt2img_model = gr.Dropdown(
+                            label="🤖 모델 선택",
+                            choices=list(MODELS.keys()),
+                            value="🎨 Mistoon Anime V3 (카툰풍 애니메이션)",
+                            elem_classes=["model-dropdown"]
+                        )
+                        
+                        txt2img_prompt = gr.Textbox(
+                            label="📝 프롬프트",
+                            placeholder="1girl, anime style, beautiful, masterpiece, best quality",
+                            lines=3
+                        )
+                        
+                        txt2img_negative = gr.Textbox(
+                            label="🚫 네거티브 프롬프트",
+                            placeholder="추가할 네거티브 프롬프트 (기본값이 자동 적용됩니다)",
+                            lines=2
+                        )
+                        
+                        with gr.Row():
+                            txt2img_width = gr.Slider(label="📐 너비", minimum=256, maximum=768, value=512, step=64)
+                            txt2img_height = gr.Slider(label="📐 높이", minimum=256, maximum=768, value=768, step=64)
+                        
+                        with gr.Row():
+                            txt2img_steps = gr.Slider(label="🔄 스텝 수", minimum=10, maximum=50, value=25, step=1)
+                            txt2img_guidance = gr.Slider(label="🎯 CFG 스케일", minimum=1.0, maximum=15.0, value=7.0, step=0.5)
+                        
+                        txt2img_seed = gr.Number(label="🎲 시드 (-1 = 랜덤)", value=-1, precision=0)
+                        
+                        txt2img_btn = gr.Button("🚀 이미지 생성", elem_classes=["generate-btn"])
+                        txt2img_status = gr.Textbox(label="📊 상태", value="프롬프트를 입력해주세요", interactive=False)
+                    
+                    # 오른쪽: 출력 패널
+                    with gr.Column(scale=1):
+                        txt2img_output = gr.Image(label="🖼️ 생성된 이미지", type="pil", elem_classes=["output-image"])
                 
-                prompt = gr.Textbox(
-                    label="📝 프롬프트 (Prompt)",
-                    placeholder="1girl, solo, long hair, blue eyes, school uniform, cherry blossoms, detailed, masterpiece, best quality",
-                    lines=3
+                # 예제
+                gr.Examples(
+                    examples=[
+                        ["🎨 Mistoon Anime V3 (카툰풍 애니메이션)", "1girl, solo, colorful, vibrant colors, cartoon style, school uniform, masterpiece", ""],
+                        ["🌸 Anything V5 (애니메이션)", "1girl, solo, long blue hair, cherry blossoms, detailed, masterpiece, best quality", ""],
+                        ["💜 Counterfeit V3 (고품질 애니메이션)", "1girl, kimono, japanese garden, autumn leaves, ultra detailed, 8k", ""],
+                    ],
+                    inputs=[txt2img_model, txt2img_prompt, txt2img_negative],
+                    label="💡 예제 프롬프트"
                 )
                 
-                negative_prompt = gr.Textbox(
-                    label="🚫 네거티브 프롬프트 (Negative Prompt)",
-                    placeholder="추가할 네거티브 프롬프트 (기본값이 자동 적용됩니다)",
-                    lines=2
+                # 이벤트 핸들러
+                txt2img_btn.click(
+                    fn=generate_txt2img,
+                    inputs=[txt2img_model, txt2img_prompt, txt2img_negative, txt2img_steps, txt2img_guidance, txt2img_width, txt2img_height, txt2img_seed],
+                    outputs=[txt2img_output, txt2img_status]
                 )
-                
-                with gr.Row():
-                    width = gr.Slider(
-                        label="📐 너비",
-                        minimum=256,
-                        maximum=768,
-                        value=512,
-                        step=64
-                    )
-                    height = gr.Slider(
-                        label="📐 높이",
-                        minimum=256,
-                        maximum=768,
-                        value=768,
-                        step=64
-                    )
-                
+            
+            # ============================================
+            # 탭 2: 이미지 → 이미지 (img2img)
+            # ============================================
+            with gr.TabItem("🖼️ 이미지 → 이미지"):
                 with gr.Row():
-                    num_steps = gr.Slider(
-                        label="🔄 스텝 수",
-                        minimum=10,
-                        maximum=50,
-                        value=25,
-                        step=1
-                    )
-                    guidance = gr.Slider(
-                        label="🎯 CFG 스케일",
-                        minimum=1.0,
-                        maximum=15.0,
-                        value=7.0,
-                        step=0.5
-                    )
+                    # 왼쪽: 입력 패널
+                    with gr.Column(scale=1):
+                        img2img_model = gr.Dropdown(
+                            label="🤖 모델 선택",
+                            choices=list(MODELS.keys()),
+                            value="🎨 Mistoon Anime V3 (카툰풍 애니메이션)",
+                            elem_classes=["model-dropdown"]
+                        )
+                        
+                        img2img_input = gr.Image(
+                            label="📤 입력 이미지 (실사, 스케치 등)",
+                            type="pil",
+                            height=200
+                        )
+                        
+                        img2img_prompt = gr.Textbox(
+                            label="📝 프롬프트 (변환할 스타일)",
+                            placeholder="anime style, colorful, masterpiece, best quality",
+                            lines=3
+                        )
+                        
+                        img2img_negative = gr.Textbox(
+                            label="🚫 네거티브 프롬프트",
+                            placeholder="추가할 네거티브 프롬프트",
+                            lines=2
+                        )
+                        
+                        img2img_strength = gr.Slider(
+                            label="💪 변환 강도 (0.0=원본 유지, 1.0=완전 변환)",
+                            minimum=0.1,
+                            maximum=1.0,
+                            value=0.75,
+                            step=0.05
+                        )
+                        
+                        with gr.Row():
+                            img2img_steps = gr.Slider(label="🔄 스텝 수", minimum=10, maximum=50, value=25, step=1)
+                            img2img_guidance = gr.Slider(label="🎯 CFG 스케일", minimum=1.0, maximum=15.0, value=7.0, step=0.5)
+                        
+                        img2img_seed = gr.Number(label="🎲 시드 (-1 = 랜덤)", value=-1, precision=0)
+                        
+                        img2img_btn = gr.Button("🚀 이미지 변환", elem_classes=["generate-btn"])
+                        img2img_status = gr.Textbox(label="📊 상태", value="이미지와 프롬프트를 입력해주세요", interactive=False)
+                    
+                    # 오른쪽: 출력 패널
+                    with gr.Column(scale=1):
+                        img2img_output = gr.Image(label="🖼️ 변환된 이미지", type="pil", elem_classes=["output-image"])
                 
-                seed = gr.Number(
-                    label="🎲 시드 (-1 = 랜덤)",
-                    value=-1,
-                    precision=0
-                )
-                
-                generate_btn = gr.Button(
-                    "🚀 이미지 생성",
-                    elem_classes=["generate-btn"]
-                )
+                # img2img 가이드
+                with gr.Accordion("📖 img2img 사용 가이드", open=False):
+                    gr.Markdown("""
+                    ### 🖼️ Image-to-Image 변환 가이드
+                    
+                    **사용 방법**:
+                    1. 변환하고 싶은 이미지를 업로드합니다 (실사 사진, 스케치 등)
+                    2. 원하는 스타일을 프롬프트로 입력합니다
+                    3. 변환 강도를 조절합니다
+                    
+                    **변환 강도 (Strength) 설명**:
+                    - `0.3` - 원본 이미지를 많이 유지 (미세한 스타일 변화)
+                    - `0.5` - 균형 잡힌 변환
+                    - `0.75` - 프롬프트에 더 충실한 변환 (권장)
+                    - `1.0` - 거의 새로 생성 (원본 무시)
+                    
+                    **추천 프롬프트**:
+                    - 실사 → 애니메이션: `anime style, colorful, masterpiece`
+                    - 스케치 → 완성본: `detailed illustration, colored, vibrant`
+                    - 지브리 스타일: `studio ghibli style, soft colors, fantasy`
+                    """)
                 
-                status_text = gr.Textbox(
-                    label="📊 상태",
-                    value="모델을 선택하고 프롬프트를 입력해주세요",
-                    interactive=False,
-                    elem_classes=["status-box"]
+                # 이벤트 핸들러
+                img2img_btn.click(
+                    fn=generate_img2img,
+                    inputs=[img2img_model, img2img_input, img2img_prompt, img2img_negative, img2img_strength, img2img_steps, img2img_guidance, img2img_seed],
+                    outputs=[img2img_output, img2img_status]
                 )
-            
-            # 오른쪽: 출력 패널
-            with gr.Column(scale=1):
-                output_image = gr.Image(
-                    label="🖼️ 생성된 이미지",
-                    type="pil",
-                    elem_classes=["output-image"]
-                )
-        
-        # 예제 - 애니메이션 스타일
-        gr.Examples(
-            examples=[
-                ["🎨 Mistoon Anime V3 (카툰풍 애니메이션)", "1girl, solo, colorful, vibrant colors, thick outlines, cartoon style, school uniform, happy expression, masterpiece, best quality", ""],
-                ["🎨 Mistoon Anime V3 (카툰풍 애니메이션)", "1boy, solo, colorful hair, bright eyes, modern clothes, city background, dynamic pose, cartoon style, masterpiece", ""],
-                ["🌸 Anything V5 (애니메이션)", "1girl, solo, long blue hair, heterochromia, school uniform, cherry blossoms, sitting, detailed background, masterpiece, best quality", ""],
-                ["💜 Counterfeit V3 (고품질 애니메이션)", "1girl, kimono, japanese garden, autumn leaves, serene expression, ultra detailed, 8k", ""],
-                ["✨ DreamShaper V8 (다목적)", "beautiful anime girl, studio ghibli style, forest spirit, magical atmosphere, soft lighting", ""],
-                ["🌟 MeinaMix (애니메이션)", "1girl, maid outfit, silver hair, purple eyes, cafe interior, warm lighting, masterpiece", ""],
-            ],
-            inputs=[model_dropdown, prompt, negative_prompt],
-            label="💡 예제 프롬프트 (클릭하여 적용)"
-        )
-        
-        # 프롬프트 가이드
-        with gr.Accordion("📖 프롬프트 작성 가이드", open=False):
-            gr.Markdown("""
-            ### 🎨 애니메이션 스타일 프롬프트 팁
-            
-            **품질 태그** (권장):
-            - `masterpiece, best quality, high quality` - 고품질 출력
-            - `detailed, ultra detailed` - 디테일 강조
-            - `8k, highres` - 고해상도 느낌
-            
-            **캐릭터 묘사**:
-            - `1girl, 1boy, solo` - 캐릭터 수
-            - `long hair, short hair, blue eyes` - 외모
-            - `school uniform, dress, armor` - 복장
-            
-            **배경/분위기**:
-            - `cherry blossoms, night sky, fantasy` - 배경
-            - `dramatic lighting, soft lighting` - 조명
-            - `floating, dynamic pose` - 포즈
-            
-            **스타일**:
-            - `anime style, manga style` - 일반 애니메이션
-            - `studio ghibli style` - 지브리 스타일
-            - `chibi, cute` - 귀여운 스타일
-            """)
-        
-        # 이벤트 핸들러
-        generate_btn.click(
-            fn=generate_image,
-            inputs=[model_dropdown, prompt, negative_prompt, num_steps, guidance, width, height, seed],
-            outputs=[output_image, status_text]
-        )
         
         # 푸터
         gr.HTML("""
@@ -385,12 +482,9 @@ def create_interface():
 
 # API 요청/응답 모델 정의
 class GenerateRequest(BaseModel):
-    """이미지 생성 요청 모델"""
+    """텍스트 → 이미지 생성 요청"""
     prompt: str = Field(..., description="이미지 생성 프롬프트")
-    model_name: str = Field(
-        default="🎨 Mistoon Anime V3 (카툰풍 애니메이션)",
-        description="사용할 모델 이름"
-    )
+    model_name: str = Field(default="🎨 Mistoon Anime V3 (카툰풍 애니메이션)", description="사용할 모델 이름")
     negative_prompt: str = Field(default="", description="네거티브 프롬프트")
     num_inference_steps: int = Field(default=25, ge=10, le=50, description="추론 스텝 수")
     guidance_scale: float = Field(default=7.5, ge=1.0, le=15.0, description="CFG 스케일")
@@ -398,8 +492,19 @@ class GenerateRequest(BaseModel):
     height: int = Field(default=512, ge=256, le=768, description="이미지 높이")
     seed: int = Field(default=-1, description="시드 값 (-1이면 랜덤)")
 
+class Img2ImgRequest(BaseModel):
+    """이미지 → 이미지 변환 요청"""
+    image_base64: str = Field(..., description="입력 이미지 (Base64 인코딩)")
+    prompt: str = Field(..., description="변환 프롬프트")
+    model_name: str = Field(default="🎨 Mistoon Anime V3 (카툰풍 애니메이션)", description="사용할 모델 이름")
+    negative_prompt: str = Field(default="", description="네거티브 프롬프트")
+    strength: float = Field(default=0.75, ge=0.1, le=1.0, description="변환 강도")
+    num_inference_steps: int = Field(default=25, ge=10, le=50, description="추론 스텝 수")
+    guidance_scale: float = Field(default=7.5, ge=1.0, le=15.0, description="CFG 스케일")
+    seed: int = Field(default=-1, description="시드 값 (-1이면 랜덤)")
+
 class GenerateResponse(BaseModel):
-    """이미지 생성 응답 모델"""
+    """이미지 생성 응답"""
     success: bool
     message: str
     image_base64: Optional[str] = None
@@ -412,8 +517,17 @@ class ModelsResponse(BaseModel):
 # FastAPI 앱 생성
 api_app = FastAPI(
     title="Anime Diffusion API",
-    description="애니메이션 스타일 이미지 생성 REST API",
-    version="1.0.0"
+    description="애니메이션 스타일 이미지 생성 REST API (txt2img + img2img)",
+    version="2.0.0"
+)
+
+# CORS 설정 추가 (외부 호출 허용)
+api_app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
 )
 
 @api_app.get("/api/models", response_model=ModelsResponse)
@@ -422,9 +536,9 @@ async def get_models():
     return ModelsResponse(models=list(MODELS.keys()))
 
 @api_app.post("/api/generate", response_model=GenerateResponse)
-async def api_generate_image(request: GenerateRequest):
+async def api_generate_txt2img(request: GenerateRequest):
     """
-    이미지 생성 API
+    텍스트 → 이미지 생성 API
     
     프롬프트를 전달하면 Base64로 인코딩된 이미지를 반환합니다.
     """
@@ -434,23 +548,18 @@ async def api_generate_image(request: GenerateRequest):
         raise HTTPException(status_code=400, detail="프롬프트를 입력해주세요")
     
     if request.model_name not in MODELS:
-        raise HTTPException(
-            status_code=400,
-            detail=f"알 수 없는 모델입니다. 사용 가능한 모델: {list(MODELS.keys())}"
-        )
+        raise HTTPException(status_code=400, detail=f"알 수 없는 모델입니다. 사용 가능한 모델: {list(MODELS.keys())}")
     
     # 모델 로드
-    pipe, status = load_model(request.model_name)
+    pipe, status = load_model(request.model_name, "txt2img")
     if pipe is None:
         raise HTTPException(status_code=500, detail=status)
     
     # 네거티브 프롬프트 설정
-    default_negative = "lowres, bad anatomy, bad hands, text, error, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, username, blurry"
-    
     if request.negative_prompt.strip():
-        full_negative = f"{request.negative_prompt}, {default_negative}"
+        full_negative = f"{request.negative_prompt}, {DEFAULT_NEGATIVE}"
     else:
-        full_negative = default_negative
+        full_negative = DEFAULT_NEGATIVE
     
     # 시드 설정
     seed = request.seed
@@ -460,9 +569,8 @@ async def api_generate_image(request: GenerateRequest):
     generator = torch.Generator(device=DEVICE).manual_seed(int(seed))
     
     try:
-        print(f"🎨 [API] 이미지 생성 중... 프롬프트: {request.prompt[:50]}...")
+        print(f"🎨 [API txt2img] 이미지 생성 중... 프롬프트: {request.prompt[:50]}...")
         
-        # 이미지 생성
         result = pipe(
             prompt=request.prompt,
             negative_prompt=full_negative,
@@ -481,7 +589,7 @@ async def api_generate_image(request: GenerateRequest):
         buffer.seek(0)
         image_base64 = base64.b64encode(buffer.getvalue()).decode("utf-8")
         
-        print(f"✅ [API] 이미지 생성 완료! (시드: {seed})")
+        print(f"✅ [API txt2img] 이미지 생성 완료! (시드: {seed})")
         
         return GenerateResponse(
             success=True,
@@ -491,7 +599,91 @@ async def api_generate_image(request: GenerateRequest):
         )
     
     except Exception as e:
-        print(f"❌ [API] 이미지 생성 실패: {e}")
+        print(f"❌ [API txt2img] 이미지 생성 실패: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@api_app.post("/api/img2img", response_model=GenerateResponse)
+async def api_generate_img2img(request: Img2ImgRequest):
+    """
+    이미지 → 이미지 변환 API
+    
+    Base64 이미지와 프롬프트를 전달하면 변환된 이미지를 반환합니다.
+    """
+    global pipe
+    
+    if not request.prompt.strip():
+        raise HTTPException(status_code=400, detail="프롬프트를 입력해주세요")
+    
+    if request.model_name not in MODELS:
+        raise HTTPException(status_code=400, detail=f"알 수 없는 모델입니다. 사용 가능한 모델: {list(MODELS.keys())}")
+    
+    # Base64 이미지 디코딩
+    try:
+        image_data = base64.b64decode(request.image_base64)
+        input_image = Image.open(io.BytesIO(image_data)).convert("RGB")
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"이미지 디코딩 실패: {str(e)}")
+    
+    # 모델 로드 (img2img)
+    pipe, status = load_model(request.model_name, "img2img")
+    if pipe is None:
+        raise HTTPException(status_code=500, detail=status)
+    
+    # 네거티브 프롬프트 설정
+    if request.negative_prompt.strip():
+        full_negative = f"{request.negative_prompt}, {DEFAULT_NEGATIVE}"
+    else:
+        full_negative = DEFAULT_NEGATIVE
+    
+    # 시드 설정
+    seed = request.seed
+    if seed == -1:
+        seed = torch.randint(0, 2**32 - 1, (1,)).item()
+    
+    generator = torch.Generator(device=DEVICE).manual_seed(int(seed))
+    
+    try:
+        print(f"🖼️ [API img2img] 이미지 변환 중... 프롬프트: {request.prompt[:50]}...")
+        
+        # 이미지 크기를 64의 배수로 조정
+        w, h = input_image.size
+        w = (w // 64) * 64
+        h = (h // 64) * 64
+        if w == 0:
+            w = 512
+        if h == 0:
+            h = 512
+        input_image = input_image.resize((w, h), Image.LANCZOS)
+        
+        result = pipe(
+            prompt=request.prompt,
+            image=input_image,
+            negative_prompt=full_negative,
+            strength=request.strength,
+            num_inference_steps=request.num_inference_steps,
+            guidance_scale=request.guidance_scale,
+            generator=generator
+        )
+        
+        image = result.images[0]
+        
+        # 이미지를 Base64로 인코딩
+        buffer = io.BytesIO()
+        image.save(buffer, format="PNG")
+        buffer.seek(0)
+        image_base64 = base64.b64encode(buffer.getvalue()).decode("utf-8")
+        
+        print(f"✅ [API img2img] 이미지 변환 완료! (시드: {seed})")
+        
+        return GenerateResponse(
+            success=True,
+            message="이미지 변환 완료",
+            image_base64=image_base64,
+            seed=seed
+        )
+    
+    except Exception as e:
+        print(f"❌ [API img2img] 이미지 변환 실패: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
 @api_app.get("/api/health")
@@ -500,7 +692,8 @@ async def health_check():
     return {
         "status": "healthy",
         "device": DEVICE,
-        "model_loaded": current_model_id is not None
+        "model_loaded": current_model_id is not None,
+        "pipeline_type": current_pipeline_type
     }
 
 # ================================
@@ -508,6 +701,8 @@ async def health_check():
 # ================================
 if __name__ == "__main__":
     print("🌸 Anime Diffusion WebUI + API 시작...")
+    print("  - txt2img: 텍스트 → 이미지 생성")
+    print("  - img2img: 이미지 → 이미지 변환")
     
     # Gradio 앱 생성
     demo = create_interface()