姿勢推定と頭部検知を合成する手段を追加

README.md

@@ -19,7 +19,7 @@
 python server/main.py
 
 # サーバーのGPU状態を確認
-python test_server_api.py --status
+curl -s http://127.0.0.1:8181/status | jq
 ```
 
 出力例：
@@ -40,20 +40,3 @@ python test_server_api.py --status
   ROCm Version (HIP): 7.0.51831
 ======================================================================
 ```
-
-### 処理プロセスの単体デバッグ
-
-顔検出処理をBlenderから独立してテストできます。
-
-```bash
-# 画像ファイルでテスト
-python debug_detector.py --image test.jpg
-
-# 動画ファイルでテスト
-python debug_detector.py --video test.mp4 --frame 0
-
-# クイックテスト（簡易版）
-./test_quick.sh test.jpg
-```
-
-詳細は [docs/debugging.md](docs/debugging.md) を参照してください。

__init__.py

@@ -15,21 +15,87 @@ bl_info = {
 
 def register():
     """Register all extension components."""
+    import bpy
+    from bpy.props import FloatProperty, IntProperty, EnumProperty, StringProperty
+
     from . import operators
     from . import panels
 
+    # Register scene properties for face detection parameters
+    bpy.types.Scene.facemask_conf_threshold = FloatProperty(
+        name="Confidence",
+        description="YOLO confidence threshold (higher = fewer false positives)",
+        default=0.5,
+        min=0.1,
+        max=1.0,
+        step=0.01,
+    )
+
+    bpy.types.Scene.facemask_iou_threshold = FloatProperty(
+        name="IOU Threshold",
+        description="Non-maximum suppression IOU threshold",
+        default=0.45,
+        min=0.1,
+        max=1.0,
+        step=0.01,
+    )
+
+    bpy.types.Scene.facemask_cache_dir = StringProperty(
+        name="Cache Directory",
+        description="Optional cache root directory (empty = default .mask_cache)",
+        default="",
+        subtype='DIR_PATH',
+    )
+
+    bpy.types.Scene.facemask_bake_blur_size = IntProperty(
+        name="Bake Blur Size",
+        description="Gaussian blur size (pixels) used for bake",
+        default=50,
+        min=1,
+        max=501,
+    )
+
+    bpy.types.Scene.facemask_bake_display_scale = FloatProperty(
+        name="Mask Scale",
+        description="Scale factor for the blur mask ellipse at bake time (1.0 = raw detection size)",
+        default=1.3,
+        min=0.5,
+        max=3.0,
+        step=0.1,
+    )
+
+    bpy.types.Scene.facemask_bake_format = EnumProperty(
+        name="Bake Format",
+        description="Output format for baked blur video",
+        items=[
+            ("MP4", "MP4", "Export as .mp4"),
+            ("AVI", "AVI", "Export as .avi"),
+            ("MOV", "MOV", "Export as .mov"),
+        ],
+        default="MP4",
+    )
+
     operators.register()
     panels.register()
 
 
 def unregister():
     """Unregister all extension components."""
+    import bpy
     from . import operators
     from . import panels
 
     panels.unregister()
     operators.unregister()
 
+    # Unregister scene properties
+    del bpy.types.Scene.facemask_conf_threshold
+    del bpy.types.Scene.facemask_iou_threshold
+    del bpy.types.Scene.facemask_cache_dir
+    del bpy.types.Scene.facemask_bake_blur_size
+    del bpy.types.Scene.facemask_bake_display_scale
+    del bpy.types.Scene.facemask_bake_format
+
 
 if __name__ == "__main__":
     register()

core/__init__.py

@@ -1,4 +1,5 @@
 """Core module exports."""
 
-from .async_generator import AsyncMaskGenerator, get_generator
-from .compositor_setup import create_mask_blur_node_tree, get_or_create_blur_node_tree
+from .async_bake_generator import AsyncBakeGenerator as AsyncBakeGenerator, get_bake_generator as get_bake_generator
+from .async_generator import AsyncMaskGenerator as AsyncMaskGenerator, get_generator as get_generator
+from .compositor_setup import create_mask_blur_node_tree as create_mask_blur_node_tree, get_or_create_blur_node_tree as get_or_create_blur_node_tree

core/async_bake_generator.py

@@ -0,0 +1,247 @@
+"""
+Async blur bake generator using Thread + Queue + Timer pattern.
+
+This module mirrors AsyncMaskGenerator behavior for bake-and-swap workflow,
+so Blender UI remains responsive during server-side bake processing.
+"""
+
+import threading
+import queue
+from typing import Optional, Callable
+
+# Will be imported when running inside Blender
+bpy = None
+
+
+class AsyncBakeGenerator:
+    """Asynchronous bake generator for non-blocking blur bake tasks."""
+
+    def __init__(self):
+        self.result_queue: queue.Queue = queue.Queue()
+        self.progress_queue: queue.Queue = queue.Queue()
+        self.worker_thread: Optional[threading.Thread] = None
+        self.is_running: bool = False
+        self.total_frames: int = 0
+        self.current_frame: int = 0
+        self._on_complete: Optional[Callable] = None
+        self._on_progress: Optional[Callable] = None
+
+    def start(
+        self,
+        video_path: str,
+        detections_path: str,
+        output_path: str,
+        blur_size: int,
+        display_scale: float,
+        fmt: str,
+        on_complete: Optional[Callable] = None,
+        on_progress: Optional[Callable] = None,
+    ):
+        """Start asynchronous bake request and progress polling."""
+        global bpy
+        import bpy as _bpy
+
+        bpy = _bpy
+
+        if self.is_running:
+            raise RuntimeError("Blur bake already in progress")
+
+        self.is_running = True
+        self.total_frames = 0
+        self.current_frame = 0
+        self._on_complete = on_complete
+        self._on_progress = on_progress
+
+        self.worker_thread = threading.Thread(
+            target=self._worker,
+            args=(video_path, detections_path, output_path, blur_size, display_scale, fmt),
+            daemon=True,
+        )
+        self.worker_thread.start()
+
+        bpy.app.timers.register(
+            self._check_progress,
+            first_interval=0.1,
+        )
+
+    def start_images(
+        self,
+        image_dir: str,
+        filenames: list,
+        output_dir: str,
+        detections_path: str,
+        blur_size: int,
+        display_scale: float,
+        on_complete=None,
+        on_progress=None,
+    ):
+        """画像シーケンスのぼかしBakeを非同期で開始する。"""
+        global bpy
+        import bpy as _bpy
+        bpy = _bpy
+
+        if self.is_running:
+            raise RuntimeError("Blur bake already in progress")
+
+        self.is_running = True
+        self.total_frames = len(filenames)
+        self.current_frame = 0
+        self._on_complete = on_complete
+        self._on_progress = on_progress
+
+        self.worker_thread = threading.Thread(
+            target=self._worker_images,
+            args=(image_dir, filenames, output_dir, detections_path, blur_size, display_scale),
+            daemon=True,
+        )
+        self.worker_thread.start()
+        bpy.app.timers.register(self._check_progress, first_interval=0.1)
+
+    def cancel(self):
+        """Cancel the current bake processing."""
+        self.is_running = False
+        if self.worker_thread and self.worker_thread.is_alive():
+            self.worker_thread.join(timeout=2.0)
+
+    def _worker_images(
+        self,
+        image_dir: str,
+        filenames: list,
+        output_dir: str,
+        detections_path: str,
+        blur_size: int,
+        display_scale: float,
+    ):
+        import time
+        from .inference_client import get_client
+
+        task_id = None
+        try:
+            client = get_client()
+            task_id = client.bake_image_blur(
+                image_dir=image_dir,
+                filenames=filenames,
+                output_dir=output_dir,
+                detections_path=detections_path,
+                blur_size=blur_size,
+                display_scale=display_scale,
+            )
+            while self.is_running:
+                status = client.get_task_status(task_id)
+                state = status.get("status")
+                total = status.get("total", 0)
+                if total > 0:
+                    self.total_frames = total
+                progress = status.get("progress", 0)
+                if progress >= 0:
+                    self.progress_queue.put(("progress", progress))
+                if state == "completed":
+                    result_path = status.get("result_path", output_dir)
+                    self.result_queue.put(("done", result_path))
+                    return
+                if state == "failed":
+                    self.result_queue.put(("error", status.get("message", "Unknown error")))
+                    return
+                if state == "cancelled":
+                    self.result_queue.put(("cancelled", None))
+                    return
+                time.sleep(0.5)
+
+            if task_id:
+                client.cancel_task(task_id)
+            self.result_queue.put(("cancelled", None))
+        except Exception as e:
+            self.result_queue.put(("error", str(e)))
+
+    def _worker(
+        self,
+        video_path: str,
+        detections_path: str,
+        output_path: str,
+        blur_size: int,
+        display_scale: float,
+        fmt: str,
+    ):
+        import time
+        from .inference_client import get_client
+
+        task_id = None
+        try:
+            client = get_client()
+            task_id = client.bake_blur(
+                video_path=video_path,
+                detections_path=detections_path,
+                output_path=output_path,
+                blur_size=blur_size,
+                display_scale=display_scale,
+                fmt=fmt,
+            )
+
+            while self.is_running:
+                status = client.get_task_status(task_id)
+                state = status.get("status")
+
+                total = status.get("total", 0)
+                if total > 0:
+                    self.total_frames = total
+
+                progress = status.get("progress", 0)
+                if progress >= 0:
+                    self.progress_queue.put(("progress", progress))
+
+                if state == "completed":
+                    result_path = status.get("result_path", output_path)
+                    self.result_queue.put(("done", result_path))
+                    return
+                if state == "failed":
+                    error_msg = status.get("message", "Unknown server error")
+                    self.result_queue.put(("error", error_msg))
+                    return
+                if state == "cancelled":
+                    self.result_queue.put(("cancelled", None))
+                    return
+
+                time.sleep(0.5)
+
+            # Local cancel path
+            if task_id:
+                client.cancel_task(task_id)
+            self.result_queue.put(("cancelled", None))
+
+        except Exception as e:
+            self.result_queue.put(("error", str(e)))
+
+    def _check_progress(self) -> Optional[float]:
+        while not self.progress_queue.empty():
+            try:
+                msg_type, data = self.progress_queue.get_nowait()
+                if msg_type == "progress":
+                    self.current_frame = data
+                    if self._on_progress:
+                        self._on_progress(self.current_frame, self.total_frames)
+            except queue.Empty:
+                break
+
+        if not self.result_queue.empty():
+            try:
+                msg_type, data = self.result_queue.get_nowait()
+                self.is_running = False
+                if self._on_complete:
+                    self._on_complete(msg_type, data)
+                return None
+            except queue.Empty:
+                pass
+
+        if self.is_running:
+            return 0.1
+        return None
+
+
+_bake_generator: Optional[AsyncBakeGenerator] = None
+
+
+def get_bake_generator() -> AsyncBakeGenerator:
+    global _bake_generator
+    if _bake_generator is None:
+        _bake_generator = AsyncBakeGenerator()
+    return _bake_generator

core/async_generator.py

@@ -9,8 +9,7 @@ Blender's UI remains responsive via bpy.app.timers.
 import os
 import threading
 import queue
-from functools import partial
-from typing import Optional, Callable, Tuple
+from typing import Optional, Callable
 from pathlib import Path
 
 # Will be imported when running inside Blender
@@ -45,7 +44,6 @@ class AsyncMaskGenerator:
         fps: float,
         conf_threshold: float = 0.5,
         iou_threshold: float = 0.45,
-        mask_scale: float = 1.5,
         on_complete: Optional[Callable] = None,
         on_progress: Optional[Callable] = None,
     ):
@@ -95,7 +93,6 @@ class AsyncMaskGenerator:
                 fps,
                 conf_threshold,
                 iou_threshold,
-                mask_scale,
             ),
             daemon=True,
         )
@@ -107,12 +104,189 @@ class AsyncMaskGenerator:
             first_interval=0.1,
         )
     
+    def start_images(
+        self,
+        image_dir: str,
+        filenames: list,
+        output_dir: str,
+        start_index: int,
+        end_index: int,
+        conf_threshold: float = 0.5,
+        iou_threshold: float = 0.45,
+        on_complete=None,
+        on_progress=None,
+    ):
+        """画像シーケンスの顔検出を非同期で開始する。"""
+        global bpy
+        import bpy as _bpy
+        bpy = _bpy
+
+        if self.is_running:
+            raise RuntimeError("Mask generation already in progress")
+
+        self.is_running = True
+        self.total_frames = end_index - start_index + 1
+        self.current_frame = 0
+        self._on_complete = on_complete
+        self._on_progress = on_progress
+
+        os.makedirs(output_dir, exist_ok=True)
+
+        self.worker_thread = threading.Thread(
+            target=self._worker_images,
+            args=(image_dir, filenames, output_dir, start_index, end_index,
+                  conf_threshold, iou_threshold),
+            daemon=True,
+        )
+        self.worker_thread.start()
+        bpy.app.timers.register(self._check_progress, first_interval=0.1)
+
+    def start_augment_pose(
+        self,
+        detections_path: str,
+        total_frames: int,
+        conf_threshold: float = 0.5,
+        iou_threshold: float = 0.45,
+        on_complete=None,
+        on_progress=None,
+    ):
+        """既存キャッシュへの pose 補完を非同期で開始する。"""
+        global bpy
+        import bpy as _bpy
+        bpy = _bpy
+
+        if self.is_running:
+            raise RuntimeError("Mask generation already in progress")
+
+        self.is_running = True
+        self.total_frames = total_frames
+        self.current_frame = 0
+        self._on_complete = on_complete
+        self._on_progress = on_progress
+
+        self.worker_thread = threading.Thread(
+            target=self._worker_augment_pose,
+            args=(detections_path, conf_threshold, iou_threshold),
+            daemon=True,
+        )
+        self.worker_thread.start()
+        bpy.app.timers.register(self._check_progress, first_interval=0.1)
+
+    def _worker_augment_pose(
+        self,
+        detections_path: str,
+        conf_threshold: float,
+        iou_threshold: float,
+    ):
+        """client.augment_pose() を呼んで task_id でポーリング。"""
+        import time
+        from .inference_client import get_client
+
+        try:
+            client = get_client()
+            task_id = client.augment_pose(
+                detections_path=detections_path,
+                conf_threshold=conf_threshold,
+                iou_threshold=iou_threshold,
+            )
+
+            while self.is_running:
+                status = client.get_task_status(task_id)
+                state = status.get("status")
+
+                total = status.get("total", 0)
+                if total > 0:
+                    self.total_frames = total
+
+                if state == "completed":
+                    progress = status.get("progress", self.total_frames)
+                    if progress >= 0:
+                        self.progress_queue.put(("progress", progress))
+                    result_path = status.get("result_path", detections_path)
+                    self.result_queue.put(("done", result_path))
+                    return
+                elif state == "failed":
+                    self.result_queue.put(("error", status.get("message", "Unknown error")))
+                    return
+                elif state == "cancelled":
+                    self.result_queue.put(("cancelled", None))
+                    return
+
+                progress = status.get("progress", 0)
+                if progress >= 0:
+                    self.progress_queue.put(("progress", progress))
+                time.sleep(0.5)
+
+            client.cancel_task(task_id)
+            self.result_queue.put(("cancelled", None))
+        except Exception as e:
+            import traceback
+            print(f"[FaceMask] Error: {e}")
+            traceback.print_exc()
+            self.result_queue.put(("error", str(e)))
+
     def cancel(self):
         """Cancel the current processing."""
         self.is_running = False
         if self.worker_thread and self.worker_thread.is_alive():
             self.worker_thread.join(timeout=2.0)
 
