Add PDF upload and YOLO routing for Spaces

README.md

@@ -1,10 +1,11 @@
 ---
-title: DEIMv2 Floorplan Symbol Detection
+title: PDF/PNG Floorplan Symbol Detection
 emoji: 🏗️
 colorFrom: blue
 colorTo: green
 sdk: gradio
-sdk_version: 5.0.0
+sdk_version: 5.49.1
+python_version: 3.12.12
 app_file: app.py
 pinned: false
 license: AItech
@@ -14,36 +15,39 @@ DEMO URL
 https://huggingface.co/spaces/himipo/gpu_symbol
 
 
-# DEIMv2 図面記号検出デモ
+# PDF/PNG 図面記号検出デモ
 
-DEIMv2 (Detection Enhanced by Interaction Module v2) を使用した図面記号検出デモアプリケーションです。
+DEIMv2 と YOLO26L を自動ルーティングして使用する図面記号検出デモアプリケーションです。
 
 ## 機能
 
-- PNG形式の図面画像からの記号検出（16クラス対応）
-- タイル推論による大サイズ画像の処理（640×640タイル、128pxオーバーラップ）
+- PDF/PNG形式の図面からの記号検出（PDFは1ページ目のみ400dpiで変換）
+- 選択クラスに応じたDEIMv2 / YOLO26Lの自動ルーティング
+- タイル推論による大サイズ画像の処理
 - 検出結果の可視化（バウンディングボックス + ラベル + スコア）
 - 記号ごとの個数集計表示
 - スコア閾値の調整（デフォルト: 0.9）
-- クラスフィルタリング機能（検出するクラスを選択可能）
+- クラスフィルタリング機能（対象クラスを選択可能）
 - NMS（Non-Maximum Suppression）による重複検出の自動マージ
 
 ## 使用方法
 
-1. 左側に **PNG形式の図面** をアップロード
+1. 左側に **PDFまたはPNG形式の図面** をアップロード
+   - PDFの場合は1ページ目のみを400dpiで変換して推論します
 2. **詳細設定**を開いて以下を調整（必要に応じて）:
    - **スコア閾値**: 検出の信頼度閾値（デフォルト: 0.9）
-   - **検出するクラス**: チェックボックスで検出したいクラスを選択（デフォルト: door1のみ）
+   - **対象クラス**: チェックボックスで検出したいクラスを選択（デフォルト: door1のみ）
 3. 「検出を実行」ボタンをクリック
 4. 中央に **検出結果付き図面**、右側に **記号名称と個数** が表示されます
 
 ## モデル
 
 - **DEIMv2**: DINOv3STAsバックボーン（ViT-Tiny）を使用した物体検出モデル
-- **検出対象**: 16クラスの図面記号
+- **YOLO26L**: 窓・ドア・サッシ系クラスを担当する物体検出モデル
+- **検出対象**: DEIMv2既存クラス + YOLO26L追加クラス
   - `kanki`, `kanki_shikaku`, `kanki_regisuta`
-  - `window1`, `window2`
-  - `door1`, `door2`
+  - `window1`, `window2`, `window3`, `window4`, `window_hiki`, `window_hiki2`
+  - `door1`, `door2`, `sash_circle`, `sash_rect`
   - `bathtub1`, `konro1`, `sink1`, `toilet1`
   - `kasaikeihou1`, `kasaikeihou2`
   - `houi1`, `houi2`, `houi3`
@@ -58,9 +62,10 @@ DEIMv2 (Detection Enhanced by Interaction Module v2) を使用した図面記号
 ## ファイル構成
 
 - `app.py`: Gradio UI + 推論パイプライン
-- `detection.py`: DEIMv2推論ラッパー（タイル推論、NMS統合）
+- `detection.py`: DEIMv2 / YOLO26L推論ルータ（タイル推論、NMS統合）
 - `configs/deimv2_floorplan.yaml`: モデル設定ファイル
 - `models/best_stg2.pth`: モデル重みファイル（Git LFS）
+- `models/yolobest.pt`: YOLO26Lモデル重みファイル（Git LFS）
 - `engine/`: DEIMv2エンジンモジュール
   - `core/`: YAMLConfig関連モジュール
     - `yaml_config.py`: YAMLConfigクラス
@@ -77,7 +82,7 @@ DEIMv2 (Detection Enhanced by Interaction Module v2) を使用した図面記号
 ## 技術詳細
 
 ### タイル推論
-大きな画像を640×640ピクセルのタイルに分割して推論します。タイル間は128ピクセルのオーバーラップを持ち、境界付近の記号も確実に検出できます。
+大きな画像をタイルに分割して推論します。DEIMv2は640×640、YOLO26Lは960×960を基本タイルとして使用し、境界付近の記号も検出できるようにオーバーラップを持たせます。
 
 ### NMS（Non-Maximum Suppression）
 タイル推論により生じる重複検出を、クラスごとにIoU閾値0.4でNMSを適用して統合します。
