Update src/app.py

src/app.py

@@ -1,2 +1,820 @@
+# app.py
+import gradio as gr
+import pillow_heif
+import spaces
+import torch
+from PIL import Image, ImageEnhance, ImageFilter  # ImageFilter 추가
+from refiners.fluxion.utils import manual_seed, no_grad
+
+from utils import load_ic_light, resize_modulo_8
+
+import zipfile
+from io import BytesIO
+import tempfile
+import cv2  # OpenCV 추가
+import numpy as np  # NumPy 추가
+
+# HEIF/AVIF 이미지 지원 등록
+pillow_heif.register_heif_opener()
+pillow_heif.register_avif_opener()
+
+# GPU 설정
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+DTYPE = torch.float16 if torch.cuda.is_available() and torch.cuda.is_bf16_supported() else torch.float32
+ic_light = load_ic_light(device=DEVICE, dtype=DTYPE)
+
+# 모델을 지정된 디바이스로 이동
+ic_light.to(device=DEVICE, dtype=DTYPE)
+ic_light.device = DEVICE
+ic_light.dtype = DTYPE
+ic_light.solver = ic_light.solver.to(device=DEVICE, dtype=DTYPE)
+
+# 번역 관련 라이브러리 및 설정
 import os
-exec(os.environ.get('APP'))
+from openai import OpenAI
+import uuid
+import time
+import logging
+import random
+from datetime import datetime
+
+# 로깅 설정
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# API 키 설정
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+
+# API 클라이언트 설정
+openai_client = OpenAI(api_key=OPENAI_API_KEY)
+
+def validate_input(text: str) -> bool:
+    """입력 텍스트 유효성 검사"""
+    if not text.strip():
+        return False
+    if not any('\u3131' <= char <= '\u318F' or '\uAC00' <= char <= '\uD7A3' for char in text):
+        return False
+    return True
+
+def translate_to_english(input_text: str):
+    """한국어를 영어로 번역하는 함수 (GPT-4-mini 사용)"""
+    logger.info("GPT-4-mini 번역 시작")
+
+    if not validate_input(input_text):
+        logger.info("유효하지 않은 입력입니다.")
+        return "유효하지 않은 입력입니다. 한글을 포함한 텍스트를 입력해주세요."
+
+    try:
+        # 현재 시간을 기반으로 랜덤 시드 설정
+        current_time = int(time.time() * 1000)
+        random.seed(current_time)
+        
+        # 온도(temperature)와 top_p 값을 매번 랜덤하게 설정
+        temperature = random.uniform(0.4, 0.85)
+        top_p = random.uniform(0.9, 0.98)
+        
+        request_id = str(uuid.uuid4())[:8]
+        timestamp_micro = int(time.time() * 1000000) % 1000
+        system_msg = f"REQ-{request_id}-{timestamp_micro}"
+
+        # 시간에 따라 변화하는 프롬프트 수식어 추가
+        current_hour = datetime.now().hour
+        time_context = f"Consider the current time is {current_hour}:00. "
+
+        response = openai_client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {
+                    "role": "system",
+                    "content": system_msg
+                },
+                {
+                    "role": "user", 
+                    "content": f"""
+1. Translate the input Korean text into English with these rules:
+2. Output ONLY the English translation.
+3. Create a coherent, brief scene using provided words/phrases.
+4. Stay strictly within the scope of input words.
+5. Maintain flow and natural transitions.
+6. Keep scene descriptions concise but complete.
+7. Do not add external elements.
+8. Focus on core scene elements.
+9. Preserve original meaning and intent.
+10. No explanations or meta-commentary.
+11. No formatting beyond basic text.
+12. Just the direct English translation.
+Additional guidance:
+13. Use input words harmoniously.
+14. Create clear mental imagery.
+15. Keep scene contained and focused.
+16. Ensure logical connections.
+17. Maintain narrative flow.
+Input: {input_text} [Seed: {current_time}]
+"""
+                }
+            ],
+            max_tokens=100,
+            temperature=temperature,
+            top_p=top_p,
+            seed=current_time
+        )
+        translated = response.choices[0].message.content.strip()
+        logger.info("GPT-4-mini 번역 완료")
+        return translated
+
+    except Exception as e:
+        logger.error(f"번역 중 오류 발생: {str(e)}")
+        return f"번역 중 오류가 발생했습니다: {str(e)}"
+
+@spaces.GPU(duration=120)  # GPU 사용을 명시하는 데코레이터
+@no_grad()
+def generate_images(
+    image: Image.Image,
+    prompt: str,
+) -> tuple[Image.Image, Image.Image, Image.Image, Image.Image]:
+    assert image.mode == "RGBA", "입력 이미지는 RGBA 모드여야 합니다."
+
+    # 시드 랜덤 설정
+    seed = torch.seed()  # 랜덤 시드 생성
+    manual_seed(seed)
+
+    # 네거티브 프롬프트 고정
+    negative_prompt = "dirty, messy, worst quality, low quality, watermark, signature, jpeg artifacts, deformed, monochrome, black and white"
+
+    # 기본값 설정
+    condition_scale = 1.25
+    num_inference_steps = 25
+    strength_first_pass = 0.9
+    strength_second_pass = 0.5
+
+    # 이미지 크기 조정
+    image = resize_modulo_8(image, 768)
+
+    # RGB와 알파 채널 분리
+    mask = image.getchannel("A")
+    image_rgb = image.convert("RGB")
+
+    # 텍스트 임베딩 계산
+    clip_text_embedding = ic_light.compute_clip_text_embedding(text=prompt, negative_text=negative_prompt)
+    ic_light.set_ic_light_condition(image=image_rgb, mask=mask)
+
+    # 조명 선호도 기본값 설정
+    light_pref_image = None  # "None"으로 고정
+
+    if light_pref_image is None:
+        x = torch.randn_like(ic_light._ic_light_condition)  # pyright: ignore[reportPrivateUsage]
+        strength_first_pass = 1.0
+    else:
+        x = ic_light.lda.image_to_latents(light_pref_image)
+        x = ic_light.solver.add_noise(x, noise=torch.randn_like(x), step=0)
+
+    # 첫 번째 패스 설정
+    num_steps = int(round(num_inference_steps / strength_first_pass))
+    first_step = int(num_steps * (1 - strength_first_pass))
+    ic_light.set_inference_steps(num_steps, first_step)
+
+    # 첫 번째 패스
+    for step in ic_light.steps:
+        x = ic_light(
+            x,
+            step=step,
+            clip_text_embedding=clip_text_embedding,
+            condition_scale=condition_scale,
+        )
+
+    # 두 번째 패스 설정
+    num_steps = int(round(num_inference_steps / strength_second_pass))
+    first_step = int(num_steps * (1 - strength_second_pass))
+    ic_light.set_inference_steps(num_steps, first_step)
+
+    # 초기화된 라텐트
+    x = ic_light.solver.add_noise(x, noise=torch.randn_like(x), step=first_step)
+
+    # 두 번째 패스
+    for step in ic_light.steps:
+        x = ic_light(
+            x,
+            step=step,
+            clip_text_embedding=clip_text_embedding,
+            condition_scale=condition_scale,
+        )
+
+    # 배경 이미지 생성
+    bg_image = ic_light.lda.latents_to_image(x)
+
+    # 최종 이미지 합성 (전경은 조정 없이 합성)
+    result = Image.composite(image_rgb, bg_image, mask)
+
+    return image_rgb, bg_image, mask, result  # image_rgb 추가
+
+@no_grad()
+def adjust_final_image(
+    bg_image: Image.Image,
+    mask: Image.Image,
+    bg_brightness: float,
+    bg_contrast: float,
+    bg_saturation: float,
+    bg_temperature: float,  # 색온도 파라미터
+    bg_vibrance: float,
+    bg_color_mixer_blues: float,
+    bg_shadows: float,  # Shadows 파라미터
+) -> Image.Image:
+    """배경 이미지를 조정하는 함수"""
+    print("Adjusting Final Image with the following parameters:")
+    print(f"Background - Brightness: {bg_brightness}, Contrast: {bg_contrast}, "
+          f"Saturation: {bg_saturation}, Temperature: {bg_temperature}, "
+          f"Vibrance: {bg_vibrance}, Blues: {bg_color_mixer_blues}, Shadows: {bg_shadows}")
+
+    # 밝기 조정
+    enhancer = ImageEnhance.Brightness(bg_image)
+    bg_image = enhancer.enhance(bg_brightness)
+
+    # 대비 조정
+    enhancer = ImageEnhance.Contrast(bg_image)
+    bg_image = enhancer.enhance(bg_contrast)
+
+    # 채도 조정
+    enhancer = ImageEnhance.Color(bg_image)
+    bg_image = enhancer.enhance(bg_saturation)
+
+    # 색온도 조정
+    if bg_temperature != 0.0:
+        # PIL 이미지를 OpenCV 형식으로 변환
+        cv_image = cv2.cvtColor(np.array(bg_image), cv2.COLOR_RGB2BGR).astype(np.float32)
+        
+        # 색온도 조정 로직
+        value = float(bg_temperature) * 30  # 색온도 효과 스케일 조절
+        if value > 0:  # 따뜻하게
+            cv_image[:, :, 2] = cv_image[:, :, 2] + value  # Red 채널 증가
+            cv_image[:, :, 0] = cv_image[:, :, 0] - value  # Blue 채널 감소
+        else:  # 차갑게
+            cv_image[:, :, 2] = cv_image[:, :, 2] + value  # Red 채널 감소
+            cv_image[:, :, 0] = cv_image[:, :, 0] - value  # Blue 채널 증가
+        
+        # 채널 값 클리핑
+        cv_image[:, :, 2] = np.clip(cv_image[:, :, 2], 0, 255)
+        cv_image[:, :, 0] = np.clip(cv_image[:, :, 0], 0, 255)
+        
+        # 다시 PIL 이미지로 변환
+        bg_image = Image.fromarray(cv2.cvtColor(cv_image.astype(np.uint8), cv2.COLOR_BGR2RGB))
+
+    # 활기(Vibrance) 조정: 채도를 비례적으로 증가/감소
+    if bg_vibrance != 0.0:
+        # Vibrance는 일반적인 채도보다 덜 민감하게 채도를 조절
+        converter = ImageEnhance.Color(bg_image)
+        factor = 1 + (bg_vibrance / 100.0)
+        bg_image = converter.enhance(factor)
+
+    # 컬러 믹서 블루 조정: 파랑 채널을 개별적으로 조정
+    if bg_color_mixer_blues != 0.0:
+        r, g, b = bg_image.split()
+        b = b.point(lambda p: min(255, max(0, p + bg_color_mixer_blues)))
+        bg_image = Image.merge("RGB", (r, g, b))
+
+    # Shadows 조정: 어두운 영역을 조정하고 가장자리를 부드럽게 처리
+    if bg_shadows != 0.0:
+        # 어두운 영역을 식별하기 위해 그레이스케일 변환
+        grayscale = bg_image.convert("L")
+        # 어두운 영역 마스크 생��� (임계값 128 이하)
+        mask_dark = grayscale.point(lambda p: p < 128 and 255)
+        mask_dark = mask_dark.convert("L")  # 그레이스케일로 변환
+
+        # 마스크 가장자리 부드럽게 처리 (Gaussian Blur 적용)
+        mask_dark = mask_dark.filter(ImageFilter.GaussianBlur(radius=10))  # 블러 반경 조절 가능
+
+        # 그림자 조정을 위한 밝기 조정
+        if bg_shadows < 0:
+            # 어두운 영역을 더 어둡게
+            factor = 1 + (bg_shadows / 100.0)  # 예: -50 -> 0.5
+            enhancer = ImageEnhance.Brightness(bg_image)
+            dark_adjusted = enhancer.enhance(factor)
+        else:
+            # 어두운 영역을 밝게
+            factor = 1 + (bg_shadows / 100.0)  # 예: 50 -> 1.5
+            enhancer = ImageEnhance.Brightness(bg_image)
+            dark_adjusted = enhancer.enhance(factor)
+
+        # 마스크를 사용하여 어두운 영역만 조정된 이미지와 합성
+        bg_image = Image.composite(dark_adjusted, bg_image, mask_dark)
+
+    # 조정된 배경 반환
+    return bg_image
+
+def download_all(original_image, bg_image, final_image):
+    """
+    모든 이미지를 ZIP 파일으로 압축하여 다운로드할 수 있도록 합니다.
+    """
+    if original_image is None or bg_image is None or final_image is None:
+        print("Download function received None input.")
+        return None
+    print("Preparing images for download...")
+    # Convert images to RGB if they are not
+    if original_image.mode != "RGB":
+        original_image = original_image.convert("RGB")
+    if bg_image.mode != "RGB":
+        bg_image = bg_image.convert("RGB")
+    if final_image.mode != "RGB":
+        final_image = final_image.convert("RGB")
+
+    # ZIP 파일 생성
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".zip") as tmp_file:
+        with zipfile.ZipFile(tmp_file, 'w') as zip_file:
+            # 원본 이미지 저장
+            original_buffer = BytesIO()
+            original_image.save(original_buffer, format="JPEG")
+            zip_file.writestr("original_image.jpg", original_buffer.getvalue())
+
+            # 생성된 배경 이미지 저장
+            bg_buffer = BytesIO()
+            bg_image.save(bg_buffer, format="JPEG")
+            zip_file.writestr("background_image.jpg", bg_buffer.getvalue())
+
+            # 최종 결과 이미지 저장
+            final_buffer = BytesIO()
+            final_image.save(final_buffer, format="JPEG")
+            zip_file.writestr("final_image.jpg", final_buffer.getvalue())
+
+        zip_path = tmp_file.name
+        print(f"ZIP file created at {zip_path}")
+
+    return zip_path
+
+def reset_sliders(initial_result):
+    """
+    슬라이더를 "필터없음"의 초기값으로 초기화하고 최종 결과 이미지를 초기 생성된 이미지로 복원하는 함수.
+    """
+    print("Resetting sliders to default values.")
+    return (
+        "필터없음",               # filter_radio
+        gr.update(value=1.0),  # 밝기
+        gr.update(value=1.0),  # 대비
+        gr.update(value=1.0),  # 채도
+        gr.update(value=0.0),  # 색온도
+        gr.update(value=0.0),  # 활기
+        gr.update(value=0.0),  # 컬러 믹서 (블루)
+        gr.update(value=0.0),  # 그림자
+        initial_result,       # 필터 적용 이미지
+    )
+
+# Gradio 인터페이스 설정
+def create_interface():
+    css = """
+    /* 프롬프트 텍스트박스 라벨과 입력 텍스트만 검은색으로 설정 */
+    .gr-textbox > label {
+        color: #000 !important;
+    }
+    .gr-textbox input {
+        color: #000 !important;
+    }
+
+    /* 필터 선택 라디오 버튼 라벨만 검은색으로 설정 */
+    .gradio-radio > label {
+        color: #000 !important;
+    }
+
+    /* 슬라이더 라벨과 현재 값 텍스트만 검은색으로 설정 */
+    .gr-slider > label {
+        color: #000 !important;
+    }
+    .gr-slider .slider-value {
+        color: #000 !important;
+    }
+
+    /* 선택된 라디오 버튼 텍스트를 검은색으로 유지하고 배경색을 흰색으로 설정 */
+    .gradio-radio label[aria-checked="true"] {
+        color: #000 !important;
+        background-color: #fff !important; /* 흰색 배경 */
+        padding: 4px 8px;
+        border-radius: 4px;
+        border: 1px solid #000 !important; /* 검은색 테두리 추가 */
+    }
+
+    /* 선택되지 않은 라디오 버튼 텍스트는 검은색 유지 */
+    .gradio-radio label[aria-checked="false"] {
+        color: #000 !important;
+        background-color: #fff !important; /* 흰색 배경 유지 */
+        border: 1px solid #000 !important; /* 검은색 테두리 추가 */
+    }
+
+    /* 라디오 버튼의 선택 표시 점 숨기기 */
+    .gradio-radio input[type="radio"] + label::before {
+        display: none;
+    }
+
+    /* 라디오 버튼 선택 시 선택 표시 점을 숨기기 */
+    .gradio-radio input[type="radio"]:checked + label::after {
+        content: "";
+        display: none;
+    }
+
+    /* 버튼 텍스트 색상도 검은색으로 변경 */
+    .btn-primary, .btn-secondary, .gr-button {
+        color: #000 !important;
+    }
+
+    /* 다운로드 버튼 텍스트 색상 검은색으로 변경 */
+    .gr-button.download-button {
+        color: #000 !important;
+    }
+
+    /* 기타 텍스트 요소에 영향을 주지 않도록 주의 */
+    /* 필요한 경우 추가적인 선택자를 여기에 작성 */
+    """
+
+    # 필터 프리셋 정의
+    filters = [
+        {
+            "name": "필터없음",
+            "bg_brightness": 1.0,
+            "bg_contrast": 1.0,
+            "bg_saturation": 1.0,
+            "bg_temperature": 0.0,
+            "bg_vibrance": 0.0,
+            "bg_color_mixer_blues": 0.0,
+            "bg_shadows": 0.0
+        },
+        {
+            "name": "깨끗한",
+            "bg_brightness": 1.3,
+            "bg_contrast": 1.2,
+            "bg_saturation": 1.0,
+            "bg_temperature": -0.2,
+            "bg_vibrance": -20.0,
+            "bg_color_mixer_blues": 5.0,
+            "bg_shadows": -10.0
+        },
+        {
+            "name": "따스한",
+            "bg_brightness": 1.3,
+            "bg_contrast": 1.2,
+            "bg_saturation": 0.8,
+            "bg_temperature": 0.0,
+            "bg_vibrance": -10.0,
+            "bg_color_mixer_blues": 2.0,
+            "bg_shadows": -10.0
+        },
+        {
+            "name": "푸른빛",
+            "bg_brightness": 1.3,
+            "bg_contrast": 1.0,
+            "bg_saturation": 1.0,
+            "bg_temperature": 0.0,
+            "bg_vibrance": 0.0,
+            "bg_color_mixer_blues": 10.0,
+            "bg_shadows": 5.0
+        }
+    ]
+
+    # 기본 필터 설정 (깨끗한)
+    default_filter = next(filter for filter in filters if filter["name"] == "깨끗한")
+
+    with gr.Blocks(theme=gr.themes.Soft(
+        primary_hue=gr.themes.Color(
+            c50="#FFF7ED",  # 가장 밝은 주황
+            c100="#FFEDD5",
+            c200="#FED7AA",
+            c300="#FDBA74",
+            c400="#FB923C",
+            c500="#F97316",  # 기본 주황
+            c600="#EA580C",
+            c700="#C2410C",
+            c800="#9A3412",
+            c900="#7C2D12",  # 가장 어두운 주황
+            c950="#431407",
+        ),
+        secondary_hue="zinc",  # 모던한 느낌의 회색 계열
+        neutral_hue="zinc",
+        font=("Pretendard", "sans-serif")
+    ), css=css) as demo:
+
+        with gr.Row():
+            # 왼쪽 열: 입력과 설정
+            with gr.Column(scale=1):
+                input_image = gr.Image(
+                    label="이미지 추가",
+                    image_mode="RGBA",
+                    type="pil",
+                )
+                prompt = gr.Textbox(
+                    label="프롬프트 (한국어)",
+                    placeholder="눈덮인 히말라야, 뭉게구름, 흰색 바닥에 놓여있는 양말",
+                )
+                run_button = gr.Button(
+                    value="이미지 생성",
+                    variant="primary",
+                    size="lg"
+                )
+                reset_button = gr.Button(
+                    value="필터 초기화",
+                    variant="secondary",
+                    size="lg"
+                )
+
+                # 필터 선택 라디오 버튼 추가
+                filter_radio = gr.Radio(
+                    label="필터 선택",
+                    choices=["필터없음", "깨끗한", "따스한", "푸른빛"],
+                    value="깨끗한",  # 기본 선택은 깨끗한
+                    type="value",
+                )
+
+                # 예시 추가
+                examples = [
+                    ["img/1.png", "눈, 히말라야", "푸른빛"],
+                    ["img/2.png", "흰색 벽지에 기대어 있는 사람", "깨끗한"],
+                    ["img/3.png", "단순한 책상위에 놓인 미니 파우치", "따스한"],
+                ]
+
+                gr.Examples(
+                    examples=examples,
+                    inputs=[input_image, prompt, filter_radio],
+                    fn=lambda img, prm, flt: on_generate(img, prm, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0) if flt == "필터없음" else on_generate(img, prm, 
+                        next(filter for filter in filters if filter["name"] == flt)["bg_brightness"],
+                        next(filter for filter in filters if filter["name"] == flt)["bg_contrast"],
+                        next(filter for filter in filters if filter["name"] == flt)["bg_saturation"],
+                        next(filter for filter in filters if filter["name"] == flt)["bg_temperature"],
+                        next(filter for filter in filters if filter["name"] == flt)["bg_vibrance"],
+                        next(filter for filter in filters if filter["name"] == flt)["bg_color_mixer_blues"],
+                        next(filter for filter in filters if filter["name"] == flt)["bg_shadows"],
+                    ),
+                    outputs=[
+                        "background_output",
+                        "mask_state",
+                        "final_output",
+                        "image_rgb_state",
+                        "initial_result",
+                    ],
+                    label="예시 선택",
+                    cache_examples=False,
+                )
+
+                # 배경 조정 옵션 순서 변경 (라벨에서 "배경" 제거)
+                bg_brightness = gr.Slider(label="밝기", minimum=0.1, maximum=5.0, value=default_filter["bg_brightness"], step=0.1)
+                bg_contrast = gr.Slider(label="대비", minimum=0.1, maximum=5.0, value=default_filter["bg_contrast"], step=0.1)
+                bg_saturation = gr.Slider(label="채도", minimum=0.0, maximum=5.0, value=default_filter["bg_saturation"], step=0.1)
+                bg_temperature = gr.Slider(  # 색온도 슬라이더
+                    label="색온도",
+                    minimum=-1.0,
+                    maximum=1.0,
+                    value=default_filter["bg_temperature"],
+                    step=0.1
+                )
+                bg_vibrance = gr.Slider(label="활기", minimum=-100.0, maximum=100.0, value=default_filter["bg_vibrance"], step=1.0)
+                bg_color_mixer_blues = gr.Slider(label="컬러 믹서 (블루)", minimum=-100.0, maximum=100.0, value=default_filter["bg_color_mixer_blues"], step=1.0)
+                bg_shadows = gr.Slider(label="그림자", minimum=-100.0, maximum=100.0, value=default_filter["bg_shadows"], step=1.0)  # Shadows 슬라이더
+
+            # 오른쪽 열: 출력과 다운로드 버튼
+            with gr.Column(scale=2):
+                background_output = gr.Image(
+                    label="생성된 이미지",
+                    type="pil",
+                    interactive=False  # 출력 전용으로 설정
+                )
+                final_output = gr.Image(
+                    label="필터 적용 이미지",
+                    type="pil",
+                    interactive=False  # 출력 전용으로 설정
+                )
+                # "모든 이미지 다운로드" 버튼과 다운로드 출력창을 중앙에 배치
+                with gr.Row(elem_classes="download-container"):
+                    download_button = gr.Button(
+                        value="모든 이미지 다운로드",
+                        elem_classes="download-button",
+                        variant="primary",
+                        size="lg"
+                    )
+                with gr.Row(elem_classes="download-container"):
+                    download_output = gr.File(label="모든 이미지 다운로드", elem_classes="download-output")
+
+        # 상태 컴포넌트
+        mask_state = gr.State()
+        image_rgb_state = gr.State()  # image_rgb 상태 추가
+        initial_result = gr.State()
+
+        # 필터 선택 시 슬라이더 값 변경 함수
+        def apply_filter_preset(selected_filter):
+            for filter in filters:
+                if filter["name"] == selected_filter:
+                    return (
+                        gr.update(value=filter["bg_brightness"]),
+                        gr.update(value=filter["bg_contrast"]),
+                        gr.update(value=filter["bg_saturation"]),
+                        gr.update(value=filter["bg_temperature"]),
+                        gr.update(value=filter["bg_vibrance"]),
+                        gr.update(value=filter["bg_color_mixer_blues"]),
+                        gr.update(value=filter["bg_shadows"]),
+                    )
+            # 기본값 반환 (필터없음)
+            return (
+                gr.update(value=1.0),
+                gr.update(value=1.0),
+                gr.update(value=1.0),
+                gr.update(value=0.0),
+                gr.update(value=0.0),
+                gr.update(value=0.0),
+                gr.update(value=0.0),
+            )
+
+        # 필터 라디오 버튼 선택 시 슬라이더 값 업데이트
+        filter_radio.change(
+            fn=apply_filter_preset,
+            inputs=[filter_radio],
+            outputs=[
+                bg_brightness,
+                bg_contrast,
+                bg_saturation,
+                bg_temperature,
+                bg_vibrance,
+                bg_color_mixer_blues,
+                bg_shadows,
+            ],
+        )
+
+        # 이미지 생성 버튼 클릭 시 generate_images 함수 호출 및 프롬프트 번역
+        def on_generate(image, prompt, bg_brightness, bg_contrast, bg_saturation, bg_temperature, bg_vibrance, bg_color_mixer_blues, bg_shadows):
+            # 프롬프트가 비어있는지 확인
+            if not prompt.strip():
+                logger.info("프롬프트가 비어 있습니다. 기본 프롬프트를 사용합니다.")
+                # 기본 프롬프트 설정
+                final_prompt = "high-quality professional studio photography, Realistic soft white tone bright lighting, HEIC, CR2, NEF"
+            else:
+                # 한국어 프롬프트를 영어로 번역
+                translated_prompt = translate_to_english(prompt)
+                if translated_prompt.startswith("유효하지 않은 입력") or translated_prompt.startswith("번역 중 오류"):
+                    return None, None, None, None, None  # 번역 실패 시 종료
+                
+                # 번역된 프롬프트에 자동으로 문자열 추가
+                final_prompt = f"{translated_prompt}, high-quality professional studio photography, Realistic soft white tone bright lighting, HEIC, CR2, NEF"
+            
+            image_rgb, bg_img, mask, result = generate_images(image, final_prompt)
+            print("Image generation completed.")
+
+            # 슬라이더 값 적용
+            if bg_img is not None and mask is not None and image_rgb is not None:
+                adjusted_bg = adjust_final_image(
+                    bg_image=bg_img,
+                    mask=mask,
+                    bg_brightness=bg_brightness,
+                    bg_contrast=bg_contrast,
+                    bg_saturation=bg_saturation,
+                    bg_temperature=bg_temperature,
+                    bg_vibrance=bg_vibrance,
+                    bg_color_mixer_blues=bg_color_mixer_blues,
+                    bg_shadows=bg_shadows,
+                )
+                final_result = Image.composite(image_rgb, adjusted_bg, mask)
+            else:
+                final_result = result
+
+            # 초기 결과에 final_result 저장
+            initial_result.value = final_result
+
+            return bg_img, mask, final_result, image_rgb, final_result  # initial_result 추가 반환
+
+        run_button.click(
+            fn=on_generate,
+            inputs=[
+                input_image,
+                prompt,
+                bg_brightness,
+                bg_contrast,
+                bg_saturation,
+                bg_temperature,
+                bg_vibrance,
+                bg_color_mixer_blues,
+                bg_shadows,
+            ],
+            outputs=[
+                background_output,
+                mask_state,
+                final_output,
+                image_rgb_state,
+                initial_result,  # initial_result 추가 반환
+            ],
+        )
+
+        def on_adjust(
+            image_rgb,  # image_rgb_state 사용
+            bg_image, mask,
+            bg_brightness, bg_contrast, bg_saturation, bg_temperature, bg_vibrance, bg_color_mixer_blues, bg_shadows,
+        ):
+            if bg_image is None or mask is None or image_rgb is None:
+                print("Adjust function received None input.")
+                return None
+            print(f"Adjusting background image... Current slider values:")
+            print(f"Brightness: {bg_brightness}, Contrast: {bg_contrast}, Saturation: {bg_saturation}, "
+                  f"Temperature: {bg_temperature}, Vibrance: {bg_vibrance}, Blues: {bg_color_mixer_blues}, Shadows: {bg_shadows}")
+            
+            adjusted_bg = adjust_final_image(
+                bg_image=bg_image,
+                mask=mask,  # mask를 반드시 전달
+                bg_brightness=bg_brightness,
+                bg_contrast=bg_contrast,
+                bg_saturation=bg_saturation,
+                bg_temperature=bg_temperature,
+                bg_vibrance=bg_vibrance,
+                bg_color_mixer_blues=bg_color_mixer_blues,
+                bg_shadows=bg_shadows,  # Shadows 파라미터 추가
+            )
+            
+            # 조정된 배경 이미지 확인
+            print(f"adjusted_bg size: {adjusted_bg.size}, mode: {adjusted_bg.mode}")
+            adjusted_bg.save("adjusted_bg_debug.jpg")  # 디버깅용 임시 파일 저장
+            
+            # image_rgb은 이미 resize된 상태이므로 추가적인 변환 필요 없음
+            input_image_rgb = image_rgb
+
+            # 이미지 크기와 모드 확인
+            print(f"input_image_rgb size: {input_image_rgb.size}, mode: {input_image_rgb.mode}")
+            print(f"adjusted_bg size: {adjusted_bg.size}, mode: {adjusted_bg.mode}")
+            print(f"mask size: {mask.size}, mode: {mask.mode}")
+            
+            # 이미지 크기가 동일한지 확인하고, 다르면 조정
+            if input_image_rgb.size != adjusted_bg.size:
+                print(f"Resizing input_image_rgb from {input_image_rgb.size} to {adjusted_bg.size}")
+                input_image_rgb = input_image_rgb.resize(adjusted_bg.size)
+            
+            # mask를 단일 채널로 변환 (필요시)
+            mask = mask.convert("L")
+            
+            try:
+                final_result = Image.composite(input_image_rgb, adjusted_bg, mask)
+            except ValueError as e:
+                print(f"Composite error: {e}")
+                return None
+            
+            # 최종 결과 확인
+            final_result.save("final_result_debug.jpg")  # 디버깅용 임시 파일 저장
+            print("Final image composite completed.")
+            
+            # 초기 결과에 final_result 저장
+            initial_result.value = final_result
+            
+            return final_result
+
+        bg_sliders = [
+            bg_brightness,
+            bg_contrast,
+            bg_saturation,
+            bg_temperature,
+            bg_vibrance,
+            bg_color_mixer_blues,
+            bg_shadows,  # Shadows 슬라이더 추가
+        ]
+
+        for slider in bg_sliders:
+            slider.change(
+                fn=on_adjust,
+                inputs=[
+                    image_rgb_state,    # image_rgb_state 사용
+                    background_output,  # 생성된 이미지
+                    mask_state,         # 알파 채널
+                    bg_brightness,
+                    bg_contrast,
+                    bg_saturation,
+                    bg_temperature,
+                    bg_vibrance,
+                    bg_color_mixer_blues,
+                    bg_shadows,         # Shadows 파라미터 추가
+                ],
+                outputs=final_output,   # 최종 결과는 합성된 이미지
+            )
+
+        # 리셋 버튼 클릭 시 모든 슬라이더를 "필터없음"의 초기값으로 초기화하고 필터 선택을 "필터없음"으로 변경
+        reset_button.click(
+            fn=reset_sliders,
+            inputs=[final_output],
+            outputs=[
+                filter_radio,      # 필터 선택 라디오 버튼
+                bg_brightness,
+                bg_contrast,
+                bg_saturation,
+                bg_temperature,
+                bg_vibrance,
+                bg_color_mixer_blues,
+                bg_shadows,
+                final_output,
+            ],
+        )
+
+        # 다운로드 버튼 클릭 시 모든 이미지 다운로드
+        download_button.click(
+            fn=download_all,
+            inputs=[
+                input_image,
+                background_output,
+                final_output
+            ],
+            outputs=download_output,
+        )
+
+    return demo
+
+if __name__ == "__main__":
+    logger.info("애플리케이션 시작")
+    demo = create_interface()
+    demo.queue()
+    demo.launch(server_name='0.0.0.0')