Update app.py

app.py

@@ -1,16 +1,12 @@
 import os
-import json
 import logging
 import re
+import json
 import gradio as gr
 from google import genai
+from google.genai import types
 import google.generativeai as genai_generative
 from dotenv import load_dotenv
-import random
-from PIL import Image
-import numpy as np
-from typing import List, Dict, Any, Optional, Tuple
-import colorsys
 
 load_dotenv()
 
@@ -18,276 +14,240 @@ load_dotenv()
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# ------------------- 레퍼런스 데이터 로드 -------------------
-def load_references(json_path="references/style_references.json"):
-    """레퍼런스 JSON 파일을 로드하는 함수"""
-    try:
-        with open(json_path, 'r', encoding='utf-8') as f:
-            return json.load(f)
-    except FileNotFoundError:
-        logger.warning(f"레퍼런스 파일을 찾을 수 없습니다: {json_path}. 기본 설정을 사용합니다.")
-        return {"clothing_references": []}
-    except json.JSONDecodeError:
-        logger.error(f"레퍼런스 파일 형식이 올바르지 않습니다: {json_path}")
-        return {"clothing_references": []}
+# ------------------- 배경 디렉토리 설정 -------------------
+BACKGROUNDS_DIR = "./background"
+if not os.path.exists(BACKGROUNDS_DIR):
+    os.makedirs(BACKGROUNDS_DIR)
+    logger.info(f"배경 디렉토리를 생성했습니다: {BACKGROUNDS_DIR}")
+
+# ------------------- 전역 변수 설정 -------------------
+SIMPLE_BACKGROUNDS = {}
+STUDIO_BACKGROUNDS = {}
+NATURE_BACKGROUNDS = {}
+INDOOR_BACKGROUNDS = {}
+TECHNOLOGY_BACKGROUNDS = {}
+COLORFUL_PATTERN_BACKGROUNDS = {}
+ABSTRACT_BACKGROUNDS = {}
+JEWELRY_BACKGROUNDS = {}  # 쥬얼리 배경 전역 변수 추가
 
-# 레퍼런스 데이터 로드
-REFERENCES_DATA = load_references()
-CLOTHING_REFERENCES = REFERENCES_DATA.get("clothing_references", [])
 
-# ------------------- 이미지 분석 함수 -------------------
-def extract_dominant_colors(img, num_colors=3):
-    """이미지에서 주요 색상을 추출하는 함수"""
+# ------------------- 배경 JSON 파일 로드 함수 -------------------
+def load_background_json(filename):
+    """배경 JSON 파일 로드 함수"""
+    file_path = os.path.join(BACKGROUNDS_DIR, filename)
     try:
-        # 이미지를 numpy 배열로 변환
-        img_array = np.array(img)
-        
-        # 이미지 크기 줄이기 (성능 향상을 위함)
-        height, width = img_array.shape[0], img_array.shape[1]
-        scale = min(100 / width, 100 / height)
-        new_width, new_height = int(width * scale), int(height * scale)
-        img_resized = img.resize((new_width, new_height))
-        img_array = np.array(img_resized)
-        
-        # 픽셀 배열 변환
-        pixels = img_array.reshape(-1, 3)
-        
-        # 픽셀 샘플링 (성능 향상을 위함)
-        pixel_sample = pixels[np.random.choice(len(pixels), min(5000, len(pixels)), replace=False)]
-        
-        # K-means 대신 간단한 색상 히스토그램 사용
-        colors = {}
-        for pixel in pixel_sample:
-            # RGB 값을 정수 튜플로 변환하여 키로 사용
-            color_key = tuple(map(int, pixel))
-            if color_key in colors:
-                colors[color_key] += 1
-            else:
-                colors[color_key] = 1
-        
-        # 가장 많이 등장한 색상 선택
-        sorted_colors = sorted(colors.items(), key=lambda x: x[1], reverse=True)
-        dominant_colors = [c[0] for c in sorted_colors[:num_colors]]
-        
-        # RGB 값을 색상 이름으로 변환
-        color_names = []
-        for color in dominant_colors:
-            r, g, b = color
-            # HSV로 변환
-            h, s, v = colorsys.rgb_to_hsv(r/255, g/255, b/255)
-            
-            # 색상 이름 결정 (간단한 구현)
-            if s < 0.1 and v > 0.8:
-                color_names.append("white")
-            elif s < 0.1 and v < 0.3:
-                color_names.append("black")
-            elif s < 0.1:
-                if v < 0.5:
-                    color_names.append("gray")
-                else:
-                    color_names.append("light_gray")
-            elif h < 0.05 or h > 0.95:
-                if s > 0.5 and v > 0.5:
-                    color_names.append("red")
-                else:
-                    color_names.append("pink")
-            elif 0.05 <= h < 0.11:
-                if v > 0.7:
-                    color_names.append("orange")
-                else:
-                    color_names.append("brown")
-            elif 0.11 <= h < 0.2:
-                if v > 0.7:
-                    color_names.append("yellow")
-                else:
-                    color_names.append("olive")
-            elif 0.2 <= h < 0.4:
-                if v > 0.7:
-                    color_names.append("green")
-                else:
-                    color_names.append("dark_green")
-            elif 0.4 <= h < 0.5:
-                color_names.append("mint")
-            elif 0.5 <= h < 0.7:
-                if s > 0.5 and v > 0.5:
-                    color_names.append("blue")
-                else:
-                    color_names.append("light_blue")
-            elif 0.7 <= h < 0.8:
-                color_names.append("purple")
-            elif 0.8 <= h < 0.95:
-                if s > 0.5 and v > 0.5:
-                    color_names.append("magenta")
-                else:
-                    color_names.append("pink")
-            else:
-                color_names.append("unknown")
-                
-        return color_names
+        with open(file_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+            logger.info(f"{filename} 파일을 성공적으로 로드했습니다. {len(data)} 항목 포함.")
+            return data
+    except FileNotFoundError:
+        logger.info(f"{filename} 파일이 없습니다.")
+        return {}
     except Exception as e:
-        logger.error(f"색상 추출 중 오류 발생: {e}")
-        return ["unknown"]
+        logger.warning(f"{filename} 파일 로드 중 오류 발생: {str(e)}.")
+        return {}
 
-def identify_clothing_type(img):
-    """이미지에서 의류 타입을 식별하는 함수 (간단한 구현)"""
-    # 실제로는 이미지 인식 모델을 사용하는 것이 좋지만, 
-    # 여기서는 간단한 휴리스틱을 사용합니다.
-    img_array = np.array(img)
-    h, w = img_array.shape[0], img_array.shape[1]
-    aspect_ratio = h / w
-    
-    # 세로로 긴 이미지는 드레스나 코트로 추정
-    if aspect_ratio > 1.8:
-        return "dress"
-    # 정사각형에 가까운 이미지는 상의로 추정
-    elif 0.9 <= aspect_ratio <= 1.3:
-        return "top"
-    # 가로로 넓은 이미지는 바지나 스커트로 추정
-    elif aspect_ratio < 0.8:
-        return "bottom"
-    else:
-        return "outerwear"
+# ------------------- 배경 옵션 초기화 함수 -------------------
+def initialize_backgrounds():
+    """모든 배경 옵션 초기화 함수"""
+    global SIMPLE_BACKGROUNDS, STUDIO_BACKGROUNDS, NATURE_BACKGROUNDS, INDOOR_BACKGROUNDS
+    global TECHNOLOGY_BACKGROUNDS, COLORFUL_PATTERN_BACKGROUNDS, ABSTRACT_BACKGROUNDS
+    global JEWELRY_BACKGROUNDS  # 쥬얼리 배경 추가
 
-def find_similar_references(clothing_type, colors, num_results=3):
-    """의류 타입과 색상을 기반으로 유사한 레퍼런스를 찾는 함수"""
-    if not CLOTHING_REFERENCES:
-        return []
-    
-    # 점수를 계산하여 가장 유사한 레퍼런스 찾기
-    scored_references = []
-    for ref in CLOTHING_REFERENCES:
-        score = 0
-        
-        # 의류 타입 점수
-        ref_type = ref.get("clothing_type", "").lower()
-        if clothing_type in ref_type or ref_type in clothing_type:
-            score += 3
-        elif "top" in clothing_type and any(t in ref_type for t in ["blouse", "shirt", "sweater", "cardigan", "jacket"]):
-            score += 2
-        elif "bottom" in clothing_type and any(t in ref_type for t in ["skirt", "pants", "jeans", "shorts"]):
-            score += 2
-        elif "dress" in clothing_type and "dress" in ref_type:
-            score += 3
-        elif "outerwear" in clothing_type and any(t in ref_type for t in ["coat", "jacket", "cardigan"]):
-            score += 2
-            
-        # 색상 점수
-        ref_color = ref.get("color", "").lower()
-        for color in colors:
-            if color.lower() in ref_color:
-                score += 2
-        
-        scored_references.append((ref, score))
     
-    # 점수에 따라 정렬하고 상위 결과 반환
-    sorted_references = sorted(scored_references, key=lambda x: x[1], reverse=True)
-    return [ref[0] for ref in sorted_references[:num_results]]
-
-# ------------------- 프롬프트 생성 함수 -------------------
-def generate_reference_based_prompt(model_image, clothing_image, shoes_image, custom_prompt=""):
-    """레퍼런스 기반의 프롬프트 생성 함수"""
-    try:
-        # 기본 이미지 검증
-        if not clothing_image:
-            return "오류: 의류 이미지를 업로드해주세요."
-        
-        # 의류 이미지 분석
-        clothing_colors = extract_dominant_colors(clothing_image)
-        clothing_type = identify_clothing_type(clothing_image)
-        
-        # 유사한 레퍼런스 찾기
-        similar_references = find_similar_references(clothing_type, clothing_colors)
-        
-        if not similar_references:
-            # 레퍼런스를 찾지 못한 경우 기본 프롬프트 생성
-            return generate_basic_prompt(model_image, clothing_image, shoes_image, custom_prompt)
-        
-        # 가장 유사한 레퍼런스의 프롬프트 사용
-        best_reference = similar_references[0]
-        reference_prompt = best_reference.get("prompt", "")
-        
-        # 커스텀 프롬프트가 있는 경우, 레퍼런스의 배경/포즈 정보와 결합
-        if custom_prompt.strip():
-            # 배경 및 포즈 정보 추출
-            ref_setting = best_reference.get("setting", "")
-            ref_pose = best_reference.get("pose", "")
-            ref_background = best_reference.get("background", "")
-            
-            # 기본 템플릿 생성
-            template = """Hyperrealistic lifestyle portrait of the woman from image #1 wearing the {clothing_desc} from image #2 {shoes_desc}, {custom_setting}. Her face is exactly preserved from image #1, with identical features, expressions, and complexion. {additional_details} --ar 9:16 --face #1 --seed 123456 --q 3 --v 5.2 --style raw"""
-            
-            # 의류와 신발 설명
-            clothing_desc = f"{', '.join(clothing_colors)} {clothing_type}"
-            shoes_desc = ""
-            if shoes_image:
-                shoes_colors = extract_dominant_colors(shoes_image)
-                shoes_desc = f"and {', '.join(shoes_colors)} shoes from image #3"
-            
-            # 추가 세부 사항
-            additional_details = f"The setting features {ref_background}."
-            
-            # 템플릿 채우기
-            prompt = template.format(
-                clothing_desc=clothing_desc,
-                shoes_desc=shoes_desc,
-                custom_setting=custom_prompt,
-                additional_details=additional_details
-            )
-        else:
-            # 커스텀 프롬프트가 없는 경우, 레퍼런스 프롬프트 그대로 사용하되 의류 설명만 업데이트
-            prompt = reference_prompt
-            
-        return prompt
+    # 디렉토리 내 모든 파일 로깅
+    logger.info(f"Backgrounds 디렉토리 경로: {BACKGROUNDS_DIR}")
+    logger.info(f"디렉토리 내 파일 목록: {os.listdir(BACKGROUNDS_DIR)}")
     
-    except Exception as e:
-        logger.exception("레퍼런스 기반 프롬프트 생성 중 오류:")
-        return f"프롬프트 생성 중 오류가 발생했습니다: {str(e)}"
+    # 각 배경 파일 로드
+    SIMPLE_BACKGROUNDS = load_background_json("simple_backgrounds.json")
+    STUDIO_BACKGROUNDS = load_background_json("studio_backgrounds.json")
+    NATURE_BACKGROUNDS = load_background_json("nature_backgrounds.json")
+    INDOOR_BACKGROUNDS = load_background_json("indoor_backgrounds.json")
+    TECHNOLOGY_BACKGROUNDS = load_background_json("tech-backgrounds-final.json")  # 파일 이름 수정
+    COLORFUL_PATTERN_BACKGROUNDS = load_background_json("colorful-pattern-backgrounds.json")  # 파일 이름 수정
+    ABSTRACT_BACKGROUNDS = load_background_json("abstract_backgrounds.json")
+    JEWELRY_BACKGROUNDS = load_background_json("jewelry_backgrounds.json")
 
-def generate_basic_prompt(model_image, clothing_image, shoes_image, custom_prompt):
-    """기본적인 프롬프트 생성 함수"""
-    # 랜덤으로 상황 선택 (커스텀 프롬프트가 비어있는 경우)
-    SETTINGS = [
-        "in a cozy cafe with wooden tables and warm lighting, sitting comfortably while enjoying a coffee",
-        "walking down a vibrant city street with storefronts, passing by shop windows",
-        "in a bright, modern home interior with minimal decor, relaxing on a comfortable sofa",
-        "at an outdoor terrace cafe with sunlight filtering through trees, seated at a small table",
-        "browsing through books in a warm-lit bookstore with wooden shelves",
-        "in a park with autumn leaves, walking along a stone pathway",
-        "in a modern kitchen with marble countertops, leaning against the island",
-        "at a casual restaurant with ambient lighting, seated in a corner booth",
-        "in a stylish apartment with large windows and city views, standing by the window",
-        "at a quiet corner of a coffee shop with plants and soft lighting, reading a book"
-    ]
     
-    if not custom_prompt.strip():
-        setting = random.choice(SETTINGS)
-    else:
-        setting = custom_prompt
+    # 기본값 설정 (파일이 없거나 비어있는 경우)
+    if not SIMPLE_BACKGROUNDS:
+        SIMPLE_BACKGROUNDS = {"클래식 화이트": "clean white background with soft even lighting"}
+    if not STUDIO_BACKGROUNDS:
+        STUDIO_BACKGROUNDS = {"미니멀 플랫레이": "minimalist flat lay with clean white background"}
+    if not NATURE_BACKGROUNDS:
+        NATURE_BACKGROUNDS = {"열대 해변": "tropical beach with crystal clear water"}
+    if not INDOOR_BACKGROUNDS:
+        INDOOR_BACKGROUNDS = {"미니멀 스칸디나비안 거실": "minimalist Scandinavian living room"}
+    if not TECHNOLOGY_BACKGROUNDS:
+        TECHNOLOGY_BACKGROUNDS = {"다이나믹 스플래시": "dynamic water splash interaction with product"}
+    if not COLORFUL_PATTERN_BACKGROUNDS:
+        COLORFUL_PATTERN_BACKGROUNDS = {"화려한 꽃 패턴": "vibrant floral pattern backdrop"}
+    if not ABSTRACT_BACKGROUNDS:
+        ABSTRACT_BACKGROUNDS = {"네온 라이트": "neon light abstract background with vibrant glowing elements"}
+    if not JEWELRY_BACKGROUNDS:
+        JEWELRY_BACKGROUNDS = {"클래식 화이트 실크": "pristine white silk fabric backdrop"}
     
-    # 완성된 프롬프트 템플릿
-    template = """Hyperrealistic lifestyle portrait of the woman from image #1 wearing the {clothing_desc} from image #2 and {shoes_desc} from image #3, {setting}. Her face is exactly preserved from image #1, with identical features, expressions, and complexion. The clothing fits her perfectly with natural draping, highlighting the fabric texture and design details. The scene is captured in warm, natural lighting that creates a soft, authentic ambience. The photograph has a shallow depth of field, focusing clearly on her and the outfit while gently blurring the background. This creates an intimate, editorial-quality lifestyle image that showcases both the model and the clothing in a natural, everyday moment. --ar 9:16 --face #1 --seed 123456 --q 3 --v 5.2 --style raw"""
+    logger.info("모든 배경 옵션 초기화 완료")
+
+# 배경 드롭다운 초기화를 위한 함수 추가
+def initialize_dropdowns():
+    """드롭다운 메뉴 초기화 함수"""
+    # 각 배경 유형별 드롭다운 선택 목록 생성
+    simple_choices = list(SIMPLE_BACKGROUNDS.keys())
+    studio_choices = list(STUDIO_BACKGROUNDS.keys())
+    nature_choices = list(NATURE_BACKGROUNDS.keys())
+    indoor_choices = list(INDOOR_BACKGROUNDS.keys())
+    tech_choices = list(TECHNOLOGY_BACKGROUNDS.keys())
+    colorful_choices = list(COLORFUL_PATTERN_BACKGROUNDS.keys())
+    abstract_choices = list(ABSTRACT_BACKGROUNDS.keys())
+    jewelry_choices = list(JEWELRY_BACKGROUNDS.keys())
+
+
     
-    # 의류와 신발 설명 (간단한 형태)
-    clothing_colors = extract_dominant_colors(clothing_image) if clothing_image else ["unknown"]
-    clothing_type = identify_clothing_type(clothing_image) if clothing_image else "outfit"
-    clothing_desc = f"{', '.join(clothing_colors)} {clothing_type}"
+    return {
+        "simple": simple_choices,
+        "studio": studio_choices,
+        "nature": nature_choices,
+        "indoor": indoor_choices,
+        "tech": tech_choices,
+        "colorful": colorful_choices,
+        "abstract": abstract_choices,
+        "jewelry": jewelry_choices,  # 새로 추가
+    }
+
+# ------------------- 프롬프트 관련 함수 -------------------
+def filter_prompt_only(prompt):
+    """Gemini의 설명 및 불필요한 메시지를 제거하고 실제 프롬프트만 추출하는 함수"""
     
-    shoes_desc = "complementary footwear"
-    if shoes_image:
-        shoes_colors = extract_dominant_colors(shoes_image)
-        shoes_desc = f"{', '.join(shoes_colors)} shoes"
+    # 코드 블록 내부의 프롬프트 찾기
+    code_block_pattern = r"```\s*(.*?)```"
+    code_match = re.search(code_block_pattern, prompt, re.DOTALL)
+    if code_match:
+        return code_match.group(1).strip()
     
-    # 템플릿 채우기
-    prompt = template.format(
-        clothing_desc=clothing_desc,
-        shoes_desc=shoes_desc,
-        setting=setting
-    )
+    # Midjourney 파라미터를 포함하는 프롬프트 부분 찾기
+    if "--ar 1:1" in prompt:
+        lines = prompt.split('\n')
+        prompt_lines = []
+        in_prompt = False
+        
+        for line in lines:
+            # 프롬프트 시작 부분 인식 (일반적인 제품 설명이나 'Magazine-worthy' 같은 키워드로 시작)
+            if (not in_prompt and 
+                ("product" in line.lower() or 
+                 "magazine" in line.lower() or 
+                 "commercial" in line.lower() or 
+                 "photography" in line.lower())):
+                in_prompt = True
+                prompt_lines.append(line)
+            # 이미 프롬프트 영역에 있는 경우 계속 추가
+            elif in_prompt:
+                # 설명이나 메타 텍스트가 시작되면 중단
+                if "explanation" in line.lower() or "let me know" in line.lower():
+                    break
+                prompt_lines.append(line)
+        
+        # 프롬프트 라인 합치기
+        if prompt_lines:
+            return '\n'.join(prompt_lines).strip()
     
-    return prompt
+    # 위 방법으로 찾지 못한 경우 원본 반환
+    return prompt.strip()
+
+def get_selected_background_info(bg_type, simple, studio, nature, indoor, tech, colorful, abstract, jewelry):
+    """선택된 배경 정보를 가져오는 함수"""
+    if bg_type == "심플 배경":
+        return {
+            "category": "심플 배경",
+            "name": simple,
+            "english": SIMPLE_BACKGROUNDS.get(simple, "white background")
+        }
+    elif bg_type == "스튜디오 배경":
+        return {
+            "category": "스튜디오 배경",
+            "name": studio,
+            "english": STUDIO_BACKGROUNDS.get(studio, "product photography studio")
+        }
+    elif bg_type == "자연 환경":
+        return {
+            "category": "자연 환경",
+            "name": nature,
+            "english": NATURE_BACKGROUNDS.get(nature, "natural environment")
+        }
+    elif bg_type == "실내 환경":
+        return {
+            "category": "실내 환경",
+            "name": indoor,
+            "english": INDOOR_BACKGROUNDS.get(indoor, "indoor environment")
+        }
+    elif bg_type == "테크놀로지 배경":
+        return {
+            "category": "테크놀로지 배경",
+            "name": tech,
+            "english": TECHNOLOGY_BACKGROUNDS.get(tech, "technology environment")
+        }
+    elif bg_type == "컬러풀 패턴 배경":
+        return {
+            "category": "컬러풀 패턴 배경",
+            "name": colorful,
+            "english": COLORFUL_PATTERN_BACKGROUNDS.get(colorful, "colorful pattern background")
+        }
+    elif bg_type == "추상/특수 배경":
+        return {
+            "category": "추상/특수 배경",
+            "name": abstract,
+            "english": ABSTRACT_BACKGROUNDS.get(abstract, "abstract background")
+        }
+
+    elif bg_type == "쥬얼리 배경":
+        return {
+            "category": "쥬얼리 배경",
+            "name": jewelry,
+            "english": JEWELRY_BACKGROUNDS.get(jewelry, "jewelry backdrop")
+        }
+
+    else:
+        return {
+            "category": "기본 배경",
+            "name": "화이트 배경",
+            "english": "white background"
+        }
 
-def generate_prompt_with_gemini(model_image, clothing_image, shoes_image, custom_prompt, reference_prompt):
-    """Gemini를 사용한 완성된 프롬프트 생성 함수"""
+# ------------------- 프롬프트 생성 함수 -------------------
+def generate_enhanced_system_instruction():
+    """향상된 시스템 인스트럭션 생성 함수"""
+    return """당신은 상품 이미지의 배경을 변경하기 위한 최고 품질의 프롬프트를 생성하는 전문가입니다.
+사용자가 제공하는 상품명, 배경 유형, 추가 요청사항을 바탕으로 미드저니(Midjourney)에 사용할 수 있는 상세하고 전문적인 프롬프트를 영어로 생성해주세요.
+
+다음 가이드라인을 반드시 준수해야 합니다:
+
+1. 상품을 "#1"로 지정하여 참조합니다. (예: "skincare tube (#1)")
+2. *** 매우 중요: 상품의 원래 특성(디자인, 색상, 형태, 로고, 패키지 등)은 어떤 상황에서도 절대 변경하지 않습니다. ***
+3. *** 상품의 본질적 특성을 유지하되, 상품에 포커스를 맞춰 모든 세부 사항이 선명하게 드러나도록 하며, 
+   8K 해상도(8K resolution), 오버샤프닝 없는 초고화질(ultra high definition without oversharpening)로 렌더링되어야 합니다. ***
+4. 이미지 비율은 정확히 1:1(정사각형) 형식으로 지정합니다. 프롬프트에 "square format", "1:1 ratio" 또는 "aspect ratio 1:1"을 명시적으로 포함합니다.
+5. 상품은 반드시 정사각형 구도의 정중앙에 배치되어야 하며, 적절한 크기로 표현하여 디테일이 완벽하게 보이도록 합니다.
+6. 상품을 이미지의 주요 초점으로 부각시키고, 상품의 비율이 전체 이미지에서 60-70% 이상 차지하도록 합니다.
+7. 조명 설명을 매우 구체적으로 해주세요. 예: "soft directional lighting from left side", "dramatic rim lighting", "diffused natural light through windows"
+8. 배경의 재질과 질감을 상세히 설명해주세요. 예: "polished marble surface", "rustic wooden table with visible grain", "matte concrete wall with subtle texture"
+9. 프롬프트에 다음 요소들을 명시적으로 포함하되, 사용 맥락에 적절하게 변형하세요:
+   - "award-winning product photography" 
+   - "magazine-worthy commercial product shot"
+   - "professional advertising imagery with perfect exposure"
+   - "studio lighting with color-accurate rendering"
+   - "8K ultra high definition product showcase"
+   - "commercial product photography with precise detail rendering"
+   - "ultra high definition"
+   - "crystal clear details"
+10. *** 최우선 지침: 사용자가 제공한 추가 요청사항을 완벽하게 프롬프트에 반영해야 합니다. 사용자의 요청사항 각각을 중요한 요소로 취급하여 프롬프트에 명시적으로 반영하고, 관련 디테일을 구체적으로 설명하세요. 절대로 사용자의 추가 요청사항을 생략하거나 무시하지 마세요. ***
+11. 사용자가 제공한 구체적인 배경과 추가 요청사항을 프롬프트에 정확히 반영하고 확장합니다.
+12. 프롬프트 끝에 "--ar 1:1 --s 750 --q 2 --v 5.2" 파라미터를 추가하여 미드저니에서 고품질 정사각형 비율을 강제합니다.
+13. 매우 중요: 프롬프트 외에 다른 설명이나 메타 텍스트를 포함하지 마세요. 예를 들어 "Here's a prompt for you" 또는 "Let me know if you need adjustments" 같은 메시지나 설명을 포함하지 마세요. 오직 프롬프트 자체만 제공하세요.
+"""
+
+def generate_prompt_with_gemini(product_name, background_info, additional_info=""):
+    """향상된 프롬프트 생성 함수"""
     GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY", "")
     if not GEMINI_API_KEY:
         return "Gemini API 키가 설정되지 않았습니다. 환경 변수 GEMINI_API_KEY를 설정하거나 코드에 직접 입력하세요."
@@ -295,374 +255,212 @@ def generate_prompt_with_gemini(model_image, clothing_image, shoes_image, custom
     try:
         genai_generative.configure(api_key=GEMINI_API_KEY)
         
-        # 시스템 인스트럭션
-        system_instruction = """당신은 가상 피팅 프롬프트 전문가입니다.
-미드저니에서 사용할 완성된 하나의 프롬프트를 생성해야 합니다.
-단순히 지시사항을 나열하는 것이 아니라, 하나의 구체적인 상황과 설정을 자연스러운 문장으로 묘사해야 합니다.
-다음 원칙을 따르세요:
-1. 완전한 문장으로 구성된 하나의 통합된 프롬프트를 작성하세요. bullet point나 개조식 나열은 절대 사용하지 마세요.
-2. 구체적인 하나의, 그러나 상세한 상황을 설정하세요:
-   - 구체적인 장소 (카페, 거리, 집 등)
-   - 구체적인 행동/포즈 (앉아있기, 걷기, 책 읽기 등)
-   - 구체적인 조명과 분위기 (따뜻한 자연광, 부드러운 카페 조명 등)
-3. 모델의 얼굴 유지를 프롬프트 내용에 자연스럽게 통합하세요.
-   - "Her face is exactly preserved from image #1" 등의 표현을 포함
-4. 의상과 신발에 대한 언급을 통합된 문장에 자연스럽게 포함하세요.
-   - 단순히 "wearing clothing #2" 보다는 더 묘사적으로
-5. 마지막에 미드저니 파라미터를 포함하세요:
-   --ar 9:16 --face #1 --seed 123456 --q 3 --v 5.2 --style raw
-최종 프롬프트는 하나의 완성된 문단으로, 사람이 쉽게 읽을 수 있고 명확한 장면을 상상할 수 있게 작성되어야 합니다.
+        # 추가 요청사항을 더 강조한 프롬프트 요청 템플릿
+        prompt_request = f"""
+상품명: {product_name}
+배경 유형: {background_info.get('english', 'studio')}
+배경 카테고리: {background_info.get('category', '')}
+배경 이름: {background_info.get('name', '')}
+추가 요청사항: {additional_info}
+
+중요 요구사항:
+1. 상품(#1)이 이미지 구도에서 중심적인 위치를 차지하며 적절한 크기(이미지의 60-70%)로 표현되도록 프롬프트를 생성해주세요.
+2. 이미지는 정확히 1:1 비율(정사각형)이어야 합니다.
+3. 상품의 디자인, 색상, 형태, 로고 등 본질적 특성은 절대 수정하지 마세요.
+4. 구체적인 조명 기법을 상세히 명시해주세요:
+   - 정확한 조명 위치 (예: "45-degree key light from upper left")
+   - 조명 품질 (예: "soft diffused light", "hard directional light")
+   - 조명 강도와 색온도 (예: "warm tungsten key light with cool blue fill")
+   - 반사와 그림자 처리 방식 (예: "controlled specular highlights with soft shadow transitions")
+5. 상품을 더 돋보이게 하는 보조 요소(props)를 자연스럽게 활용하되, 상품이 항상 주인공이어야 합니다.
+6. 배경 재질과 표면 질감을 구체적으로 설명하고, 상품과의 상호작용 방식을 명시해주세요.
+7. 색상 구성(color palette, color harmonies)을 명확히 해주세요.
+8. 고급스러운 상업 광고 품질의 이미지가 되도록 프롬프트를 작성해주세요.
+9. 프롬프트 끝에 미드저니 파라미터 "--ar 1:1 --s 750 --q 2 --v 5.2"를 추가해주세요.
+10. **매우 중요**: 사용자가 제공한 추가 요청사항("{additional_info}")을 프롬프트에 완벽하게 반영해야 합니다. 각 요청사항을 프롬프트의 주요 부분에 명시적으로 포함시키고, 관련 디테일을 자세히 기술해주세요.
+
+한국어 입력 내용을 전문적인 영어로 번역하여 반영해주세요.
 """
+        # 추가 요청사항을 강조한 시스템 인스트럭션 생성
+        enhanced_system_instruction = generate_enhanced_system_instruction() + f"""
         
-        # 프롬프트 요청
-        prompt_request = f"""
-다음 가상 피팅 프롬프트를 분석하고, 완성된 하나의 상황을 묘사하는 통합된 문단으로 다시 작성해주세요:
-{reference_prompt}
-사용자의 커스텀 프롬프트/상황: "{custom_prompt}"
-개조식이나 bullet point 형태가 아닌, 완전한 문장들로 구성된 하나의 통합된 문단으로 작성해주세요.
-구체적인 장소, 행동, 조명, 분위기를 포함하여 명확하게 상상할 수 있는 하나의 상황을 묘사해야 합니다.
-얼굴 유지, 의상 착용, 환경 묘사가 모두 자연스럽게 통합되어야 합니다.
-미드저니 파라미터는 그대로 유지하세요.
-응답은 오직 최종 프롬프트 텍스트만 포함해야 합니다.
+특별 지침: 사용자의 추가 요청사항은 최우선 순위로 처리해야 합니다. 추가 요청사항("{additional_info}")의 각 항목을 프롬프트에 명시적으로 포함시키고, 해당 요청에 관련된 구체적인 설명을 추���하세요. 사용자의 요청사항을 무시하거나 생략하지 마세요.
 """
         
-        # 모델 설정 및 생성
+        # 더 창의적인 결과를 위한 생성 설정 조정
         model = genai_generative.GenerativeModel(
-            'gemini-pro',
-            system_instruction=system_instruction
+            'gemini-2.0-flash',
+            system_instruction=enhanced_system_instruction
         )
         
         response = model.generate_content(
             prompt_request,
             generation_config=genai_generative.types.GenerationConfig(
-                temperature=0.7,
+                temperature=0.7,      # 정확성을 위해 약간 낮춤
                 top_p=0.95,
                 top_k=40,
-                max_output_tokens=800,
+                max_output_tokens=1600,  # 더 상세한 프롬프트 허용
             )
         )
         
-        enhanced_prompt = response.text.strip()
+        response_text = response.text.strip()
         
-        # 미드저니 파라미터 확인 및 추가
-        if "--ar 9:16" not in enhanced_prompt:
-            enhanced_prompt += " --ar 9:16 --face #1 --seed 123456 --q 3 --v 5.2 --style raw"
+        # 추가 요청사항이 프롬프트에 제대로 반영되었는지 확인하는 로직
+        if additional_info and not any(keyword.lower() in response_text.lower() for keyword in additional_info.split(',')):
+            # 추가 요청사항이 반영되지 않았다면 추가
+            logger.warning("추가 요청사항이 프롬프트에 반영되지 않았습니다. 강제로 추가합니다.")
             
-        return enhanced_prompt
-    
-    except Exception as e:
-        logger.exception("프롬프트 생성 중 오류 발생:")
-        return f"프롬프트 생성 중 오류가 발생했습니다: {str(e)}"
-
-def filter_prompt_only(prompt):
-    """Gemini의 설명 및 불필요한 메시지를 제거하고 실제 프롬프트만 추출하는 함수"""
-    
-    # 코드 블록 내부의 프롬프트 찾기
-    code_block_pattern = r"```\s*(.*?)```"
-    code_match = re.search(code_block_pattern, prompt, re.DOTALL)
-    if code_match:
-        return code_match.group(1).strip()
-    
-    # "I hope this helps" 등의 메시지 제거
-    end_phrases = [
-        "I hope this", 
-        "This enhanced prompt", 
-        "I've enhanced", 
-        "The above prompt",
-        "Hope this helps",
-        "This prompt will",
-        "Best regards"
-    ]
-    
-    for phrase in end_phrases:
-        idx = prompt.find(phrase)
-        if idx > 0:
-            prompt = prompt[:idx].strip()
-    
-    # 시작 부분에 있을 수 있는 설명 제거
-    start_phrases = [
-        "Here's an enhanced",
-        "Here is the improved",
-        "I've refined",
-        "Below is the",
-        "The enhanced"
-    ]
-    
-    for phrase in start_phrases:
-        if prompt.startswith(phrase):
-            lines = prompt.split('\n', 1)
-            if len(lines) > 1:
-                prompt = lines[1].strip()
-    
-    return prompt.strip()
-
-# ------------------- 프롬프트 생성 메인 함수 -------------------
-def generate_final_prompt(model_image, clothing_image, shoes_image, custom_prompt):
-    """최종 프롬프트 생성 함수"""
-    # 입력값 검증
-    if not model_image or not clothing_image:
-        return "오류: 필수 이미지(모델, 의류)를 모두 업로드해주세요."
-    
-    try:
-        # 레퍼런스 기반 프롬프트 생성
-        reference_prompt = generate_reference_based_prompt(model_image, clothing_image, shoes_image, custom_prompt)
-        
-        # Gemini API를 사용한 프롬프트 개선
-        try:
-            generated_prompt = generate_prompt_with_gemini(model_image, clothing_image, shoes_image, custom_prompt, reference_prompt)
+            # 요청사항을 직접 프롬프트에 추가 (메타 텍스트 없이)
+            if "--ar 1:1" in response_text:
+                # 미드저니 파라미터 앞에 추가
+                parts = response_text.split("--ar 1:1")
+                if len(parts) >= 2:
+                    # 추가 요청사항 직접 삽입
+                    response_text = parts[0].rstrip(" ,") + ", " + additional_info + ". --ar 1:1" + parts[1]
+            else:
+                # 미드저니 파라미터가 없는 경우 끝에 추가
+                response_text = response_text.rstrip(" .") + ". " + additional_info
             
-            # API 키 오류 확인
-            if "Gemini API 키가 설정되지 않았습니다" in generated_prompt:
-                logger.warning("Gemini API 키가 없어 기본 레퍼런스 프롬프트를 사용합니다.")
-                return reference_prompt
+        # 미드저니 파라미터가 없을 경우 추가
+        if "--ar 1:1" not in response_text:
+            response_text = response_text.rstrip(" .") + ". --ar 1:1 --s 750 --q 2 --v 5.2"
             
-            # 프롬프트만 추출
-            final_prompt = filter_prompt_only(generated_prompt)
-            return final_prompt
-        except Exception as e:
-            logger.exception("Gemini 프롬프트 생성 중 오류:")
-            # Gemini API 오류 시 레퍼런스 프롬프트 반환
-            return reference_prompt
-    
+        return response_text
     except Exception as e:
-        logger.exception("최종 프롬프트 생성 중 오류:")
-        # 모든 오류 시 기본 프롬프트 생성
-        return generate_basic_prompt(model_image, clothing_image, shoes_image, custom_prompt)
-
-# ------------------- 레퍼런스 필터링 함수 -------------------
-def filter_references_by_style(style=None):
-    """스타일로 레퍼런스 필터링"""
-    if not style or style == "모든 스타일":
-        return CLOTHING_REFERENCES
-    
-    filtered_refs = [ref for ref in CLOTHING_REFERENCES if ref.get("style", "").lower() == style.lower()]
-    return filtered_refs
-
-def filter_references_by_clothing_type(clothing_type=None):
-    """의류 타입으로 레퍼런스 필터링"""
-    if not clothing_type or clothing_type == "모든 타입":
-        return CLOTHING_REFERENCES
-    
-    filtered_refs = []
-    for ref in CLOTHING_REFERENCES:
-        ref_type = ref.get("clothing_type", "").lower()
-        if clothing_type.lower() in ref_type:
-            filtered_refs.append(ref)
-    
-    return filtered_refs
-
-def get_available_styles():
-    """사용 가능한 모든 스타일 목록 반환"""
-    styles = set()
-    for ref in CLOTHING_REFERENCES:
-        style = ref.get("style", "")
-        if style:
-            styles.add(style)
-    
-    return ["모든 스타일"] + sorted(list(styles))
-
-def get_available_clothing_types():
-    """사용 가능한 모든 의류 타입 목록 반환"""
-    types = set()
-    for ref in CLOTHING_REFERENCES:
-        clothing_type = ref.get("clothing_type", "")
-        if clothing_type:
-            # 복합 타입 분리 (예: "니트 카디건" -> "니트", "카디건")
-            for t in clothing_type.split():
-                types.add(t)
-    
-    return ["모든 타입"] + sorted(list(types))
+        logger.exception("프롬프트 생성 중 오류 발생:")
+        return f"프롬프트 생성 중 오류가 발생했습니다: {str(e)}"
 
-def get_reference_examples(style=None, clothing_type=None, num_examples=5):
-    """스타일과 의류 타입에 따른 레퍼런스 예시 반환"""
-    filtered_by_style = filter_references_by_style(style)
-    filtered_by_type = filter_references_by_clothing_type(clothing_type)
-    
-    # 두 필터 결과의 교집합
-    if style and style != "모든 스타일" and clothing_type and clothing_type != "모든 타입":
-        filtered = [ref for ref in filtered_by_style if ref in filtered_by_type]
-    elif style and style != "모든 스타일":
-        filtered = filtered_by_style
-    elif clothing_type and clothing_type != "모든 타입":
-        filtered = filtered_by_type
-    else:
-        filtered = CLOTHING_REFERENCES
-    
-    # 무작위로 선택
-    if len(filtered) > num_examples:
-        return random.sample(filtered, num_examples)
-    else:
-        return filtered
+# ------------------- 프롬프트 생성 전용 함수 -------------------
+def generate_prompt_only(image, bg_type, simple, studio, nature, indoor, tech, colorful, abstract, jewelry, product_name, additional_info):
+    product_name = product_name.strip() or "제품"
+    background_info = get_selected_background_info(bg_type, simple, studio, nature, indoor, tech, colorful, abstract, jewelry)
+    generated_prompt = generate_prompt_with_gemini(product_name, background_info, additional_info)
+    if "Gemini API 키가 설정되지 않았습니다" in generated_prompt:
+        warning_msg = (
+            "[Gemini API 키 누락]\n"
+            "API 키 설정 방법:\n"
+            "1. 환경 변수: export GEMINI_API_KEY=\"your-api-key\"\n"
+            "2. 코드 내 직접 입력: GEMINI_API_KEY = \"your-api-key\"\n"
+            "키 발급: https://makersuite.google.com/"
+        )
+        return warning_msg
+    final_prompt = filter_prompt_only(generated_prompt)
+    return final_prompt
 
 # ------------------- Gradio 인터페이스 구성 -------------------
 def create_app():
-    with gr.Blocks(title="가상 피팅 스튜디오") as demo:
-        gr.Markdown("# 가상 피팅 스튜디오")
+    # 드롭다운 옵션 초기화
+    dropdown_options = initialize_dropdowns()
+    
+    with gr.Blocks(title="고급 상품 이미지 배경 프롬프트 생성") as demo:
+        gr.Markdown("# 고급 상품 이미지 배경 프롬프트 생성")
         gr.Markdown(
-            "모델, 의류, 신발 이미지를 업로드하여 자연스러운 가상 피팅 프롬프트를 생성합니다."
+            "상품 이미지를 업로드하고, 제품명, 배경 옵션, 추가 요청사항을 입력하면 Gemini API를 통해 영어 프롬프트를 생성합니다."
         )
-        
         with gr.Row():
             with gr.Column(scale=1):
-                # ���미지 업로드 요소들
-                model_image = gr.Image(label="모델 이미지 업로드 (#1로 참조됨)", type="pil")
-                clothing_image = gr.Image(label="의류 이미지 업로드 (#2로 참조됨)", type="pil")
-                shoes_image = gr.Image(label="신발 이미지 업로드 (#3으로 참조됨)", type="pil")
-                
-                # 필터링 옵션
-                with gr.Row():
-                    style_dropdown = gr.Dropdown(
-                        choices=get_available_styles(),
-                        label="스타일 선택",
-                        value="모든 스타일"
-                    )
-                    clothing_type_dropdown = gr.Dropdown(
-                        choices=get_available_clothing_types(),
-                        label="의류 타입 선택",
-                        value="모든 타입"
-                    )
+                product_name = gr.Textbox(label="상품명 (한국어 입력)", placeholder="예: 스킨케어 튜브, 스마트워치, 향수, 운동화 등", interactive=True)
+                # 상품 이미지 업로드를 상품명 아래로 이동
+                image_input = gr.Image(label="상품 이미지 업로드", type="pil")
                 
-                # 레퍼런스 예시 표시
-                reference_examples = gr.Dropdown(
-                    label="레퍼런스 예시 (선택하면 프롬프트가 자동으로 표시됩니다)",
-                    choices=[],
+                background_type = gr.Radio(
+                    choices=["심플 배경", "스튜디오 배경", "자연 환경", "실내 환경", "테크놀로지 배경", "컬러풀 패턴 배경", "추상/특수 배경", "쥬얼리 배경"],
+                    label="배경 유형",
+                    value="심플 배경"
+                )
+                simple_dropdown = gr.Dropdown(
+                    choices=dropdown_options["simple"],
+                    value=dropdown_options["simple"][0] if dropdown_options["simple"] else None,
+                    label="심플 배경 선택",
+                    visible=True,
                     interactive=True
                 )
-                
-                # 커스텀 프롬프트 입력
-                custom_prompt = gr.Textbox(
-                    label="커스텀 상황 설명 (한국어로 입력 가능, 비워두면 레퍼런스 상황 적용)",
-                    placeholder="예: 따뜻한 조명의 카페에서 창가에 앉아 책을 읽고 있는 모습, 햇살이 비치는 거리를 걷고 있는 모습 등",
-                    lines=3,
-                    interactive=True,
-                    value=""
+                studio_dropdown = gr.Dropdown(
+                    choices=dropdown_options["studio"],
+                    value=dropdown_options["studio"][0] if dropdown_options["studio"] else None,
+                    label="스튜디오 배경 선택",
+                    visible=False,
+                    interactive=True
                 )
-                
-                # 프롬프트 생성 버튼
-                prompt_btn = gr.Button("프롬프트 생성", variant="primary")
-                
-                # 예시 상황 선택 드롭다운
-                example_situations = [
-                    "카페에서 창가에 앉아 커피를 마시는 편안한 모습",
-                    "가을 낙엽이 있는 공원 산책로를 걷는 모습",
-                    "모던한 거실에서 소파에 편안하게 앉아 책을 읽는 모습",
-                    "오픈된 주방에서 아일랜드 식탁에 기대어 있는 모습",
-                    "서점에서 책장 사이를 걸으며 책을 고르는 모습",
-                    "야외 테라스 카페에서 햇살을 받으며 앉아있는 모습",
-                    "해변가 산책로를 걸으며 바다를 바라보는 모습",
-                    "도심 속 공원에서 벤치에 앉아 휴식을 취하는 모습",
-                    "갤러리에서 작품을 감상하는 우아한 모습",
-                    "쇼핑몰에서 쇼핑백을 들고 걷는 모습"
-                ]
-                
-                example_dropdown = gr.Dropdown(
-                    choices=example_situations,
-                    label="예시 상황 (선택하면 자동으로 입력됩니다)",
+                nature_dropdown = gr.Dropdown(
+                    choices=dropdown_options["nature"],
+                    value=dropdown_options["nature"][0] if dropdown_options["nature"] else None,
+                    label="자연 환경 선택",
+                    visible=False,
+                    interactive=True
                 )
-                
-                # 드롭다운 선택 시 텍스트박스에 입력
-                example_dropdown.change(
-                    fn=lambda x: x,
-                    inputs=example_dropdown,
-                    outputs=custom_prompt
+                indoor_dropdown = gr.Dropdown(
+                    choices=dropdown_options["indoor"],
+                    value=dropdown_options["indoor"][0] if dropdown_options["indoor"] else None,
+                    label="실내 환경 선택",
+                    visible=False,
+                    interactive=True
                 )
-            
-            with gr.Column(scale=1):
-                # 프롬프트 출력 영역
-                prompt_output = gr.Textbox(label="생성된 프롬프트", lines=8)
-                
-                # 레퍼런스 정보 표시
-                reference_info = gr.Markdown(label="선택된 레퍼런스 정보")
-                
-                # 복사 버튼
-                copy_btn = gr.Button("프롬프트 복사하기", variant="secondary")
-                
-                # 복사 상태 표시
-                copy_status = gr.Markdown("")
-                
-                # 복사 버튼 기능 구현
-                def copy_to_clipboard(text):
-                    return "📋 프롬프트가 준비되었습니다. 텍스트를 선택하고 Ctrl+C(또는 Cmd+C)로 복사하세요."
-                
-                copy_btn.click(
-                    fn=copy_to_clipboard,
-                    inputs=prompt_output,
-                    outputs=copy_status
+                tech_dropdown = gr.Dropdown(
+                    choices=dropdown_options["tech"],
+                    value=dropdown_options["tech"][0] if dropdown_options["tech"] else None,
+                    label="테크놀로지 배경 선택",
+                    visible=False,
+                    interactive=True
+                )
+                colorful_dropdown = gr.Dropdown(
+                    choices=dropdown_options["colorful"],
+                    value=dropdown_options["colorful"][0] if dropdown_options["colorful"] else None,
+                    label="컬러풀 패턴 배경 선택",
+                    visible=False,
+                    interactive=True
+                )
+                abstract_dropdown = gr.Dropdown(
+                    choices=dropdown_options["abstract"],
+                    value=dropdown_options["abstract"][0] if dropdown_options["abstract"] else None,
+                    label="추상/특수 배경 선택",
+                    visible=False,
+                    interactive=True
                 )
                 
-                # 주요 특징 설명
-                gr.Markdown("""
-                ### 주요 특징:
-                - **레퍼런스 기반 프롬프트**: 55개 이상의 스타일 레퍼런스를 바탕으로 최적의 프롬프트 생성
-                - **자동 의류 분석**: 업로드된 의류 이미지 색상과 타입을 자동 분석하여 최적의 레퍼런스 매칭
-                - **얼굴 완벽 보존**: 모델의 얼굴 특징을 자연스럽게 유지하는 최적화된 프롬프트
-                - **맞춤형 환경 설정**: 의류 스타일에 가장 어울리는 배경과 포즈 자동 추천
-                - **AI 강화 프롬프트**: Gemini AI로 더욱 자연스럽고 상세한 프롬프트 생성
-                """)
-        
-        # 레퍼런스 예시 업데이트 함수
-        def update_reference_examples(style, clothing_type):
-            examples = get_reference_examples(style, clothing_type)
-            example_choices = [f"{ref.get('id', '?')}. {ref.get('style', '?')} - {ref.get('clothing_type', '?')} ({ref.get('color', '?')})" for ref in examples]
-            return gr.Dropdown.update(choices=example_choices)
+                jewelry_dropdown = gr.Dropdown(
+                    choices=dropdown_options["jewelry"],
+                    value=dropdown_options["jewelry"][0] if dropdown_options["jewelry"] else None,
+                    label="쥬얼리 배경 선택",
+                    visible=False,
+                    interactive=True
+                )
         
-        # 레퍼런스 선택 시 정보 및 프롬프트 업데이트 함수
-        def update_reference_info(selected_example):
-            if not selected_example:
-                return "", ""
-            
-            try:
-                # ID 추출
-                ref_id = int(selected_example.split('.')[0])
-                
-                # 해당 ID의 레퍼런스 찾기
-                reference = next((ref for ref in CLOTHING_REFERENCES if ref.get("id") == ref_id), None)
+                additional_info = gr.Textbox(
+                    label="추가 요청사항 (선택사항)",
+                    placeholder="예: 고급스러운 느낌, 밝은 조명, 자연스러운 보조 객체 등",
+                    lines=3,
+                    interactive=True
+                )
+                def update_dropdowns(bg_type):
+                    return {
+                        simple_dropdown: gr.update(visible=(bg_type == "심플 배경")),
+                        studio_dropdown: gr.update(visible=(bg_type == "스튜디오 배경")),
+                        nature_dropdown: gr.update(visible=(bg_type == "자연 환경")),
+                        indoor_dropdown: gr.update(visible=(bg_type == "실내 환경")),
+                        tech_dropdown: gr.update(visible=(bg_type == "테크놀로지 배경")),
+                        colorful_dropdown: gr.update(visible=(bg_type == "컬러풀 패턴 배경")),
+                        abstract_dropdown: gr.update(visible=(bg_type == "추상/특수 배경")),
+                        jewelry_dropdown: gr.update(visible=(bg_type == "쥬얼리 배경"))  # 쥬얼리 드롭다운 추가
+                        
+                    }
+                background_type.change(
+                    fn=update_dropdowns,
+                    inputs=[background_type],
+                    outputs=[simple_dropdown, studio_dropdown, nature_dropdown, indoor_dropdown, tech_dropdown, colorful_dropdown, abstract_dropdown, jewelry_dropdown]
+                )
                 
-                if reference:
-                    # 마크다운 형식의 레퍼런스 정보
-                    info = f"""
-                    ### 레퍼런스 #{reference.get('id')}
-                    - **스타일**: {reference.get('style', 'N/A')}
-                    - **의류 타입**: {reference.get('clothing_type', 'N/A')}
-                    - **색상**: {reference.get('color', 'N/A')}
-                    - **환경**: {reference.get('setting', 'N/A')}
-                    - **포즈**: {reference.get('pose', 'N/A')}
-                    - **배경**: {reference.get('background', 'N/A')}
-                    """
-                    
-                    # 프롬프트
-                    prompt = reference.get('prompt', '')
-                    
-                    return info, prompt
-                else:
-                    return "레퍼런스를 찾을 수 없습니다.", ""
-            except Exception as e:
-                return f"오류 발생: {str(e)}", ""
-        
-        # 스타일과 의류 타입 선택 시 레퍼런스 예시 업데이트
-        style_dropdown.change(
-            fn=update_reference_examples,
-            inputs=[style_dropdown, clothing_type_dropdown],
-            outputs=reference_examples
-        )
-        
-        clothing_type_dropdown.change(
-            fn=update_reference_examples,
-            inputs=[style_dropdown, clothing_type_dropdown],
-            outputs=reference_examples
-        )
-        
-        # 레퍼런스 예시 선택 시 정보 및 프롬프트 업데이트
-        reference_examples.change(
-            fn=update_reference_info,
-            inputs=reference_examples,
-            outputs=[reference_info, prompt_output]
-        )
+                # 프롬프트 생성 버튼으로 변경
+                prompt_btn = gr.Button("프롬프트 생성", variant="primary")
+            
+            with gr.Column(scale=1):
+                # 프롬프트 출력 영역만 유지
+                prompt_output = gr.Textbox(label="생성된 프롬프트 (영어)", lines=10)
         
         # 프롬프트 생성 함수 연결
         prompt_btn.click(
-            fn=generate_final_prompt,
-            inputs=[model_image, clothing_image, shoes_image, custom_prompt],
+            fn=generate_prompt_only,
+            inputs=[image_input, background_type, simple_dropdown, studio_dropdown, nature_dropdown, indoor_dropdown, tech_dropdown, colorful_dropdown, abstract_dropdown, jewelry_dropdown, product_name, additional_info],
             outputs=prompt_output
         )
     
@@ -670,6 +468,9 @@ def create_app():
 
 # ------------------- 메인 실행 함수 -------------------
 if __name__ == "__main__":
+    # 배경 옵션 초기화 - JSON 파일에서 로드
+    initialize_backgrounds()
+    
     # 앱 생성 및 실행
     app = create_app()
     app.queue()