@@ -94,6 +99,6 @@ DEIMv2 (Detection Enhanced by Interaction Module v2) を使用した図面記号
 
 - **モデルファイルが見つからない**: Git LFSが正しく設定されているか確認してください
 - **メモリ不足**: CPU UpgradeまたはGPUオプションの使用を検討してください
-- **推論エラー**: 画像形式がPNG形式であることを確認してください
+- **推論エラー**: 入力がPDFまたはPNG形式であることを確認してください
 - **検出結果が表示されない**: スコア閾値を下げる（例: 0.5）か、検出するクラスをすべて選択してください
 - **デバッグモード**: 環境変数 `DEBUG_DEIMV2=1` を設定すると、詳細��デバッグ情報が出力されます

app.py

@@ -1,10 +1,17 @@
 # app.py
 from collections import Counter
 from functools import lru_cache
-from typing import Tuple, Dict, Any, List
+import math
+from pathlib import Path
+from typing import Tuple, Any, List
 import os
+import warnings
 import yaml
 
+os.environ.setdefault("MPLCONFIGDIR", "/tmp/matplotlib")
+os.environ.setdefault("YOLO_CONFIG_DIR", "/tmp/ultralytics")
+os.makedirs(os.environ["YOLO_CONFIG_DIR"], exist_ok=True)
+
 import gradio as gr
 import numpy as np
 import spaces
@@ -12,31 +19,23 @@ from PIL import Image, ImageDraw, ImageFont
 
 from detection import run_inference, Detection
 
-# Gradio 5.0.x と JSON コンポーネントの組み合わせで
-# /info 生成時に json_schema_to_python_type が bool を dict とみなして落ちる
-# 既知バグがあるため、bool を安全に処理するようにパッチを当てる。
-try:
-    from gradio_client import utils as grc_utils
-
-    _orig_json_schema_to_python_type = grc_utils._json_schema_to_python_type  # type: ignore[attr-defined]
-    _orig_json_schema_to_python_type_public = grc_utils.json_schema_to_python_type
-
-    def _json_schema_to_python_type_safe(schema, defs=None):  # type: ignore[override]
-        if isinstance(schema, bool):
-            return "Any"
-        return _orig_json_schema_to_python_type(schema, defs)
-
-    grc_utils._json_schema_to_python_type = _json_schema_to_python_type_safe  # type: ignore[attr-defined]
-
-    def _json_schema_to_python_type_safe_public(schema):
-        if isinstance(schema, bool):
-            return "Any"
-        return _orig_json_schema_to_python_type_public(schema)
-
-    grc_utils.json_schema_to_python_type = _json_schema_to_python_type_safe_public
-except Exception:
-    # パッチが失敗してもアプリ起動は継続する
-    pass
+PDF_DPI = 400
+MAX_RENDERED_PIXELS = int(os.getenv("MAX_RENDERED_PIXELS", "120000000"))
+SUPPORTED_IMAGE_SUFFIXES = {".png", ".jpg", ".jpeg", ".tif", ".tiff", ".bmp", ".webp"}
+Image.MAX_IMAGE_PIXELS = MAX_RENDERED_PIXELS
+warnings.simplefilter("error", Image.DecompressionBombWarning)
+YOLO_CLASS_NAMES = [
+    "window1",
+    "window2",
+    "window3",
+    "window4",
+    "window_hiki",
+    "window_hiki2",
+    "door1",
+    "door2",
+    "sash_circle",
+    "sash_rect",
+]
 
 
 @lru_cache(maxsize=1)
@@ -44,30 +43,147 @@ def load_class_names() -> List[str]:
     """
     設定ファイルからクラスリストを読み込む
     """
+    default_class_names = ["kanki", "kanki_shikaku", "kanki_regisuta", "window1", "window2", 
+                           "door1", "door2", "bathtub1", "konro1", "sink1", "toilet1", 
+                           "kasaikeihou1", "kasaikeihou2", "houi1", "houi2", "houi3"]
     config_path = "configs/deimv2_floorplan.yaml"
     try:
         with open(config_path, 'r', encoding='utf-8') as f:
             config = yaml.safe_load(f)
             # Modelセクションからclass_namesを取得
             if 'Model' in config and 'class_names' in config['Model']:
-                return config['Model']['class_names']
+                class_names = config['Model']['class_names']
             else:
                 # フォールバック: デフォルトのクラスリスト
