Update app.py

app.py

@@ -4,267 +4,93 @@ import os
 import requests
 from PIL import Image, ImageDraw, ImageFilter, ImageEnhance
 import io
-import base64
 import tempfile
 import numpy as np
 
-# Replicate API 토큰 설정 (환경변수에서 가져오기)
+# Replicate API 토큰 설정
 REPLICATE_API_TOKEN = os.getenv("REPLICATE_API_TOKEN")
 if REPLICATE_API_TOKEN:
     os.environ["REPLICATE_API_TOKEN"] = REPLICATE_API_TOKEN
 
+def upload_image_to_temp_url(image):
+    """이미지를 임시 파일로 저장"""
+    if image is None:
+        return None
+    
+    with tempfile.NamedTemporaryFile(delete=False, suffix='.png') as tmp_file:
+        image.save(tmp_file.name, format='PNG')
+        return tmp_file.name
+
 def remove_background_with_ai(image_path):
-    """AI를 이용한 배경 제거"""
+    """AI 배경 제거"""
     if not REPLICATE_API_TOKEN:
-        return None, "Replicate API 토큰이 설정되지 않았습니다."
+        return None, "Replicate API 토큰이 필요합니다."
     
     try:
-        # Replicate Background Remover API 호출
         output = replicate.run(
             "851-labs/background-remover:a029dff38972b5fda4ec5d75d7d1cd25aeff621d2cf4946a41055d7db66b80bc",
-            input={
-                "image": open(image_path, "rb")
-            }
+            input={"image": open(image_path, "rb")}
         )
         
-        # 결과 이미지 다운로드
         response = requests.get(output)
         if response.status_code == 200:
-            bg_removed_image = Image.open(io.BytesIO(response.content))
-            return bg_removed_image, "배경 제거 완료"
+            return Image.open(io.BytesIO(response.content)), "배경 제거 완료"
         else:
             return None, "배경 제거 실패"
             
     except Exception as e:
