initial commit

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1 @@
+.venv

README copy.md

@@ -0,0 +1 @@
+# 리드미

app.py

@@ -0,0 +1,660 @@
+import gradio as gr
+import cv2
+import numpy as np
+import pandas as pd
+import json
+import os
+import threading
+import gc
+from datetime import datetime
+try:
+    from pyngrok import ngrok
+    NGROK_AVAILABLE = True
+except ImportError:
+    NGROK_AVAILABLE = False
+try:
+    from skimage.metrics import structural_similarity as ssim
+    from skimage.metrics import peak_signal_noise_ratio as psnr
+except ImportError:
+    # scikit-image가 없는 경우 대체 방법 사용
+    def ssim(img1, img2):
+        # 간단한 MSE 기반 유사도 계산
+        mse = np.mean((img1 - img2) ** 2)
+        return 1 / (1 + mse / 1000)
+    
+    def psnr(img1, img2):
+        mse = np.mean((img1 - img2) ** 2)
+        if mse == 0:
+            return 100
+        return 20 * np.log10(255.0 / np.sqrt(mse))
+import io
+
+class ImageSimilarityLeaderboard:
+    def __init__(self, reference_image_path="label2.jpg", data_file="leaderboard.json"):
+        self.reference_image_path = reference_image_path
+        self.data_file = data_file
+        self.admin_password = "9900"  # 관리자 비밀번호
+        self.admin_authenticated = False  # 관리자 인증 상태
+        
+        # 메모리 최적화를 위한 캐시 및 락 (먼저 초기화)
+        self._ref_image_cache = None
+        self._cache_loaded = False
+        self._file_lock = threading.Lock()  # 파일 I/O 동시성 제어
+        self._processing_lock = threading.Lock()  # 처리 동시성 제어
+        
+        # 락 초기화 후 데이터 로드
+        self.leaderboard_data = self.load_leaderboard()
+        self.last_modified = self.get_file_modified_time()
+
+        # macOS 호환성을 위한 경고 억제
+        import warnings
+        warnings.filterwarnings("ignore", category=UserWarning, module="cv2")
+        
+    def load_leaderboard(self):
+        """리더보드 데이터를 로드합니다."""
+        with self._file_lock:  # 파일 I/O 동시성 제어
+            if os.path.exists(self.data_file):
+                try:
+                    with open(self.data_file, 'r', encoding='utf-8') as f:
+                        return json.load(f)
+                except:
+                    return []
+            return []
+    
+    def get_file_modified_time(self):
+        """파일 수정 시간을 반환합니다."""
+        if os.path.exists(self.data_file):
+            return os.path.getmtime(self.data_file)
+        return 0
+    
+    def save_leaderboard(self):
+        """리더보드 데이터를 저장합니다."""
+        with self._file_lock:  # 파일 I/O 동시성 제어
+            with open(self.data_file, 'w', encoding='utf-8') as f:
+                json.dump(self.leaderboard_data, f, ensure_ascii=False, indent=2)
+            self.last_modified = self.get_file_modified_time()
+    
+    def check_for_updates(self):
+        """리더보드 업데이트 확인"""
+        current_modified = self.get_file_modified_time()
+        if current_modified > self.last_modified:
+            self.leaderboard_data = self.load_leaderboard()
+            self.last_modified = current_modified
+            return True
+        return False
+    
+    def _load_reference_image(self):
+        """참조 이미지를 한 번만 로드하고 캐시합니다."""
+        if not self._cache_loaded:
+            if os.path.exists(self.reference_image_path):
+                ref_image = cv2.imread(self.reference_image_path)
+                if ref_image is not None:
+                    # macOS 메모리 최적화
+                    if ref_image.shape[0] > 1024 or ref_image.shape[1] > 1024:
+                        # 큰 이미지는 미리 리사이즈하여 메모리 사용량 감소
+                        scale = min(1024 / ref_image.shape[0], 1024 / ref_image.shape[1])
+                        if scale < 1:
+                            new_width = int(ref_image.shape[1] * scale)
+                            new_height = int(ref_image.shape[0] * scale)
+                            ref_image = cv2.resize(ref_image, (new_width, new_height))
+
+                    self._ref_image_cache = cv2.cvtColor(ref_image, cv2.COLOR_BGR2RGB)
+                    self._cache_loaded = True
+                    # 메모리 정리
+                    del ref_image
+                    gc.collect()
+        return self._ref_image_cache
+    
+    def _get_memory_usage(self):
+        """현재 메모리 사용량을 반환합니다."""
+        try:
+            import psutil
+            process = psutil.Process()
+            memory_info = process.memory_info()
+            return memory_info.rss / 1024 / 1024  # MB 단위
+        except (ImportError, AttributeError):
+            # macOS나 다른 환경에서 psutil이 없거나 동작하지 않는 경우
+            try:
+                import resource
+                # getrusage를 통한 메모리 사용량 측정
+                usage = resource.getrusage(resource.RUSAGE_SELF)
+                return usage.ru_maxrss / 1024  # KB -> MB
+            except:
+                return 0
+    
+    def calculate_similarity(self, image1, image2):
+        try:
+            # 1) 그레이스케일 변환
+            if image1.ndim == 3:
+                gray1 = cv2.cvtColor(image1, cv2.COLOR_RGB2GRAY)
+            else:
+                gray1 = image1.copy()
+
+            if image2.ndim == 3:
+                gray2 = cv2.cvtColor(image2, cv2.COLOR_RGB2GRAY)
+            else:
+                gray2 = image2.copy()
+
+            # 2) 각 이미지를 독립적으로 표준 크기로 리사이즈 (512x512)
+            target_size = (512, 512)
+
+            gray1 = cv2.resize(gray1, target_size, interpolation=cv2.INTER_LINEAR)
+            gray2 = cv2.resize(gray2, target_size, interpolation=cv2.INTER_LINEAR)
+
+            # 4) SSIM 계산 (구조적 유사도)
+            try:
+                ssim_score = ssim(gray1.astype(np.float32), gray2.astype(np.float32))
+            except:
+                # SSIM 계산 실패시 MSE 기반 대체
+                mse = np.mean((gray1.astype(np.float32) - gray2.astype(np.float32)) ** 2)
+                ssim_score = 1 / (1 + mse / 10000)
+
+            # 5) PSNR 계산 (픽셀 단위 유사도)
+            mse = np.mean((gray1.astype(np.float32) - gray2.astype(np.float32)) ** 2)
+            if mse == 0:
+                psnr_score = 1.0
+            else:
+                psnr_score = 20 * np.log10(255.0 / np.sqrt(mse))
+                # PSNR을 0-1 범위로 더 관대하게 정규화 (보통 PSNR은 20-40 범위)
+                psnr_score = min(psnr_score / 40.0, 1.0)
+
+            # 6) 히스토그램 유사도
+            hist1 = cv2.calcHist([gray1], [0], None, [256], [0, 256])
+            hist2 = cv2.calcHist([gray2], [0], None, [256], [0, 256])
+            hist_corr = cv2.compareHist(hist1, hist2, cv2.HISTCMP_CORREL)
+            hist_score = (hist_corr + 1) / 2  # -1~1 → 0~1
+
+            # 7) 최종 점수 계산 (더 단순하게)
+            final_score = (ssim_score * 0.7 + hist_score * 0.3) * 100
+
+            # 8) PSNR이 높으면 약간의 보너스
+            if psnr_score > 0.8:
+                bonus = min((psnr_score - 0.8) * 25, 5)  # 최대 5점 보너스
+                final_score = min(final_score + bonus, 100)
+
+            return {
+                'ssim': float(ssim_score),
+                'psnr': float(psnr_score * 100),  # 백분율로 변환
+                'histogram': float(hist_score),
+                'template': 0.0,  # 사용하지 않음
+                'edge': 0.0,      # 사용하지 않음
+                'phash': 0.0,     # 사용하지 않음
+                'final_score': float(final_score)
+            }
+        except Exception as e:
+            print(f"유사도 계산 오류: {e}")
+            return {'ssim':0.0,'psnr':0.0,'histogram':0.0,'template':0.0,'edge':0.0,'phash':0.0,'final_score':0.0}
+    
+    def process_image(self, uploaded_image, username):
+        """업로드된 이미지를 처리하고 점수를 계산합니다."""
+        if uploaded_image is None:
+            return "📤 이미지를 업로드해주세요.", self.get_leaderboard_df()
+        
+        # 사용자명 검증 제거 - 어떤 이름이든 허용
+        if not username or not username.strip():
+            return "❌ 사용자 이름을 입력해주세요.", self.get_leaderboard_df()
+        
+        username = username.strip()
+        
+        # 동시성 제어 - 한 번에 하나의 이미지만 처리
+        with self._processing_lock:
+            try:
+                # 캐시된 참조 이미지 사용
+                ref_image = self._load_reference_image()
+                if ref_image is None:
+                    return f"참조 이미지({self.reference_image_path})를 로드할 수 없습니다.", None
+                
+                # 업로드된 이미지를 numpy 배열로 변환
+                if isinstance(uploaded_image, str):
+                    # 파일 경로인 경우
+                    user_image = cv2.imread(uploaded_image)
+                    if user_image is None:
+                        return "업로드된 이미지를 읽을 수 없습니다.", None
+                    user_image = cv2.cvtColor(user_image, cv2.COLOR_BGR2RGB)
+                else:
+                    # PIL Image인 경우
+                    user_image = np.array(uploaded_image)
+                    if user_image is None or user_image.size == 0:
+                        return "업로드된 이미지가 유효하지 않습니다.", None
+                
+                # 이미지 크기 확인
+                if user_image.shape[0] < 10 or user_image.shape[1] < 10:
+                    return "이미지가 너무 작습니다. 최소 10x10 픽셀 이상이어야 합니다.", None
+                
+                # 유사도 계산
+                similarity_scores = self.calculate_similarity(ref_image, user_image)
+
+                # 메모리 정리 (macOS 최적화)
+                del user_image
+                if 'ref_image' in locals():
+                    del ref_image
+                gc.collect()
+
+                # macOS에서 메모리 강제 정리
+                import platform
+                if platform.system() == 'Darwin':  # macOS
+                    import ctypes
+                    try:
+                        libc = ctypes.CDLL('libc.dylib')
+                        libc.malloc_trim(0)
+                    except:
+                        pass
+                
+                # 리더보드에 추가 (JSON 직렬화를 위해 float로 변환)
+                entry = {
+                    'username': username,
+                    'score': float(round(similarity_scores['final_score'], 2)),
+                    'date': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+                    'ssim': float(round(similarity_scores['ssim'], 4)),
+                    'psnr': float(round(similarity_scores['psnr'], 2)),
+                    'histogram': float(round(similarity_scores['histogram'], 4))
+                }
+                
+                # 같은 이름의 기존 기록이 있는지 확인하고, 더 높은 점수만 유지
+                existing_indices = [i for i, data in enumerate(self.leaderboard_data) if data['username'] == username]
+                
+                if existing_indices:
+                    # 기존 기록 중 가장 높은 점수 찾기
+                    existing_scores = [self.leaderboard_data[i]['score'] for i in existing_indices]
+                    max_existing_score = max(existing_scores)
+                    
+                    # 새 점수가 더 높으면 기존 기록들을 모두 제거하고 새 기록 추가
+                    if entry['score'] > max_existing_score:
+                        # 기존 기록들을 역순으로 제거 (인덱스 변경 방지)
+                        for i in sorted(existing_indices, reverse=True):
+                            del self.leaderboard_data[i]
+                        self.leaderboard_data.append(entry)
+                        self.save_leaderboard()
+                        
+                        # 갱신된 경우의 메시지
+                        result_message = f"""🎉 대단해요! 새로운 최고 기록입니다!
+
+👤 {username}님
+🏆 점수: {entry['score']:.0f}점
+📈 이전 최고: {max_existing_score:.0f}점
+
+✅ 리더보드에 등록되었습니다!
+📅 {entry['date']}"""
+                    else:
+                        # 새 점수가 더 낮거나 같으면 리더보드는 업데이트하지 않음
+                        result_message = f"""🎯 점수가 계산되었습니다!
+
+👤 {username}님
+🏆 현재 점수: {entry['score']:.0f}점
+📈 최고 점수: {max_existing_score:.0f}점
+
+💪 조금만 더 노력하면 최고 기록을 갱신할 수 있을 것 같아요!
+다시 시도해보세요!"""
+                else:
+                    # 기존 기록이 없으면 새로 추가
+                    self.leaderboard_data.append(entry)
+                    self.save_leaderboard()
+                    
+                    # 새로 등록된 경우의 메시지
+                    result_message = f"""🎉 첫 등록을 축하합니다!
+
+👤 {username}님
+🏆 점수: {entry['score']:.0f}점
+
+✅ 리더보드에 등록되었습니다!
+📅 {entry['date']}"""
+                
+                return result_message, self.get_leaderboard_df()
+                
+            except Exception as e:
+                import traceback
+                error_msg = f"오류가 발생했습니다: {str(e)}\n\n상세 정보:\n{traceback.format_exc()}"
+                return error_msg, None
+    
+    def get_leaderboard_df(self):
+        """리더보드를 DataFrame으로 반환합니다."""
+        if not self.leaderboard_data:
+            return pd.DataFrame(columns=['순위', '사용자명', '점수', '날짜'])
+        
+        # 점수 기준으로 정렬
+        sorted_data = sorted(self.leaderboard_data, key=lambda x: x['score'], reverse=True)
+        
+        # DataFrame 생성
+        df_data = []
+        for i, entry in enumerate(sorted_data, 1):
+            df_data.append({
+                '순위': i,
+                '사용자명': entry['username'],
+                '점수': entry['score'],
+                '날짜': entry['date']
+            })
+        
+        return pd.DataFrame(df_data)
+    
+    def authenticate_admin(self, password):
+        """관리자 인증"""
+        if password == self.admin_password:
+            self.admin_authenticated = True
+            return "✅ 관리자 인증이 완료되었습니다.", True
+        else:
+            self.admin_authenticated = False
+            return "❌ 잘못된 비밀번호입니다.", False
+    
+    def update_reference_image(self, new_image):
+        """참조 이미지 업데이트"""
+        if not self.admin_authenticated:
+            return "❌ 관리자 인증이 필요합니다."
+        
+        try:
+            if new_image is None:
+                return "❌ 이미지를 업로���해주세요."
+            
+            # 이미지를 저장
+            new_image.save(self.reference_image_path)
+            return f"✅ 참조 이미지가 업데이트되었습니다. ({self.reference_image_path})"
+        except Exception as e:
+            return f"❌ 이미지 저장 중 오류가 발생했습니다: {str(e)}"
+    
+    def clear_leaderboard(self):
+        """리더보드를 초기화합니다."""
+        if not self.admin_authenticated:
+            return "❌ 관리자 인증이 필요합니다.", self.get_leaderboard_df()
+        
+        self.leaderboard_data = []
+        self.save_leaderboard()
+        return "✅ 리더보드가 초기화되었습니다.", pd.DataFrame(columns=['순위', '사용자명', '점수', '날짜'])
+    
+
+# 전역 리더보드 인스턴스들 (4개 탭: 3개 반 + 연습)
+leaderboards = {
+    'respect': ImageSimilarityLeaderboard("label2.jpg", "respect.json"),
+    'challenge': ImageSimilarityLeaderboard("label2.jpg", "challenge.json"),
+    'originality': ImageSimilarityLeaderboard("label2.jpg", "originality.json"),
+    'practice': ImageSimilarityLeaderboard("label2.jpg", "practice.json")
+}
+
+def process_user_image_respect(image, username):
+    """Respect반 사용자 이미지 처리 함수"""
+    return leaderboards['respect'].process_image(image, username)
+
+def process_user_image_challenge(image, username):
+    """Challenge반 사용자 이미지 처리 함수"""
+    return leaderboards['challenge'].process_image(image, username)
+
+def process_user_image_originality(image, username):
+    """Originality반 사용자 이미지 처리 함수"""
+    return leaderboards['originality'].process_image(image, username)
+
+def get_current_leaderboard_respect():
+    """Respect반 현재 리더보드 반환"""
+    return leaderboards['respect'].get_leaderboard_df()
+
+def get_current_leaderboard_challenge():
+    """Challenge반 현재 리더보드 반환"""
+    return leaderboards['challenge'].get_leaderboard_df()
+
+def get_current_leaderboard_originality():
+    """Originality반 현재 리더보드 반환"""
+    return leaderboards['originality'].get_leaderboard_df()
+
+def check_and_update_leaderboard_respect():
+    """Respect반 리더보드 업데이트 확인 및 반환"""
+    leaderboards['respect'].check_for_updates()
+    return leaderboards['respect'].get_leaderboard_df()
+
+def check_and_update_leaderboard_challenge():
+    """Challenge반 리더보드 업데이트 확인 및 반환"""
+    leaderboards['challenge'].check_for_updates()
+    return leaderboards['challenge'].get_leaderboard_df()
+
+def check_and_update_leaderboard_originality():
+    """Originality반 리더보드 업데이트 확인 및 반환"""
+    leaderboards['originality'].check_for_updates()
+    return leaderboards['originality'].get_leaderboard_df()
+
+def process_user_image_practice(image, username):
+    """연습 탭 사용자 이미지 처리 함수"""
+    return leaderboards['practice'].process_image(image, username)
+
+def get_current_leaderboard_practice():
+    """연습 탭 현재 리더보드 반환"""
+    return leaderboards['practice'].get_leaderboard_df()
+
+def check_and_update_leaderboard_practice():
+    """연습 탭 리더보드 업데이트 확인 및 반환"""
+    leaderboards['practice'].check_for_updates()
+    return leaderboards['practice'].get_leaderboard_df()
+
+def create_interface():
+    """Gradio 인터페이스 생성"""
+    with gr.Blocks(title="비슷한 이미지를 만들어주세요!", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("""
+        # 🏆 참조 이미지와 얼마나 유사한지 측정하여 리더보드에 등록해보세요!
+        """)
+        
+        
+        # 탭 생성
+        with gr.Tabs():
+            # 연습 탭 (메인)
+            with gr.Tab("🎓 연습"):
+                gr.Markdown("### 💡 연습용 탭 (메인)")
+                gr.Markdown("업로드 및 이미지 유사도를 테스트해볼 수 있는 연습 공간입니다.")
+                gr.Markdown("---")
+
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📤 이미지 업로드 (연습)")
+                        image_input_practice = gr.Image(
+                            label="비교할 이미지를 업로드하세요",
+                            type="pil",
+                            height=300
+                        )
+                        username_input_practice = gr.Textbox(
+                            label="사용자 이름 (연습용)",
+                            placeholder="이름을 입력하세요",
+                            max_lines=1
+                        )
+                        submit_btn_practice = gr.Button("🚀 유사도 테스트", variant="primary", size="lg")
+
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📊 테스트 결과")
+                        result_output_practice = gr.Textbox(
+                            label="유사도 분��� 결과",
+                            lines=12,
+                            interactive=False
+                        )
+
+                        gr.Markdown("### 🏅 연습 리더보드")
+                        leaderboard_output_practice = gr.Dataframe(
+                            headers=["순위", "사용자명", "점수", "날짜"],
+                            datatype=["number", "str", "number", "str"],
+                            interactive=False
+                        )
+
+                # 연습 탭 이벤트 핸들러
+                submit_btn_practice.click(
+                    fn=process_user_image_practice,
+                    inputs=[image_input_practice, username_input_practice],
+                    outputs=[result_output_practice, leaderboard_output_practice]
+                )
+
+            # Respect반 탭
+            with gr.Tab("🎯 Respect반"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📤 이미지 업로드 (Respect반)")
+                        image_input_respect = gr.Image(
+                            label="비교할 이미지를 업로드하세요",
+                            type="pil",
+                            height=300
+                        )
+                        username_input_respect = gr.Textbox(
+                            label="사용자 이름",
+                            placeholder="이름을 입력하세요",
+                            max_lines=1
+                        )
+                        submit_btn_respect = gr.Button("🚀 점수 계산 및 등록", variant="primary", size="lg")
+
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📊 결과 (Respect반)")
+                        result_output_respect = gr.Textbox(
+                            label="계산 결과",
+                            lines=10,
+                            interactive=False
+                        )
+
+                        gr.Markdown("### 🏅 Respect반 리더보드")
+                        leaderboard_output_respect = gr.Dataframe(
+                            headers=["순위", "사용자명", "점수", "날짜"],
+                            datatype=["number", "str", "number", "str"],
+                            interactive=False
+                        )
+
+                # Respect반 이벤트 핸들러
+                submit_btn_respect.click(
+                    fn=process_user_image_respect,
+                    inputs=[image_input_respect, username_input_respect],
+                    outputs=[result_output_respect, leaderboard_output_respect]
+                )
+
+            # Challenge반 탭
+            with gr.Tab("⚡ Challenge반"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📤 이미지 업로드 (Challenge반)")
+                        image_input_challenge = gr.Image(
+                            label="비교할 이미지를 업로드하세요",
+                            type="pil",
+                            height=300
+                        )
+                        username_input_challenge = gr.Textbox(
+                            label="사용자 이름",
+                            placeholder="이름을 입력하세요",
+                            max_lines=1
+                        )
+                        submit_btn_challenge = gr.Button("🚀 점수 계산 및 등록", variant="primary", size="lg")
+
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📊 결과 (Challenge반)")
+                        result_output_challenge = gr.Textbox(
+                            label="계산 결과",
+                            lines=10,
+                            interactive=False
+                        )
+
+                        gr.Markdown("### 🏅 Challenge반 리더보드")
+                        leaderboard_output_challenge = gr.Dataframe(
+                            headers=["순위", "사용자명", "점수", "날짜"],
+                            datatype=["number", "str", "number", "str"],
+                            interactive=False
+                        )
+
+                # Challenge반 이벤트 핸들러
+                submit_btn_challenge.click(
+                    fn=process_user_image_challenge,
+                    inputs=[image_input_challenge, username_input_challenge],
+                    outputs=[result_output_challenge, leaderboard_output_challenge]
+                )
+
+            # Originality반 탭
+            with gr.Tab("🎨 Originality반"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📤 이미지 업로드 (Originality반)")
+                        image_input_originality = gr.Image(
+                            label="비교할 이미지를 업로드하세요",
+                            type="pil",
+                            height=300
+                        )
+                        username_input_originality = gr.Textbox(
+                            label="사용자 이름",
+                            placeholder="이름을 입력하세요",
+                            max_lines=1
+                        )
+                        submit_btn_originality = gr.Button("🚀 점수 계산 및 등록", variant="primary", size="lg")
+
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📊 결과 (Originality반)")
+                        result_output_originality = gr.Textbox(
+                            label="계산 결과",
+                            lines=10,
+                            interactive=False
+                        )
+
+                        gr.Markdown("### 🏅 Originality반 리더보드")
+                        leaderboard_output_originality = gr.Dataframe(
+                            headers=["순위", "사용자명", "점수", "날짜"],
+                            datatype=["number", "str", "number", "str"],
+                            interactive=False
+                        )
+
+                # Originality반 이벤트 핸들러
+                submit_btn_originality.click(
+                    fn=process_user_image_originality,
+                    inputs=[image_input_originality, username_input_originality],
+                    outputs=[result_output_originality, leaderboard_output_originality]
+                ) 
+        
+        # 페이지 로드 시 모든 리더보드 표시
+        demo.load(
+            fn=lambda: (get_current_leaderboard_practice(), get_current_leaderboard_respect(), get_current_leaderboard_challenge(), get_current_leaderboard_originality()),
+            outputs=[leaderboard_output_practice, leaderboard_output_respect, leaderboard_output_challenge, leaderboard_output_originality]
+        )
+
+        # 실시간 업데이트 (10초마다 - 모든 탭 업데이트)
+        timer = gr.Timer(value=10)
+        timer.tick(
+            fn=lambda: (check_and_update_leaderboard_practice(), check_and_update_leaderboard_respect(), check_and_update_leaderboard_challenge(), check_and_update_leaderboard_originality()),
+            outputs=[leaderboard_output_practice, leaderboard_output_respect, leaderboard_output_challenge, leaderboard_output_originality]
+        )
+    
+    return demo
+
+def main():
+    """메인 함수"""
+    print("🏆 이미지 유사도 리더보드 시스템을 시작합니다...")
+    print("📁 참조 이미지: label2.jpg")
+    print("💾 데이터 파일:")
+    print("   • Respect반: respect.json")
+    print("   • Challenge반: challenge.json")
+    print("   • Originality반: originality.json")
+    print("   • 연습: practice.json")
+
+    # 각 반별 메모리 사용량 체크
+    for class_name, lb in leaderboards.items():
+        initial_memory = lb._get_memory_usage()
+        print(f"💾 {class_name} 초기 메모리 사용량: {initial_memory:.1f}MB")
+
+    if not os.path.exists("label2.jpg"):
+        print("⚠️  경고: 참조 이미지(label2.jpg)를 찾을 수 없습니다!")
+        print("   label2.jpg 파일을 프로젝트 루트에 배치해주세요.")
+    
+    # Gradio 인터페이스 생성 및 실행
+    demo = create_interface()
+    print("🚀 서버를 시작합니다...")
+    print("📊 최적화 사항:")
+    print("   • 참조 이미지 캐싱 활성화")
+    print("   • 이미지 크기 제한: 512x512")
+    print("   • 동시성 제어 활성화")
+    print("   • 메모리 정리 자동화")
+    print("   • 실시간 업데이트: 10초 간격")
+    print("   • 4개 탭별 독립 리더보드 운영 (3개 반 + 연습)")
+    
+    # 외부 공유 우선 시도
+    print("\n🌐 외부 접근 시도 중...")
+    try:
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=9900,
+            share=True,
+            show_error=False,  # 에러 표시 최소화
+            quiet=False  # 로그 표시 (공유 링크 확인용)
+        )
+    except Exception as e:
+        print(f"❌ 외부 공유 실패: {e}")
+        print("🔄 로컬 네트워크 모드로 전환...")
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=9900,
+            share=False,
+            show_error=True,
+            quiet=False
+        )
+
+if __name__ == "__main__":
+    main()

practice.json

@@ -0,0 +1,10 @@
+[
+  {
+    "username": "0조",
+    "score": 2.33,
+    "date": "2025-09-08 14:31:16",
+    "ssim": 0.0292,
+    "psnr": 2.91,
+    "histogram": 0.0
+  }
+]

pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "temp"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "gradio>=4.0.0",
+    "opencv-python-headless>=4.8.0",
+    "numpy>=1.24.0",
+    "Pillow>=10.0.0",
+    "scikit-image>=0.21.0",
+    "pandas>=2.0.0",
+    "pyngrok>=7.3.0",
+]

requirements.txt

@@ -0,0 +1,63 @@
+aiofiles==24.1.0
+annotated-types==0.7.0
+anyio==4.10.0
+brotli==1.1.0
+certifi==2025.8.3
+charset-normalizer==3.4.3
+click==8.2.1
+fastapi==0.116.1
+ffmpy==0.6.1
+filelock==3.19.1
+fsspec==2025.9.0
+gradio==5.44.1
+gradio-client==1.12.1
+groovy==0.1.2
+h11==0.16.0
+hf-xet==1.1.9
+httpcore==1.0.9
+httpx==0.28.1
+huggingface-hub==0.34.4
+idna==3.10
+imageio==2.37.0
+jinja2==3.1.6
+lazy-loader==0.4
+markdown-it-py==4.0.0
+markupsafe==3.0.2
+mdurl==0.1.2
+networkx==3.5
+numpy==2.3.2
+opencv-python-headless==4.11.0.86
+orjson==3.11.3
+packaging==25.0
+pandas==2.3.2
+pillow==11.3.0
+pydantic==2.11.7
+pydantic-core==2.33.2
+pydub==0.25.1
+pygments==2.19.2
+pyngrok==7.3.0
+python-dateutil==2.9.0.post0
+python-multipart==0.0.20
+pytz==2025.2
+pyyaml==6.0.2
+requests==2.32.5
+rich==14.1.0
+ruff==0.12.12
+safehttpx==0.1.6
+scikit-image==0.25.2
+scipy==1.16.1
+semantic-version==2.10.0
+shellingham==1.5.4
+six==1.17.0
+sniffio==1.3.1
+starlette==0.47.3
+tifffile==2025.8.28
+tomlkit==0.13.3
+tqdm==4.67.1
+typer==0.17.4
+typing-extensions==4.15.0
+typing-inspection==0.4.1
+tzdata==2025.2
+urllib3==2.5.0
+uvicorn==0.35.0
+websockets==15.0.1