-                return ["kanki", "kanki_shikaku", "kanki_regisuta", "window1", "window2", 
-                        "door1", "door2", "bathtub1", "konro1", "sink1", "toilet1", 
-                        "kasaikeihou1", "kasaikeihou2", "houi1", "houi2", "houi3"]
+                class_names = default_class_names
     except Exception as e:
         # エラー時はデフォルトのクラスリストを返す
         print(f"Warning: Failed to load class names from config: {e}")
-        return ["kanki", "kanki_shikaku", "kanki_regisuta", "window1", "window2", 
-                "door1", "door2", "bathtub1", "konro1", "sink1", "toilet1", 
-                "kasaikeihou1", "kasaikeihou2", "houi1", "houi2", "houi3"]
+        class_names = default_class_names
+
+    merged = list(class_names)
+    for class_name in YOLO_CLASS_NAMES:
+        if class_name not in merged:
+            merged.append(class_name)
+    return merged
 
 
 def pil_to_np(img: Image.Image) -> np.ndarray:
     return np.array(img.convert("RGB"))
 
 
+def detect_upload_kind(path: Path) -> str:
+    """マジックバイト優先でアップロード種別を判定する。"""
+    suffix = path.suffix.lower()
+
+    try:
+        with open(path, "rb") as f:
+            header = f.read(16)
+    except Exception:
+        return "unknown"
+
+    if header.startswith(b"%PDF"):
+        return "pdf"
+    if header.startswith(b"\x89PNG\r\n\x1a\n"):
+        return "image"
+    if header.startswith(b"\xff\xd8\xff"):
+        return "image"
+    if header[:4] in {b"II*\x00", b"MM\x00*"}:
+        return "image"
+    if header.startswith(b"RIFF") and header[8:12] == b"WEBP":
+        return "image"
+    if suffix == ".pdf":
+        return "pdf"
+    if suffix in SUPPORTED_IMAGE_SUFFIXES:
+        return "image"
+    return "unknown"
+
+
+def ensure_pixel_limit(width: int, height: int, source_label: str) -> None:
+    pixels = int(width) * int(height)
+    if pixels > MAX_RENDERED_PIXELS:
+        raise gr.Error(
+            f"{source_label}が大きすぎます。"
+            f"サイズ: {width}x{height}px / 上限: {MAX_RENDERED_PIXELS:,}px"
+        )
+
+
+def extract_upload_path(upload: Any) -> Path:
+    if isinstance(upload, dict):
+        upload_path = upload.get("path")
+    elif isinstance(upload, (str, os.PathLike)):
+        upload_path = upload
+    else:
+        upload_path = getattr(upload, "path", None)
+        if upload_path is None:
+            candidate = getattr(upload, "name", None)
+            if isinstance(candidate, (str, os.PathLike)) and Path(candidate).exists():
+                upload_path = candidate
+
+    if not isinstance(upload_path, (str, os.PathLike)):
+        raise gr.Error("アップロードファイルを読み込めませんでした。")
+
+    path = Path(upload_path)
+    if not path.exists():
+        raise gr.Error("アップロードファイルが見つかりません。")
+    return path
+
+
+def normalize_upload_to_pil(upload: Any) -> Image.Image:
+    """PDF/画像アップロードを推論用のRGB PIL画像へ正規化する。"""
+    if upload is None:
+        raise gr.Error("PDFまたはPNG形式の図面をアップロードしてください。")
+
+    if isinstance(upload, Image.Image):
+        ensure_pixel_limit(upload.width, upload.height, "画像")
+        return upload.convert("RGB")
+
+    path = extract_upload_path(upload)
+    upload_kind = detect_upload_kind(path)
+
+    if upload_kind == "pdf":
+        try:
+            import fitz
+
+            with fitz.open(str(path)) as doc:
+                if doc.needs_pass or doc.is_encrypted:
+                    raise gr.Error("暗号化またはパスワード保護されたPDFには対応していません。")
+                if doc.page_count < 1:
+                    raise gr.Error("PDFにページがありません。")
+                page = doc.load_page(0)
+                scale = PDF_DPI / 72.0
+                expected_width = math.ceil(page.rect.width * scale)
+                expected_height = math.ceil(page.rect.height * scale)
+                ensure_pixel_limit(expected_width, expected_height, "PDFの400dpi変換結果")
+                pix = page.get_pixmap(dpi=PDF_DPI, colorspace=fitz.csRGB, alpha=False)
+                ensure_pixel_limit(pix.width, pix.height, "PDFの400dpi変換結果")
+                if pix.n != 3:
+                    raise gr.Error("PDFのRGB変換に失敗しました。")
+                image = Image.frombytes("RGB", (pix.width, pix.height), pix.samples)
+                return image.convert("RGB")
+        except gr.Error:
+            raise
+        except Exception as e:
+            raise gr.Error(f"PDFの読み込みに失敗しました: {str(e)}")
+
+    if upload_kind == "image":
+        try:
+            with Image.open(path) as img:
+                ensure_pixel_limit(img.width, img.height, "画像")
+                img.verify()
+            with Image.open(path) as img:
+                ensure_pixel_limit(img.width, img.height, "画像")
+                return img.convert("RGB")
+        except Image.DecompressionBombWarning:
+            raise gr.Error("画像が大きすぎるため処理できません。")
+        except Image.DecompressionBombError:
+            raise gr.Error("画像が大きすぎるため処理できません。")
+        except Exception as e:
+            raise gr.Error(f"画像ファイルの読み込みに失敗しました: {str(e)}")
+
+    raise gr.Error("対応形式はPDFまたはPNG画像です。")
+
+
 def draw_detections(
     image_pil: Image.Image,
     detections: List[Detection],
@@ -130,38 +246,21 @@ def summarize_detections(detections: List[Detection]) -> List[List[Any]]:
 
 
 def inference_pipeline(
-    image: Image.Image,
+    upload: Any,
     score_thresh: float = 0.8,
     selected_classes: List[str] = None,
 ) -> Tuple[Image.Image, List[List[Any]]]:
     """Gradio から呼ばれるメイン処理"""
-    if image is None:
-        raise gr.Error("PNG形式の図面をアップロードしてください。")
-
     try:
-        # 画像が文字列（ファイルパス）の場合はPIL Imageに変換
-        if isinstance(image, str):
-            try:
-                img_pil = Image.open(image).convert("RGB")
-            except Exception as e:
-                raise gr.Error(f"画像ファイルの読み込みに失敗しました: {str(e)}")
-        else:
-            # 既にPIL Imageオブジェクトの場合
-            img_pil = image.convert("RGB")
-        
+        img_pil = normalize_upload_to_pil(upload)
         img_np = pil_to_np(img_pil)
 
-        # DEIMv2 推論
-        detections = run_inference(img_np, score_thresh=score_thresh)
-
-        # クラスフィルタリング: 選択されたクラスのみを残す
-        if selected_classes is not None and len(selected_classes) > 0:
-            # 選択されたクラスリストに含まれる検出結果のみをフィルタリング
-            filtered_detections = [
-                det for det in detections 
-                if det[4] in selected_classes  # det[4]はlabel_name
-            ]
-            detections = filtered_detections
+        # 選択クラスに応じて detection.py 側で YOLO26L / DEIMv2 を自動ルーティング
+        detections = run_inference(
+            img_np,
+            score_thresh=score_thresh,
+            selected_classes=selected_classes,
+        )
 
         # 描画
         vis_pil = draw_detections(img_pil.copy(), detections)
@@ -170,32 +269,35 @@ def inference_pipeline(
         summary = summarize_detections(detections)
 
         return vis_pil, summary
+    except gr.Error:
+        raise
     except Exception as e:
         error_msg = f"エラーが発生しました: {str(e)}"
         raise gr.Error(error_msg)
 
 
-@spaces.GPU
+@spaces.GPU(duration=180)
 def gpu_inference(
-    image: Image.Image,
+    upload: Any,
     score_thresh: float = 0.9,  # UIのデフォルト値と統一
     selected_classes: List[str] = None,
 ):
     """Spaces ZeroGPU が検出できるようにデコレータ付きの推論関数を用意"""
-    return inference_pipeline(image, score_thresh, selected_classes)
+    return inference_pipeline(upload, score_thresh, selected_classes)
 
 
 # =========================
 # Gradio UI
 # =========================
-with gr.Blocks(title="DEIMv2 Floorplan Symbol Detection") as demo:
+with gr.Blocks(title="PDF/PNG Floorplan Symbol Detection") as demo:
     gr.Markdown(
         """
 # 図面記号検出デモ（by AItech）
 
-1. 左側に **PNG図面** をアップロード  
-2. 「検出を実行」を押す  
-3. 中央に **検出結果付き図面**、右側に **記号名称＋個数** が表示されます。
+1. 左側に **PDFまたはPNG図面** をアップロード  
+2. PDFの場合は **1ページ目のみ400dpiで変換** して推論します  
+3. 対象クラスを選択して「検出を実行」を押す  
+4. 中央に **検出結果付き図面**、右側に **記号名称＋個数** が表示されます。
 """
     )
 
@@ -205,10 +307,10 @@ with gr.Blocks(title="DEIMv2 Floorplan Symbol Detection") as demo:
     with gr.Row():
         # 左: 入力
         with gr.Column(scale=1):
-            input_image = gr.Image(
-                label="入力図面 (PNG)",
-                type="pil",
-                image_mode="RGB",
+            input_file = gr.File(
+                label="PDF/PNG図面アップロード",
+                file_types=[".pdf", ".png", ".jpg", ".jpeg", ".tif", ".tiff", ".bmp", ".webp"],
+                type="filepath",
             )
             
             # 詳細設定タブ（デフォルトは閉じた状態）
@@ -223,8 +325,8 @@ with gr.Blocks(title="DEIMv2 Floorplan Symbol Detection") as demo:
                 selected_classes = gr.CheckboxGroup(
                     choices=class_names,
                     value=["door1"],  # デフォルトでdoor1のみ選択
-                    label="検出するクラス",
-                    info="選択したクラスの検出結果のみが表示されます",
+                    label="対象クラス",
+                    info="選択したクラスに応じてYOLO26LまたはDEIMv2で自動推論します",
                 )
             
             run_button = gr.Button("検出を実行", variant="primary")
@@ -247,14 +349,15 @@ with gr.Blocks(title="DEIMv2 Floorplan Symbol Detection") as demo:
     # ボタンの動作
     run_button.click(
         fn=gpu_inference,
-        inputs=[input_image, score_thresh, selected_classes],
+        inputs=[input_file, score_thresh, selected_classes],
         outputs=[output_image, summary_dataframe],
     )
 
 # Gradio 5では、Spaces上ではdemoオブジェクトを直接エクスポートするだけで動作します
 # ローカルテスト時のみdemo.launch()を呼び出します
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    server_port = int(os.getenv("GRADIO_SERVER_PORT", "7860"))
+    demo.launch(server_name="0.0.0.0", server_port=server_port)
 
 # Spaces上では、demoオブジェクトを直接エクスポートします
 # Gradio 5は自動的にdemoオブジェクトを検出して起動します

detection.py

@@ -1,7 +1,9 @@
 # detection.py
+from collections import Counter
 from functools import lru_cache
-from typing import List, Tuple
+from typing import Dict, List, Optional, Set, Tuple
 import os
+import yaml
 import numpy as np
 import torch
 import torch.nn as nn
@@ -10,6 +12,9 @@ import torchvision.transforms as T
 
 # デバッグ出力制御フラグ（環境変数で制御）
 DEBUG_DEIMV2 = os.getenv("DEBUG_DEIMV2", "0") == "1"
+YOLO_CONFIG_DIR = os.getenv("YOLO_CONFIG_DIR", "/tmp/ultralytics")
+os.makedirs(YOLO_CONFIG_DIR, exist_ok=True)
+os.environ.setdefault("YOLO_CONFIG_DIR", YOLO_CONFIG_DIR)
 
 # YAMLConfigをインポート（engineパッケージ経由でレジストリをロード）
 # モジュール登録のために、すべての必要なモジュールを明示的にインポート
@@ -50,6 +55,26 @@ Detection = Tuple[float, float, float, float, str, float]
 # ★ここを自分のファイル名に合わせる
 MODEL_CONFIG_PATH = "configs/deimv2_floorplan.yaml"
 MODEL_WEIGHTS_PATH = "models/best_stg2.pth"
+YOLO_WEIGHTS_PATH = "models/yolobest.pt"
+YOLO_TILE_SIZE = 960
+YOLO_TILE_OVERLAP = 192
+DEIM_TILE_SIZE = 640
+DEIM_TILE_OVERLAP = 128
+TILE_MERGE_IOU_THRESHOLD = 0.4
+
+YOLO_CLASS_NAMES = [
+    "window1",
+    "window2",
+    "window3",
+    "window4",
+    "window_hiki",
+    "window_hiki2",
+    "door1",
+    "door2",
+    "sash_circle",
+    "sash_rect",
+]
+YOLO_CLASSES: Set[str] = set(YOLO_CLASS_NAMES)
 
 
 def _get_device():
@@ -60,13 +85,28 @@ def _get_device():
     """
     return torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
-# クラスID→記号名マッピング
-# クラス名リスト: ["kanki", "kanki_shikaku", "kanki_regisuta", "window1", "window2", "door1", "door2", "bathtub1", "konro1", "sink1", "toilet1", "kasaikeihou1", "kasaikeihou2", "houi1", "houi2", "houi3"]
-label_map = {
-    0: "kanki",      # kanki
-    5: "door1",
-    6: "door2",
-}
+
+def _get_device_key() -> str:
+    return "cuda:0" if torch.cuda.is_available() else "cpu"
+
+def load_deimv2_class_names() -> List[str]:
+    default_class_names = ["kanki", "kanki_shikaku", "kanki_regisuta", "window1", "window2",
+                           "door1", "door2", "bathtub1", "konro1", "sink1", "toilet1",
+                           "kasaikeihou1", "kasaikeihou2", "houi1", "houi2", "houi3"]
+    try:
+        with open(MODEL_CONFIG_PATH, "r", encoding="utf-8") as f:
+            config = yaml.safe_load(f)
+        class_names = config.get("Model", {}).get("class_names")
+        if isinstance(class_names, list) and class_names:
+            return [str(name) for name in class_names]
+    except Exception as e:
+        print(f"Warning: Failed to load DEIMv2 class names: {e}")
+    return default_class_names
+
+
+DEIM_CLASS_NAMES = load_deimv2_class_names()
+DEIM_LABEL_MAP: Dict[int, str] = {idx: name for idx, name in enumerate(DEIM_CLASS_NAMES)}
+DEIM_CLASSES: Set[str] = set(DEIM_CLASS_NAMES) - YOLO_CLASSES
 
 
 @lru_cache(maxsize=1)
@@ -427,7 +467,7 @@ def run_inference_single_tile(
             unique_labels, label_counts = np.unique(labels, return_counts=True)
             print(f"[DEBUG]     ラベル分布:")
             for label_id, count in zip(unique_labels, label_counts):
-                label_name = label_map.get(int(label_id), f"class_{int(label_id)}")
+                label_name = DEIM_LABEL_MAP.get(int(label_id), f"class_{int(label_id)}")
                 print(f"        - クラスID {int(label_id)} ({label_name}): {count}件")
             
             # スコア閾値以上の検出数
@@ -440,7 +480,7 @@ def run_inference_single_tile(
                 print(f"[DEBUG]     上位5件の検出結果:")
                 for rank, idx in enumerate(top_indices, 1):
                     label_id = int(labels[idx])
-                    label_name = label_map.get(label_id, f"class_{label_id}")
+                    label_name = DEIM_LABEL_MAP.get(label_id, f"class_{label_id}")
                     score = float(scores[idx])
                     x1, y1, x2, y2 = boxes[idx]
                     print(f"        [{rank}] {label_name}, スコア={score:.4f}, bbox=({x1:.1f},{y1:.1f},{x2:.1f},{y2:.1f})")
@@ -457,10 +497,10 @@ def run_inference_single_tile(
         
         x1, y1, x2, y2 = [float(v) for v in box.tolist()]
         label_id = int(label)
-        label_name = label_map.get(label_id, f"class_{label_id}")
+        label_name = DEIM_LABEL_MAP.get(label_id, f"class_{label_id}")
         
-        # label_mapに存在しないクラスもカウント（デバッグ用）
-        if label_id not in label_map:
+        # DEIM_LABEL_MAPに存在しないクラスもカウント（デバッグ用）
+        if label_id not in DEIM_LABEL_MAP:
             filtered_by_label += 1
         
         # タイル座標を元の画像座標に変換
@@ -472,16 +512,17 @@ def run_inference_single_tile(
         detections.append((x1_orig, y1_orig, x2_orig, y2_orig, label_name, score))
     
     if DEBUG_DEIMV2 and (filtered_by_thresh > 0 or filtered_by_label > 0):
-        print(f"[DEBUG]     フィ���タリング: スコア閾値で{filtered_by_thresh}件、label_mapで{filtered_by_label}件除外")
+        print(f"[DEBUG]     フィルタリング: スコア閾値で{filtered_by_thresh}件、DEIM_LABEL_MAPで{filtered_by_label}件除外")
     
     return detections
 
 
-def run_inference(
+def run_deimv2_inference(
     image_np: np.ndarray,
     score_thresh: float = 0.8,
-    tile_size: int = 640,
-    tile_overlap: int = 128,
+    selected_classes: Optional[Set[str]] = None,
+    tile_size: int = DEIM_TILE_SIZE,
+    tile_overlap: int = DEIM_TILE_OVERLAP,
 ) -> List[Detection]:
     """
     タイル推論を実行する。
@@ -490,6 +531,7 @@ def run_inference(
     Args:
         image_np: RGB np.ndarray (H, W, 3)
         score_thresh: スコア閾値
+        selected_classes: DEIMv2で返すクラス。Noneまたは空の場合はDEIM担当クラスすべて
         tile_size: タイルサイズ（デフォルト: 640）
         tile_overlap: タイル間のオーバーラップ（デフォルト: 128）
     
@@ -511,6 +553,7 @@ def run_inference(
         
         im_pil = Image.fromarray(image_np).convert("RGB")
         img_w, img_h = im_pil.size
+        allowed_classes = set(selected_classes) if selected_classes else set(DEIM_CLASSES)
         
         if DEBUG_DEIMV2:
             print(f"[DEBUG] ===== タイル推論開始 =====")
@@ -574,7 +617,10 @@ def run_inference(
             
             if DEBUG_DEIMV2:
                 print(f"[DEBUG]   検出数: {len(tile_detections)}件")
-            all_detections.extend(tile_detections)
+            all_detections.extend(
+                det for det in tile_detections
+                if det[4] in allowed_classes
+            )
         
         if DEBUG_DEIMV2:
             print(f"[DEBUG] 総検出数（重複あり）: {len(all_detections)}件")
@@ -670,3 +716,203 @@ def run_inference(
         return merged_detections
     except Exception as e:
         raise RuntimeError(f"推論の実行に失敗しました: {e}")
+
+
+@lru_cache(maxsize=2)
+def load_yolo_model(device_key: str):
+    """YOLO26Lモデルをデバイス単位で遅延ロードする。"""
+    weights_path = os.path.abspath(YOLO_WEIGHTS_PATH)
+    if not os.path.exists(weights_path):
+        raise FileNotFoundError(f"YOLOモデルファイルが見つかりません: {weights_path}")
+
+    try:
+        from ultralytics import YOLO
+
+        model = YOLO(weights_path)
+        names = getattr(model.model, "names", None) or getattr(model, "names", None)
+        class_map = normalize_yolo_class_map(names)
+        expected_map = {idx: name for idx, name in enumerate(YOLO_CLASS_NAMES)}
+        if class_map != expected_map:
+            raise RuntimeError(
+                f"YOLOクラス名が想定と異なります: {class_map}. "
+                f"expected={expected_map}"
+            )
+        return model, class_map
+    except Exception as e:
+        raise RuntimeError(f"YOLOモデルの読み込みに失敗しました: {e}")
+
+
+def normalize_yolo_class_map(names) -> Dict[int, str]:
+    if isinstance(names, dict):
+        return {int(idx): str(name) for idx, name in names.items()}
+    if isinstance(names, (list, tuple)):
+        return {idx: str(name) for idx, name in enumerate(names)}
+    raise RuntimeError(f"YOLOクラス名を読み取れません: {names}")
+
+
+def clamp_detection(det: Detection, img_w: int, img_h: int) -> Optional[Detection]:
+    x1, y1, x2, y2, label_name, score = det
+    x1 = max(0.0, min(float(x1), float(img_w)))
+    y1 = max(0.0, min(float(y1), float(img_h)))
+    x2 = max(0.0, min(float(x2), float(img_w)))
+    y2 = max(0.0, min(float(y2), float(img_h)))
+    if x2 <= x1 or y2 <= y1:
+        return None
+    return (x1, y1, x2, y2, label_name, float(score))
+
+
+def merge_detections_by_class(
+    detections: List[Detection],
+    device: Optional[torch.device] = None,
+    iou_threshold: float = TILE_MERGE_IOU_THRESHOLD,
+) -> List[Detection]:
+    if not detections:
+        return []
+
+    from torchvision.ops import nms
+
+    target_device = device or torch.device("cpu")
+    detections_by_class: Dict[str, List[Tuple[float, float, float, float, float]]] = {}
+    for x1, y1, x2, y2, label_name, score in detections:
+        detections_by_class.setdefault(label_name, []).append((x1, y1, x2, y2, score))
+
+    merged: List[Detection] = []
+    for label_name, boxes_scores in detections_by_class.items():
+        boxes_tensor = torch.tensor(
+            [[x1, y1, x2, y2] for x1, y1, x2, y2, _ in boxes_scores],
+            device=target_device,
+            dtype=torch.float32,
+        )
+        scores_tensor = torch.tensor(
+            [score for _, _, _, _, score in boxes_scores],
+            device=target_device,
+            dtype=torch.float32,
+        )
+        keep_indices = nms(boxes_tensor, scores_tensor, iou_threshold=iou_threshold)
+        for idx in keep_indices.cpu().numpy():
+            x1, y1, x2, y2, score = boxes_scores[int(idx)]
+            merged.append((x1, y1, x2, y2, label_name, score))
+    return merged
+
+
+def run_yolo_inference(
+    image_np: np.ndarray,
+    score_thresh: float = 0.8,
+    selected_classes: Optional[Set[str]] = None,
+    tile_size: int = YOLO_TILE_SIZE,
+    tile_overlap: int = YOLO_TILE_OVERLAP,
+) -> List[Detection]:
+    """YOLO26Lタイル推論を実行し、既存Detection形式で返す。"""
+    if image_np.dtype != np.uint8:
+        if image_np.max() <= 1.0:
+            image_np = (image_np * 255).astype(np.uint8)
+        else:
+            image_np = image_np.astype(np.uint8)
+
+    im_pil = Image.fromarray(image_np).convert("RGB")
+    img_w, img_h = im_pil.size
+    allowed_classes = set(selected_classes) if selected_classes else set(YOLO_CLASSES)
+    if not allowed_classes:
+        return []
+
+    device = _get_device()
+    device_key = _get_device_key()
+    model, class_map = load_yolo_model(device_key)
+    selected_class_ids = sorted(
+        class_id for class_id, label_name in class_map.items()
+        if label_name in allowed_classes
+    )
+    if not selected_class_ids:
+        return []
+
+    step = tile_size - tile_overlap
+    all_detections: List[Detection] = []
+
+    for tile_y in range(0, img_h, step):
+        for tile_x in range(0, img_w, step):
+            tile_x_end = min(tile_x + tile_size, img_w)
+            tile_y_end = min(tile_y + tile_size, img_h)
+            tile = im_pil.crop((tile_x, tile_y, tile_x_end, tile_y_end))
+
+            with torch.inference_mode():
+                results = model.predict(
+                    tile,
+                    imgsz=tile_size,
+                    conf=score_thresh,
+                    iou=TILE_MERGE_IOU_THRESHOLD,
+                    classes=selected_class_ids,
+                    verbose=False,
+                    device=device_key,
+                )
+
+            if not results:
+                continue
+            boxes = getattr(results[0], "boxes", None)
+            if boxes is None or len(boxes) == 0:
+                continue
+
+            xyxy = boxes.xyxy.detach().cpu().numpy()
+            confs = boxes.conf.detach().cpu().numpy()
+            classes = boxes.cls.detach().cpu().numpy().astype(int)
+            for box, conf, class_id in zip(xyxy, confs, classes):
+                label_name = class_map.get(int(class_id), f"class_{int(class_id)}")
+                if label_name not in allowed_classes:
+                    continue
+                x1, y1, x2, y2 = [float(v) for v in box.tolist()]
+                det = clamp_detection(
+                    (x1 + tile_x, y1 + tile_y, x2 + tile_x, y2 + tile_y, label_name, float(conf)),
+                    img_w,
+                    img_h,
+                )
+                if det is not None:
+                    all_detections.append(det)
+
+    return merge_detections_by_class(all_detections, device=device)
+
+
+def resolve_requested_classes(selected_classes: Optional[List[str]]) -> Tuple[Set[str], Set[str]]:
+    requested = set(selected_classes or [])
+    if not requested:
+        return set(DEIM_CLASSES), set(YOLO_CLASSES)
+
+    deim_requested = requested & DEIM_CLASSES
+    yolo_requested = requested & YOLO_CLASSES
+    unknown_requested = requested - DEIM_CLASSES - YOLO_CLASSES
+    if unknown_requested:
+        print(f"Warning: Unknown selected classes ignored: {sorted(unknown_requested)}")
+    return deim_requested, yolo_requested
+
+
+def run_inference(
+    image_np: np.ndarray,
+    score_thresh: float = 0.8,
+    selected_classes: Optional[List[str]] = None,
+) -> List[Detection]:
+    """
+    選択クラスに応じてDEIMv2/YOLO26Lを自動ルーティングして推論する。
+    """
+    try:
+        deim_classes, yolo_classes = resolve_requested_classes(selected_classes)
+        all_detections: List[Detection] = []
+
+        if deim_classes:
+            all_detections.extend(
+                run_deimv2_inference(
+                    image_np,
+                    score_thresh=score_thresh,
+                    selected_classes=deim_classes,
+                )
+            )
+
+        if yolo_classes:
+            all_detections.extend(
+                run_yolo_inference(
+                    image_np,
+                    score_thresh=score_thresh,
+                    selected_classes=yolo_classes,
+                )
+            )
+
+        return all_detections
+    except Exception as e:
+        raise RuntimeError(f"推論の実行に失敗しました: {e}")

models/yolobest.pt

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

requirements.txt

@@ -1,11 +1,12 @@
-gradio>=5.1.0
+gradio==5.49.1
+python-multipart>=0.0.20
 spaces
-torch==2.5.1
-torchvision==0.20.1
+torch==2.8.0
+torchvision==0.23.0
 numpy
 Pillow>=9.0.0
 opencv-python-headless
-huggingface_hub==0.25.2
+huggingface_hub>=0.33.5
 PyYAML>=6.0
 tensorboard
 scipy>=1.7.0
@@ -13,6 +14,8 @@ faster-coco-eval>=1.6.7
 calflops
 transformers
 onnxruntime>=1.16.0
+PyMuPDF>=1.24.0
+ultralytics>=8.3.0
 # DEIMv2関連の依存関係
 timm
 omegaconf