-        return None, f"배경 제거 중 오류: {str(e)}"
-
-def upload_image_to_temp_url(image):
-    """이미지를 임시 URL로 업로드하는 함수 (실제로는 base64 인코딩)"""
-    if image is None:
-        return None
-    
-    # PIL Image를 base64로 인코딩
-    buffer = io.BytesIO()
-    image.save(buffer, format='PNG')
-    buffer.seek(0)
-    
-    # 임시 파일로 저장
-    with tempfile.NamedTemporaryFile(delete=False, suffix='.png') as tmp_file:
-        image.save(tmp_file.name, format='PNG')
-        return tmp_file.name
-    """이미지를 임시 URL로 업로드하는 함수 (실제로는 base64 인코딩)"""
-    if image is None:
-        return None
-    
-    # PIL Image를 base64로 인코딩
-    buffer = io.BytesIO()
-    image.save(buffer, format='PNG')
-    buffer.seek(0)
-    
-    # 임시 파일로 저장
-    with tempfile.NamedTemporaryFile(delete=False, suffix='.png') as tmp_file:
-        image.save(tmp_file.name, format='PNG')
-        return tmp_file.name
-
-def create_perfect_white_background(image, margin=100):
-    """완전한 흰색 배경 생성"""
-    if image.mode != 'RGBA':
-        image = image.convert('RGBA')
-    
-    # 원본 이미지 크기
-    width, height = image.size
-    
-    # 여백을 포함한 새로운 크기
-    new_width = width + margin * 2
-    new_height = height + margin * 2
-    
-    # 완전한 흰색 배경 생성
-    white_background = Image.new('RGB', (new_width, new_height), (255, 255, 255))
-    
-    # 원본 이미지를 중앙에 배치
-    paste_x = (new_width - width) // 2
-    paste_y = (new_height - height) // 2
-    
-    # 알파 채널이 있는 경우 투명 부분 처리
-    if image.mode == 'RGBA':
-        # 투명 배경을 흰색으로 변경
-        white_bg_temp = Image.new('RGBA', image.size, (255, 255, 255, 255))
-        alpha_composite = Image.alpha_composite(white_bg_temp, image)
-        white_background.paste(alpha_composite.convert('RGB'), (paste_x, paste_y))
-    else:
-        white_background.paste(image, (paste_x, paste_y))
-    
-    return white_background
-
-def ensure_white_background_85_percent(image):
-    """85% 흰색 배경 규칙을 확실히 만족시키기"""
-    # 현재 흰색 비율 확인
-    is_compliant, white_ratio = check_white_background_ratio(image)
-    
-    if not is_compliant:
-        # 85% 미달시 이미지를 축소하여 흰색 영역 늘리기
-        current_size = image.size
-        # 현재 흰색 비율에 따라 축소 비율 계산
-        target_ratio = 0.87  # 85%보다 약간 여유있게
-        if white_ratio > 0:
-            scale_factor = min(0.8, (white_ratio / target_ratio) * 0.9)
-        else:
-            scale_factor = 0.7
-        
-        new_size = (int(current_size[0] * scale_factor), int(current_size[1] * scale_factor))
-        resized_image = image.resize(new_size, Image.Resampling.LANCZOS)
-        
-        # 완전한 흰색 배경에 축소된 이미지를 중앙 배치
-        final_image = Image.new('RGB', current_size, (255, 255, 255))
-        paste_x = (current_size[0] - new_size[0]) // 2
-        paste_y = (current_size[1] - new_size[1]) // 2
-        final_image.paste(resized_image, (paste_x, paste_y))
-        
-        return final_image
-    
-    return image
-    """흰 배경에 그림자 효과 추가"""
-    if image.mode != 'RGBA':
-        image = image.convert('RGBA')
-    
-    # 원본 이미지 크기
-    width, height = image.size
-    
-    # 그림자를 위한 여백 추가
-    shadow_margin = max(shadow_offset) + 20
-    new_width = width + shadow_margin * 2
-    new_height = height + shadow_margin * 2
-    
-    # 흰색 배경 생성
-    result = Image.new('RGBA', (new_width, new_height), (255, 255, 255, 255))
-    
-    # 그림자 생성
-    shadow = Image.new('RGBA', (new_width, new_height), (0, 0, 0, 0))
-    shadow_draw = ImageDraw.Draw(shadow)
-    
-    # 원본 이미지의 알파 채널을 이용해 그림자 마스크 생성
-    alpha = image.split()[-1]
-    shadow_pos = (shadow_margin + shadow_offset[0], shadow_margin + shadow_offset[1])
-    shadow.paste(Image.new('RGBA', image.size, (0, 0, 0, int(255 * shadow_intensity))), shadow_pos, alpha)
-    
-    # 그림자 블러 효과
-    shadow = shadow.filter(ImageFilter.GaussianBlur(radius=8))
-    
-    # 그림자를 배경에 합성
-    result = Image.alpha_composite(result, shadow)
-    
-    # 원본 이미지를 중앙에 배치
-    image_pos = (shadow_margin, shadow_margin)
-    result.paste(image, image_pos, image)
-    
-    return result.convert('RGB')
-
-def enhance_image_quality(image):
-    """이미지 화질 향상"""
-    # 선명도 향상
-    enhancer = ImageEnhance.Sharpness(image)
-    image = enhancer.enhance(1.2)
-    
-    # 대비 향상
-    enhancer = ImageEnhance.Contrast(image)
-    image = enhancer.enhance(1.1)
-    
-    # 색상 채도 향상
-    enhancer = ImageEnhance.Color(image)
-    image = enhancer.enhance(1.05)
-    
-    return image
+        return None, f"배경 제거 오류: {str(e)}"
 
-def change_product_angle_with_ai(image_path, angle_option):
-    """AI를 이용한 상품 각도/방향 변경으로 아이템 위너 회피"""
+def upscale_with_clarity(image_path):
+    """화질 개선 업스케일러"""
     if not REPLICATE_API_TOKEN:
-        return None, "Replicate API 토큰이 설정되지 않았습니다."
+        return None, "Replicate API 토큰이 필요합니다."
     
     try:
