add rr

app.py

@@ -1,274 +1,256 @@
 import gradio as gr
+import cv2
 from ultralytics import YOLO
 import numpy as np
-import pandas as pd
-import matplotlib.pyplot as plt
-from PIL import Image
-import cv2
-import threading
 import time
 
-# 체스 기물별 유니코드 심볼 및 색상 정의
-CHESS_PIECES = {
-    'w_king': {'symbol': '♔', 'color': '#FFFFFF', 'edge': '#000000'},
-    'w_queen': {'symbol': '♕', 'color': '#FFFFFF', 'edge': '#000000'},
-    'w_rook': {'symbol': '♖', 'color': '#FFFFFF', 'edge': '#000000'},
-    'w_bishop': {'symbol': '♗', 'color': '#FFFFFF', 'edge': '#000000'},
-    'w_knight': {'symbol': '♘', 'color': '#FFFFFF', 'edge': '#000000'},
-    'w_pawn': {'symbol': '♙', 'color': '#FFFFFF', 'edge': '#000000'},
-    'b_king': {'symbol': '♚', 'color': '#000000', 'edge': '#FFFFFF'},
-    'b_queen': {'symbol': '♛', 'color': '#000000', 'edge': '#FFFFFF'},
-    'b_rook': {'symbol': '♜', 'color': '#000000', 'edge': '#FFFFFF'},
-    'b_bishop': {'symbol': '♝', 'color': '#000000', 'edge': '#FFFFFF'},
-    'b_knight': {'symbol': '♞', 'color': '#000000', 'edge': '#FFFFFF'},
-    'b_pawn': {'symbol': '♟', 'color': '#000000', 'edge': '#FFFFFF'}
-}
+# YOLOv8 모델 로드 (최초 실행 시 자동 다운로드)
+model = YOLO("yolov8n.pt")  # 가장 가벼운 모델, 더 정확한 모델은 yolov8s.pt 등 사용 가능
 
-# 전역 변수
-current_model = None
-cap = None
-streaming = False
-stream_thread = None
+# 전역 변수로 FPS 계산용
+frame_count = 0
+start_time = time.time()
 
-# YOLOv8 추론 함수 (정적 이미지용)
-def predict_chess(img, model_weight_file, conf, iou):
-    global current_model
+def object_detection(image, conf_threshold=0.25, iou_threshold=0.45, show_labels=True, show_conf=True):
+    global frame_count, start_time
     
-    # 모델 로드
-    weight_path = model_weight_file.name if model_weight_file is not None else 'yolov8n.pt'
-    model = YOLO(weight_path)
-    current_model = model
+    if image is None:
+        return None
     
-    results = model.predict(img, conf=conf, iou=iou, show_labels=True, show_conf=True)
-    boxes = results[0].boxes
-    names = results[0].names
-    dets = []
-    for box in boxes:
-        cls = int(box.cls[0])
-        name = names[cls]
-        dets.append({
-            'name': name,
-            'conf': float(box.conf[0]),
-            'xmin': float(box.xyxy[0][0]),
-            'ymin': float(box.xyxy[0][1]),
-            'xmax': float(box.xyxy[0][2]),
-            'ymax': float(box.xyxy[0][3])
-        })
-    df = pd.DataFrame(dets)
-    im_array = results[0].plot()
-    im = Image.fromarray(im_array[..., ::-1])
-    return im, df
-
-# 웹캠 스트림 시작 함수
-def start_webcam_stream(model_weight_file, conf, iou):
-    global current_model, cap, streaming, stream_thread
+    # Gradio에서 이미지는 RGB, OpenCV는 BGR이므로 변환
+    img_bgr = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
     
-    # 모델 로드
-    if model_weight_file is not None:
-        weight_path = model_weight_file.name
-        current_model = YOLO(weight_path)
-    elif current_model is None:
-        current_model = YOLO('yolov8n.pt')
+    # YOLO 추론 실행
+    results = model(img_bgr, conf=conf_threshold, iou=iou_threshold)
     
