1481 lines
58 KiB
Python
1481 lines
58 KiB
Python
import sys
|
||
import os
|
||
import cv2
|
||
import time
|
||
import numpy as np
|
||
from collections import defaultdict, deque
|
||
from PyQt5.QtWidgets import QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, QLabel, QPushButton, \
|
||
QFileDialog, QFrame, QScrollArea, QComboBox, QListWidget, QListWidgetItem, QLineEdit, QMessageBox, QDialog, \
|
||
QDialogButtonBox, QFormLayout, QTextEdit
|
||
from PyQt5.QtCore import QTimer, Qt, pyqtSignal, QThread, QDateTime
|
||
from PyQt5.QtGui import QImage, QPixmap, QFont, QPainter, QPen, QColor
|
||
from yolopart.detector import LicensePlateYOLO
|
||
from gate_control import GateController, WhitelistManager
|
||
|
||
#选择使用哪个模块
|
||
# from LPRNET_part.lpr_interface import LPRNmodel_predict
|
||
# from LPRNET_part.lpr_interface import LPRNinitialize_model
|
||
#使用OCR
|
||
# from OCR_part.ocr_interface import LPRNmodel_predict
|
||
# from OCR_part.ocr_interface import LPRNinitialize_model
|
||
# 使用CRNN
|
||
# from CRNN_part.crnn_interface import LPRNmodel_predict
|
||
# from CRNN_part.crnn_interface import LPRNinitialize_model
|
||
|
||
class PlateInputDialog(QDialog):
|
||
"""车牌输入对话框"""
|
||
def __init__(self, title, default_text=""):
|
||
super().__init__()
|
||
self.setWindowTitle(title)
|
||
self.setFixedSize(300, 100)
|
||
self.setWindowModality(Qt.ApplicationModal)
|
||
|
||
layout = QVBoxLayout()
|
||
|
||
# 车牌输入框
|
||
self.plate_input = QLineEdit()
|
||
self.plate_input.setPlaceholderText("请输入车牌号")
|
||
self.plate_input.setText(default_text)
|
||
self.plate_input.setMaxLength(10)
|
||
|
||
# 按钮
|
||
buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
|
||
buttons.accepted.connect(self.accept)
|
||
buttons.rejected.connect(self.reject)
|
||
|
||
layout.addWidget(QLabel("车牌号:"))
|
||
layout.addWidget(self.plate_input)
|
||
layout.addWidget(buttons)
|
||
|
||
self.setLayout(layout)
|
||
|
||
def get_plate_number(self):
|
||
"""获取输入的车牌号"""
|
||
return self.plate_input.text().strip()
|
||
|
||
|
||
class PlateStabilizer:
|
||
"""车牌识别结果稳定器"""
|
||
|
||
def __init__(self, history_size=10, confidence_threshold=0.6, stability_frames=5):
|
||
self.history_size = history_size # 历史帧数量
|
||
self.confidence_threshold = confidence_threshold # 置信度阈值
|
||
self.stability_frames = stability_frames # 稳定帧数要求
|
||
|
||
# 存储每个车牌的历史识别结果
|
||
self.plate_histories = defaultdict(lambda: deque(maxlen=history_size))
|
||
# 存储当前稳定的车牌结果
|
||
self.stable_results = {}
|
||
# 车牌ID计数器
|
||
self.plate_id_counter = 0
|
||
# 车牌位置追踪
|
||
self.plate_positions = {}
|
||
|
||
def calculate_plate_distance(self, pos1, pos2):
|
||
"""计算两个车牌位置的距离"""
|
||
if pos1 is None or pos2 is None:
|
||
return float('inf')
|
||
|
||
# 计算中心点距离
|
||
center1 = ((pos1[0] + pos1[2]) / 2, (pos1[1] + pos1[3]) / 2)
|
||
center2 = ((pos2[0] + pos2[2]) / 2, (pos2[1] + pos2[3]) / 2)
|
||
|
||
return np.sqrt((center1[0] - center2[0])**2 + (center1[1] - center2[1])**2)
|
||
|
||
def match_plates_to_history(self, current_detections):
|
||
"""将当前检测结果匹配到历史记录"""
|
||
matched_plates = {}
|
||
used_ids = set()
|
||
|
||
for detection in current_detections:
|
||
bbox = detection.get('bbox', [0, 0, 0, 0])
|
||
best_match_id = None
|
||
min_distance = float('inf')
|
||
|
||
# 寻找最佳匹配的历史车牌
|
||
for plate_id, last_pos in self.plate_positions.items():
|
||
if plate_id in used_ids:
|
||
continue
|
||
|
||
distance = self.calculate_plate_distance(bbox, last_pos)
|
||
if distance < min_distance and distance < 100: # 距离阈值
|
||
min_distance = distance
|
||
best_match_id = plate_id
|
||
|
||
if best_match_id is not None:
|
||
matched_plates[best_match_id] = detection
|
||
used_ids.add(best_match_id)
|
||
self.plate_positions[best_match_id] = bbox
|
||
else:
|
||
# 创建新的车牌ID
|
||
new_id = f"plate_{self.plate_id_counter}"
|
||
self.plate_id_counter += 1
|
||
matched_plates[new_id] = detection
|
||
self.plate_positions[new_id] = bbox
|
||
|
||
return matched_plates
|
||
|
||
def calculate_confidence(self, plate_text, detection_quality=1.0):
|
||
"""计算识别结果的置信度"""
|
||
if not plate_text or plate_text == "识别失败":
|
||
return 0.0
|
||
|
||
# 基础置信度基于文本长度和字符类型
|
||
base_confidence = 0.5
|
||
|
||
# 长度合理性检查
|
||
if 7 <= len(plate_text) <= 8:
|
||
base_confidence += 0.2
|
||
|
||
# 字符类型检查（中文+字母+数字的组合）
|
||
has_chinese = any('\u4e00' <= char <= '\u9fff' for char in plate_text)
|
||
has_letter = any(char.isalpha() for char in plate_text)
|
||
has_digit = any(char.isdigit() for char in plate_text)
|
||
|
||
if has_chinese and has_letter and has_digit:
|
||
base_confidence += 0.2
|
||
|
||
# 检测质量影响
|
||
confidence = base_confidence * detection_quality
|
||
|
||
return min(confidence, 1.0)
|
||
|
||
def update_and_get_stable_result(self, current_detections, corrected_images, plate_texts):
|
||
"""更新历史记录并返回稳定的识别结果"""
|
||
if not current_detections:
|
||
return []
|
||
|
||
# 匹配当前检测到历史记录
|
||
matched_plates = self.match_plates_to_history(current_detections)
|
||
|
||
stable_results = []
|
||
|
||
for plate_id, detection in matched_plates.items():
|
||
# 获取对应的矫正图像和识别文本
|
||
detection_idx = current_detections.index(detection)
|
||
corrected_image = corrected_images[detection_idx] if detection_idx < len(corrected_images) else None
|
||
plate_text = plate_texts[detection_idx] if detection_idx < len(plate_texts) else "识别失败"
|
||
|
||
# 计算置信度
|
||
confidence = self.calculate_confidence(plate_text)
|
||
|
||
# 添加到历史记录
|
||
history_entry = {
|
||
'text': plate_text,
|
||
'confidence': confidence,
|
||
'detection': detection,
|
||
'corrected_image': corrected_image
|
||
}
|
||
self.plate_histories[plate_id].append(history_entry)
|
||
|
||
# 计算稳定结果
|
||
stable_text = self.get_stable_text(plate_id)
|
||
|
||
if stable_text and stable_text != "识别失败":
|
||
stable_results.append({
|
||
'id': plate_id,
|
||
'class_name': detection['class_name'],
|
||
'corrected_image': corrected_image,
|
||
'plate_number': stable_text,
|
||
'detection': detection
|
||
})
|
||
|
||
return stable_results
|
||
|
||
def get_stable_text(self, plate_id):
|
||
"""获取指定车牌的稳定识别结果"""
|
||
history = self.plate_histories[plate_id]
|
||
|
||
if len(history) < 3: # 历史记录太少，返回最新结果
|
||
return history[-1]['text'] if history else "识别失败"
|
||
|
||
# 统计各种识别结果的加权投票
|
||
text_votes = defaultdict(float)
|
||
total_confidence = 0
|
||
|
||
for entry in history:
|
||
text = entry['text']
|
||
confidence = entry['confidence']
|
||
|
||
if text != "识别失败" and confidence > 0.3:
|
||
text_votes[text] += confidence
|
||
total_confidence += confidence
|
||
|
||
if not text_votes:
|
||
return "识别失败"
|
||
|
||
# 找到得票最高的结果
|
||
best_text = max(text_votes.items(), key=lambda x: x[1])
|
||
|
||
# 检查是否足够稳定（得票率超过阈值）
|
||
vote_ratio = best_text[1] / total_confidence if total_confidence > 0 else 0
|
||
|
||
if vote_ratio >= self.confidence_threshold:
|
||
return best_text[0]
|
||
else:
|
||
# 不够稳定，返回最近的高置信度结果
|
||
recent_high_conf = [entry for entry in list(history)[-5:]
|
||
if entry['confidence'] > 0.5 and entry['text'] != "识别失败"]
|
||
|
||
if recent_high_conf:
|
||
return recent_high_conf[-1]['text']
|
||
else:
|
||
return history[-1]['text']
|
||
|
||
def clear_old_plates(self, current_plate_ids):
|
||
"""清理不再出现的车牌历史记录"""
|
||
# 移除超过一定时间未更新的车牌
|
||
plates_to_remove = []
|
||
for plate_id in self.plate_histories.keys():
|
||
if plate_id not in current_plate_ids:
|
||
plates_to_remove.append(plate_id)
|
||
|
||
for plate_id in plates_to_remove:
|
||
if plate_id in self.plate_histories:
|
||
del self.plate_histories[plate_id]
|
||
if plate_id in self.plate_positions:
|
||
del self.plate_positions[plate_id]
|
||
if plate_id in self.stable_results:
|
||
del self.stable_results[plate_id]
|
||
|
||
class CameraThread(QThread):
|
||
"""摄像头线程类"""
|
||
frame_ready = pyqtSignal(np.ndarray)
|
||
|
||
def __init__(self):
|
||
super().__init__()
|
||
self.camera = None
|
||
self.running = False
|
||
|
||
def start_camera(self):
|
||
"""启动摄像头"""
|
||
self.camera = cv2.VideoCapture(0)
|
||
if self.camera.isOpened():
|
||
self.running = True
|
||
self.start()
|
||
return True
|
||
return False
|
||
|
||
def stop_camera(self):
|
||
"""停止摄像头"""
|
||
self.running = False
|
||
if self.camera:
|
||
self.camera.release()
|
||
self.quit()
|
||
self.wait()
|
||
|
||
def run(self):
|
||
"""线程运行函数"""
|
||
while self.running:
|
||
if self.camera and self.camera.isOpened():
|
||
ret, frame = self.camera.read()
|
||
if ret:
|
||
self.frame_ready.emit(frame)
|
||
self.msleep(30) # 约30fps
|
||
|
||
class VideoThread(QThread):
|
||
"""视频处理线程类"""
|
||
frame_ready = pyqtSignal(np.ndarray)
|
||
video_finished = pyqtSignal()
|
||
|
||
def __init__(self):
|
||
super().__init__()
|
||
self.video_path = None
|
||
self.cap = None
|
||
self.running = False
|
||
self.paused = False
|
||
|
||
def load_video(self, video_path):
|
||
"""加载视频文件"""
|
||
self.video_path = video_path
|
||
self.cap = cv2.VideoCapture(video_path)
|
||
return self.cap.isOpened()
|
||
|
||
def start_video(self):
|
||
"""开始播放视频"""
|
||
if self.cap and self.cap.isOpened():
|
||
self.running = True
|
||
self.paused = False
|
||
self.start()
|
||
return True
|
||
return False
|
||
|
||
def pause_video(self):
|
||
"""暂停/继续视频"""
|
||
self.paused = not self.paused
|
||
return self.paused
|
||
|
||
def stop_video(self):
|
||
"""停止视频"""
|
||
self.running = False
|
||
if self.cap:
|
||
self.cap.release()
|
||
self.quit()
|
||
self.wait()
|
||
|
||
def run(self):
|
||
"""线程运行函数"""
|
||
while self.running:
|
||
if not self.paused and self.cap and self.cap.isOpened():
|
||
ret, frame = self.cap.read()
|
||
if ret:
|
||
self.frame_ready.emit(frame)
|
||
else:
|
||
# 视频播放结束
|
||
self.video_finished.emit()
|
||
self.running = False
|
||
break
|
||
self.msleep(30) # 约30fps
|
||
|
||
class LicensePlateWidget(QWidget):
|
||
"""单个车牌结果显示组件"""
|
||
|
||
def __init__(self, plate_id, class_name, corrected_image, plate_number):
|
||
super().__init__()
|
||
self.plate_id = plate_id
|
||
self.init_ui(class_name, corrected_image, plate_number)
|
||
|
||
def init_ui(self, class_name, corrected_image, plate_number):
|
||
layout = QHBoxLayout()
|
||
layout.setContentsMargins(10, 5, 10, 5)
|
||
layout.setSpacing(8) # 设置组件间距
|
||
|
||
# 车牌类型标签
|
||
type_label = QLabel(class_name)
|
||
type_label.setFixedWidth(60)
|
||
type_label.setAlignment(Qt.AlignCenter)
|
||
type_label.setStyleSheet(
|
||
"QLabel { "
|
||
"background-color: #4CAF50 if class_name == '绿牌' else #2196F3; "
|
||
"color: white; "
|
||
"border-radius: 5px; "
|
||
"padding: 5px; "
|
||
"font-weight: bold; "
|
||
"}"
|
||
)
|
||
if class_name == '绿牌':
|
||
type_label.setStyleSheet(
|
||
"QLabel { "
|
||
"background-color: #4CAF50; "
|
||
"color: white; "
|
||
"border-radius: 5px; "
|
||
"padding: 5px; "
|
||
"font-weight: bold; "
|
||
"}"
|
||
)
|
||
else:
|
||
type_label.setStyleSheet(
|
||
"QLabel { "
|
||
"background-color: #2196F3; "
|
||
"color: white; "
|
||
"border-radius: 5px; "
|
||
"padding: 5px; "
|
||
"font-weight: bold; "
|
||
"}"
|
||
)
|
||
|
||
# 矫正后的车牌图像
|
||
image_label = QLabel()
|
||
image_label.setStyleSheet("border: 1px solid #ddd; background-color: white;")
|
||
|
||
if corrected_image is not None:
|
||
# 转换numpy数组为QPixmap
|
||
h, w = corrected_image.shape[:2]
|
||
if len(corrected_image.shape) == 3:
|
||
bytes_per_line = 3 * w
|
||
q_image = QImage(corrected_image.data, w, h, bytes_per_line, QImage.Format_RGB888).rgbSwapped()
|
||
else:
|
||
bytes_per_line = w
|
||
q_image = QImage(corrected_image.data, w, h, bytes_per_line, QImage.Format_Grayscale8)
|
||
|
||
pixmap = QPixmap.fromImage(q_image)
|
||
|
||
# 动态计算显示尺寸，保持车牌的宽高比
|
||
original_width = pixmap.width()
|
||
original_height = pixmap.height()
|
||
|
||
# 设置最大显示尺寸限制
|
||
max_width = 150
|
||
max_height = 60
|
||
|
||
# 计算缩放比例，确保图像完整显示
|
||
width_ratio = max_width / original_width if original_width > 0 else 1
|
||
height_ratio = max_height / original_height if original_height > 0 else 1
|
||
scale_ratio = min(width_ratio, height_ratio, 1.0) # 不放大，只缩小
|
||
|
||
# 计算实际显示尺寸
|
||
display_width = int(original_width * scale_ratio)
|
||
display_height = int(original_height * scale_ratio)
|
||
|
||
# 确保最小显示尺寸
|
||
display_width = max(display_width, 80)
|
||
display_height = max(display_height, 25)
|
||
|
||
# 设置标签尺寸并缩放图像
|
||
image_label.setFixedSize(display_width, display_height)
|
||
scaled_pixmap = pixmap.scaled(display_width, display_height, Qt.KeepAspectRatio, Qt.SmoothTransformation)
|
||
image_label.setPixmap(scaled_pixmap)
|
||
image_label.setAlignment(Qt.AlignCenter)
|
||
else:
|
||
# 当没有图像时，设置固定尺寸显示提示信息
|
||
image_label.setFixedSize(120, 40)
|
||
image_label.setText("车牌未完全\n进入摄像头")
|
||
image_label.setAlignment(Qt.AlignCenter)
|
||
image_label.setStyleSheet("border: 1px solid #ddd; background-color: #f5f5f5; color: #666;")
|
||
|
||
# 车牌号标签 - 使用自适应宽度
|
||
number_label = QLabel(plate_number)
|
||
number_label.setMinimumWidth(120) # 设置最小宽度
|
||
number_label.setMaximumWidth(200) # 设置最大宽度
|
||
number_label.setAlignment(Qt.AlignCenter)
|
||
number_label.setStyleSheet(
|
||
"QLabel { "
|
||
"border: 1px solid #ddd; "
|
||
"background-color: white; "
|
||
"padding: 8px; "
|
||
"font-family: 'Courier New'; "
|
||
"font-size: 14px; "
|
||
"font-weight: bold; "
|
||
"}"
|
||
)
|
||
# 根据文本长度调整宽度
|
||
font_metrics = number_label.fontMetrics()
|
||
text_width = font_metrics.boundingRect(plate_number).width()
|
||
optimal_width = max(120, min(200, text_width + 20)) # 加20像素的边距
|
||
number_label.setFixedWidth(optimal_width)
|
||
|
||
layout.addWidget(type_label)
|
||
layout.addWidget(image_label)
|
||
layout.addWidget(number_label)
|
||
layout.addStretch()
|
||
|
||
self.setLayout(layout)
|
||
# 调整整体组件的最小高度以适应动态图像尺寸
|
||
min_height = max(60, image_label.height() + 20) # 至少60像素高度
|
||
self.setMinimumHeight(min_height)
|
||
self.setStyleSheet(
|
||
"QWidget { "
|
||
"background-color: white; "
|
||
"border: 1px solid #e0e0e0; "
|
||
"border-radius: 8px; "
|
||
"margin: 2px; "
|
||
"}"
|
||
)
|
||
|
||
class MainWindow(QMainWindow):
|
||
"""主窗口类"""
|
||
|
||
def __init__(self):
|
||
super().__init__()
|
||
self.detector = None
|
||
self.camera_thread = None
|
||
self.video_thread = None
|
||
self.current_frame = None
|
||
self.detections = []
|
||
self.current_mode = "camera" # 当前模式：camera, video, image
|
||
self.is_processing = False # 标志位，表示是否正在处理识别任务
|
||
self.last_plate_results = [] # 存储上一次的车牌识别结果
|
||
self.current_recognition_method = "CRNN" # 当前识别方法
|
||
|
||
# 添加车牌稳定器
|
||
self.plate_stabilizer = PlateStabilizer(
|
||
history_size=15, # 保存15帧历史
|
||
confidence_threshold=0.7, # 70%置信度阈值
|
||
stability_frames=5 # 需要5帧稳定
|
||
)
|
||
|
||
# 初始化道闸控制器和白名单管理器
|
||
self.gate_controller = GateController()
|
||
self.whitelist_manager = WhitelistManager()
|
||
|
||
# 记录车牌首次检测时间和上次发送指令时间
|
||
self.plate_first_detected = {} # 记录车牌首次检测时间
|
||
self.plate_last_command_time = {} # 记录车牌上次发送指令时间
|
||
|
||
self.init_ui()
|
||
self.init_detector()
|
||
self.init_camera()
|
||
self.init_video()
|
||
self.init_gate_control()
|
||
|
||
# 初始化默认识别方法（CRNN）的模型
|
||
self.change_recognition_method(self.current_recognition_method)
|
||
|
||
# 设置定时器，每30秒清理一次过期的车牌记录
|
||
self.cleanup_timer = QTimer(self)
|
||
self.cleanup_timer.timeout.connect(self.cleanup_plate_records)
|
||
self.cleanup_timer.start(30000) # 30秒
|
||
|
||
|
||
def init_ui(self):
|
||
"""初始化用户界面"""
|
||
self.setWindowTitle("车牌识别系统")
|
||
self.setGeometry(100, 100, 1200, 800)
|
||
|
||
# 创建中央widget
|
||
central_widget = QWidget()
|
||
self.setCentralWidget(central_widget)
|
||
|
||
# 创建主布局
|
||
main_layout = QHBoxLayout(central_widget)
|
||
|
||
# 左侧摄像头显示区域
|
||
left_frame = QFrame()
|
||
left_frame.setFrameStyle(QFrame.StyledPanel)
|
||
left_frame.setStyleSheet("QFrame { background-color: #f0f0f0; border: 2px solid #ddd; }")
|
||
left_layout = QVBoxLayout(left_frame)
|
||
|
||
# 摄像头显示标签
|
||
self.camera_label = QLabel()
|
||
self.camera_label.setMinimumSize(640, 480)
|
||
self.camera_label.setStyleSheet("QLabel { background-color: black; border: 1px solid #ccc; }")
|
||
self.camera_label.setAlignment(Qt.AlignCenter)
|
||
self.camera_label.setText("摄像头未启动")
|
||
self.camera_label.setScaledContents(False)
|
||
|
||
# 控制按钮
|
||
button_layout = QHBoxLayout()
|
||
self.start_button = QPushButton("启动摄像头")
|
||
self.stop_button = QPushButton("停止摄像头")
|
||
self.start_button.clicked.connect(self.start_camera)
|
||
self.stop_button.clicked.connect(self.stop_camera)
|
||
self.stop_button.setEnabled(False)
|
||
|
||
# 视频控制按钮
|
||
self.open_video_button = QPushButton("打开视频")
|
||
self.stop_video_button = QPushButton("停止视频")
|
||
self.pause_video_button = QPushButton("暂停视频")
|
||
self.open_video_button.clicked.connect(self.open_video_file)
|
||
self.stop_video_button.clicked.connect(self.stop_video)
|
||
self.pause_video_button.clicked.connect(self.pause_video)
|
||
self.stop_video_button.setEnabled(False)
|
||
self.pause_video_button.setEnabled(False)
|
||
|
||
# 图片控制按钮
|
||
self.open_image_button = QPushButton("打开图片")
|
||
self.open_image_button.clicked.connect(self.open_image_file)
|
||
|
||
button_layout.addWidget(self.start_button)
|
||
button_layout.addWidget(self.stop_button)
|
||
button_layout.addWidget(self.open_video_button)
|
||
button_layout.addWidget(self.stop_video_button)
|
||
button_layout.addWidget(self.pause_video_button)
|
||
button_layout.addWidget(self.open_image_button)
|
||
button_layout.addStretch()
|
||
|
||
left_layout.addWidget(self.camera_label)
|
||
left_layout.addLayout(button_layout)
|
||
|
||
# 右侧结果显示区域
|
||
right_frame = QFrame()
|
||
right_frame.setFrameStyle(QFrame.StyledPanel)
|
||
right_frame.setFixedWidth(460)
|
||
right_frame.setStyleSheet("QFrame { background-color: #fafafa; border: 2px solid #ddd; }")
|
||
right_layout = QVBoxLayout(right_frame)
|
||
|
||
# 道闸控制区域
|
||
gate_frame = QFrame()
|
||
gate_frame.setFrameStyle(QFrame.StyledPanel)
|
||
gate_frame.setStyleSheet("QFrame { background-color: #f0f8ff; border: 1px solid #b0d4f1; border-radius: 5px; }")
|
||
gate_layout = QVBoxLayout(gate_frame)
|
||
|
||
# 道闸控制标题
|
||
gate_title = QLabel("道闸控制")
|
||
gate_title.setAlignment(Qt.AlignCenter)
|
||
gate_title.setFont(QFont("Arial", 14, QFont.Bold))
|
||
gate_title.setStyleSheet("QLabel { color: #1976d2; padding: 5px; }")
|
||
|
||
# 道闸控制按钮
|
||
gate_button_layout = QHBoxLayout()
|
||
self.open_gate_button = QPushButton("手动开闸")
|
||
self.close_gate_button = QPushButton("手动关闸")
|
||
self.open_gate_button.clicked.connect(self.manual_open_gate)
|
||
self.close_gate_button.clicked.connect(self.manual_close_gate)
|
||
|
||
# 设置道闸按钮样式
|
||
gate_button_style = """
|
||
QPushButton {
|
||
background-color: #4CAF50;
|
||
color: white;
|
||
border: none;
|
||
padding: 8px 16px;
|
||
border-radius: 4px;
|
||
font-weight: bold;
|
||
}
|
||
QPushButton:hover {
|
||
background-color: #45a049;
|
||
}
|
||
QPushButton:pressed {
|
||
background-color: #3d8b40;
|
||
}
|
||
"""
|
||
self.open_gate_button.setStyleSheet(gate_button_style)
|
||
|
||
close_button_style = """
|
||
QPushButton {
|
||
background-color: #f44336;
|
||
color: white;
|
||
border: none;
|
||
padding: 8px 16px;
|
||
border-radius: 4px;
|
||
font-weight: bold;
|
||
}
|
||
QPushButton:hover {
|
||
background-color: #d32f2f;
|
||
}
|
||
QPushButton:pressed {
|
||
background-color: #b71c1c;
|
||
}
|
||
"""
|
||
self.close_gate_button.setStyleSheet(close_button_style)
|
||
|
||
gate_button_layout.addWidget(self.open_gate_button)
|
||
gate_button_layout.addWidget(self.close_gate_button)
|
||
|
||
# 白名单管理区域
|
||
whitelist_layout = QVBoxLayout()
|
||
whitelist_label = QLabel("车牌白名单")
|
||
whitelist_label.setFont(QFont("Arial", 12, QFont.Bold))
|
||
whitelist_label.setStyleSheet("QLabel { color: #333; padding: 5px; }")
|
||
|
||
# 白名单按钮
|
||
whitelist_button_layout = QHBoxLayout()
|
||
self.add_plate_button = QPushButton("添加车牌")
|
||
self.edit_plate_button = QPushButton("编辑车牌")
|
||
self.delete_plate_button = QPushButton("删除车牌")
|
||
self.add_plate_button.clicked.connect(self.add_plate_to_whitelist)
|
||
self.edit_plate_button.clicked.connect(self.edit_plate_in_whitelist)
|
||
self.delete_plate_button.clicked.connect(self.delete_plate_from_whitelist)
|
||
|
||
# 设置白名单按钮样式
|
||
whitelist_button_style = """
|
||
QPushButton {
|
||
background-color: #2196F3;
|
||
color: white;
|
||
border: none;
|
||
padding: 6px 12px;
|
||
border-radius: 4px;
|
||
font-weight: bold;
|
||
font-size: 11px;
|
||
}
|
||
QPushButton:hover {
|
||
background-color: #1976D2;
|
||
}
|
||
QPushButton:pressed {
|
||
background-color: #0D47A1;
|
||
}
|
||
"""
|
||
self.add_plate_button.setStyleSheet(whitelist_button_style)
|
||
self.edit_plate_button.setStyleSheet(whitelist_button_style)
|
||
self.delete_plate_button.setStyleSheet(whitelist_button_style)
|
||
|
||
whitelist_button_layout.addWidget(self.add_plate_button)
|
||
whitelist_button_layout.addWidget(self.edit_plate_button)
|
||
whitelist_button_layout.addWidget(self.delete_plate_button)
|
||
|
||
# 白名单列表
|
||
self.whitelist_list = QListWidget()
|
||
self.whitelist_list.setMaximumHeight(120)
|
||
self.whitelist_list.setStyleSheet("""
|
||
QListWidget {
|
||
border: 1px solid #ddd;
|
||
background-color: white;
|
||
border-radius: 4px;
|
||
padding: 5px;
|
||
}
|
||
QListWidget::item {
|
||
padding: 5px;
|
||
border-bottom: 1px solid #eee;
|
||
}
|
||
QListWidget::item:selected {
|
||
background-color: #e3f2fd;
|
||
color: #1976d2;
|
||
}
|
||
""")
|
||
|
||
# 调试日志区域
|
||
log_label = QLabel("调试日志")
|
||
log_label.setFont(QFont("Arial", 10, QFont.Bold))
|
||
log_label.setStyleSheet("QLabel { color: #333; padding: 5px; }")
|
||
|
||
self.log_text = QTextEdit()
|
||
self.log_text.setMaximumHeight(100)
|
||
self.log_text.setReadOnly(True)
|
||
self.log_text.setStyleSheet("""
|
||
QTextEdit {
|
||
border: 1px solid #ddd;
|
||
background-color: #f9f9f9;
|
||
border-radius: 4px;
|
||
padding: 5px;
|
||
font-family: 'Consolas', 'Courier New', monospace;
|
||
font-size: 10px;
|
||
}
|
||
""")
|
||
|
||
# 添加到道闸控制布局
|
||
whitelist_layout.addWidget(whitelist_label)
|
||
whitelist_layout.addLayout(whitelist_button_layout)
|
||
whitelist_layout.addWidget(self.whitelist_list)
|
||
|
||
gate_layout.addWidget(gate_title)
|
||
gate_layout.addLayout(gate_button_layout)
|
||
gate_layout.addLayout(whitelist_layout)
|
||
gate_layout.addWidget(log_label)
|
||
gate_layout.addWidget(self.log_text)
|
||
|
||
# 标题
|
||
title_label = QLabel("检测结果")
|
||
title_label.setAlignment(Qt.AlignCenter)
|
||
title_label.setFont(QFont("Arial", 16, QFont.Bold))
|
||
title_label.setStyleSheet("QLabel { color: #333; padding: 10px; }")
|
||
|
||
# 识别方法选择
|
||
method_layout = QHBoxLayout()
|
||
method_label = QLabel("识别方法:")
|
||
method_label.setFont(QFont("Arial", 10))
|
||
|
||
self.method_combo = QComboBox()
|
||
self.method_combo.addItems(["CRNN", "LightCRNN", "OCR"])
|
||
self.method_combo.setCurrentText("CRNN") # 默认选择CRNN
|
||
self.method_combo.currentTextChanged.connect(self.change_recognition_method)
|
||
|
||
method_layout.addWidget(method_label)
|
||
method_layout.addWidget(self.method_combo)
|
||
method_layout.addStretch()
|
||
|
||
# 车牌数量显示
|
||
self.count_label = QLabel("识别到的车牌数量: 0")
|
||
self.count_label.setAlignment(Qt.AlignCenter)
|
||
self.count_label.setFont(QFont("Arial", 12))
|
||
self.count_label.setStyleSheet(
|
||
"QLabel { "
|
||
"background-color: #e3f2fd; "
|
||
"border: 1px solid #2196f3; "
|
||
"border-radius: 5px; "
|
||
"padding: 8px; "
|
||
"color: #1976d2; "
|
||
"font-weight: bold; "
|
||
"}"
|
||
)
|
||
|
||
# 滚动区域用于显示车牌结果
|
||
scroll_area = QScrollArea()
|
||
scroll_area.setWidgetResizable(True)
|
||
scroll_area.setStyleSheet("QScrollArea { border: none; background-color: transparent; }")
|
||
|
||
self.results_widget = QWidget()
|
||
self.results_layout = QVBoxLayout(self.results_widget)
|
||
self.results_layout.setAlignment(Qt.AlignTop)
|
||
|
||
scroll_area.setWidget(self.results_widget)
|
||
|
||
# 当前识别任务显示
|
||
self.current_method_label = QLabel("当前识别方法: CRNN")
|
||
self.current_method_label.setAlignment(Qt.AlignRight)
|
||
self.current_method_label.setFont(QFont("Arial", 9))
|
||
self.current_method_label.setStyleSheet("QLabel { color: #666; padding: 5px; }")
|
||
|
||
right_layout.addWidget(gate_frame)
|
||
right_layout.addWidget(title_label)
|
||
right_layout.addLayout(method_layout)
|
||
right_layout.addWidget(self.count_label)
|
||
right_layout.addWidget(scroll_area)
|
||
right_layout.addWidget(self.current_method_label)
|
||
|
||
# 添加到主布局
|
||
main_layout.addWidget(left_frame, 2)
|
||
main_layout.addWidget(right_frame, 1)
|
||
|
||
# 设置样式
|
||
self.setStyleSheet("""
|
||
QMainWindow {
|
||
background-color: #f5f5f5;
|
||
}
|
||
QPushButton {
|
||
background-color: #2196F3;
|
||
color: white;
|
||
border: none;
|
||
padding: 8px 16px;
|
||
border-radius: 4px;
|
||
font-weight: bold;
|
||
}
|
||
QPushButton:hover {
|
||
background-color: #1976D2;
|
||
}
|
||
QPushButton:pressed {
|
||
background-color: #0D47A1;
|
||
}
|
||
QPushButton:disabled {
|
||
background-color: #cccccc;
|
||
color: #666666;
|
||
}
|
||
""")
|
||
|
||
def init_detector(self):
|
||
"""初始化检测器"""
|
||
model_path = os.path.join(os.path.dirname(__file__), "yolopart", "yolo11s-pose42.pt")
|
||
self.detector = LicensePlateYOLO(model_path)
|
||
|
||
def reset_processing_state(self):
|
||
"""重置处理状态和清理界面"""
|
||
# 重置处理标志
|
||
self.is_processing = False
|
||
|
||
# 清空当前帧和检测结果
|
||
self.current_frame = None
|
||
self.detections = []
|
||
|
||
# 重置车牌稳定器
|
||
self.plate_stabilizer = PlateStabilizer(
|
||
history_size=15,
|
||
confidence_threshold=0.7,
|
||
stability_frames=5
|
||
)
|
||
|
||
# 清空右侧结果显示
|
||
self.count_label.setText("识别到的车牌数量: 0")
|
||
for i in reversed(range(self.results_layout.count())):
|
||
child = self.results_layout.itemAt(i).widget()
|
||
if child:
|
||
child.setParent(None)
|
||
self.last_plate_results = []
|
||
|
||
print("处理状态已重置，界面已清理")
|
||
|
||
def init_camera(self):
|
||
"""初始化摄像头线程"""
|
||
self.camera_thread = CameraThread()
|
||
self.camera_thread.frame_ready.connect(self.process_frame)
|
||
|
||
def init_video(self):
|
||
"""初始化视频线程"""
|
||
self.video_thread = VideoThread()
|
||
self.video_thread.frame_ready.connect(self.process_frame)
|
||
self.video_thread.video_finished.connect(self.on_video_finished)
|
||
|
||
def start_camera(self):
|
||
"""启动摄像头"""
|
||
# 重置处理状态和清理界面
|
||
self.reset_processing_state()
|
||
|
||
if self.camera_thread.start_camera():
|
||
self.current_mode = "camera"
|
||
self.start_button.setEnabled(False)
|
||
self.stop_button.setEnabled(True)
|
||
self.camera_label.setText("摄像头启动中...")
|
||
else:
|
||
self.camera_label.setText("摄像头启动失败")
|
||
|
||
def stop_camera(self):
|
||
"""停止摄像头"""
|
||
self.camera_thread.stop_camera()
|
||
self.start_button.setEnabled(True)
|
||
self.stop_button.setEnabled(False)
|
||
self.camera_label.setText("摄像头已停止")
|
||
# 只在摄像头模式下清除标签内容
|
||
if self.current_mode == "camera":
|
||
self.camera_label.clear()
|
||
|
||
def on_video_finished(self):
|
||
"""视频播放结束时的处理"""
|
||
self.video_thread.stop_video()
|
||
self.open_video_button.setEnabled(True)
|
||
self.stop_video_button.setEnabled(False)
|
||
self.pause_video_button.setEnabled(False)
|
||
self.camera_label.setText("视频播放结束")
|
||
self.current_mode = "camera"
|
||
|
||
def open_video_file(self):
|
||
"""打开视频文件"""
|
||
# 停止当前模式
|
||
if self.current_mode == "camera" and self.camera_thread and self.camera_thread.running:
|
||
self.stop_camera()
|
||
elif self.current_mode == "video" and self.video_thread and self.video_thread.running:
|
||
self.stop_video()
|
||
|
||
# 重置处理状态和清理界面
|
||
self.reset_processing_state()
|
||
|
||
# 选择视频文件
|
||
video_path, _ = QFileDialog.getOpenFileName(self, "选择视频文件", "", "视频文件 (*.mp4 *.avi *.mov *.mkv)")
|
||
|
||
if video_path:
|
||
if self.video_thread.load_video(video_path):
|
||
self.current_mode = "video"
|
||
self.start_video()
|
||
self.camera_label.setText(f"正在播放视频: {os.path.basename(video_path)}")
|
||
else:
|
||
self.camera_label.setText("视频加载失败")
|
||
|
||
def start_video(self):
|
||
"""开始播放视频"""
|
||
if self.video_thread.start_video():
|
||
self.open_video_button.setEnabled(False)
|
||
self.stop_video_button.setEnabled(True)
|
||
self.pause_video_button.setEnabled(True)
|
||
self.pause_video_button.setText("暂停")
|
||
else:
|
||
self.camera_label.setText("视频播放失败")
|
||
|
||
def pause_video(self):
|
||
"""暂停/继续视频"""
|
||
if self.video_thread.pause_video():
|
||
self.pause_video_button.setText("继续")
|
||
else:
|
||
self.pause_video_button.setText("暂停")
|
||
|
||
def stop_video(self):
|
||
"""停止视频"""
|
||
self.video_thread.stop_video()
|
||
self.open_video_button.setEnabled(True)
|
||
self.stop_video_button.setEnabled(False)
|
||
self.pause_video_button.setEnabled(False)
|
||
self.camera_label.setText("视频已停止")
|
||
# 只在视频模式下清除标签内容
|
||
if self.current_mode == "video":
|
||
self.camera_label.clear()
|
||
self.current_mode = "camera"
|
||
|
||
def open_image_file(self):
|
||
"""打开图片文件"""
|
||
# 停止当前模式
|
||
if self.current_mode == "camera" and self.camera_thread and self.camera_thread.running:
|
||
self.stop_camera()
|
||
elif self.current_mode == "video" and self.video_thread and self.video_thread.running:
|
||
self.stop_video()
|
||
|
||
# 重置处理状态和清理界面
|
||
self.reset_processing_state()
|
||
|
||
# 选择图片文件
|
||
image_path, _ = QFileDialog.getOpenFileName(self, "选择图片文件", "", "图片文件 (*.jpg *.jpeg *.png *.bmp)")
|
||
|
||
if image_path:
|
||
self.current_mode = "image"
|
||
try:
|
||
# 读取图片 - 方法1: 使用cv2.imdecode处理中文路径
|
||
image = cv2.imdecode(np.fromfile(image_path, dtype=np.uint8), cv2.IMREAD_COLOR)
|
||
|
||
# 如果方法1失败，尝试方法2: 直接使用cv2.imread
|
||
if image is None:
|
||
image = cv2.imread(image_path)
|
||
|
||
if image is not None:
|
||
print(f"成功加载图片: {image_path}, 尺寸: {image.shape}")
|
||
self.process_image(image)
|
||
# 不在这里设置文本，避免覆盖图片
|
||
# self.camera_label.setText(f"正在显示图片: {os.path.basename(image_path)}")
|
||
else:
|
||
print(f"图片加载失败: {image_path}")
|
||
self.camera_label.setText("图片加载失败")
|
||
except Exception as e:
|
||
print(f"图片处理异常: {str(e)}")
|
||
self.camera_label.setText(f"图片处理错误: {str(e)}")
|
||
|
||
def process_image(self, image):
|
||
"""处理图片"""
|
||
try:
|
||
print(f"开始处理图片，图片尺寸: {image.shape}")
|
||
self.current_frame = image.copy()
|
||
|
||
# 进行车牌检测
|
||
print("正在进行车牌检测...")
|
||
self.detections = self.detector.detect_license_plates(image)
|
||
print(f"检测到 {len(self.detections)} 个车牌")
|
||
|
||
# 在图像上绘制检测结果
|
||
print("正在绘制检测结果...")
|
||
display_frame = self.draw_detections(image.copy())
|
||
|
||
# 转换为Qt格式并显示
|
||
print("正在显示图片...")
|
||
self.display_frame(display_frame)
|
||
|
||
# 更新右侧结果显示
|
||
print("正在更新结果显示...")
|
||
self.update_results_display()
|
||
print("图片处理完成")
|
||
except Exception as e:
|
||
print(f"图片处理过程中出错: {str(e)}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
|
||
def process_frame(self, frame):
|
||
"""处理摄像头帧"""
|
||
if frame is None:
|
||
return
|
||
|
||
self.current_frame = frame.copy()
|
||
|
||
# 先显示原始帧，保证视频流畅播放
|
||
self.display_frame(frame)
|
||
|
||
# 如果当前没有在处理识别任务，则开始新的识别任务
|
||
if not self.is_processing:
|
||
self.is_processing = True
|
||
# 异步进行车牌检测和识别
|
||
QTimer.singleShot(0, self.async_detect_and_update)
|
||
|
||
def async_detect_and_update(self):
|
||
"""异步进行车牌检测和识别"""
|
||
if self.current_frame is None:
|
||
self.is_processing = False # 重置标志位
|
||
return
|
||
|
||
try:
|
||
# 进行车牌检测
|
||
self.detections = self.detector.detect_license_plates(self.current_frame)
|
||
|
||
# 在图像上绘制检测结果
|
||
display_frame = self.draw_detections(self.current_frame.copy())
|
||
|
||
# 更新显示帧（显示带检测结果的帧）
|
||
# 无论是摄像头模式还是视频模式，都显示检测框
|
||
self.display_frame(display_frame)
|
||
|
||
# 更新右侧结果显示
|
||
self.update_results_display()
|
||
except Exception as e:
|
||
print(f"异步检测和更新失败: {str(e)}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
finally:
|
||
# 无论成功或失败，都要重置标志位
|
||
self.is_processing = False
|
||
|
||
def draw_detections(self, frame):
|
||
"""在图像上绘制检测结果"""
|
||
# 获取车牌号列表
|
||
plate_numbers = []
|
||
for detection in self.detections:
|
||
# 矫正车牌图像
|
||
corrected_image = self.correct_license_plate(detection)
|
||
# 获取车牌号
|
||
if corrected_image is not None:
|
||
plate_number = self.recognize_plate_number(corrected_image, detection['class_name'])
|
||
plate_numbers.append(plate_number)
|
||
else:
|
||
plate_numbers.append("识别失败")
|
||
|
||
return self.detector.draw_detections(frame, self.detections, plate_numbers)
|
||
|
||
def display_frame(self, frame):
|
||
"""显示帧到界面"""
|
||
try:
|
||
print(f"开始显示帧，帧尺寸: {frame.shape}")
|
||
|
||
# 方法1: 标准方法
|
||
try:
|
||
rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
|
||
h, w, ch = rgb_frame.shape
|
||
bytes_per_line = ch * w
|
||
qt_image = QImage(rgb_frame.data, w, h, bytes_per_line, QImage.Format_RGB888)
|
||
|
||
print(f"方法1: 创建QImage，尺寸: {qt_image.width()}x{qt_image.height()}")
|
||
if qt_image.isNull():
|
||
print("方法1: QImage为空，尝试方法2")
|
||
raise Exception("QImage为空")
|
||
|
||
pixmap = QPixmap.fromImage(qt_image)
|
||
if pixmap.isNull():
|
||
print("方法1: QPixmap为空，尝试方法2")
|
||
raise Exception("QPixmap为空")
|
||
|
||
# 手动缩放图片以适应标签大小，保持宽高比
|
||
scaled_pixmap = pixmap.scaled(self.camera_label.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation)
|
||
self.camera_label.setPixmap(scaled_pixmap)
|
||
print("方法1: 帧显示完成")
|
||
return
|
||
except Exception as e1:
|
||
print(f"方法1失败: {str(e1)}")
|
||
|
||
# 方法2: 使用imencode和imdecode
|
||
try:
|
||
print("尝试方法2: 使用imencode和imdecode")
|
||
_, buffer = cv2.imencode('.jpg', frame)
|
||
rgb_frame = cv2.imdecode(buffer, cv2.IMREAD_COLOR)
|
||
rgb_frame = cv2.cvtColor(rgb_frame, cv2.COLOR_BGR2RGB)
|
||
h, w, ch = rgb_frame.shape
|
||
bytes_per_line = ch * w
|
||
qt_image = QImage(rgb_frame.data, w, h, bytes_per_line, QImage.Format_RGB888)
|
||
|
||
print(f"方法2: 创建QImage，尺寸: {qt_image.width()}x{qt_image.height()}")
|
||
if qt_image.isNull():
|
||
print("方法2: QImage为空")
|
||
raise Exception("QImage为空")
|
||
|
||
pixmap = QPixmap.fromImage(qt_image)
|
||
if pixmap.isNull():
|
||
print("方法2: QPixmap为空")
|
||
raise Exception("QPixmap为空")
|
||
|
||
# 手动缩放图片以适应标签大小，保持宽高比
|
||
scaled_pixmap = pixmap.scaled(self.camera_label.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation)
|
||
self.camera_label.setPixmap(scaled_pixmap)
|
||
print("方法2: 帧显示完成")
|
||
return
|
||
except Exception as e2:
|
||
print(f"方法2失败: {str(e2)}")
|
||
|
||
# 方法3: 直接使用QImage的构造函数
|
||
try:
|
||
print("尝试方法3: 直接使用QImage的构造函数")
|
||
height, width, channel = frame.shape
|
||
bytes_per_line = 3 * width
|
||
q_image = QImage(frame.data, width, height, bytes_per_line, QImage.Format_BGR888)
|
||
|
||
print(f"方法3: 创建QImage，尺寸: {q_image.width()}x{q_image.height()}")
|
||
if q_image.isNull():
|
||
print("方法3: QImage为空")
|
||
raise Exception("QImage为空")
|
||
|
||
pixmap = QPixmap.fromImage(q_image)
|
||
if pixmap.isNull():
|
||
print("方法3: QPixmap为空")
|
||
raise Exception("QPixmap为空")
|
||
|
||
# 手动缩放图片以适应标签大小，保持宽高比
|
||
scaled_pixmap = pixmap.scaled(self.camera_label.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation)
|
||
self.camera_label.setPixmap(scaled_pixmap)
|
||
print("方法3: 帧显示完成")
|
||
return
|
||
except Exception as e3:
|
||
print(f"方法3失败: {str(e3)}")
|
||
|
||
# 所有方法都失败
|
||
print("所有显示方法都失败")
|
||
self.camera_label.setText("图片显示失败")
|
||
|
||
except Exception as e:
|
||
print(f"显示帧过程中出错: {str(e)}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
self.camera_label.setText(f"显示错误: {str(e)}")
|
||
|
||
def update_results_display(self):
|
||
"""更新右侧结果显示（使用稳定化结果）"""
|
||
print(f"开始更新结果显示，当前模式: {self.current_mode}, 检测数量: {len(self.detections) if self.detections else 0}")
|
||
|
||
if not self.detections:
|
||
self.count_label.setText("识别到的车牌数量: 0")
|
||
# 清除显示
|
||
for i in reversed(range(self.results_layout.count())):
|
||
child = self.results_layout.itemAt(i).widget()
|
||
if child:
|
||
child.setParent(None)
|
||
self.last_plate_results = []
|
||
print("无检测结果，已清空界面")
|
||
return
|
||
|
||
# 获取矫正图像和识别文本
|
||
corrected_images = []
|
||
plate_texts = []
|
||
|
||
for detection in self.detections:
|
||
corrected_image = self.correct_license_plate(detection)
|
||
corrected_images.append(corrected_image)
|
||
|
||
if corrected_image is not None:
|
||
plate_text = self.recognize_plate_number(corrected_image, detection['class_name'])
|
||
else:
|
||
plate_text = "识别失败"
|
||
plate_texts.append(plate_text)
|
||
|
||
# 使用稳定器获取稳定的识别结果
|
||
stable_results = self.plate_stabilizer.update_and_get_stable_result(
|
||
self.detections, corrected_images, plate_texts
|
||
)
|
||
|
||
# 更新车牌数量显示
|
||
self.count_label.setText(f"识别到的车牌数量: {len(stable_results)}")
|
||
print(f"稳定结果数量: {len(stable_results)}")
|
||
|
||
# 检查结果是否发生变化
|
||
results_changed = self.check_results_changed(stable_results)
|
||
print(f"结果是否变化: {results_changed}")
|
||
|
||
if results_changed:
|
||
# 清除之前的结果
|
||
for i in reversed(range(self.results_layout.count())):
|
||
child = self.results_layout.itemAt(i).widget()
|
||
if child:
|
||
child.setParent(None)
|
||
|
||
# 添加新的稳定结果
|
||
for i, result in enumerate(stable_results):
|
||
plate_widget = LicensePlateWidget(
|
||
i + 1, # 显示序号
|
||
result['class_name'],
|
||
result['corrected_image'],
|
||
result['plate_number']
|
||
)
|
||
self.results_layout.addWidget(plate_widget)
|
||
print(f"添加车牌widget: {result['plate_number']}")
|
||
|
||
# 更新存储的结果
|
||
self.last_plate_results = stable_results
|
||
|
||
# 处理道闸控制逻辑
|
||
for result in stable_results:
|
||
plate_number = result.get('plate_number', '')
|
||
if plate_number and plate_number != "识别失败":
|
||
# 调用道闸控制逻辑
|
||
self.process_gate_control(plate_number)
|
||
|
||
# 清理旧的车牌记录
|
||
current_plate_ids = [result['id'] for result in stable_results]
|
||
self.plate_stabilizer.clear_old_plates(current_plate_ids)
|
||
print("结果显示更新完成")
|
||
|
||
def check_results_changed(self, new_results):
|
||
"""检查识别结果是否发生变化"""
|
||
if len(self.last_plate_results) != len(new_results):
|
||
return True
|
||
|
||
for i, new_result in enumerate(new_results):
|
||
if i >= len(self.last_plate_results):
|
||
return True
|
||
|
||
old_result = self.last_plate_results[i]
|
||
|
||
# 比较关键字段
|
||
if (old_result.get('class_name') != new_result.get('class_name') or
|
||
old_result.get('plate_number') != new_result.get('plate_number')):
|
||
return True
|
||
|
||
return False
|
||
|
||
def correct_license_plate(self, detection):
|
||
"""矫正车牌图像"""
|
||
if self.current_frame is None:
|
||
return None
|
||
|
||
# 检查是否为不完整检测
|
||
if detection.get('incomplete', False):
|
||
return None
|
||
|
||
# 使用检测器的矫正方法
|
||
return self.detector.correct_license_plate(
|
||
self.current_frame,
|
||
detection['keypoints']
|
||
)
|
||
|
||
def recognize_plate_number(self, corrected_image, class_name):
|
||
"""识别车牌号"""
|
||
if corrected_image is None:
|
||
return "识别失败"
|
||
|
||
try:
|
||
# 根据当前选择的识别方法调用相应的函数
|
||
if self.current_recognition_method == "CRNN":
|
||
from CRNN_part.crnn_interface import LPRNmodel_predict
|
||
elif self.current_recognition_method == "LightCRNN":
|
||
from lightCRNN_part.lightcrnn_interface import LPRNmodel_predict
|
||
elif self.current_recognition_method == "OCR":
|
||
from OCR_part.ocr_interface import LPRNmodel_predict
|
||
|
||
# 预测函数（来自模块）
|
||
result = LPRNmodel_predict(corrected_image)
|
||
|
||
# 将字符列表转换为字符串，支持8位车牌号
|
||
if isinstance(result, list) and len(result) >= 7:
|
||
# 根据车牌类型决定显示位数
|
||
if class_name == '绿牌' and len(result) >= 8:
|
||
# 绿牌显示8位，过滤掉空字符占位符
|
||
plate_chars = [char for char in result[:8] if char != '']
|
||
# 如果过滤后确实有8位，显示8位；否则显示7位
|
||
if len(plate_chars) == 8:
|
||
return ''.join(plate_chars)
|
||
else:
|
||
return ''.join(plate_chars[:7])
|
||
else:
|
||
# 蓝牌或其他类型显示前7位，过滤掉空字符
|
||
plate_chars = [char for char in result[:7] if char != '']
|
||
return ''.join(plate_chars)
|
||
else:
|
||
return "识别失败"
|
||
except Exception as e:
|
||
print(f"车牌号识别失败: {e}")
|
||
return "识别失败"
|
||
|
||
def change_recognition_method(self, method):
|
||
"""切换识别方法"""
|
||
self.current_recognition_method = method
|
||
self.current_method_label.setText(f"当前识别方法: {method}")
|
||
|
||
# 初始化对应的模型
|
||
if method == "CRNN":
|
||
from CRNN_part.crnn_interface import LPRNinitialize_model
|
||
LPRNinitialize_model()
|
||
elif method == "LightCRNN":
|
||
from lightCRNN_part.lightcrnn_interface import LPRNinitialize_model
|
||
LPRNinitialize_model()
|
||
elif method == "OCR":
|
||
from OCR_part.ocr_interface import LPRNinitialize_model
|
||
LPRNinitialize_model()
|
||
|
||
# 如果当前有显示的帧，重新处理以更新识别结果
|
||
if self.current_frame is not None:
|
||
self.process_frame(self.current_frame)
|
||
|
||
def init_gate_control(self):
|
||
"""初始化道闸控制功能"""
|
||
# 更新白名单列表显示
|
||
self.update_whitelist_display()
|
||
|
||
# 添加初始日志
|
||
self.add_log("道闸控制系统已初始化")
|
||
|
||
# GateController的IP地址在初始化时已设置，默认为192.168.43.12
|
||
|
||
def manual_open_gate(self):
|
||
"""手动开闸"""
|
||
self.gate_controller.manual_open_gate()
|
||
self.add_log("手动开闸指令已发送")
|
||
|
||
def manual_close_gate(self):
|
||
"""手动关闸"""
|
||
self.gate_controller.manual_close_gate()
|
||
self.add_log("手动关闸指令已发送")
|
||
|
||
def cleanup_plate_records(self):
|
||
"""清理过期的车牌记录"""
|
||
current_time = time.time()
|
||
|
||
# 清理超过30秒的首次检测记录
|
||
expired_plates = []
|
||
for plate, first_time in self.plate_first_detected.items():
|
||
if current_time - first_time > 30:
|
||
expired_plates.append(plate)
|
||
|
||
for plate in expired_plates:
|
||
del self.plate_first_detected[plate]
|
||
self.add_log(f"清理过期的首次检测记录: {plate}")
|
||
|
||
# 清理超过1小时的指令发送记录
|
||
expired_commands = []
|
||
for plate, last_time in self.plate_last_command_time.items():
|
||
if current_time - last_time > 3600:
|
||
expired_commands.append(plate)
|
||
|
||
for plate in expired_commands:
|
||
del self.plate_last_command_time[plate]
|
||
self.add_log(f"清理过期的指令记录: {plate}")
|
||
|
||
def add_plate_to_whitelist(self):
|
||
"""添加车牌到白名单"""
|
||
dialog = PlateInputDialog("添加车牌", "")
|
||
if dialog.exec_() == QDialog.Accepted:
|
||
plate_number = dialog.get_plate_number()
|
||
if plate_number:
|
||
self.whitelist_manager.add_plate(plate_number)
|
||
self.update_whitelist_display()
|
||
self.add_log(f"已添加车牌到白名单: {plate_number}")
|
||
|
||
def edit_plate_in_whitelist(self):
|
||
"""编辑白名单中的车牌"""
|
||
current_item = self.whitelist_list.currentItem()
|
||
if not current_item:
|
||
QMessageBox.warning(self, "提示", "请先选择要编辑的车牌")
|
||
return
|
||
|
||
old_plate = current_item.text()
|
||
dialog = PlateInputDialog("编辑车牌", old_plate)
|
||
if dialog.exec_() == QDialog.Accepted:
|
||
new_plate = dialog.get_plate_number()
|
||
if new_plate and new_plate != old_plate:
|
||
self.whitelist_manager.remove_plate(old_plate)
|
||
self.whitelist_manager.add_plate(new_plate)
|
||
self.update_whitelist_display()
|
||
self.add_log(f"已修改车牌: {old_plate} -> {new_plate}")
|
||
|
||
def delete_plate_from_whitelist(self):
|
||
"""从白名单中删除车牌"""
|
||
current_item = self.whitelist_list.currentItem()
|
||
if not current_item:
|
||
QMessageBox.warning(self, "提示", "请先选择要删除的车牌")
|
||
return
|
||
|
||
plate = current_item.text()
|
||
reply = QMessageBox.question(self, "确认", f"确定要删除车牌 {plate} 吗？",
|
||
QMessageBox.Yes | QMessageBox.No)
|
||
|
||
if reply == QMessageBox.Yes:
|
||
self.whitelist_manager.remove_plate(plate)
|
||
self.update_whitelist_display()
|
||
self.add_log(f"已从白名单删除车牌: {plate}")
|
||
|
||
def update_whitelist_display(self):
|
||
"""更新白名单列表显示"""
|
||
self.whitelist_list.clear()
|
||
for plate in self.whitelist_manager.get_whitelist():
|
||
self.whitelist_list.addItem(plate)
|
||
|
||
def add_log(self, message):
|
||
"""添加日志消息"""
|
||
current_time = QDateTime.currentDateTime().toString("hh:mm:ss")
|
||
log_message = f"[{current_time}] {message}"
|
||
self.log_text.append(log_message)
|
||
# 限制日志行数，避免内存占用过多
|
||
if self.log_text.document().blockCount() > 100:
|
||
cursor = self.log_text.textCursor()
|
||
cursor.movePosition(cursor.Start)
|
||
cursor.select(cursor.BlockUnderCursor)
|
||
cursor.removeSelectedText()
|
||
cursor.deleteChar() # 删除换行符
|
||
|
||
def process_gate_control(self, plate_number):
|
||
"""处理道闸控制逻辑"""
|
||
# 检查车牌是否在白名单中
|
||
if self.whitelist_manager.is_whitelisted(plate_number):
|
||
current_time = time.time()
|
||
|
||
# 检查是否在10秒内已发送过指令
|
||
if plate_number in self.plate_last_command_time:
|
||
time_since_last_command = current_time - self.plate_last_command_time[plate_number]
|
||
if time_since_last_command < 10: # 10秒内不再发送指令
|
||
self.add_log(f"车牌 {plate_number} 在10秒内已发送过指令，跳过")
|
||
return
|
||
|
||
# 记录车牌首次检测时间
|
||
if plate_number not in self.plate_first_detected:
|
||
self.plate_first_detected[plate_number] = current_time
|
||
self.add_log(f"车牌 {plate_number} 首次检测，等待2秒稳定确认")
|
||
return
|
||
|
||
# 检查是否已稳定2秒
|
||
time_since_first_detected = current_time - self.plate_first_detected[plate_number]
|
||
if time_since_first_detected >= 2: # 稳定2秒后发送指令
|
||
# 使用GateController的auto_open_gate方法，它会自动处理时间差
|
||
self.gate_controller.auto_open_gate(plate_number)
|
||
self.add_log(f"车牌 {plate_number} 验证通过，已发送开闸指令")
|
||
|
||
# 更新上次发送指令时间
|
||
self.plate_last_command_time[plate_number] = current_time
|
||
# 清除首次检测时间，以便下次重新检测
|
||
if plate_number in self.plate_first_detected:
|
||
del self.plate_first_detected[plate_number]
|
||
else:
|
||
# 还未稳定2秒，继续等待
|
||
self.add_log(f"车牌 {plate_number} 检测中，已等待 {time_since_first_detected:.1f} 秒")
|
||
else:
|
||
# 不在白名单中，发送禁行指令
|
||
self.gate_controller.deny_access(plate_number)
|
||
self.add_log(f"车牌 {plate_number} 不在白名单中，已发送禁行指令")
|
||
|
||
def closeEvent(self, event):
|
||
"""窗口关闭事件"""
|
||
if self.camera_thread and self.camera_thread.running:
|
||
self.camera_thread.stop_camera()
|
||
if self.video_thread and self.video_thread.running:
|
||
self.video_thread.stop_video()
|
||
event.accept()
|
||
|
||
def main():
|
||
app = QApplication(sys.argv)
|
||
window = MainWindow()
|
||
window.show()
|
||
sys.exit(app.exec_())
|
||
|
||
if __name__ == "__main__":
|
||
main() |