-        # 각도 변경 프롬프트 옵션 (완전한 흰색 배경 강조)
-        angle_prompts = {
-            "왼쪽 45도": "Change the product angle to show it from 45-degree left side view, professional product photography, pure white background #FFFFFF, clean white backdrop, no shadows, solid white background",
-            "오른쪽 45도": "Change the product angle to show it from 45-degree right side view, professional product photography, pure white background #FFFFFF, clean white backdrop, no shadows, solid white background", 
-            "상단 앵글": "Change to top-down angle view of the product, bird's eye view, professional product photography, pure white background #FFFFFF, clean white backdrop, no shadows, solid white background",
-            "3/4 뷰": "Change to 3/4 angle view of the product, three-quarter perspective, professional product photography, pure white background #FFFFFF, clean white backdrop, no shadows, solid white background",
-            "정면에서 측면": "Change from front view to side view of the product, profile angle, professional product photography, pure white background #FFFFFF, clean white backdrop, no shadows, solid white background",
-            "측면에서 정면": "Change from side view to front view of the product, frontal angle, professional product photography, pure white background #FFFFFF, clean white backdrop, no shadows, solid white background"
-        }
-        
-        selected_prompt = angle_prompts.get(angle_option, angle_prompts["3/4 뷰"])
-        
-        # Replicate API 호출
         output = replicate.run(
-            "black-forest-labs/flux-kontext-pro",
-            input={
-                "prompt": selected_prompt,
-                "input_image": open(image_path, "rb"),
-                "output_format": "jpg"
-            }
+            "philz1337x/clarity-upscaler:dfad41707589d68ecdccd1dfa600d55a208f9310748e44bfe35b4a6291453d5e",
+            input={"image": open(image_path, "rb")}
         )
         
-        # 결과 이미지 다운로드
-        response = requests.get(output)
+        # output은 리스트이므로 첫 번째 항목 사용
+        response = requests.get(output[0])
         if response.status_code == 200:
-            angled_image = Image.open(io.BytesIO(response.content))
-            return angled_image, f"상품 각도 변경 완료: {angle_option}"
+            return Image.open(io.BytesIO(response.content)), "화질 개선 완료"
         else:
-            return None, "각도 변경 실패"
+            return None, "화질 개선 실패"
             
     except Exception as e:
-        return None, f"각도 변경 중 오류: {str(e)}"
-
-def check_white_background_ratio(image, threshold=0.85):
-    """흰색 배경 비율 확인 (85% 규칙)"""
-    if image.mode != 'RGB':
-        image = image.convert('RGB')
-    
-    pixels = np.array(image)
-    white_pixels = np.sum(np.all(pixels >= [240, 240, 240], axis=2))
-    total_pixels = pixels.shape[0] * pixels.shape[1]
-    white_ratio = white_pixels / total_pixels
-    
-    return white_ratio >= threshold, white_ratio
+        return None, f"화질 개선 오류: {str(e)}"
 
-def process_with_ai_enhancement(image_path, prompt_option):
-    """AI를 이용한 이미지 품질 향상"""
+def create_coupang_thumbnail_fixed(image_path):
+    """고정된 설정으로 쿠팡 썸네일 생성"""
     if not REPLICATE_API_TOKEN:
-        return None, "Replicate API 토큰이 설정되지 않았습니다."
+        return None, "Replicate API 토큰이 필요합니다."
     
     try:
-        # 프롬프트 옵션별 설정 (완전한 흰색 배경 강조)
-        prompts = {
-            "기본 품질향상": "Enhance image quality, make it more professional and crisp, pure white background #FFFFFF, clean white backdrop, no shadows, solid white background",
-            "제품 사진 최적화": "Transform into professional product photography, clean pure white background #FFFFFF, high quality, studio lighting, solid white backdrop, no shadows",
-            "쿠팡 스타일": "Make it look like a professional e-commerce product photo for Korean online shopping, clean pure white background #FFFFFF, perfect lighting, solid white backdrop, no shadows",
-            "프리미엄 느낌": "Make it look premium and luxury, professional product shot, perfect pure white background #FFFFFF, studio quality, clean white backdrop, no shadows, solid white background"
-        }
-        
-        selected_prompt = prompts.get(prompt_option, prompts["기본 품질향상"])
+        # 고정된 프롬프트: 완전한 흰색배경, 85%상품이미지, 그림자효과, 3/4뷰 고정
+        fixed_prompt = "Professional product photography, 3/4 angle view, pure white background #FFFFFF, natural soft shadows, clean white backdrop, high quality e-commerce photo, solid white background, product takes 85% of image space"
         
-        # Replicate API 호출
         output = replicate.run(
             "black-forest-labs/flux-kontext-pro",
             input={
-                "prompt": selected_prompt,
+                "prompt": fixed_prompt,
                 "input_image": open(image_path, "rb"),
                 "output_format": "jpg"
             }
         )
         
-        # 결과 이미지 다운로드
         response = requests.get(output)
         if response.status_code == 200:
-            enhanced_image = Image.open(io.BytesIO(response.content))
-            return enhanced_image, "AI 향상 완료"
+            return Image.open(io.BytesIO(response.content)), "썸네일 생성 완료"
         else:
