def create_capture(camera: QCamera, callback: Callable,
error: Callable) -> QCameraImageCapture:
capture = QCameraImageCapture(camera)
capture.setCaptureDestination(QCameraImageCapture.CaptureToBuffer)
capture.imageCaptured.connect(callback)
capture.error.connect(error)
return capture
class CameraMainWin(QtWidgets.QMainWindow, CameraWin.CameraWin):
def __init__(self):
super(CameraMainWin, self).__init__()
self.setupUi(self)
#定义相机实例对象并设置捕获模式
self.camera = QCamera()
self.camera.setCaptureMode(QCamera.CaptureViewfinder)
self.cameraOpened = False # 设置相机打开状态为未打开
#设置取景器分辨率
viewFinderSettings = QCameraViewfinderSettings()
viewFinderSettings.setResolution(800, 600)
self.camera.setViewfinderSettings(viewFinderSettings)
#初始化取景器
self.viewCamera = QtMultimediaWidgets.QCameraViewfinder(self)
self.camera.setViewfinder(self.viewCamera)
self.camera.setCaptureMode(QCamera.CaptureStillImage)
self.camerLayout.addWidget(self.viewCamera) #取景器放置到预留的布局中
#设置图像捕获
self.capture = QCameraImageCapture(self.camera)
self.capture.setCaptureDestination(
QCameraImageCapture.CaptureToBuffer) #CaptureToBuffer
self.switchCamera: QPushButton
self.switchCamera.clicked.connect(self.SwitchCamera)
self.takePic.clicked.connect(self.TakePic)
self.capture.error.connect(lambda i, e, s: self.alert(s))
self.capture.imageAvailable.connect(self.saveImage)
self.capture.imageCaptured.connect(
lambda d, i: self.status.showMessage("Image %04d captured" % self.
save_seq))
#相机（摄像头）开关处理
def SwitchCamera(self):
if not self.cameraOpened:
print('test1')
self.camera.start()
print('test2')
self.cameraOpened = True
self.switchCamera.setText("关闭摄像头")
else:
self.camera.stop()
self.cameraOpened = False
self.switchCamera.setText("打开摄像头")
def TakePic(self): #拍照响应槽函数，照片保存到文件
FName = fr"/Users/xiaozhenlong/Desktop/tmp/{time.strftime('%Y%m%d%H%M%S', time.localtime())}" #文件名初始化
print(self.capture.capture(FName + '.jpg'))
print(f"捕获图像保存到文件：{FName}.jpg")
def saveImage(self, requestId, image):
print('test3')
image: PyQt5.QtMultimedia.QVideoFrame
image = qimage2numpy2(image.image())
print(image.shape)
cv2.imwrite('/Users/xiaozhenlong/Desktop/tmp/test3.jpg', image)
class CameraMainWin(QtWidgets.QMainWindow, CameraWin.Ui_CameraWin):
def __init__(self):
super(CameraMainWin, self).__init__()
self.setupUi(self)
#定义相机实例对象并设置捕获模式
self.camera = QCamera()
self.camera.setCaptureMode(QCamera.CaptureViewfinder)
self.cameraOpened = False # 设置相机打开状态为未打开
#设置取景器分辨率
viewFinderSettings = QCameraViewfinderSettings()
viewFinderSettings.setResolution(800, 600)
self.camera.setViewfinderSettings(viewFinderSettings)
#初始化取景器
self.viewCamera = QtMultimediaWidgets.QCameraViewfinder(self)
self.camera.setViewfinder(self.viewCamera)
self.camerLayout.addWidget(self.viewCamera) #取景器放置到预留的布局中
#设置图像捕获
self.capImg = QCameraImageCapture(self.camera)
self.capImg.setCaptureDestination(
QCameraImageCapture.CaptureToFile) #CaptureToBuffer
#相机（摄像头）开关处理
def switchCamera(self):
if not self.cameraOpened:
self.camera.start()
self.cameraOpened = True
self.btnSwitchCamera.setText("关闭摄像头")
else:
self.camera.stop()
self.cameraOpened = False
self.btnSwitchCamera.setText("打开摄像头")
def takePic(self): #拍照响应槽函数，照片保存到文件
FName = fr"E:\iddatabasepic\cap{time.strftime('%Y%m%d%H%M%S', time.localtime())}" #文件名初始化
self.capImg.capture(FName)
print(f"捕获图像保存到文件：{FName}.jpg")
class Camera(QObject):
def __init__(self, parent=QObject()):
super(Camera, self).__init__(parent)
# chooses the system default camera
self.cam = QCamera()
self.imageCapture = QCameraImageCapture(self.cam)
self.caminfo = QCameraInfo(self.cam)
self.camvfind = QCameraViewfinder()
self.camvfindset = QCameraViewfinderSettings()
self.recorder = QMediaRecorder(self.cam)
def init_camera(self):
cameras = QCameraInfo.availableCameras()
for cameraInfo in cameras:
# select the capturing device if it is available
if cameraInfo.description().find("Capture") is not -1:
self.cam = QCamera(cameraInfo)
self.caminfo = QCameraInfo(self.cam)
self.recorder = QMediaRecorder(self.cam)
print("Camera Chosen: " + self.caminfo.description())
print(self.cam.supportedViewfinderFrameRateRanges())
self.cam.setCaptureMode(QCamera.CaptureStillImage)
if self.cam.isCaptureModeSupported(QCamera.CaptureStillImage):
print("Capturemode supported")
self.cam.load()
self.cam.setViewfinder(self.camvfind)
self.cam.start()
self.imageCapture = QCameraImageCapture(self.cam)
self.imageCapture.setCaptureDestination(
QCameraImageCapture.CaptureToBuffer)
def capture_still(self):
self.imageCapture.capture()
def setOnCapture(self, callback=None):
self.imageCapture.imageCaptured.connect(callback)
def start_vid(self):
self.cam.load()
# self.camvfind.show()
self.cam.setViewfinder(self.camvfind)
self.cam.setCaptureMode(QCamera.CaptureVideo)
self.cam.start()
audio = QAudioEncoderSettings()
audio.setCodec("audio/amr")
audio.setQuality(QtMultimedia.QMultimedia.NormalQuality)
video = QVideoEncoderSettings()
# video.setCodec("video/mp4")
video.setQuality(QtMultimedia.QMultimedia.NormalQuality)
video.setResolution(1920, 1080)
video.setFrameRate(30.0)
# self.recorder.setAudioSettings(audio)
self.recorder.setVideoSettings(video)
self.recorder.setContainerFormat("mp4")
print("Output Loc: " + str(self.recorder.outputLocation()))
def start_recording(self):
directory = os.path.abspath(str(os.getcwd()))
filename = "test" + str(time.time()) + ".mp4"
abs_path = os.path.join(directory, filename)
self.recorder.setOutputLocation(QUrl(abs_path))
self.recorder.record()
def stop_recording(self):
self.recorder.stop()
class QmyMainWindow(QMainWindow):
def __init__(self, parent=None):
super().__init__(parent) #调用父类构造函数，创建窗体
self.ui = Ui_MainWindow() #创建UI对象
self.ui.setupUi(self) #构造UI界面
self.__LabCameraState = QLabel("摄像头state:")
self.__LabCameraState.setMinimumWidth(150)
self.ui.statusBar.addWidget(self.__LabCameraState)
self.__LabImageID = QLabel("图片文件ID:")
self.__LabImageID.setMinimumWidth(100)
self.ui.statusBar.addWidget(self.__LabImageID)
self.__LabImageFile = QLabel("") #保存的图片文件名
## self.ui.statusBar.addWidget(self.__LabImageFile)
self.ui.statusBar.addPermanentWidget(self.__LabImageFile)
self.camera = None #QCamera对象
cameras = QCameraInfo.availableCameras() #list[QCameraInfo]
if len(cameras) > 0:
self.__iniCamera() #初始化摄像头
self.__iniImageCapture() #初始化静态画图
self.camera.start()
## ==============自定义功能函数========================
def __iniCamera(self): ##创建 QCamera对象
camInfo = QCameraInfo.defaultCamera() #获取缺省摄像头,QCameraInfo
self.ui.comboCamera.addItem(camInfo.description()) #摄像头描述
self.ui.comboCamera.setCurrentIndex(0)
self.camera = QCamera(camInfo) #创建摄像头对象
self.camera.setViewfinder(self.ui.viewFinder) #设置取景框预览
## camera.setCaptureMode(QCamera.CaptureViewfinder) #预览
self.camera.setCaptureMode(QCamera.CaptureStillImage) #设置为抓图
## camera.setCaptureMode(QCamera.CaptureVideo)
mode = QCamera.CaptureStillImage
supported = self.camera.isCaptureModeSupported(mode)
self.ui.checkStillImage.setChecked(supported) #支持拍照
supported = self.camera.isCaptureModeSupported(QCamera.CaptureVideo)
self.ui.checkVideo.setChecked(supported) #支持视频录制
supported = self.camera.exposure().isAvailable()
self.ui.checkExposure.setChecked(supported) #支持曝光补偿
supported = self.camera.focus().isAvailable()
self.ui.checkFocus.setChecked(supported) #支持变焦
self.camera.stateChanged.connect(self.do_cameraStateChanged)
def __iniImageCapture(self): ##创建 QCameraImageCapture对象
self.capturer = QCameraImageCapture(self.camera)
settings = QImageEncoderSettings() #拍照设置
settings.setCodec("image/jpeg") #设置抓图图形编码
settings.setResolution(640, 480) #分辨率
settings.setQuality(QMultimedia.HighQuality) #图片质量
self.capturer.setEncodingSettings(settings)
self.capturer.setBufferFormat(QVideoFrame.Format_Jpeg) #缓冲区格式
if self.ui.chkBoxSaveToFile.isChecked():
dest = QCameraImageCapture.CaptureToFile #保存到文件
else:
dest = QCameraImageCapture.CaptureToBuffer #保存到缓冲区
self.capturer.setCaptureDestination(dest) #保存目标
self.capturer.readyForCaptureChanged.connect(self.do_imageReady)
self.capturer.imageCaptured.connect(self.do_imageCaptured)
self.capturer.imageSaved.connect(self.do_imageSaved)
## ==============event处理函数==========================
## ==========由connectSlotsByName()自动连接的槽函数============
@pyqtSlot(bool) ##设置保存方式
def on_chkBoxSaveToFile_clicked(self, checked):
if checked:
dest = QCameraImageCapture.CaptureToFile #保存到文件
else:
dest = QCameraImageCapture.CaptureToBuffer #保存到缓冲区
self.capturer.setCaptureDestination(dest) #保存目标
@pyqtSlot() ##拍照
def on_actCapture_triggered(self):
QSound.play("shutter.wav") #播放快门音效
self.camera.searchAndLock() #快门半按下时锁定摄像头参数
self.capturer.capture() #拍照
self.camera.unlock() #快门按钮释放时解除锁定
@pyqtSlot() ##打开摄像头
def on_actStartCamera_triggered(self):
self.camera.start()
@pyqtSlot() ##关闭摄像头
def on_actStopCamera_triggered(self):
self.camera.stop()
## =============自定义槽函数===============================
def do_cameraStateChanged(self, state): ##摄像头状态变化
if (state == QCamera.UnloadedState):
self.__LabCameraState.setText("摄像头state: UnloadedState")
elif (state == QCamera.LoadedState):
self.__LabCameraState.setText("摄像头state: LoadedState")
elif (state == QCamera.ActiveState):
self.__LabCameraState.setText("摄像头state: ActiveState")
self.ui.actStartCamera.setEnabled(state != QCamera.ActiveState)
self.ui.actStopCamera.setEnabled(state == QCamera.ActiveState)
def do_imageReady(self, ready): ##是否可以拍照了
self.ui.actCapture.setEnabled(ready)
def do_imageCaptured(self, imageID, preview): ##图片被抓取到内存
#preview是 QImage
H = self.ui.LabImage.height()
W = self.ui.LabImage.width()
scaledImage = preview.scaled(W, H, Qt.KeepAspectRatio,
Qt.SmoothTransformation)
self.ui.LabImage.setPixmap(QPixmap.fromImage(scaledImage))
self.__LabImageID.setText("图片文件ID:%d" % imageID)
self.__LabImageFile.setText("图片保存为： ")
def do_imageSaved(self, imageID, fileName): ##图片被保存
self.__LabImageID.setText("图片文件ID:%d" % imageID)
self.__LabImageFile.setText("图片保存为： " + fileName)
class MainWindow(QWidget):
face = Face()
def __init__(self):
super().__init__()
self.start_ui()
def start_ui(self):
self.zui = Ui_zwin()
self.zui.setupUi(self)
self.zui.camera_label.setScaledContents(True)
# 初始化信息
self.zui.label_xuehao.setText("工号：")
self.zui.label_mingzi.setText("姓名：")
self.zui.label_time.setText("签到时间：")
# 查询按钮
self.zui.cxbtn.clicked.connect(self.cx_ui)
# 注册按钮
self.zui.zcbtn.clicked.connect(self.zq_zc)
# 签到按钮
self.zui.qdbtn.clicked.connect(self.zq_qd)
# 删除按钮
self.zui.del_btn.clicked.connect(self.del_yg)
# 导出按钮
self.zui.out_btn.clicked.connect(self.out_ex)
# 摄像头控制
camera = QCamera(self) # 创建摄像头
cameraviewfinder = QCameraViewfinder(self.zui.camera_label) # 创建显示窗口
cameraviewfinder.resize(752, 420)
self.cameraImageCapture = QCameraImageCapture(camera) # 绑定获取的摄像头
self.cameraImageCapture.setCaptureDestination(
QCameraImageCapture.CaptureToFile) # 获取数据类型
camera.setCaptureMode(QCamera.CaptureStillImage)
camera.setViewfinder(cameraviewfinder) # 绑定窗口
camera.start() # 开启摄像头
def out_ex(self):
"""
导出考勤记录
:return:
"""
wk = Workbook()
wb = wk.active
wb.append(['姓名', '工号', '打卡时间', '状态'])
result = obj.get_list("select name, no, ctime, st from qds", [])
for i in result:
wb.append(i)
wk.save(r'kaoqing.xlsx')
return QMessageBox.information(self, "提示", '导出成功...', QMessageBox.Yes,
QMessageBox.Yes)
def del_yg(self):
"""
删除员工
:return:
"""
gh = self.zui.gonghao.text()
if not gh:
return QMessageBox.information(self, "提示", '请填写工号...',
QMessageBox.Yes, QMessageBox.Yes)
if obj.get_list('select no from user where no=%s', [
gh,
]):
obj.modify('delete from user where no=%s', [
gh,
])
return QMessageBox.information(self, "提示", '删除成功...',
QMessageBox.Yes, QMessageBox.Yes)
else:
return QMessageBox.information(self, "提示", '删除失败...',
QMessageBox.Yes, QMessageBox.Yes)
def zc(self, xx, image):
"""
注册
:return:
"""
self.cameraImageCapture.disconnect()
pximap = QPixmap.fromImage(image) # 获取摄像头图片
pximap.save('image.jpg') # 保存图片
name = self.zui.mingzi.text()
no = self.zui.xuehao.text()
if not name or not no:
QMessageBox.information(self, "提示", '请填写工号跟姓名...', QMessageBox.Yes,
QMessageBox.Yes)
return self.zui.zcbtn.setDisabled(False)
path = 'image.jpg'
print(103)
face_token = self.face.C_addFace(name, no, path)
print(105, face_token)
if face_token:
try:
obj.modify(
"insert into user(name,no,face_token) values (%s,%s,%s)", [
name,
no,
face_token,
])
except Exception as e:
obj.rollback()
self.zui.zcbtn.setDisabled(False)
return QMessageBox.information(self, "提示", '用户已存在...',
QMessageBox.Yes,
QMessageBox.Yes)
QMessageBox.information(self, "提示", '注册成功...', QMessageBox.Yes,
QMessageBox.Yes)
obj.modify("insert into qds_month(name,no,st_no) values (%s,%s,0)",
[
name,
no,
])
else:
QMessageBox.information(self, "提示", '注册失败...', QMessageBox.Yes,
QMessageBox.Yes)
self.zui.zcbtn.setDisabled(False)
def qd(self, xx, image):
"""
签到
:return:
"""
self.cameraImageCapture.disconnect()
pximap = QPixmap.fromImage(image) # 获取摄像头图片
pximap.save('image.jpg') # 保存图片
t = self.face.C_searchFace('image.jpg')
if t:
no = t[1]
name = t[0]
face_token = t[2]
res = obj.get_list("select no from user where face_token=%s", [
face_token,
])
if len(res) <= 0:
QMessageBox.information(self, "提示", '数据库无此人信息...',
QMessageBox.Yes, QMessageBox.Yes)
return self.zui.qdbtn.setDisabled(False)
ctime = datetime.datetime.today().strftime('%Y-%m-%d %H:%M:%S')
self.zui.label_xuehao.setText("工号：" + str(no))
self.zui.label_mingzi.setText("姓名：" + str(name))
self.zui.label_time.setText("签到时间：" + ctime)
hour = datetime.datetime.today().hour
st = '异常'
if hour < 8 or hour > 17:
st = '正常'
# 执行sql语句
obj.modify(
"insert into qds(name,no,ctime,st) values (%s,%s,%s,%s)", [
name,
no,
ctime,
st,
])
QMessageBox.information(self, "提示", '签到成功...', QMessageBox.Yes,
QMessageBox.Yes)
else:
QMessageBox.information(self, "提示", '查无此人...', QMessageBox.Yes,
QMessageBox.Yes)
self.zui.qdbtn.setDisabled(False)
def zq_zc(self):
"""注册抓取"""
self.zui.zcbtn.setDisabled(True)
self.cameraImageCapture.imageCaptured.connect(self.zc) # 截取图片后链接显示方法
self.cameraImageCapture.capture() # 抓取方法
def zq_qd(self):
"""签到抓取"""
self.zui.qdbtn.setDisabled(True)
self.cameraImageCapture.imageCaptured.connect(self.qd) # 截取图片后链接显示方法
self.cameraImageCapture.capture() # 抓取方法
def cx_ui(self):
# 查询窗口
self.cxui = Ui_cx()
self.cxw = QDialog()
self.cxui.setupUi(self.cxw)
# 设置表格
self.cxui.tableWidget.horizontalHeader().setStretchLastSection(False)
self.cxui.tableWidget.setColumnWidth(0, 120)
self.cxui.tableWidget.setColumnWidth(1, 120)
# self.cxui.tableWidget.setColumnWidth(2, 100)
self.cxui.tableWidget.horizontalHeader().setSectionResizeMode(
0, QHeaderView.Stretch)
self.cxui.tableWidget.horizontalHeader().setSectionResizeMode(
1, QHeaderView.Stretch)
self.cxui.tableWidget.horizontalHeader().setSectionResizeMode(
2, QHeaderView.Stretch)
self.cxui.tableWidget.setRowCount(0) # 设置行=0
self.cxui.tableWidget.clearContents() # 清除内容
# 查询按钮
self.cxui.btn_cx.disconnect()
self.cxui.btn_cx.clicked.connect(self.cx)
self.cxw.exec_()
def cx(self):
"""查询数据"""
self.cxui.tableWidget.setRowCount(0) # 设置行=0
self.cxui.tableWidget.clearContents() # 清楚内容
no = self.cxui.xuehao_cx.text()
name = self.cxui.mingzi_cx.text()
print(no, name, 'xxxxxx')
if name == 'admin':
data = obj.get_list(
"select name, no, ctime, st_no from qds_month order by st_no desc",
[])
if len(data) <= 0:
return QMessageBox.information(self, "提示", '查询无记录...',
QMessageBox.Yes,
QMessageBox.Yes)
for k, i in enumerate(data):
name = i[0]
no = i[1]
ctime = i[2]
st = i[3]
self.cxui.tableWidget.insertRow(k)
self.cxui.tableWidget.setItem(k, 0, QTableWidgetItem(str(no)))
self.cxui.tableWidget.item(k,
0).setTextAlignment(Qt.AlignCenter)
self.cxui.tableWidget.setItem(k, 1,
QTableWidgetItem(str(name)))
self.cxui.tableWidget.item(k,
1).setTextAlignment(Qt.AlignCenter)
self.cxui.tableWidget.setItem(k, 2,
QTableWidgetItem(str(ctime)))
self.cxui.tableWidget.item(k,
2).setTextAlignment(Qt.AlignCenter)
self.cxui.tableWidget.setItem(k, 3, QTableWidgetItem(str(st)))
self.cxui.tableWidget.item(k,
3).setTextAlignment(Qt.AlignCenter)
print(i)
return
if not no and not name:
time = datetime.datetime.now()
sql = "select name, no, ctime, st from qds where st = '异常' " + 'order by ctime desc limit 7'
print(sql)
data = obj.get_list(sql, [])
print(data)
if len(data) <= 0:
return QMessageBox.information(self, "提示", '查询无记录...',
QMessageBox.Yes,
QMessageBox.Yes)
for k, i in enumerate(data):
name = i[0]
no = i[1]
ctime = i[2]
st = i[3]
print(type(ctime))
now = str(ctime)
cur = str(time)
now = now[:10]
cur = cur[:10]
if now != cur:
continue
self.cxui.tableWidget.insertRow(k)
self.cxui.tableWidget.setItem(k, 0, QTableWidgetItem(str(no)))
self.cxui.tableWidget.item(k,
0).setTextAlignment(Qt.AlignCenter)
self.cxui.tableWidget.setItem(k, 1,
QTableWidgetItem(str(name)))
self.cxui.tableWidget.item(k,
1).setTextAlignment(Qt.AlignCenter)
self.cxui.tableWidget.setItem(k, 2,
QTableWidgetItem(str(ctime)))
self.cxui.tableWidget.item(k,
2).setTextAlignment(Qt.AlignCenter)
self.cxui.tableWidget.setItem(k, 3, QTableWidgetItem(str(st)))
self.cxui.tableWidget.item(k,
3).setTextAlignment(Qt.AlignCenter)
print(i)
return
#return QMessageBox.information(self, "提示", '请出入查询条件...', QMessageBox.Yes, QMessageBox.Yes)
s = ''
if no:
s += "and no like '%%{}%%'".format(no, )
if name:
s += "and name like '%%{}%%'".format(name, )
sql = "select name, no, ctime,st from qds where 1=1" + ' ' + s + 'order by ctime desc limit 7'
print(sql)
data = obj.get_list(sql, [])
if len(data) <= 0:
return QMessageBox.information(self, "提示", '查询无记录...',
QMessageBox.Yes, QMessageBox.Yes)
for k, i in enumerate(data):
name = i[0]
no = i[1]
ctime = i[2]
st = i[3]
self.cxui.tableWidget.insertRow(k)
self.cxui.tableWidget.setItem(k, 0, QTableWidgetItem(str(no)))
self.cxui.tableWidget.item(k, 0).setTextAlignment(Qt.AlignCenter)
self.cxui.tableWidget.setItem(k, 1, QTableWidgetItem(str(name)))
self.cxui.tableWidget.item(k, 1).setTextAlignment(Qt.AlignCenter)
self.cxui.tableWidget.setItem(k, 2, QTableWidgetItem(str(ctime)))
self.cxui.tableWidget.item(k, 2).setTextAlignment(Qt.AlignCenter)
self.cxui.tableWidget.setItem(k, 3, QTableWidgetItem(str(st)))
self.cxui.tableWidget.item(k, 3).setTextAlignment(Qt.AlignCenter)
print(i)
class QmyCamerawindow(QMainWindow):
def __initCamera(self):
camInfo = QCameraInfo.defaultCamera()
self.camera = QCamera(camInfo)
self.camera2 = QCamera(camInfo)
self.camera.setViewfinder(self._ui.widget)
self.camera2.setViewfinder(self._ui.widget_2)
self.camera.setCaptureMode(
QCamera.CaptureStillImage) #captureviewfinder
self.camera2.setCaptureMode(QCamera.CaptureStillImage)
def _initImageCapture(self):
self.capture = QCameraImageCapture(self.camera)
self.capture2 = QCameraImageCapture(self.camera2)
setting = QImageEncoderSettings()
setting.setCodec("image/jpeg")
self.capture.setEncodingSettings(setting)
self.capture.setBufferFormat(QVideoFrame.Format_Jpeg)
self.capture.setCaptureDestination(QCameraImageCapture.CaptureToBuffer)
self.capture.readyForCaptureChanged.connect(self.do_imageReady)
self.capture.imageCaptured.connect(self.do_imageCaptured)
self.capture2.setEncodingSettings(setting)
self.capture2.setBufferFormat(QVideoFrame.Format_Jpeg)
self.capture2.setCaptureDestination(
QCameraImageCapture.CaptureToBuffer)
self.capture2.readyForCaptureChanged.connect(self.do_imageReady)
self.capture2.imageCaptured.connect(self.do_imageCaptured2)
# self.capture.setCaptureDestination(QCameraImageCapture.CaptureToFile)
def do_imageReady(self, ready):
self._ui.actionActCaputure.setEnabled(ready)
def do_imageCaptured2(self, image_id, preview):
self.getpicname2()
preview.save(self.picname2)
cv2.waitKey(500)
resultid = useract.find_one(self.facealbum_token, self.picname2)
print(resultid)
cv2.waitKey(500)
data = sqlact.search_sql("student", resultid)
print(data)
self._ui.plainTextEdit_3.setPlainText(data[0][1])
self._ui.plainTextEdit_4.setPlainText(data[0][2])
self._ui.plainTextEdit_5.setPlainText(str(data[0][3]))
# print(preview)
def do_imageCaptured(self, image_id, preview):
H = self._ui.label_2.height()
W = self._ui.label_2.width()
scaledImage = preview.scaled(W, H, Qt.KeepAspectRatio,
Qt.SmoothTransformation)
self._ui.label_2.setPixmap(QPixmap.fromImage(scaledImage))
self.getpicname()
preview.save(self.picname)
# useract.add_newone("student",name)
def on_actionActCaputure_triggered(self):
# QSound.play("shutter.wav")
self.camera.searchAndLock()
self.capture.capture()
self.camera.unlock()
# FName = fr"E:\iddatabasepic\cap{time.strftime('%Y%m%d%H%M%S', time.localtime())}"
# self.flag += 1
# self.capture.capture(FName)
# print(f"捕获图像保存到文件：{FName}.jpg")
def on_actionActStartCamera_triggered(self):
self.camera.start()
self.flag = 1
def on_actionActCloseCamrera_triggered(self):
self.camera.stop()
self.flag = 0
def on_actionActExit_triggered(self):
self.camera.stop()
self.close()
def gettext(self):
self.text = self._ui.plainTextEdit.toPlainText()
self.text2 = self._ui.plainTextEdit_2.toPlainText()
useract.add_newone("student", self.text, self.text2,
self.facealbum_token, self.picname)
def getpicname(self): #获取图片名
self.picname = fr"E:\iddatabasepic\cap{time.strftime('%Y%m%d%H%M%S', time.localtime())}" + ".jpg"
# print(self.text)
def getpicname2(self): #获取图片名
self.picname2 = fr"E:\iddatabasepic\capnew{time.strftime('%Y%m%d%H%M%S', time.localtime())}" + ".jpg"
def tabshift1(self):
# print(self.tabWidget.currentIndex())
# print("hello")
self._ui.tabWidget.setCurrentIndex(0)
if self.flag2 == 1:
self.camera2.stop()
self.flag2 = 0
def tabshift2(self):
self._ui.tabWidget.setCurrentIndex(1)
if self.flag == 1:
self.camera.stop()
self.flag = 0
self.flag2 = 1
useract.group_all(self.facealbum_token)
self.camera2.start()
def tabshift3(self):
self._ui.tabWidget.setCurrentIndex(2)
if self.flag == 1:
self.camera.stop()
self.flag = 0
if self.flag2 == 1:
self.camera2.stop()
self.flag2 = 0
def searchcap(self):
self.camera2.searchAndLock()
self.capture2.capture()
self.camera2.unlock()
def dataview(self):
view = sqlact.search_all_sql("student")
self._ui.plainTextEdit_7.setPlainText(",".join(
[str(t) for i in view for t in i]))
def __init__(self, parent=None):
super().__init__(parent)
self._ui = Ui_MainWindowcamera()
self.flag = 1
self.flag2 = 0
self._ui.setupUi(self)
self.camera = None
self.picname2 = ""
self.picname = ""
self.facealbum_token = "1577420387-3990379c-dcc2-4fe8-ae47-bf37a299118d"
self._ui.btnget.clicked.connect(self.gettext)
self._ui.addnew.clicked.connect(self.tabshift1)
self._ui.searchinfo.clicked.connect(self.tabshift2)
self._ui.pushButton_3.clicked.connect(self.tabshift3)
self._ui.btncap.clicked.connect(self.searchcap)
self._ui.btndata.clicked.connect(self.dataview)
cameras = QCameraInfo.availableCameras()
if len(cameras) > 0:
self.__initCamera()
self._initImageCapture()
self.camera.start()
class CameraView(QMainWindow):
"""
Camera view widget
.ui form is based on pyqt5/examples/multimediawidgets/camera
"""
def __init__(self, camera, parent=None):
super(CameraView, self).__init__(parent)
self.app = QApplication.instance()
self.camera = camera
self.ui = ui_camera.Ui_CameraView()
self.ui.setupUi(self)
self.setWindowTitle(iWebcamIpfsCapture())
self.camera.setCaptureMode(QCamera.CaptureStillImage)
self.camera.stateChanged.connect(self.onCameraStateChange)
self.camera.error.connect(self.onCameraError)
# Image capture
self.imageCapture = QCameraImageCapture(self.camera)
self.imageCapture.setCaptureDestination(
QCameraImageCapture.CaptureToBuffer)
self.imageCapture.imageCaptured.connect(
lambda reqid, img: ensure(self.handleImage(reqid, img)))
self.imageCapture.readyForCaptureChanged.connect(self.readyForCapture)
# Recorder
self.mediaRecorder = QMediaRecorder(self.camera)
self.mediaRecorder.durationChanged.connect(self.recDurationChanged)
self.mediaRecorder.stateChanged.connect(self.updateRecorderState)
self.mediaRecorder.actualLocationChanged.connect(
self.recLocationChanged)
self.mediaRecorder.error.connect(self.onRecorderError)
self.ui.captureWidget.currentChanged.connect(self.updateCaptureMode)
self.ui.captureImageButton.clicked.connect(self.captureImage)
self.ui.closeButton.clicked.connect(self.onClose)
self.ui.recordButton.clicked.connect(self.record)
self.ui.pauseButton.clicked.connect(self.pause)
self.ui.stopButton.clicked.connect(lambda: ensure(self.stop()))
self.ui.muteButton.toggled.connect(self.setMuted)
self.ui.pauseButton.hide()
self.isCapturingImage = False
self.videoLocation = None
self.showMaximized()
def keyPressEvent(self, event):
if event.isAutoRepeat():
return
if event.key() == Qt.Key_Escape:
self.camera.stop()
self.hide()
event.accept()
elif event.key() == Qt.Key_S:
if self.camera.captureMode() == QCamera.CaptureStillImage:
self.captureImage()
event.accept()
else:
super(CameraView, self).keyPressEvent(event)
async def handleImage(self, requestId, img):
scaledImage = img.scaled(self.ui.viewfinder.size(), Qt.KeepAspectRatio,
Qt.SmoothTransformation)
self.ui.lastImagePreviewLabel.setPixmap(QPixmap.fromImage(scaledImage))
self.displayCapturedImage()
imgFormat = self.ui.captureImageFormat.currentText()
array = QByteArray()
buffer = QBuffer(array)
buffer.open(QIODevice.WriteOnly)
img.save(buffer, imgFormat)
buffer.close()
await self.importImageBuffer(buffer, imgFormat.lower())
QTimer.singleShot(3000, self.displayViewfinder)
def recLocationChanged(self, loc):
pass
def record(self):
self.mediaRecorder.record()
self.videoLocation = self.mediaRecorder.outputLocation()
self.updateRecordTime()
def pause(self):
self.mediaRecorder.pause()
async def stop(self):
self.mediaRecorder.stop()
self.ui.statusbar.showMessage('')
if self.videoLocation and await questionBoxAsync(
'Video import', 'Import video to your repository ?'):
filePath = self.videoLocation.toLocalFile()
if not os.path.isfile(filePath):
return messageBox('Could not find captured video')
basename = os.path.basename(filePath)
name = inputTextCustom('Video import',
'Video filename',
text=basename)
if not name:
return
if name != basename:
dst = Path(os.path.dirname(filePath)).joinpath(name)
shutil.move(filePath, str(dst))
else:
dst = Path(filePath)
if name:
ensure(self.importVideoRecord(dst, name))
@ipfsOp
async def importImageBuffer(self, ipfsop, buffer, extension):
fModel = ipfsop.ctx.currentProfile.filesModel
entry = await ipfsop.addBytes(bytes(buffer.data()),
pin=self.ui.pinCapturedPhoto.isChecked())
if entry:
if self.ui.copyPhotoToMfs.isChecked():
await ipfsop.filesLink(entry,
fModel.itemPictures.path,
name='camshot-{id}.{ext}'.format(
id=int(time.time()), ext=extension))
self.app.mainWindow.fileManagerWidget.refreshItem(
fModel.itemPictures)
if self.ui.copyPhotoCidToClipboard.isChecked():
self.app.setClipboardText(entry['Hash'])
else:
messageBox('Could not import image')
@ipfsOp
async def importVideoRecord(self, ipfsop, videoPath, name):
fModel = ipfsop.ctx.currentProfile.filesModel
entry = await ipfsop.addPath(str(videoPath),
wrap=True,
pin=self.ui.pinVideo.isChecked())
if entry:
# Can remove it from disk now
try:
videoPath.unlink()
except Exception:
log.debug(f'Could not remove video {videoPath}')
if self.ui.copyVideoToMfs.isChecked():
await ipfsop.filesLink(entry,
fModel.itemVideos.path,
name=f'{name}.dirw')
self.app.mainWindow.fileManagerWidget.refreshItem(
fModel.itemVideos)
if self.ui.copyVideoCidToClipboard.isChecked():
try:
# Copy the video's CID
listing = await ipfsop.listObject(entry['Hash'])
links = listing['Objects'].pop()['Links']
videoCid = links.pop()['Hash']
self.app.setClipboardText(videoCid)
except Exception:
# Fall back to copying the directory wrapper
self.app.setClipboardText(entry['Hash'])
else:
messageBox('Could not import video')
def setMuted(self, muted):
self.mediaRecorder.setMuted(muted)
def captureImage(self):
self.isCapturingImage = True
self.imageCapture.capture()
def updateCaptureMode(self):
tabIndex = self.ui.captureWidget.currentIndex()
captureMode = QCamera.CaptureStillImage if tabIndex == 0 else \
QCamera.CaptureVideo
if self.camera.isCaptureModeSupported(captureMode):
self.camera.setCaptureMode(captureMode)
def onCameraStateChange(self, state):
if state == QCamera.ActiveState:
pass
elif state in (QCamera.UnloadedState, QCamera.LoadedState):
pass
def updateRecorderState(self, state):
if state == QMediaRecorder.StoppedState:
self.ui.recordButton.setEnabled(True)
self.ui.pauseButton.setEnabled(True)
self.ui.stopButton.setEnabled(False)
elif state == QMediaRecorder.PausedState:
self.ui.recordButton.setEnabled(True)
self.ui.pauseButton.setEnabled(False)
self.ui.stopButton.setEnabled(True)
elif state == QMediaRecorder.RecordingState:
self.ui.recordButton.setEnabled(False)
self.ui.pauseButton.setEnabled(True)
self.ui.stopButton.setEnabled(True)
def onRecorderError(self):
messageBox('Capture Error: {}'.format(
self.mediaRecorder.errorString()))
def onCameraError(self):
messageBox('Camera Error: {}'.format(self.camera.errorString()))
def recDurationChanged(self, duration):
self.updateRecordTime()
def updateRecordTime(self):
msg = "Recorded {secs} secs".format(
secs=self.mediaRecorder.duration() // 1000)
self.ui.statusbar.showMessage(msg)
def displayViewfinder(self):
self.ui.stackedWidget.setCurrentIndex(0)
def displayCapturedImage(self):
self.ui.stackedWidget.setCurrentIndex(1)
def readyForCapture(self, ready):
self.ui.captureImageButton.setEnabled(ready)
def onClose(self):
self.camera.stop()
self.hide()
def closeEvent(self, event):
self.camera.stop()
super().closeEvent(event)
class TIFgrabGUI(QMainWindow):
def __init__(self, capcard_full, capcard_short, parent=None):
super(TIFgrabGUI, self).__init__(parent)
self.cleanup_side_captures()
# set up GUI from designer-made layout
self.ui = Ui_TIFgrabMW()
self.ui.setupUi(self)
# Temporarily? hard code the device definition
self.sys_device = "/dev/video0"
target_cam_serialnum = capcard_short[self.sys_device]
target_cam_label = capcard_full[self.sys_device]
print("Targeting camera device ", self.sys_device)
print("Labeling as ", target_cam_label)
self.picframe_width = self.ui.ThumbnailView.frameGeometry().width()
self.picframe_height = self.ui.ThumbnailView.frameGeometry().height()
#for device_name in QCamera.availableDevices():
# print("Looking at", device_name)
# if (device_name == target_cam_dev):
#self.camera_device = device_name
# self.camera_device = target_cam_dev.encode('utf-8')
self.camera_device = self.sys_device.encode('utf-8')
self.camera_label = target_cam_label
self.ui.Sourcename_Disp.setText(self.camera_label)
self.cam1 = QCamera(self.camera_device)
# self.cam1_info = QCameraInfo(self.cam1)
# self.cam1_nonhuman_name = self.cam1_info.deviceName()
# print("Description= ",self.cam1_info.description())
# print("Nonhuman= ", self.cam1_info.deviceName())
self.cam1_capture = QCameraImageCapture(self.cam1)
print("Still image capture from device %s, capture card %s)" %
(self.camera_device, self.camera_label))
self.cam1.setCaptureMode(QCamera.CaptureStillImage)
self.cam1_capture.setCaptureDestination(
QCameraImageCapture.CaptureToBuffer)
#### Assign a startup image ####
# print('Displaying startup image')
#self.tifimage = QPixmap('/home/scotty/src/GrabDev/tasman_island_lighthouse.tif', 'tif')
self.tifimage = QPixmap('./tasman_island_lighthouse.tif', 'tif')
self.thumb = self.tifimage.scaled(self.picframe_width,
self.picframe_height,
Qt.KeepAspectRatio)
self.ui.ThumbnailView.setScaledContents(True)
self.ui.ThumbnailView.setPixmap(self.thumb)
# Set event handlers
self.ui.grabButton.clicked.connect(self.on_grab_button)
self.ui.TimerRadio.toggled.connect(self.on_timerradio_button)
self.ui.quitButton.clicked.connect(self.on_quit_button)
self.cam1_capture.imageCaptured.connect(self.on_image_captured)
self.ui.FilenameDisp.setText("No image captured")
self.cam1.start()
def on_grab_button(self):
self.cam1.searchAndLock()
self.capture_time = systime()
self.capture_name = "./" + self.camera_label + "_" + self.capture_time + ".tif"
self.cam1_capture.capture()
self.cam1.unlock()
def on_image_captured(self, id, captured_image):
# The image to be displayed on screen
self.captured2pixmap = QPixmap()
success = self.captured2pixmap.convertFromImage(captured_image)
self.list_pic_stats()
self.thumb_scaled = self.captured2pixmap.scaled(
self.picframe_width, self.picframe_height, Qt.KeepAspectRatio)
self.ui.ThumbnailView.setScaledContents(True)
self.ui.ThumbnailView.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Ignored)
self.ui.FilenameDisp.setText(self.capture_name)
self.ui.ThumbnailView.setPixmap(self.thumb_scaled)
# The image to be saved to file as TIF
# First confirm that the destination folder exists, create if it doesn't.
self.manage_daily_folder()
self.capture_fullpath = self.outdirname + "/" + self.capture_name
outimage = QPixmap()
outimage.convertFromImage(captured_image)
outfile = QFile(self.capture_fullpath)
outfile.open(QIODevice.WriteOnly)
outimage.save(outfile, "TIFF")
outfile.close()
def list_pic_stats(self):
sizestr = ("Size: %d X %d") % (self.captured2pixmap.width(),
self.captured2pixmap.height())
depthstr = ("Depth:%s ") % (self.captured2pixmap.depth())
bmapstr = ("Is Bitmap?:%s") % (self.captured2pixmap.isQBitmap())
alphastr = ("Has alpha?:%s") % (self.captured2pixmap.hasAlphaChannel())
self.ui.PicStats.setPlainText(self.sys_device)
self.ui.PicStats.appendPlainText(sizestr)
self.ui.PicStats.appendPlainText(depthstr)
def on_timerradio_button(self):
if self.ui.TimerRadio.isChecked():
self.ui.grabButton.setEnabled(False)
self.add_timer_groupbox()
if not self.ui.TimerRadio.isChecked():
if self.timergb:
self.timergb.grab_timer.stop()
self.ui.grabButton.setEnabled(True)
self.timergb.deleteLater()
self.timergb = None
def add_timer_groupbox(self):
self.timergb = TimerGB(75, 100)
self.timergb.grab_timeout.connect(self.on_grab_button)
self.timergb.gb_closed.connect(self.on_timergb_closed)
self.timergb.show()
def on_timergb_closed(self):
if self.ui.TimerRadio.isChecked():
if self.timergb:
# self.grab_timer.stop()
self.timergb.deleteLater()
self.timergb = None
self.ui.TimerRadio.setChecked(False)
self.ui.grabButton.setEnabled(True)
def cleanup_side_captures(self):
# Remove jpgs saved by QCameraImageCapture in default location
defaultlocation = "/home/jason/Pictures"
print("Removing all jpgs from ", defaultlocation)
fullpath = ("%s/*.jpg") % (defaultlocation)
for filename in glob(fullpath):
print("Removing ", filename)
os.remove(filename)
def on_quit_button(self):
self.cam1.stop()
try:
if self.timergb:
self.timergb.deleteLater()
self.timergb = None
except:
pass
self.cleanup_side_captures()
QCoreApplication.exit()
def sigint_handler(*args):
try:
if self.timergb:
self.timergb.deleteLater()
self.timergb = None
except:
pass
sys.stderr.write('\r')
QApplication.quit()
def do_init(ini_filename):
cf = ConfigParser()
cf.read(ini_filename)
def manage_daily_folder(self):
# Tests for existence of folder to hold the date's captures.
# If folder doesn't exist, creates it.
today = sysdate()
self.outdirname = "/data/capture_" + today
if not os.path.exists(self.outdirname):
os.makedirs(self.outdirname)
class mainInterface(QWidget):
# 定义信号
processFinished = pyqtSignal(dict)
def __init__(self):
"""
初始化
:return: null
"""
# 超类初始化
super().__init__()
# UI初始化
self.ui = Ui_mainWidget()
self.ui.setupUi(self)
self.grabKeyboard()
self.setMouseTracking(True)
self.setWindowFlags(Qt.FramelessWindowHint)
self.setWindowIcon(QIcon('OCR.ico'))
# 初始化相机
self.camera = QCamera()
self.imageCapture = QCameraImageCapture(self.camera)
self.viewsetting = QCameraViewfinderSettings()
self.initimplement()
# 初始化标题栏
self.initTitleBar()
# 初始化系统托盘
self.tray = QSystemTrayIcon()
self.tray.setIcon(QIcon('OCR.ico'))
self.initTray()
# OCR识别部分
self.OCR = ocr()
self.OCR.setappid('1257206643')
self.OCR.setsecretid('AKIDFTddWEg9Ncsz0sE7oOpBNOExdDdeCUJ3')
self.OCR.setsecretkey('FQitsgUND8yfrZK0RrBMOJB5tWhCm5Ol')
# 初始化登录部分
self.logWidget = QWidget()
self.logui = Ui_Form()
self.logui.setupUi(self.logWidget)
self.logWidget.setWindowFlags(Qt.FramelessWindowHint)
self.logWidget.setWindowModality(Qt.ApplicationModal)
self.logui.close_btn.clicked.connect(self.logWidget.close)
# 初始化变量
self.mousePressd = False
self.mousePoint = None
self.result = {}
self.isFirst = False
self.ocrType = ocrType.ocr_general # 默认为印刷体识别
# 初始化字定义信号连接
self.processFinished.connect(self.updateOCRInfo)
self.ui.btn_login.clicked.connect(self.logWidget.show)
self.ui.comboBox_choose.currentIndexChanged.connect(self.changeocrType)
def initTitleBar(self):
"""
初始化标题栏
:return: null
"""
self.ui.frame.setStyleSheet(
"QFrame#frame{background-color:rgb(244, 76, 76);}")
self.ui.label_logo.setStyleSheet(
"QLabel{border-image:url(./image/ocr.png);}")
self.ui.label_title.setStyleSheet(
"QLabel{border-image:url(./image/iOCR.png);}")
self.ui.comboBox_choose.setStyleSheet(
"QComboBox {border-radius:15px;border: 2px solid #4AFFF4;font-family:'楷体';font-size:20px;}"
"QComboBox QAbstractItemView::item{height:50px;width:200px;}"
"QComboBox::down-arrow{image: url(./image/arrow.png);width:25px;height:25px;}"
"QComboBox::drop-down {subcontrol-origin: padding;subcontrol-position:top right;border:none;margin-right:30px;}"
"QComboBox::down-arrow:hover{image:url(./image/arrow_hover.png);width:25px;height:25px;}"
"QComboBox::down-arrow:on {top: 1px;left: 1px;}")
self.ui.comboBox_choose.insertItem(0, ' 印刷体识别')
self.ui.comboBox_choose.insertItem(1, ' 手写体识别')
self.ui.comboBox_choose.insertItem(2, ' 身份证识别')
self.ui.comboBox_choose.insertItem(3, ' 名片识别')
self.ui.comboBox_choose.insertItem(4, ' 银行卡识别')
self.ui.btn_login.setStyleSheet(
"QPushButton{border-image:url(./image/default-portrait.png);}")
self.ui.btn_setting.setStyleSheet(
"QPushButton{border-image:url(./image/settings.png);}"
"QPushButton:hover{border-image:url(./image/qcconfig-hover.png);}")
self.ui.btn_min.setStyleSheet(
"QPushButton{border-image:url(./image/mini_new.png);}"
"QPushButton:hover{border-image:url(./image/mini_hover_new.png);}")
self.ui.btn_close.setStyleSheet(
"QPushButton{border-image:url(./image/close.png);}"
"QPushButton:hover{border-image:url(./image/close-hover.png);}")
self.ui.checkBox_cam.setStyleSheet(
"QCheckBox{spacing: 5px;font-size: 24px;vertical-align:middle}"
"QCheckBox::indicator { width: 45px;height: 45px;}"
"QCheckBox::indicator::unchecked {image: url(./image/close_cam.png);}"
"QCheckBox::indicator::checked { image: url(./image/open_cam.png);}"
)
self.ui.captureBtn.setStyleSheet(
"QPushButton{border-style: outset;border-width: 2px;border-color: rgb(82,215,100);border-radius: 5px;font-size: 24px;}"
"QPushButton:pressed{background-color: rgb(176,215,181);border-style: inset;}"
)
self.ui.checkBox_cam.setChecked(True)
self.ui.btn_close.clicked.connect(lambda: qApp.quit())
self.ui.btn_min.clicked.connect(self.miniToTray)
self.ui.checkBox_cam.stateChanged.connect(self.camControl)
def initTray(self):
"""
初始化系统托盘信息
:return:
"""
tray_menu = QMenu()
restoreAction = QAction('&Show', self)
quitAction = QAction('&Quit', self)
tray_menu.addAction(restoreAction)
tray_menu.addAction(quitAction)
self.tray.setContextMenu(tray_menu)
restoreAction.triggered.connect(self.trayActivatedEvent)
quitAction.triggered.connect(qApp.quit)
self.tray.activated.connect(self.trayActivatedEvent)
def initimplement(self):
"""
初始化实现端口
:return: ui
"""
camInfo = QCameraInfo(self.camera)
if camInfo.defaultCamera().isNull():
QMessageBox.warning(self, 'Warning', 'No available camera!',
QMessageBox.Ok)
return -1
else:
self.ui.caputurePhoto.setText(camInfo.description())
self.camera.setViewfinder(self.ui.cameraShow)
self.camera.setCaptureMode(QCamera.CaptureStillImage)
self.camera.load()
resolution = self.camera.supportedViewfinderResolutions()
if len(resolution) != 0:
if QSize(640, 480) in resolution:
self.viewsetting.setResolution(QSize(640, 480))
elif QSize(640, 360) in resolution:
self.viewsetting.setResolution(QSize(640, 360))
else:
self.viewsetting.setResolution(resolution[0])
self.camera.setViewfinderSettings(self.viewsetting)
# ------------------------------Note--------------------------------
# 此种方法利用摄像头准备捕捉图像的状态来进行捕捉图像，readyForCapture
# 为true时，才进行捕捉图像，详见下面捕捉函数槽函数。这种方法将进行不
# 停的捕捉，将每次捕捉的相邻图像进行图像相似度判断。当图像相似度低于
# 阈值时，认定为新图像，才进行OCR识别。否则仅捕捉图像而不进行识别。当
# 然捕捉图像速度过于太快时，可以用定时器，每隔0.5秒，去检查readyFor
# Capture状态位，进而有效控制程序资源。
# 本应用中采用按键捕捉方式，非自动，详见下面按键捕捉事件
# ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
# self.imageCapture.readyForCaptureChanged.connect(self.captureimage)
self.camera.start()
self.ui.caputurePhoto.setScaledContents(True)
self.imageCapture.setCaptureDestination(
QCameraImageCapture.CaptureToBuffer)
self.imageCapture.imageCaptured.connect(self.displayimage)
self.ui.captureBtn.clicked.connect(self.openDlg)
def displayimage(self, num, image):
"""
显示图形
:param num: number
:param image: image
:return: null
"""
self.ui.caputurePhoto.setPixmap(QPixmap.fromImage(image))
self.ui.ocrInfo.setText('识别中......')
t = threading.Thread(target=self.ocrForImage, args=(image, ))
t.start()
# def captureimage(self, state):
# """
# 捕捉图像槽函数
# :state: 状态变量
# :return: null
# """
# if state is True:
# self.camera.searchAndLock()
# self.imageCapture.capture()
# self.camera.unlock()
# def saveimage(self):
# """
# 保存图像槽函数
# :return: null
# """
# pix = QPixmap(self.ui.caputurePhoto.pixmap())
# if pix:
# pix.save(r'D://1.png', 'PNG')
# QMessageBox.information(self, 'Message', 'Capture Successfully', QMessageBox.Ok)
def ocrForImage(self, image):
"""
为截取的图片进行ocr识别
:param image: QImage
:return: null
"""
# Note:子线程里不能对ui界面做改动，ui界面修改只能在主线程中修改，下面注释的做法是错误的
# self.ui.ocrInfo.setText('识别中......')
byte = QByteArray()
buffer = QBuffer(byte)
buffer.open(QIODevice.WriteOnly)
image.save(buffer, 'PNG')
if self.ocrType == ocrType.ocr_general:
self.result = self.OCR.client.general_detect(
CIBuffers([byte.data()]))
elif self.ocrType == ocrType.ocr_handwriting:
self.result = self.OCR.client.handwriting_detect(
CIBuffers([byte.data()]))
elif self.ocrType == ocrType.ocr_idcard:
self.result = self.OCR.client.idcard_detect(
CIBuffers([byte.data()]), 0)
elif self.ocrType == ocrType.ocr_namecard:
self.result = self.OCR.client.namecard_detect(
CIBuffers([byte.data()]), 0)
elif self.ocrType == ocrType.ocr_bankcard:
self.result = self.OCR.client.bankcard_detect(
CIBuffers([byte.data()]))
else:
pass
self.processFinished.emit(self.result)
def updateOCRInfo(self, res):
"""
将ocr识别结果显示在信息框中
:param res:
:return:
"""
if self.ocrType == ocrType.ocr_general or self.ocrType == ocrType.ocr_handwriting:
if res['code'] == 0 and res['message'] == 'OK':
self.ui.ocrInfo.setText('OK')
ocrInfo = []
for i in range(len(self.result['data']['items'])):
ocrInfo.append(
self.result['data']['items'][i]['itemstring'])
self.ui.ocrInfo.setText(''.join(ocrInfo))
else:
self.ui.ocrInfo.setText('识别失败！')
elif self.ocrType == ocrType.ocr_bankcard:
if res['code'] == 0 and res['message'] == 'OK':
self.ui.ocrInfo.setText('OK')
ocrInfo = []
for i in range(len(self.result['data']['items'])):
ocrInfo.append(self.result['data']['items'][i]['item'])
ocrInfo.append(':')
ocrInfo.append(
self.result['data']['items'][i]['itemstring'])
ocrInfo.append('\n')
self.ui.ocrInfo.setText(''.join(ocrInfo))
else:
self.ui.ocrInfo.setText('识别失败！')
elif self.ocrType == ocrType.ocr_idcard:
if res['result_list'][0]['code'] == 0 and res['result_list'][0][
'message'] == 'OK':
self.ui.ocrInfo.setText('OK')
ocrInfo = []
ocrInfo_keys = list(
self.result['result_list'][0]['data'].keys())
ocrInfo_values = list(
self.result['result_list'][0]['data'].values())
for i in range(
len(self.result['result_list'][0]['data']) // 2):
ocrInfo.append(ocrInfo_keys[i])
ocrInfo.append(':')
ocrInfo.append(ocrInfo_values[i])
ocrInfo.append('\n')
self.ui.ocrInfo.setText(''.join(ocrInfo))
else:
self.ui.ocrInfo.setText('识别失败！')
elif self.ocrType == ocrType.ocr_namecard:
if res['result_list'][0]['code'] == 0 and res['result_list'][0][
'message'] == 'OK':
self.ui.ocrInfo.setText('OK')
ocrInfo = []
for i in range(len(self.result['result_list'][0]['data'])):
ocrInfo.append(
self.result['result_list'][0]['data'][i]['item'])
ocrInfo.append(':')
ocrInfo.append(
self.result['result_list'][0]['data'][i]['value'])
ocrInfo.append('\n')
self.ui.ocrInfo.setText(''.join(ocrInfo))
else:
self.ui.ocrInfo.setText('识别失败！')
else:
pass
def camControl(self, state):
"""
槽函数
控制相机开关
:param state: checkbox开关状态
:return:null
"""
if state == Qt.Unchecked:
self.ui.cameraShow.setUpdatesEnabled(False)
elif state == Qt.Checked:
self.ui.cameraShow.setUpdatesEnabled(True)
else:
return -1
def miniToTray(self):
"""
槽函数
最小化到系统托盘
:return:null
"""
if not self.tray.isVisible():
self.tray.show()
if self.tray.isVisible():
if self.isFirst is False:
QMessageBox.information(
self, "Systray", "The program will keep running in the "
"system tray. To terminate the program, "
"choose <b>Quit</b> in the context menu "
"of the system tray entry.")
self.isFirst = True
self.hide()
def trayActivatedEvent(self, reason):
"""
槽函数
响应点击托盘图标
:param reason: 响应原因
:return: null
"""
if reason == QSystemTrayIcon.Context:
pass
else:
self.tray.hide()
self.show()
def openDlg(self):
"""
槽函数
打开对话框选取文件
:return:文件名
"""
filename, filetype = QFileDialog.getOpenFileName(
self, '选取图片', path.expanduser('~'),
"Image Files (*.png *.jpg *.bmp)")
if filename:
if QFile(filename).size() >= 6291456:
QMessageBox.information(self, '打开图片',
'选择图片大于6MB大小，暂不支持识别，请重新选择。')
self.openDlg()
else:
self.displayimage(0, QImage(filename))
def keyPressEvent(self, e):
"""
槽函数
键盘按键响应事件
:param e: 按键事件
:return: null
"""
if e.key() == Qt.Key_Space:
if self.imageCapture.isReadyForCapture():
self.camera.searchAndLock()
self.imageCapture.capture()
self.camera.unlock()
def mouseMoveEvent(self, e):
"""
槽函数
定义鼠标移动事件
:param e: QMouseEvent
:return: null
"""
if (e.buttons() == Qt.LeftButton) and self.mousePressd:
self.move(e.globalPos() - self.mousePoint)
e.accept()
def mousePressEvent(self, e):
"""
槽函数
定义鼠标按下事件
:param e: QMouseEvent
:return: null
"""
if e.button() == Qt.LeftButton:
self.mousePressd = True
self.mousePoint = e.globalPos() - self.pos()
e.accept()
def mouseReleaseEvent(self, e):
"""
槽函数
定义鼠标松开事件
:param e: QMouseEvent
:return: null
"""
self.mousePressd = False
def changeocrType(self, index):
"""
槽函数
改变ocr识别类型
:param index: int
:return: null
"""
if index == 0:
self.ocrType = ocrType.ocr_general
elif index == 1:
self.ocrType = ocrType.ocr_handwriting
elif index == 2:
self.ocrType = ocrType.ocr_idcard
elif index == 3:
self.ocrType = ocrType.ocr_namecard
elif index == 4:
self.ocrType = ocrType.ocr_bankcard
else:
pass
class _CameraWidget(QWidget):
imagecaptured = pyqtSignal(QPixmap)
cancel = pyqtSignal()
def __init__(self, parent=None):
super(_CameraWidget, self).__init__(parent)
self.setLayout(QGridLayout())
self.toolbar = QToolBar()
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.toolbar.setIconSize(QSize(48, 48))
self.toolbar.addWidget(spacer)
self.swapaction = self.toolbar.addAction(QIcon(":/widgets/cameraswap"),
"Swap Camera")
self.swapaction.triggered.connect(self.swapcamera)
self.current_camera_index = 0
self.camera = None
self.viewfinder = QCameraViewfinder()
self.viewfinder.mousePressEvent = self.capture
self.viewfinder.setAspectRatioMode(Qt.KeepAspectRatioByExpanding)
self.update_camera_buttons()
self.capturebutton = QPushButton("Capture", self)
self.capturebutton.pressed.connect(self.capture)
self.actionCancel = self.toolbar.addAction(QIcon(":/icons/cancel"),
"Cancel")
self.actionCancel.triggered.connect(self._cancel)
self.layout().setContentsMargins(0, 0, 0, 0)
self.layout().addWidget(self.toolbar)
self.layout().addWidget(self.viewfinder)
self.layout().addWidget(self.capturebutton)
self.viewfinder.show()
def __del__(self):
if self.camera:
self.camera.unload()
def _cancel(self):
if self.camera:
self.camera.unload()
self.cancel.emit()
@property
def list_of_cameras(self):
return QCameraInfo.availableCameras()
def update_camera_buttons(self):
if len(self.list_of_cameras) <= 1:
self.swapaction.setVisible(False)
def capture(self, *args):
self.camera.searchAndLock()
self.camera_capture.capture()
self.camera.unlock()
def swapcamera(self):
cameras = QCameraInfo.availableCameras()
if self.current_camera_index + 1 == len(cameras):
self.current_camera_index = 0
else:
self.current_camera_index += 1
self.start(self.current_camera_index)
@property
def camera_res(self):
width, height = tuple(roam.config.settings['camera_res'].split(','))
return width, height
def imageCaptured(self, frameid, image):
# TODO Doing a pixmap convert here is a waste but downstream needs a qpixmap for now
# refactor later
if self.camera:
self.camera.unload()
self.imagecaptured.emit(QPixmap.fromImage(image))
def start(self, dev=1):
if self.camera:
self.camera.unload()
cameras = QCameraInfo.availableCameras()
self.camera = QCamera(cameras[dev])
self.camera.setViewfinder(self.viewfinder)
self.camera.setCaptureMode(QCamera.CaptureStillImage)
self.camera.start()
self.camera_capture = QCameraImageCapture(self.camera)
self.camera_capture.setCaptureDestination(
QCameraImageCapture.CaptureToBuffer)
self.camera_capture.imageCaptured.connect(self.imageCaptured)
class CameraInterface(CameraBase.CameraBase):
def __init__(self, *args, camera_info=None):
super(CameraInterface, self).__init__(*args)
# 定义相机实例对象并设置捕获模式
if camera_info:
self.mCamera = QCamera(camera_info)
else:
self.mCamera = QCamera()
self.mCamera.setCaptureMode(QCamera.CaptureViewfinder)
self.mDisplayWidth = 800
self.mDisplayHeight = 600
self.mRate = 10
# 设置取景器分辨率
self.setDisplaySize(self.mDisplayWidth, self.mDisplayHeight)
self.setRate(self.mRate)
# 初始化取景器
self.mViewCamera = QtMultimediaWidgets.QCameraViewfinder(self)
self.mViewCamera.show()
self.mCamera.setViewfinder(self.mViewCamera)
self.mCamera.setCaptureMode(QCamera.CaptureStillImage)
# 设置图像捕获
self.mCapture = QCameraImageCapture(self.mCamera)
if self.mCapture.isCaptureDestinationSupported(
QCameraImageCapture.CaptureToBuffer):
self.mCapture.setCaptureDestination(
QCameraImageCapture.CaptureToBuffer) # CaptureToBuffer
# self.mCapture.error.connect(lambda i, e, s: self.alert(s))
self.mCapture.imageAvailable.connect(self.readFrame)
self.mTimerImageGrab = QTimer(self)
self.mTimerImageGrab.timeout.connect(self.timerImgGrab)
# self.t1 = 0.0
def timerImgGrab(self):
self.mCapture.capture('tmp.jpg')
def readFrame(self, requestId, image):
self.mFrame = image.image().copy()
def openCamera(self):
if not self.mCameraOpened:
self.mCamera.start()
viewFinderSettings = QCameraViewfinderSettings()
rate_range = self.mCamera.supportedViewfinderFrameRateRanges()
if rate_range:
viewFinderSettings.setMinimumFrameRate(
rate_range[0].minimumFrameRate)
viewFinderSettings.setMaximumFrameRate(
rate_range[0].maximumFrameRate)
else:
viewFinderSettings.setMinimumFrameRate(1)
viewFinderSettings.setMaximumFrameRate(self.mRate)
self.mTimerImageGrab.start(1000 / self.mRate)
self.mCameraOpened = True
def releaseCamera(self):
if self.mCameraOpened:
self.mCamera.stop()
self.mCameraOpened = False
self.signalReleased.emit()
def takePictures(self, path: str):
self.mCapture.setCaptureDestination(QCameraImageCapture.CaptureToFile)
self.mCapImg.capture(path)
self.mCapture.setCaptureDestination(
QCameraImageCapture.CaptureToBuffer)
def takeVideo(self, path: str):
pass
def endTakeVideo(self):
pass
def setDisplaySize(self, display_width_: int, display_height_: int):
self.mDisplayWidth = display_width_
self.mDisplayHeight = display_height_
viewFinderSettings = QCameraViewfinderSettings()
viewFinderSettings.setResolution(self.mDisplayWidth,
self.mDisplayHeight)
self.mCamera.setViewfinderSettings(viewFinderSettings)
def setRate(self, rate):
self.mRate = rate
class LiveFeedWidget(QGraphicsView):
class _State(Enum):
Init = "Init"
Idle = "Idle"
Preparing = "Preparing"
WaitingForCapture = "WaitingForCapture"
error = pyqtSignal(str)
image_captured = pyqtSignal(QImage)
initialized = pyqtSignal()
def __init__(
self,
camera: Camera,
is_mirrored: bool,
mask: Mask,
parent=None,
):
super().__init__(parent=parent)
self._is_mirrored = is_mirrored
self._mask = mask
self._state = LiveFeedWidget._State.Init
self._video_item = QGraphicsVideoItem()
# I think this is the size in pixels on the screen?
self._video_item.setSize(QSizeF(self._mask.size))
# TODO I think this will not draw centrally? If not should fix this
self._video_item.setAspectRatioMode(Qt.KeepAspectRatioByExpanding)
if self._is_mirrored:
self._video_item.setTransform(QTransform().scale(-1, 1))
self.setMask(self._mask.clip_region)
self._scene: OverlayTextGraphicsScene = OverlayTextGraphicsScene(
self._mask.size)
self._scene.addItem(self._video_item)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setScene(self._scene)
# Setup camera
#
self._camera = camera
self._camera.setViewfinder(self._video_item)
self._camera.setCaptureMode(QCamera.CaptureStillImage)
self._camera.error.connect(self._on_camera_error)
self._camera.statusChanged.connect(self._on_camera_status_changed)
# Setup capture
#
self._capture = QCameraImageCapture(self._camera)
self._capture.setCaptureDestination(
QCameraImageCapture.CaptureToBuffer)
self._capture.imageCaptured.connect(self._image_captured)
self._capture.error.connect(self._on_capture_error)
self._camera.start()
logger.info("Camera started")
def set_overlay_text(self, text: str):
self._scene.set_overlay_text(text)
def prepare(self):
if self._state != LiveFeedWidget._State.Idle:
logger.warning("Dropping call to prepare when in state: %s",
self._state)
else:
self._state = LiveFeedWidget._State.Preparing
self._camera.searchAndLock()
def trigger_capture(self):
if self._state != LiveFeedWidget._State.Preparing:
logger.warning(
"Dropping call to trigger_capture when in state: %s",
self._state)
else:
logger.debug("trigger_capture")
self._state = LiveFeedWidget._State.WaitingForCapture
self._capture.capture()
# noinspection PyPep8Naming
def _on_camera_error(self, QCamera_Error: int):
self._state = LiveFeedWidget._State.Idle
self.error.emit(f"Camera error, code: {QCamera_Error}")
# noinspection PyPep8Naming
def _on_capture_error(self,
p_int=None,
QCameraImageCapture_Error=None,
p_str=None):
self._state = LiveFeedWidget._State.Idle
self.error.emit(
f"Capture error: {p_int} / {QCameraImageCapture_Error} / {p_str}")
def _image_captured(self, id_: int, image: QImage):
if self._state != LiveFeedWidget._State.WaitingForCapture:
logger.warning("Dropping _image_captured when in state: %s",
self._state)
self._state = LiveFeedWidget._State.Idle
logger.debug("image captured: %s %s", id_, image)
self._camera.unlock()
# TODO If I don't unload and the reload the camera, gstreamer dies
# with CameraBin error: "Internal data stream error.", not sure why
# :(
self._camera.unload()
self.image_captured.emit(_mirror_if_necessary(image,
self._is_mirrored))
def reload(self):
# See comment on _image_captured
self._camera.start()
def _on_camera_status_changed(self, status):
logger.debug("_on_camera_status_changed: %s", status)
if status == QCamera.ActiveStatus:
self._state = LiveFeedWidget._State.Idle
self.initialized.emit()
