当前位置：首页 > news >正文

PiscCode使用YOLO识别超大分辨率高清视图实践

news 2025/10/5 6:42:40

引言：高分辨率图像中的目标检测挑战

在计算机视觉的实际应用中，我们经常需要处理高分辨率图像——从4K监控视频到亿级像素的卫星影像，从医疗数字病理切片到工业精密检测。传统的目标检测方法在这些场景下面临着严峻挑战：

核心矛盾：小目标在高分辨率图像中占据的像素比例极低，经过深度神经网络的多层下采样后，有效特征信息几乎消失。这就好比在足球场上寻找一枚硬币，传统的"全局观察"方式效果有限。

YOLOHD（YOLO High Definition）正是针对这一挑战提出的创新解决方案。它基于ultralytics YOLO模型，通过智能分块策略将大尺寸图像分解为可管理的小分块，在保持YOLO高效特性的同时，显著提升小目标检测能力。

算法核心思想：分而治之的工程智慧

基本设计哲学

YOLOHD的核心思想源于经典的"分而治之"策略。与直接将整张高分辨率图像输入检测器不同，算法将图像分割成大量重叠的小分块，对每个分块独立运行YOLO检测，最后通过智能融合获得全局检测结果。

与传统方法的区别

# 传统YOLO检测
results = model(frame)  # 直接处理整帧# YOLOHD检测
tiles = generate_adaptive_tiles(frame)  # 生成分块
for tile in tiles:results += model(tile)  # 分块检测
final_results = merge_detections(results)  # 结果融合

技术架构深度解析

1. 多层次分块生成系统

YOLOHD采用三级分块策略，确保不同尺度的目标都能得到适当处理：

金字塔多尺度分块

pyramid_scales = [(1.0, (400, 400), 0.3),   # 基础尺度(0.75, (300, 300), 0.4),  # 中等尺度  (0.5, (200, 200), 0.5),   # 小尺度(0.33, (132, 132), 0.6),  # 超小尺度(1.5, (600, 600), 0.2),   # 放大尺度
]

设计原理：

尺度多样性：从132×132到600×600，覆盖不同尺寸目标
重叠率自适应：小尺度分块采用更高重叠率（60%），防止目标被切割
上下文保留：大尺度分块提供充足的上下文信息

超密集分块网络

对于极端小目标场景，YOLOHD提供了超密集分块配置：

self.ultra_dense_configs = [{'size': (160, 160), 'overlap': 0.7, 'min_size': 32},{'size': (120, 120), 'overlap': 0.75, 'min_size': 24},{'size': (80, 80), 'overlap': 0.8, 'min_size': 16},{'size': (60, 60), 'overlap': 0.85, 'min_size': 12}
]

这种配置实现了真正的"无死角"扫描，特别适合卫星影像、医疗图像等对微小目标检测要求极高的场景。

基于时序的ROI分块

利用视频序列的时空连贯性，在历史检测区域周围生成密集分块：

def _generate_roi_intensive_tiles(self, frame: np.ndarray):if not self.prev_detections:return []for det in self.prev_detections:x1, y1, x2, y2 = det['bbox']# 扩展ROI区域margin_x = int(bbox_width * self.fine_detection_margin * 1.5)margin_y = int(bbox_height * self.fine_detection_margin * 1.5)

这种策略显著提升了视频目标跟踪的稳定性和连续性。

2. 分块质量增强技术

针对小分块中目标特征微弱的问题，YOLOHD集成了图像增强模块：

def _enhance_tile_quality(self, tile: np.ndarray) -> np.ndarray:# YUV色彩空间的亮度通道增强yuv = cv2.cvtColor(tile, cv2.COLOR_BGR2YUV)yuv[:,:,0] = cv2.equalizeHist(yuv[:,:,0])enhanced = cv2.cvtColor(yuv, cv2.COLOR_YUV2BGR)# 锐化增强边缘特征kernel = np.array([[-1,-1,-1], [-1,9,-1], [-1,-1,-1]])enhanced = cv2.filter2D(enhanced, -1, kernel)return enhanced

技术细节：

YUV空间处理：避免RGB空间直接增强导致的颜色失真
选择性增强：只对亮度通道进行直方图均衡化
可控锐化：使用适中的锐化核平衡特征增强和噪声控制

3. 智能置信度补偿机制

小目标检测的固有挑战是特征信息有限导致置信度偏低。YOLOHD通过自适应补偿策略解决这一问题：

