Create app-backup.py

app-backup.py

@@ -0,0 +1,956 @@
+import tempfile
+import time
+from collections.abc import Sequence
+from typing import Any, cast
+import os
+from huggingface_hub import login, hf_hub_download
+
+import gradio as gr
+import numpy as np
+import pillow_heif
+import spaces
+import torch
+from gradio_image_annotation import image_annotator
+from gradio_imageslider import ImageSlider
+from PIL import Image
+from pymatting.foreground.estimate_foreground_ml import estimate_foreground_ml
+from refiners.fluxion.utils import no_grad
+from refiners.solutions import BoxSegmenter
+from transformers import GroundingDinoForObjectDetection, GroundingDinoProcessor
+from diffusers import FluxPipeline
+from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM
+import gc
+
+from PIL import Image, ImageDraw, ImageFont
+from PIL import Image
+from gradio_client import Client, handle_file
+import uuid
+
+
+def clear_memory():
+    """메모리 정리 함수"""
+    gc.collect()
+    try:
+        if torch.cuda.is_available():
+            with torch.cuda.device(0):  # 명시적으로 device 0 사용
+                torch.cuda.empty_cache()
+    except:
+        pass
+
+# GPU 설정
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")  # 명시적으로 cuda:0 지정
+
+# GPU 설정을 try-except로 감싸기
+if torch.cuda.is_available():
+    try:
+        with torch.cuda.device(0):
+            torch.cuda.empty_cache()
+            torch.backends.cudnn.benchmark = True
+            torch.backends.cuda.matmul.allow_tf32 = True
+    except:
+        print("Warning: Could not configure CUDA settings")
+
+# 번역 모델 초기화
+model_name = "Helsinki-NLP/opus-mt-ko-en"
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModelForSeq2SeqLM.from_pretrained(model_name).to('cpu')
+translator = pipeline("translation", model=model, tokenizer=tokenizer, device=-1)
+
+def translate_to_english(text: str) -> str:
+    """한글 텍스트를 영어로 번역"""
+    try:
+        if any(ord('가') <= ord(char) <= ord('힣') for char in text):
+            translated = translator(text, max_length=128)[0]['translation_text']
+            print(f"Translated '{text}' to '{translated}'")
+            return translated
+        return text
+    except Exception as e:
+        print(f"Translation error: {str(e)}")
+        return text
+
+BoundingBox = tuple[int, int, int, int]
+
+pillow_heif.register_heif_opener()
+pillow_heif.register_avif_opener()
+
+# HF 토큰 설정
+HF_TOKEN = os.getenv("HF_TOKEN")
+if HF_TOKEN is None:
+    raise ValueError("Please set the HF_TOKEN environment variable")
+
+try:
+    login(token=HF_TOKEN)
+except Exception as e:
+    raise ValueError(f"Failed to login to Hugging Face: {str(e)}")
+
+# 모델 초기화
+segmenter = BoxSegmenter(device="cpu")
+segmenter.device = device
+segmenter.model = segmenter.model.to(device=segmenter.device)
+
+gd_model_path = "IDEA-Research/grounding-dino-base"
+gd_processor = GroundingDinoProcessor.from_pretrained(gd_model_path)
+gd_model = GroundingDinoForObjectDetection.from_pretrained(gd_model_path, torch_dtype=torch.float32)
+gd_model = gd_model.to(device=device)
+assert isinstance(gd_model, GroundingDinoForObjectDetection)
+
+# FLUX 파이프라인 초기화
+pipe = FluxPipeline.from_pretrained(
+    "black-forest-labs/FLUX.1-dev",
+    torch_dtype=torch.float16,
+    use_auth_token=HF_TOKEN
+)
+pipe.enable_attention_slicing(slice_size="auto")
+
+# LoRA 가중치 로드
+pipe.load_lora_weights(
+    hf_hub_download(
+        "ByteDance/Hyper-SD",
+        "Hyper-FLUX.1-dev-8steps-lora.safetensors",
+        use_auth_token=HF_TOKEN
+    )
+)
+pipe.fuse_lora(lora_scale=0.125)
+
+# GPU 설정을 try-except로 감싸기
+try:
+    if torch.cuda.is_available():
+        pipe = pipe.to("cuda:0")  # 명시적으로 cuda:0 지정
+except Exception as e:
+    print(f"Warning: Could not move pipeline to CUDA: {str(e)}")
+
+client = Client("NabeelShar/BiRefNet_for_text_writing")
+
+class timer:
+    def __init__(self, method_name="timed process"):
+        self.method = method_name
+    def __enter__(self):
+        self.start = time.time()
+        print(f"{self.method} starts")
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        end = time.time()
+        print(f"{self.method} took {str(round(end - self.start, 2))}s")
+
+def bbox_union(bboxes: Sequence[list[int]]) -> BoundingBox | None:
+    if not bboxes:
+        return None
+    for bbox in bboxes:
+        assert len(bbox) == 4
+        assert all(isinstance(x, int) for x in bbox)
+    return (
+        min(bbox[0] for bbox in bboxes),
+        min(bbox[1] for bbox in bboxes),
+        max(bbox[2] for bbox in bboxes),
+        max(bbox[3] for bbox in bboxes),
+    )
+
+def corners_to_pixels_format(bboxes: torch.Tensor, width: int, height: int) -> torch.Tensor:
+    x1, y1, x2, y2 = bboxes.round().to(torch.int32).unbind(-1)
+    return torch.stack((x1.clamp_(0, width), y1.clamp_(0, height), x2.clamp_(0, width), y2.clamp_(0, height)), dim=-1)
+
+def gd_detect(img: Image.Image, prompt: str) -> BoundingBox | None:
+    inputs = gd_processor(images=img, text=f"{prompt}.", return_tensors="pt").to(device=device)
+    with no_grad():
+        outputs = gd_model(**inputs)
+    width, height = img.size
+    results: dict[str, Any] = gd_processor.post_process_grounded_object_detection(
+        outputs,
+        inputs["input_ids"],
+        target_sizes=[(height, width)],
+    )[0]
+    assert "boxes" in results and isinstance(results["boxes"], torch.Tensor)
+    bboxes = corners_to_pixels_format(results["boxes"].cpu(), width, height)
+    return bbox_union(bboxes.numpy().tolist())
+
+def apply_mask(img: Image.Image, mask_img: Image.Image, defringe: bool = True) -> Image.Image:
+    assert img.size == mask_img.size
+    img = img.convert("RGB")
+    mask_img = mask_img.convert("L")
+    if defringe:
+        rgb, alpha = np.asarray(img) / 255.0, np.asarray(mask_img) / 255.0
+        foreground = cast(np.ndarray[Any, np.dtype[np.uint8]], estimate_foreground_ml(rgb, alpha))
+        img = Image.fromarray((foreground * 255).astype("uint8"))
+    result = Image.new("RGBA", img.size)
+    result.paste(img, (0, 0), mask_img)
+    return result
+
+
+def adjust_size_to_multiple_of_8(width: int, height: int) -> tuple[int, int]:
+    """이미지 크기를 8의 배수로 조정하는 함수"""
+    new_width = ((width + 7) // 8) * 8
+    new_height = ((height + 7) // 8) * 8
+    return new_width, new_height
+
+def calculate_dimensions(aspect_ratio: str, base_size: int = 512) -> tuple[int, int]:
+    """선택된 비율에 따라 이미지 크기 계산"""
+    if aspect_ratio == "1:1":
+        return base_size, base_size
+    elif aspect_ratio == "16:9":
+        return base_size * 16 // 9, base_size
+    elif aspect_ratio == "9:16":
+        return base_size, base_size * 16 // 9
+    elif aspect_ratio == "4:3":
+        return base_size * 4 // 3, base_size
+    return base_size, base_size
+
+@spaces.GPU(duration=20)  # 40초에서 20초로 감소
+def generate_background(prompt: str, aspect_ratio: str) -> Image.Image:
+    try:
+        width, height = calculate_dimensions(aspect_ratio)
+        width, height = adjust_size_to_multiple_of_8(width, height)
+        
+        max_size = 768
+        if width > max_size or height > max_size:
+            ratio = max_size / max(width, height)
+            width = int(width * ratio)
+            height = int(height * ratio)
+            width, height = adjust_size_to_multiple_of_8(width, height)
+
+        with timer("Background generation"):
+            try:
+                with torch.inference_mode():
+                    image = pipe(
+                        prompt=prompt,
+                        width=width,
+                        height=height,
+                        num_inference_steps=8,
+                        guidance_scale=4.0
+                    ).images[0]
+            except Exception as e:
+                print(f"Pipeline error: {str(e)}")
+                return Image.new('RGB', (width, height), 'white')
+                
+        return image
+    except Exception as e:
+        print(f"Background generation error: {str(e)}")
+        return Image.new('RGB', (512, 512), 'white')
+
+def create_position_grid():
+    return """
+    <div class="position-grid" style="display: grid; grid-template-columns: repeat(3, 1fr); gap: 10px; width: 150px; margin: auto;">
+        <button class="position-btn" data-pos="top-left">↖</button>
+        <button class="position-btn" data-pos="top-center">↑</button>
+        <button class="position-btn" data-pos="top-right">↗</button>
+        <button class="position-btn" data-pos="middle-left">←</button>
+        <button class="position-btn" data-pos="middle-center">•</button>
+        <button class="position-btn" data-pos="middle-right">→</button>
+        <button class="position-btn" data-pos="bottom-left">↙</button>
+        <button class="position-btn" data-pos="bottom-center" data-default="true">↓</button>
+        <button class="position-btn" data-pos="bottom-right">↘</button>
+    </div>
+    """
+
+def calculate_object_position(position: str, bg_size: tuple[int, int], obj_size: tuple[int, int]) -> tuple[int, int]:
+    """오브젝트의 위치 계산"""
+    bg_width, bg_height = bg_size
+    obj_width, obj_height = obj_size
+    
+    positions = {
+        "top-left": (0, 0),
+        "top-center": ((bg_width - obj_width) // 2, 0),
+        "top-right": (bg_width - obj_width, 0),
+        "middle-left": (0, (bg_height - obj_height) // 2),
+        "middle-center": ((bg_width - obj_width) // 2, (bg_height - obj_height) // 2),
+        "middle-right": (bg_width - obj_width, (bg_height - obj_height) // 2),
+        "bottom-left": (0, bg_height - obj_height),
+        "bottom-center": ((bg_width - obj_width) // 2, bg_height - obj_height),
+        "bottom-right": (bg_width - obj_width, bg_height - obj_height)
+    }
+    
+    return positions.get(position, positions["bottom-center"])
+
+def resize_object(image: Image.Image, scale_percent: float) -> Image.Image:
+    """오브젝트 크기 조정"""
+    width = int(image.width * scale_percent / 100)
+    height = int(image.height * scale_percent / 100)
+    return image.resize((width, height), Image.Resampling.LANCZOS)
+
+def combine_with_background(foreground: Image.Image, background: Image.Image, 
+                          position: str = "bottom-center", scale_percent: float = 100) -> Image.Image:
+    """전경과 배경 합성 함수"""
+    print(f"Combining with position: {position}, scale: {scale_percent}")
+    
+    result = background.convert('RGBA')
+    scaled_foreground = resize_object(foreground, scale_percent)
+    
+    x, y = calculate_object_position(position, result.size, scaled_foreground.size)
+    print(f"Calculated position coordinates: ({x}, {y})")
+    
+    result.paste(scaled_foreground, (x, y), scaled_foreground)
+    return result
+
+@spaces.GPU(duration=30)  # 120초에서 30초로 감소
+def _gpu_process(img: Image.Image, prompt: str | BoundingBox | None) -> tuple[Image.Image, BoundingBox | None, list[str]]:
+    time_log: list[str] = []
+    try:
+        if isinstance(prompt, str):
+            t0 = time.time()
+            bbox = gd_detect(img, prompt)
+            time_log.append(f"detect: {time.time() - t0}")
+            if not bbox:
+                print(time_log[0])
+                raise gr.Error("No object detected")
+        else:
+            bbox = prompt
+        t0 = time.time()
+        mask = segmenter(img, bbox)
+        time_log.append(f"segment: {time.time() - t0}")
+        return mask, bbox, time_log
+    except Exception as e:
+        print(f"GPU process error: {str(e)}")
+        raise
+
+def _process(img: Image.Image, prompt: str | BoundingBox | None, bg_prompt: str | None = None, aspect_ratio: str = "1:1") -> tuple[tuple[Image.Image, Image.Image, Image.Image], gr.DownloadButton]:
+    try:
+        # 입력 이미지 크기 제한
+        max_size = 1024
+        if img.width > max_size or img.height > max_size:
+            ratio = max_size / max(img.width, img.height)
+            new_size = (int(img.width * ratio), int(img.height * ratio))
+            img = img.resize(new_size, Image.LANCZOS)
+
+        # CUDA 메모리 관리 수정
+        try:
+            if torch.cuda.is_available():
+                current_device = torch.cuda.current_device()
+                with torch.cuda.device(current_device):
+                    torch.cuda.empty_cache()
+        except Exception as e:
+            print(f"CUDA memory management failed: {e}")
+
+        with torch.cuda.amp.autocast(enabled=torch.cuda.is_available()):
+            mask, bbox, time_log = _gpu_process(img, prompt)
+            masked_alpha = apply_mask(img, mask, defringe=True)
+
+        if bg_prompt:
+            background = generate_background(bg_prompt, aspect_ratio)
+            combined = background
+        else:
+            combined = Image.alpha_composite(Image.new("RGBA", masked_alpha.size, "white"), masked_alpha)
+
+        clear_memory()
+
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as temp:
+            combined.save(temp.name)
+            return (img, combined, masked_alpha), gr.DownloadButton(value=temp.name, interactive=True)
+    except Exception as e:
+        clear_memory()
+        print(f"Processing error: {str(e)}")
+        raise gr.Error(f"Processing failed: {str(e)}")
+
+def on_change_bbox(prompts: dict[str, Any] | None):
+    return gr.update(interactive=prompts is not None)
+
+
+def on_change_prompt(img: Image.Image | None, prompt: str | None, bg_prompt: str | None = None):
+    return gr.update(interactive=bool(img and prompt))
+
+
+def process_prompt(img: Image.Image, prompt: str, bg_prompt: str | None = None, 
+                  aspect_ratio: str = "1:1", position: str = "bottom-center", 
+                  scale_percent: float = 100) -> tuple[Image.Image, Image.Image]:
+    try:
+        if img is None or prompt.strip() == "":
+            raise gr.Error("Please provide both image and prompt")
+        
+        print(f"Processing with position: {position}, scale: {scale_percent}")  # 디버깅용
+        
+        try:
+            prompt = translate_to_english(prompt)
+            if bg_prompt:
+                bg_prompt = translate_to_english(bg_prompt)
+        except Exception as e:
+            print(f"Translation error (continuing with original text): {str(e)}")
+        
+        results, _ = _process(img, prompt, bg_prompt, aspect_ratio)
+        
+        if bg_prompt:
+            try:
+                print(f"Using position: {position}")  # 디버깅용
+                # 위치 값 검증
+                valid_positions = ["top-left", "top-center", "top-right",
+                                 "middle-left", "middle-center", "middle-right",
+                                 "bottom-left", "bottom-center", "bottom-right"]
+                if position not in valid_positions:
+                    position = "bottom-center"
+                    print(f"Invalid position, using default: {position}")
+                
+                combined = combine_with_background(
+                    foreground=results[2],
+                    background=results[1],
+                    position=position,
+                    scale_percent=scale_percent
+                )
+                return combined, results[2]
+            except Exception as e:
+                print(f"Combination error: {str(e)}")
+                return results[1], results[2]
+        
+        return results[1], results[2]  # 기본 반환 추가
+    except Exception as e:
+        print(f"Error in process_prompt: {str(e)}")
+        raise gr.Error(str(e))
+    finally:
+        clear_memory()
+
+    
+def process_bbox(img: Image.Image, box_input: str) -> tuple[Image.Image, Image.Image]:
+    try:
+        if img is None or box_input.strip() == "":
+            raise gr.Error("Please provide both image and bounding box coordinates")
+        
+        try:
+            coords = eval(box_input)
+            if not isinstance(coords, list) or len(coords) != 4:
+                raise ValueError("Invalid box format")
+            bbox = tuple(int(x) for x in coords)
+        except:
+            raise gr.Error("Invalid box format. Please provide [xmin, ymin, xmax, ymax]")
+        
+        # Process the image
+        results, _ = _process(img, bbox)
+        
+        # 합성된 이미지와 추출된 이미지만 반환
+        return results[1], results[2]
+    except Exception as e:
+        raise gr.Error(str(e))
+
+# Event handler functions 수정
+def update_process_button(img, prompt):
+    return gr.update(
+        interactive=bool(img and prompt),
+        variant="primary" if bool(img and prompt) else "secondary"
+    )
+
+def update_box_button(img, box_input):
+    try:
+        if img and box_input:
+            coords = eval(box_input)
+            if isinstance(coords, list) and len(coords) == 4:
+                return gr.update(interactive=True, variant="primary")
+        return gr.update(interactive=False, variant="secondary")
+    except:
+        return gr.update(interactive=False, variant="secondary")
+
+
+css = """
+footer {display: none}
+.main-title {
+    text-align: center;
+    margin: 1em 0;
+    padding: 1.5em;
+    background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
+    border-radius: 15px;
+    box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+}
+.main-title h1 {
+    color: #2196F3;
+    font-size: 2.8em;
+    margin-bottom: 0.3em;
+    font-weight: 700;
+}
+.main-title p {
+    color: #555;
+    font-size: 1.3em;
+    line-height: 1.4;
+}
+.container {
+    max-width: 1200px;
+    margin: auto;
+    padding: 20px;
+}
+.input-panel, .output-panel {
+    background: white;
+    padding: 1.5em;
+    border-radius: 12px;
+    box-shadow: 0 2px 8px rgba(0,0,0,0.08);
+    margin-bottom: 1em;
+}
+.controls-panel {
+    background: #f8f9fa;
+    padding: 1em;
+    border-radius: 8px;
+    margin: 1em 0;
+}
+.image-display {
+    min-height: 512px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: #fafafa;
+    border-radius: 8px;
+    margin: 1em 0;
+}
+.example-section {
+    text-align: center;
+    padding: 2em;
+    background: #f5f5f5;
+    border-radius: 12px;
+    margin-top: 2em;
+}
+.example-section img {
+    max-width: 100%;
+    border-radius: 8px;
+    box-shadow: 0 4px 8px rgba(0,0,0,0.1);
+}
+.accordion {
+    border: 1px solid #e0e0e0;
+    border-radius: 8px;
+    margin: 1em 0;
+}
+.accordion-header {
+    padding: 1em;
+    background: #f5f5f5;
+    cursor: pointer;
+}
+.accordion-content {
+    padding: 1em;
+    display: none;
+}
+.accordion.open .accordion-content {
+    display: block;
+}
+.position-grid {
+    display: grid;
+    grid-template-columns: repeat(3, 1fr);
+    gap: 8px;
+    margin: 1em 0;
+}
+.position-btn {
+    padding: 10px;
+    border: 1px solid #ddd;
+    border-radius: 4px;
+    background: white;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    width: 40px;
+    height: 40px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+.position-btn:hover {
+    background: #e3f2fd;
+}
+.position-btn.selected {
+    background-color: #2196F3;
+    color: white;
+    border-color: #1976D2;
+}
+"""
+
+
+def add_text_with_stroke(draw, text, x, y, font, text_color, stroke_width):
+    """Helper function to draw text with stroke"""
+    # Draw the stroke/outline
+    for adj_x in range(-stroke_width, stroke_width + 1):
+        for adj_y in range(-stroke_width, stroke_width + 1):
+            draw.text((x + adj_x, y + adj_y), text, font=font, fill=text_color)
+
+def remove_background(image):
+    # Save the image to a specific location
+    filename = f"image_{uuid.uuid4()}.png"  # Generates a universally unique identifier (UUID) for the filename
+    image.save(filename)
+    # Call gradio client for background removal
+    result = client.predict(images=handle_file(filename), api_name="/image")
+    return Image.open(result[0])
+
+def superimpose(image_with_text, overlay_image):
+    # Open image as RGBA to handle transparency
+    overlay_image = overlay_image.convert("RGBA")
+    # Paste overlay on the background
+    image_with_text.paste(overlay_image, (0, 0), overlay_image)
+    # Save the final image
+    # image_with_text.save("output_image.png")
+    return image_with_text
+
+def add_text_to_image(
+    input_image,
+    text,
+    font_size,
+    color,
+    opacity,
+    x_position,
+    y_position,
+    thickness,
+    text_position_type,
+    font_choice
+):
+    try:
+        if input_image is None or text.strip() == "":
+            return input_image
+
+        # PIL Image 객체로 변환
+        if not isinstance(input_image, Image.Image):
+            if isinstance(input_image, np.ndarray):
+                image = Image.fromarray(input_image)
+            else:
+                raise ValueError("Unsupported image type")
+        else:
+            image = input_image.copy()
+
+        # 이미지를 RGBA 모드로 변환
+        if image.mode != 'RGBA':
+            image = image.convert('RGBA')
+
+        # 폰트 설정
+        font_files = {
+            "Default": "DejaVuSans.ttf",
+            "Korean Regular": "ko-Regular.ttf"
+        }
+        
+        try:
+            font_file = font_files.get(font_choice, "DejaVuSans.ttf")
+            font = ImageFont.truetype(font_file, int(font_size))
+        except Exception as e:
+            print(f"Font loading error ({font_choice}): {str(e)}")
+            font = ImageFont.load_default()
+        
+        # 색상 설정
+        color_map = {
+            'White': (255, 255, 255),
+            'Black': (0, 0, 0),
+            'Red': (255, 0, 0),
+            'Green': (0, 255, 0),
+            'Blue': (0, 0, 255),
+            'Yellow': (255, 255, 0),
+            'Purple': (128, 0, 128)
+        }
+        rgb_color = color_map.get(color, (255, 255, 255))
+        
+        # 임시 Draw 객체 생성하여 텍스트 크기 계산
+        temp_draw = ImageDraw.Draw(image)
+        text_bbox = temp_draw.textbbox((0, 0), text, font=font)
+        text_width = text_bbox[2] - text_bbox[0]
+        text_height = text_bbox[3] - text_bbox[1]
+
+        # 위치 계산
+        actual_x = int((image.width - text_width) * (x_position / 100))
+        actual_y = int((image.height - text_height) * (y_position / 100))
+
+        # 텍스트 색상 설정
+        text_color = (*rgb_color, int(opacity))
+        
+        if text_position_type == "Text Behind Image":
+            try:
+                # 원본 이미지에서 전경 객체만 추출
+                foreground = remove_background(image)
+                
+                # 배경 이미지 생성 (원본 이미지 복사)
+                background = image.copy()
+                
+                # 텍스트를 그릴 임시 레이어 생성
+                text_layer = Image.new('RGBA', image.size, (255, 255, 255, 0))
+                draw_text = ImageDraw.Draw(text_layer)
+                
+                # 텍스트 그리기
+                add_text_with_stroke(
+                    draw_text,
+                    text,
+                    actual_x,
+                    actual_y,
+                    font,
+                    text_color,
+                    int(thickness)
+                )
+                
+                # 배경에 텍스트 합성
+                background = Image.alpha_composite(background, text_layer)
+                
+                # 텍스트가 있는 배경 위에 전경 객체 합성
+                output_image = Image.alpha_composite(background, foreground)
+            except Exception as e:
+                print(f"Error in Text Behind Image processing: {str(e)}")
+                return input_image
+        else:
+            # 텍스트 오버레이 생성
+            txt_overlay = Image.new('RGBA', image.size, (255, 255, 255, 0))
+            draw = ImageDraw.Draw(txt_overlay)
+            
+            # 텍스트를 이미지 위에 그리기
+            add_text_with_stroke(
+                draw,
+                text,
+                actual_x,
+                actual_y,
+                font,
+                text_color,
+                int(thickness)
+            )
+            output_image = Image.alpha_composite(image, txt_overlay)
+        
+        # RGB로 변환
+        output_image = output_image.convert('RGB')
+        
+        return output_image
+
+    except Exception as e:
+        print(f"Error in add_text_to_image: {str(e)}")
+        return input_image
+
+    
+def update_position(new_position):
+    """위치 업데이트 함수"""
+    print(f"Position updated to: {new_position}")
+    return new_position
+
+def update_controls(bg_prompt):
+    """배경 프롬프트 입력 여부에 따라 컨트롤 표시 업데이트"""
+    is_visible = bool(bg_prompt)
+    return [
+        gr.update(visible=is_visible),  # aspect_ratio
+        gr.update(visible=is_visible),  # object_controls
+    ]
+
+with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
+    position = gr.State(value="bottom-center")  # 여기로 이동
+
+    gr.HTML("""
+        <div class="main-title">
+            <h1>🎨 GiniGen Canvas-o3</h1>
+            <p>Remove background of specified objects, generate new backgrounds, and insert text over or behind images with prompts.</p>
+        </div>
+    """)
+
+    with gr.Row(equal_height=True):
+        # 왼쪽 패널 (입력)
+        with gr.Column(scale=1):
+            with gr.Group(elem_classes="input-panel"):
+                input_image = gr.Image(
+                    type="pil",
+                    label="Upload Image",
+                    interactive=True,
+                    height=400
+                )
+                text_prompt = gr.Textbox(
+                    label="Object to Extract",
+                    placeholder="Enter what you want to extract...",
+                    interactive=True
+                )
+                with gr.Row():
+                    bg_prompt = gr.Textbox(
+                        label="Background Prompt (optional)",
+                        placeholder="Describe the background...",
+                        interactive=True,
+                        scale=3
+                    )
+                    aspect_ratio = gr.Dropdown(
+                        choices=["1:1", "16:9", "9:16", "4:3"],
+                        value="1:1",
+                        label="Aspect Ratio",
+                        interactive=True,
+                        visible=True,
+                        scale=1
+                    )
+
+                with gr.Group(elem_classes="controls-panel", visible=False) as object_controls:
+                    with gr.Column(scale=1):
+                        position = gr.State(value="bottom-center")  # 초기값 설정
+                        with gr.Row():
+                            btn_top_left = gr.Button("↖", elem_classes="position-btn")
+                            btn_top_center = gr.Button("↑", elem_classes="position-btn")
+                            btn_top_right = gr.Button("↗", elem_classes="position-btn")
+                        with gr.Row():
+                            btn_middle_left = gr.Button("←", elem_classes="position-btn")
+                            btn_middle_center = gr.Button("•", elem_classes="position-btn")
+                            btn_middle_right = gr.Button("→", elem_classes="position-btn")
+                        with gr.Row():
+                            btn_bottom_left = gr.Button("↙", elem_classes="position-btn")
+                            btn_bottom_center = gr.Button("↓", elem_classes="position-btn", value="selected")
+                            btn_bottom_right = gr.Button("↘", elem_classes="position-btn")
+                    with gr.Column(scale=1):
+                        scale_slider = gr.Slider(
+                            minimum=10,
+                            maximum=200,
+                            value=50,
+                            step=5,
+                            label="Object Size (%)"
+                        )
+
+                process_btn = gr.Button(
+                    "Process",
+                    variant="primary",
+                    interactive=False,
+                    size="lg"
+                )
+
+        # 오른쪽 패널 (출력)
+        with gr.Column(scale=1):
+            with gr.Group(elem_classes="output-panel"):
+                with gr.Tab("Result"):
+                    combined_image = gr.Image(
+                        label="Combined Result",
+                        show_download_button=True,
+                        type="pil",
+                        height=400
+                    )
+                    
+                    # 텍스트 삽입 옵션을 Accordion으로 변경
+                    with gr.Accordion("Text Insertion Options", open=False):
+                        with gr.Group():
+                            with gr.Row():
+                                text_input = gr.Textbox(
+                                    label="Text Content",
+                                    placeholder="Enter text to add..."
+                                )
+                                text_position_type = gr.Radio(
+                                    choices=["Text Over Image", "Text Behind Image"],
+                                    value="Text Over Image",
+                                    label="Text Position"
+                                )
+                            
+                            with gr.Row():
+                                with gr.Column(scale=1):
+                                    font_choice = gr.Dropdown(
+                                        choices=["Default", "Korean Regular"],  # "Korean Son" 제거
+
+                                        value="Default",
+                                        label="Font Selection",
+                                        interactive=True
+                                    )
+
+                                    
+                                    font_size = gr.Slider(
+                                        minimum=10,
+                                        maximum=200,
+                                        value=40,
+                                        step=5,
+                                        label="Font Size"
+                                    )
+                                    color_dropdown = gr.Dropdown(
+                                        choices=["White", "Black", "Red", "Green", "Blue", "Yellow", "Purple"],
+                                        value="White",
+                                        label="Text Color"
+                                    )
+                                    thickness = gr.Slider(
+                                        minimum=0,
+                                        maximum=10,
+                                        value=1,
+                                        step=1,
+                                        label="Text Thickness"
+                                    )
+                                with gr.Column(scale=1):
+                                    opacity_slider = gr.Slider(
+                                        minimum=0,
+                                        maximum=255,
+                                        value=255,
+                                        step=1,
+                                        label="Opacity"
+                                    )
+                                    x_position = gr.Slider(
+                                        minimum=0,
+                                        maximum=100,
+                                        value=50,
+                                        step=1,
+                                        label="Left(0%)~Right(100%)"
+                                    )
+                                    y_position = gr.Slider(
+                                        minimum=0,
+                                        maximum=100,
+                                        value=50,
+                                        step=1,
+                                        label="High(0%)~Low(100%)"
+                                    )
+                            add_text_btn = gr.Button("Apply Text", variant="primary")
+
+                    extracted_image = gr.Image(
+                        label="Extracted Object",
+                        show_download_button=True,
+                        type="pil",
+                        height=200
+                    )
+
+    # CSS 클래스를 위한 스타일 추가
+    gr.HTML("""
+        <style>
+        .position-btn.selected {
+            background-color: #2196F3 !important;
+            color: white !important;
+        }
+        </style>
+    """)
+
+# 버튼 클릭 이벤트 바인딩
+    position_mapping = {
+        btn_top_left: "top-left",
+        btn_top_center: "top-center",
+        btn_top_right: "top-right",
+        btn_middle_left: "middle-left",
+        btn_middle_center: "middle-center",
+        btn_middle_right: "middle-right",
+        btn_bottom_left: "bottom-left",
+        btn_bottom_center: "bottom-center",
+        btn_bottom_right: "bottom-right"
+    }
+
+    for btn, pos in position_mapping.items():
+        btn.click(
+            fn=lambda pos=pos: update_position(pos),  # 클로저 문제 해결을 위해 수정
+            outputs=position
+        )
+ 
+
+    # 이벤트 바인딩
+    bg_prompt.change(
+        fn=update_controls,
+        inputs=bg_prompt,
+        outputs=[aspect_ratio, object_controls],
+        queue=False
+    )
+    
+    input_image.change(
+        fn=update_process_button,
+        inputs=[input_image, text_prompt],
+        outputs=process_btn,
+        queue=False
+    )
+    
+    text_prompt.change(
+        fn=update_process_button,
+        inputs=[input_image, text_prompt],
+        outputs=process_btn,
+        queue=False
+    )
+
+    process_btn.click(
+        fn=process_prompt,
+        inputs=[
+            input_image,
+            text_prompt,
+            bg_prompt,
+            aspect_ratio,
+            position,
+            scale_slider
+        ],
+        outputs=[combined_image, extracted_image],
+        queue=True
+    )
+
+# 이벤트 바인딩 부분에서
+    add_text_btn.click(
+        fn=add_text_to_image,
+        inputs=[
+            combined_image,  # 첫 번째 인자로 이미지
+            text_input,      # 두 번째 인자로 텍스트
+            font_size,
+            color_dropdown,
+            opacity_slider,
+            x_position,
+            y_position,
+            thickness,
+            text_position_type,
+            font_choice
+        ],
+        outputs=combined_image,
+        api_name="add_text"  # API 이름 추가
+    )
+    
+
+
+demo.queue(max_size=5)
+demo.launch(
+    server_name="0.0.0.0",
+    server_port=7860,
+    share=False,
+    max_threads=2
+)