能否把下面代码里面在运行时展现出缺陷的显示变小一点，同时为什么我刚刚测试好几次我和标准样本类似的过来它都没有主动截取当前帧并检测
# -*- coding: utf-8 -*-
import sys
import os
import cv2
import numpy as np
import math
import time
import logging
from collections import deque
from PyQt5.QtWidgets import (
QApplication, QMainWindow, QPushButton, QWidget, QVBoxLayout, QHBoxLayout,
QMessageBox, QLabel, QFileDialog, QToolBox, QComboBox, QStatusBar, QGroupBox,
QSlider, QDockWidget, QProgressDialog, QLineEdit, QRadioButton, QGridLayout,
QSpinBox, QCheckBox, QDialog, QDialogButtonBox, QDoubleSpinBox, QProgressBar
)
from PyQt5.QtCore import QRect, Qt, QSettings, QThread, pyqtSignal, QTimer
from PyQt5.QtGui import QImage, QPixmap
from CamOperation_class import CameraOperation
from MvCameraControl_class import *
import ctypes
from ctypes import cast, POINTER
from datetime import datetime
import skimage
import platform
from CameraParams_header import (
MV_GIGE_DEVICE,
MV_USB_DEVICE,
MV_GENTL_CAMERALINK_DEVICE,
MV_GENTL_CXP_DEVICE,
MV_GENTL_XOF_DEVICE
)
# ===== 全局配置 =====
# 模板匹配参数
MATCH_THRESHOLD = 0.85 # 默认匹配置信度阈值
MIN_MATCH_COUNT = 10 # 最小匹配特征点数量
# ===== 全局变量 =====
current_sample_path = ""
detection_history = []
isGrabbing = False
isOpen = False
obj_cam_operation = None
frame_monitor_thread = None
template_matcher_thread = None
MV_OK = 0
MV_E_CALLORDER = -2147483647
# ==================== 优化后的质量检测算法 ====================
def enhanced_check_print_quality(sample_image_path, test_image, threshold=0.05):
# 不再使用传感器数据调整阈值
adjusted_threshold = threshold
try:
sample_img_data = np.fromfile(sample_image_path, dtype=np.uint8)
sample_image = cv2.imdecode(sample_img_data, cv2.IMREAD_GRAYSCALE)
if sample_image is None:
logging.error(f"无法解码样本图像: {sample_image_path}")
return None, None, None
except Exception as e:
logging.exception(f"样本图像读取异常: {str(e)}")
return None, None, None
if len(test_image.shape) == 3:
test_image_gray = cv2.cvtColor(test_image, cv2.COLOR_BGR2GRAY)
else:
test_image_gray = test_image.copy()
sample_image = cv2.GaussianBlur(sample_image, (5, 5), 0)
test_image_gray = cv2.GaussianBlur(test_image_gray, (5, 5), 0)
try:
orb = cv2.ORB_create(nfeatures=200)
keypoints1, descriptors1 = orb.detectAndCompute(sample_image, None)
keypoints2, descriptors2 = orb.detectAndCompute(test_image_gray, None)
if descriptors1 is None or descriptors2 is None:
logging.warning("无法提取特征描述符，跳过配准")
aligned_sample = sample_image
else:
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
matches = bf.match(descriptors1, descriptors2)
matches = sorted(matches, key=lambda x: x.distance)
if len(matches) > MIN_MATCH_COUNT:
src_pts = np.float32([keypoints1[m.queryIdx].pt for m in matches]).reshape(-1, 1, 2)
dst_pts = np.float32([keypoints2[m.trainIdx].pt for m in matches]).reshape(-1, 1, 2)
H, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)
if H is not None:
aligned_sample = cv2.warpPerspective(
sample_image, H,
(test_image_gray.shape[1], test_image_gray.shape[0])
)
logging.info("图像配准成功，使用配准后样本")
else:
aligned_sample = sample_image
logging.warning("无法计算单应性矩阵，使用原始样本")
else:
aligned_sample = sample_image
logging.warning(f"特征点匹配不足({len(matches)}/{MIN_MATCH_COUNT})，跳过图像配准")
except Exception as e:
logging.error(f"图像配准失败: {str(e)}")
aligned_sample = sample_image
try:
if aligned_sample.shape != test_image_gray.shape:
test_image_g极ray = cv2.resize(test_image_gray, (aligned_sample.shape[1], aligned_sample.shape[0]))
except Exception as e:
logging.error(f"图像调整大小失败: {str(e)}")
return None, None, None
try:
from skimage.metrics import structural_similarity as compare_ssim
ssim_score, ssim_diff = compare_ssim(
aligned_sample,
test_image_gray,
full=True,
gaussian_weights=True,
data_range=255
)
except ImportError:
from skimage.measure import compare_ssim
ssim_score, ssim_diff = compare_ssim(
aligned_sample,
test_image_gray,
full=True,
gaussian_weights=True
)
except Exception as e:
logging.error(f"SSIM计算失败: {str(e)}")
abs_diff = cv2.absdiff(aligned_sample, test_image_gray)
ssim_diff = abs_diff.astype(np.float32) / 255.0
ssim_score = 1.0 - np.mean(ssim_diff)
ssim_diff = (1 - ssim_diff) * 255
abs_diff = cv2.absdiff(aligned_sample, test_image_gray)
combined_diff = cv2.addWeighted(ssim_diff.astype(np.uint8), 0.7, abs_diff, 0.3, 0)
_, thresholded = cv2.threshold(combined_diff, 30, 255, cv2.THRESH_BINARY)
kernel = np.ones((3, 3), np.uint8)
thresholded = cv2.morphologyEx(thresholded, cv2.MORPH_OPEN, kernel)
thresholded = cv2.morphologyEx(thresholded, cv2.MORPH_CLOSE, kernel)
diff_pixels = np.count_nonzero(thresholded)
total_pixels = aligned_sample.size
diff_ratio = diff_pixels / total_pixels
is_qualified = diff_ratio <= adjusted_threshold
marked_image = cv2.cvtColor(test_image_gray, cv2.COLOR_GRAY2BGR)
marked_image[thresholded == 255] = [0, 0, 255]
labels = skimage.measure.label(thresholded)
properties = skimage.measure.regionprops(labels)
for prop in properties:
if prop.area > 50:
y, x = prop.centroid
cv2.putText(marked_image, f"Defect", (int(x), int(y)),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 255), 1)
return is_qualified, diff_ratio, marked_image
# ==================== 视觉触发的质量检测流程 ====================
def vision_controlled_check(capture_path=None):
global current_sample_path, detection_history
logging.info("视觉触发质量检测启动")
# 如果没有提供抓拍路径，使用当前帧
if capture_path is None:
frame = obj_cam_operation.get_current_frame()
else:
# 从文件加载抓拍的图像
frame = cv2.imread(capture_path)
if frame is None:
logging.error(f"无法加载抓拍图像: {capture_path}")
frame = obj_cam_operation.get_current_frame()
if frame is None:
QMessageBox.warning(mainWindow, "错误", "无法获取当前帧图像！", QMessageBox.Ok)
return
progress = QProgressDialog("正在检测...", "取消", 0, 100, mainWindow)
progress.setWindowModality(Qt.WindowModal)
progress.setValue(10)
try:
diff_threshold = mainWindow.sliderDiffThreshold.value() / 100.0
logging.info(f"使用差异度阈值: {diff_threshold}")
progress.setValue(30)
is_qualified, diff_ratio, marked_image = enhanced_check_print_quality(
current_sample_path,
frame,
threshold=diff_threshold
)
progress.setValue(70)
if is_qualified is None:
QMessageBox.critical(mainWindow, "检测错误", "检测失败，请检查日志", QMessageBox.Ok)
return
logging.info(f"检测结果: 合格={is_qualified}, 差异={diff_ratio}")
progress.setValue(90)
update_diff_display(diff_ratio, is_qualified)
result_text = f"印花是否合格: {'合格' if is_qualified else '不合格'}\n差异占比: {diff_ratio*100:.2f}%\n阈值: {diff_threshold*100:.2f}%"
QMessageBox.information(mainWindow, "检测结果", result_text, QMessageBox.Ok)
if marked_image is not None:
cv2.imshow("缺陷标记结果", marked_image)
cv2.waitKey(0)
cv2.destroyAllWindows()
detection_result = {
'timestamp': datetime.now(),
'qualified': is_qualified,
'diff_ratio': diff_ratio,
'threshold': diff_threshold,
'trigger_type': 'vision' if capture_path else 'manual'
}
detection_history.append(detection_result)
update_history_display()
progress.setValue(100)
except Exception as e:
logging.exception("印花检测失败")
QMessageBox.critical(mainWindow, "检测错误", f"检测过程中发生错误: {str(e)}", QMessageBox.Ok)
finally:
progress.close()
# ==================== 相机操作函数 ====================
def open_device():
global deviceList, nSelCamIndex, obj_cam_operation, isOpen, frame_monitor_thread, mainWindow
if isOpen:
QMessageBox.warning(mainWindow, "Error", '相机已打开!', QMessageBox.Ok)
return MV_E_CALLORDER
nSelCamIndex = mainWindow.ComboDevices.currentIndex()
if nSelCamIndex < 0:
QMessageBox.warning(mainWindow, "Error", '请选择相机!', QMessageBox.Ok)
return MV_E_CALLORDER
# 创建相机控制对象
cam = MvCamera()
# 初始化相机操作对象
obj_cam_operation = CameraOperation(cam, deviceList, nSelCamIndex)
ret = obj_cam_operation.open_device()
if 0 != ret:
strError = "打开设备失败 ret:" + ToHexStr(ret)
QMessageBox.warning(mainWindow, "Error", strError, QMessageBox.Ok)
isOpen = False
else:
set_continue_mode()
get_param()
isOpen = True
enable_controls()
# 创建并启动帧监控线程
frame_monitor_thread = FrameMonitorThread(obj_cam_operation)
frame_monitor_thread.frame_status.connect(mainWindow.statusBar().showMessage)
frame_monitor_thread.start()
def start_grabbing():
global obj_cam_operation, isGrabbing, template_matcher_thread
ret = obj_cam_operation.start_grabbing(mainWindow.widgetDisplay.winId())
if ret != 0:
strError = "开始取流失败 ret:" + ToHexStr(ret)
QMessageBox.warning(mainWindow, "Error", strError, QMessageBox.Ok)
else:
isGrabbing = True
enable_controls()
# 等待第一帧到达
QThread.msleep(500)
if not obj_cam_operation.is_frame_available():
QMessageBox.warning(mainWindow, "警告", "开始取流后未接收到帧，请检查相机连接！", QMessageBox.Ok)
# 如果启用了自动检测，启动检测线程
if mainWindow.chkAutoDetect.isChecked():
toggle_template_matching(True)
def stop_grabbing():
global obj_cam_operation, isGrabbing, template_matcher_thread
ret = obj_cam_operation.Stop_grabbing()
if ret != 0:
strError = "停止取流失败 ret:" + ToHexStr(ret)
QMessageBox.warning(mainWindow, "Error", strError, QMessageBox.Ok)
else:
isGrabbing = False
enable_controls()
# 停止模板匹配线程
if template_matcher_thread and template_matcher_thread.isRunning():
template_matcher_thread.stop()
def close_device():
global isOpen, isGrabbing, obj_cam_operation, frame_monitor_thread, template_matcher_thread
if frame_monitor_thread and frame_monitor_thread.isRunning():
frame_monitor_thread.stop()
frame_monitor_thread.wait(2000)
# 停止模板匹配线程
if template_matcher_thread and template_matcher_thread.isRunning():
template_matcher_thread.stop()
template_matcher_thread.wait(2000)
template_matcher_thread = None
if isOpen and obj_cam_operation:
obj_cam_operation.close_device()
isOpen = False
isGrabbing = False
enable_controls()
# ==================== 模板匹配检测器 ====================
class TemplateMatcherThread(QThread):
template_detected = pyqtSignal(str) # 检测到匹配时发出的信号，传递图像路径
def __init__(self, cam_operation, parent=None):
super().__init__(parent)
self.cam_operation = cam_operation
self.running = True
self.last_detection_time = 0
self.sample_template = None
self.min_match_count = MIN_MATCH_COUNT
self.match_threshold = MATCH_THRESHOLD
self.sample_kp = None
self.sample_des = None
# 特征检测器
self.orb = cv2.ORB_create(nfeatures=1000)
# 特征匹配器
self.bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
# 性能监控
self.processing_times = deque(maxlen=100)
# 匹配历史记录
self.match_history = deque(maxlen=10)
def set_sample(self, sample_img):
"""设置标准样本"""
if sample_img is None or sample_img.size == 0:
return False
# 转换为灰度图
if len(sample_img.shape) == 3: # 彩色图像 (BGR)
gray_sample = cv2.cvtColor(sample_img, cv2.COLOR_BGR2GRAY)
elif len(sample_img.shape) == 2: # 已经是灰度图
gray_sample = sample_img
else:
logging.warning("不支持的图像格式")
return False
# 提取特征
self.sample_kp, self.sample_des = self.orb.detectAndCompute(gray_sample, None)
if self.sample_des is None or len(self.sample_kp) < self.min_match_count:
logging.warning("样本图像特征点不足")
return False
self.sample_template = sample_img
logging.info(f"标准样本设置成功，特征点数: {len(self.sample_kp)}")
return True
def match_template(self, frame):
"""在帧中匹配标准样本"""
start_time = time.time()
if self.sample_kp is None or self.sample_des is None:
return False, None
# 转换为灰度图
if len(frame.shape) == 3:
gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
else:
gray_frame = frame.copy()
# 检测当前帧特征点
frame_kp, frame_des = self.orb.detectAndCompute(gray_frame, None)
if frame_des is None or len(frame_kp) < self.min_match_count:
return False, None
# 匹配特征点
matches = self.bf.match(self.sample_des, frame_des)
matches = sorted(matches, key=lambda x: x.distance)
# 检查匹配质量
if len(matches) < self.min_match_count:
return False, None
# 计算平均匹配距离
avg_distance = sum(m.distance for m in matches) / len(matches)
max_distance = matches[0].distance * 2.0
# 筛选优质匹配
good_matches = [m for m in matches if m.distance < max(0.7 * avg_distance, 30.0)]
if len(good_matches) < self.min_match_count:
return False, None
# 计算匹配分数 (0-1, 1表示完美匹配)
match_score = 1.0 - (avg_distance / 100.0)
match_score = max(0.0, min(1.0, match_score))
# 记录匹配历史
self.match_history.append(match_score)
# 性能监控
proc_time = time.time() - start_time
self.processing_times.append(proc_time)
# 检查是否超过阈值
if match_score >= self.match_threshold:
# 获取匹配位置
src_pts = np.float32([self.sample_kp[m.queryIdx].pt for m in good_matches]).reshape(-1,1,2)
dst_pts = np.float32([frame_kp[m.trainIdx].pt for m in good_matches]).reshape(-1,1,2)
# 计算变换矩阵
M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)
if M is not None:
# 获取样本图像的尺寸
h, w = self.sample_template.shape[:2] if len(self.sample_template.shape) == 2 else self.sample_template.shape[:2][:2]
# 计算样本在帧中的位置
pts = np.float32([[0,0], [0,h-1], [w-1,h-1], [w-1,0]]).reshape(-1,1,2)
dst = cv2.perspectiveTransform(pts, M)
return True, (match_score, dst)
return False, None
def run(self):
"""主检测循环"""
last_process_time = time.time()
min_frame_interval = 0.05 # 最小处理间隔20fps
while self.running:
current_time = time.time()
# 控制处理频率
if current_time - last_process_time < min_frame_interval:
time.sleep(0.001)
continue
last_process_time = current_time
if not self.cam_operation or not self.cam_operation.is_frame_available():
time.sleep(0.01)
continue
frame = self.cam_operation.get_current_frame()
if frame is None:
continue
# 尝试匹配模板
detected, match_data = self.match_template(frame)
if detected:
self.last_detection_time = current_time
match_score, box_points = match_data
# 在图像上绘制匹配框
marked_frame = frame.copy()
cv2.polylines(marked_frame, [np.int32(box_points)], True, (0,255,0), 3, cv2.LINE_AA)
cv2.putText(marked_frame, f"Match: {match_score:.2f}",
(10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,255,0), 2)
# 保存用于质量检测的图像
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
capture_dir = os.path.join("captures", "matches")
os.makedirs(capture_dir, exist_ok=True)
capture_path = os.path.join(capture_dir, f"match_{timestamp}.jpg")
cv2.imwrite(capture_path, marked_frame)
# 进行质量检测
self.template_detected.emit(capture_path)
logging.info(
f"检测到匹配目标 | 匹配度: {match_score:.2f} | "
f"阈值: {self.match_threshold}"
)
# ==================== 模板匹配控制函数 ====================
def toggle_template_matching(state):
global template_matcher_thread, current_sample_path
if state == Qt.Checked and isGrabbing:
# 确保已设置样本
if not current_sample_path:
QMessageBox.warning(mainWindow, "错误", "请先设置标准样本", QMessageBox.Ok)
mainWindow.chkAutoDetect.setChecked(False)
return
if template_matcher_thread is None:
template_matcher_thread = TemplateMatcherThread(obj_cam_operation)
template_matcher_thread.template_detected.connect(vision_controlled_check)
# 加载样本图像
sample_img = cv2.imread(current_sample_path)
if sample_img is None:
QMessageBox.warning(mainWindow, "错误", "无法加载标准样本图像", QMessageBox.Ok)
mainWindow.chkAutoDetect.setChecked(False)
return
if not template_matcher_thread.set_sample(sample_img):
QMessageBox.warning(mainWindow, "错误", "标准样本特征不足", QMessageBox.Ok)
mainWindow.chkAutoDetect.setChecked(False)
return
template_matcher_thread.start()
logging.info("模板匹配自动检测已启用")
elif template_matcher_thread:
template_matcher_thread.stop()
logging.info("模板匹配自动检测已禁用")
def update_match_threshold(value):
global template_matcher_thread
if template_matcher_thread:
template_matcher_thread.match_threshold = value / 100.0
mainWindow.lblThresholdValue.setText(f"{value}%")
# ==================== UI更新函数 ====================
def update_diff_display(diff_ratio, is_qualified):
mainWindow.lblCurrentDiff.setText(f"当前差异度: {diff_ratio*100:.2f}%")
if is_qualified:
mainWindow.lblDiffStatus.setText("状态: 合格")
mainWindow.lblDiffStatus.setStyleSheet("color: green; font-size: 12px;")
else:
mainWindow.lblDiffStatus.setText("状态: 不合格")
mainWindow.lblDiffStatus.setStyleSheet("color: red; font-size: 12px;")
def update_diff_threshold(value):
mainWindow.lblDiffValue.setText(f"{value}%")
def update_sample_display():
global current_sample_path
if current_sample_path:
mainWindow.lblSamplePath.setText(f"当前样本: {os.path.basename(current_sample_path)}")
mainWindow.lblSamplePath.setToolTip(current_sample_path)
mainWindow.bnPreviewSample.setEnabled(True)
else:
mainWindow.lblSamplePath.setText("当前样本: 未设置样本")
mainWindow.bnPreviewSample.setEnabled(False)
def update_history_display():
global detection_history
mainWindow.cbHistory.clear()
for i, result in enumerate(detection_history[-10:]):
timestamp = result['timestamp'].strftime("%H:%M:%S")
status = "合格" if result['qualified'] else "不合格"
ratio = f"{result['diff_ratio']*100:.2f}%"
trigger = "视觉" if result['trigger_type'] == 'vision' else "手动"
mainWindow.cbHistory.addItem(f"[{trigger} {timestamp}] {status} - 差异: {ratio}")
# ==================== 主窗口类 ====================
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle("布料印花检测系统 - 模板匹配版")
self.resize(1200, 800)
central_widget = QWidget()
self.setCentralWidget(central_widget)
main_layout = QVBoxLayout(central_widget)
# 设备枚举区域
device_layout = QHBoxLayout()
self.ComboDevices = QComboBox()
self.bnEnum = QPushButton("枚举设备")
self.bnOpen = QPushButton("打开设备")
self.bnClose = QPushButton("关闭设备")
device_layout.addWidget(self.ComboDevices)
device_layout.addWidget(self.bnEnum)
device_layout.addWidget(self.bnOpen)
device_layout.addWidget(self.bnClose)
main_layout.addLayout(device_layout)
# 取流控制组
self.groupGrab = QGroupBox("取流控制")
grab_layout = QHBoxLayout(self.groupGrab)
self.bnStart = QPushButton("开始取流")
self.bnStop = QPushButton("停止取流")
self.radioContinueMode = QRadioButton("连续模式")
self.radioTriggerMode = QRadioButton("触发模式")
self.bnSoftwareTrigger = QPushButton("软触发")
grab_layout.addWidget(self.bnStart)
grab_layout.addWidget(self.bnStop)
grab_layout.addWidget(self.radioContinueMode)
grab_layout.addWidget(self.radioTriggerMode)
grab_layout.addWidget(self.bnSoftwareTrigger)
main_layout.addWidget(self.groupGrab)
# 参数设置组
self.paramgroup = QGroupBox("相机参数")
param_layout = QGridLayout(self.paramgroup)
self.edtExposureTime = QLineEdit()
self.edtGain = QLineEdit()
self.edtFrameRate = QLineEdit()
self.bnGetParam = QPushButton("获取参数")
self.bnSetParam = QPushButton("设置参数")
self.bnSaveImage = QPushButton("保存图像")
param_layout.addWidget(QLabel("曝光时间:"), 0, 0)
param_layout.addWidget(self.edtExposureTime, 0, 1)
param_layout.addWidget(self.bnGetParam, 0, 2)
param_layout.addWidget(QLabel("增益:"), 1, 0)
param_layout.addWidget(self.edtGain, 1, 1)
param_layout.addWidget(self.bnSetParam, 1, 2)
param_layout.addWidget(QLabel("帧率:"), 2, 0)
param_layout.addWidget(self.edtFrameRate, 2, 1)
param_layout.addWidget(self.bnSaveImage, 2, 2)
main_layout.addWidget(self.paramgroup)
# 图像显示区域
self.widgetDisplay = QLabel()
self.widgetDisplay.setMinimumSize(640, 480)
self.widgetDisplay.setStyleSheet("background-color: black;")
self.widgetDisplay.setAlignment(Qt.AlignCenter)
self.widgetDisplay.setText("相机预览区域")
main_layout.addWidget(self.widgetDisplay, 1)
# 创建自定义UI组件
self.setup_custom_ui()
def setup_custom_ui(self):
# 工具栏
toolbar = self.addToolBar("检测工具")
self.bnCheckPrint = QPushButton("手动检测")
self.bnSaveSample = QPushButton("保存标准样本")
self.bnPreviewSample = QPushButton("预览样本")
self.cbHistory = QComboBox()
self.cbHistory.setMinimumWidth(300)
toolbar.addWidget(self.bnCheckPrint)
toolbar.addWidget(self.bnSaveSample)
toolbar.addWidget(self.bnPreviewSample)
toolbar.addWidget(QLabel("历史记录:"))
toolbar.addWidget(self.cbHistory)
# 状态栏样本路径
self.lblSamplePath = QLabel("当前样本: 未设置样本")
self.statusBar().addPermanentWidget(self.lblSamplePath)
# 右侧面板
right_panel = QWidget()
right_layout = QVBoxLayout(right_panel)
right_layout.setContentsMargins(10, 10, 10, 10)
# 差异度调整组
diff_group = QGroupBox("差异度调整")
diff_layout = QVBoxLayout(diff_group)
self.lblDiffThreshold = QLabel("差异度阈值 (0-100%):")
self.sliderDiffThreshold = QSlider(Qt.Horizontal)
self.sliderDiffThreshold.setRange(0, 100)
self.sliderDiffThreshold.setValue(5)
self.lblDiffValue = QLabel("5%")
self.lblCurrentDiff = QLabel("当前差异度: -")
self.lblCurrentDiff.setStyleSheet("font-size: 14px; font-weight: bold;")
self.lblDiffStatus = QLabel("状态: 未检测")
self.lblDiffStatus.setStyleSheet("font-size: 12px;")
diff_layout.addWidget(self.lblDiffThreshold)
diff_layout.addWidget(self.sliderDiffThreshold)
diff_layout.addWidget(self.lblDiffValue)
diff_layout.addWidget(self.lblCurrentDiff)
diff_layout.addWidget(self.lblDiffStatus)
right_layout.addWidget(diff_group)
# ===== 模板匹配面板 =====
match_group = QGroupBox("模板匹配")
match_layout = QVBoxLayout(match_group)
# 样本设置
sample_layout = QHBoxLayout()
self.bnSetSample = QPushButton("设置标准样本")
self.bnPreviewSample = QPushButton("预览样本")
self.lblSampleStatus = QLabel("状态: 未设置样本")
sample_layout.addWidget(self.bnSetSample)
sample_layout.addWidget(self.bnPreviewSample)
sample_layout.addWidget(self.lblSampleStatus)
match_layout.addLayout(sample_layout)
# 匹配参数
param_layout = QHBoxLayout()
self.lblMatchThreshold = QLabel("匹配阈值:")
self.sliderThreshold = QSlider(Qt.Horizontal)
self.sliderThreshold.setRange(50, 100)
self.sliderThreshold.setValue(85)
self.lblThresholdValue = QLabel("85%")
param_layout.addWidget(self.lblMatchThreshold)
param_layout.addWidget(self.sliderThreshold)
param_layout.addWidget(self.lblThresholdValue)
match_layout.addLayout(param_layout)
# 自动检测开关
self.chkAutoDetect = QCheckBox("启用模板匹配自动检测")
self.chkAutoDetect.setChecked(False)
match_layout.addWidget(self.chkAutoDetect)
right_layout.addWidget(match_group)
right_layout.addStretch(1)
# 停靠窗口
dock = QDockWidget("检测控制面板", self)
dock.setWidget(right_panel)
dock.setFeatures(QDockWidget.DockWidgetMovable | QDockWidget.DockWidgetFloatable)
self.addDockWidget(Qt.RightDockWidgetArea, dock)
def closeEvent(self, event):
logging.info("主窗口关闭，执行清理...")
close_device()
event.accept()
# ===== 辅助函数 =====
def ToHexStr(num):
if not isinstance(num, int):
try:
num = int(num)
except:
return f"<非整数:{type(num)}>"
chaDic = {10: 'a', 11: 'b', 12: 'c', 13: 'd', 14: 'e', 15: 'f'}
hexStr = ""
if num < 0:
num = num + 2 ** 32
while num >= 16:
digit = num % 16
hexStr = chaDic.get(digit, str(digit)) + hexStr
num //= 16
hexStr = chaDic.get(num, str(num)) + hexStr
return "0x" + hexStr
def enum_devices():
global deviceList, obj_cam_operation
n_layer_type = (
MV_GIGE_DEVICE |
MV_USB_DEVICE |
MV_GENTL_CAMERALINK_DEVICE |
MV_GENTL_CXP_DEVICE |
MV_GENTL_XOF_DEVICE
)
# 创建设备列表
deviceList = MV_CC_DEVICE_INFO_LIST()
# 枚举设备
ret = MvCamera.MV_CC_EnumDevices(n_layer_type, deviceList)
if ret != MV_OK:
error_msg = f"枚举设备失败! 错误码: 0x{ret:x}"
logging.error(error_msg)
QMessageBox.warning(mainWindow, "错误", error_msg, QMessageBox.Ok)
return ret
if deviceList.nDeviceNum == 0:
QMessageBox.warning(mainWindow, "提示", "未找到任何设备", QMessageBox.Ok)
return MV_OK
logging.info(f"找到 {deviceList.nDeviceNum} 个设备")
# 处理设备信息
devList = []
for i in range(deviceList.nDeviceNum):
# 获取设备信息
mvcc_dev_info = ctypes.cast(
deviceList.pDeviceInfo[i],
ctypes.POINTER(MV_CC_DEVICE_INFO)
).contents
# 根据设备类型提取信息
if mvcc_dev_info.nTLayerType == MV_GIGE_DEVICE:
st_gige_info = mvcc_dev_info.SpecialInfo.stGigEInfo
ip_addr = (
f"{(st_gige_info.nCurrentIp >> 24) & 0xFF}."
f"{(st_gige_info.nCurrentIp >> 16) & 0xFF}."
f"{(st_gige_info.nCurrentIp >> 8) & 0xFF}."
f"{st_gige_info.nCurrentIp & 0xFF}"
)
# 修复：将c_ubyte_Array_16转换为字节串再解码
user_defined_bytes = bytes(st_gige_info.chUserDefinedName)
dev_name = f"GigE: {user_defined_bytes.decode('gbk', 'ignore')}"
devList.append(f"[{i}] {dev_name} ({ip_addr})")
elif mvcc_dev_info.nTLayerType == MV_USB_DEVICE:
st_usb_info = mvcc_dev_info.SpecialInfo.stUsb3VInfo
serial = bytes(st_usb_info.chSerialNumber).decode('ascii', 'ignore').rstrip('\x00')
# 修复：同样处理用户自定义名称
user_defined_bytes = bytes(st_usb_info.chUserDefinedName)
dev_name = f"USB: {user_defined_bytes.decode('gbk', 'ignore')}"
devList.append(f"[{i}] {dev_name} (SN: {serial})")
else:
devList.append(f"[{i}] 未知设备类型: {mvcc_dev_info.nTLayerType}")
# 更新UI
mainWindow.ComboDevices.clear()
mainWindow.ComboDevices.addItems(devList)
if devList:
mainWindow.ComboDevices.setCurrentIndex(0)
mainWindow.statusBar().showMessage(f"找到 {deviceList.nDeviceNum} 个设备", 3000)
return MV_OK
def set_continue_mode():
ret = obj_cam_operation.set_trigger_mode(False)
if ret != 0:
strError = "设置连续模式失败 ret:" + ToHexStr(ret)
QMessageBox.warning(mainWindow, "Error", strError, QMessageBox.Ok)
else:
mainWindow.radioContinueMode.setChecked(True)
mainWindow.radioTriggerMode.setChecked(False)
mainWindow.bnSoftwareTrigger.setEnabled(False)
def set_software_trigger_mode():
ret = obj_cam_operation.set_trigger_mode(True)
if ret != 0:
strError = "设置触发模式失败 ret:" + ToHexStr(ret)
QMessageBox.warning(mainWindow, "Error", strError, QMessageBox.Ok)
else:
mainWindow.radioContinueMode.setChecked(False)
mainWindow.radioTriggerMode.setChecked(True)
mainWindow.bnSoftwareTrigger.setEnabled(isGrabbing)
def trigger_once():
ret = obj_cam_operation.trigger_once()
if ret != 0:
strError = "软触发失败 ret:" + ToHexStr(ret)
QMessageBox.warning(mainWindow, "Error", strError, QMessageBox.Ok)
def save_sample_image():
global isGrabbing, obj_cam_operation, current_sample_path
if not isGrabbing:
QMessageBox.warning(mainWindow, "错误", "请先开始取流并捕获图像！", QMessageBox.Ok)
return
# 尝试捕获当前帧
frame = obj_cam_operation.capture_frame()
if frame is None:
QMessageBox.warning(mainWindow, "无有效图像", "未捕获到有效图像，请检查相机状态！", QMessageBox.Ok)
return
# 确保图像有效
if frame.size == 0 or frame.shape[0] == 0 or frame.shape[1] == 0:
QMessageBox.warning(mainWindow, "无效图像", "捕获的图像无效，请检查相机设置！", QMessageBox.Ok)
return
settings = QSettings("ClothInspection", "CameraApp")
last_dir = settings.value("last_save_dir", os.path.join(os.getcwd(), "captures"))
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
default_filename = f"sample_{timestamp}"
file_path, selected_filter = QFileDialog.getSaveFileName(
mainWindow,
"保存标准样本图像",
os.path.join(last_dir, default_filename),
"BMP Files (*.bmp);;PNG Files (*.png);;JPEG Files (*.jpg);;所有文件 (*)",
options=QFileDialog.DontUseNativeDialog
)
if not file_path:
return
# 确保文件扩展名正确
file_extension = os.path.splitext(file_path)[1].lower()
if not file_extension:
if "BMP" in selected_filter:
file_path += ".bmp"
elif "PNG" in selected_filter:
file_path += ".png"
elif "JPEG" in selected_filter or "JPG" in selected_filter:
file_path += ".jpg"
else:
file_path += ".bmp"
file_extension = os.path.splitext(file_path)[1].lower()
# 创建目录（如果不存在）
directory = os.path.dirname(file_path)
if directory and not os.path.exists(directory):
try:
os.makedirs(directory, exist_ok=True)
except OSError as e:
QMessageBox.critical(mainWindow, "目录创建错误", f"无法创建目录 {directory}: {str(e)}", QMessageBox.Ok)
return
# 保存图像
try:
# 使用OpenCV保存图像
if not cv2.imwrite(file_path, frame):
raise Exception("OpenCV保存失败")
# 更新状态
current_sample_path = file_path
update_sample_display()
settings.setValue("last_save_dir", os.path.dirname(file_path))
# 显示成功消息
QMessageBox.information(mainWindow, "成功", f"标准样本已保存至:\n{file_path}", QMessageBox.Ok)
# 更新样本状态
mainWindow.lblSampleStatus.setText("状态: 样本已设置")
mainWindow.lblSampleStatus.setStyleSheet("color: green;")
except Exception as e:
logging.error(f"保存图像失败: {str(e)}")
QMessageBox.critical(mainWindow, "保存错误", f"保存图像时发生错误:\n{str(e)}", QMessageBox.Ok)
def preview_sample():
global current_sample_path
if not current_sample_path or not os.path.exists(current_sample_path):
QMessageBox.warning(mainWindow, "错误", "请先设置有效的标准样本图像！", QMessageBox.Ok)
return
try:
# 直接使用OpenCV加载图像
sample_img = cv2.imread(current_sample_path)
if sample_img is None:
raise Exception("无法加载图像")
# 显示图像
cv2.imshow("标准样本预览", sample_img)
cv2.waitKey(0)
cv2.destroyAllWindows()
except Exception as e:
QMessageBox.warning(mainWindow, "错误", f"预览样本失败: {str(e)}", QMessageBox.Ok)
def is_float(str):
try:
float(str)
return True
except ValueError:
return False
def get_param():
try:
ret = obj_cam_operation.get_parameters()
if ret != MV_OK:
strError = "获取参数失败，错误码: " + ToHexStr(ret)
QMessageBox.warning(mainWindow, "错误", strError, QMessageBox.Ok)
else:
mainWindow.edtExposureTime.setText("{0:.2f}".format(obj_cam_operation.exposure_time))
mainWindow.edtGain.setText("{0:.2f}".format(obj_cam_operation.gain))
mainWindow.edtFrameRate.setText("{0:.2f}".format(obj_cam_operation.frame_rate))
except Exception as e:
error_msg = f"获取参数时发生错误: {str(e)}"
QMessageBox.critical(mainWindow, "严重错误", error_msg, QMessageBox.Ok)
def set_param():
frame_rate = mainWindow.edtFrameRate.text()
exposure = mainWindow.edtExposureTime.text()
gain = mainWindow.edtGain.text()
if not (is_float(frame_rate) and is_float(exposure) and is_float(gain)):
strError = "设置参数失败: 参数必须是有效的浮点数"
QMessageBox.warning(mainWindow, "错误", strError, QMessageBox.Ok)
return MV_E_PARAMETER
try:
ret = obj_cam_operation.set_param(
frame_rate=float(frame_rate),
exposure_time=float(exposure),
gain=float(gain)
)
if ret != MV_OK:
strError = "设置参数失败，错误码: " + ToHexStr(ret)
QMessageBox.warning(mainWindow, "错误", strError, QMessageBox.Ok)
except Exception as e:
error_msg = f"设置参数时发生错误: {str(e)}"
QMessageBox.critical(mainWindow, "严重错误", error_msg, QMessageBox.Ok)
def enable_controls():
global isGrabbing, isOpen
mainWindow.groupGrab.setEnabled(isOpen)
mainWindow.paramgroup.setEnabled(isOpen)
mainWindow.bnOpen.setEnabled(not isOpen)
mainWindow.bnClose.setEnabled(isOpen)
mainWindow.bnStart.setEnabled(isOpen and (not isGrabbing))
mainWindow.bnStop.setEnabled(isOpen and isGrabbing)
mainWindow.bnSoftwareTrigger.setEnabled(isGrabbing and mainWindow.radioTriggerMode.isChecked())
mainWindow.bnSaveImage.setEnabled(isOpen and isGrabbing)
mainWindow.bnCheckPrint.setEnabled(isOpen and isGrabbing)
mainWindow.bnSaveSample.setEnabled(isOpen and isGrabbing)
mainWindow.bnPreviewSample.setEnabled(bool(current_sample_path))
# 模板匹配控制
mainWindow.chkAutoDetect.setEnabled(bool(current_sample_path) and isGrabbing)
# ===== 相机帧监控线程 =====
class FrameMonitorThread(QThread):
frame_status = pyqtSignal(str) # 用于发送状态消息的信号
def __init__(self, cam_operation):
super().__init__()
self.cam_operation = cam_operation
self.running = True
self.frame_count = 0
self.last_time = time.time()
def run(self):
"""监控相机帧状态的主循环"""
while self.running:
try:
if self.cam_operation and self.cam_operation.is_grabbing:
# 获取帧统计信息
frame_info = self.get_frame_info()
if frame_info:
fps = frame_info.get('fps', 0)
dropped = frame_info.get('dropped', 0)
status = f"FPS: {fps:.1f} | 丢帧: {dropped}"
self.frame_status.emit(status)
else:
self.frame_status.emit("取流中...")
else:
self.frame_status.emit("相机未取流")
except Exception as e:
self.frame_status.emit(f"监控错误: {str(e)}")
# 每500ms检查一次
QThread.msleep(500)
def stop(self):
"""停止监控线程"""
self.running = False
self.wait(1000) # 等待线程结束
def calculate_fps(self):
"""计算当前帧率"""
current_time = time.time()
elapsed = current_time - self.last_time
if elapsed > 0:
fps = self.frame_count / elapsed
self.frame_count = 0
self.last_time = current_time
return fps
return 0
def get_frame_info(self):
"""获取帧信息"""
try:
# 更新帧计数
self.frame_count += 1
# 返回帧信息
return {
'fps': self.calculate_fps(),
'dropped': 0 # 实际应用中需要从相机获取真实丢帧数
}
except Exception as e:
logging.error(f"获取帧信息失败: {str(e)}")
return None
# ===== 主程序入口 =====
if __name__ == "__main__":
# 配置日志系统
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
handlers=[
logging.FileHandler("cloth_inspection_template.log"),
logging.StreamHandler()
]
)
logging.info("布料印花检测系统(模板匹配版)启动")
app = QApplication(sys.argv)
mainWindow = MainWindow()
# 信号连接
mainWindow.sliderDiffThreshold.valueChanged.connect(update_diff_threshold)
mainWindow.bnCheckPrint.clicked.connect(lambda: vision_controlled_check(None))
mainWindow.bnSaveSample.clicked.connect(save_sample_image)
mainWindow.bnPreviewSample.clicked.connect(preview_sample)
mainWindow.bnEnum.clicked.connect(enum_devices)
mainWindow.bnOpen.clicked.connect(open_device)
mainWindow.bnClose.clicked.connect(close_device)
mainWindow.bnStart.clicked.connect(start_grabbing)
mainWindow.bnStop.clicked.connect(stop_grabbing)
mainWindow.bnSoftwareTrigger.clicked.connect(trigger_once)
mainWindow.radioTriggerMode.clicked.connect(set_software_trigger_mode)
mainWindow.radioContinueMode.clicked.connect(set_continue_mode)
mainWindow.bnGetParam.clicked.connect(get_param)
mainWindow.bnSetParam.clicked.connect(set_param)
mainWindow.bnSaveImage.clicked.connect(save_sample_image)
# 模板匹配信号连接
mainWindow.sliderThreshold.valueChanged.connect(update_match_threshold)
mainWindow.chkAutoDetect.stateChanged.connect(toggle_template_matching)
mainWindow.show()
app.exec_()
close_device()
sys.exit()
最新发布
本文介绍了一种高效算法，用于计算一组整数中所有不同数对之间的汉明距离总和。通过统计每个二进制位上的0和1的个数，避免了传统的逐对比较方法，从而将时间复杂度降低到O(n)。
扫一扫
25
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