-            return None, "AI 처리 실패"
+            return None, "썸네일 생성 실패"
             
     except Exception as e:
-        return None, f"AI 처리 중 오류: {str(e)}"
+        return None, f"썸네일 생성 오류: {str(e)}"
 
-def create_coupang_thumbnail(image, auto_remove_bg, white_bg_mode, apply_angle_change, angle_option, ai_enhancement, prompt_option):
-    """쿠팡 썸네일 생성 메인 함수"""
+def process_image(image, remove_bg, upscale_quality):
+    """메인 처리 함수"""
     if image is None:
         return None, "이미지를 업로드해주세요."
     
@@ -272,213 +98,95 @@ def create_coupang_thumbnail(image, auto_remove_bg, white_bg_mode, apply_angle_c
         result_image = image.copy()
         status_messages = []
         
-        # 0단계: 자동 배경 제거 (선택사항)
-        if auto_remove_bg and REPLICATE_API_TOKEN:
+        # 1단계: 배경 제거 (선택사항)
+        if remove_bg:
             temp_path = upload_image_to_temp_url(result_image)
             if temp_path:
                 bg_removed_img, bg_msg = remove_background_with_ai(temp_path)
                 if bg_removed_img:
                     result_image = bg_removed_img
-                    status_messages.append(f"✅ 자동 배경 제거: {bg_msg}")
+                    status_messages.append(f"✅ {bg_msg}")
                 else:
-                    status_messages.append(f"❌ 배경 제거: {bg_msg}")
-                os.unlink(temp_path)  # 임시 파일 삭제
-        elif auto_remove_bg and not REPLICATE_API_TOKEN:
-            status_messages.append("⚠️ 배경 제거에는 Replicate API 토큰이 필요합니다")
+                    status_messages.append(f"❌ {bg_msg}")
+                os.unlink(temp_path)
         
-        # 1단계: 상품 각도 변경 (아이템 위너 회피)
-        if apply_angle_change and REPLICATE_API_TOKEN:
+        # 2단계: 화질 개선 (선택사항)
+        if upscale_quality:
             temp_path = upload_image_to_temp_url(result_image)
             if temp_path:
-                angled_img, angle_msg = change_product_angle_with_ai(temp_path, angle_option)
-                if angled_img:
-                    result_image = angled_img
-                    status_messages.append(f"✅ 상품 각도 변경: {angle_msg}")
+                upscaled_img, upscale_msg = upscale_with_clarity(temp_path)
+                if upscaled_img:
+                    result_image = upscaled_img
+                    status_messages.append(f"✅ {upscale_msg}")
                 else:
-                    status_messages.append(f"❌ 각도 변경: {angle_msg}")
-                os.unlink(temp_path)  # 임시 파일 삭제
-        elif apply_angle_change and not REPLICATE_API_TOKEN:
-            status_messages.append("⚠️ 각도 변경에는 Replicate API 토큰이 필요합니다")
-        
-        # 2단계: AI 품질 향상 (선택사항)
-        if ai_enhancement and REPLICATE_API_TOKEN:
-            temp_path = upload_image_to_temp_url(result_image)
-            if temp_path:
-                enhanced_img, ai_msg = process_with_ai_enhancement(temp_path, prompt_option)
-                if enhanced_img:
-                    result_image = enhanced_img
-                    status_messages.append(f"✅ AI 향상: {ai_msg}")
-                else:
-                    status_messages.append(f"❌ AI 향상: {ai_msg}")
-                os.unlink(temp_path)  # 임시 파일 삭제
-        
-        # 3단계: 화질 향상
-        result_image = enhance_image_quality(result_image)
-        status_messages.append("✅ 화질 향상 완료")
-        
-        # 4단계: 배경 처리 (흰색 배경 모드 선택)
-        if white_bg_mode == "완전한 흰색":
-            result_image = create_perfect_white_background(result_image)
-            status_messages.append("✅ 완전한 흰색 배경 적용")
-        elif white_bg_mode == "그림자 효과":
-            result_image = create_white_background_shadow(result_image)
-            status_messages.append("✅ 그림자 효과가 있는 흰색 배경 적용")
-        else:  # "기본 흰색"
-            # 그림자 없이 흰 배경만 적용
-            if result_image.mode == 'RGBA':
-                white_bg = Image.new('RGB', result_image.size, (255, 255, 255))
-                white_bg.paste(result_image, mask=result_image.split()[-1] if result_image.mode == 'RGBA' else None)
-                result_image = white_bg
-            status_messages.append("✅ 기본 흰색 배경 적용")
-        
-        # 5단계: 85% 흰색 배경 규칙 강제 적용
-        result_image = ensure_white_background_85_percent(result_image)
-        
-        # 85% 흰색 배경 규칙 확인
-        is_compliant, white_ratio = check_white_background_ratio(result_image)
-        if is_compliant:
-            status_messages.append(f"✅ 85% 흰색 배경 규칙 준수 ({white_ratio:.1%})")
-        else:
-            status_messages.append(f"⚠️ 흰색 배경 비율: ({white_ratio:.1%}) - 추가 조정 필요")
-        
-        # 최종 이미지 크기 조정 (쿠팡 권장 사이즈)
-        result_image = result_image.resize((1000, 1000), Image.Resampling.LANCZOS)
-        status_messages.append("✅ 1000x1000 크기로 조정 완료")
+                    status_messages.append(f"❌ {upscale_msg}")
+                os.unlink(temp_path)
+        
+        # 3단계: 쿠팡 썸네일 생성 (고정 설정)
+        temp_path = upload_image_to_temp_url(result_image)
+        if temp_path:
+            final_img, final_msg = create_coupang_thumbnail_fixed(temp_path)
+            if final_img:
+                result_image = final_img
+                status_messages.append(f"✅ {final_msg}")
+                
+                # 최종 크기 조정
+                result_image = result_image.resize((1000, 1000), Image.Resampling.LANCZOS)
+                status_messages.append("✅ 1000x1000 크기 조정 완료")
+            else:
+                status_messages.append(f"❌ {final_msg}")
+            os.unlink(temp_path)
         
         return result_image, "\n".join(status_messages)
         
     except Exception as e:
-        return None, f"처리 중 오류가 발생했습니다: {str(e)}"
+        return None, f"처리 중 오류: {str(e)}"
 
-# Gradio 인터페이스 생성
+# Gradio 인터페이스
 def create_interface():
-    with gr.Blocks(title="🛒 쿠팡 썸네일 생성기", theme=gr.themes.Soft()) as iface:
-        gr.Markdown("""
-        # 쿠팡 썸네일 생성기 - Gradio 5.0+
-        
-        일반 상품 이미지를 업로드하면 **자동 배경 제거 → 쿠팡 규정 준수 썸네일**로 한 번에 변환해드립니다!
-        
-        ## 💡 완전 자동화된 쿠팡 규정 대응:
-        - 🎯 **자동 배경 제거** (AI 기반)
-        - ✅ **흰 배경 + 85% 규칙** 완벽 준수
-        - ✅ **AI 마법 프롬프트**로 화질 향상 
-        - ✅ **상품 각도 변경**으로 아이템 위너(중복) 회피
-        - ✅ **그림자 효과**로 자연스러운 입체감 연출
-        """)
+    with gr.Blocks(title="쿠팡 썸네일 생성기", theme=gr.themes.Soft()) as iface:
         
         with gr.Row():
             with gr.Column(scale=1):
-                gr.Markdown("### 📤 이미지 업로드")
+                # 이미지 업로드
                 input_image = gr.Image(
-                    label="상품 이미지 (배경 있어도 OK!)", 
+                    label="상품 이미지 업로드", 
                     type="pil",
-                    height=300
+                    height=400
                 )
                 
-                gr.Markdown("### ⚙️ 옵션 설정")
-                
+                # 선택 기능 2가지
                 with gr.Group():
-                    gr.Markdown("**🔧 전처리 옵션**")
-                    auto_remove_bg = gr.Checkbox(
-                        label="자동 배경 제거", 
+                    remove_bg = gr.Checkbox(
+                        label="배경 제거", 
                         value=True,
-                        info="AI로 배경을 자동 제거 (Replicate API 필요)"
-                    )
-                
-                with gr.Group():
-                    gr.Markdown("**🎨 배경 옵션**")
-                    white_bg_mode = gr.Radio(
-                        choices=["완전한 흰색", "그림자 효과", "기본 흰색"],
-                        value="완전한 흰색",
-                        label="흰색 배경 모드",
-                        info="완전한 흰색: 100% 순백색 / 그림자 효과: 입체감 연출 / 기본 흰색: 단순 배경"
+                        info="AI로 배경을 자동 제거합니다"
                     )
-                    apply_angle_change = gr.Checkbox(
-                        label="상품 각도 변경 (아이템 위너 회피)", 
+                    upscale_quality = gr.Checkbox(
+                        label="화질 개선기", 
                         value=True,
-                        info="AI로 상품의 각도/방향을 변경하여 중복 회피"
-                    )
-                    angle_option = gr.Dropdown(
-                        choices=["왼쪽 45도", "오른쪽 45도", "상단 앵글", "3/4 뷰", "정면에서 측면", "측면에서 정면"],
-                        value="3/4 뷰",
-                        label="변경할 각도",
-                        info="상품을 어떤 각도로 변경할지 선택",
-                        visible=True
-                    )
-                
-                with gr.Group():
-                    gr.Markdown("**🤖 AI 향상 (Replicate API 필요)**")
-                    ai_enhancement = gr.Checkbox(
-                        label="AI 품질 향상 사용", 
-                        value=False,
-                        info="Replicate API 토큰이 필요합니다"
-                    )
-                    prompt_option = gr.Dropdown(
-                        choices=["기본 품질향상", "제품 사진 최적화", "쿠팡 스타일", "프리미엄 느낌"],
-                        value="쿠팡 스타일",
-                        label="AI 향상 스타일"
+                        info="AI로 화질을 향상시킵니다"
                     )
                 
-                process_btn = gr.Button("🚀 쿠팡 썸네일 생성", variant="primary", size="lg")
+                # 실행 버튼
+                process_btn = gr.Button("🚀 썸네일 생성", variant="primary", size="lg")
             
             with gr.Column(scale=1):
-                gr.Markdown("### 📥 결과")
+                # 출력 이미지
                 output_image = gr.Image(
-                    label="쿠팡 규정 썸네일", 
+                    label="쿠팡 썸네일 결과", 
                     height=400
                 )
                 status_output = gr.Textbox(
                     label="처리 상태", 
-                    lines=8,
-                    max_lines=15
+                    lines=6,
+                    max_lines=10
                 )
         
-        # 사용 예시
-        gr.Markdown("""
-        ---
-        ## 📋 사용 방법
-        1. **일반 상품 이미지**를 업로드하세요 (배경 있어도 OK!)
-        2. **자동 배경 제거** 옵션을 켜두세요 (기본값)
-        3. **상품 각도 변경 옵션**을 선택하여 아이템 위너(중복)를 회피하세요
-        4. 원하는 **효과 옵션**을 선택하세요
-        5. **Replicate API 토큰**을 환경변수로 설정하세요 (필수)
-        6. **'쿠팡 썸네일 생성'** 버튼을 클릭하세요
-        
-        ## 🔄 완전 자동화 워크플로우
-        **원본 이미지** → **배경 제거** → **각도 변경** → **품질 향상** → **쿠팡 규정 썸네일**
-        
-        ## 🎯 상품 각도 변경 옵션 설명
-        - **왼쪽 45도**: 상품을 왼쪽에서 45도 각도로 촬영한 느낌
-        - **오른쪽 45도**: 상품을 오른쪽에서 45도 각도로 촬영한 느낌  
-        - **상단 앵글**: 위에서 내려다본 탑뷰 각도
-        - **3/4 뷰**: 가장 일반적인 상품 촬영 각도 (추천)
-        - **정면에서 측면**: 정면 이미지를 측면 각도로 변경
-        - **측면에서 정면**: 측면 이미지를 정면 각도로 변경
-        
-        ## 🔑 API 설정 (선택사항)
-        AI 향상 기능을 사용하려면 환경변수를 설정하세요:
-        ```bash
-        export REPLICATE_API_TOKEN=your_token_here
-        ```
-        """)
-        
-        # 이벤트 처리
-        def update_angle_visibility(apply_angle):
-            return gr.update(visible=apply_angle)
-        
-        apply_angle_change.change(update_angle_visibility, apply_angle_change, angle_option)
-        
+        # 버튼 클릭 이벤트
         process_btn.click(
-            create_coupang_thumbnail,
-            inputs=[
-                input_image, 
-                auto_remove_bg,
-                white_bg_mode,
-                apply_angle_change, 
-                angle_option, 
-                ai_enhancement, 
-                prompt_option
-            ],
+            process_image,
+            inputs=[input_image, remove_bg, upscale_quality],
             outputs=[output_image, status_output]
         )