if self.confidence_boost:# 基于目标尺寸的置信度补偿size_ratio = min(bbox_width, bbox_height) / 100.0if size_ratio < 0.5:compensation = 1.0 + 0.3 * (0.5 - size_ratio)final_confidence = min(1.0, final_confidence * compensation)

补偿逻辑：

目标越小，补偿幅度越大
设置上限防止过度补偿
保持概率值的合理性

4. 并行处理架构

充分利用现代多核处理器的计算能力：

with ThreadPoolExecutor(max_workers=min(self.max_workers, len(tiles))) as executor:future_to_tile = {executor.submit(self._process_tile, tile, x, y, tile_id, scale): (x, y, tile_id, scale)for x, y, tile, tile_id, scale in tiles}for future in as_completed(future_to_tile):detections = future.result()all_detections.extend(detections)

优化特性：

动态线程管理：根据分块数量自动调整线程数
异步结果收集：边计算边收集，减少等待时间
异常处理：单个分块失败不影响整体流程

5. 宽松的非极大值抑制

由于同一目标可能在多个分块中被检测到，YOLOHD采用宽松的NMS策略：

def _nms(self, detections: List[Dict]) -> List[Dict]:indices = cv2.dnn.NMSBoxes(bboxes=boxes.tolist(),scores=scores.tolist(),score_threshold=0.01,  # 极低的初始阈值nms_threshold=self.nms_threshold  # 宽松的NMS阈值)

设计考虑：

低分数阈值保留更多候选检测
宽松NMS避免误删真实目标
最终通过置信度过滤控制输出质量

参数调优与实践指南

关键参数解析

# 精度优先配置（适合离线分析）
detector = YOLOHDObjectDetector(tile_size=320,           # 较小分块提升小目标检测overlap=0.5,            # 较高重叠率score_threshold=0.25,   # 相对宽松的置信度阈值nms_threshold=0.25,     # 宽松的NMSenable_ultra_dense=True, # 启用超密集分块max_tiles=128,          # 允许更多分块
)# 速度优先配置（适合实时应用）  
detector = YOLOHDObjectDetector(tile_size=640,           # 较大分块减少数量overlap=0.3,            # 较低重叠率max_tiles=64,           # 限制分块数量enable_ultra_dense=False,# 关闭超密集分块max_workers=4,          # 适中并行度
)

分块策略选择建议

常规场景：使用默认金字塔分块
微小目标场景：启用超密集分块
视频序列：利用ROI分块提升连续性
资源受限环境：限制分块数量和大小

性能优化技巧

# 内存友好的批处理
def process_large_image(self, image):tiles = self._generate_adaptive_tiles(image)# 分批处理控制内存使用batch_size = 8all_detections = []for i in range(0, len(tiles), batch_size):batch = tiles[i:i + batch_size]batch_detections = self._process_tile_batch(batch)all_detections.extend(batch_detections)return self._nms(all_detections)

应用场景分析

1. 卫星遥感与航空影像

挑战：船只、车辆等目标在卫星影像中可能只有10-20像素，传统方法极易漏检。

YOLOHD方案：

使用60×60超密集分块扫描
高重叠率确保目标完整性
图像增强改善低对比度目标

2. 医疗影像分析

挑战：细胞、病变区域尺寸微小且对比度低。

YOLOHD方案：

多尺度分块适应不同尺寸特征
置信度补偿提升低对比度目标检测
ROI分块基于解剖学先验知识

3. 工业视觉检测

挑战：微小缺陷检测，实时性要求高。

YOLOHD方案：

平衡分块大小和数量
并行处理满足实时需求
宽松NMS避免漏检

4. 视频监控系统

挑战：远距离小目标检测，时序连续性要求。

YOLOHD方案：

时空连贯性分块提升跟踪稳定性
动态参数调整适应不同场景
高效的并行架构

算法优势与创新点

相对于原生YOLO的改进

小目标检测能力：通过分块策略显著提升微小目标召回率
多尺度适应性：自动适应不同尺寸目标
计算效率：分块并行处理充分利用硬件资源
灵活性：可配置的分块策略适应不同应用场景

工程实践价值

即插即用：基于现有YOLO模型，无需重新训练
参数可调：丰富的配置选项满足不同需求
易于部署：标准Python实现，依赖简单
可扩展性：模块化设计便于功能扩展

局限性与改进方向

当前局限性

计算开销：分块数量增加带来额外计算成本
边界目标处理：分块边界处目标可能被切割
参数敏感：性能对分块参数设置较为敏感
重复检测：同一目标可能在多个分块中被重复检测

完整工具类

import cv2
import random
import numpy as np
from concurrent.futures import ThreadPoolExecutor, as_completed
from typing import List, Dict, Tuple, Optional, Union
import time
import mathclass YOLOHDObjectDetector:def __init__(self,model_path: str = "yolo12x.pt",score_threshold: float = 0.25,  # 进一步降低阈值tile_size: Union[int, Tuple[int, int]] = 320,  # 更小的基础分块overlap: float = 0.5,  # 更大的重叠比例max_workers: int = 1,  # 更多工作线程min_tile_size: int = 160,  # 更小的最小分块adaptive_tiling: bool = True,max_tiles: int = 128,  # 更多分块multi_scale_tiling: bool = True,fine_detection_margin: float = 0.6,  # 更大的边界扩展device: str = 'cuda',nms_threshold: float = 0.25,  # 更宽松的NMSenable_ultra_dense: bool = True,  # 启用超密集分块enable_pyramid_scaling: bool = True,  # 启用金字塔缩放min_object_size: int = 8,  # 最小目标尺寸confidence_boost: bool = True  # 置信度提升):"""超细粒度分块目标检测器 - 增强版新增参数::param enable_ultra_dense: 启用超密集分块模式:param enable_pyramid_scaling: 启用金字塔多尺度缩放:param min_object_size: 最小检测目标尺寸:param confidence_boost: 启用置信度提升策略"""# 参数验证assert 0 <= overlap < 1, "overlap必须在0-1之间"assert min_tile_size > 30, "min_tile_size必须大于30"# 导入YOLOtry:from ultralytics import YOLOexcept ImportError:raise ImportError("请安装ultralytics: pip install ultralytics")# 初始化YOLO检测器self.model = YOLO(model_path)self.device = deviceself.score_threshold = score_thresholdself.nms_threshold = nms_thresholdself.min_object_size = min_object_sizeself.confidence_boost = confidence_boost# 分块参数if isinstance(tile_size, int):self.tile_size = (tile_size, tile_size)else:self.tile_size = tile_sizeself.overlap = overlapself.max_workers = max_workersself.min_tile_size = min_tile_sizeself.adaptive_tiling = adaptive_tilingself.max_tiles = max_tilesself.multi_scale_tiling = multi_scale_tilingself.fine_detection_margin = fine_detection_marginself.enable_ultra_dense = enable_ultra_denseself.enable_pyramid_scaling = enable_pyramid_scaling# 性能统计self.stats = {'detection_time': 0,'frame_count': 0,'tiles_processed': 0,'total_detections': 0,'multi_scale_tiles': 0,'pyramid_scales_used': 0,'ultra_dense_tiles': 0}# 缓存上一帧的检测结果用于智能分块self.prev_detections = []self.prev_frame_size = None# 颜色映射self.category_colors = {}# 预定义超密集分块配置self.ultra_dense_configs = [{'size': (160, 160), 'overlap': 0.7, 'min_size': 32},{'size': (120, 120), 'overlap': 0.75, 'min_size': 24},{'size': (80, 80), 'overlap': 0.8, 'min_size': 16},{'size': (60, 60), 'overlap': 0.85, 'min_size': 12}]def _get_color(self, category_name: str) -> Tuple[int, int, int]:"""获取类别对应的颜色"""if category_name not in self.category_colors:self.category_colors[category_name] = (random.randint(50, 255),random.randint(50, 255),random.randint(50, 255))return self.category_colors[category_name]def _enhance_tile_quality(self, tile: np.ndarray) -> np.ndarray:"""增强分块图像质量"""# 应用直方图均衡化增强对比度if len(tile.shape) == 3:# 转换为YUV色彩空间进行亮度增强yuv = cv2.cvtColor(tile, cv2.COLOR_BGR2YUV)yuv[:,:,0] = cv2.equalizeHist(yuv[:,:,0])enhanced = cv2.cvtColor(yuv, cv2.COLOR_YUV2BGR)# 轻微锐化kernel = np.array([[-1,-1,-1], [-1,9,-1], [-1,-1,-1]])enhanced = cv2.filter2D(enhanced, -1, kernel)return enhancedreturn tiledef _process_tile(self, tile: np.ndarray, x0: int, y0: int, tile_id: int = 0, scale: float = 1.0) -> List[Dict]:"""处理单个分块 - 增强版"""try:original_h, original_w = tile.shape[:2]# 动态调整分块大小策略enhancement_needed = original_h < 200 or original_w < 200if enhancement_needed:tile = self._enhance_tile_quality(tile)# 多尺度处理小分块scales_to_try = [1.0]if original_h < 150 or original_w < 150:scales_to_try.extend([1.5, 2.0])  # 对小分块尝试放大all_detections = []for current_scale in scales_to_try:processed_tile = tile.copy()# 应用缩放if current_scale != 1.0:new_w = int(original_w * current_scale)new_h = int(original_h * current_scale)processed_tile = cv2.resize(processed_tile, (new_w, new_h), interpolation=cv2.INTER_CUBIC)# 使用YOLO进行检测 - 降低置信度阈值以检测更多目标detect_threshold = max(0.1, self.score_threshold * 0.8)  # 进一步降低阈值results = self.model(processed_tile, conf=detect_threshold, device=self.device, verbose=False)for result in results:if result.boxes is not None:boxes = result.boxes.xyxy.cpu().numpy()confidences = result.boxes.conf.cpu().numpy()class_ids = result.boxes.cls.cpu().numpy()for i, (box, conf, class_id) in enumerate(zip(boxes, confidences, class_ids)):# 计算原始坐标scale_factor = scale / current_scalex_min = int(box[0] * scale_factor + x0)y_min = int(box[1] * scale_factor + y0)x_max = int(box[2] * scale_factor + x0)y_max = int(box[3] * scale_factor + y0)category = self.model.names[int(class_id)]# 更宽松的尺寸过滤bbox_width = x_max - x_minbbox_height = y_max - y_minif (bbox_width >= self.min_object_size and bbox_height >= self.min_object_size):# 置信度提升策略final_confidence = float(conf)if self.confidence_boost:# 对小目标给予置信度补偿size_ratio = min(bbox_width, bbox_height) / 100.0if size_ratio < 0.5:final_confidence = min(1.0, final_confidence * (1.0 + 0.3 * (0.5 - size_ratio)))detection = {'bbox': (x_min, y_min, x_max, y_max),'category': category,'score': final_confidence,'tile_id': tile_id,'scale': scale * current_scale,'original_confidence': float(conf)}all_detections.append(detection)return all_detectionsexcept Exception as e:print(f"分块处理错误: {e}")return []def _generate_pyramid_tiles(self, frame: np.ndarray) -> List[Tuple[int, int, np.ndarray, int, float]]:"""生成金字塔多尺度分块"""height, width = frame.shape[:2]tiles = []tile_id = 0# 金字塔尺度配置pyramid_scales = [(1.0, (400, 400), 0.3),   # 基础尺度(0.75, (300, 300), 0.4),  # 中等尺度(0.5, (200, 200), 0.5),   # 小尺度(0.33, (132, 132), 0.6),  # 超小尺度(1.5, (600, 600), 0.2),   # 放大尺度]for scale, (tile_w, tile_h), overlap in pyramid_scales:# 计算实际分块大小actual_tile_w = int(tile_w * scale)actual_tile_h = int(tile_h * scale)step_x = int(actual_tile_w * (1 - overlap))step_y = int(actual_tile_h * (1 - overlap))# 确保最小步长step_x = max(step_x, actual_tile_w // 8)step_y = max(step_y, actual_tile_h // 8)for y in range(0, height, step_y):for x in range(0, width, step_x):y_end = min(y + actual_tile_h, height)x_end = min(x + actual_tile_w, width)tile_height = y_end - ytile_width = x_end - xif tile_height > 40 and tile_width > 40:  # 更小的最小尺寸tile = frame[y:y_end, x:x_end]tiles.append((x, y, tile, tile_id, scale))tile_id += 1self.stats['pyramid_scales_used'] = len(pyramid_scales)return tilesdef _generate_ultra_dense_tiles(self, frame: np.ndarray) -> List[Tuple[int, int, np.ndarray, int, float]]:"""生成超密集分块"""height, width = frame.shape[:2]tiles = []tile_id = 0for config in self.ultra_dense_configs:tile_w, tile_h = config['size']overlap = config['overlap']min_size = config['min_size']step_x = max(1, int(tile_w * (1 - overlap)))step_y = max(1, int(tile_h * (1 - overlap)))# 全图超密集扫描for y in range(0, height, step_y):for x in range(0, width, step_x):y_end = min(y + tile_h, height)x_end = min(x + tile_w, width)if (y_end - y >= min_size and x_end - x >= min_size):tile = frame[y:y_end, x:x_end]tiles.append((x, y, tile, tile_id, 1.0))tile_id += 1# 添加额外的偏移分块if len(tiles) < self.max_tiles * 2:  # 允许更多分块offset_x = x + step_x // 2offset_y = y + step_y // 2if (offset_x + tile_w <= width and offset_y + tile_h <= height):offset_tile = frame[offset_y:offset_y + tile_h, offset_x:offset_x + tile_w]tiles.append((offset_x, offset_y, offset_tile, tile_id, 1.0))tile_id += 1self.stats['ultra_dense_tiles'] = len(tiles)return tilesdef _generate_roi_intensive_tiles(self, frame: np.ndarray) -> List[Tuple[int, int, np.ndarray, int, float]]:"""在感兴趣区域生成超密集分块 - 增强版"""height, width = frame.shape[:2]tiles = []tile_id = 0if not self.prev_detections:return tiles# 对每个历史检测区域进行超密集分块for det in self.prev_detections:x1, y1, x2, y2 = det['bbox']# 更大的扩展ROI区域bbox_width = x2 - x1bbox_height = y2 - y1margin_x = int(bbox_width * self.fine_detection_margin * 1.5)  # 增加扩展margin_y = int(bbox_height * self.fine_detection_margin * 1.5)roi_x1 = max(0, x1 - margin_x)roi_y1 = max(0, y1 - margin_y)roi_x2 = min(width, x2 + margin_x)roi_y2 = min(height, y2 + margin_y)# 在ROI区域内使用超密集分块for config in self.ultra_dense_configs[:2]:  # 使用前两种最密集的配置tile_w, tile_h = config['size']overlap = config['overlap']min_size = config['min_size']step_x = max(1, int(tile_w * (1 - overlap)))step_y = max(1, int(tile_h * (1 - overlap)))for y in range(roi_y1, roi_y2, step_y):for x in range(roi_x1, roi_x2, step_x):y_end = min(y + tile_h, roi_y2)x_end = min(x + tile_w, roi_x2)if y_end - y >= min_size and x_end - x >= min_size:tile = frame[y:y_end, x:x_end]tiles.append((x, y, tile, tile_id, 1.0))tile_id += 1return tilesdef _generate_adaptive_tiles(self, frame: np.ndarray) -> List[Tuple[int, int, np.ndarray, int, float]]:"""生成自适应分块组合 - 增强版"""tiles = []# 1. 金字塔多尺度分块if self.enable_pyramid_scaling:pyramid_tiles = self._generate_pyramid_tiles(frame)tiles.extend(pyramid_tiles)# 2. 超密集分块if self.enable_ultra_dense and len(tiles) < self.max_tiles * 2:ultra_tiles = self._generate_ultra_dense_tiles(frame)tiles.extend(ultra_tiles[:self.max_tiles * 2 - len(tiles)])# 3. ROI密集分块if len(tiles) < self.max_tiles * 2:roi_tiles = self._generate_roi_intensive_tiles(frame)tiles.extend(roi_tiles[:self.max_tiles * 2 - len(tiles)])# 智能去重unique_tiles = []seen_positions = set()for tile in tiles:# 更精细的位置去重pos_key = (tile[0] // 5, tile[1] // 5, tile[3])  # 添加tile_id确保多样性if pos_key not in seen_positions:seen_positions.add(pos_key)unique_tiles.append(tile)if len(unique_tiles) >= self.max_tiles * 2:  # 允许更多分块breakself.stats['multi_scale_tiles'] = len(unique_tiles)return unique_tilesdef _detect_tiles(self, frame: np.ndarray) -> List[Dict]:"""分块检测主函数 - 增强版"""start_time = time.time()# 生成分块tiles = self._generate_adaptive_tiles(frame)if not tiles:return []self.stats['tiles_processed'] += len(tiles)# 并行处理分块 - 使用更多线程all_detections = []with ThreadPoolExecutor(max_workers=min(self.max_workers, len(tiles))) as executor:future_to_tile = {executor.submit(self._process_tile, tile, x, y, tile_id, scale): (x, y, tile_id, scale)for x, y, tile, tile_id, scale in tiles}for future in as_completed(future_to_tile):try:detections = future.result()all_detections.extend(detections)except Exception as e:print(f"分块检测错误: {e}")# 应用更宽松的NMSfinal_detections = self._nms(all_detections)# 保存当前检测结果用于下一帧的智能分块self.prev_detections = final_detectionsself.prev_frame_size = frame.shape[:2]self.stats['detection_time'] += time.time() - start_timeself.stats['total_detections'] += len(final_detections)return final_detectionsdef _nms(self, detections: List[Dict]) -> List[Dict]:"""非极大值抑制 - 更宽松版本"""if not detections:return []# 按类别分组categories = set(det['category'] for det in detections)final_detections = []for category in categories:category_dets = [det for det in detections if det['category'] == category]if not category_dets:continue# 提取边界框和分数boxes = np.array([det['bbox'] for det in category_dets])scores = np.array([det.get('score', 1.0) for det in category_dets])if len(boxes) == 0:continue# 使用更宽松的NMSindices = cv2.dnn.NMSBoxes(bboxes=boxes.tolist(),scores=scores.tolist(),score_threshold=0.01,  # 极低的阈值nms_threshold=self.nms_threshold  # 更宽松的NMS)if indices is not None:indices = indices.flatten()for idx in indices:if idx < len(category_dets):final_detections.append(category_dets[idx])else:# 如果NMS返回空，保留所有检测final_detections.extend(category_dets)return final_detectionsdef _draw_detections(self, frame: np.ndarray, detections: List[Dict]) -> np.ndarray:"""在帧上绘制检测结果 - 增强版"""annotated_frame = frame.copy()for det in detections:x1, y1, x2, y2 = det['bbox']category = det['category']score = det.get('score', 0.0)color = self._get_color(category)# 根据置信度调整框的粗细thickness = max(1, int(4 * score))# 绘制边界框cv2.rectangle(annotated_frame, (x1, y1), (x2, y2), color, thickness)# 绘制更详细的标签label = f"{category} {score:.3f}"(label_width, label_height), baseline = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.4, 1)# 标签背景cv2.rectangle(annotated_frame,(x1, y1 - label_height - baseline - 3),(x1 + label_width, y1),color,-1)# 标签文字cv2.putText(annotated_frame, label, (x1, y1 - baseline - 2),cv2.FONT_HERSHEY_SIMPLEX, 0.4, (255, 255, 255), 1)# 绘制中心点center_x = (x1 + x2) // 2center_y = (y1 + y2) // 2cv2.circle(annotated_frame, (center_x, center_y), 2, color, -1)return annotated_framedef get_performance_stats(self) -> Dict:"""获取性能统计"""if self.stats['frame_count'] > 0:avg_detection = self.stats['detection_time'] / self.stats['frame_count']avg_tiles = self.stats['tiles_processed'] / self.stats['frame_count']avg_detections = self.stats['total_detections'] / self.stats['frame_count']return {'avg_detection_time': f"{avg_detection:.3f}s",'avg_tiles_per_frame': f"{avg_tiles:.1f}",'avg_detections_per_frame': f"{avg_detections:.1f}",'multi_scale_tiles_used': self.stats['multi_scale_tiles'],'pyramid_scales': self.stats['pyramid_scales_used'],'ultra_dense_tiles': self.stats['ultra_dense_tiles'],'total_frames': self.stats['frame_count'],'frame_fps': f"{1 / (avg_detection + 1e-6):.1f}",'min_object_size': self.min_object_size}return {}def reset(self) -> None:"""重置检测器状态"""self.prev_detections.clear()self.stats = {'detection_time': 0,'frame_count': 0,'tiles_processed': 0,'total_detections': 0,'multi_scale_tiles': 0,'pyramid_scales_used': 0,'ultra_dense_tiles': 0}def process_frame(self, frame: np.ndarray, draw: bool = True) -> Tuple[Optional[np.ndarray], List[Dict]]:"""处理单帧图像"""if frame is None or frame.size == 0:return None, []self.stats['frame_count'] += 1# 检测目标detections = self._detect_tiles(frame)# 绘制结果result_frame = self._draw_detections(frame, detections) if draw else framereturn result_frame, detectionsdef do(self, frame: np.ndarray, device=None) -> Optional[np.ndarray]:"""兼容旧版本的do方法"""result_frame, _ = self.process_frame(frame)return result_frame