+    def _worker_images(
+        self,
+        image_dir: str,
+        filenames: list,
+        output_dir: str,
+        start_index: int,
+        end_index: int,
+        conf_threshold: float,
+        iou_threshold: float,
+    ):
+        import time
+        from .inference_client import get_client
+
+        try:
+            client = get_client()
+            task_id = client.generate_mask_images(
+                image_dir=image_dir,
+                filenames=filenames,
+                output_dir=output_dir,
+                start_index=start_index,
+                end_index=end_index,
+                conf_threshold=conf_threshold,
+                iou_threshold=iou_threshold,
+            )
+            while self.is_running:
+                status = client.get_task_status(task_id)
+                state = status.get("status")
+                total = status.get("total", 0)
+                if total > 0:
+                    self.total_frames = total
+                if state == "completed":
+                    progress = status.get("progress", self.total_frames)
+                    if progress >= 0:
+                        self.progress_queue.put(("progress", progress))
+                    result_path = status.get(
+                        "result_path",
+                        os.path.join(output_dir, "detections.msgpack"),
+                    )
+                    self.result_queue.put(("done", result_path))
+                    return
+                elif state == "failed":
+                    self.result_queue.put(("error", status.get("message", "Unknown error")))
+                    return
+                elif state == "cancelled":
+                    self.result_queue.put(("cancelled", None))
+                    return
+                progress = status.get("progress", 0)
+                if progress >= 0:
+                    self.progress_queue.put(("progress", progress))
+                time.sleep(0.5)
+
+            client.cancel_task(task_id)
+            self.result_queue.put(("cancelled", None))
+        except Exception as e:
+            self.result_queue.put(("error", str(e)))
+
     def _worker(
         self,
         video_path: str,
@@ -122,7 +296,6 @@ class AsyncMaskGenerator:
         fps: float,
         conf_threshold: float,
         iou_threshold: float,
-        mask_scale: float,
     ):
         """
         Worker thread function. Delegates to inference server and polls status.
@@ -134,7 +307,7 @@ class AsyncMaskGenerator:
             client = get_client()
             
             # Start task on server
-            print(f"[FaceMask] Requesting generation on server...")
+            print("[FaceMask] Requesting generation on server...")
             task_id = client.generate_mask(
                 video_path=video_path,
                 output_dir=output_dir,
@@ -142,7 +315,6 @@ class AsyncMaskGenerator:
                 end_frame=end_frame,
                 conf_threshold=conf_threshold,
                 iou_threshold=iou_threshold,
-                mask_scale=mask_scale,
             )
             print(f"[FaceMask] Task started: {task_id}")
             
@@ -151,8 +323,19 @@ class AsyncMaskGenerator:
                 status = client.get_task_status(task_id)
                 state = status.get("status")
 
+                total = status.get("total", 0)
+                if total > 0:
+                    self.total_frames = total
+                
                 if state == "completed":
-                    self.result_queue.put(("done", output_dir))
+                    final_progress = status.get("progress", self.total_frames)
+                    if final_progress >= 0:
+                        self.progress_queue.put(("progress", final_progress))
+                    result_path = status.get(
+                        "result_path",
+                        os.path.join(output_dir, "detections.msgpack"),
+                    )
+                    self.result_queue.put(("done", result_path))
                     return
                 
                 elif state == "failed":
@@ -167,7 +350,7 @@ class AsyncMaskGenerator:
                 
                 # Report progress
                 progress = status.get("progress", 0)
-                if progress > 0:
+                if progress >= 0:
                     self.progress_queue.put(("progress", progress))
                 
                 time.sleep(0.5)
@@ -207,6 +390,16 @@ class AsyncMaskGenerator:
                 msg_type, data = self.result_queue.get_nowait()
                 self.is_running = False
 
+                # Ensure UI receives a final progress update before completion.
+                if (
+                    msg_type == "done"
+                    and self.total_frames > 0
+                    and self.current_frame < self.total_frames
+                    and self._on_progress
+                ):
+                    self.current_frame = self.total_frames
+                    self._on_progress(self.current_frame, self.total_frames)
+                
                 if self._on_complete:
                     self._on_complete(msg_type, data)
                 

core/batch_processor.py

@@ -0,0 +1,280 @@
+"""
+Batch processor for sequential Generate+Bake across multiple VSE strips.
+
+Uses timer-based async chaining so Blender's UI stays responsive.
+"""
+
+from typing import List, Optional, Callable, Any
+
+# Lazy-imported inside Blender
+bpy = None
+
+
+class _DummyOperator:
+    """Dummy operator object for _start_bake_impl calls."""
+
+    def report(self, level, msg):
+        print(f"[FaceMask] Batch: {msg}")
+
+
+class BatchProcessor:
+    """Manages sequential Generate Detection Cache → Bake across a list of strips."""
+
+    def __init__(self):
+        self.is_running: bool = False
+        self._mode: str = "full"  # "full" or "mask_only"
+        self._strip_names: List[str] = []
+        self._current_idx: int = 0
+        self._context: Any = None
+        self._cancelled: bool = False
+        self._results: List[dict] = []
+        self._on_item_complete: Optional[Callable] = None  # (idx, total, name, status)
+        self._on_all_complete: Optional[Callable] = None   # (results)
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def start(self, context, strips, on_item_complete=None, on_all_complete=None, mode="full"):
+        """Start batch processing for the given strips.
+
+        mode:
+          "full"      - マスク生成（キャッシュなければ）→ Bake
+          "mask_only" - キャッシュを無視してマスク生成のみ（Bakeしない）
+        """
+        global bpy
+        import bpy as _bpy
+        bpy = _bpy
+
+        if self.is_running:
+            raise RuntimeError("Batch already running")
+
+        self.is_running = True
+        self._mode = mode
+        self._strip_names = [s.name for s in strips]
+        self._current_idx = 0
+        self._context = context
+        self._cancelled = False
+        self._results = []
+        self._on_item_complete = on_item_complete
+        self._on_all_complete = on_all_complete
+
+        wm = context.window_manager
+        wm.batch_current = 0
+        wm.batch_total = len(self._strip_names)
+        wm.batch_current_name = ""
+
+        bpy.app.timers.register(self._process_next, first_interval=0.0)
+
+    def cancel(self):
+        """Cancel batch. Stops currently running mask gen / bake."""
+        self._cancelled = True
+        from .async_generator import get_generator
+        from .async_bake_generator import get_bake_generator
+        gen = get_generator()
+        bake_gen = get_bake_generator()
+        if gen.is_running:
+            gen.cancel()
+        if bake_gen.is_running:
+            bake_gen.cancel()
+
+    # ------------------------------------------------------------------
+    # Internal: queue stepping
+    # ------------------------------------------------------------------
+
+    def _process_next(self):
+        """Process the next strip in the queue (called via timer)."""
+        if self._cancelled:
+            self._finish()
+            return None
+
+        if self._current_idx >= len(self._strip_names):
+            self._finish()
+            return None
+
+        strip_name = self._strip_names[self._current_idx]
+        seq_editor = self._context.scene.sequence_editor
+        strip = seq_editor.strips.get(strip_name)
+
+        if strip is None:
+            print(f"[FaceMask] Batch: strip not found, skipping: {strip_name}")
+            self._results.append({"strip": strip_name, "status": "skipped"})
+            if self._on_item_complete:
+                self._on_item_complete(self._current_idx, len(self._strip_names), strip_name, "skipped")
+            self._current_idx += 1
+            bpy.app.timers.register(self._process_next, first_interval=0.0)
+            return None
+
+        # Update wm progress labels
+        wm = self._context.window_manager
+        wm.batch_current = self._current_idx + 1
+        wm.batch_current_name = strip_name
+        for area in self._context.screen.areas:
+            if area.type == "SEQUENCE_EDITOR":
+                area.tag_redraw()
+
+        if self._mode == "mask_only":
+            # キャッシュを無視して常にマスク生成（Bakeしない）
+            self._start_mask_gen(strip)
+        else:
+            from .utils import check_detection_cache
+            if not check_detection_cache(strip.name):
+                self._start_mask_gen(strip)
+            else:
+                self._start_bake(strip)
+
+        return None  # one-shot timer
+
+    def _schedule_next(self):
+        bpy.app.timers.register(self._process_next, first_interval=0.0)
+
+    # ------------------------------------------------------------------
+    # Mask generation
+    # ------------------------------------------------------------------
+
+    def _start_mask_gen(self, strip):
+        from ..operators.generate_mask import start_mask_gen_for_strip
+
+        strip_name = strip.name
+
+        def on_complete(status, data):
+            self._on_mask_done(strip_name, status, data)
+
+        def on_progress(current, total):
+            wm = self._context.window_manager
+            wm.mask_progress = current
+            wm.mask_total = max(total, 1)
+            for area in self._context.screen.areas:
+                if area.type == "SEQUENCE_EDITOR":
+                    area.tag_redraw()
+
+        try:
+            start_mask_gen_for_strip(self._context, strip, on_complete, on_progress)
+            print(f"[FaceMask] Batch: started mask gen for {strip_name}")
+        except Exception as e:
+            print(f"[FaceMask] Batch: failed to start mask gen for {strip_name}: {e}")
+            self._on_mask_done(strip_name, "error", str(e))
+
+    def _on_mask_done(self, strip_name, status, data):
+        if self._cancelled or status == "cancelled":
+            self._results.append({"strip": strip_name, "status": "cancelled"})
+            self._finish()
+            return
+
+        if status == "error":
+            print(f"[FaceMask] Batch: mask gen failed for {strip_name}: {data}")
+            self._results.append({"strip": strip_name, "status": "error", "reason": str(data)})
+            if self._on_item_complete:
+                self._on_item_complete(self._current_idx, len(self._strip_names), strip_name, "error")
+            self._current_idx += 1
+            self._schedule_next()
+            return
+
+        # Mask gen succeeded
+        if self._mode == "mask_only":
+            # Bakeしない：結果を記録して次へ
+            self._results.append({"strip": strip_name, "status": "done"})
+            if self._on_item_complete:
+                self._on_item_complete(self._current_idx, len(self._strip_names), strip_name, "done")
+            self._current_idx += 1
+            self._schedule_next()
+            return
+
+        # full mode: proceed to bake
+        seq_editor = self._context.scene.sequence_editor
+        strip = seq_editor.strips.get(strip_name)
+        if strip is None:
+            print(f"[FaceMask] Batch: strip removed after mask gen: {strip_name}")
+            self._results.append({"strip": strip_name, "status": "skipped"})
+            if self._on_item_complete:
+                self._on_item_complete(self._current_idx, len(self._strip_names), strip_name, "skipped")
+            self._current_idx += 1
+            self._schedule_next()
+            return
+
+        self._start_bake(strip)
+
+    # ------------------------------------------------------------------
+    # Bake
+    # ------------------------------------------------------------------
+
+    def _start_bake(self, strip):
+        from .async_bake_generator import get_bake_generator
+        from ..operators.apply_blur import _start_bake_impl
+
+        strip_name = strip.name
+
+        def on_complete_extra(status, data):
+            self._on_bake_done(strip_name, status, data)
+
+        bake_gen = get_bake_generator()
+        result = _start_bake_impl(
+            _DummyOperator(),
+            self._context,
+            force=False,
+            strip=strip,
+            on_complete_extra=on_complete_extra,
+        )
+
+        if result == {"CANCELLED"}:
+            # Error starting bake
+            print(f"[FaceMask] Batch: bake failed to start for {strip_name}")
+            self._results.append({"strip": strip_name, "status": "error", "reason": "bake failed to start"})
+            if self._on_item_complete:
+                self._on_item_complete(self._current_idx, len(self._strip_names), strip_name, "error")
+            self._current_idx += 1
+            self._schedule_next()
+        elif not bake_gen.is_running:
+            # Cache hit: on_complete_extra was NOT called by _start_bake_impl
+            print(f"[FaceMask] Batch: bake cache hit for {strip_name}")
+            self._on_bake_done(strip_name, "done", None)
+
+    def _on_bake_done(self, strip_name, status, data):
+        if self._cancelled or status == "cancelled":
+            self._results.append({"strip": strip_name, "status": "cancelled"})
+            self._finish()
+            return
+
+        if status == "error":
+            print(f"[FaceMask] Batch: bake failed for {strip_name}: {data}")
+            self._results.append({"strip": strip_name, "status": "error", "reason": str(data)})
+        else:
+            self._results.append({"strip": strip_name, "status": "done"})
+            print(f"[FaceMask] Batch: completed {strip_name}")
+
+        if self._on_item_complete:
+            self._on_item_complete(self._current_idx, len(self._strip_names), strip_name, status)
+
+        self._current_idx += 1
+        self._schedule_next()
+
+    # ------------------------------------------------------------------
+    # Finish
+    # ------------------------------------------------------------------
+
+    def _finish(self):
+        self.is_running = False
+        wm = self._context.window_manager
+        wm.batch_current = 0
+        wm.batch_total = 0
+        wm.batch_current_name = ""
+
+        print(f"[FaceMask] Batch: all done. Results: {self._results}")
+
+        if self._on_all_complete:
+            self._on_all_complete(self._results)
+
+        for area in self._context.screen.areas:
+            if area.type == "SEQUENCE_EDITOR":
+                area.tag_redraw()
+
+
+# Singleton
+_batch_processor: Optional[BatchProcessor] = None
+
+
+def get_batch_processor() -> BatchProcessor:
+    global _batch_processor
+    if _batch_processor is None:
+        _batch_processor = BatchProcessor()
+    return _batch_processor

core/compositor_setup.py

@@ -5,13 +5,10 @@ Creates and manages compositing node trees that apply blur
 only to masked regions of a video strip.
 """
 
-from typing import Optional, Tuple
-
-
 def create_mask_blur_node_tree(
     name: str = "FaceMaskBlur",
     blur_size: int = 50,
-) -> "bpy.types.NodeTree":
+) -> "bpy.types.NodeTree":  # noqa: F821
     """
     Create a compositing node tree for mask-based blur.
     
@@ -110,10 +107,10 @@ def create_mask_blur_node_tree(
 
 
 def setup_strip_compositor_modifier(
-    strip: "bpy.types.Strip",
-    mask_strip: "bpy.types.Strip",
-    node_tree: "bpy.types.NodeTree",
-) -> "bpy.types.SequenceModifier":
+    strip: "bpy.types.Strip",  # noqa: F821
+    mask_strip: "bpy.types.Strip",  # noqa: F821
+    node_tree: "bpy.types.NodeTree",  # noqa: F821
+) -> "bpy.types.SequenceModifier":  # noqa: F821
     """
     Add a Compositor modifier to a strip using the mask-blur node tree.
     
@@ -125,8 +122,6 @@ def setup_strip_compositor_modifier(
     Returns:
         The created modifier
     """
-    import bpy
-    
     # Add compositor modifier
     modifier = strip.modifiers.new(
         name="FaceMaskBlur",
@@ -153,7 +148,7 @@ def setup_strip_compositor_modifier(
     return modifier
 
 
-def get_or_create_blur_node_tree(blur_size: int = 50) -> "bpy.types.NodeTree":
+def get_or_create_blur_node_tree(blur_size: int = 50) -> "bpy.types.NodeTree":  # noqa: F821
     """
     Get existing or create new blur node tree with specified blur size.
     

core/inference_client.py

@@ -5,15 +5,16 @@ Manages the server process and handles HTTP communication
 using standard library (avoiding requests dependency).
 """
 
-import subprocess
-import time
 import json
-import urllib.request
-import urllib.error
-import threading
 import os
 import signal
-from typing import Optional, Dict, Any, Tuple
+import subprocess
+import sys
+import threading
+import time
+import urllib.error
+import urllib.request
+from typing import Any, Dict, Optional
 
 
 class InferenceClient:
@@ -46,24 +47,24 @@ class InferenceClient:
             # Load environment variables from .env file if it exists
             env_file = os.path.join(root_dir, ".env")
             if os.path.exists(env_file):
-                with open(env_file, 'r') as f:
+                with open(env_file, "r") as f:
                     for line in f:
                         line = line.strip()
-                        if line and not line.startswith('#') and '=' in line:
-                            key, value = line.split('=', 1)
+                        if line and not line.startswith("#") and "=" in line:
+                            key, value = line.split("=", 1)
                             server_env[key] = value
                 print(f"[FaceMask] Loaded environment from: {env_file}")
 
             # Clean PYTHONPATH to avoid conflicts with Nix Python packages
             # Only include project root to allow local imports
-            server_env['PYTHONPATH'] = root_dir
+            server_env["PYTHONPATH"] = root_dir
 
             # Remove Python-related environment variables that might cause conflicts
             # These can cause venv to import packages from Nix instead of venv
             env_vars_to_remove = [
-                'PYTHONUNBUFFERED',
-                '__PYVENV_LAUNCHER__',  # macOS venv variable
-                'VIRTUAL_ENV',  # Will be set by venv's Python automatically
+                "PYTHONUNBUFFERED",
+                "__PYVENV_LAUNCHER__",  # macOS venv variable
+                "VIRTUAL_ENV",  # Will be set by venv's Python automatically
             ]
             for var in env_vars_to_remove:
                 server_env.pop(var, None)
@@ -73,30 +74,39 @@ class InferenceClient:
             if os.path.isdir(venv_bin):
                 # Build a clean PATH with venv first, then essential system paths
                 # Filter out any Nix Python-specific paths to avoid version conflicts
-                current_path = server_env.get('PATH', '')
-                path_entries = current_path.split(':')
+                current_path = server_env.get("PATH", "")
+                path_entries = current_path.split(":")
 
                 # Filter out Nix Python 3.11 paths
                 filtered_paths = [
-                    p for p in path_entries
-                    if not ('/python3.11/' in p.lower() or '/python3-3.11' in p.lower())
+                    p
+                    for p in path_entries
+                    if not ("/python3.11/" in p.lower() or "/python3-3.11" in p.lower())
                 ]
 
                 # Reconstruct PATH with venv first
-                clean_path = ':'.join([venv_bin] + filtered_paths)
-                server_env['PATH'] = clean_path
+                clean_path = ":".join([venv_bin] + filtered_paths)
+                server_env["PATH"] = clean_path
                 print(f"[FaceMask] Using venv from: {venv_bin}")
 
             # Prepare log file for server output
             import tempfile
+
             log_dir = tempfile.gettempdir()
             self.log_file_path = os.path.join(log_dir, "facemask_server.log")
-            self.log_file = open(self.log_file_path, 'w', buffering=1)  # Line buffered
+            self.log_file = open(self.log_file_path, "w", buffering=1)  # Line buffered
             print(f"[FaceMask] Server log: {self.log_file_path}")
 
-            # Start process with 'python' command (will use venv if PATH is set correctly)
+            # Start server with explicit Python executable when available.
+            python_executable = "python"
+            venv_python = os.path.join(venv_bin, "python")
+            if os.path.isfile(venv_python):
+                python_executable = venv_python
+            else:
+                python_executable = sys.executable
+
             self.server_process = subprocess.Popen(
-                ["python", "-u", server_script],  # -u for unbuffered output
+                [python_executable, "-u", server_script],  # -u for unbuffered output
                 cwd=root_dir,
                 text=True,
                 env=server_env,
@@ -120,12 +130,12 @@ class InferenceClient:
                     try:
                         if self.log_file:
                             self.log_file.close()
-                        with open(self.log_file_path, 'r') as f:
+                        with open(self.log_file_path, "r") as f:
                             log_content = f.read()
                             if log_content.strip():
                                 print("[FaceMask] Server log:")
                                 # Show last 50 lines
-                                lines = log_content.strip().split('\n')
+                                lines = log_content.strip().split("\n")
                                 for line in lines[-50:]:
                                     print(line)
                     except Exception as e:
@@ -143,11 +153,11 @@ class InferenceClient:
             try:
                 if self.log_file:
                     self.log_file.close()
-                with open(self.log_file_path, 'r') as f:
+                with open(self.log_file_path, "r") as f:
                     log_content = f.read()
                     if log_content.strip():
                         print("[FaceMask] Server log (partial):")
-                        lines = log_content.strip().split('\n')
+                        lines = log_content.strip().split("\n")
                         for line in lines[-30:]:
                             print(line)
             except Exception:
@@ -179,7 +189,9 @@ class InferenceClient:
     def is_server_running(self) -> bool:
         """Check if server is responding."""
         try:
-            with urllib.request.urlopen(f"{self.SERVER_URL}/status", timeout=1) as response:
+            with urllib.request.urlopen(
+                f"{self.SERVER_URL}/status", timeout=1
+            ) as response:
                 return response.status == 200
         except (urllib.error.URLError, ConnectionRefusedError, TimeoutError):
             return False
@@ -192,7 +204,6 @@ class InferenceClient:
         end_frame: int,
         conf_threshold: float,
         iou_threshold: float,
-        mask_scale: float,
     ) -> str:
         """
         Request mask generation.
@@ -210,37 +221,195 @@ class InferenceClient:
             "end_frame": end_frame,
             "conf_threshold": conf_threshold,
             "iou_threshold": iou_threshold,
-            "mask_scale": mask_scale,
         }
 
         req = urllib.request.Request(
             f"{self.SERVER_URL}/generate",
-            data=json.dumps(data).encode('utf-8'),
-            headers={'Content-Type': 'application/json'},
-            method='POST'
+            data=json.dumps(data).encode("utf-8"),
+            headers={"Content-Type": "application/json"},
+            method="POST",
         )
 
         try:
             with urllib.request.urlopen(req) as response:
-                result = json.loads(response.read().decode('utf-8'))
-                return result['id']
+                result = json.loads(response.read().decode("utf-8"))
+                return result["id"]
+        except urllib.error.HTTPError as e:
+            raise RuntimeError(f"Server error: {e.read().decode('utf-8')}")
+
+    def augment_pose(
+        self,
+        detections_path: str,
+        conf_threshold: float,
+        iou_threshold: float,
+    ) -> str:
+        """既存キャッシュに pose 推定結果を追加合成する。task_id を返す。"""
+        if not self.is_server_running():
+            self.start_server()
+
+        data = {
+            "detections_path": detections_path,
+            "conf_threshold": conf_threshold,
+            "iou_threshold": iou_threshold,
+        }
+
+        req = urllib.request.Request(
+            f"{self.SERVER_URL}/augment_pose",
+            data=json.dumps(data).encode("utf-8"),
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+
+        try:
+            with urllib.request.urlopen(req) as response:
+                result = json.loads(response.read().decode("utf-8"))
+                return result["id"]
         except urllib.error.HTTPError as e:
             raise RuntimeError(f"Server error: {e.read().decode('utf-8')}")
 
     def get_task_status(self, task_id: str) -> Dict[str, Any]:
         """Get status of a task."""
         try:
-            with urllib.request.urlopen(f"{self.SERVER_URL}/tasks/{task_id}") as response:
-                return json.loads(response.read().decode('utf-8'))
+            with urllib.request.urlopen(
+                f"{self.SERVER_URL}/tasks/{task_id}"
+            ) as response:
+                return json.loads(response.read().decode("utf-8"))
         except urllib.error.HTTPError:
             return {"status": "unknown"}
 
+    def get_video_info(self, video_path: str) -> Dict[str, Any]:
+        """Get video metadata from the inference server."""
+        if not self.is_server_running():
+            self.start_server()
+
+        req = urllib.request.Request(
+            f"{self.SERVER_URL}/video_info",
+            data=json.dumps({"video_path": video_path}).encode("utf-8"),
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        try:
+            with urllib.request.urlopen(req) as response:
+                return json.loads(response.read().decode("utf-8"))
+        except urllib.error.HTTPError as e:
+            raise RuntimeError(f"Server error: {e.read().decode('utf-8')}")
+
+    def bake_blur(
+        self,
+        video_path: str,
+        detections_path: str,
+        output_path: str,
+        blur_size: int,
+        display_scale: float,
+        fmt: str,
+    ) -> str:
+        """
+        Request blur bake for a source video + mask video.
+
+        Returns:
+            task_id (str)
+        """
+        if not self.is_server_running():
+            self.start_server()
+
+        data = {
+            "video_path": video_path,
+            "detections_path": detections_path,
+            "output_path": output_path,
+            "blur_size": blur_size,
+            "display_scale": display_scale,
+            "format": fmt,
+        }
+
+        req = urllib.request.Request(
+            f"{self.SERVER_URL}/bake_blur",
+            data=json.dumps(data).encode("utf-8"),
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+
+        try:
+            with urllib.request.urlopen(req) as response:
+                result = json.loads(response.read().decode("utf-8"))
+                return result["id"]
+        except urllib.error.HTTPError as e:
+            raise RuntimeError(f"Server error: {e.read().decode('utf-8')}")
+
+    def generate_mask_images(
+        self,
+        image_dir: str,
+        filenames: list,
+        output_dir: str,
+        start_index: int,
+        end_index: int,
+        conf_threshold: float,
+        iou_threshold: float,
+    ) -> str:
+        """画像シーケンスの顔検出タスクを開始して task_id を返す。"""
+        if not self.is_server_running():
+            self.start_server()
+
+        data = {
+            "image_dir": image_dir,
+            "filenames": filenames,
+            "output_dir": output_dir,
+            "start_index": start_index,
+            "end_index": end_index,
+            "conf_threshold": conf_threshold,
+            "iou_threshold": iou_threshold,
+        }
+        req = urllib.request.Request(
+            f"{self.SERVER_URL}/generate_images",
+            data=json.dumps(data).encode("utf-8"),
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        try:
+            with urllib.request.urlopen(req) as response:
+                result = json.loads(response.read().decode("utf-8"))
+                return result["id"]
+        except urllib.error.HTTPError as e:
+            raise RuntimeError(f"Server error: {e.read().decode('utf-8')}")
+
+    def bake_image_blur(
+        self,
+        image_dir: str,
+        filenames: list,
+        output_dir: str,
+        detections_path: str,
+        blur_size: int,
+        display_scale: float,
+    ) -> str:
+        """画像シーケンスのぼかしBakeタスクを開始して task_id を返す。"""
+        if not self.is_server_running():
+            self.start_server()
+
+        data = {
+            "image_dir": image_dir,
+            "filenames": filenames,
+            "output_dir": output_dir,
+            "detections_path": detections_path,
+            "blur_size": blur_size,
+            "display_scale": display_scale,
+        }
+        req = urllib.request.Request(
+            f"{self.SERVER_URL}/bake_image_blur",
+            data=json.dumps(data).encode("utf-8"),
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        try:
+            with urllib.request.urlopen(req) as response:
+                result = json.loads(response.read().decode("utf-8"))
+                return result["id"]
+        except urllib.error.HTTPError as e:
+            raise RuntimeError(f"Server error: {e.read().decode('utf-8')}")
+
     def cancel_task(self, task_id: str):
         """Cancel a task."""
         try:
             req = urllib.request.Request(
-                f"{self.SERVER_URL}/tasks/{task_id}/cancel",
-                method='POST'
+                f"{self.SERVER_URL}/tasks/{task_id}/cancel", method="POST"
             )
             with urllib.request.urlopen(req):
                 pass
@@ -251,6 +420,7 @@ class InferenceClient:
 # Singleton
 _client: Optional[InferenceClient] = None
 
+
 def get_client() -> InferenceClient:
     global _client
     if _client is None:

core/utils.py

@@ -0,0 +1,141 @@
+"""
+Utility functions for Face Mask extension.
+
+Provides helper functions for server status, cache info, etc.
+"""
+
+import os
+import urllib.request
+import urllib.error
+import json
+import tempfile
+from typing import Dict, Tuple, Optional
+
+
+def get_server_status() -> Dict:
+    """
+    Get server status and GPU information.
+
+    Returns:
+        dict: {
+            'running': bool,
+            'gpu_available': bool,
+            'gpu_device': str or None,
+            'gpu_count': int,
+            'rocm_version': str or None,
+        }
+    """
+    result = {
+        'running': False,
+        'gpu_available': False,
+        'gpu_device': None,
+        'gpu_count': 0,
+        'rocm_version': None,
+    }
+
+    try:
+        with urllib.request.urlopen("http://127.0.0.1:8181/status", timeout=1) as response:
+            data = json.loads(response.read().decode('utf-8'))
+            result['running'] = data.get('status') == 'running'
+            result['gpu_available'] = data.get('gpu_available', False)
+            result['gpu_device'] = data.get('gpu_device')
+            result['gpu_count'] = data.get('gpu_count', 0)
+            result['rocm_version'] = data.get('rocm_version')
+    except (urllib.error.URLError, ConnectionRefusedError, TimeoutError):
+        result['running'] = False
+
+    return result
+
+
+def get_cache_root() -> str:
+    """
+    Resolve cache root directory from scene setting or defaults.
+
+    Priority:
+    1) Scene setting: facemask_cache_dir (if non-empty)
+    2) Saved blend file directory + .mask_cache
+    3) Temp directory + blender_mask_cache
+    """
+    import bpy
+
+    scene = getattr(bpy.context, "scene", None)
+    cache_setting = ""
+    if scene is not None:
+        cache_setting = (getattr(scene, "facemask_cache_dir", "") or "").strip()
+
+    if cache_setting:
+        return bpy.path.abspath(cache_setting)
+
+    blend_file = bpy.data.filepath
+    if blend_file:
+        project_dir = os.path.dirname(blend_file)
+        return os.path.join(project_dir, ".mask_cache")
+    return os.path.join(tempfile.gettempdir(), "blender_mask_cache")
+
+
+def get_cache_dir_for_strip(strip_name: str) -> str:
+    """Get cache directory path for a specific strip."""
+    return os.path.join(get_cache_root(), strip_name)
+
+
+def get_detections_path_for_strip(strip_name: str) -> str:
+    """Get msgpack detection cache path for a specific strip."""
+    return os.path.join(get_cache_dir_for_strip(strip_name), "detections.msgpack")
+
+
+def check_detection_cache(strip_name: str) -> bool:
+    """Detection cache ファイルが存在し有効かどうか確認する。"""
+    path = get_detections_path_for_strip(strip_name)
+    try:
+        return os.path.exists(path) and os.path.getsize(path) > 0
+    except OSError:
+        return False
+
+
+def get_cache_info(strip_name: Optional[str] = None) -> Tuple[str, int, int]:
+    """
+    Get cache directory information.
+
+    Args:
+        strip_name: If provided, get info for specific strip. Otherwise, get info for all cache.
+
+    Returns:
+        Tuple of (cache_path, total_size_bytes, file_count)
+    """
+    if strip_name:
+        cache_path = get_cache_dir_for_strip(strip_name)
+    else:
+        cache_path = get_cache_root()
+
+    # Calculate size and count
+    total_size = 0
+    file_count = 0
+
+    if os.path.exists(cache_path):
+        for root, dirs, files in os.walk(cache_path):
+            for file in files:
+                file_path = os.path.join(root, file)
+                try:
+                    total_size += os.path.getsize(file_path)
+                    file_count += 1
+                except OSError:
+                    pass
+
+    return cache_path, total_size, file_count
+
+
+def format_size(size_bytes: int) -> str:
+    """
+    Format bytes to human-readable size.
+
+    Args:
+        size_bytes: Size in bytes
+
+    Returns:
+        Formatted string (e.g., "1.5 MB")
+    """
+    for unit in ['B', 'KB', 'MB', 'GB']:
+        if size_bytes < 1024.0:
+            return f"{size_bytes:.1f} {unit}"
+        size_bytes /= 1024.0
+    return f"{size_bytes:.1f} TB"

debug_detector.py

@@ -1,267 +0,0 @@
-#!/usr/bin/env python3
-"""
-顔検出処理の単体デバッグスクリプト
-
-Usage:
-    # 画像ファイルで検出をテスト
-    python debug_detector.py --image path/to/image.jpg
-
-    # 動画ファイルで検出をテスト（指定フレームのみ）
-    python debug_detector.py --video path/to/video.mp4 --frame 100
-
-    # 動画ファイルで複数フレームをテスト
-    python debug_detector.py --video path/to/video.mp4 --start 0 --end 10
-
-    # 結果を保存
-    python debug_detector.py --image test.jpg --output result.jpg
-"""
-
-import argparse
-import sys
-from pathlib import Path
-import cv2
-import numpy as np
-
-# プロジェクトルートをパスに追加
-project_root = Path(__file__).parent
-sys.path.insert(0, str(project_root))
-
-from server.detector import YOLOFaceDetector
-
-
-def draw_detections(image: np.ndarray, detections, mask=None):
-    """
-    検出結果を画像に描画
-
-    Args:
-        image: 元画像（BGR）
-        detections: 検出結果のリスト [(x, y, w, h, conf), ...]
-        mask: マスク画像（オプション）
-
-    Returns:
-        描画済み画像
-    """
-    output = image.copy()
-
-    # マスクをオーバーレイ
-    if mask is not None:
-        # マスクを3チャンネルに変換
-        mask_colored = cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR)
-        # 赤色でオーバーレイ（半透明）
-        mask_overlay = np.zeros_like(output)
-        mask_overlay[:, :, 2] = mask  # 赤チャンネル
-        output = cv2.addWeighted(output, 1.0, mask_overlay, 0.3, 0)
-
-    # バウンディングボックスを描画
-    for (x, y, w, h, conf) in detections:
-        # ボックス
-        cv2.rectangle(output, (x, y), (x + w, y + h), (0, 255, 0), 2)
-
-        # 信頼度テキスト
-        label = f"{conf:.2f}"
-        label_size, baseline = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)
-        y_label = max(y, label_size[1])
-        cv2.rectangle(
-            output,
-            (x, y_label - label_size[1]),
-            (x + label_size[0], y_label + baseline),
-            (0, 255, 0),
-            -1
-        )
-        cv2.putText(
-            output,
-            label,
-            (x, y_label),
-            cv2.FONT_HERSHEY_SIMPLEX,
-            0.5,
-            (0, 0, 0),
-            1
-        )
-
-    return output
-
-
-def debug_image(args, detector):
-    """画像ファイルで検出をデバッグ"""
-    print(f"画像を読み込み中: {args.image}")
-    image = cv2.imread(args.image)
-
-    if image is None:
-        print(f"エラー: 画像を読み込めません: {args.image}")
-        return
-
-    print(f"画像サイズ: {image.shape[1]}x{image.shape[0]}")
-
-    # 検出実行
-    print("顔検出を実行中...")
-    detections = detector.detect(image)
-
-    print(f"\n検出結果: {len(detections)}個の顔を検出")
-    for i, (x, y, w, h, conf) in enumerate(detections):
-        print(f"  [{i+1}] x={x}, y={y}, w={w}, h={h}, conf={conf:.3f}")
-
-    # マスク生成
-    if len(detections) > 0:
-        mask = detector.generate_mask(
-            image.shape,
-            detections,
-            mask_scale=args.mask_scale,
-            feather_radius=args.feather_radius
-        )
-    else:
-        mask = None
-
-    # 結果を描画
-    result = draw_detections(image, detections, mask)
-
-    # 表示または保存
-    if args.output:
-        cv2.imwrite(args.output, result)
-        print(f"\n結果を保存しました: {args.output}")
-
-        if mask is not None and args.save_mask:
-            mask_path = args.output.replace('.', '_mask.')
-            cv2.imwrite(mask_path, mask)
-            print(f"マスクを保存しました: {mask_path}")
-    else:
-        cv2.imshow("Detection Result", result)
-        if mask is not None:
-            cv2.imshow("Mask", mask)
-        print("\nキーを押して終了してください...")
-        cv2.waitKey(0)
-        cv2.destroyAllWindows()
-
-
-def debug_video(args, detector):
-    """動画ファイルで検出をデバッグ"""
-    print(f"動画を読み込み中: {args.video}")
-    cap = cv2.VideoCapture(args.video)
-
-    if not cap.isOpened():
-        print(f"エラー: 動画を開けません: {args.video}")
-        return
-
-    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-    fps = cap.get(cv2.CAP_PROP_FPS)
-    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-
-    print(f"動画情報: {width}x{height}, {fps:.2f}fps, {total_frames}フレーム")
-
-    # フレーム範囲の決定
-    start_frame = args.start if args.start is not None else args.frame
-    end_frame = args.end if args.end is not None else args.frame
-
-    start_frame = max(0, min(start_frame, total_frames - 1))
-    end_frame = max(0, min(end_frame, total_frames - 1))
-
-    print(f"処理範囲: フレーム {start_frame} - {end_frame}")
-
-    # 出力動画の準備
-    out_writer = None
-    if args.output:
-        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-        out_writer = cv2.VideoWriter(args.output, fourcc, fps, (width, height))
-
-    # フレーム処理
-    for frame_idx in range(start_frame, end_frame + 1):
-        cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
-        ret, frame = cap.read()
-
-        if not ret:
-            print(f"警告: フレーム {frame_idx} を読み込めませんでした")
-            continue
-
-        # 検出実行
-        detections = detector.detect(frame)
-
-        # マスク生成
-        if len(detections) > 0:
-            mask = detector.generate_mask(
-                frame.shape,
-                detections,
-                mask_scale=args.mask_scale,
-                feather_radius=args.feather_radius
-            )
-        else:
-            mask = None
-
-        # 結果を描画
-        result = draw_detections(frame, detections, mask)
-
-        print(f"フレーム {frame_idx}: {len(detections)}個の顔を検出")
-
-        # 保存または表示
-        if out_writer:
-            out_writer.write(result)
-        else:
-            cv2.imshow(f"Frame {frame_idx}", result)
-            if mask is not None:
-                cv2.imshow("Mask", mask)
-
-            key = cv2.waitKey(0 if end_frame == start_frame else 30)
-            if key == ord('q'):
-                break
-
-    cap.release()
-    if out_writer:
-        out_writer.release()
-        print(f"\n結果を保存しました: {args.output}")
-    else:
-        cv2.destroyAllWindows()
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="顔検出処理の単体デバッグスクリプト",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog=__doc__
-    )
-
-    # 入力ソース
-    input_group = parser.add_mutually_exclusive_group(required=True)
-    input_group.add_argument("--image", type=str, help="テスト用画像ファイル")
-    input_group.add_argument("--video", type=str, help="テスト用動画ファイル")
-
-    # 動画用オプション
-    parser.add_argument("--frame", type=int, default=0, help="処理する動画フレーム番号（デフォルト: 0）")
-    parser.add_argument("--start", type=int, help="処理開始フレーム（動画のみ）")
-    parser.add_argument("--end", type=int, help="処理終了フレーム（動画のみ）")
-
-    # 検出パラメータ
-    parser.add_argument("--conf", type=float, default=0.5, help="信頼度閾値（デフォルト: 0.5）")
-    parser.add_argument("--iou", type=float, default=0.45, help="NMS IoU閾値（デフォルト: 0.45）")
-    parser.add_argument("--mask-scale", type=float, default=1.5, help="マスクスケール（デフォルト: 1.5）")
-    parser.add_argument("--feather-radius", type=int, default=20, help="マスクぼかし半径（デフォルト: 20）")
-
-    # 出力オプション
-    parser.add_argument("--output", "-o", type=str, help="結果画像/動画の保存先")
-    parser.add_argument("--save-mask", action="store_true", help="マスク画像も保存する（画像のみ）")
-
-    # モデル
-    parser.add_argument("--model", type=str, help="カスタムモデルパス")
-
-    args = parser.parse_args()
-
-    # 検出器を初期化
-    print("YOLOFaceDetectorを初期化中...")
-    detector = YOLOFaceDetector(
-        model_path=args.model,
-        conf_threshold=args.conf,
-        iou_threshold=args.iou
-    )
-
-    # モデルを事前ロード
-    print("モデルをロード中...")
-    _ = detector.model
-    print("準備完了\n")
-
-    # デバッグ実行
-    if args.image:
-        debug_image(args, detector)
-    else:
-        debug_video(args, detector)
-
-
-if __name__ == "__main__":
-    main()

docs/debugging.md

@@ -1,151 +0,0 @@
-# デバッグガイド
-
-## 処理プロセスの単体デバッグ
-
-顔検出処理をBlenderアドオンから独立してテストできます。
-
-### セットアップ
-
-```bash
-# 仮想環境をアクティベート
-source .venv/bin/activate
-
-# 必要なパッケージがインストールされていることを確認
-pip install ultralytics opencv-python torch
-```
-
-### 基本的な使い方
-
-#### 画像ファイルで検出をテスト
-
-```bash
-# 検出結果を画面に表示
-python debug_detector.py --image path/to/image.jpg
-
-# 検出結果を保存
-python debug_detector.py --image path/to/image.jpg --output result.jpg
-
-# マスク画像も保存
-python debug_detector.py --image path/to/image.jpg --output result.jpg --save-mask
-```
-
-#### 動画ファイルで検出をテスト
-
-```bash
-# 特定のフレームをテスト
-python debug_detector.py --video path/to/video.mp4 --frame 100
-
-# フレーム範囲をテスト（画面表示）
-python debug_detector.py --video path/to/video.mp4 --start 0 --end 10
-
-# フレーム範囲を処理して動画保存
-python debug_detector.py --video path/to/video.mp4 --start 0 --end 100 --output result.mp4
-```
-
-### パラメータ調整
-
-```bash
-# 信頼度閾値を調整（デフォルト: 0.5）
-python debug_detector.py --image test.jpg --conf 0.3
-
-# NMS IoU閾値を調整（デフォルト: 0.45）
-python debug_detector.py --image test.jpg --iou 0.5
-
-# マスクサイズを調整（デフォルト: 1.5）
-python debug_detector.py --image test.jpg --mask-scale 2.0
-
-# マスクのぼかし半径を調整（デフォルト: 20）
-python debug_detector.py --image test.jpg --feather-radius 30
-```
-
-### カスタムモデルの使用
-
-```bash
-python debug_detector.py --image test.jpg --model path/to/custom_model.pt
-```
-
-## 推論サーバーの単体起動
-
-推論サーバーを単独で起動してテストすることもできます。
-
-### サーバー起動
-
-```bash
-# 仮想環境をアクティベート
-source .venv/bin/activate
-
-# サーバーを起動（ポート8181）
-python server/main.py
-```
-
-### APIテスト
-
-別のターミナルで：
-
-```bash
-# サーバー状態を確認
-curl http://127.0.0.1:8181/status
-
-# マスク生成をリクエスト
-curl -X POST http://127.0.0.1:8181/generate \
-  -H "Content-Type: application/json" \
-  -d '{
-    "video_path": "/path/to/video.mp4",
-    "output_dir": "/tmp/masks",
-    "start_frame": 0,
-    "end_frame": 10,
-    "conf_threshold": 0.5,
-    "iou_threshold": 0.45,
-    "mask_scale": 1.5
-  }'
-
-# タスクの状態を確認（task_idは上記レスポンスから取得）
-curl http://127.0.0.1:8181/tasks/{task_id}
-
-# タスクをキャンセル
-curl -X POST http://127.0.0.1:8181/tasks/{task_id}/cancel
-```
-
-## トラブルシューティング
-
-### GPU（ROCm）が認識されない
-
-```bash
-# PyTorchがROCmを認識しているか確認
-python -c "import torch; print(f'CUDA available: {torch.cuda.is_available()}')"
-
-# ROCm環境変数を確認
-echo $ROCM_PATH
-echo $HSA_OVERRIDE_GFX_VERSION
-```
-
-環境変数が設定されていない場合：
-
-```bash
-source .envrc
-# または
-eval "$(direnv export bash)"
-```
-
-### モデルが見つからない
-
-デフォルトモデルは `models/yolov8n-face-lindevs.pt` に配置する必要があります。
-
-```bash
-ls -l models/yolov8n-face-lindevs.pt
-```
-
-### メモリ不足エラー
-
-大きな動画を処理する場合、メモリ不足になる可能性があります：
-
-- フレーム範囲を小さく分割して処理
-- `--conf` 閾値を上げて検出数を減らす
-- より小さいモデルを使用
-
-## デバッグのベストプラクティス
-
-1. **まず画像でテスト**: 動画よりも画像の方が早く結果を確認できます
-2. **パラメータの影響を理解**: `--conf`、`--mask-scale` などを変えて結果を比較
-3. **小さいフレーム範囲から始める**: 動画テストは最初は5-10フレーム程度で
-4. **結果を保存して比較**: `--output` オプションで結果を保存し、パラメータごとに比較

flake.nix

@@ -48,8 +48,8 @@
             export ROCM_PATH="${pkgs.rocmPackages.clr}"
             export HSA_OVERRIDE_GFX_VERSION="11.0.0"  # RX 7900 (RDNA 3 / gfx1100)
 
-            # LD_LIBRARY_PATH: ROCm、C++標準ライブラリ、その他必要なライブラリ
-            export LD_LIBRARY_PATH="${pkgs.stdenv.cc.cc.lib}/lib:${pkgs.zlib}/lib:${pkgs.zstd.out}/lib:${pkgs.rocmPackages.clr}/lib:${pkgs.rocmPackages.rocm-runtime}/lib:$LD_LIBRARY_PATH"
+            # LD_LIBRARY_PATH: ROCm libraries FIRST (critical for GPU inference)
+            export LD_LIBRARY_PATH="${pkgs.rocmPackages.clr}/lib:${pkgs.rocmPackages.rocm-runtime}/lib:${pkgs.stdenv.cc.cc.lib}/lib:${pkgs.zlib}/lib:${pkgs.zstd.out}/lib:$LD_LIBRARY_PATH"
 
             # venvのセットアップ
             VENV_DIR="$PWD/.venv"
@@ -61,24 +61,22 @@
             # venvをアクティベート
             source "$VENV_DIR/bin/activate"
 
-            # 必要なパッケージのインストール確認とインストール
+            # PyTorch ROCm版の導入（GPU未認識時のみ）
             if ! python -c "import torch; print(torch.cuda.is_available())" 2>/dev/null | grep -q "True"; then
-              echo "[Setup] Installing Python dependencies..."
-              # まずPyTorch ROCm版をインストール（ROCm 7.0 nightly - ROCm 7.1.1環境で動作確認済み）
+              echo "[Setup] Installing PyTorch ROCm dependencies..."
               pip install --quiet --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/rocm7.0
-              # 次に通常のPyPIから他のパッケージをインストール
-              pip install --quiet \
-                ultralytics \
-                opencv-python-headless \
-                numpy \
-                fastapi \
-                uvicorn \
-                pydantic
-              # opencv-pythonがインストールされていたら削除（headless版のみ使用）
-              pip uninstall -y opencv-python opencv 2>/dev/null || true
-              # opencv-python-headlessを再インストールして確実にする
-              pip install --quiet --force-reinstall opencv-python-headless
-              echo "[Setup] Dependencies installed successfully"
+            fi
+
+            # プロジェクト依存（requirements.txt）を同期
+            if [ -f "$PWD/requirements.txt" ]; then
+              echo "[Setup] Syncing Python dependencies from requirements.txt..."
+              pip install --quiet -r "$PWD/requirements.txt"
+            fi
+
+            # OpenCVは壊れやすいので、import失敗時のみheadlessを強制再導入
+            if ! python -c "import cv2" >/dev/null 2>&1; then
+              echo "[Setup] Repairing OpenCV (opencv-python-headless)..."
+              pip install --quiet --force-reinstall --no-cache-dir opencv-python-headless
             fi
 
             # Pythonパスにカレントディレクトリを追加
@@ -89,12 +87,11 @@
             export BLENDER_USER_ADDONS="$BLENDER_USER_SCRIPTS/addons"
 
             # 環境変数をファイルに保存（サーバープロセス用）
+            # CRITICAL: ROCm library paths MUST come first for GPU inference
             cat > "$PWD/.env" << EOF
-LD_LIBRARY_PATH=${pkgs.stdenv.cc.cc.lib}/lib:${pkgs.zlib}/lib:${pkgs.zstd.out}/lib:${pkgs.rocmPackages.clr}/lib:${pkgs.rocmPackages.rocm-runtime}/lib
+LD_LIBRARY_PATH=${pkgs.rocmPackages.clr}/lib:${pkgs.rocmPackages.rocm-runtime}/lib:${pkgs.stdenv.cc.cc.lib}/lib:${pkgs.zlib}/lib:${pkgs.zstd.out}/lib
 ROCM_PATH=${pkgs.rocmPackages.clr}
 HSA_OVERRIDE_GFX_VERSION=11.0.0
-PYTORCH_ROCM_ARCH=gfx1100
-ROCBLAS_TENSILE_LIBPATH=${pkgs.rocmPackages.clr}/lib/rocblas/library
 EOF
 
             echo "[Setup] Environment ready with GPU support"

operators/__init__.py

@@ -2,13 +2,19 @@
 
 from . import generate_mask
 from . import apply_blur
+from . import clear_cache
+from . import batch_bake
 
 
 def register():
     generate_mask.register()
     apply_blur.register()
+    clear_cache.register()
+    batch_bake.register()
 
 
 def unregister():
+    batch_bake.unregister()
+    clear_cache.unregister()
     apply_blur.unregister()
     generate_mask.unregister()

operators/apply_blur.py

@@ -1,242 +1,359 @@
 """
-Apply Blur Operator for masked face blur in VSE.
+Bake-and-swap blur operators for VSE.
 
-Provides operators to apply blur effects using mask strips
-generated by the face detection operators.
+This module bakes masked blur into a regular video file using the inference
+server, then swaps the active strip's source filepath to the baked result.
 """
 
+import os
 import bpy
-from bpy.props import FloatProperty, IntProperty, StringProperty
+from bpy.props import IntProperty
 from bpy.types import Operator
 
+from ..core.async_bake_generator import get_bake_generator
+from ..core.async_generator import get_generator as get_mask_generator
+from ..core.utils import get_detections_path_for_strip
 
-class SEQUENCER_OT_apply_mask_blur(Operator):
-    """Apply blur effect using mask strip."""
 
-    bl_idname = "sequencer.apply_mask_blur"
-    bl_label = "Apply Mask Blur"
-    bl_description = "Apply blur effect to video using mask strip"
-    bl_options = {'REGISTER', 'UNDO'}
+KEY_ORIGINAL = "facemask_original_filepath"
+KEY_BAKED = "facemask_baked_filepath"
+KEY_MODE = "facemask_source_mode"
+KEY_FORMAT = "facemask_bake_format"
+KEY_BLUR_SIZE = "facemask_bake_blur_size"
+KEY_DISPLAY_SCALE = "facemask_bake_display_scale"
 
-    blur_size: IntProperty(
-        name="Blur Size",
-        description="Size of the blur effect in pixels",
-        default=50,
-        min=1,
-        max=500,
+
+FORMAT_EXT = {
+    "MP4": "mp4",
+    "AVI": "avi",
+    "MOV": "mov",
+}
+
+
+def _output_path(video_strip, detections_path: str, fmt: str) -> str:
+    ext = FORMAT_EXT.get(fmt, "mp4")
+    out_dir = os.path.dirname(detections_path)
+    safe_name = video_strip.name.replace("/", "_").replace("\\", "_")
+    return os.path.join(out_dir, f"{safe_name}_blurred.{ext}")
+
+
+def _output_dir_for_images(strip, detections_path: str) -> str:
+    out_dir = os.path.dirname(detections_path)
+    safe_name = strip.name.replace("/", "_").replace("\\", "_")
+    return os.path.join(out_dir, f"{safe_name}_blurred")
+
+
+def _reload_movie_strip(strip):
+    if hasattr(strip, "reload"):
+        try:
+            strip.reload()
+        except Exception:
+            pass
+
+
+def _set_strip_source(strip, path: str):
+    if strip.type == "IMAGE":
+        strip.directory = path
+    else:
+        strip.filepath = path
+        _reload_movie_strip(strip)
+
+
+def _start_bake_impl(operator, context, force: bool = False, strip=None, on_complete_extra=None):
+    """Bakeの共通実装。force=True でキャッシュを無視して再Bakeする。
+
+    strip: 処理対象のstrip。None の場合は active_strip を使用。
+    on_complete_extra: 非同期Bake完了時に追加で呼ばれるコールバック (status, data)。
+                       キャッシュヒット即時完了の場合は呼ばれない。
+    MOVIE / IMAGE 両対応。
+    """
+    seq_editor = context.scene.sequence_editor
+    scene = context.scene
+    video_strip = strip if strip is not None else seq_editor.active_strip
+    is_image = video_strip.type == "IMAGE"
+
+    detections_path = get_detections_path_for_strip(video_strip.name)
+    if not os.path.exists(detections_path):
+        operator.report({"ERROR"}, f"Detection cache not found: {detections_path}")
+        return {"CANCELLED"}
+
+    blur_size = int(scene.facemask_bake_blur_size)
+    display_scale = float(scene.facemask_bake_display_scale)
+
+    if is_image:
+        image_dir = bpy.path.abspath(video_strip.directory)
+        filenames = [elem.filename for elem in video_strip.elements]
+        if not os.path.isdir(image_dir):
+            operator.report({"ERROR"}, f"Image directory not found: {image_dir}")
+            return {"CANCELLED"}
+        output_dir = _output_dir_for_images(video_strip, detections_path)
+        original_source = image_dir
+        bake_format = None  # IMAGE strips don't use format
+    else:
+        video_path = bpy.path.abspath(video_strip.filepath)
+        if not os.path.exists(video_path):
+            operator.report({"ERROR"}, f"Source video not found: {video_path}")
+            return {"CANCELLED"}
+        bake_format = scene.facemask_bake_format
+        output_path = _output_path(video_strip, detections_path, bake_format)
+        original_source = video_path
+
+    if not force:
+        # パラメータが一致するキャッシュがあればswapのみ
+        cached_baked_path = video_strip.get(KEY_BAKED)
+        cached_blur_size = video_strip.get(KEY_BLUR_SIZE)
+        cached_display_scale = video_strip.get(KEY_DISPLAY_SCALE)
+        try:
+            cached_blur_size_int = int(cached_blur_size)
+        except (TypeError, ValueError):
+            cached_blur_size_int = None
+        try:
+            cached_display_scale_f = float(cached_display_scale)
+        except (TypeError, ValueError):
+            cached_display_scale_f = None
+
+        cache_exists = (
+            cached_baked_path and os.path.exists(cached_baked_path)
+            and cached_blur_size_int == blur_size
+            and cached_display_scale_f == display_scale
         )
+        if not is_image:
+            cache_exists = cache_exists and video_strip.get(KEY_FORMAT) == bake_format
+
+        if cache_exists:
+            if video_strip.get(KEY_MODE) != "baked":
+                video_strip[KEY_MODE] = "baked"
+                _set_strip_source(video_strip, cached_baked_path)
+            operator.report({"INFO"}, "Using cached baked blur")
+            return {"FINISHED"}
+
+    bake_generator = get_bake_generator()
+    wm = context.window_manager
+
+    def on_complete(status, data):
+        strip = context.scene.sequence_editor.strips.get(video_strip.name)
+        if not strip:
+            print(f"[FaceMask] Bake complete but strip no longer exists: {video_strip.name}")
+            return
+
+        if status == "done":
+            result = data or (output_dir if is_image else output_path)
+            current_mode = strip.get(KEY_MODE, "original")
+            if not strip.get(KEY_ORIGINAL) or current_mode != "baked":
+                strip[KEY_ORIGINAL] = original_source
+            strip[KEY_BAKED] = result
+            strip[KEY_MODE] = "baked"
+            strip[KEY_BLUR_SIZE] = blur_size
+            strip[KEY_DISPLAY_SCALE] = display_scale
+            if not is_image:
+                strip[KEY_FORMAT] = bake_format
+            _set_strip_source(strip, result)
+            print(f"[FaceMask] Bake completed and source swapped: {result}")
+        elif status == "error":
+            print(f"[FaceMask] Bake failed: {data}")
+        elif status == "cancelled":
+            print("[FaceMask] Bake cancelled")
+
+        for area in context.screen.areas:
+            if area.type == "SEQUENCE_EDITOR":
+                area.tag_redraw()
+
+        if on_complete_extra:
+            on_complete_extra(status, data)
+
+    def on_progress(current, total):
+        wm.bake_progress = current
+        wm.bake_total = max(total, 1)
+        for area in context.screen.areas:
+            if area.type == "SEQUENCE_EDITOR":
+                area.tag_redraw()
+
+    wm.bake_progress = 0
+    wm.bake_total = 1
+
+    try:
+        if is_image:
+            bake_generator.start_images(
+                image_dir=image_dir,
+                filenames=filenames,
+                output_dir=output_dir,
+                detections_path=detections_path,
+                blur_size=blur_size,
+                display_scale=display_scale,
+                on_complete=on_complete,
+                on_progress=on_progress,
+            )
+        else:
+            bake_generator.start(
+                video_path=video_path,
+                detections_path=detections_path,
+                output_path=output_path,
+                blur_size=blur_size,
+                display_scale=display_scale,
+                fmt=bake_format.lower(),
+                on_complete=on_complete,
+                on_progress=on_progress,
+            )
+    except Exception as e:
+        operator.report({"ERROR"}, f"Failed to start bake: {e}")
+        return {"CANCELLED"}
+
+    operator.report({"INFO"}, "Started blur bake in background")
+    return {"FINISHED"}
+
+
+class SEQUENCER_OT_bake_and_swap_blur_source(Operator):
+    """Bake masked blur (reuse cache if parameters match)."""
+
+    bl_idname = "sequencer.bake_and_swap_blur_source"
+    bl_label = "Bake"
+    bl_description = "Bake masked blur to video and swap active strip source"
+    bl_options = {"REGISTER", "UNDO"}
 
     @classmethod
     def poll(cls, context):
-        """Check if operator can run."""
         if not context.scene.sequence_editor:
             return False
-
-        seq_editor = context.scene.sequence_editor
-        strip = seq_editor.active_strip
-        if not strip:
+        if get_mask_generator().is_running:
             return False
-
-        if strip.type not in {'MOVIE', 'IMAGE'}:
+        if get_bake_generator().is_running:
             return False
-
-        # Check if corresponding mask strip exists
-        mask_name = f"{strip.name}_mask"
-        return mask_name in seq_editor.strips
+        strip = context.scene.sequence_editor.active_strip
+        return bool(strip and strip.type in {"MOVIE", "IMAGE"})
 
     def execute(self, context):
-        seq_editor = context.scene.sequence_editor
-        video_strip = seq_editor.active_strip
+        return _start_bake_impl(self, context, force=False)
 
-        # Auto-detect mask strip
-        mask_name = f"{video_strip.name}_mask"
-        mask_strip = seq_editor.strips.get(mask_name)
 
-        if not mask_strip:
-            self.report({'ERROR'}, f"Mask strip not found: {mask_name}")
-            return {'CANCELLED'}
+class SEQUENCER_OT_force_rebake_blur(Operator):
+    """Force re-bake, ignoring any existing cached result."""
 
-        try:
-            # Use Mask Modifier approach (Blender 5.0 compatible)
-            self._apply_with_mask_modifier(context, video_strip, mask_strip)
-        except Exception as e:
-            self.report({'ERROR'}, f"Failed to apply blur: {e}")
-            return {'CANCELLED'}
+    bl_idname = "sequencer.force_rebake_blur"
+    bl_label = "Re-bake"
+    bl_description = "Discard cached bake and re-bake from scratch"
+    bl_options = {"REGISTER", "UNDO"}
 
-        return {'FINISHED'}
+    @classmethod
+    def poll(cls, context):
+        if not context.scene.sequence_editor:
+            return False
+        if get_mask_generator().is_running:
+            return False
+        if get_bake_generator().is_running:
+            return False
+        strip = context.scene.sequence_editor.active_strip
+        return bool(strip and strip.type in {"MOVIE", "IMAGE"})
 
-    def _apply_with_mask_modifier(self, context, video_strip: "bpy.types.Strip", mask_strip: "bpy.types.Strip"):
-        """
-        Apply blur using Mask Modifier, grouped in a Meta Strip.
+    def execute(self, context):
+        return _start_bake_impl(self, context, force=True)
 
-        Workflow:
-        1. Duplicate the video strip
-        2. Create Gaussian Blur effect on the duplicate
-        3. Add Mask modifier to the blur effect (references mask strip)
-        4. Group all into a Meta Strip
 
-        The blur effect with mask will automatically composite over the original
-        video due to VSE's channel layering system.
-        """
-        seq_editor = context.scene.sequence_editor
+class SEQUENCER_OT_swap_to_baked_blur(Operator):
+    """Swap active strip source to already-baked video (no re-bake)."""
 
-        # Find available channels
-        used_channels = {s.channel for s in seq_editor.strips}
-        duplicate_channel = video_strip.channel + 1
-        while duplicate_channel in used_channels:
-            duplicate_channel += 1
+    bl_idname = "sequencer.swap_to_baked_blur"
+    bl_label = "Swap to Baked"
+    bl_description = "Switch active strip source to the baked video without re-baking"
+    bl_options = {"REGISTER", "UNDO"}
 
-        blur_channel = duplicate_channel + 1
-        while blur_channel in used_channels:
-            blur_channel += 1
+    @classmethod
+    def poll(cls, context):
+        if not context.scene.sequence_editor:
+            return False
+        if get_bake_generator().is_running:
+            return False
+        strip = context.scene.sequence_editor.active_strip
+        if not strip or strip.type not in {"MOVIE", "IMAGE"}:
+            return False
+        baked_path = strip.get(KEY_BAKED)
+        return bool(baked_path and os.path.exists(baked_path))
 
-        # Step 1: Duplicate the video strip
-        if video_strip.type == 'MOVIE':
-            video_copy = seq_editor.strips.new_movie(
-                name=f"{video_strip.name}_copy",
-                filepath=bpy.path.abspath(video_strip.filepath),
-                channel=duplicate_channel,
-                frame_start=video_strip.frame_final_start,
-            )
-        elif video_strip.type == 'IMAGE':
-            # For image sequences, duplicate differently
-            video_copy = seq_editor.strips.new_image(
-                name=f"{video_strip.name}_copy",
-                filepath=bpy.path.abspath(video_strip.elements[0].filename) if video_strip.elements else "",
-                channel=duplicate_channel,
-                frame_start=video_strip.frame_final_start,
-            )
-            # Copy all elements
-            for elem in video_strip.elements[1:]:
-                video_copy.elements.append(elem.filename)
+    def execute(self, context):
+        strip = context.scene.sequence_editor.active_strip
+        baked_path = strip.get(KEY_BAKED)
+        _set_strip_source(strip, baked_path)
+        strip[KEY_MODE] = "baked"
+        self.report({"INFO"}, "Swapped to baked source")
+        return {"FINISHED"}
+
+
+class SEQUENCER_OT_restore_original_source(Operator):
+    """Restore active strip source filepath to original video."""
+
+    bl_idname = "sequencer.restore_original_source"
+    bl_label = "Restore Original"
+    bl_description = "Restore active strip to original source filepath"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context):
+        if not context.scene.sequence_editor:
+            return False
+        if get_bake_generator().is_running:
+            return False
+        strip = context.scene.sequence_editor.active_strip
+        if not strip or strip.type not in {"MOVIE", "IMAGE"}:
+            return False
+        if strip.get(KEY_MODE, "original") == "original":
+            return False
+        return bool(strip.get(KEY_ORIGINAL))
+
+    def execute(self, context):
+        strip = context.scene.sequence_editor.active_strip
+        original_path = strip.get(KEY_ORIGINAL)
+        if not original_path:
+            self.report({"ERROR"}, "Original source path is not stored")
+            return {"CANCELLED"}
+        if not os.path.exists(original_path):
+            self.report({"ERROR"}, f"Original source not found: {original_path}")
+            return {"CANCELLED"}
+
+        _set_strip_source(strip, original_path)
+        strip[KEY_MODE] = "original"
+        self.report({"INFO"}, "Restored original source")
+        return {"FINISHED"}
+
+
+class SEQUENCER_OT_apply_mask_blur(Operator):
+    """Compatibility alias: run bake-and-swap blur workflow."""
+
+    bl_idname = "sequencer.apply_mask_blur"
+    bl_label = "Apply Mask Blur"
+    bl_description = "Compatibility alias for Bake"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context):
+        return SEQUENCER_OT_bake_and_swap_blur_source.poll(context)
+
+    def execute(self, context):
+        return bpy.ops.sequencer.bake_and_swap_blur_source("EXEC_DEFAULT")
+
+
+class SEQUENCER_OT_cancel_bake_blur(Operator):
+    """Cancel ongoing blur bake."""
+
+    bl_idname = "sequencer.cancel_bake_blur"
+    bl_label = "Cancel Blur Bake"
+    bl_description = "Cancel current blur bake process"
+    bl_options = {"REGISTER"}
+
+    def execute(self, context):
+        bake_generator = get_bake_generator()
+        if bake_generator.is_running:
+            bake_generator.cancel()
+            self.report({"INFO"}, "Blur bake cancelled")
         else:
-            raise ValueError(f"Unsupported strip type: {video_strip.type}")
-
-        # Match strip length
-        strip_length = video_strip.frame_final_end - video_strip.frame_final_start
-        video_copy.frame_final_end = video_copy.frame_final_start + strip_length
-
-        # Step 2: Create Gaussian Blur effect on the duplicate
-        blur_effect = seq_editor.strips.new_effect(
-            name=f"{video_strip.name}_blur",
-            type='GAUSSIAN_BLUR',
-            channel=blur_channel,
-            frame_start=video_strip.frame_final_start,
-            length=strip_length,
-            input1=video_copy,
-        )
-
-        # Set blur size (Blender 5.0 API)
-        if hasattr(blur_effect, 'size_x'):
-            blur_effect.size_x = self.blur_size
-            blur_effect.size_y = self.blur_size
-        elif hasattr(blur_effect, 'size'):
-            blur_effect.size = self.blur_size
-
-        # Step 3: Add Mask modifier to the blur effect
-        mask_mod = blur_effect.modifiers.new(
-            name="FaceMask",
-            type='MASK'
-        )
-
-        # Set mask input (Blender 5.0 API)
-        if hasattr(mask_mod, 'input_mask_strip'):
-            mask_mod.input_mask_strip = mask_strip
-        elif hasattr(mask_mod, 'input_mask_id'):
-            mask_mod.input_mask_type = 'STRIP'
-            mask_mod.input_mask_id = mask_strip
-
-        # Hide the mask strip (but keep it active for the modifier)
-        mask_strip.mute = True
-
-        # Step 4: Create Meta Strip to group everything
-        # Deselect all first
-        for strip in seq_editor.strips:
-            strip.select = False
-
-        # Select the strips to group
-        video_copy.select = True
-        blur_effect.select = True
-        mask_strip.select = True
-
-        # Set active strip for context
-        seq_editor.active_strip = blur_effect
-
-        # Create meta strip using operator
-        bpy.ops.sequencer.meta_make()
-
-        # Find the newly created meta strip (it will be selected)
-        meta_strip = None
-        for strip in seq_editor.strips:
-            if strip.select and strip.type == 'META':
-                meta_strip = strip
-                break
-
-        if meta_strip:
-            meta_strip.name = f"{video_strip.name}_blurred_meta"
-            self.report({'INFO'}, f"Applied blur with Mask Modifier (grouped in Meta Strip)")
-        else:
-            self.report({'INFO'}, f"Applied blur with Mask Modifier (blur on channel {blur_channel})")
-    
-    def _apply_with_meta_strip(self, context, video_strip: "bpy.types.Strip", mask_strip: "bpy.types.Strip"):
-        """
-        Fallback method using Meta Strip and effects.
-        
-        This is less elegant but works on all Blender versions.
-        """
-        seq_editor = context.scene.sequence_editor
-        
-        # Find available channels
-        base_channel = video_strip.channel
-        blur_channel = base_channel + 1
-        effect_channel = blur_channel + 1
-        
-        # Ensure mask is in correct position
-        mask_strip.channel = blur_channel
-        mask_strip.frame_start = video_strip.frame_final_start
-        
-        # Create Gaussian Blur effect on the video strip
-        # First, we need to duplicate the video for the blurred version
-        video_copy = seq_editor.strips.new_movie(
-            name=f"{video_strip.name}_blur",
-            filepath=bpy.path.abspath(video_strip.filepath) if hasattr(video_strip, 'filepath') else "",
-            channel=blur_channel,
-            frame_start=video_strip.frame_final_start,
-        ) if video_strip.type == 'MOVIE' else None
-        
-        if video_copy:
-            # Calculate length (Blender 5.0 uses length instead of frame_end)
-            strip_length = video_strip.frame_final_end - video_strip.frame_final_start
-            
-            # Apply Gaussian blur effect (Blender 5.0 API)
-            blur_effect = seq_editor.strips.new_effect(
-                name=f"{video_strip.name}_gaussian",
-                type='GAUSSIAN_BLUR',
-                channel=effect_channel,
-                frame_start=video_strip.frame_final_start,
-                length=strip_length,
-                input1=video_copy,
-            )
-            
-            # Set blur size (Blender 5.0 uses size property, not size_x/size_y)
-            if hasattr(blur_effect, 'size_x'):
-                blur_effect.size_x = self.blur_size
-                blur_effect.size_y = self.blur_size
-            elif hasattr(blur_effect, 'size'):
-                blur_effect.size = self.blur_size
-            
-            # Create Alpha Over to combine original with blurred (using mask)
-            # Note: Full implementation would require compositing
-            # This is a simplified version
-            
-            self.report({'INFO'}, "Created blur effect (full compositing in development)")
-        else:
-            # For image sequences, different approach needed
-            self.report({'WARNING'}, "Image sequence blur not yet fully implemented")
+            self.report({"WARNING"}, "No blur bake in progress")
+        return {"FINISHED"}
 
 
-# Registration
 classes = [
+    SEQUENCER_OT_bake_and_swap_blur_source,
+    SEQUENCER_OT_force_rebake_blur,
+    SEQUENCER_OT_swap_to_baked_blur,
+    SEQUENCER_OT_restore_original_source,
+    SEQUENCER_OT_cancel_bake_blur,
     SEQUENCER_OT_apply_mask_blur,
 ]
 
@@ -244,8 +361,12 @@ classes = [
 def register():
     for cls in classes:
         bpy.utils.register_class(cls)
+    bpy.types.WindowManager.bake_progress = IntProperty(default=0)
+    bpy.types.WindowManager.bake_total = IntProperty(default=0)
 
 
 def unregister():
+    del bpy.types.WindowManager.bake_progress
+    del bpy.types.WindowManager.bake_total
     for cls in reversed(classes):
         bpy.utils.unregister_class(cls)

operators/batch_bake.py

@@ -0,0 +1,191 @@
+"""
+Batch Bake operator: sequentially Generate Detection Cache → Bake
+for all selected MOVIE strips in the VSE.
+"""
+
+import os
+import bpy
+from bpy.props import IntProperty, StringProperty
+from bpy.types import Operator
+
+from ..core.batch_processor import get_batch_processor
+from ..core.async_generator import get_generator as get_mask_generator
+from ..core.async_bake_generator import get_bake_generator
+from .apply_blur import KEY_ORIGINAL, KEY_MODE, _set_strip_source
+
+
+class SEQUENCER_OT_batch_bake_selected(Operator):
+    """Generate detection cache and bake blur for all selected MOVIE/IMAGE strips."""
+
+    bl_idname = "sequencer.batch_bake_selected"
+    bl_label = "Batch Bake Selected"
+    bl_description = "Generate detection cache and bake blur for all selected MOVIE/IMAGE strips"
+    bl_options = {"REGISTER"}
+
+    @classmethod
+    def poll(cls, context):
+        if not context.scene.sequence_editor:
+            return False
+        if get_batch_processor().is_running:
+            return False
+        if get_mask_generator().is_running:
+            return False
+        if get_bake_generator().is_running:
+            return False
+        seq_editor = context.scene.sequence_editor
+        return any(s.select and s.type in {"MOVIE", "IMAGE"} for s in seq_editor.strips)
+
+    def execute(self, context):
+        seq_editor = context.scene.sequence_editor
+        strips = [s for s in seq_editor.strips if s.select and s.type in {"MOVIE", "IMAGE"}]
+
+        if not strips:
+            self.report({"WARNING"}, "No MOVIE or IMAGE strips selected")
+            return {"CANCELLED"}
+
+        batch = get_batch_processor()
+
+        def on_item_complete(idx, total, strip_name, status):
+            pass  # wm properties already updated by BatchProcessor
+
+        def on_all_complete(results):
+            done = sum(1 for r in results if r["status"] == "done")
+            total = len(results)
+            print(f"[FaceMask] Batch finished: {done}/{total} strips completed")
+
+        wm = context.window_manager
+        wm.batch_current = 0
+        wm.batch_total = len(strips)
+        wm.batch_current_name = ""
+
+        batch.start(context, strips, on_item_complete=on_item_complete, on_all_complete=on_all_complete)
+        self.report({"INFO"}, f"Batch bake started for {len(strips)} strips")
+        return {"FINISHED"}
+
+
+class SEQUENCER_OT_batch_regenerate_cache(Operator):
+    """Regenerate detection cache for all selected MOVIE/IMAGE strips (ignore existing cache)."""
+
+    bl_idname = "sequencer.batch_regenerate_cache"
+    bl_label = "Batch Regenerate Cache"
+    bl_description = "Regenerate detection cache for all selected MOVIE/IMAGE strips"
+    bl_options = {"REGISTER"}
+
+    @classmethod
+    def poll(cls, context):
+        if not context.scene.sequence_editor:
+            return False
+        if get_batch_processor().is_running:
+            return False
+        if get_mask_generator().is_running:
+            return False
+        if get_bake_generator().is_running:
+            return False
+        seq_editor = context.scene.sequence_editor
+        return any(s.select and s.type in {"MOVIE", "IMAGE"} for s in seq_editor.strips)
+
+    def execute(self, context):
+        seq_editor = context.scene.sequence_editor
+        strips = [s for s in seq_editor.strips if s.select and s.type in {"MOVIE", "IMAGE"}]
+
+        if not strips:
+            self.report({"WARNING"}, "No MOVIE or IMAGE strips selected")
+            return {"CANCELLED"}
+
+        batch = get_batch_processor()
+
+        def on_all_complete(results):
+            done = sum(1 for r in results if r["status"] == "done")
+            print(f"[FaceMask] Batch regenerate finished: {done}/{len(results)} strips")
+
+        batch.start(
+            context,
+            strips,
+            on_all_complete=on_all_complete,
+            mode="mask_only",
+        )
+        self.report({"INFO"}, f"Batch regenerate cache started for {len(strips)} strips")
+        return {"FINISHED"}
+
+
+class SEQUENCER_OT_batch_restore_original(Operator):
+    """Restore original source for all selected MOVIE/IMAGE strips."""
+
+    bl_idname = "sequencer.batch_restore_original"
+    bl_label = "Batch Restore Original"
+    bl_description = "Restore original source filepath for all selected MOVIE/IMAGE strips"
+    bl_options = {"REGISTER", "UNDO"}
+
+    @classmethod
+    def poll(cls, context):
+        if not context.scene.sequence_editor:
+            return False
+        if get_batch_processor().is_running:
+            return False
+        seq_editor = context.scene.sequence_editor
+        return any(s.select and s.type in {"MOVIE", "IMAGE"} for s in seq_editor.strips)
+
+    def execute(self, context):
+        seq_editor = context.scene.sequence_editor
+        strips = [s for s in seq_editor.strips if s.select and s.type in {"MOVIE", "IMAGE"}]
+
+        restored = 0
+        skipped = 0
+        for strip in strips:
+            original_path = strip.get(KEY_ORIGINAL)
+            if not original_path or not os.path.exists(original_path):
+                skipped += 1
+                continue
+            if strip.get(KEY_MODE, "original") != "original":
+                _set_strip_source(strip, original_path)
+                strip[KEY_MODE] = "original"
+            restored += 1
+
+        self.report(
+            {"INFO"},
+            f"Restored {restored} strip(s)"
+            + (f", skipped {skipped} (no original stored)" if skipped else ""),
+        )
+        return {"FINISHED"}
+
+
+class SEQUENCER_OT_cancel_batch_bake(Operator):
+    """Cancel ongoing batch bake."""
+
+    bl_idname = "sequencer.cancel_batch_bake"
+    bl_label = "Cancel Batch Bake"
+    bl_description = "Cancel the current batch bake process"
+    bl_options = {"REGISTER"}
+
+    def execute(self, context):
+        batch = get_batch_processor()
+        if batch.is_running:
+            batch.cancel()
+            self.report({"INFO"}, "Batch bake cancelled")
+        else:
+            self.report({"WARNING"}, "No batch bake in progress")
+        return {"FINISHED"}
+
+
+classes = [
+    SEQUENCER_OT_batch_bake_selected,
+    SEQUENCER_OT_batch_regenerate_cache,
+    SEQUENCER_OT_batch_restore_original,
+    SEQUENCER_OT_cancel_batch_bake,
+]
+
+
+def register():
+    for cls in classes:
+        bpy.utils.register_class(cls)
+    bpy.types.WindowManager.batch_current = IntProperty(default=0)
+    bpy.types.WindowManager.batch_total = IntProperty(default=0)
+    bpy.types.WindowManager.batch_current_name = StringProperty(default="")
+
+
+def unregister():
+    del bpy.types.WindowManager.batch_current_name
+    del bpy.types.WindowManager.batch_total
+    del bpy.types.WindowManager.batch_current
+    for cls in reversed(classes):
+        bpy.utils.unregister_class(cls)

operators/clear_cache.py

@@ -0,0 +1,113 @@
+"""
+Clear Cache Operator.
+
+Provides operators to clear mask cache directories.
+"""
+
+import os
+import shutil
+import bpy
+from bpy.types import Operator
+from bpy.props import BoolProperty
+
+from ..core.utils import get_cache_root, get_cache_dir_for_strip
+
+
+class SEQUENCER_OT_clear_mask_cache(Operator):
+    """Clear mask cache directories."""
+
+    bl_idname = "sequencer.clear_mask_cache"
+    bl_label = "Clear Mask Cache"
+    bl_description = "Delete cached mask images"
+    bl_options = {'REGISTER', 'UNDO'}
+
+    all_strips: BoolProperty(
+        name="All Strips",
+        description="Clear cache for all strips (otherwise only current strip)",
+        default=False,
+    )
+
+    def execute(self, context):
+        total_size = 0
+
+        if self.all_strips:
+            # Clear all cache directories
+            cache_root = get_cache_root()
+
+            if os.path.exists(cache_root):
+                # Calculate size before deletion
+                for root, dirs, files in os.walk(cache_root):
+                    for file in files:
+                        file_path = os.path.join(root, file)
+                        try:
+                            total_size += os.path.getsize(file_path)
+                        except OSError:
+                            pass
+
+                # Delete cache directory
+                try:
+                    shutil.rmtree(cache_root)
+                    self.report({'INFO'}, f"Cleared all cache ({self._format_size(total_size)})")
+                except Exception as e:
+                    self.report({'ERROR'}, f"Failed to clear cache: {e}")
+                    return {'CANCELLED'}
+            else:
+                self.report({'INFO'}, "No cache to clear")
+                return {'FINISHED'}
+
+        else:
+            # Clear cache for active strip only
+            seq_editor = context.scene.sequence_editor
+            if not seq_editor or not seq_editor.active_strip:
+                self.report({'WARNING'}, "No strip selected")
+                return {'CANCELLED'}
+
+            strip = seq_editor.active_strip
+            cache_dir = get_cache_dir_for_strip(strip.name)
+
+            if os.path.exists(cache_dir):
+                # Calculate size
+                for root, dirs, files in os.walk(cache_dir):
+                    for file in files:
+                        file_path = os.path.join(root, file)
+                        try:
+                            total_size += os.path.getsize(file_path)
+                        except OSError:
+                            pass
+
+                # Delete
+                try:
+                    shutil.rmtree(cache_dir)
+                    self.report({'INFO'}, f"Cleared cache for {strip.name} ({self._format_size(total_size)})")
+                except Exception as e:
+                    self.report({'ERROR'}, f"Failed to clear cache: {e}")
+                    return {'CANCELLED'}
+            else:
+                self.report({'INFO'}, f"No cache for {strip.name}")
+                return {'FINISHED'}
+
+        return {'FINISHED'}
+
+    def _format_size(self, size_bytes):
+        """Format bytes to human-readable size."""
+        for unit in ['B', 'KB', 'MB', 'GB']:
+            if size_bytes < 1024.0:
+                return f"{size_bytes:.1f} {unit}"
+            size_bytes /= 1024.0
+        return f"{size_bytes:.1f} TB"
+
+
+# Registration
+classes = [
+    SEQUENCER_OT_clear_mask_cache,
+]
+
+
+def register():
+    for cls in classes:
+        bpy.utils.register_class(cls)
+
+
+def unregister():
+    for cls in reversed(classes):
+        bpy.utils.unregister_class(cls)

operators/generate_mask.py

@@ -7,10 +7,99 @@ from video strips in the Video Sequence Editor.
 
 import os
 import bpy
-from bpy.props import FloatProperty, IntProperty
+from bpy.props import IntProperty, BoolProperty
 from bpy.types import Operator
 
 from ..core.async_generator import get_generator
+from ..core.inference_client import get_client
+from ..core.utils import get_cache_dir_for_strip, check_detection_cache
+
+
+def compute_strip_frame_range(strip, scene, client) -> tuple:
+    """(start_frame, end_frame, source_fps) を返す。失敗時は例外を送出。"""
+    video_path = bpy.path.abspath(strip.filepath)
+    video_info = client.get_video_info(video_path)
+    total_video_frames = int(video_info.get("frame_count", 0))
+    source_fps = float(video_info.get("fps", 0.0))
+    if total_video_frames <= 0:
+        raise ValueError(f"Could not read frame count from video: {video_path}")
+    if source_fps <= 0:
+        source_fps = scene.render.fps / scene.render.fps_base
+    project_fps = scene.render.fps / scene.render.fps_base
+    fps_ratio = source_fps / project_fps
+    start_frame = int(round(strip.frame_offset_start * fps_ratio))
+    end_frame = start_frame + int(round(strip.frame_final_duration * fps_ratio)) - 1
+    start_frame = max(0, min(start_frame, total_video_frames - 1))
+    end_frame = max(start_frame, min(end_frame, total_video_frames - 1))
+    return start_frame, end_frame, source_fps
+
+
+def get_image_strip_files(strip) -> tuple:
+    """IMAGE strip の (abs_image_dir, filenames_list) を返す。"""
+    image_dir = bpy.path.abspath(strip.directory)
+    filenames = [elem.filename for elem in strip.elements]
+    return image_dir, filenames
+
+
+def compute_image_strip_range(strip) -> tuple:
+    """IMAGE strip のアクティブ範囲 (start_index, end_index) を返す。"""
+    total_elements = len(strip.elements)
+    start_idx = max(0, int(strip.frame_offset_start))
+    end_idx = start_idx + int(strip.frame_final_duration) - 1
+    start_idx = min(start_idx, total_elements - 1)
+    end_idx = max(start_idx, min(end_idx, total_elements - 1))
+    return start_idx, end_idx
+
+
+def start_mask_gen_for_strip(context, strip, on_complete, on_progress):
+    """Strip のマスク生成を開始する共通処理（MOVIE / IMAGE 両対応）。
+
+    generator.is_running 等のエラー時は例外を送出する。
+    wm.mask_progress / mask_total を初期化してから generator.start*() を呼ぶ。
+    """
+    scene = context.scene
+    wm = context.window_manager
+    generator = get_generator()
+
+    if generator.is_running:
+        raise RuntimeError("Mask generation already in progress")
+
+    output_dir = get_cache_dir_for_strip(strip.name)
+    os.makedirs(output_dir, exist_ok=True)
+    wm.mask_progress = 0
+
+    if strip.type == "IMAGE":
+        image_dir, filenames = get_image_strip_files(strip)
+        if not filenames:
+            raise ValueError("Image strip has no elements")
+        start_idx, end_idx = compute_image_strip_range(strip)
+        wm.mask_total = end_idx - start_idx + 1
+        generator.start_images(
+            image_dir=image_dir,
+            filenames=filenames,
+            output_dir=output_dir,
+            start_index=start_idx,
+            end_index=end_idx,
+            conf_threshold=scene.facemask_conf_threshold,
+            iou_threshold=scene.facemask_iou_threshold,
+            on_complete=on_complete,
+            on_progress=on_progress,
+        )
+    else:
+        client = get_client()
+        start_frame, end_frame, source_fps = compute_strip_frame_range(strip, scene, client)
+        wm.mask_total = end_frame - start_frame + 1
+        generator.start(
+            video_path=bpy.path.abspath(strip.filepath),
+            output_dir=output_dir,
+            start_frame=start_frame,
+            end_frame=end_frame,
+            fps=source_fps,
+            conf_threshold=scene.facemask_conf_threshold,
+            iou_threshold=scene.facemask_iou_threshold,
+            on_complete=on_complete,
+            on_progress=on_progress,
+        )
 
 
 class SEQUENCER_OT_generate_face_mask(Operator):
@@ -21,212 +110,80 @@ class SEQUENCER_OT_generate_face_mask(Operator):
     bl_description = "Detect faces and generate mask image sequence"
     bl_options = {'REGISTER', 'UNDO'}
 
-    # YOLO Detection parameters
-    conf_threshold: FloatProperty(
-        name="Confidence",
-        description="YOLO confidence threshold (higher = fewer false positives)",
-        default=0.25,
-        min=0.1,
-        max=1.0,
-    )
-    
-    iou_threshold: FloatProperty(
-        name="IOU Threshold",
-        description="Non-maximum suppression IOU threshold",
-        default=0.45,
-        min=0.1,
-        max=1.0,
-    )
-    
-    mask_scale: FloatProperty(
-        name="Mask Scale",
-        description="Scale factor for mask region (1.0 = exact face size)",
-        default=1.5,
-        min=1.0,
-        max=3.0,
+    force: BoolProperty(
+        name="Force Regenerate",
+        description="既存のキャッシュを無視して再生成する",
+        default=False,
     )
 
     @classmethod
     def poll(cls, context):
-        """Check if operator can run."""
         if not context.scene.sequence_editor:
             return False
-        
         strip = context.scene.sequence_editor.active_strip
         if not strip:
             return False
-        
         return strip.type in {'MOVIE', 'IMAGE'}
 
     def execute(self, context):
         strip = context.scene.sequence_editor.active_strip
-        scene = context.scene
 
-        # Get video path
+        # ファイル存在確認
         if strip.type == 'MOVIE':
             video_path = bpy.path.abspath(strip.filepath)
         else:
-            # Image sequence - get directory
             video_path = bpy.path.abspath(strip.directory)
 
         if not os.path.exists(video_path):
             self.report({'ERROR'}, f"Video file not found: {video_path}")
             return {'CANCELLED'}
 
-        # Determine output directory
-        output_dir = self._get_cache_dir(context, strip)
-        
-        # Check cache - if masks already exist, use them
-        expected_frame_count = strip.frame_final_end - strip.frame_final_start + 1
-        if self._check_cache(output_dir, expected_frame_count):
-            self.report({'INFO'}, f"Using cached masks from {output_dir}")
-            self._add_mask_strip(context, strip.name, output_dir)
+        # キャッシュ確認（force=True の場合はスキップ）
+        if not self.force and check_detection_cache(strip.name):
+            self.report({'INFO'}, f"Using cached detections for {strip.name}")
             return {'FINISHED'}
 
-        # Get frame range
-        start_frame = strip.frame_final_start
-        end_frame = strip.frame_final_end
-        fps = scene.render.fps / scene.render.fps_base
-        
-        # Start async generation
         generator = get_generator()
 
-        if generator.is_running:
-            self.report({'WARNING'}, "Mask generation already in progress")
-            return {'CANCELLED'}
-        
-        # Store strip name for callback
-        strip_name = strip.name
-        
         def on_complete(status, data):
-            """Called when mask generation completes."""
+            wm = context.window_manager
+            wm.mask_total = max(wm.mask_total, generator.total_frames)
+            if status == "done":
+                wm.mask_progress = wm.mask_total
+            elif status in {"error", "cancelled"}:
+                wm.mask_progress = min(wm.mask_progress, wm.mask_total)
+
             if status == "done":
-                # Add mask strip to sequence editor
-                self._add_mask_strip(context, strip_name, data)
                 print(f"[FaceMask] Mask generation completed: {data}")
             elif status == "error":
                 print(f"[FaceMask] Error: {data}")
             elif status == "cancelled":
                 print("[FaceMask] Generation cancelled")
 
-        def on_progress(current, total):
-            """Called on progress updates."""
-            # Update window manager properties for UI
-            wm = context.window_manager
-            wm.mask_progress = current
-            wm.mask_total = total
-            
-            # Force UI redraw
             for area in context.screen.areas:
                 if area.type == 'SEQUENCE_EDITOR':
                     area.tag_redraw()
 
-        # Initialize progress
+        def on_progress(current, total):
             wm = context.window_manager
-        wm.mask_progress = 0
-        wm.mask_total = end_frame - start_frame + 1
+            wm.mask_progress = current
+            wm.mask_total = total
+            for area in context.screen.areas:
+                if area.type == 'SEQUENCE_EDITOR':
+                    area.tag_redraw()
 
-        # Start generation
-        generator.start(
-            video_path=video_path,
-            output_dir=output_dir,
-            start_frame=0,  # Frame indices in video
-            end_frame=end_frame - start_frame,
-            fps=fps,
-            conf_threshold=self.conf_threshold,
-            iou_threshold=self.iou_threshold,
-            mask_scale=self.mask_scale,
-            on_complete=on_complete,
-            on_progress=on_progress,
-        )
+        try:
+            start_mask_gen_for_strip(context, strip, on_complete, on_progress)
+        except RuntimeError as e:
+            self.report({'WARNING'}, str(e))
+            return {'CANCELLED'}
+        except Exception as e:
+            self.report({'ERROR'}, f"Failed to start mask generation: {e}")
+            return {'CANCELLED'}
 
         self.report({'INFO'}, f"Started mask generation for {strip.name}")
         return {'FINISHED'}
 
-    def _get_cache_dir(self, context, strip) -> str:
-        """Get or create cache directory for mask images."""
-        import tempfile
-        
-        # Use temp directory with project-specific subdirectory
-        # This avoids issues with extension_path_user package name resolution
-        blend_file = bpy.data.filepath
-        if blend_file:
-            # Use blend file directory if saved
-            project_dir = os.path.dirname(blend_file)
-            cache_dir = os.path.join(project_dir, ".mask_cache", strip.name)
-        else:
-            # Use temp directory for unsaved projects
-            cache_dir = os.path.join(tempfile.gettempdir(), "blender_mask_cache", strip.name)
-        
-        os.makedirs(cache_dir, exist_ok=True)
-        return cache_dir
-    
-    def _check_cache(self, cache_dir: str, expected_frames: int) -> bool:
-        """Check if cached masks exist and are complete.
-        
-        Args:
-            cache_dir: Path to cache directory
-            expected_frames: Number of frames expected
-            
-        Returns:
-            True if cache exists and has at least 90% of expected frames
-        """
-        if not os.path.exists(cache_dir):
-            return False
-        
-        mask_files = [f for f in os.listdir(cache_dir) 
-                      if f.startswith("mask_") and f.endswith(".png")]
-        
-        # Accept cache if at least 90% of frames exist
-        # (some frames may have been skipped due to read errors)
-        return len(mask_files) >= expected_frames * 0.9
-    
-    def _add_mask_strip(self, context, source_strip_name: str, mask_dir: str):
-        """Add mask image sequence as a new strip."""
-        scene = context.scene
-        seq_editor = scene.sequence_editor
-        
-        if not seq_editor:
-            return
-        
-        # Find source strip (Blender 5.0 uses 'strips' instead of 'sequences')
-        source_strip = seq_editor.strips.get(source_strip_name)
-        if not source_strip:
-            return
-        
-        # Get first mask image
-        mask_files = sorted([
-            f for f in os.listdir(mask_dir)
-            if f.startswith("mask_") and f.endswith(".png")
-        ])
-        
-        if not mask_files:
-            return
-        
-        first_mask = os.path.join(mask_dir, mask_files[0])
-        
-        # Find an empty channel
-        used_channels = {s.channel for s in seq_editor.strips}
-        new_channel = source_strip.channel + 1
-        while new_channel in used_channels:
-            new_channel += 1
-        
-        # Add image sequence (Blender 5.0 API)
-        mask_strip = seq_editor.strips.new_image(
-            name=f"{source_strip_name}_mask",
-            filepath=first_mask,
-            channel=new_channel,
-            frame_start=source_strip.frame_final_start,
-        )
-        
-        # Add remaining frames
-        for mask_file in mask_files[1:]:
-            mask_strip.elements.append(mask_file)
-        
-        # Set blend mode for mask
-        mask_strip.blend_type = 'ALPHA_OVER'
-        mask_strip.blend_alpha = 0.5
-
 
 class SEQUENCER_OT_cancel_mask_generation(Operator):
     """Cancel ongoing mask generation."""
@@ -248,10 +205,88 @@ class SEQUENCER_OT_cancel_mask_generation(Operator):
         return {'FINISHED'}
 
 
+class SEQUENCER_OT_augment_pose_mask(Operator):
+    """Add pose-based head detections to existing detection cache."""
+
+    bl_idname = "sequencer.augment_pose_mask"
+    bl_label = "Augment with Pose"
+    bl_description = "Run pose estimation and merge results into existing detection cache"
+    bl_options = {'REGISTER'}
+
+    @classmethod
+    def poll(cls, context):
+        if not context.scene.sequence_editor:
+            return False
+        strip = context.scene.sequence_editor.active_strip
+        if not strip or strip.type != 'MOVIE':
+            return False
+        return check_detection_cache(strip.name)
+
+    def execute(self, context):
+        strip = context.scene.sequence_editor.active_strip
+        output_dir = get_cache_dir_for_strip(strip.name)
+        detections_path = os.path.join(output_dir, "detections.msgpack")
+
+        if not os.path.exists(detections_path):
+            self.report({'ERROR'}, f"Detection cache not found: {detections_path}")
+            return {'CANCELLED'}
+
+        generator = get_generator()
+        scene = context.scene
+        wm = context.window_manager
+        wm.mask_progress = 0
+        wm.mask_total = 0  # サーバー側から実際の値に更新される
+
+        def on_complete(status, data):
+            wm.mask_total = max(wm.mask_total, generator.total_frames)
+            if status == "done":
+                wm.mask_progress = wm.mask_total
+            elif status in {"error", "cancelled"}:
+                wm.mask_progress = min(wm.mask_progress, wm.mask_total)
+
+            if status == "done":
+                print(f"[FaceMask] Pose augmentation completed: {data}")
+            elif status == "error":
+                print(f"[FaceMask] Error: {data}")
+            elif status == "cancelled":
+                print("[FaceMask] Pose augmentation cancelled")
+
+            for area in context.screen.areas:
+                if area.type == 'SEQUENCE_EDITOR':
+                    area.tag_redraw()
+
+        def on_progress(current, total_f):
+            wm.mask_progress = current
+            wm.mask_total = total_f
+            for area in context.screen.areas:
+                if area.type == 'SEQUENCE_EDITOR':
+                    area.tag_redraw()
+
+        try:
+            generator.start_augment_pose(
+                detections_path=detections_path,
+                total_frames=0,
+                conf_threshold=scene.facemask_conf_threshold,
+                iou_threshold=scene.facemask_iou_threshold,
+                on_complete=on_complete,
+                on_progress=on_progress,
+            )
+        except RuntimeError as e:
+            self.report({'WARNING'}, str(e))
+            return {'CANCELLED'}
+        except Exception as e:
+            self.report({'ERROR'}, f"Failed to start pose augmentation: {e}")
+            return {'CANCELLED'}
+
+        self.report({'INFO'}, f"Started pose augmentation for {strip.name}")
+        return {'FINISHED'}
+
+
 # Registration
 classes = [
     SEQUENCER_OT_generate_face_mask,
     SEQUENCER_OT_cancel_mask_generation,
+    SEQUENCER_OT_augment_pose_mask,
 ]
 
 
@@ -259,13 +294,11 @@ def register():
     for cls in classes:
         bpy.utils.register_class(cls)
 
-    # Add progress properties to window manager
     bpy.types.WindowManager.mask_progress = IntProperty(default=0)
     bpy.types.WindowManager.mask_total = IntProperty(default=0)
 
 
 def unregister():
-    # Remove properties
     del bpy.types.WindowManager.mask_progress
     del bpy.types.WindowManager.mask_total
 

panels/vse_panel.py

@@ -5,10 +5,19 @@ Provides a sidebar panel in the Video Sequence Editor
 for controlling mask generation and blur application.
 """
 
+import os
 import bpy
 from bpy.types import Panel
 
+from ..core.async_bake_generator import get_bake_generator
 from ..core.async_generator import get_generator
+from ..core.batch_processor import get_batch_processor
+from ..core.utils import (
+    get_server_status,
+    get_cache_info,
+    format_size,
+    check_detection_cache,
+)
 
 
 class SEQUENCER_PT_face_mask(Panel):
@@ -22,18 +31,30 @@ class SEQUENCER_PT_face_mask(Panel):
     
     def draw(self, context):
         layout = self.layout
+        scene = context.scene
         wm = context.window_manager
         seq_editor = context.scene.sequence_editor
         # Note: Blender 5.0 uses 'strips' instead of 'sequences'
 
+        batch = get_batch_processor()
         generator = get_generator()
+        bake_generator = get_bake_generator()
 
-        # Show progress if generating
+        # Batch progress (highest priority)
+        if batch.is_running:
+            self._draw_batch_progress(layout, wm, batch, generator, bake_generator)
+            return
+
+        # Show progress if generating masks
         if generator.is_running:
             self._draw_progress(layout, wm, generator)
             return
+        # Show progress if baking blur
+        if bake_generator.is_running:
+            self._draw_bake_progress(layout, wm, bake_generator)
+            return
 
-        # Show controls if strip selected
+        # Show primary controls first (top priority in UI)
         if seq_editor and seq_editor.active_strip:
             strip = seq_editor.active_strip
 
@@ -45,6 +66,94 @@ class SEQUENCER_PT_face_mask(Panel):
         else:
             layout.label(text="No strip selected")
 
+        layout.separator()
+
+        # Secondary sections
+        self._draw_parameters(layout, scene)
+        self._draw_server_status(layout)
+        self._draw_cache_info(layout, context, seq_editor)
+        self._draw_batch_controls(layout, context, seq_editor)
+    
+    def _draw_parameters(self, layout, scene):
+        """Draw detection parameters."""
+        box = layout.box()
+        box.label(text="Parameters", icon='PREFERENCES')
+
+        col = box.column(align=True)
+        col.prop(scene, "facemask_conf_threshold")
+        col.prop(scene, "facemask_iou_threshold")
+
+    def _draw_server_status(self, layout):
+        """Draw server status and GPU info."""
+        box = layout.box()
+        box.label(text="Server Status", icon='SYSTEM')
+
+        status = get_server_status()
+
+        # Server status
+        row = box.row()
+        if status['running']:
+            row.label(text="Server:", icon='CHECKMARK')
+            row.label(text="Running")
+        else:
+            row.label(text="Server:", icon='ERROR')
+            row.label(text="Stopped")
+
+        # GPU status
+        if status['running']:
+            row = box.row()
+            if status['gpu_available']:
+                row.label(text="GPU:", icon='CHECKMARK')
+                gpu_name = status['gpu_device'] or "Available"
+                # Truncate long GPU names
+                if len(gpu_name) > 25:
+                    gpu_name = gpu_name[:22] + "..."
+                row.label(text=gpu_name)
+            else:
+                row.label(text="GPU:", icon='ERROR')
+                row.label(text="Not Available")
+
+    def _draw_cache_info(self, layout, context, seq_editor):
+        """Draw cache information and clear button."""
+        box = layout.box()
+        box.label(text="Cache", icon='FILE_CACHE')
+
+        # Get cache info
+        if seq_editor and seq_editor.active_strip:
+            strip_name = seq_editor.active_strip.name
+            cache_path, total_size, file_count = get_cache_info(strip_name)
+        else:
+            cache_path, total_size, file_count = get_cache_info()
+
+        # Cache info
+        row = box.row()
+        row.label(text="Size:")
+        row.label(text=format_size(total_size))
+
+        row = box.row()
+        row.label(text="Files:")
+        row.label(text=str(file_count))
+
+        # Cache directory setting
+        box.prop(context.scene, "facemask_cache_dir")
+
+        # Clear cache buttons
+        row = box.row(align=True)
+        if seq_editor and seq_editor.active_strip:
+            op = row.operator(
+                "sequencer.clear_mask_cache",
+                text="Clear Strip Cache",
+                icon='TRASH',
+            )
+            op.all_strips = False
+
+        op = row.operator(
+            "sequencer.clear_mask_cache",
+            text="Clear All",
+            icon='TRASH',
+        )
+        op.all_strips = True
+
     def _draw_progress(self, layout, wm, generator):
         """Draw progress bar during generation."""
         box = layout.box()
@@ -64,6 +173,93 @@ class SEQUENCER_PT_face_mask(Panel):
             icon='CANCEL',
         )
 
+    def _draw_bake_progress(self, layout, wm, generator):
+        """Draw progress bar during blur bake."""
+        box = layout.box()
+        box.label(text="Baking Blur...", icon='RENDER_ANIMATION')
+
+        progress = wm.bake_progress / max(wm.bake_total, 1)
+        box.progress(
+            factor=progress,
+            text=f"Frame {wm.bake_progress} / {wm.bake_total}",
+        )
+
+        box.operator(
+            "sequencer.cancel_bake_blur",
+            text="Cancel",
+            icon='CANCEL',
+        )
+
+    def _draw_batch_progress(self, layout, wm, batch, generator, bake_generator):
+        """Draw batch bake progress."""
+        box = layout.box()
+        if batch._mode == "mask_only":
+            box.label(text="Batch Generating Cache...", icon='RENDER_ANIMATION')
+        else:
+            box.label(text="Batch Baking...", icon='RENDER_ANIMATION')
+
+        # Overall progress
+        total = max(wm.batch_total, 1)
+        # Show n-1/total while current strip is in progress, n/total when moving to next
+        done_count = max(wm.batch_current - 1, 0)
+        overall_factor = done_count / total
+        box.progress(
+            factor=overall_factor,
+            text=f"{wm.batch_current} / {wm.batch_total}",
+        )
+
+        if wm.batch_current_name:
+            box.label(text=f"Strip: {wm.batch_current_name}")
+
+        # Inner progress (mask gen or bake)
+        if generator.is_running:
+            inner = wm.mask_progress / max(wm.mask_total, 1)
+            box.progress(
+                factor=inner,
+                text=f"Detecting: {wm.mask_progress} / {wm.mask_total}",
+            )
+        elif bake_generator.is_running:
+            inner = wm.bake_progress / max(wm.bake_total, 1)
+            box.progress(
+                factor=inner,
+                text=f"Baking: {wm.bake_progress} / {wm.bake_total}",
+            )
+
+        box.operator(
+            "sequencer.cancel_batch_bake",
+            text="Cancel Batch",
+            icon='CANCEL',
+        )
+
+    def _draw_batch_controls(self, layout, context, seq_editor):
+        """Draw batch bake button when multiple MOVIE/IMAGE strips are selected."""
+        if not seq_editor:
+            return
+        selected_movies = [s for s in seq_editor.strips if s.select and s.type in {"MOVIE", "IMAGE"}]
+        if not selected_movies:
+            return
+        count = len(selected_movies)
+        image_count = sum(1 for s in selected_movies if s.type == "IMAGE")
+        video_count = sum(1 for s in selected_movies if s.type == "MOVIE")
+        label = f"Batch ({count} selected, image: {image_count}, video: {video_count})"
+        box = layout.box()
+        box.label(text=label, icon='RENDER_ANIMATION')
+        box.operator(
+            "sequencer.batch_bake_selected",
+            text="Batch Bake Selected",
+            icon='RENDER_ANIMATION',
+        )
+        box.operator(
+            "sequencer.batch_regenerate_cache",
+            text="Batch Regenerate Cache",
+            icon='FILE_REFRESH',
+        )
+        box.operator(
+            "sequencer.batch_restore_original",
+            text="Batch Restore Original",
+            icon='LOOP_BACK',
+        )
+
     def _draw_generation_controls(self, layout, context, strip):
         """Draw mask generation controls."""
         box = layout.box()
@@ -73,41 +269,83 @@ class SEQUENCER_PT_face_mask(Panel):
         row = box.row()
         row.label(text=f"Strip: {strip.name}")
         
-        # Check for existing mask
-        seq_editor = context.scene.sequence_editor
-        mask_name = f"{strip.name}_mask"
-        has_mask = mask_name in seq_editor.strips
+        has_mask = check_detection_cache(strip.name)
 
         if has_mask:
             row = box.row()
-            row.label(text="✓ Mask exists", icon='CHECKMARK')
+            row.label(text="✓ Detection cache exists", icon='CHECKMARK')
         
-        # Generate button
+        # Generate / Regenerate button
+        if not has_mask:
+            box.operator(
+                "sequencer.generate_face_mask",
+                text="Generate Detection Cache",
+                icon='FACE_MAPS',
+            )
+        else:
             op = box.operator(
                 "sequencer.generate_face_mask",
-            text="Generate Face Mask" if not has_mask else "Regenerate Mask",
-            icon='FACE_MAPS',
+                text="Regenerate Cache",
+                icon='FILE_REFRESH',
+            )
+            op.force = True
+            if strip.type == 'MOVIE':
+                box.operator(
+                    "sequencer.augment_pose_mask",
+                    text="Augment with Pose",
+                    icon='MOD_ARMATURE',
                 )
     
     def _draw_blur_controls(self, layout, context, strip):
         """Draw blur application controls."""
         box = layout.box()
-        box.label(text="Blur Application", icon='MATFLUID')
+        box.label(text="Blur Bake", icon='MATFLUID')
 
-        # Check for mask strip
-        seq_editor = context.scene.sequence_editor
-        mask_name = f"{strip.name}_mask"
-        has_mask = mask_name in seq_editor.strips
+        has_mask = check_detection_cache(strip.name)
 
         if not has_mask:
-            box.label(text="Generate a mask first", icon='INFO')
+            box.label(text="Generate detection cache first", icon='INFO')
             return
 
-        # Apply blur button
-        op = box.operator(
-            "sequencer.apply_mask_blur",
-            text="Apply Mask Blur",
-            icon='PROP_CON',
+        # Bake parameters
+        col = box.column(align=True)
+        col.prop(context.scene, "facemask_bake_blur_size")
+        col.prop(context.scene, "facemask_bake_display_scale")
+        if strip.type == "MOVIE":
+            col.prop(context.scene, "facemask_bake_format")
+
+        box.separator()
+
+        baked_path = strip.get("facemask_baked_filepath", "")
+        has_baked = bool(baked_path and os.path.exists(bpy.path.abspath(baked_path)))
+        source_mode = strip.get("facemask_source_mode", "original")
+
+        if not has_baked:
+            # 初回: Bakeのみ
+            box.operator(
+                "sequencer.bake_and_swap_blur_source",
+                text="Bake",
+                icon='RENDER_STILL',
+            )
+        else:
+            # Bake済み: ソース切り替え + Re-bake
+            row = box.row(align=True)
+            if source_mode == "baked":
+                row.operator(
+                    "sequencer.restore_original_source",
+                    text="Restore Original",
+                    icon='LOOP_BACK',
+                )
+            else:
+                row.operator(
+                    "sequencer.swap_to_baked_blur",
+                    text="Swap to Baked",
+                    icon='PLAY',
+                )
+            row.operator(
+                "sequencer.force_rebake_blur",
+                text="Re-bake",
+                icon='FILE_REFRESH',
             )
 
 

requirements.txt

@@ -0,0 +1,7 @@
+ultralytics
+opencv-python-headless
+msgpack
+numpy
+fastapi
+uvicorn
+pydantic

server/detector.py

@@ -1,28 +1,36 @@
 """
-YOLOv8 Face Detector using PyTorch with ROCm support.
+YOLOv8 Head Detector using CrowdHuman-trained model with PyTorch ROCm support.
 
-This module provides high-performance face detection using
-YOLOv8-face model with AMD GPU (ROCm) acceleration.
+Directly detects human heads (frontal, profile, rear) using the Owen718
+CrowdHuman YOLOv8 model, which was trained on dense crowd scenes.
 """
 
 import os
 from typing import List, Tuple, Optional
-from pathlib import Path
 import numpy as np
 
 
-class YOLOFaceDetector:
-    """
-    YOLOv8 face detector with PyTorch ROCm support.
+def _download_model(dest_path: str):
+    """モデルが存在しない場合に手動ダウンロード手順を表示して例外を送出する。"""
+    gdrive_id = "1qlBmiEU4GBV13fxPhLZqjhjBbREvs8-m"
+    raise RuntimeError(
+        f"モデルファイルが見つかりません: {dest_path}\n"
+        "以下の手順でダウンロードしてください:\n"
+        f"  1. https://drive.google.com/file/d/{gdrive_id} を開く\n"
+        f"  2. ダウンロードしたファイルを {dest_path} に配置する"
+    )
 
-    Features:
-    - ROCm GPU acceleration for AMD GPUs
-    - High accuracy face detection
-    - Automatic NMS for overlapping detections
+
+class YOLOHeadDetector:
+    """
+    Head detector using CrowdHuman-trained YOLOv8 model with PyTorch ROCm support.
+
+    Directly detects heads (class 0: head) without pose estimation,
+    enabling robust detection of rear-facing, side-facing, and partially
+    visible people in dense crowd scenes.
     """
 
-    # Default model path relative to this file
-    DEFAULT_MODEL = "yolov8n-face-lindevs.pt"
+    DEFAULT_MODEL = os.path.join("models", "crowdhuman_yolov8_head.pt")
 
     def __init__(
         self,
@@ -31,15 +39,6 @@ class YOLOFaceDetector:
         iou_threshold: float = 0.45,
         input_size: Tuple[int, int] = (640, 640),
     ):
-        """
-        Initialize the YOLO face detector.
-
-        Args:
-            model_path: Path to PyTorch model file. If None, uses default model.
-            conf_threshold: Confidence threshold for detections
-            iou_threshold: IoU threshold for NMS
-            input_size: Model input size (width, height)
-        """
         self.conf_threshold = conf_threshold
         self.iou_threshold = iou_threshold
         self.input_size = input_size
@@ -49,23 +48,20 @@ class YOLOFaceDetector:
 
     @property
     def model(self):
-        """Lazy-load YOLO model."""
+        """Lazy-load YOLO head detection model."""
         if self._model is None:
             from ultralytics import YOLO
             import torch
 
-            # Determine model path
-            if self._model_path is None:
-                # Assuming models are in ../models relative to server/detector.py
-                models_dir = Path(__file__).parent.parent / "models"
-                model_path = str(models_dir / self.DEFAULT_MODEL)
-            else:
+            if self._model_path is not None:
+                if not os.path.exists(self._model_path):
+                    raise FileNotFoundError(f"Model not found: {self._model_path}")
                 model_path = self._model_path
-
+            else:
+                model_path = self.DEFAULT_MODEL
                 if not os.path.exists(model_path):
-                raise FileNotFoundError(f"Model not found: {model_path}")
+                    _download_model(model_path)
 
-            # Detect device (ROCm GPU or CPU)
             if torch.cuda.is_available():
                 self._device = 'cuda'
                 device_name = torch.cuda.get_device_name(0)
@@ -74,25 +70,32 @@ class YOLOFaceDetector:
                 self._device = 'cpu'
                 print("[FaceMask] Using CPU for inference (ROCm GPU not available)")
 
-            # Load model (let Ultralytics handle device management)
             try:
                 self._model = YOLO(model_path)
-                # Don't call .to() - let predict() handle device assignment
-                print(f"[FaceMask] Model loaded, will use device: {self._device}")
+                print(f"[FaceMask] Head detection model loaded: {model_path}")
+                print(f"[FaceMask] Device: {self._device}")
             except Exception as e:
                 print(f"[FaceMask] Error loading model: {e}")
                 import traceback
                 traceback.print_exc()
                 raise
 
-            print(f"[FaceMask] YOLO model loaded: {model_path}")
-            print(f"[FaceMask] Device: {self._device}")
-
         return self._model
 
+    def _results_to_detections(self, result) -> List[Tuple[int, int, int, int, float]]:
+        """Convert a single YOLO result to (x, y, w, h, conf) tuples."""
+        if result.boxes is None:
+            return []
+        detections = []
+        for box in result.boxes:
+            conf = float(box.conf[0].cpu().numpy())
+            x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
+            detections.append((int(x1), int(y1), int(x2 - x1), int(y2 - y1), conf))
+        return detections
+
     def detect(self, frame: np.ndarray) -> List[Tuple[int, int, int, int, float]]:
         """
-        Detect faces in a frame.
+        Detect heads in a frame.
 
         Args:
             frame: BGR image as numpy array (H, W, C)
@@ -100,7 +103,6 @@ class YOLOFaceDetector:
         Returns:
             List of detections as (x, y, width, height, confidence)
         """
-        # Run inference
         import torch
         print(f"[FaceMask] Inference device: {self._device}, CUDA available: {torch.cuda.is_available()}")
         try:
@@ -116,7 +118,6 @@ class YOLOFaceDetector:
             print(f"[FaceMask] ERROR during inference: {e}")
             import traceback
             traceback.print_exc()
-            # Fallback to CPU
             print("[FaceMask] Falling back to CPU inference...")
             self._device = 'cpu'
             results = self.model.predict(
@@ -128,24 +129,49 @@ class YOLOFaceDetector:
                 device='cpu',
             )
 
-        # Extract detections
-        detections = []
-        if len(results) > 0 and results[0].boxes is not None:
-            boxes = results[0].boxes
-            for box in boxes:
-                # Get coordinates in xyxy format
-                x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
-                conf = float(box.conf[0].cpu().numpy())
+        if results:
+            return self._results_to_detections(results[0])
+        return []
 
-                # Convert to x, y, width, height
-                x = int(x1)
-                y = int(y1)
-                w = int(x2 - x1)
-                h = int(y2 - y1)
+    def detect_batch(self, frames: List[np.ndarray]) -> List[List[Tuple[int, int, int, int, float]]]:
+        """
+        Detect heads in multiple frames at once (batch processing).
 
-                detections.append((x, y, w, h, conf))
+        Args:
+            frames: List of BGR images as numpy arrays (H, W, C)
 
-        return detections
+        Returns:
+            List of detection lists, one per frame.
+            Each detection: (x, y, width, height, confidence)
+        """
+        if not frames:
+            return []
+
+        try:
+            results = self.model.predict(
+                frames,
+                conf=self.conf_threshold,
+                iou=self.iou_threshold,
+                imgsz=self.input_size[0],
+                verbose=False,
+                device=self._device,
+            )
+        except Exception as e:
+            print(f"[FaceMask] ERROR during batch inference: {e}")
+            import traceback
+            traceback.print_exc()
+            print("[FaceMask] Falling back to CPU inference...")
+            self._device = 'cpu'
+            results = self.model.predict(
+                frames,
+                conf=self.conf_threshold,
+                iou=self.iou_threshold,
+                imgsz=self.input_size[0],
+                verbose=False,
+                device='cpu',
+            )
+
+        return [self._results_to_detections(r) for r in results]
 
     def generate_mask(
         self,
@@ -155,11 +181,11 @@ class YOLOFaceDetector:
         feather_radius: int = 20,
     ) -> np.ndarray:
         """
-        Generate a mask image from face detections.
+        Generate a mask image from head detections.
 
         Args:
             frame_shape: Shape of the original frame (height, width, channels)
-            detections: List of face detections (x, y, w, h, conf)
+            detections: List of head detections (x, y, w, h, conf)
             mask_scale: Scale factor for mask region
             feather_radius: Radius for edge feathering
 
@@ -172,25 +198,19 @@ class YOLOFaceDetector:
         mask = np.zeros((height, width), dtype=np.uint8)
 
         for (x, y, w, h, conf) in detections:
-            # Scale the bounding box
             center_x = x + w // 2
             center_y = y + h // 2
-
             scaled_w = int(w * mask_scale)
             scaled_h = int(h * mask_scale)
 
-            # Draw ellipse for natural face shape
             cv2.ellipse(
                 mask,
                 (center_x, center_y),
                 (scaled_w // 2, scaled_h // 2),
-                0,  # angle
-                0, 360,  # arc
-                255,  # color (white)
-                -1,  # filled
+                0, 0, 360,
+                255, -1,
             )
 
-        # Apply Gaussian blur for feathering
         if feather_radius > 0 and len(detections) > 0:
             kernel_size = feather_radius * 2 + 1
             mask = cv2.GaussianBlur(mask, (kernel_size, kernel_size), 0)
@@ -199,12 +219,214 @@ class YOLOFaceDetector:
 
 
 # Singleton instance
-_detector: Optional[YOLOFaceDetector] = None
+_detector: Optional[YOLOHeadDetector] = None
 
 
-def get_detector(**kwargs) -> YOLOFaceDetector:
-    """Get or create the global YOLO detector instance."""
+def get_detector(**kwargs) -> YOLOHeadDetector:
+    """Get or create the global YOLO head detector instance."""
     global _detector
     if _detector is None:
-        _detector = YOLOFaceDetector(**kwargs)
+        _detector = YOLOHeadDetector(**kwargs)
     return _detector
+
+
+# ---------------------------------------------------------------------------
+# Pose-based head detector (YOLOv8 pose estimation)
+# ---------------------------------------------------------------------------
+
+# COCO pose keypoint indices
+_HEAD_KP = [0, 1, 2, 3, 4]      # nose, left_eye, right_eye, left_ear, right_ear
+_SHOULDER_KP = [5, 6]            # left_shoulder, right_shoulder
+_KP_CONF_THRESH = 0.3
+
+
+def _head_bbox_from_pose(
+    kp_xy: np.ndarray,
+    kp_conf: np.ndarray,
+    person_x1: float,
+    person_y1: float,
+    person_x2: float,
+    person_y2: float,
+) -> Tuple[int, int, int, int]:
+    """
+    Estimate head bounding box (x, y, w, h) from COCO pose keypoints.
+
+    Strategy:
+    1. Use head keypoints (0-4: nose, eyes, ears) if visible.
+    2. Fall back to shoulder keypoints (5-6) to infer head position.
+    3. Last resort: use top of the person bounding box.
+    """
+    person_w = max(person_x2 - person_x1, 1.0)
+
+    # --- Step 1: head keypoints ---
+    visible_head = [
+        (float(kp_xy[i][0]), float(kp_xy[i][1]))
+        for i in _HEAD_KP
+        if float(kp_conf[i]) > _KP_CONF_THRESH
+    ]
+    if visible_head:
+        xs = [p[0] for p in visible_head]
+        ys = [p[1] for p in visible_head]
+        kp_x1, kp_y1 = min(xs), min(ys)
+        kp_x2, kp_y2 = max(xs), max(ys)
+        span = max(kp_x2 - kp_x1, kp_y2 - kp_y1, 1.0)
+        cx = (kp_x1 + kp_x2) / 2.0
+        cy = (kp_y1 + kp_y2) / 2.0
+        r = max(span * 0.5, person_w * 0.10)
+        x1 = int(cx - r)
+        y1 = int(cy - r)
+        x2 = int(cx + r)
+        y2 = int(cy + r)
+        return x1, y1, x2 - x1, y2 - y1
+
+    # --- Step 2: shoulder keypoints ---
+    visible_shoulder = [
+        (float(kp_xy[i][0]), float(kp_xy[i][1]))
+        for i in _SHOULDER_KP
+        if float(kp_conf[i]) > _KP_CONF_THRESH
+    ]
+    if visible_shoulder:
+        cx = sum(p[0] for p in visible_shoulder) / len(visible_shoulder)
+        cy_sh = sum(p[1] for p in visible_shoulder) / len(visible_shoulder)
+        if len(visible_shoulder) == 2:
+            sh_width = abs(visible_shoulder[1][0] - visible_shoulder[0][0])
+        else:
+            sh_width = person_w * 0.5
+        r = max(sh_width * 0.3, person_w * 0.12)
+        cy = cy_sh - r * 1.3
+        x1 = int(cx - r)
+        y1 = int(cy - r)
+        x2 = int(cx + r)
+        y2 = int(cy + r)
+        return x1, y1, x2 - x1, y2 - y1
+
+    # --- Step 3: person bbox top ---
+    r = max(person_w * 0.15, 20.0)
+    cx = (person_x1 + person_x2) / 2.0
+    x1 = int(cx - r)
+    y1 = int(person_y1)
+    x2 = int(cx + r)
+    y2 = int(person_y1 + r * 2.0)
+    return x1, y1, x2 - x1, y2 - y1
+
+
+class YOLOPoseHeadDetector:
+    """
+    Head detector using YOLOv8 pose estimation with PyTorch ROCm support.
+
+    Extracts head bounding boxes from COCO pose keypoints (nose, eyes, ears).
+    yolov8l-pose.pt is auto-downloaded by Ultralytics on first use.
+    """
+
+    DEFAULT_MODEL = os.path.join("models", "yolov8l-pose.pt")
+
+    def __init__(
+        self,
+        model_path: Optional[str] = None,
+        conf_threshold: float = 0.25,
+        iou_threshold: float = 0.45,
+        input_size: Tuple[int, int] = (640, 640),
+    ):
+        self.conf_threshold = conf_threshold
+        self.iou_threshold = iou_threshold
+        self.input_size = input_size
+        self._model = None
+        self._model_path = model_path
+        self._device = None
+
+    @property
+    def model(self):
+        """Lazy-load YOLO pose model."""
+        if self._model is None:
+            from ultralytics import YOLO
+            import torch
+
+            model_path = self._model_path if self._model_path is not None else self.DEFAULT_MODEL
+
+            if torch.cuda.is_available():
+                self._device = 'cuda'
+                device_name = torch.cuda.get_device_name(0)
+                print(f"[FaceMask] Using ROCm GPU for pose inference: {device_name}")
+            else:
+                self._device = 'cpu'
+                print("[FaceMask] Using CPU for pose inference (ROCm GPU not available)")
+
+            try:
+                self._model = YOLO(model_path)
+                print(f"[FaceMask] Pose model loaded: {model_path}")
+                print(f"[FaceMask] Device: {self._device}")
+            except Exception as e:
+                print(f"[FaceMask] Error loading pose model: {e}")
+                import traceback
+                traceback.print_exc()
+                raise
+
+        return self._model
+
+    def _results_to_detections(self, result) -> List[Tuple[int, int, int, int, float]]:
+        """Convert a single YOLO pose result to (x, y, w, h, conf) tuples."""
+        detections = []
+        if result.boxes is None or result.keypoints is None:
+            return detections
+
+        boxes = result.boxes
+        keypoints = result.keypoints
+
+        for i, box in enumerate(boxes):
+            conf = float(box.conf[0].cpu().numpy())
+            x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
+
+            kp_data = keypoints.data[i].cpu().numpy()  # shape (17, 3): x, y, conf
+            kp_xy = kp_data[:, :2]
+            kp_conf = kp_data[:, 2]
+
+            hx, hy, hw, hh = _head_bbox_from_pose(
+                kp_xy, kp_conf,
+                float(x1), float(y1), float(x2), float(y2),
+            )
+            detections.append((hx, hy, hw, hh, conf))
+
+        return detections
+
+    def detect_batch(self, frames: List[np.ndarray]) -> List[List[Tuple[int, int, int, int, float]]]:
+        """Detect heads in multiple frames at once (batch processing)."""
+        if not frames:
+            return []
+
+        try:
+            results = self.model.predict(
+                frames,
+                conf=self.conf_threshold,
+                iou=self.iou_threshold,
+                imgsz=self.input_size[0],
+                verbose=False,
+                device=self._device,
+            )
+        except Exception as e:
+            print(f"[FaceMask] ERROR during pose batch inference: {e}")
+            import traceback
+            traceback.print_exc()
+            print("[FaceMask] Falling back to CPU inference...")
+            self._device = 'cpu'
+            results = self.model.predict(
+                frames,
+                conf=self.conf_threshold,
+                iou=self.iou_threshold,
+                imgsz=self.input_size[0],
+                verbose=False,
+                device='cpu',
+            )
+
+        return [self._results_to_detections(r) for r in results]
+
+
+# Pose detector singleton
+_pose_detector: Optional[YOLOPoseHeadDetector] = None
+
+
+def get_pose_detector(**kwargs) -> YOLOPoseHeadDetector:
+    """Get or create the global YOLO pose head detector instance."""
+    global _pose_detector
+    if _pose_detector is None:
+        _pose_detector = YOLOPoseHeadDetector(**kwargs)
+    return _pose_detector

test_quick.sh

@@ -1,73 +0,0 @@
-#!/bin/bash
-# クイックテストスクリプト
-# 処理プロセスが正常に動作するか確認
-
-set -e
-
-echo "=== 顔検出処理のクイックテスト ==="
-echo ""
-
-# 仮想環境の確認
-if [ ! -d ".venv" ]; then
-    echo "エラー: .venv が見つかりません"
-    echo "仮想環境を作成してください: python -m venv .venv"
-    exit 1
-fi
-
-# 環境変数の読み込み
-if [ -f ".env" ]; then
-    echo "環境変数を読み込み中..."
-    export $(cat .env | grep -v '^#' | xargs)
-fi
-
-# 仮想環境をアクティベート
-source .venv/bin/activate
-
-# モデルの確認
-MODEL_PATH="models/yolov8n-face-lindevs.pt"
-if [ ! -f "$MODEL_PATH" ]; then
-    echo "警告: モデルファイルが見つかりません: $MODEL_PATH"
-    echo "デフォルトモデルをダウンロードしてください"
-fi
-
-# テスト画像の確認
-if [ $# -eq 0 ]; then
-    echo "使い方: $0 <画像ファイルまたは動画ファイル>"
-    echo ""
-    echo "例:"
-    echo "  $0 test.jpg"
-    echo "  $0 test.mp4"
-    exit 1
-fi
-
-INPUT_FILE="$1"
-
-if [ ! -f "$INPUT_FILE" ]; then
-    echo "エラー: ファイルが見つかりません: $INPUT_FILE"
-    exit 1
-fi
-
-# ファイルタイプの判定
-EXT="${INPUT_FILE##*.}"
-EXT_LOWER=$(echo "$EXT" | tr '[:upper:]' '[:lower:]')
-
-echo "入力ファイル: $INPUT_FILE"
-echo ""
-
-# GPU情報の表示
-echo "=== GPU情報 ==="
-python -c "import torch; print(f'PyTorch CUDA available: {torch.cuda.is_available()}'); print(f'Device: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else \"CPU\"}') if torch.cuda.is_available() else None" 2>/dev/null || echo "PyTorchが見つかりません"
-echo ""
-
-# テスト実行
-echo "=== 検出テストを開始 ==="
-if [[ "$EXT_LOWER" == "mp4" || "$EXT_LOWER" == "avi" || "$EXT_LOWER" == "mov" ]]; then
-    # 動画の場合は最初の1フレームのみテスト
-    python debug_detector.py --video "$INPUT_FILE" --frame 0
-else
-    # 画像の場合
-    python debug_detector.py --image "$INPUT_FILE"
-fi
-
-echo ""
-echo "=== テスト完了 ==="

test_server_api.py

@@ -1,224 +0,0 @@
-#!/usr/bin/env python3
-"""
-推論サーバーAPIのテストスクリプト
-
-Usage:
-    # サーバーの状態確認
-    python test_server_api.py --status
-
-    # マスク生成のテスト
-    python test_server_api.py --video test.mp4 --output /tmp/masks --start 0 --end 10
-"""
-
-import argparse
-import json
-import time
-import urllib.request
-import urllib.error
-from pathlib import Path
-import sys
-
-
-SERVER_URL = "http://127.0.0.1:8181"
-
-
-def check_status():
-    """サーバーの状態を確認"""
-    try:
-        with urllib.request.urlopen(f"{SERVER_URL}/status", timeout=2) as response:
-            data = json.loads(response.read().decode('utf-8'))
-            print("✓ サーバーは稼働中です")
-            print(f"  Status: {data.get('status')}")
-            print(f"  GPU Available: {data.get('gpu_available')}")
-            if data.get('gpu_device'):
-                print(f"  GPU Device: {data.get('gpu_device')}")
-            if data.get('gpu_count'):
-                print(f"  GPU Count: {data.get('gpu_count')}")
-            if data.get('rocm_version'):
-                print(f"  ROCm Version: {data.get('rocm_version')}")
-            return True
-    except (urllib.error.URLError, ConnectionRefusedError, TimeoutError) as e:
-        print("✗ サーバーに接続できません")
-        print(f"  エラー: {e}")
-        print("\nサーバーを起動してください:")
-        print("  ./run_server.sh")
-        return False
-
-
-def submit_task(video_path, output_dir, start_frame, end_frame, conf, iou, mask_scale):
-    """マスク生成タスクを送信"""
-    data = {
-        "video_path": video_path,
-        "output_dir": output_dir,
-        "start_frame": start_frame,
-        "end_frame": end_frame,
-        "conf_threshold": conf,
-        "iou_threshold": iou,
-        "mask_scale": mask_scale,
-    }
-
-    req = urllib.request.Request(
-        f"{SERVER_URL}/generate",
-        data=json.dumps(data).encode('utf-8'),
-        headers={'Content-Type': 'application/json'},
-        method='POST'
-    )
-
-    try:
-        with urllib.request.urlopen(req) as response:
-            result = json.loads(response.read().decode('utf-8'))
-            return result
-    except urllib.error.HTTPError as e:
-        error_msg = e.read().decode('utf-8')
-        raise RuntimeError(f"サーバーエラー: {error_msg}")
-
-
-def get_task_status(task_id):
-    """タスクの状態を取得"""
-    try:
-        with urllib.request.urlopen(f"{SERVER_URL}/tasks/{task_id}") as response:
-            return json.loads(response.read().decode('utf-8'))
-    except urllib.error.HTTPError:
-        return {"status": "unknown"}
-
-
-def cancel_task(task_id):
-    """タスクをキャンセル"""
-    try:
-        req = urllib.request.Request(
-            f"{SERVER_URL}/tasks/{task_id}/cancel",
-            method='POST'
-        )
-        with urllib.request.urlopen(req):
-            pass
-        return True
-    except urllib.error.HTTPError:
-        return False
-
-
-def monitor_task(task_id, poll_interval=0.5):
-    """タスクの進行状況を監視"""
-    print(f"\nタスクID: {task_id}")
-    print("進行状況を監視中...\n")
-
-    last_progress = -1
-
-    while True:
-        status = get_task_status(task_id)
-        state = status.get('status')
-        progress = status.get('progress', 0)
-        total = status.get('total', 0)
-
-        # 進行状況の表示
-        if progress != last_progress and total > 0:
-            percentage = (progress / total) * 100
-            bar_length = 40
-            filled = int(bar_length * progress / total)
-            bar = '=' * filled + '-' * (bar_length - filled)
-            print(f"\r[{bar}] {progress}/{total} ({percentage:.1f}%)", end='', flush=True)
-            last_progress = progress
-
-        # 終了状態のチェック
-        if state == "completed":
-            print("\n\n✓ 処理が完了しました")
-            print(f"  出力先: {status.get('result_path')}")
-            print(f"  メッセージ: {status.get('message')}")
-            return True
-
-        elif state == "failed":
-            print("\n\n✗ 処理が失敗しました")
-            print(f"  エラー: {status.get('message')}")
-            return False
-
-        elif state == "cancelled":
-            print("\n\n- 処理がキャンセルされました")
-            return False
-
-        time.sleep(poll_interval)
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="推論サーバーAPIのテストスクリプト"
-    )
-
-    # 操作モード
-    mode_group = parser.add_mutually_exclusive_group(required=True)
-    mode_group.add_argument("--status", action="store_true", help="サーバーの状態を確認")
-    mode_group.add_argument("--video", type=str, help="処理する動画ファイル")
-
-    # タスクパラメータ
-    parser.add_argument("--output", type=str, default="/tmp/masks", help="マスク出力先ディレクトリ")
-    parser.add_argument("--start", type=int, default=0, help="開始フレーム")
-    parser.add_argument("--end", type=int, default=10, help="終了フレーム")
-    parser.add_argument("--conf", type=float, default=0.5, help="信頼度閾値")
-    parser.add_argument("--iou", type=float, default=0.45, help="NMS IoU閾値")
-    parser.add_argument("--mask-scale", type=float, default=1.5, help="マスクスケール")
-
-    # その他のオプション
-    parser.add_argument("--no-wait", action="store_true", help="タスク送信後、完了を待たない")
-
-    args = parser.parse_args()
-
-    # 状態確認モード
-    if args.status:
-        check_status()
-        return
-
-    # マスク生成モード
-    print("=== 推論サーバーAPIテスト ===\n")
-
-    # サーバーの確認
-    if not check_status():
-        sys.exit(1)
-
-    # 動画ファイルの確認
-    if not Path(args.video).exists():
-        print(f"\n✗ 動画ファイルが見つかりません: {args.video}")
-        sys.exit(1)
-
-    video_path = str(Path(args.video).absolute())
-    output_dir = str(Path(args.output).absolute())
-
-    print(f"\n動画: {video_path}")
-    print(f"出力先: {output_dir}")
-    print(f"フレーム範囲: {args.start} - {args.end}")
-    print(f"パラメータ: conf={args.conf}, iou={args.iou}, mask_scale={args.mask_scale}")
-
-    # タスクを送信
-    print("\nタスクを送信中...")
-    try:
-        result = submit_task(
-            video_path,
-            output_dir,
-            args.start,
-            args.end,
-            args.conf,
-            args.iou,
-            args.mask_scale
-        )
-    except Exception as e:
-        print(f"\n✗ タスク送信失敗: {e}")
-        sys.exit(1)
-
-    task_id = result['id']
-    print(f"✓ タスクが送信されました (ID: {task_id})")
-
-    # 完了待機
-    if not args.no_wait:
-        try:
-            success = monitor_task(task_id)
-            sys.exit(0 if success else 1)
-        except KeyboardInterrupt:
-            print("\n\n中断されました")
-            print("タスクをキャンセル中...")
-            if cancel_task(task_id):
-                print("✓ タスクをキャンセルしました")
-            sys.exit(130)
-    else:
-        print("\nタスクの状態を確認するには:")
-        print(f"  python test_server_api.py --task-status {task_id}")
-
-
-if __name__ == "__main__":
-    main()