-    # 웹캠 초기화
-    if cap is None:
-        cap = cv2.VideoCapture(0)
-        if not cap.isOpened():
-            return None, "웹캠을 열 수 없습니다."
+    # 바운딩 박스 등 시각화된 이미지(BGR)
+    annotated = results[0].plot(
+        show_labels=show_labels,
+        show_conf=show_conf,
+        line_width=2,
+        font_size=1
+    )
     
-    streaming = True
+    # FPS 계산 및 표시
+    frame_count += 1
+    current_time = time.time()
+    if current_time - start_time > 1.0:  # 1초마다 FPS 업데이트
+        fps = frame_count / (current_time - start_time)
+        frame_count = 0
+        start_time = current_time
+        
+        # FPS를 이미지에 표시
+        cv2.putText(annotated, f'FPS: {fps:.1f}', (10, 30), 
+                   cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
     
-    def stream_generator():
-        while streaming and cap is not None and cap.isOpened():
-            ret, frame = cap.read()
-            if not ret:
-                break
-            
-            # YOLO 추론
-            results = current_model.predict(frame, conf=conf, iou=iou, show_labels=True, show_conf=True)
-            annotated_frame = results[0].plot()
+    # BGR을 RGB로 변환하여 반환
+    annotated_rgb = cv2.cvtColor(annotated, cv2.COLOR_BGR2RGB)
+    return annotated_rgb
+
+def reset_fps():
+    global frame_count, start_time
+    frame_count = 0
+    start_time = time.time()
+
+# Gradio 인터페이스 구성
+with gr.Blocks(title="실시간 YOLO 객체 탐지") as demo:
+    gr.Markdown("""
+    # 🚀 실시간 YOLO 객체 탐지
+    웹캠을 통해 실시간으로 객체를 탐지합니다. 다양한 설정을 조정하여 탐지 성능을 최적화할 수 있습니다.
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            webcam_input = gr.Image(
+                label='📹 웹캠 입력', 
+                sources="webcam", 
+                streaming=True, 
+                width=640, 
+                height=480
+            )
             
-            # BGR을 RGB로 변환
-            annotated_frame = cv2.cvtColor(annotated_frame, cv2.COLOR_BGR2RGB)
-            pil_image = Image.fromarray(annotated_frame)
+            # 설정 패널
+            with gr.Group():
+                gr.Markdown("### ⚙️ 탐지 설정")
+                conf_slider = gr.Slider(
+                    minimum=0.1, 
+                    maximum=1.0, 
+                    value=0.25, 
+                    step=0.05,
+                    label="신뢰도 임계값 (Confidence Threshold)"
+                )
+                iou_slider = gr.Slider(
+                    minimum=0.1, 
+                    maximum=1.0, 
+                    value=0.45, 
+                    step=0.05,
+                    label="IoU 임계값 (Non-Max Suppression)"
+                )
+                
+                with gr.Row():
+                    show_labels_cb = gr.Checkbox(label="라벨 표시", value=True)
+                    show_conf_cb = gr.Checkbox(label="신뢰도 표시", value=True)
+                
+                reset_btn = gr.Button("FPS 리셋", variant="secondary")
             
-            yield pil_image
+        with gr.Column():
+            webcam_output = gr.Image(
+                label='🎯 객체 탐지 결과',
+                width=640,
+                height=480
+            )
             
-            time.sleep(0.05)  # 약 20 FPS
+            # 정보 패널
+            with gr.Group():
+                gr.Markdown("""
+                ### 📊 탐지 정보
+                - **신뢰도 임계값**: 낮을수록 더 많은 객체 탐지 (false positive 증가)
+                - **IoU 임계값**: 중복 탐지 제거 기준
+                - **FPS**: 초당 프레임 처리 속도
+                
+                ### 🎮 사용 방법
+                1. 웹캠 접근 권한 허용
+                2. 설정값 조정으로 탐지 성능 최적화
+                3. 실시간으로 객체 탐지 결과 확인
+                """)
     
-    return stream_generator(), "웹캠 스트림이 시작되었습니다."
-
-# 웹캠 스트림 중지 함수
-def stop_webcam_stream():
-    global cap, streaming
-    streaming = False
-    if cap is not None:
-        cap.release()
-        cap = None
-    return None, "웹캠 스트림이 중지되었습니다."
+    # 스트리밍 이벤트 연결
+    webcam_input.stream(
+        fn=object_detection,
+        inputs=[webcam_input, conf_slider, iou_slider, show_labels_cb, show_conf_cb],
+        outputs=[webcam_output],
+        stream_every=0.1  # 100ms마다 처리 (약 10 FPS)
+    )
+    
+    # FPS 리셋 버튼 이벤트
+    reset_btn.click(fn=reset_fps, inputs=[], outputs=[])
 
-# 실시간 웹캠 처리 함수 (Generator 방식)
-def webcam_stream_generator(model_weight_file, conf, iou):
-    global current_model, cap, streaming
+# 다양한 모델 옵션을 제공하는 고급 버전
+with gr.Blocks(title="고급 YOLO 객체 탐지") as advanced_demo:
+    gr.Markdown("""
+    # 🔬 고급 YOLO 객체 탐지
+    다양한 YOLO 모델을 선택하고 고급 설정을 조정할 수 있습니다.
+    """)
     
-    # 모델 로드
-    if model_weight_file is not None:
-        weight_path = model_weight_file.name
-        current_model = YOLO(weight_path)
-    elif current_model is None:
-        current_model = YOLO('yolov8n.pt')
+    # 모델 선택
+    model_choice = gr.Dropdown(
+        choices=["yolov8n.pt", "yolov8s.pt", "yolov8m.pt", "yolov8l.pt", "yolov8x.pt"],
+        value="yolov8n.pt",
+        label="YOLO 모델 선택",
+        info="n < s < m < l < x (속도 vs 정확도)"
+    )
     
-    # 웹캠 초기화
-    if cap is None:
-        cap = cv2.VideoCapture(0)
-        if not cap.isOpened():
-            yield None
-            return
+    current_model = model  # 현재 모델 저장
     
-    streaming = True
+    def change_model(model_name):
+        global current_model
+        current_model = YOLO(model_name)
+        return f"모델이 {model_name}으로 변경되었습니다."
     
-    while streaming:
-        ret, frame = cap.read()
-        if not ret:
-            break
+    def advanced_object_detection(image, model_name, conf_threshold, iou_threshold, show_labels, show_conf):
+        global current_model, frame_count, start_time
         
-        # YOLO 추론
-        results = current_model.predict(frame, conf=conf, iou=iou, show_labels=True, show_conf=True)
-        annotated_frame = results[0].plot()
+        if image is None:
+            return None
         
-        # BGR을 RGB로 변환
-        annotated_frame = cv2.cvtColor(annotated_frame, cv2.COLOR_BGR2RGB)
-        pil_image = Image.fromarray(annotated_frame)
+        # 모델 변경 확인
+        if current_model.model_name != model_name:
+            current_model = YOLO(model_name)
         
-        yield pil_image
+        img_bgr = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+        results = current_model(img_bgr, conf=conf_threshold, iou=iou_threshold)
         
-        time.sleep(0.05)  # 약 20 FPS
-
-# 기물별 개수 시각화
-def plot_piece_count(df):
-    if df.empty:
-        fig, ax = plt.subplots()
-        ax.text(0.5, 0.5, 'No pieces detected', ha='center', va='center')
-        ax.axis('off')
-        return fig
-    counts = df['name'].value_counts().sort_index()
-    labels = counts.index.tolist()
-    colors = [CHESS_PIECES.get(n, {'color': '#888'})['color'] for n in counts.index]
-    edges = [CHESS_PIECES.get(n, {'edge': '#888'})['edge'] for n in counts.index]
-    fig, ax = plt.subplots(figsize=(8,4))
-    bars = ax.bar(labels, counts.values, color=colors, edgecolor=edges, linewidth=2)
-    for i, v in enumerate(counts.values):
-        text_color = '#000000' if colors[i] == '#FFFFFF' else '#FFFFFF'
-        ax.text(i, v-0.1, str(v), ha='center', va='top', fontsize=16, color=text_color, fontweight='bold')
-    ax.set_title('Detected Chess Pieces (by symbol)')
-    ax.set_ylabel('Count')
-    ax.set_xticklabels(labels, fontsize=8, rotation=30)
-    return fig
-
-# 체스판 plot (기물 위치 시각화)
-def plot_chessboard(df, img_shape):
-    fig, ax = plt.subplots(figsize=(6,6))
-    # 체스판 그리드
-    for i in range(9):
-        ax.plot([0,8],[i,i], color='k', lw=1)
-        ax.plot([i,i],[0,8], color='k', lw=1)
-    # 기물 표시
-    if not df.empty:
-        for _, row in df.iterrows():
-            x = ((row['xmin']+row['xmax'])/2) / img_shape[1] * 8
-            y = ((row['ymin']+row['ymax'])/2) / img_shape[0] * 8
-            piece = CHESS_PIECES.get(row['name'], {'symbol': row['name'], 'color': '#888'})
-            ax.text(x, 8-y, piece['symbol'], fontsize=28, ha='center', va='center', color=piece['color'], fontweight='bold')
-    ax.set_xlim(0,8)
-    ax.set_ylim(0,8)
-    ax.set_xticks(range(9))
-    ax.set_yticks(range(9))
-    ax.set_xticklabels([])
-    ax.set_yticklabels([])
-    ax.set_title('Chessboard Piece Placement')
-    ax.set_aspect('equal')
-    return fig
-
-# Gradio 앱 함수 (정적 이미지용)
-def gradio_chess(img, model_weight_file, conf, iou):
-    im, df = predict_chess(img, model_weight_file, conf, iou)
-    piece_fig = plot_piece_count(df)
-    board_fig = plot_chessboard(df, np.array(img).shape)
-    return im, piece_fig, board_fig
-
-# Gradio 인터페이스
-with gr.Blocks() as demo:
-    gr.Markdown("""
-    # ♟️ YOLOv8 Chess Piece Detection
-    이미지 업로드 또는 실시간 웹캠 스트림으로 체스 기물 탐지 및 분석 결과를 보여줍니다.
-    """)
-    
-    with gr.Tab("이미지 분석"):
-        with gr.Row():
-            with gr.Column():
-                img_in = gr.Image(type="pil", label="체스판 이미지 업로드")
-                model_in = gr.File(label="YOLOv8 모델 가중치 파일 업로드 (.pt, 선택)", file_types=[".pt"])
-                conf_in = gr.Slider(0,1,step=0.01,value=0.25,label="Confidence Threshold")
-                iou_in = gr.Slider(0,1,step=0.01,value=0.45,label="IoU Threshold")
-                btn = gr.Button("분석 실행")
-            with gr.Column():
-                img_out = gr.Image(label="탐지 결과 이미지")
-                piece_out = gr.Plot(label="기물별 개수 시각화")
+        annotated = results[0].plot(
+            show_labels=show_labels,
+            show_conf=show_conf,
+            line_width=2,
+            font_size=1
+        )
         
-        btn.click(fn=gradio_chess, inputs=[img_in, model_in, conf_in, iou_in], outputs=[img_out, piece_out])
+        # FPS 계산
+        frame_count += 1
+        current_time = time.time()
+        if current_time - start_time > 1.0:
+            fps = frame_count / (current_time - start_time)
+            frame_count = 0
+            start_time = current_time
+            
+            cv2.putText(annotated, f'FPS: {fps:.1f} | Model: {model_name}', 
+                       (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
         
-        gr.Examples(
-            examples=["./sample_object/one_object.jpg", "./sample_object/many_object.jpg"],
-            inputs=[img_in]
-        )
+        annotated_rgb = cv2.cvtColor(annotated, cv2.COLOR_BGR2RGB)
+        return annotated_rgb
     
-    with gr.Tab("실시간 웹캠 스트림"):
-        with gr.Row():
-            with gr.Column():
-                # 모델 및 파라미터 설정
-                model_webcam = gr.File(label="YOLOv8 모델 가중치 파일 업로드 (.pt, 선택)", file_types=[".pt"])
-                conf_webcam = gr.Slider(0,1,step=0.01,value=0.25,label="Confidence Threshold")
-                iou_webcam = gr.Slider(0,1,step=0.01,value=0.45,label="IoU Threshold")
-                
-                # 제어 버튼
-                start_btn = gr.Button("웹캠 스트림 시작", variant="primary")
-                stop_btn = gr.Button("웹캠 스트림 중���", variant="secondary")
+    with gr.Row():
+        with gr.Column():
+            adv_webcam_input = gr.Image(
+                label='📹 웹캠 입력', 
+                sources="webcam", 
+                streaming=True, 
+                width=640, 
+                height=480
+            )
+            
+            with gr.Group():
+                gr.Markdown("### 🎛️ 고급 설정")
+                adv_conf_slider = gr.Slider(0.1, 1.0, 0.25, 0.05, label="신뢰도 임계값")
+                adv_iou_slider = gr.Slider(0.1, 1.0, 0.45, 0.05, label="IoU 임계값")
                 
-                # 상태 표시
-                status_text = gr.Textbox(label="상태", value="웹캠 스트림을 시작하려면 '웹캠 스트림 시작' 버튼을 클릭하세요", interactive=False)
+                with gr.Row():
+                    adv_show_labels_cb = gr.Checkbox(label="라벨 표시", value=True)
+                    adv_show_conf_cb = gr.Checkbox(label="신뢰도 표시", value=True)
                 
-            with gr.Column():
-                webcam_output = gr.Image(label="실시간 탐지 결과", streaming=True)
-        
-        # 웹캠 스트림 시작 버튼 이벤트
-        start_btn.click(
-            fn=lambda mw, conf, iou: webcam_stream_generator(mw, conf, iou),
-            inputs=[model_webcam, conf_webcam, iou_webcam],
-            outputs=[webcam_output]
-        )
-        
-        # 웹캠 스트림 중지 버튼 이벤트
-        stop_btn.click(
-            fn=stop_webcam_stream,
-            inputs=[],
-            outputs=[webcam_output, status_text]
-        )
-
-# 앱 종료 시 웹캠 정리
-def cleanup():
-    global cap, streaming
-    streaming = False
-    if cap is not None:
-        cap.release()
+                change_model_btn = gr.Button("모델 변경", variant="primary")
+                model_status = gr.Textbox(label="모델 상태", interactive=False)
+            
+        with gr.Column():
+            adv_webcam_output = gr.Image(
+                label='🎯 객체 탐지 결과',
+                width=640,
+                height=480
+            )
+    
+    # 이벤트 연결
+    adv_webcam_input.stream(
+        fn=advanced_object_detection,
+        inputs=[adv_webcam_input, model_choice, adv_conf_slider, adv_iou_slider, 
+                adv_show_labels_cb, adv_show_conf_cb],
+        outputs=[adv_webcam_output],
+        stream_every=0.1
+    )
+    
+    change_model_btn.click(
+        fn=change_model,
+        inputs=[model_choice],
+        outputs=[model_status]
+    )
 
-import atexit
-atexit.register(cleanup)
+# 탭으로 구성된 최종 인터페이스
+with gr.Blocks(title="YOLO 웹캠 객체 탐지") as final_demo:
+    gr.Markdown("""
+    # 🎯 YOLO 웹캠 객체 탐지
+    실시간 웹캠 스트림에서 객체를 탐지합니다.
+    """)
+    
+    with gr.Tabs():
+        with gr.TabItem("🚀 기본 모드"):
+            demo.render()
+        
+        with gr.TabItem("🔬 고급 모드"):
+            advanced_demo.render()
 
 if __name__ == "__main__":
-    demo.launch(share=True, server_name='0.0.0.0', server_port=7860, debug=True)
+    # 기본 모드로 실행
+    demo.launch(
+        share=True,
+        server_name="0.0.0.0",
+        server_port=7860,
+        debug=False
+    )
+    
+    # 고급 모드로 실행하려면 다음 줄의 주석을 해제하세요:
+    # final_demo.launch(share=True, server_name="0.0.0.0", server_port=7860)
 
 # 실행 방법:
-# 1. 필요한 라이브러리 설치:
-#    pip install gradio ultralytics opencv-python matplotlib pandas pillow
-# 2. 파일을 app.py로 저장하고 실행:
-#    python app.py
+# pip install gradio ultralytics opencv-python
+# python app.py