1406 lines
63 KiB
Python
1406 lines
63 KiB
Python
#!/usr/bin/env python3
|
||
# -*- coding: utf-8 -*-
|
||
"""
|
||
综合录制管理器
|
||
支持屏幕录制和足部视频录制
|
||
"""
|
||
|
||
import cv2
|
||
import numpy as np
|
||
import pyautogui
|
||
import threading
|
||
import time
|
||
from datetime import datetime
|
||
import os
|
||
import logging
|
||
import json
|
||
import base64
|
||
from pathlib import Path
|
||
from typing import Optional, Dict, Any, List
|
||
import sys
|
||
import subprocess
|
||
import signal
|
||
import queue
|
||
# 移除psutil导入，不再需要性能监控
|
||
import gc
|
||
|
||
try:
|
||
from .camera_manager import CameraManager
|
||
from .femtobolt_manager import FemtoBoltManager
|
||
from .pressure_manager import PressureManager
|
||
from .utils.config_manager import ConfigManager
|
||
except ImportError:
|
||
from camera_manager import CameraManager
|
||
from femtobolt_manager import FemtoBoltManager
|
||
from pressure_manager import PressureManager
|
||
from utils.config_manager import ConfigManager
|
||
|
||
class RecordingManager:
|
||
def __init__(self, camera_manager: Optional[CameraManager] = None, db_manager=None,
|
||
femtobolt_manager: Optional[FemtoBoltManager] = None,
|
||
pressure_manager: Optional[PressureManager] = None,
|
||
config_manager: Optional[ConfigManager] = None):
|
||
"""
|
||
初始化录制管理器
|
||
|
||
Args:
|
||
camera_manager: 相机管理器实例
|
||
db_manager: 数据库管理器实例
|
||
femtobolt_manager: FemtoBolt深度相机管理器实例
|
||
pressure_manager: 压力传感器管理器实例
|
||
config_manager: 配置管理器实例
|
||
"""
|
||
self.camera_manager = camera_manager
|
||
self.db_manager = db_manager
|
||
self.femtobolt_manager = femtobolt_manager
|
||
self.pressure_manager = pressure_manager
|
||
|
||
# 配置管理
|
||
self.config_manager = config_manager or ConfigManager()
|
||
|
||
# 录制状态
|
||
self.sync_recording = False
|
||
self.is_recording = False
|
||
self.recording_stop_event = threading.Event()
|
||
|
||
# 会话信息
|
||
self.current_session_id = None
|
||
self.current_patient_id = None
|
||
self.recording_start_time = None
|
||
|
||
# 视频写入器
|
||
self.feet_video_writer = None
|
||
self.screen_video_writer = None
|
||
self.femtobolt_video_writer = None
|
||
|
||
# 录制线程
|
||
self.feet_recording_thread = None
|
||
self.screen_recording_thread = None
|
||
self.femtobolt_recording_thread = None
|
||
self.camera1_recording_thread = None
|
||
self.camera2_recording_thread = None
|
||
|
||
# 共享屏幕采集资源
|
||
self._shared_screen_thread = None
|
||
self._screen_capture_stop_event = threading.Event()
|
||
self._screen_frame_lock = threading.Lock()
|
||
self._latest_screen_frame = None
|
||
self._latest_screen_time = 0.0
|
||
self._screen_frame_event = threading.Event()
|
||
|
||
self._ffmpeg_processes = {}
|
||
self._ffmpeg_meta = {}
|
||
|
||
self._threaded_queues = {}
|
||
self._threaded_threads = {}
|
||
self._threaded_stop_events = {}
|
||
|
||
# 独立的录制参数配置
|
||
self.screen_fps = 25 # 屏幕录制帧率
|
||
self.camera1_fps = 20 # 相机1录制帧率
|
||
self.camera2_fps = 20 # 相机2录制帧率
|
||
self.femtobolt_fps = 15 # FemtoBolt录制帧率
|
||
|
||
# 录制区域
|
||
self.screen_region = None
|
||
self.camera1_region = None
|
||
self.camera2_region = None
|
||
self.femtobolt_region = None
|
||
|
||
# 屏幕尺寸
|
||
self.screen_size = pyautogui.size()
|
||
|
||
# 输出目录
|
||
self.screen_output_dir = None
|
||
self.camera_output_dir = None
|
||
self.femtobolt_output_dir = None
|
||
|
||
# 视频参数
|
||
self.MAX_FRAME_SIZE = (1280, 720) # 最大帧尺寸
|
||
|
||
# 独立的帧率控制参数
|
||
self.screen_current_fps = self.screen_fps
|
||
self.camera1_current_fps = self.camera1_fps
|
||
self.camera2_current_fps = self.camera2_fps
|
||
self.femtobolt_current_fps = self.femtobolt_fps
|
||
|
||
# 区域大小阈值配置 - 根据实际录制场景优化
|
||
self.SMALL_REGION_THRESHOLD = 400 * 300 # 小区域阈值 (120,000像素)
|
||
self.MEDIUM_REGION_THRESHOLD = 800 * 600 # 中等区域阈值 (480,000像素)
|
||
self.LARGE_REGION_THRESHOLD = 1600 * 900 # 大区域阈值 (1,440,000像素)
|
||
|
||
# 基于区域大小的帧率配置 - 大幅降低帧率以减小文件大小
|
||
self.fps_config = {
|
||
'small': {'screen': 12, 'camera': 25, 'femtobolt': 20}, # 小区域：低帧率
|
||
'medium': {'screen': 10, 'camera': 22, 'femtobolt': 18}, # 中等区域：更低帧率
|
||
'large': {'screen': 8, 'camera': 18, 'femtobolt': 15}, # 大区域：很低帧率
|
||
'xlarge': {'screen': 6, 'camera': 15, 'femtobolt': 12} # 超大区域：极低帧率
|
||
}
|
||
|
||
# 移除CPU监控和性能优化参数，使用固定帧率控制
|
||
|
||
# 录制同步控制
|
||
self.recording_sync_barrier = None # 同步屏障
|
||
self.recording_threads = {} # 录制线程字典
|
||
self.recording_start_sync = threading.Event() # 录制开始同步事件
|
||
self.global_recording_start_time = None # 全局录制开始时间
|
||
|
||
# 日志
|
||
self.logger = logging.getLogger(__name__)
|
||
|
||
self.logger.info("录制管理器初始化完成")
|
||
|
||
# 移除系统性能检查方法
|
||
|
||
def _calculate_region_size_category(self, region):
|
||
"""
|
||
根据录制区域大小计算区域类别
|
||
|
||
Args:
|
||
region: 录制区域 (x, y, width, height)
|
||
|
||
Returns:
|
||
str: 区域大小类别 ('small', 'medium', 'large', 'xlarge')
|
||
"""
|
||
if not region or len(region) != 4:
|
||
return 'medium' # 默认中等大小
|
||
|
||
_, _, width, height = region
|
||
area = width * height
|
||
|
||
if area <= self.SMALL_REGION_THRESHOLD:
|
||
return 'small'
|
||
elif area <= self.MEDIUM_REGION_THRESHOLD:
|
||
return 'medium'
|
||
elif area <= self.LARGE_REGION_THRESHOLD:
|
||
return 'large'
|
||
else:
|
||
return 'xlarge'
|
||
|
||
def _set_adaptive_fps_by_region(self, recording_type, region):
|
||
"""
|
||
根据录制区域大小设置自适应帧率
|
||
|
||
Args:
|
||
recording_type: 录制类型 ('screen', 'camera1', 'camera2', 'femtobolt')
|
||
region: 录制区域 (x, y, width, height)
|
||
"""
|
||
size_category = self._calculate_region_size_category(region)
|
||
lookup_key = 'camera' if recording_type in ['camera1', 'camera2'] else recording_type
|
||
target_fps = self.fps_config[size_category][lookup_key]
|
||
|
||
# 计算区域面积用于日志
|
||
_, _, width, height = region
|
||
area = width * height
|
||
|
||
if recording_type == 'screen':
|
||
self.screen_current_fps = target_fps
|
||
elif recording_type == 'camera1':
|
||
self.camera1_current_fps = target_fps
|
||
elif recording_type == 'camera2':
|
||
self.camera2_current_fps = target_fps
|
||
elif recording_type == 'femtobolt':
|
||
self.femtobolt_current_fps = target_fps
|
||
|
||
self.logger.info(f"{recording_type}录制区域解包成功: x={region[0]}, y={region[1]}, w={width}, h={height}")
|
||
self.logger.info(f"{recording_type}录制区域分析: 面积={area:,}像素, 类别={size_category}, 优化帧率={target_fps}fps")
|
||
|
||
# 如果是大区域，提示将启用性能优化
|
||
if size_category in ['large', 'xlarge']:
|
||
self.logger.info(f"{recording_type}大区域检测: 将启用降采样和压缩优化以提升性能")
|
||
|
||
# 移除动态性能调整方法，使用固定帧率控制
|
||
|
||
def _optimize_frame_for_large_region(self, frame, region, recording_type):
|
||
"""
|
||
为大区域录制优化帧数据
|
||
|
||
Args:
|
||
frame: 原始帧数据
|
||
region: 录制区域
|
||
recording_type: 录制类型
|
||
|
||
Returns:
|
||
优化后的帧数据
|
||
"""
|
||
if frame is None:
|
||
return None
|
||
|
||
# 屏幕录制优先保证清晰度：不做降采样，避免字体和图标模糊
|
||
if recording_type == 'screen':
|
||
return frame
|
||
|
||
size_category = self._calculate_region_size_category(region)
|
||
_, _, width, height = region
|
||
|
||
if size_category == 'xlarge':
|
||
scale = 0.5
|
||
elif size_category == 'large':
|
||
scale = 0.6
|
||
elif size_category == 'medium':
|
||
scale = 0.75
|
||
else:
|
||
scale = 0.85
|
||
|
||
if scale < 1.0:
|
||
new_width = max(1, int(width * scale))
|
||
new_height = max(1, int(height * scale))
|
||
downsampled = cv2.resize(frame, (new_width, new_height), interpolation=cv2.INTER_AREA)
|
||
self.logger.debug(f"{recording_type}区域降采样({size_category}): {width}x{height} -> {new_width}x{new_height}")
|
||
frame = cv2.resize(downsampled, (width, height), interpolation=cv2.INTER_LINEAR)
|
||
return frame
|
||
|
||
def _start_shared_screen_capture(self, fps: int):
|
||
"""启动共享屏幕采集线程，单次采集整屏并供各录制线程区域裁剪使用"""
|
||
# 如果线程已在运行，直接返回
|
||
if self._shared_screen_thread and self._shared_screen_thread.is_alive():
|
||
return
|
||
|
||
self._screen_capture_stop_event.clear()
|
||
|
||
def _capture_loop():
|
||
interval = 1.0 / max(1, fps)
|
||
while not self._screen_capture_stop_event.is_set() and self.sync_recording:
|
||
start_t = time.time()
|
||
try:
|
||
screenshot = pyautogui.screenshot() # 全屏一次采集
|
||
full_frame = cv2.cvtColor(np.array(screenshot), cv2.COLOR_RGB2BGR)
|
||
with self._screen_frame_lock:
|
||
self._latest_screen_frame = full_frame
|
||
self._latest_screen_time = start_t
|
||
# 通知有新帧
|
||
self._screen_frame_event.set()
|
||
except Exception as e:
|
||
self.logger.error(f'共享屏幕采集错误: {e}')
|
||
time.sleep(0.01)
|
||
# 精确控制帧率
|
||
elapsed = time.time() - start_t
|
||
sleep_t = interval - elapsed
|
||
if sleep_t > 0:
|
||
time.sleep(sleep_t)
|
||
|
||
self._shared_screen_thread = threading.Thread(target=_capture_loop, daemon=True, name='SharedScreenCaptureThread')
|
||
self._shared_screen_thread.start()
|
||
|
||
def _stop_shared_screen_capture(self):
|
||
"""停止共享屏幕采集线程并清理资源"""
|
||
self._screen_capture_stop_event.set()
|
||
if self._shared_screen_thread and self._shared_screen_thread.is_alive():
|
||
self._shared_screen_thread.join(timeout=2.0)
|
||
self._shared_screen_thread = None
|
||
with self._screen_frame_lock:
|
||
self._latest_screen_frame = None
|
||
self._latest_screen_time = 0.0
|
||
self._screen_frame_event.clear()
|
||
|
||
def _get_latest_screen_frame(self):
|
||
"""线程安全获取最新整屏帧"""
|
||
with self._screen_frame_lock:
|
||
return None if self._latest_screen_frame is None else self._latest_screen_frame.copy()
|
||
|
||
def _get_primary_screen_bounds(self) -> Dict[str, int]:
|
||
try:
|
||
import ctypes
|
||
user32 = ctypes.windll.user32
|
||
w = user32.GetSystemMetrics(0)
|
||
h = user32.GetSystemMetrics(1)
|
||
return {'x': 0, 'y': 0, 'width': int(w), 'height': int(h)}
|
||
except Exception:
|
||
sw, sh = self.screen_size
|
||
return {'x': 0, 'y': 0, 'width': int(sw), 'height': int(sh)}
|
||
|
||
def _get_virtual_desktop_bounds(self) -> Dict[str, int]:
|
||
try:
|
||
import ctypes
|
||
user32 = ctypes.windll.user32
|
||
x = user32.GetSystemMetrics(76) # SM_XVIRTUALSCREEN
|
||
y = user32.GetSystemMetrics(77) # SM_YVIRTUALSCREEN
|
||
w = user32.GetSystemMetrics(78) # SM_CXVIRTUALSCREEN
|
||
h = user32.GetSystemMetrics(79) # SM_CYVIRTUALSCREEN
|
||
return {'x': int(x), 'y': int(y), 'width': int(w), 'height': int(h)}
|
||
except Exception:
|
||
# 回退：使用主屏尺寸，从(0,0)开始
|
||
sw, sh = self.screen_size
|
||
return {'x': 0, 'y': 0, 'width': int(sw), 'height': int(sh)}
|
||
|
||
def start_recording_ffmpeg(self, session_id: str, patient_id: str, screen_location: List[int], fps: int = None) -> Dict[str, Any]:
|
||
result = {'success': False, 'message': ''}
|
||
try:
|
||
x, y, w, h = screen_location
|
||
bounds = self._get_primary_screen_bounds()
|
||
x_clamped = max(bounds['x'], min(int(x), bounds['x'] + bounds['width'] - 1))
|
||
y_clamped = max(bounds['y'], min(int(y), bounds['y'] + bounds['height'] - 1))
|
||
max_w = (bounds['x'] + bounds['width']) - x_clamped
|
||
max_h = (bounds['y'] + bounds['height']) - y_clamped
|
||
w_clamped = max(1, min(int(w), int(max_w)))
|
||
h_clamped = max(1, min(int(h), int(max_h)))
|
||
off_x = x_clamped - bounds['x']
|
||
off_y = y_clamped - bounds['y']
|
||
|
||
file_dir = self.config_manager.get_config_value('FILEPATH', 'path')
|
||
timestamp = datetime.now().strftime('%H%M%S%f')[:-3]
|
||
base_path = os.path.join(file_dir, patient_id, session_id, f'video_{timestamp}')
|
||
os.makedirs(base_path, exist_ok=True)
|
||
screen_video_path = os.path.join(base_path, 'screen.mp4')
|
||
target_fps = fps or self.screen_fps
|
||
ffmpeg_path = None
|
||
if self.config_manager:
|
||
ffmpeg_path = (
|
||
self.config_manager.get_config_value('SCREEN_RECORDING', 'ffmpeg_path', fallback=None) or
|
||
self.config_manager.get_config_value('RECORDING', 'ffmpeg_path', fallback=None)
|
||
)
|
||
if not ffmpeg_path or not os.path.isfile(str(ffmpeg_path)):
|
||
base_dir = os.path.dirname(sys.executable) if getattr(sys, 'frozen', False) else os.path.dirname(os.path.abspath(__file__))
|
||
alt_path = os.path.join(base_dir, 'ffmpeg', 'bin', 'ffmpeg.exe')
|
||
if os.path.isfile(alt_path):
|
||
ffmpeg_path = alt_path
|
||
else:
|
||
result['message'] = '未配置有效的ffmpeg_path，请在配置中设置 SCREEN_RECORDING.ffmpeg_path 或 RECORDING.ffmpeg_path'
|
||
return result
|
||
|
||
cmd = [
|
||
str(ffmpeg_path),
|
||
'-y',
|
||
'-f', 'gdigrab',
|
||
'-framerate', str(target_fps),
|
||
'-draw_mouse', str(int((self.config_manager.get_config_value('SCREEN_RECORDING', 'ffmpeg_draw_mouse', fallback='0') or '0'))),
|
||
'-offset_x', str(off_x),
|
||
'-offset_y', str(off_y),
|
||
'-video_size', f'{w_clamped}x{h_clamped}',
|
||
'-i', 'desktop',
|
||
]
|
||
|
||
codec = (self.config_manager.get_config_value('SCREEN_RECORDING', 'ffmpeg_codec', fallback=None) or
|
||
self.config_manager.get_config_value('RECORDING', 'ffmpeg_codec', fallback=None) or
|
||
'libx264')
|
||
preset = (self.config_manager.get_config_value('SCREEN_RECORDING', 'ffmpeg_preset', fallback=None) or
|
||
self.config_manager.get_config_value('RECORDING', 'ffmpeg_preset', fallback=None) or
|
||
('p1' if codec == 'h264_nvenc' else 'ultrafast'))
|
||
threads = int((self.config_manager.get_config_value('SCREEN_RECORDING', 'ffmpeg_threads', fallback='2') or '2'))
|
||
bframes = int((self.config_manager.get_config_value('SCREEN_RECORDING', 'ffmpeg_bframes', fallback='0') or '0'))
|
||
gop = int((self.config_manager.get_config_value('SCREEN_RECORDING', 'ffmpeg_gop', fallback=str(max(1, int(target_fps*2)))) or str(max(1, int(target_fps*2)))))
|
||
|
||
cmd += ['-c:v', codec]
|
||
# 统一的低CPU选项
|
||
cmd += ['-preset', str(preset)]
|
||
cmd += ['-bf', str(bframes)]
|
||
cmd += ['-g', str(gop)]
|
||
cmd += ['-pix_fmt', 'yuv420p']
|
||
cmd += ['-threads', str(threads)]
|
||
cmd += ['-r', str(target_fps)]
|
||
cmd += [screen_video_path]
|
||
proc = subprocess.Popen(
|
||
cmd,
|
||
stdin=subprocess.PIPE,
|
||
stdout=subprocess.DEVNULL,
|
||
stderr=subprocess.DEVNULL,
|
||
creationflags=getattr(subprocess, 'CREATE_NEW_PROCESS_GROUP', 0)
|
||
)
|
||
self._ffmpeg_processes['screen'] = proc
|
||
self._ffmpeg_meta['screen'] = {'base_path': base_path, 'patient_id': patient_id, 'session_id': session_id, 'video_path': screen_video_path}
|
||
result['success'] = True
|
||
result['message'] = 'ffmpeg录制已启动'
|
||
result['database_updates'] = {
|
||
'session_id': session_id,
|
||
'status': 'recording',
|
||
'video_paths': {
|
||
'screen_video_path': os.path.relpath(screen_video_path, file_dir)
|
||
}
|
||
}
|
||
return result
|
||
except Exception as e:
|
||
result['message'] = f'ffmpeg启动失败: {e}'
|
||
return result
|
||
|
||
def stop_recording_ffmpeg(self, session_id: str = None) -> Dict[str, Any]:
|
||
result = {'success': False, 'message': ''}
|
||
try:
|
||
proc = self._ffmpeg_processes.get('screen')
|
||
meta = self._ffmpeg_meta.get('screen')
|
||
if proc:
|
||
try:
|
||
if proc.stdin and proc.poll() is None:
|
||
try:
|
||
proc.communicate(input=b'q', timeout=2.0)
|
||
except Exception:
|
||
pass
|
||
try:
|
||
proc.send_signal(getattr(signal, 'CTRL_BREAK_EVENT', signal.SIGTERM))
|
||
except Exception:
|
||
pass
|
||
try:
|
||
proc.terminate()
|
||
except Exception:
|
||
pass
|
||
try:
|
||
proc.wait(timeout=3.0)
|
||
except Exception:
|
||
try:
|
||
proc.kill()
|
||
except Exception:
|
||
pass
|
||
finally:
|
||
self._ffmpeg_processes.pop('screen', None)
|
||
result['success'] = True
|
||
result['message'] = 'ffmpeg录制已停止'
|
||
if meta:
|
||
result['database_updates'] = {
|
||
'session_id': meta.get('session_id'),
|
||
'status': 'recorded'
|
||
}
|
||
return result
|
||
except Exception as e:
|
||
result['message'] = f'ffmpeg停止失败: {e}'
|
||
return result
|
||
|
||
def start_recording_threaded(self, session_id: str, patient_id: str, screen_location: List[int], fps: int = None) -> Dict[str, Any]:
|
||
result = {'success': False, 'message': ''}
|
||
try:
|
||
x, y, w, h = screen_location
|
||
file_dir = self.config_manager.get_config_value('FILEPATH', 'path')
|
||
timestamp = datetime.now().strftime('%H%M%S%f')[:-3]
|
||
base_path = os.path.join(file_dir, patient_id, session_id, f'video_{timestamp}')
|
||
os.makedirs(base_path, exist_ok=True)
|
||
screen_video_path = os.path.join(base_path, 'screen.mp4')
|
||
target_fps = fps or self.screen_fps
|
||
try:
|
||
fourcc = cv2.VideoWriter_fourcc(*'avc1')
|
||
except Exception:
|
||
try:
|
||
fourcc = cv2.VideoWriter_fourcc(*'H264')
|
||
except Exception:
|
||
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
|
||
vw = cv2.VideoWriter(screen_video_path, fourcc, target_fps, (w, h))
|
||
if not vw or not vw.isOpened():
|
||
result['message'] = 'VideoWriter初始化失败'
|
||
return result
|
||
q = queue.Queue(maxsize=target_fps * 2)
|
||
stop_event = threading.Event()
|
||
self._threaded_queues['screen'] = q
|
||
self._threaded_stop_events['screen'] = stop_event
|
||
|
||
def _capture():
|
||
self._start_shared_screen_capture(target_fps)
|
||
while not stop_event.is_set():
|
||
full = self._get_latest_screen_frame()
|
||
if full is None:
|
||
time.sleep(0.001)
|
||
continue
|
||
H, W = full.shape[:2]
|
||
x0 = max(0, min(x, W - 1))
|
||
y0 = max(0, min(y, H - 1))
|
||
x1 = max(0, min(x0 + w, W))
|
||
y1 = max(0, min(y0 + h, H))
|
||
if x1 > x0 and y1 > y0:
|
||
crop = full[y0:y1, x0:x1]
|
||
if crop.shape[1] != w or crop.shape[0] != h:
|
||
frame = cv2.resize(crop, (w, h), interpolation=cv2.INTER_AREA)
|
||
else:
|
||
frame = crop
|
||
try:
|
||
q.put_nowait(frame)
|
||
except Exception:
|
||
try:
|
||
_ = q.get_nowait()
|
||
except Exception:
|
||
pass
|
||
try:
|
||
q.put_nowait(frame)
|
||
except Exception:
|
||
pass
|
||
else:
|
||
time.sleep(0.002)
|
||
|
||
def _writer():
|
||
last = time.time()
|
||
interval = 1.0 / max(1, target_fps)
|
||
while not stop_event.is_set():
|
||
try:
|
||
frame = q.get(timeout=0.05)
|
||
except Exception:
|
||
frame = None
|
||
now = time.time()
|
||
if frame is not None:
|
||
vw.write(frame)
|
||
else:
|
||
if now - last < interval:
|
||
time.sleep(interval - (now - last))
|
||
last = now
|
||
try:
|
||
vw.release()
|
||
except Exception:
|
||
pass
|
||
|
||
t1 = threading.Thread(target=_capture, daemon=True, name='ThreadedScreenCapture')
|
||
t2 = threading.Thread(target=_writer, daemon=True, name='ThreadedScreenWriter')
|
||
self._threaded_threads['screen'] = (t1, t2)
|
||
t1.start(); t2.start()
|
||
result['success'] = True
|
||
result['message'] = '线程录制已启动'
|
||
result['database_updates'] = {
|
||
'session_id': session_id,
|
||
'status': 'recording',
|
||
'video_paths': {
|
||
'screen_video_path': os.path.relpath(screen_video_path, file_dir)
|
||
}
|
||
}
|
||
return result
|
||
except Exception as e:
|
||
result['message'] = f'线程录制启动失败: {e}'
|
||
return result
|
||
|
||
def stop_recording_threaded(self, session_id: str = None) -> Dict[str, Any]:
|
||
result = {'success': False, 'message': ''}
|
||
try:
|
||
stop_event = self._threaded_stop_events.get('screen')
|
||
threads = self._threaded_threads.get('screen')
|
||
if stop_event:
|
||
stop_event.set()
|
||
if threads:
|
||
for t in threads:
|
||
try:
|
||
t.join(timeout=2.0)
|
||
except Exception:
|
||
pass
|
||
self._threaded_threads.pop('screen', None)
|
||
self._stop_shared_screen_capture()
|
||
result['success'] = True
|
||
result['message'] = '线程录制已停止'
|
||
return result
|
||
except Exception as e:
|
||
result['message'] = f'线程录制停止失败: {e}'
|
||
return result
|
||
|
||
def start_recording(self, session_id: str, patient_id: str, screen_location: List[int], camera1_location: List[int], camera2_location: List[int], femtobolt_location: List[int], recording_types: List[str] = None) -> Dict[str, Any]:
|
||
"""
|
||
启动同步录制
|
||
|
||
Args:
|
||
session_id: 检测会话ID
|
||
patient_id: 患者ID
|
||
screen_location: 屏幕录制区域 [x, y, w, h]
|
||
camera1_location: 相机1录制区域 [x, y, w, h]
|
||
camera2_location: 相机2录制区域 [x, y, w, h]
|
||
femtobolt_location: FemtoBolt录制区域 [x, y, w, h]
|
||
recording_types: 录制类型列表 ['screen', 'camera', 'feet', 'femtobolt']，默认全部录制
|
||
|
||
Returns:
|
||
Dict: 录制启动状态和信息
|
||
"""
|
||
result = {
|
||
'success': False,
|
||
'session_id': session_id,
|
||
'patient_id': patient_id,
|
||
'recording_start_time': None,
|
||
'video_paths': {
|
||
'camera1_video': None,
|
||
'camera2_video': None,
|
||
'feet_video': None,
|
||
'screen_video': None,
|
||
'femtobolt_video': None
|
||
},
|
||
'message': ''
|
||
}
|
||
|
||
try:
|
||
# 检查是否已在录制
|
||
if self.sync_recording:
|
||
result['message'] = f'已在录制中，当前会话ID: {self.current_session_id}'
|
||
return result
|
||
|
||
# 设置默认录制类型
|
||
recording_types = ['screen']
|
||
|
||
# 验证录制区域参数（仅对启用的录制类型进行验证）
|
||
if 'screen' in recording_types:
|
||
if not screen_location or not isinstance(screen_location, list) or len(screen_location) != 4:
|
||
result['success'] = False
|
||
result['message'] = '屏幕录制区域参数无效或缺失，必须是包含4个元素的数组[x, y, w, h]'
|
||
return result
|
||
|
||
if 'camera1' in recording_types:
|
||
if not camera1_location or not isinstance(camera1_location, list) or len(camera1_location) != 4:
|
||
result['success'] = False
|
||
result['message'] = '相机1录制区域参数无效或缺失，必须是包含4个元素的数组[x, y, w, h]'
|
||
return result
|
||
|
||
if 'camera2' in recording_types:
|
||
if not camera2_location or not isinstance(camera2_location, list) or len(camera2_location) != 4:
|
||
result['success'] = False
|
||
result['message'] = '相机2录制区域参数无效或缺失，必须是包含4个元素的数组[x, y, w, h]'
|
||
return result
|
||
|
||
if 'femtobolt' in recording_types:
|
||
if not femtobolt_location or not isinstance(femtobolt_location, list) or len(femtobolt_location) != 4:
|
||
result['success'] = False
|
||
result['message'] = 'FemtoBolt录制区域参数无效或缺失，必须是包含4个元素的数组[x, y, w, h]'
|
||
return result
|
||
|
||
# 设置录制参数
|
||
self.current_session_id = session_id
|
||
# self.logger.info(f'检测sessionID................: {self.current_session_id}')
|
||
self.current_patient_id = patient_id
|
||
self.screen_region = tuple(screen_location) # [x, y, w, h] -> (x, y, w, h)
|
||
self.camera1_region = tuple(camera1_location) # [x, y, w, h] -> (x, y, w, h)
|
||
self.camera2_region = tuple(camera2_location) # [x, y, w, h] -> (x, y, w, h)
|
||
self.femtobolt_region = tuple(femtobolt_location) # [x, y, w, h] -> (x, y, w, h)
|
||
|
||
strategy = None
|
||
if self.config_manager:
|
||
strategy = (
|
||
self.config_manager.get_config_value('SCREEN_RECORDING', 'strategy', fallback=None) or
|
||
self.config_manager.get_config_value('RECORDING', 'screen_strategy', fallback=None)
|
||
)
|
||
if strategy:
|
||
strategy = str(strategy).lower()
|
||
if strategy in ['ffmpeg', 'threaded']:
|
||
self.sync_recording = True
|
||
if strategy == 'ffmpeg':
|
||
return self.start_recording_ffmpeg(session_id, patient_id, screen_location, fps=self.screen_fps)
|
||
else:
|
||
return self.start_recording_threaded(session_id, patient_id, screen_location, fps=self.screen_fps)
|
||
|
||
# 根据录制区域大小设置自适应帧率
|
||
if 'screen' in recording_types:
|
||
self._set_adaptive_fps_by_region('screen', self.screen_region)
|
||
if 'camera1' in recording_types:
|
||
self._set_adaptive_fps_by_region('camera1', self.camera1_region)
|
||
if 'camera2' in recording_types:
|
||
self._set_adaptive_fps_by_region('camera2', self.camera2_region)
|
||
if 'femtobolt' in recording_types:
|
||
self._set_adaptive_fps_by_region('femtobolt', self.femtobolt_region)
|
||
|
||
# 设置录制同步
|
||
active_recording_count = len([t for t in recording_types if t in ['screen', 'camera1', 'camera2', 'femtobolt']])
|
||
self.recording_sync_barrier = threading.Barrier(active_recording_count)
|
||
self.recording_start_sync.clear()
|
||
self.global_recording_start_time = None
|
||
|
||
self.recording_start_time = datetime.now()
|
||
|
||
# 创建主存储目录
|
||
timestamp = datetime.now().strftime('%H%M%S%f')[:-3] # 精确到毫秒
|
||
file_dir = self.config_manager.get_config_value('FILEPATH', 'path')
|
||
base_path = os.path.join(file_dir, patient_id, session_id,f'video_{timestamp}')
|
||
db_base_path = os.path.join(patient_id, session_id,f'video_{timestamp}')
|
||
|
||
try:
|
||
# 设置目录权限
|
||
self._set_directory_permissions(base_path)
|
||
os.makedirs(base_path, exist_ok=True)
|
||
|
||
except Exception as dir_error:
|
||
self.logger.error(f'创建录制目录失败: {base_path}, 错误: {dir_error}')
|
||
result['success'] = False
|
||
result['message'] = f'创建录制目录失败: {dir_error}'
|
||
return result
|
||
|
||
|
||
camera1_video_path = os.path.join(base_path, 'camera1.mp4')
|
||
camera2_video_path = os.path.join(base_path, 'camera2.mp4')
|
||
screen_video_path = os.path.join(base_path, 'screen.mp4')
|
||
femtobolt_video_path = os.path.join(base_path, 'femtobolt.mp4')
|
||
|
||
|
||
# 准备数据库更新信息，返回给调用方统一处理
|
||
result['database_updates'] = {
|
||
'session_id': session_id,
|
||
'status': 'recording',
|
||
'video_paths': {
|
||
'camera1_video_path': None,
|
||
'camera2_video_path': None,
|
||
'screen_video_path': os.path.join(db_base_path, 'screen.mp4'),
|
||
'femtobolt_video_path': None
|
||
}
|
||
}
|
||
self.logger.debug(f'数据库更新信息已准备 - 会话ID: {session_id}')
|
||
|
||
# 视频编码参数 - 使用浏览器兼容的H.264编解码器
|
||
# 优先使用H.264编码器以确保浏览器兼容性
|
||
try:
|
||
fourcc = cv2.VideoWriter_fourcc(*'avc1') # H.264编码器，浏览器兼容性最好
|
||
except:
|
||
try:
|
||
fourcc = cv2.VideoWriter_fourcc(*'H264') # 备选H.264编码器
|
||
except:
|
||
try:
|
||
fourcc = cv2.VideoWriter_fourcc(*'mp4v') # 备选编解码器
|
||
except:
|
||
fourcc = cv2.VideoWriter_fourcc(*'MJPG') # 最后备选
|
||
|
||
# 根据录制类型选择性地初始化视频写入器，使用各自的自适应帧率
|
||
self.screen_video_writer = None
|
||
self.femtobolt_video_writer = None
|
||
self.camera1_video_writer = None
|
||
self.camera2_video_writer = None
|
||
|
||
if 'camera1' in recording_types:
|
||
self.camera1_video_writer = cv2.VideoWriter(
|
||
camera1_video_path, fourcc, self.camera1_current_fps, (self.camera1_region[2], self.camera1_region[3])
|
||
)
|
||
self.logger.info(f'相机1视频写入器使用帧率: {self.camera1_current_fps}fps')
|
||
|
||
if 'camera2' in recording_types:
|
||
self.camera2_video_writer = cv2.VideoWriter(
|
||
camera2_video_path, fourcc, self.camera2_current_fps, (self.camera2_region[2], self.camera2_region[3])
|
||
)
|
||
self.logger.info(f'相机2视频写入器使用帧率: {self.camera2_current_fps}fps')
|
||
|
||
if 'screen' in recording_types:
|
||
self.screen_video_writer = cv2.VideoWriter(
|
||
screen_video_path, fourcc, self.screen_current_fps, (self.screen_region[2], self.screen_region[3])
|
||
)
|
||
self.logger.info(f'屏幕视频写入器使用帧率: {self.screen_current_fps}fps')
|
||
|
||
if 'femtobolt' in recording_types:
|
||
self.femtobolt_video_writer = cv2.VideoWriter(
|
||
femtobolt_video_path, fourcc, self.femtobolt_current_fps, (self.femtobolt_region[2], self.femtobolt_region[3])
|
||
)
|
||
self.logger.info(f'FemtoBolt视频写入器使用帧率: {self.femtobolt_current_fps}fps')
|
||
|
||
|
||
# 检查相机1视频写入器
|
||
if 'camera1' in recording_types:
|
||
if self.camera1_video_writer and self.camera1_video_writer.isOpened():
|
||
self.logger.info(f'相机1视频写入器初始化成功: {camera1_video_path}')
|
||
else:
|
||
self.logger.error(f'相机1视频写入器初始化失败: {camera1_video_path}')
|
||
else:
|
||
self.logger.info('相机1录制功能已禁用')
|
||
# 检查相机2视频写入器
|
||
if 'camera2' in recording_types:
|
||
if self.camera2_video_writer and self.camera2_video_writer.isOpened():
|
||
self.logger.info(f'相机2视频写入器初始化成功: {camera2_video_path}')
|
||
else:
|
||
self.logger.error(f'相机2视频写入器初始化失败: {camera2_video_path}')
|
||
else:
|
||
self.logger.info('足部录制功能已禁用')
|
||
# 检查屏幕视频写入器
|
||
if 'screen' in recording_types:
|
||
if self.screen_video_writer and self.screen_video_writer.isOpened():
|
||
self.logger.info(f'屏幕视频写入器初始化成功: {screen_video_path}')
|
||
else:
|
||
self.logger.error(f'屏幕视频写入器初始化失败: {screen_video_path}')
|
||
else:
|
||
self.logger.info('屏幕录制功能已禁用')
|
||
|
||
# 检查FemtoBolt视频写入器
|
||
if 'femtobolt' in recording_types:
|
||
if self.femtobolt_video_writer and self.femtobolt_video_writer.isOpened():
|
||
self.logger.info(f'FemtoBolt视频写入器初始化成功: {femtobolt_video_path}')
|
||
else:
|
||
self.logger.error(f'FemtoBolt视频写入器初始化失败: {femtobolt_video_path}')
|
||
else:
|
||
self.logger.info('FemtoBolt录制功能已禁用')
|
||
|
||
# 重置停止事件
|
||
self.recording_stop_event.clear()
|
||
self.sync_recording = True
|
||
|
||
# 启动共享屏幕采集（取所需类型的最大帧率）
|
||
max_needed_fps = 0
|
||
for t in recording_types:
|
||
if t == 'screen':
|
||
max_needed_fps = max(max_needed_fps, self.screen_current_fps)
|
||
elif t == 'camera1':
|
||
max_needed_fps = max(max_needed_fps, self.camera1_current_fps)
|
||
elif t == 'camera2':
|
||
max_needed_fps = max(max_needed_fps, self.camera2_current_fps)
|
||
elif t == 'femtobolt':
|
||
max_needed_fps = max(max_needed_fps, self.femtobolt_current_fps)
|
||
if max_needed_fps > 0:
|
||
self._start_shared_screen_capture(max_needed_fps)
|
||
|
||
# 根据录制类型启动对应的录制线程
|
||
if 'camera1' in recording_types and self.camera1_video_writer and self.camera1_video_writer.isOpened():
|
||
self.camera1_recording_thread = threading.Thread(
|
||
target=self._generic_recording_thread,
|
||
args=('camera1', self.camera1_region, camera1_video_path, self.camera1_video_writer),
|
||
daemon=True,
|
||
name='Camera1RecordingThread'
|
||
)
|
||
self.camera1_recording_thread.start()
|
||
# self.logger.info(f'相机1录制线程已启动 - 区域: {self.camera1_region}, 输出文件: {camera1_video_path}')
|
||
|
||
if 'camera2' in recording_types and self.camera2_video_writer and self.camera2_video_writer.isOpened():
|
||
self.camera2_recording_thread = threading.Thread(
|
||
target=self._generic_recording_thread,
|
||
args=('camera2', self.camera2_region, camera2_video_path, self.camera2_video_writer),
|
||
daemon=True,
|
||
name='Camera2RecordingThread'
|
||
)
|
||
self.camera2_recording_thread.start()
|
||
# self.logger.info(f'相机2录制线程已启动 - 区域: {self.camera2_region}, 输出文件: {camera2_video_path}')
|
||
|
||
if 'screen' in recording_types and self.screen_video_writer and self.screen_video_writer.isOpened():
|
||
self.screen_recording_thread = threading.Thread(
|
||
target=self._generic_recording_thread,
|
||
args=('screen', self.screen_region, screen_video_path, self.screen_video_writer),
|
||
daemon=True,
|
||
name='ScreenRecordingThread'
|
||
)
|
||
self.screen_recording_thread.start()
|
||
# self.logger.info(f'屏幕录制线程已启动 - 区域: {self.screen_region}, 输出文件: {screen_video_path}')
|
||
|
||
if 'femtobolt' in recording_types and self.femtobolt_video_writer and self.femtobolt_video_writer.isOpened():
|
||
self.femtobolt_recording_thread = threading.Thread(
|
||
target=self._generic_recording_thread,
|
||
args=('femtobolt', self.femtobolt_region, femtobolt_video_path, self.femtobolt_video_writer),
|
||
daemon=True,
|
||
name='FemtoBoltRecordingThread'
|
||
)
|
||
self.femtobolt_recording_thread.start()
|
||
# self.logger.info(f'FemtoBolt录制线程已启动 - 区域: {self.femtobolt_region}, 输出文件: {femtobolt_video_path}')
|
||
|
||
result['success'] = True
|
||
result['recording_start_time'] = self.recording_start_time.isoformat()
|
||
result['message'] = '同步录制已启动'
|
||
|
||
self.logger.info(f'同步录制已启动 - 会话ID: {session_id}, 患者ID: {patient_id}')
|
||
|
||
except Exception as e:
|
||
self.logger.error(f'启动同步录制失败: {e}')
|
||
result['message'] = f'启动录制失败: {str(e)}'
|
||
# 清理已创建的写入器
|
||
self._cleanup_video_writers()
|
||
|
||
return result
|
||
|
||
def stop_recording(self, session_id: str = None) -> Dict[str, Any]:
|
||
"""
|
||
停止录制
|
||
|
||
Args:
|
||
session_id: 会话ID，用于验证是否为当前录制会话
|
||
|
||
Returns:
|
||
Dict: 停止录制的结果
|
||
"""
|
||
result = {
|
||
'success': False,
|
||
'session_id': self.current_session_id,
|
||
'message': ''
|
||
}
|
||
|
||
try:
|
||
# 验证会话ID
|
||
if session_id and session_id != self.current_session_id:
|
||
result['message'] = f'会话ID不匹配: 期望 {self.current_session_id}, 收到 {session_id}'
|
||
return result
|
||
|
||
if not self.sync_recording:
|
||
result['message'] = '当前没有进行录制'
|
||
return result
|
||
|
||
strategy = None
|
||
if self.config_manager:
|
||
strategy = (
|
||
self.config_manager.get_config_value('SCREEN_RECORDING', 'strategy', fallback=None) or
|
||
self.config_manager.get_config_value('RECORDING', 'screen_strategy', fallback=None)
|
||
)
|
||
if strategy:
|
||
strategy = str(strategy).lower()
|
||
if strategy in ['ffmpeg', 'threaded']:
|
||
self.sync_recording = False
|
||
self.recording_stop_event.set()
|
||
if strategy == 'ffmpeg':
|
||
res = self.stop_recording_ffmpeg(session_id)
|
||
else:
|
||
res = self.stop_recording_threaded(session_id)
|
||
self.current_session_id = None
|
||
self.current_patient_id = None
|
||
self.recording_start_time = None
|
||
return res
|
||
|
||
# 记录停止时间，确保所有录制线程同时结束
|
||
recording_stop_time = time.time()
|
||
self.logger.info(f'开始停止录制，停止时间: {recording_stop_time}')
|
||
|
||
# 设置停止标志
|
||
self.sync_recording = False
|
||
self.recording_stop_event.set()
|
||
|
||
# 收集活跃的录制线程
|
||
active_threads = []
|
||
if hasattr(self, 'camera1_recording_thread') and self.camera1_recording_thread and self.camera1_recording_thread.is_alive():
|
||
active_threads.append(('camera1', self.camera1_recording_thread))
|
||
if hasattr(self, 'camera2_recording_thread') and self.camera2_recording_thread and self.camera2_recording_thread.is_alive():
|
||
active_threads.append(('camera2', self.camera2_recording_thread))
|
||
if hasattr(self, 'screen_recording_thread') and self.screen_recording_thread and self.screen_recording_thread.is_alive():
|
||
active_threads.append(('screen', self.screen_recording_thread))
|
||
if hasattr(self, 'femtobolt_recording_thread') and self.femtobolt_recording_thread and self.femtobolt_recording_thread.is_alive():
|
||
active_threads.append(('femtobolt', self.femtobolt_recording_thread))
|
||
|
||
# 同时等待所有录制线程结束
|
||
self.logger.info(f'等待 {len(active_threads)} 个录制线程结束')
|
||
for thread_name, thread in active_threads:
|
||
thread.join(timeout=5.0)
|
||
if thread.is_alive():
|
||
self.logger.warning(f'{thread_name}录制线程未能在超时时间内结束')
|
||
else:
|
||
self.logger.info(f'{thread_name}录制线程已结束')
|
||
|
||
# 计算实际录制时长并记录详细信息
|
||
if self.global_recording_start_time:
|
||
actual_recording_duration = recording_stop_time - self.global_recording_start_time
|
||
self.logger.info(f'录制时长统计:')
|
||
self.logger.info(f' 全局开始时间: {self.global_recording_start_time}')
|
||
self.logger.info(f' 全局结束时间: {recording_stop_time}')
|
||
self.logger.info(f' 实际录制时长: {actual_recording_duration:.3f}秒')
|
||
|
||
# 记录各录制类型的预期帧数
|
||
for thread_name, thread in active_threads:
|
||
if thread_name == 'screen':
|
||
expected_frames = int(actual_recording_duration * self.screen_current_fps)
|
||
self.logger.info(f' 屏幕录制预期帧数: {expected_frames}帧 (帧率{self.screen_current_fps}fps)')
|
||
elif thread_name == 'camera1':
|
||
expected_frames = int(actual_recording_duration * self.camera1_current_fps)
|
||
self.logger.info(f' 相机1录制预期帧数: {expected_frames}帧 (帧率{self.camera1_current_fps}fps)')
|
||
elif thread_name == 'camera2':
|
||
expected_frames = int(actual_recording_duration * self.camera2_current_fps)
|
||
self.logger.info(f' 相机2录制预期帧数: {expected_frames}帧 (帧率{self.camera2_current_fps}fps)')
|
||
elif thread_name == 'femtobolt':
|
||
expected_frames = int(actual_recording_duration * self.femtobolt_current_fps)
|
||
self.logger.info(f' FemtoBolt录制预期帧数: {expected_frames}帧 (帧率{self.femtobolt_current_fps}fps)')
|
||
|
||
# 清理视频写入器
|
||
self._cleanup_video_writers()
|
||
# 停止共享屏幕采集
|
||
self._stop_shared_screen_capture()
|
||
|
||
# 准备数据库更新信息，返回给调用方统一处理
|
||
if self.current_session_id:
|
||
result['database_updates'] = {
|
||
'session_id': self.current_session_id,
|
||
'status': 'recorded'
|
||
}
|
||
self.logger.info(f'数据库更新信息已准备 - 会话ID: {self.current_session_id}')
|
||
|
||
result['success'] = True
|
||
result['message'] = '录制已停止'
|
||
|
||
self.logger.info(f'录制已停止 - 会话ID: {self.current_session_id}')
|
||
|
||
# 重置会话信息
|
||
self.current_session_id = None
|
||
self.current_patient_id = None
|
||
self.recording_start_time = None
|
||
|
||
except Exception as e:
|
||
self.logger.error(f'停止录制失败: {e}')
|
||
result['message'] = f'停止录制失败: {str(e)}'
|
||
|
||
return result
|
||
|
||
|
||
def _generic_recording_thread(self, recording_type, region, output_file_name, video_writer):
|
||
"""
|
||
通用录制线程，支持屏幕、相机和FemtoBolt录制
|
||
|
||
Args:
|
||
recording_type: 录制类型 ('screen', 'camera1', 'camera2', 'femtobolt')
|
||
region: 录制区域 (x, y, width, height)
|
||
output_file_name: 输出文件名
|
||
video_writer: 视频写入器对象
|
||
"""
|
||
try:
|
||
self.logger.info(f'{recording_type}录制线程启动 - 区域: {region}, 输出文件: {output_file_name}')
|
||
frame_count = 0
|
||
|
||
# 根据录制类型获取对应的自适应帧率
|
||
if recording_type == 'screen':
|
||
target_fps = self.screen_current_fps
|
||
elif recording_type == 'camera1':
|
||
target_fps = self.camera1_current_fps
|
||
elif recording_type == 'camera2':
|
||
target_fps = self.camera2_current_fps
|
||
elif recording_type == 'femtobolt':
|
||
target_fps = self.femtobolt_current_fps
|
||
else:
|
||
target_fps = 25 # 默认帧率
|
||
|
||
frame_interval = 1.0 / target_fps
|
||
last_frame_time = time.time()
|
||
|
||
self.logger.info(f'{recording_type}录制线程使用帧率: {target_fps}fps')
|
||
|
||
# 等待所有录制线程准备就绪
|
||
if self.recording_sync_barrier:
|
||
self.recording_sync_barrier.wait()
|
||
|
||
# 第一个到达的线程设置全局开始时间
|
||
if self.global_recording_start_time is None:
|
||
self.global_recording_start_time = time.time()
|
||
self.recording_start_sync.set()
|
||
else:
|
||
self.recording_start_sync.wait()
|
||
|
||
# 所有线程从相同时间点开始录制
|
||
recording_start_time = self.global_recording_start_time
|
||
|
||
if not video_writer or not video_writer.isOpened():
|
||
self.logger.error(f'{recording_type}视频写入器初始化失败: {output_file_name}')
|
||
return
|
||
|
||
# 验证并解包region参数
|
||
if not region or len(region) != 4:
|
||
self.logger.error(f'{recording_type}录制区域参数无效: {region}')
|
||
return
|
||
|
||
x, y, w, h = region
|
||
self.logger.info(f'{recording_type}录制区域解包成功: x={x}, y={y}, w={w}, h={h}')
|
||
|
||
while self.sync_recording and not self.recording_stop_event.is_set():
|
||
try:
|
||
current_time = time.time()
|
||
|
||
# 严格的帧率控制 - 确保按照设定的fps精确录制
|
||
elapsed_time = current_time - last_frame_time
|
||
if elapsed_time < frame_interval:
|
||
sleep_time = frame_interval - elapsed_time
|
||
time.sleep(sleep_time)
|
||
current_time = time.time() # 重新获取时间
|
||
|
||
frame = None
|
||
|
||
# 获取帧数据 - 从共享整屏帧进行区域裁剪
|
||
full_frame = self._get_latest_screen_frame()
|
||
if full_frame is None:
|
||
# 若共享帧尚未就绪，退化为单次全屏采集
|
||
try:
|
||
screenshot = pyautogui.screenshot()
|
||
full_frame = cv2.cvtColor(np.array(screenshot), cv2.COLOR_RGB2BGR)
|
||
except Exception as e:
|
||
self.logger.error(f'{recording_type}备用屏幕采集失败: {e}')
|
||
full_frame = None
|
||
|
||
if full_frame is not None:
|
||
H, W = full_frame.shape[:2]
|
||
x0 = max(0, min(x, W-1))
|
||
y0 = max(0, min(y, H-1))
|
||
x1 = max(0, min(x0 + w, W))
|
||
y1 = max(0, min(y0 + h, H))
|
||
if x1 > x0 and y1 > y0:
|
||
crop = full_frame[y0:y1, x0:x1]
|
||
if (x1 - x0) != w or (y1 - y0) != h:
|
||
frame = cv2.resize(crop, (w, h), interpolation=cv2.INTER_AREA)
|
||
else:
|
||
frame = crop
|
||
else:
|
||
frame = None
|
||
else:
|
||
frame = None
|
||
|
||
# 对所有区域录制进行优化以减小文件大小
|
||
frame = self._optimize_frame_for_large_region(frame, region, recording_type)
|
||
|
||
# 写入视频帧
|
||
if frame is not None:
|
||
video_writer.write(frame)
|
||
frame_count += 1
|
||
else:
|
||
self.logger.warning(f'{recording_type}获取帧失败，跳过此帧')
|
||
|
||
last_frame_time = current_time
|
||
|
||
except Exception as e:
|
||
self.logger.error(f'{recording_type}录制线程错误: {e}')
|
||
time.sleep(0.1)
|
||
|
||
# 计算录制统计信息
|
||
if self.global_recording_start_time:
|
||
total_recording_time = time.time() - self.global_recording_start_time
|
||
expected_frames = int(total_recording_time * target_fps)
|
||
if abs(frame_count - expected_frames) > target_fps * 0.1: # 如果帧数差异超过0.1秒的帧数
|
||
self.logger.warning(f'{recording_type}帧数异常: 实际{frame_count}帧 vs 预期{expected_frames}帧，差异{frame_count - expected_frames}帧')
|
||
else:
|
||
self.logger.info(f'{recording_type}录制线程结束，总帧数: {frame_count}')
|
||
|
||
except Exception as e:
|
||
self.logger.error(f'{recording_type}录制线程异常: {e}')
|
||
finally:
|
||
# 清理资源
|
||
if video_writer:
|
||
try:
|
||
video_writer.release()
|
||
self.logger.info(f'{recording_type}视频写入器已释放')
|
||
except Exception as e:
|
||
self.logger.error(f'释放{recording_type}视频写入器失败: {e}')
|
||
|
||
def _cleanup_video_writers(self):
|
||
"""清理视频写入器"""
|
||
try:
|
||
if hasattr(self, 'feet_video_writer') and self.feet_video_writer:
|
||
self.feet_video_writer.release()
|
||
self.feet_video_writer = None
|
||
self.logger.debug("足部视频写入器已清理")
|
||
|
||
if hasattr(self, 'screen_video_writer') and self.screen_video_writer:
|
||
self.screen_video_writer.release()
|
||
self.screen_video_writer = None
|
||
self.logger.debug("屏幕视频写入器已清理")
|
||
|
||
if hasattr(self, 'femtobolt_video_writer') and self.femtobolt_video_writer:
|
||
self.femtobolt_video_writer.release()
|
||
self.femtobolt_video_writer = None
|
||
self.logger.debug("FemtoBolt视频写入器已清理")
|
||
|
||
except Exception as e:
|
||
self.logger.error(f"清理视频写入器失败: {e}")
|
||
|
||
def _set_directory_permissions(self, path):
|
||
"""设置目录权限"""
|
||
try:
|
||
import subprocess
|
||
import platform
|
||
|
||
if platform.system() == 'Windows':
|
||
try:
|
||
# 为Users用户组授予完全控制权限
|
||
subprocess.run([
|
||
'icacls', path, '/grant', 'Users:(OI)(CI)F'
|
||
], check=True, capture_output=True, text=True)
|
||
|
||
# 为Everyone用户组授予完全控制权限
|
||
subprocess.run([
|
||
'icacls', path, '/grant', 'Everyone:(OI)(CI)F'
|
||
], check=True, capture_output=True, text=True)
|
||
|
||
self.logger.info(f"已设置Windows目录权限（Users和Everyone完全控制）: {path}")
|
||
except subprocess.CalledProcessError as icacls_error:
|
||
self.logger.warning(f"Windows权限设置失败: {icacls_error}")
|
||
else:
|
||
self.logger.info(f"已设置目录权限为777: {path}")
|
||
|
||
except Exception as perm_error:
|
||
self.logger.warning(f"设置目录权限失败: {perm_error}，但目录创建成功")
|
||
|
||
def set_screen_region(self, region):
|
||
"""设置屏幕录制区域"""
|
||
if self.sync_recording:
|
||
self.logger.warning("录制进行中，无法更改区域设置")
|
||
return False
|
||
|
||
self.screen_region = region
|
||
|
||
if self.screen_region:
|
||
x, y, width, height = self.screen_region
|
||
# 确保区域在屏幕范围内
|
||
x = max(0, min(x, self.screen_size[0] - 1))
|
||
y = max(0, min(y, self.screen_size[1] - 1))
|
||
width = min(width, self.screen_size[0] - x)
|
||
height = min(height, self.screen_size[1] - y)
|
||
self.screen_region = (x, y, width, height)
|
||
self.logger.info(f"录制区域已设置: {self.screen_region}")
|
||
else:
|
||
self.logger.info("录制模式已设置: 全屏录制")
|
||
|
||
return True
|
||
|
||
def set_recording_regions(self, screen_region=None, camera_region=None, femtobolt_region=None):
|
||
"""
|
||
设置三个录制区域
|
||
|
||
Args:
|
||
screen_region: 屏幕录制区域 (x, y, width, height)
|
||
camera_region: 相机录制区域 (x, y, width, height)
|
||
femtobolt_region: FemtoBolt录制区域 (x, y, width, height)
|
||
"""
|
||
if self.sync_recording:
|
||
self.logger.warning("录制进行中，无法更改区域设置")
|
||
return False
|
||
|
||
self.screen_region = screen_region
|
||
# 兼容旧参数：如果传入单一camera_region，则同时设置为camera1与camera2区域
|
||
if camera_region is not None:
|
||
self.camera1_region = camera_region
|
||
self.camera2_region = camera_region
|
||
self.femtobolt_region = femtobolt_region
|
||
|
||
self.logger.info(f'录制区域已设置:')
|
||
self.logger.info(f' 屏幕区域: {screen_region}')
|
||
self.logger.info(f' 相机1区域: {self.camera1_region}')
|
||
self.logger.info(f' 相机2区域: {self.camera2_region}')
|
||
self.logger.info(f' FemtoBolt区域: {femtobolt_region}')
|
||
|
||
return True
|
||
|
||
def get_status(self):
|
||
"""获取录制状态"""
|
||
return {
|
||
'recording': self.sync_recording,
|
||
'session_id': self.current_session_id,
|
||
'patient_id': self.current_patient_id,
|
||
'recording_start_time': self.recording_start_time.isoformat() if self.recording_start_time else None,
|
||
'screen_size': self.screen_size,
|
||
'screen_region': self.screen_region,
|
||
'screen_fps': self.screen_fps,
|
||
'camera1_region': self.camera1_region,
|
||
'camera2_region': self.camera2_region,
|
||
'camera1_fps': self.camera1_fps,
|
||
'camera2_fps': self.camera2_fps,
|
||
'feet_writer_active': self.feet_video_writer is not None and self.feet_video_writer.isOpened() if self.feet_video_writer else False,
|
||
'screen_writer_active': self.screen_video_writer is not None and self.screen_video_writer.isOpened() if self.screen_video_writer else False
|
||
}
|
||
|
||
|
||
|
||
def save_detection_images(self, session_id: str, patient_id: str, detection_data: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""
|
||
保存前端传入的检测图片到指定目录
|
||
|
||
Args:
|
||
session_id: 检测会话ID
|
||
patient_id: 患者ID
|
||
detection_data: 前端传入的检测数据，包含base64格式的图片数据
|
||
|
||
Returns:
|
||
Dict: 包含所有采集数据的字典，符合detection_data表结构
|
||
"""
|
||
# 生成采集时间戳
|
||
timestamp = datetime.now().strftime('%H%M%S%f')[:-3] # 精确到毫秒
|
||
file_path = self.config_manager.get_config_value('FILEPATH', 'path')
|
||
data_dir = Path(os.path.join(file_path,patient_id, session_id, f"image_{timestamp}"))
|
||
# 创建数据存储目录
|
||
data_dir.mkdir(parents=True, exist_ok=True)
|
||
|
||
# 设置目录权限为777（完全权限）
|
||
try:
|
||
import stat
|
||
os.chmod(str(data_dir), stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO) # 777权限
|
||
self.logger.debug(f"已设置目录权限为777: {data_dir}")
|
||
except Exception as perm_error:
|
||
self.logger.warning(f"设置目录权限失败: {perm_error}，但目录创建成功")
|
||
|
||
# 初始化数据字典
|
||
data = {
|
||
'session_id': session_id,
|
||
'head_pose': detection_data.get('head_pose'),
|
||
'screen_location': detection_data.get('screen_location'),
|
||
'body_pose': None,
|
||
'body_image': None,
|
||
'foot_data': detection_data.get('foot_data'),
|
||
'foot_data_image': None,
|
||
'foot1_image': None,
|
||
'foot2_image': None,
|
||
'screen_image': None,
|
||
'timestamp': timestamp
|
||
}
|
||
|
||
try:
|
||
# 保存图片数据
|
||
image_fields = [
|
||
('body_image', 'body'),
|
||
('foot1_image', 'foot1'),
|
||
('foot2_image', 'foot2'),
|
||
('foot_data_image', 'foot_data')
|
||
]
|
||
|
||
for field, prefix in image_fields:
|
||
base64_data = detection_data.get(field)
|
||
if base64_data:
|
||
try:
|
||
# 移除base64头部信息
|
||
if ';base64,' in base64_data:
|
||
base64_data = base64_data.split(';base64,')[1]
|
||
|
||
# 解码base64数据
|
||
image_data = base64.b64decode(base64_data)
|
||
|
||
# 生成图片文件名
|
||
filename = f'{prefix}_{timestamp}.jpg'
|
||
file_path = data_dir / filename
|
||
|
||
# 保存图片
|
||
with open(file_path, 'wb') as f:
|
||
f.write(image_data)
|
||
|
||
# 更新数据字典中的图片路径
|
||
|
||
data[field] = str(os.path.join(patient_id, session_id, f"image_{timestamp}", filename))
|
||
self.logger.debug(f'{field}保存成功: {filename}')
|
||
|
||
except Exception as e:
|
||
self.logger.error(f'保存{field}失败: {e}')
|
||
# 屏幕截图
|
||
screen_image = self._capture_screen_image(data_dir, data.get('screen_location'), timestamp=timestamp)
|
||
if screen_image:
|
||
data['screen_image'] = str(os.path.join( patient_id, session_id, f"image_{timestamp}", screen_image))
|
||
|
||
self.logger.debug(f'数据保存完成: {session_id}, 时间戳: {timestamp}')
|
||
|
||
except Exception as e:
|
||
self.logger.error(f'数据保存失败: {e}')
|
||
|
||
return data
|
||
|
||
|
||
|
||
def _capture_screen_image(self, data_dir, screen_location, timestamp) -> Optional[str]:
|
||
"""
|
||
采集屏幕截图，根据screen_region 进行截图
|
||
|
||
Args:
|
||
data_dir: 数据存储目录路径
|
||
|
||
Returns:
|
||
str: 截图文件的相对路径，失败返回None
|
||
"""
|
||
try:
|
||
# 截取屏幕
|
||
if screen_location:
|
||
# 使用指定区域截图
|
||
x, y, width, height = screen_location
|
||
screenshot = pyautogui.screenshot(region=(x, y, width, height))
|
||
else:
|
||
# 全屏截图
|
||
screenshot = pyautogui.screenshot()
|
||
|
||
# 保存截图
|
||
from pathlib import Path
|
||
screen_filename = f'screen_{timestamp}.jpg'
|
||
image_path = Path(data_dir) / screen_filename
|
||
screenshot.save(str(image_path), quality=95, optimize=True)
|
||
|
||
return screen_filename
|
||
|
||
except Exception as e:
|
||
self.logger.error(f'屏幕截图失败: {e}')
|
||
return None
|
||
|
||
|
||
|
||
|
||
# 保持向后兼容的ScreenRecorder类
|
||
class ScreenRecorder:
|
||
def __init__(self, output_dir="recordings", fps=20, quality=80, region=None):
|
||
"""向后兼容的屏幕录制器"""
|
||
self.recording_manager = RecordingManager()
|
||
self.recording_manager.screen_fps = fps
|
||
self.recording_manager.set_screen_region(region)
|
||
self.output_dir = output_dir
|
||
|
||
# 创建输出目录
|
||
if not os.path.exists(output_dir):
|
||
os.makedirs(output_dir)
|
||
|
||
def start_recording(self, filename=None):
|
||
"""开始录制"""
|
||
if filename is None:
|
||
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
|
||
filename = f"screen_record_{timestamp}"
|
||
|
||
# 使用文件名作为会话ID
|
||
session_id = filename
|
||
patient_id = "default"
|
||
|
||
return self.recording_manager.start_recording(session_id, patient_id)
|
||
|
||
def stop_recording(self):
|
||
"""停止录制"""
|
||
return self.recording_manager.stop_recording()
|
||
|
||
def get_status(self):
|
||
"""获取状态"""
|
||
return self.recording_manager.get_status()
|