feat(batch): 배치 추론 및 스마트 클립 추출 구현 (Issue #77, #78, #82)

Issue #77 - 배치 Pose/ST-GCN 추론:
- PoseEstimator.extract_batch(): 다중 프레임 GPU 배치 추론
- STGCNClassifier.predict_batch(): 다중 윈도우 배치 예측
- 기존 단일 추론 API 완전 호환

Issue #78 - ProcessPoolExecutor 병렬 시각화:
- BatchProcessor 클래스: 배치 GPU 추론 + CPU 병렬 시각화 통합
- _visualize_worker(): pickle 가능한 워커 함수
- 프레임 순서 보장 로직 구현

Issue #82 - 스마트 클립 추출:
- 낙상 감지 구간만 클립 추출 (전 1초 + 후 2초)
- 비낙상 시 클립 없이 결과 메시지만 반환
- FFmpeg 인코딩 시간 80%+ 감소 (489프레임 -> 90프레임)

테스트: 15개 단위 테스트 작성 및 통과

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

app.py

@@ -314,6 +314,13 @@ def create_probability_graph(
     return fig
 
 
+# -----------------------------------------------------------------------------
+# 스마트 클립 추출 설정 (Issue #82)
+# -----------------------------------------------------------------------------
+CLIP_PRE_FALL_SECONDS = 1.0   # 낙상 전 1초
+CLIP_POST_FALL_SECONDS = 2.0  # 낙상 후 2초
+
+
 # -----------------------------------------------------------------------------
 # 메인 추론 함수
 # -----------------------------------------------------------------------------
@@ -325,7 +332,11 @@ def process_video(
     progress: gr.Progress = gr.Progress()
 ) -> Tuple[Optional[str], Optional[go.Figure], str]:
     """
-    비디오 처리 및 낙상 감지
+    비디오 처리 및 낙상 감지 (스마트 클립 추출)
+
+    Issue #82: 낙상 감지 구간만 클립으로 추출하여 인코딩 시간 대폭 감소
+    - 낙상 감지 시: 낙상 전 1초 + 낙상 후 2초 구간만 추출
+    - 비낙상 시: 낙상 미감지 메시지 반환
 
     Args:
         video_path: 입력 비디오 경로
@@ -334,7 +345,7 @@ def process_video(
         progress: Gradio 진행률 표시
 
     Returns:
-        output_video_path: 결과 비디오 경로
+        output_video_path: 결과 클립 경로 (낙상 감지 시) 또는 None (비낙상)
         probability_graph: 확률 그래프
         result_text: 최종 판정 텍스트
     """
@@ -376,62 +387,104 @@ def process_video(
                     f"60초 이내의 비디오를 업로드하세요."
                 )
 
-        # 출력 비디오 설정 (보안: NamedTemporaryFile 사용)
-        with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp:
-            output_path = tmp.name
-        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-        # Info panel 추가로 높이 80px 증가
-        out = cv2.VideoWriter(output_path, fourcc, fps, (width, height + 80))
+        # 클립 추출을 위한 프레임 수 계산
+        pre_fall_frames = int(fps * CLIP_PRE_FALL_SECONDS)
+        post_fall_frames = int(fps * CLIP_POST_FALL_SECONDS)
 
-        # 처리 루프
+        # 처리 루프 - 프레임 버퍼링 + 낙상 감지
         frame_idx = 0
         frame_indices = []
         probabilities = []
-        fall_detected = False
         max_confidence = 0.0
 
+        # 낙상 감지 추적
+        first_fall_frame = None  # 첫 낙상 감지 프레임
+        fall_detected = False
+
+        # 시각화 프레임 버퍼 (클립 추출용)
+        vis_frame_buffer = []
+        raw_frame_buffer = []  # 원본 프레임 버퍼 (재처리용)
+
         while True:
-            # 프레임 읽기 (프로파일링)
+            # 프레임 읽기
             with pipeline.profiler.profile('video_read'):
                 ret, frame = cap.read()
             if not ret:
                 break
 
+            # 원본 프레임 버퍼에 저장 (클립 추출에 필요)
+            raw_frame_buffer.append(frame.copy())
+
             # 프레임 처리
             vis_frame, info = pipeline.process_frame(frame, frame_idx)
 
+            # 시각화 프레임 버퍼에 저장
+            vis_frame_buffer.append(vis_frame)
+
             # 확률 기록
             if info['confidence'] is not None:
                 frame_indices.append(frame_idx)
                 probabilities.append(info['confidence'])
                 max_confidence = max(max_confidence, info['confidence'])
 
-            # 낙상 감지 확인
-            if info['alert']:
+            # 첫 낙상 감지 시점 기록
+            if info['alert'] and first_fall_frame is None:
+                first_fall_frame = frame_idx
                 fall_detected = True
 
-            # 출력 저장 (프로파일링)
-            with pipeline.profiler.profile('video_write'):
-                out.write(vis_frame)
-
             frame_idx += 1
 
             # 진행률 업데이트
             if frame_idx % 10 == 0:
-                progress_val = 0.2 + 0.7 * (frame_idx / total_frames)
-                progress(progress_val, desc=f"처리 중... ({frame_idx}/{total_frames})")
+                progress_val = 0.2 + 0.6 * (frame_idx / total_frames)
+                progress(progress_val, desc=f"분석 중... ({frame_idx}/{total_frames})")
 
-        # 리소스 해제
         cap.release()
+
+        # 확률 그래프 생성 (항상 생성)
+        progress(0.85, desc="그래프 생성 중...")
+        if frame_indices and probabilities:
+            fig = create_probability_graph(frame_indices, probabilities, fall_threshold)
+        else:
+            fig = None
+
+        # 낙상 미감지 시 클립 없이 반환
+        if not fall_detected or first_fall_frame is None:
+            progress(1.0, desc="완료!")
+            result_text = (
+                f"[Non-Fall] 낙상이 감지되지 않았습니다.\n"
+                f"최대 확률: {max_confidence:.1%}\n"
+                f"분석 프레임: {total_frames}개"
+            )
+            return None, fig, result_text
+
+        # 클립 구간 계산
+        clip_start = max(0, first_fall_frame - pre_fall_frames)
+        clip_end = min(len(vis_frame_buffer), first_fall_frame + post_fall_frames)
+        clip_frames = vis_frame_buffer[clip_start:clip_end]
+
+        if not clip_frames:
+            progress(1.0, desc="완료!")
+            return None, fig, "클립 추출에 실패했습니다."
+
+        # 클립 비디오 생성 (프레임 수 감소로 인코딩 시간 대폭 감소)
+        progress(0.9, desc="클립 인코딩 중...")
+        with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp:
+            output_path = tmp.name
+
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        # Info panel 추가로 높이 80px 증가
+        clip_height, clip_width = clip_frames[0].shape[:2]
+        out = cv2.VideoWriter(output_path, fourcc, fps, (clip_width, clip_height))
+
+        for vis_frame in clip_frames:
+            out.write(vis_frame)
         out.release()
 
         # H.264 코덱으로 재인코딩 (브라우저 호환)
-        progress(0.9, desc="비디오 인코딩 중...")
-        # 보안: NamedTemporaryFile 사용 (CWE-377 방지)
         with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp:
             output_h264 = tmp.name
-        # 보안: subprocess.run 사용 (shell injection 방지)
-        # FFmpeg 인코딩 프로파일링
+
         with pipeline.profiler.profile('ffmpeg_encode'):
             subprocess.run(
                 [
@@ -453,19 +506,18 @@ def process_video(
         else:
             final_output = output_path  # 폴백
 
-        # 확률 그래프 생성
-        progress(0.95, desc="그래프 생성 중...")
-        if frame_indices and probabilities:
-            fig = create_probability_graph(frame_indices, probabilities, fall_threshold)
-        else:
-            fig = None
-
         # 최종 판정
         progress(1.0, desc="완료!")
-        if fall_detected:
-            result_text = f"[FALL DETECTED] 낙상이 감지되었습니다! (최대 확률: {max_confidence:.1%})"
-        else:
-            result_text = f"[Non-Fall] 낙상이 감지되지 않았습니다. (최대 확률: {max_confidence:.1%})"
+        fall_time = first_fall_frame / fps if fps > 0 else 0
+        clip_duration = len(clip_frames) / fps if fps > 0 else 0
+        result_text = (
+            f"[FALL DETECTED] 낙상이 감지되었습니다!\n"
+            f"낙상 시점: {fall_time:.2f}초 (프레임 #{first_fall_frame})\n"
+            f"최대 확률: {max_confidence:.1%}\n"
+            f"클립 길이: {clip_duration:.1f}초 ({len(clip_frames)}프레임)\n"
+            f"원본 대비: {len(clip_frames)}/{total_frames}프레임 "
+            f"({len(clip_frames)/total_frames*100:.1f}% 인코딩)"
+        )
 
         return final_output, fig, result_text