Upload 2 files

NAIA/WD14_Auto_Prompt_Generator.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3e8e9ba4a43a52dc2c79dff2a71ea654095f9916eb240f916798a724200031c5
+size 1551836514

NAIA/wd14_test.py

@@ -0,0 +1,782 @@
+import tkinter as tk
+from tkinter import filedialog, messagebox, scrolledtext, ttk
+from PIL import Image, ImageTk, ImageGrab
+import threading
+import os
+import numpy as np
+import pandas as pd
+import cv2
+import tempfile
+import io
+import json
+import sys
+import os
+
+def resource_path(relative_path):
+    """ PyInstaller에 의해 임시 폴더에 생성된 리소스의 절대 경로를 반환합니다. """
+    try:
+        # PyInstaller는 임시 폴더를 생성하고 _MEIPASS에 경로를 저장합니다.
+        base_path = sys._MEIPASS
+    except Exception:
+        base_path = os.path.abspath(".")
+
+    return os.path.join(base_path, relative_path)
+
+class WD14TaggerGUI:
+    def __init__(self, root):
+        self.root = root
+        self.root.title("WD14 Auto Prompt Generator (aiart)")
+        self.root.geometry("700x870")
+
+        self.SETTINGS_FILE = "tagger_app_settings.json"
+
+        self.current_image_path = None
+        self.session = None
+        self.tags_df = None
+
+        # 변수 초기화
+        self.general_threshold_var = tk.DoubleVar(value=0.5)
+        self.char_threshold_var = tk.DoubleVar(value=0.85)
+        self.rm_c_var = tk.BooleanVar()
+        self.rm_color_var = tk.BooleanVar()
+        self.rm_clothes_var = tk.BooleanVar()
+        self.webui_mode_var = tk.BooleanVar()
+        self.instant_inference_var = tk.BooleanVar(value=False)
+        ## 1) 접기/펼치기 상태 변수 추가
+        self.show_removed_tags_var = tk.BooleanVar(value=True)
+        self.show_ignore_tags_var = tk.BooleanVar(value=False)
+        self.prompt_active_var = tk.BooleanVar(value=False)
+
+
+        self.init_filter_data()
+        self.setup_ui()
+        self.load_model()
+        self.show_initial_preview()
+        self.setup_drag_drop()
+
+        self.load_settings()
+        self.root.protocol("WM_DELETE_WINDOW", self.on_closing)
+        
+        ## 2) 전역 Ctrl+V 이벤트 바인딩
+        self.root.bind('<Control-v>', self.handle_paste)
+
+    def init_filter_data(self):
+        # ... (기존과 동일)
+        try:
+            from tagbag import bag_of_tags, clothes_list
+            from character_dictionary import character_dictionary as cd
+
+            self.bag_of_tags = bag_of_tags
+            self.clothes_list = clothes_list
+            self.character_keys = list(cd.keys()) if isinstance(cd, dict) else []
+
+        except ImportError as e:
+            print(f"⚠ NAIA 파일 import 실패: {e}")
+            print("기본 데이터를 사용합니다.")
+            self.bag_of_tags = [
+                'smile', 'blush', 'open_mouth', 'closed_eyes', 'wink', 'frown',
+                'twintails', 'ponytail', 'braid', 'long_hair', 'short_hair',
+                'large_breasts', 'small_breasts', 'cleavage', 'navel'
+            ]
+            self.clothes_list = [
+                'dress', 'skirt', 'shirt', 'jacket', 'uniform', 'school_uniform'
+            ]
+            self.character_keys = []
+
+        self.colors = ['black', 'white', 'blond', 'silver', 'gray', 'yellow',
+                        'blue', 'purple', 'red', 'pink', 'brown', 'orange',
+                        'green', 'aqua', 'gradient']
+    
+    ## 1) 접기/펼치기 토글 함수
+    def toggle_removed_tags(self):
+        if self.show_removed_tags_var.get():
+            self.removed_tags_text.grid(row=3, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
+        else:
+            self.removed_tags_text.grid_forget()
+
+    ## 1) 접기/펼치기 토글 함수
+    def toggle_ignore_tags(self):
+        if self.show_ignore_tags_var.get():
+            self.ignore_tags_text.grid(row=1, column=0, columnspan=2, sticky=(tk.W, tk.E, tk.N, tk.S))
+            self.save_settings_btn.grid(row=1, column=2, sticky="ne", padx=(10, 0))
+        else:
+            self.ignore_tags_text.grid_forget()
+            self.save_settings_btn.grid_forget()
+
+    def toggle_prompts(self):
+        pass
+
+    def setup_ui(self):
+        main_frame = ttk.Frame(self.root, padding="10")
+        main_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
+        
+        # ... (상단 UI 설정은 기존과 거의 동일)
+        load_frame = ttk.Frame(main_frame)
+        load_frame.grid(row=0, column=0, columnspan=2, sticky=(tk.W, tk.E), pady=(0, 10))
+        self.load_btn = ttk.Button(load_frame, text="이미지 불러오기", command=self.load_image)
+        self.load_btn.grid(row=0, column=0, padx=(0, 5))
+        self.clipboard_btn = ttk.Button(load_frame, text="이미지 불러오기 (클립보드)", command=self.load_from_clipboard)
+        self.clipboard_btn.grid(row=0, column=1)
+
+        content_frame = ttk.Frame(main_frame)
+        content_frame.grid(row=1, column=0, columnspan=2, sticky=(tk.W, tk.E, tk.N, tk.S), pady=(0, 10))
+
+        self.preview_frame = ttk.LabelFrame(content_frame, text="미리보기", padding="10")
+        self.preview_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S), padx=(0, 2))
+        self.image_label = ttk.Label(self.preview_frame, text="")
+        self.image_label.grid(row=0, column=0)
+
+        settings_frame = ttk.LabelFrame(content_frame, text="설정", padding="10")
+        settings_frame.grid(row=0, column=1, sticky=(tk.W, tk.E, tk.N, tk.S), padx=(2, 0))
+
+        ttk.Label(settings_frame, text="태그 임계값:").grid(row=0, column=0, sticky=tk.W)
+        ttk.Spinbox(settings_frame, from_=0.0, to=1.0, increment=0.05,
+                   textvariable=self.general_threshold_var, width=15).grid(row=0, column=1, pady=(0, 10))
+
+        ttk.Label(settings_frame, text="캐릭터 임계값:").grid(row=1, column=0, sticky=tk.W)
+        ttk.Spinbox(settings_frame, from_=0.0, to=1.0, increment=0.05,
+                   textvariable=self.char_threshold_var, width=15).grid(row=1, column=1, pady=(0, 10))
+        
+        extract_control_frame = ttk.Frame(settings_frame)
+        extract_control_frame.grid(row=2, column=0, columnspan=2, pady=10)
+
+        self.extract_btn = ttk.Button(extract_control_frame, text="태그 추출",
+                                    command=self.extract_tags, state='disabled')
+        self.extract_btn.pack(side=tk.LEFT, padx=(0, 10))
+
+        self.instant_inference_cb = ttk.Checkbutton(extract_control_frame, text="즉시 추론", variable=self.instant_inference_var)
+        self.instant_inference_cb.pack(side=tk.LEFT)
+
+        filter_frame = ttk.LabelFrame(settings_frame, text="태그 필터링", padding="5")
+        filter_frame.grid(row=3, column=0, columnspan=2, sticky=(tk.W, tk.E), pady=(10, 0))
+        ttk.Checkbutton(filter_frame, text="캐릭터 특징+이름 제거", variable=self.rm_c_var).grid(row=0, column=0, sticky=tk.W, pady=2)
+        ttk.Checkbutton(filter_frame, text="의류 색상 제거", variable=self.rm_color_var).grid(row=1, column=0, sticky=tk.W, pady=2)
+        ttk.Checkbutton(filter_frame, text="의상 제거 (비추천)", variable=self.rm_clothes_var).grid(row=2, column=0, sticky=tk.W, pady=2)
+        ttk.Checkbutton(filter_frame, text="WEBUI/Comfy 모드", variable=self.webui_mode_var).grid(row=3, column=0, sticky=tk.W, pady=2)
+
+        # 선행/후행 프롬프트 프레임
+        prompt_frame = ttk.Frame(settings_frame)
+        prompt_frame.grid(row=4, column=0, columnspan=2, sticky="ew", pady=(15, 0))
+        
+        self.prompt_active_cb = ttk.Checkbutton(prompt_frame, text="선행/후행 프롬프트 활성",
+                                                variable=self.prompt_active_var,
+                                                command=self.toggle_prompts)
+        self.prompt_active_cb.grid(row=0, column=0, sticky="w")
+
+        # 탭 위젯 (Notebook) 생성
+        self.prompt_notebook = ttk.Notebook(prompt_frame)
+        self.prompt_notebook.grid(row=1, column=0, columnspan=2, sticky="ew", pady=(5, 0))
+
+        # 선행 프롬프트 탭
+        prefix_frame = ttk.Frame(self.prompt_notebook, padding=5)
+        self.prompt_notebook.add(prefix_frame, text="선행 프롬프트")
+        self.prefix_text = scrolledtext.ScrolledText(prefix_frame, height=3, width=30)
+        self.prefix_text.pack(fill="both", expand=True)
+
+        # 후행 프롬프트 탭
+        suffix_frame = ttk.Frame(self.prompt_notebook, padding=5)
+        self.prompt_notebook.add(suffix_frame, text="후행 프롬프트")
+        self.suffix_text = scrolledtext.ScrolledText(suffix_frame, height=3, width=30)
+        self.suffix_text.pack(fill="both", expand=True)
+        
+        # 초기 상태 설정
+        self.toggle_prompts()
+
+        result_frame = ttk.LabelFrame(main_frame, text="추출된 태그", padding="10")
+        result_frame.grid(row=2, column=0, columnspan=2, sticky=(tk.W, tk.E, tk.N, tk.S), pady=(10, 0))
+
+        self.result_text = scrolledtext.ScrolledText(result_frame, height=8)
+        self.result_text.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
+        self.result_text.tag_config("prompt", foreground="grey")
+
+        copy_frame = ttk.Frame(result_frame)
+        copy_frame.grid(row=1, column=0, pady=(10, 5), sticky=(tk.W, tk.E))
+        ttk.Button(copy_frame, text="전체 복사", command=self.copy_all_tags).grid(row=0, column=0, padx=(0, 5))
+        ttk.Button(copy_frame, text="2번 태그부터 복사", command=self.copy_from_second).grid(row=0, column=1, padx=5)
+        ttk.Button(copy_frame, text="3번 태그부터 복사", command=self.copy_from_third).grid(row=0, column=2, padx=5)
+
+        ## 1) '제거된 태그' 라벨을 체크박스로 변경
+        self.removed_tags_cb = ttk.Checkbutton(result_frame, text="제거된 태그",
+                                               variable=self.show_removed_tags_var,
+                                               command=self.toggle_removed_tags)
+        self.removed_tags_cb.grid(row=2, column=0, sticky=tk.W, pady=(10, 2))
+        
+        self.removed_tags_text = scrolledtext.ScrolledText(result_frame, height=5)
+        # self.removed_tags_text.grid(...)는 toggle 함수에서 관리
+
+        ## 1) '무시할 태그' 라벨을 체크박스로 변경하고 별도 프레임으로 분리
+        ignore_frame = ttk.Frame(main_frame, padding="0")
+        ignore_frame.grid(row=3, column=0, columnspan=2, sticky=(tk.W, tk.E), pady=(10, 0))
+        
+        self.ignore_tags_cb = ttk.Checkbutton(ignore_frame, text="무시할 태그 (쉼표로 구분)",
+                                              variable=self.show_ignore_tags_var,
+                                              command=self.toggle_ignore_tags)
+        self.ignore_tags_cb.grid(row=0, column=0, sticky=tk.W)
+
+        self.ignore_tags_text = scrolledtext.ScrolledText(ignore_frame, height=4)
+        self.save_settings_btn = ttk.Button(ignore_frame, text="설정 저장", command=self.save_settings)
+
+        ignore_frame.columnconfigure(1, weight=1)
+
+        ## 1) 초기 상태 설정
+        self.toggle_removed_tags()
+        self.toggle_ignore_tags()
+
+        # ... (그리드 설정)
+        self.root.columnconfigure(0, weight=1)
+        self.root.rowconfigure(0, weight=1)
+        main_frame.columnconfigure(0, weight=1)
+        # main_frame.rowconfigure(2)와 (3)은 내용에 따라 자동 조절되도록 weight 미설정
+        content_frame.columnconfigure(0, weight=1)
+        content_frame.columnconfigure(1, weight=1)
+        result_frame.columnconfigure(0, weight=1)
+        result_frame.rowconfigure(0, weight=1)
+
+
+    def on_closing(self):
+        self.save_settings()
+        self.root.destroy()
+
+    def save_settings(self):
+        settings = {
+            'general_threshold': self.general_threshold_var.get(),
+            'char_threshold': self.char_threshold_var.get(),
+            'rm_c': self.rm_c_var.get(),
+            'rm_color': self.rm_color_var.get(),
+            'rm_clothes': self.rm_clothes_var.get(),
+            'webui_mode': self.webui_mode_var.get(),
+            'instant_inference': self.instant_inference_var.get(),
+            'ignore_tags': self.ignore_tags_text.get(1.0, tk.END).strip(),
+            ## 1) 접기/펼치기 상태 저장
+            'show_removed_tags': self.show_removed_tags_var.get(),
+            'show_ignore_tags': self.show_ignore_tags_var.get(),
+            'prompt_active': self.prompt_active_var.get(),
+            'prefix_prompt': self.prefix_text.get(1.0, tk.END).strip(),
+            'suffix_prompt': self.suffix_text.get(1.0, tk.END).strip()
+        }
+        try:
+            with open(self.SETTINGS_FILE, 'w', encoding='utf-8') as f:
+                json.dump(settings, f, indent=4)
+            # if self.root.focus_get() == self.save_settings_btn:
+            #     messagebox.showinfo("저장 완료", f"설정이 {self.SETTINGS_FILE}에 저장되었습니다.")
+        except Exception as e:
+            messagebox.showerror("저장 실패", f"설정 저장 중 오류가 발생했습니다: {e}")
+
+    def load_settings(self):
+        try:
+            if os.path.exists(self.SETTINGS_FILE):
+                with open(self.SETTINGS_FILE, 'r', encoding='utf-8') as f:
+                    settings = json.load(f)
+                    # ... (기존 설정 로드)
+                    self.general_threshold_var.set(settings.get('general_threshold', 0.5))
+                    self.char_threshold_var.set(settings.get('char_threshold', 0.85))
+                    self.rm_c_var.set(settings.get('rm_c', False))
+                    self.rm_color_var.set(settings.get('rm_color', False))
+                    self.rm_clothes_var.set(settings.get('rm_clothes', False))
+                    self.webui_mode_var.set(settings.get('webui_mode', False))
+                    self.instant_inference_var.set(settings.get('instant_inference', False))
+                    
+                    self.ignore_tags_text.delete(1.0, tk.END)
+                    self.ignore_tags_text.insert(1.0, settings.get('ignore_tags', ''))
+
+                    ## 1) 접기/펼치기 상태 로드 및 UI 업데이트
+                    self.show_removed_tags_var.set(settings.get('show_removed_tags', True))
+                    self.show_ignore_tags_var.set(settings.get('show_ignore_tags', False))
+                    self.toggle_removed_tags()
+                    self.toggle_ignore_tags()
+                    self.prompt_active_var.set(settings.get('prompt_active', False))
+                    
+                    self.prefix_text.delete(1.0, tk.END)
+                    self.prefix_text.insert(1.0, settings.get('prefix_prompt', ''))
+                    
+                    self.suffix_text.delete(1.0, tk.END)
+                    self.suffix_text.insert(1.0, settings.get('suffix_prompt', ''))
+
+                    self.toggle_prompts() # UI 상태 업데이트
+
+        except Exception as e:
+            messagebox.showwarning("설정 로드 실패", f"설정 파일({self.SETTINGS_FILE})을 불러오는 데 실패했습니다: {e}")
+    
+    ## 2) 전역 붙여넣기 이벤트 핸들러 추가
+    def handle_paste(self, event):
+        try:
+            # 1. 클립보드에 이미지가 있는지 확인
+            clipboard_image = ImageGrab.grabclipboard()
+            if isinstance(clipboard_image, Image.Image):
+                self.load_from_clipboard()
+                return "break"  # 이벤트 전파 중단
+        except (ValueError, TypeError):
+             pass
+        except Exception as e:
+            print(f"클립보드 이미지 확인 중 오류: {e}")
+
+
+        try:
+            # 클립보드의 텍스트 내용을 가져옵니다.
+            clipboard_text = self.root.clipboard_get()
+            
+            # 2. 클립보드에 텍스트가 있고, URL 형식인지 확인
+            if isinstance(clipboard_text, str) and clipboard_text.startswith(('http://', 'https://')):
+                self._load_image_from_url(clipboard_text)
+                return "break" # 이벤트 전파 중단
+            
+            ## --- 여기부터 추가되는 부분 --- ##
+            # 3. 클립보드 텍스트가 이미지 파일 경로인지 확인
+            image_extensions = ('.jpg', '.jpeg', '.png', '.webp', '.bmp', '.tiff')
+            if isinstance(clipboard_text, str) and clipboard_text.lower().endswith(image_extensions):
+                # 따옴표로 감싸진 경로일 경우 제거 (파일 탐색기에서 복사 시)
+                path = clipboard_text.strip('"')
+                # 파일 시스템에 실제 존재하는 경로인지 확인 후 헬퍼 메서드 호출
+                if os.path.exists(path):
+                    self._load_image_from_path(path)
+                    return "break" # 이벤트 전파 중단
+            ## --- 여기까지 추가 --- ##
+
+        except tk.TclError:
+            # 클립보드에 텍스트가 없는 경우
+            pass
+        except Exception as e:
+            messagebox.showerror("붙여넣기 오류", f"처리 중 오류 발생: {e}")
+            return "break"
+
+        # 위 조건에 해당하지 않으면 기본 붙여넣기 동작
+        return
+
+    ## 2) URL 처리 로직을 별도 메서드로 분리 (재사용성)
+    def _load_image_from_url(self, url):
+        try:
+            img = self.download_image_from_url(url)
+            temp_dir = tempfile.gettempdir()
+            temp_file = os.path.join(temp_dir, f"wd14_url_{os.getpid()}.png")
+            img.save(temp_file)
+            
+            self.current_image_path = temp_file
+            self.show_preview(temp_file)
+            if self.session is not None:
+                self.extract_btn.config(state='normal')
+                if self.instant_inference_var.get():
+                    self.extract_tags()
+        except Exception as e:
+            messagebox.showerror("오류", f"웹 이미지 로드 실패: {str(e)}")
+
+    def load_model(self):
+        try:
+            import onnxruntime as ort
+            
+            # --- 수정 후 ---
+            model_path = resource_path("model.onnx")
+            tags_path = resource_path("selected_tags.csv")
+            
+            self.session = ort.InferenceSession(model_path, providers=['CPUExecutionProvider'])
+            self.tags_df = pd.read_csv(tags_path)
+            
+        except Exception as e:
+            messagebox.showerror("오류", f"모델 로드 실패: {str(e)}")
+
+    def show_initial_preview(self):
+        # ... (기존과 동일)
+        try:
+            white_image = Image.new('RGB', (374, 374), 'white')
+            photo = ImageTk.PhotoImage(white_image)
+            self.image_label.config(image=photo, text="이미지를 Drag&Drop\n해주세요")
+            self.image_label.image = photo
+        except Exception as e:
+            self.image_label.config(text="이미지를 Drag&Drop\n해주세요")
+
+    def setup_drag_drop(self):
+        # ... (기존과 동일)
+        try:
+            from tkinterdnd2 import TkinterDnD, DND_ALL
+            self.TkdndVersion = TkinterDnD._require(self.root)
+            self.image_label.drop_target_register(DND_ALL)
+            self.image_label.dnd_bind('<<Drop>>', self.on_drop)
+            self.image_label.dnd_bind('<<DragEnter>>', self.on_drag_enter)
+            self.image_label.dnd_bind('<<DragLeave>>', self.on_drag_leave)
+        except ImportError:
+            print("tkinterdnd2가 설치되지 않음. pip install tkinterdnd2로 설치하면 드래그앤드롭을 사용할 수 있습니다.")
+        except Exception as e:
+            print(f"Drag & Drop 초기화 오류: {e}")
+
+    # ... (on_drag_enter, on_drag_leave, download_image_from_url 기존과 동일)
+    def on_drag_enter(self, event):
+        try:
+            self.preview_frame.config(text="미리보기 (이미지를 놓아주세요!)")
+        except: pass
+
+    def on_drag_leave(self, event):
+        try:
+            self.preview_frame.config(text="미리보기")
+        except: pass
+
+    def download_image_from_url(self, url):
+        import requests
+        response = requests.get(url)
+        response.raise_for_status()
+        return Image.open(io.BytesIO(response.content))
+
+    def on_drop(self, event):
+        try:
+            if not isinstance(event, str):
+                file_path_or_url = event.data.strip("{}")
+            else:
+                file_path_or_url = event
+
+            if not file_path_or_url:
+                messagebox.showwarning("경고", "드롭된 데이터를 읽을 수 없습니다.")
+                self.preview_frame.config(text="미리보기")
+                return
+            
+            # URL 처리
+            if file_path_or_url.startswith(('http://', 'https://')):
+                self._load_image_from_url(file_path_or_url) ## 2) 재사용되는 URL 로드 함수 호출
+                self.preview_frame.config(text="미리보기")
+                return
+            else:
+                if file_path_or_url.startswith(('blob:')):
+                    messagebox.showwarning("Blob URL 오류", "NAI 홈페이지에서 생성한 이미지는 즉시 복사할 수 없습니다.\n이미지를 다운로드한 후 드래그 & 드롭해주세요.")
+                    self.preview_frame.config(text="미리보기")
+                    return
+                
+                # 파일 처리
+                file_path_or_url = file_path_or_url.replace("\\", '/')
+                if os.path.exists(file_path_or_url):
+                    self.current_image_path = file_path_or_url
+                    self.show_preview(file_path_or_url)
+                    if self.session is not None:
+                        self.extract_btn.config(state='normal')
+                        if self.instant_inference_var.get():
+                            self.extract_tags()
+                    self.preview_frame.config(text="미리보기")
+                else:
+                    messagebox.showerror("오류", f"유효하지 않은 파일 경로입니다: '{file_path_or_url}'")
+                    self.preview_frame.config(text="미리보기")
+                    
+        except Exception as e:
+            messagebox.showerror("오류", f"파일 드롭 오류: {str(e)}")
+            self.preview_frame.config(text="미리보기")
+    
+    def _load_image_from_path(self, path):
+        """주어진 파일 경로에서 이미지를 로드하고 미리보기를 표시합니다."""
+        # 경로의 유효성을 한 번 더 확인합니다.
+        if os.path.exists(path):
+            self.current_image_path = path
+            self.show_preview(path)
+            if self.session is not None:
+                self.extract_btn.config(state='normal')
+                if self.instant_inference_var.get():
+                    self.extract_tags()
+        else:
+            # 혹시 모를 경우를 대비한 경고창
+            messagebox.showwarning("경로 오류", f"파일을 찾을 수 없습니다: {path}")
+
+    def load_from_clipboard(self):
+        try:
+            image = ImageGrab.grabclipboard()
+            if isinstance(image, Image.Image):
+                temp_dir = tempfile.gettempdir()
+                temp_file = os.path.join(temp_dir, f"wd14_clipboard_{os.getpid()}.png")
+                # RGBA 이미지를 RGB로 변환하여 JPEG/PNG 호환성 문제 방지
+                if image.mode == 'RGBA':
+                    image = image.convert('RGB')
+                image.save(temp_file, 'PNG') # 포맷을 명시적으로 지정
+                
+                self.current_image_path = temp_file
+                self.show_preview(temp_file)
+                if self.session is not None:
+                    self.extract_btn.config(state='normal')
+                    if self.instant_inference_var.get():
+                        self.extract_tags()
+            else:
+                # 이 메시지는 handle_paste 로직 때문에 거의 보이지 않게 됨
+                messagebox.showinfo("정보", "클립보드에 이미지가 없습니다.")
+        except Exception as e:
+            messagebox.showerror("오류", f"클립보드 불러오기 오류: {str(e)}")
+
+    # ... (load_image, show_preview, extract_tags, _extract_tags_thread, apply_tag_filters,
+    #  _is_character_name, _format_results, copy 함수들, _update_results, make_square, smart_resize 기존과 동일)
+    def load_image(self):
+        file_path = filedialog.askopenfilename(
+            title="이미지 선택",
+            filetypes=[("이미지 파일", "*.jpg *.jpeg *.png *.bmp *.tiff *.webp")]
+        )
+        if file_path:
+            self.current_image_path = file_path
+            self.show_preview(file_path)
+            if self.session is not None:
+                self.extract_btn.config(state='normal')
+                if self.instant_inference_var.get():
+                    self.extract_tags()
+
+    def show_preview(self, image_path):
+        try:
+            image = Image.open(image_path).convert('RGB')
+            size = max(image.size)
+            square_image = Image.new('RGB', (size, size), 'white')
+            paste_x = (size - image.width) // 2
+            paste_y = (size - image.height) // 2
+            square_image.paste(image, (paste_x, paste_y))
+            square_image.thumbnail((374, 374), Image.Resampling.LANCZOS)
+            photo = ImageTk.PhotoImage(square_image)
+            self.image_label.config(image=photo, text="")
+            self.image_label.image = photo
+        except Exception as e:
+            self.image_label.config(text=f"이미지 로드 실패: {str(e)}")
+
+    def extract_tags(self):
+        if not self.current_image_path or not self.session:
+            return
+        self.extract_btn.config(state='disabled', text='추출 중...')
+        self.result_text.delete(1.0, tk.END)
+        self.result_text.insert(tk.END, "태그 추출 중...")
+        self.removed_tags_text.delete(1.0, tk.END) 
+        thread = threading.Thread(target=self._extract_tags_thread)
+        thread.daemon = True
+        thread.start()
+
+    def _extract_tags_thread(self):
+        try:
+            input_image = Image.open(self.current_image_path)
+            _, height, _, _ = self.session.get_inputs()[0].shape
+            image = input_image.convert('RGBA')
+            new_image = Image.new('RGBA', image.size, 'WHITE')
+            new_image.paste(image, mask=image)
+            image = new_image.convert('RGB')
+            image = np.asarray(image)[:, :, ::-1]
+            image = self.make_square(image, height)
+            image = self.smart_resize(image, height)
+            image = image.astype(np.float32)
+            image = np.expand_dims(image, 0)
+            input_name = self.session.get_inputs()[0].name
+            label_name = self.session.get_outputs()[0].name
+            confidents = self.session.run([label_name], {input_name: image})[0]
+            tags_with_conf = []
+            for i, conf in enumerate(confidents[0]):
+                if i < len(self.tags_df):
+                    tags_with_conf.append((self.tags_df.iloc[i]['name'], float(conf)))
+            tags = dict(tags_with_conf[4:])
+            
+            result_tuple = self._format_results(tags)
+            self.root.after(0, self._update_results, result_tuple)
+        except Exception as e:
+            error_msg = f"태그 추출 오류: {str(e)}"
+            self.root.after(0, self._update_results, (error_msg, ""))
+
+    def apply_tag_filters(self, tags_list):
+        """태그 필터링 적용 (공백 기준으로 로직 단순화)"""
+        # 모델에서 넘어온 원본 태그(_ 포함) 리스트
+        original_tags = tags_list.copy()
+        # 모든 처리를 위해 공백 기준으로 변환한 태그 리스트
+        tags_to_process = [tag.replace('_', ' ') for tag in original_tags]
+        
+        # 최종적으로 남을 태그들의 인덱스를 관리
+        final_indices = list(range(len(tags_to_process)))
+        
+        user_removed_originals = []
+        other_removed_originals = []
+
+        # 1. 사용자가 정의한 무시할 태그 처리
+        ignore_list_str = self.ignore_tags_text.get(1.0, tk.END).strip()
+        if ignore_list_str:
+            user_ignored_tags = {tag.strip().replace('_', ' ') for tag in ignore_list_str.split(',') if tag.strip()}
+            indices_to_remove = {i for i in final_indices if tags_to_process[i] in user_ignored_tags}
+            for i in indices_to_remove:
+                user_removed_originals.append(original_tags[i])
+            final_indices = [i for i in final_indices if i not in indices_to_remove]
+
+        # 2. 나머지 필터들 적용 (내부 데이터가 이미 공백 기준이므로 직접 비교)
+        if self.rm_c_var.get():
+            indices_to_remove = {i for i in final_indices if tags_to_process[i] in self.bag_of_tags or self._is_character_name(tags_to_process[i])}
+            for i in indices_to_remove:
+                other_removed_originals.append(original_tags[i])
+            final_indices = [i for i in final_indices if i not in indices_to_remove]
+
+        if self.rm_color_var.get():
+            indices_to_remove = {i for i in final_indices if any(color in tags_to_process[i] for color in self.colors) and " eyes" not in tags_to_process[i] and " hair" not in tags_to_process[i] and " pupils" not in tags_to_process[i]}
+            for i in indices_to_remove:
+                other_removed_originals.append(original_tags[i])
+            final_indices = [i for i in final_indices if i not in indices_to_remove]
+        
+        if self.rm_clothes_var.get():
+            indices_to_remove = {i for i in final_indices if tags_to_process[i] in self.clothes_list and tags_to_process[i] not in self.bag_of_tags}
+            for i in indices_to_remove:
+                other_removed_originals.append(original_tags[i])
+            final_indices = [i for i in final_indices if i not in indices_to_remove]
+
+        # 3. 최종 태그 목록 생성 및 포맷팅
+        final_tags_with_space = [tags_to_process[i] for i in final_indices]
+        
+        if self.webui_mode_var.get():
+            final_tags_formatted = [tag.replace('(', '\\(').replace(')', '\\)') for tag in final_tags_with_space]
+        else:
+            final_tags_formatted = final_tags_with_space
+
+        # 4. 선행/후행 프롬프트 처리
+        final_tags_with_type = [(tag, 'original') for tag in final_tags_formatted]
+        if self.prompt_active_var.get():
+            prefix_str = self.prefix_text.get(1.0, tk.END).strip()
+            if prefix_str:
+                prefix_tags = [t.strip() for t in prefix_str.split(',') if t.strip()]
+                prefix_tags_with_type = [(tag, 'prompt') for tag in prefix_tags]
+                person_tags = {'1girl', '2girls', '3girls', '4girls', '5girls', '6+girls', 
+                            '1boy', '2boys', '3boys', '4boys', '5boys', '6+boys'}
+                last_person_tag_index = -1
+                search_range = min(len(final_tags_with_type), 4)
+                for i in range(search_range):
+                    if final_tags_with_type[i][0] in person_tags:
+                        last_person_tag_index = i
+                if last_person_tag_index != -1:
+                    final_tags_with_type[last_person_tag_index+1:last_person_tag_index+1] = prefix_tags_with_type
+                else:
+                    final_tags_with_type[0:0] = prefix_tags_with_type
+            
+            suffix_str = self.suffix_text.get(1.0, tk.END).strip()
+            if suffix_str:
+                suffix_tags = [t.strip() for t in suffix_str.split(',') if t.strip()]
+                suffix_tags_with_type = [(tag, 'prompt') for tag in suffix_tags]
+                final_tags_with_type.extend(suffix_tags_with_type)
+
+        return final_tags_with_type, user_removed_originals, list(set(other_removed_originals))
+
+    def _is_character_name(self, tag):
+        if hasattr(self, 'character_keys') and tag in self.character_keys:
+            return True
+        if ('_' in tag and any(c.isupper() for c in tag) and
+            not tag.startswith('1') and
+            not any(word in tag.lower() for word in ['girl', 'boy', 'solo', 'multiple']) and
+            not any(word in tag.lower() for word in ['hair', 'eye', 'dress', 'shirt']) and
+            len(tag) > 3):
+            return True
+        return False
+
+    def _format_results(self, tags):
+        """결과 포맷팅 (타입 정보가 포함된 리스트를 그대로 전달)"""
+        # ... (메서드 상단의 1차 필터링 로직은 동일) ...
+        general_threshold = self.general_threshold_var.get()
+        char_threshold = self.char_threshold_var.get()
+        
+        person_tags = {'1girl', '2girls', '3girls', '4girls', '5girls', '6+girls',
+                       '1boy', '2boys', '3boys', '4boys', '5boys', '6+boys',
+                       'multiple_girls', 'multiple_boys', 'solo', 'no_humans'}
+        
+        filtered_tags = []
+        for tag, conf in tags.items():
+            if tag in person_tags:
+                if conf >= 0.9: filtered_tags.append(tag)
+            elif any(c.isupper() for c in tag) and '_' in tag and conf >= char_threshold:
+                filtered_tags.append(tag)
+            elif conf >= general_threshold:
+                filtered_tags.append(tag)
+
+        # 2차 필터링: 타입 정보가 포함된 최종 태그 리스트를 받음
+        final_tags_with_type, user_removed, other_removed = self.apply_tag_filters(filtered_tags)
+        
+        # 제거된 태그들을 표시용으로 재구성
+        removed_for_display = []
+        for tag in user_removed:
+            removed_for_display.append((tag, 'ignored'))
+        for tag in other_removed:
+            if tag not in user_removed:
+                removed_for_display.append((tag, 'other'))
+        
+        # 튜플로 결과 반환: ((태그, 타입) 리스트, (태그, 타입) 리스트)
+        return final_tags_with_type, removed_for_display
+
+    def copy_all_tags(self):
+        content = self.result_text.get(1.0, tk.END).strip()
+        if content:
+            self.root.clipboard_clear()
+            self.root.clipboard_append(content)
+            #messagebox.showinfo("복사 완료", "전체 태그가 클립보드에 복사되었습니다.")
+        else:
+            messagebox.showwarning("복사 실패", "복사할 태그가 없습니다.")
+
+    def copy_from_second(self):
+        self._copy_from_index(1, "2번 태그부터")
+
+    def copy_from_third(self):
+        self._copy_from_index(2, "3번 태그부터")
+
+    def _copy_from_index(self, start_index, description):
+        content = self.result_text.get(1.0, tk.END).strip()
+        if content:
+            tags_list = [tag.strip() for tag in content.split(',')]
+            if len(tags_list) > start_index:
+                selected_tags = tags_list[start_index:]
+                result = ', '.join(selected_tags)
+                self.root.clipboard_clear()
+                self.root.clipboard_append(result)
+                #messagebox.showinfo("복사 완료", f"{description} 태그가 클립보드에 복사되었습니다.")
+            else:
+                messagebox.showwarning("복사 실패", f"태그가 {start_index + 1}개 미만입니다.")
+        else:
+            messagebox.showwarning("복사 실패", "복사할 태그가 없습니다.")
+
+    def _update_results(self, result_tuple):
+        """결과 업데이트 (선행/후행 프롬프트 색상 적용)"""
+        main_tags_info, removed_tags_info = result_tuple
+        
+        # 메인 태그 박스 업데이트
+        self.result_text.delete(1.0, tk.END)
+        if main_tags_info:
+            for i, (tag, tag_type) in enumerate(main_tags_info):
+                if i > 0:
+                    self.result_text.insert(tk.END, ', ')
+                
+                # 프롬프트 태그일 경우 "prompt" 스타일 적용
+                if tag_type == 'prompt':
+                    self.result_text.insert(tk.END, tag, 'prompt')
+                else: # 'original' 태그
+                    self.result_text.insert(tk.END, tag)
+        
+        # 제거된 태그 박스 업데이트 (기존과 동일)
+        self.removed_tags_text.config(state=tk.NORMAL)
+        self.removed_tags_text.delete(1.0, tk.END)
+        if removed_tags_info:
+            for i, (tag, tag_type) in enumerate(removed_tags_info):
+                display_tag = tag.replace('_', ' ')
+                
+                if i > 0:
+                    self.removed_tags_text.insert(tk.END, ', ')
+                
+                if tag_type == 'ignored':
+                    self.removed_tags_text.insert(tk.END, display_tag, 'ignored')
+                else:
+                    self.removed_tags_text.insert(tk.END, display_tag)
+        self.removed_tags_text.config(state=tk.DISABLED)
+
+        self.extract_btn.config(state='normal', text='태그 추출')
+
+    def make_square(self, img, target_size):
+        old_size = img.shape[:2]
+        desired_size = max(old_size)
+        desired_size = max(desired_size, target_size)
+        delta_w = desired_size - old_size[1]
+        delta_h = desired_size - old_size[0]
+        top, bottom = delta_h // 2, delta_h - (delta_h // 2)
+        left, right = delta_w // 2, delta_w - (delta_w // 2)
+        color = [255, 255, 255]
+        new_im = cv2.copyMakeBorder(
+            img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color
+        )
+        return new_im
+
+    def smart_resize(self, img, size):
+        if img.shape[0] > size:
+            img = cv2.resize(img, (size, size), interpolation=cv2.INTER_AREA)
+        elif img.shape[0] < size:
+            img = cv2.resize(img, (size, size), interpolation=cv2.INTER_CUBIC)
+        return img
+
+def main():
+    try:
+        from tkinterdnd2 import TkinterDnD
+        root = TkinterDnD.Tk()
+    except ImportError:
+        print("tkinterdnd2가 설치되지 않아 Drag & Drop 기능이 비활성화됩니다.")
+        root = tk.Tk()
+
+    app = WD14TaggerGUI(root)
+    root.mainloop()
+
+if __name__ == "__main__":
+    main()