class Camera(QObject):
def __init__(self, parent = QObject()):
super(Camera, self).__init__(parent)
print("3")
self.cam = QCamera(QCameraInfo.defaultCamera()) #"/dev/video0".encode()
print("4")
self.caminfo = QCameraInfo(self.cam)
self.camvfind = QCameraViewfinder()
self.camvfindset = QCameraViewfinderSettings()
self.cammode = self.cam.CaptureMode(0)
self.camimgcap = QCameraImageCapture(self.cam)
def iniCamera(self):
print(self.caminfo.description())
print(self.caminfo.availableCameras())
for caminfo in QCameraInfo.availableCameras():
print(caminfo.deviceName())
if self.cam.isCaptureModeSupported(self.cammode):
print("Capturemode supported")
def startVid(self):
#self.camimgcap.CaptureDestination(2)
self.camvfind.show()
self.cam.setViewfinder(self.camvfind)
self.cam.setCaptureMode(self.cammode)
self.cam.start()
class Camera(QObject):
def __init__(self, parent=QObject()):
super(Camera, self).__init__(parent)
# chooses the system default camera
self.cam = QCamera()
self.caminfo = QCameraInfo(self.cam)
self.camvfind = QCameraViewfinder()
self.camvfindset = QCameraViewfinderSettings()
self.recorder = QMediaRecorder(self.cam)
def iniCamera(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())
if self.cam.isCaptureModeSupported(QCamera.CaptureVideo):
print("Capturemode supported")
def startVid(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")
def startRecording(self, filename):
directory = os.path.abspath(str(os.getcwd()))
abs_path = os.path.join(directory, filename)
self.recorder.setOutputLocation(QUrl(abs_path))
self.recorder.record()
def stopRecording(self):
self.recorder.stop()
def getViewFinder(self):
return self.camvfind
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 Camera(QMainWindow):
def __init__(self, parent=None):
super(Camera, self).__init__(parent)
self.ui = Ui_Camera()
self.camera = None
self.imageCapture = None
self.mediaRecorder = None
self.isCapturingImage = False
self.applicationExiting = False
self.imageSettings = QImageEncoderSettings()
self.audioSettings = QAudioEncoderSettings()
self.videoSettings = QVideoEncoderSettings()
self.videoContainerFormat = ''
self.ui.setupUi(self)
cameraDevice = QByteArray()
videoDevicesGroup = QActionGroup(self)
videoDevicesGroup.setExclusive(True)
for deviceName in QCamera.availableDevices():
description = QCamera.deviceDescription(deviceName)
videoDeviceAction = QAction(description, videoDevicesGroup)
videoDeviceAction.setCheckable(True)
videoDeviceAction.setData(deviceName)
if cameraDevice.isEmpty():
cameraDevice = deviceName
videoDeviceAction.setChecked(True)
self.ui.menuDevices.addAction(videoDeviceAction)
videoDevicesGroup.triggered.connect(self.updateCameraDevice)
self.ui.captureWidget.currentChanged.connect(self.updateCaptureMode)
self.ui.lockButton.hide()
self.setCamera(cameraDevice)
def setCamera(self, cameraDevice):
if cameraDevice.isEmpty():
self.camera = QCamera()
else:
self.camera = QCamera(cameraDevice)
self.camera.stateChanged.connect(self.updateCameraState)
self.camera.error.connect(self.displayCameraError)
self.mediaRecorder = QMediaRecorder(self.camera)
self.mediaRecorder.stateChanged.connect(self.updateRecorderState)
self.imageCapture = QCameraImageCapture(self.camera)
self.mediaRecorder.durationChanged.connect(self.updateRecordTime)
self.mediaRecorder.error.connect(self.displayRecorderError)
self.mediaRecorder.setMetaData(QMediaMetaData.Title, "Test Title")
self.ui.exposureCompensation.valueChanged.connect(
self.setExposureCompensation)
self.camera.setViewfinder(self.ui.viewfinder)
self.updateCameraState(self.camera.state())
self.updateLockStatus(self.camera.lockStatus(), QCamera.UserRequest)
self.updateRecorderState(self.mediaRecorder.state())
self.imageCapture.readyForCaptureChanged.connect(self.readyForCapture)
self.imageCapture.imageCaptured.connect(self.processCapturedImage)
self.imageCapture.imageSaved.connect(self.imageSaved)
self.camera.lockStatusChanged.connect(self.updateLockStatus)
self.ui.captureWidget.setTabEnabled(0,
self.camera.isCaptureModeSupported(QCamera.CaptureStillImage))
self.ui.captureWidget.setTabEnabled(1,
self.camera.isCaptureModeSupported(QCamera.CaptureVideo))
self.updateCaptureMode()
self.camera.start()
def keyPressEvent(self, event):
if event.isAutoRepeat():
return
if event.key() == Qt.Key_CameraFocus:
self.displayViewfinder()
self.camera.searchAndLock()
event.accept()
elif event.key() == Qt.Key_Camera:
if self.camera.captureMode() == QCamera.CaptureStillImage:
self.takeImage()
elif self.mediaRecorder.state() == QMediaRecorder.RecordingState:
self.stop()
else:
self.record()
event.accept()
else:
super(Camera, self).keyPressEvent(event)
def keyReleaseEvent(self, event):
if event.isAutoRepeat():
return
if event.key() == Qt.Key_CameraFocus:
self.camera.unlock()
else:
super(Camera, self).keyReleaseEvent(event)
def updateRecordTime(self):
msg = "Recorded %d sec" % self.mediaRecorder.duration() // 1000
self.ui.statusbar.showMessage(msg)
def processCapturedImage(self, requestId, img):
scaledImage = img.scaled(self.ui.viewfinder.size(), Qt.KeepAspectRatio,
Qt.SmoothTransformation)
self.ui.lastImagePreviewLabel.setPixmap(QPixmap.fromImage(scaledImage))
self.displayCapturedImage()
QTimer.singleShot(4000, self.displayViewfinder)
def configureCaptureSettings(self):
if self.camera.captureMode() == QCamera.CaptureStillImage:
self.configureImageSettings()
elif self.camera.captureMode() == QCamera.CaptureVideo:
self.configureVideoSettings()
def configureVideoSettings(self):
settingsDialog = VideoSettings(self.mediaRecorder)
settingsDialog.setAudioSettings(self.audioSettings)
settingsDialog.setVideoSettings(self.videoSettings)
settingsDialog.setFormat(self.videoContainerFormat)
if settingsDialog.exec_():
self.audioSettings = settingsDialog.audioSettings()
self.videoSettings = settingsDialog.videoSettings()
self.videoContainerFormat = settingsDialog.format()
self.mediaRecorder.setEncodingSettings(self.audioSettings,
self.videoSettings, self.videoContainerFormat)
def configureImageSettings(self):
settingsDialog = ImageSettings(self.imageCapture)
settingsDialog.setImageSettings(self.imageSettings)
if settingsDialog.exec_():
self.imageSettings = settingsDialog.imageSettings()
imageCapture.setEncodingSettings(self.imageSettings)
def record(self):
self.mediaRecorder.record()
self.updateRecordTime()
def pause(self):
self.mediaRecorder.pause()
def stop(self):
self.mediaRecorder.stop()
def setMuted(self, muted):
self.mediaRecorder.setMuted(muted)
def toggleLock(self):
if self.camera.lockStatus() in (QCamera.Searching, QCamera.Locked):
self.camera.unlock()
elif self.camera.lockStatus() == QCamera.Unlocked:
self.camera.searchAndLock()
def updateLockStatus(self, status, reason):
indicationColor = Qt.black
if status == QCamera.Searching:
self.ui.statusbar.showMessage("Focusing...")
self.ui.lockButton.setText("Focusing...")
indicationColor = Qt.yellow
elif status == QCamera.Locked:
self.ui.lockButton.setText("Unlock")
self.ui.statusbar.showMessage("Focused", 2000)
indicationColor = Qt.darkGreen
elif status == QCamera.Unlocked:
self.ui.lockButton.setText("Focus")
if reason == QCamera.LockFailed:
self.ui.statusbar.showMessage("Focus Failed", 2000)
indicationColor = Qt.red
palette = self.ui.lockButton.palette()
palette.setColor(QPalette.ButtonText, indicationColor)
self.ui.lockButton.setPalette(palette)
def takeImage(self):
self.isCapturingImage = True
self.imageCapture.capture()
def startCamera(self):
self.camera.start()
def stopCamera(self):
self.camera.stop()
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 updateCameraState(self, state):
if state == QCamera.ActiveState:
self.ui.actionStartCamera.setEnabled(False)
self.ui.actionStopCamera.setEnabled(True)
self.ui.captureWidget.setEnabled(True)
self.ui.actionSettings.setEnabled(True)
elif state in (QCamera.UnloadedState, QCamera.LoadedState):
self.ui.actionStartCamera.setEnabled(True)
self.ui.actionStopCamera.setEnabled(False)
self.ui.captureWidget.setEnabled(False)
self.ui.actionSettings.setEnabled(False)
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 setExposureCompensation(self, index):
self.camera.exposure().setExposureCompensation(index * 0.5)
def displayRecorderError(self):
QMessageBox.warning(self, "Capture error",
self.mediaRecorder.errorString())
def displayCameraError(self):
QMessageBox.warning(self, "Camera error", self.camera.errorString())
def updateCameraDevice(self, action):
self.setCamera(action.data())
def displayViewfinder(self):
self.ui.stackedWidget.setCurrentIndex(0)
def displayCapturedImage(self):
self.ui.stackedWidget.setCurrentIndex(1)
def readyForCapture(self, ready):
self.ui.takeImageButton.setEnabled(ready)
def imageSaved(self, id, fileName):
self.isCapturingImage = False
if self.applicationExiting:
self.close()
def closeEvent(self, event):
if self.isCapturingImage:
self.setEnabled(False)
self.applicationExiting = True
event.ignore()
else:
event.accept()
class Camera(QMainWindow):
def __init__(self, parent=None):
super(Camera, self).__init__(parent)
self.ui = Ui_Camera()
self.camera = None
self.imageCapture = None
# self.mediaRecorder = None
self.isCapturingImage = False
self.applicationExiting = False
self.imageSettings = QImageEncoderSettings()
self.audioSettings = QAudioEncoderSettings()
# self.videoSettings = QVideoEncoderSettings()
# self.videoContainerFormat = ''
self.ui.setupUi(self)
cameraDevice = QByteArray()
videoDevicesGroup = QActionGroup(self)
videoDevicesGroup.setExclusive(True)
for deviceName in QCamera.availableDevices():
description = QCamera.deviceDescription(deviceName)
videoDeviceAction = QAction(description, videoDevicesGroup)
videoDeviceAction.setCheckable(True)
videoDeviceAction.setData(deviceName)
if cameraDevice.isEmpty():
cameraDevice = deviceName
videoDeviceAction.setChecked(True)
self.ui.menuDevices.addAction(videoDeviceAction)
videoDevicesGroup.triggered.connect(self.updateCameraDevice)
self.ui.captureWidget.currentChanged.connect(self.updateCaptureMode)
#self.ui.lockButton.hide()
self.setCamera(cameraDevice)
def setCamera(self, cameraDevice):
if cameraDevice.isEmpty():
self.camera = QCamera()
else:
self.camera = QCamera(cameraDevice)
self.camera.stateChanged.connect(self.updateCameraState)
self.camera.error.connect(self.displayCameraError)
# self.mediaRecorder = QMediaRecorder(self.camera)
# self.mediaRecorder.stateChanged.connect(self.updateRecorderState)
self.imageCapture = QCameraImageCapture(self.camera)
# self.mediaRecorder.durationChanged.connect(self.updateRecordTime)
# self.mediaRecorder.error.connect(self.displayRecorderError)
# self.mediaRecorder.setMetaData(QMediaMetaData.Title, "Test Title")
# self.ui.exposureCompensation.valueChanged.connect(
# self.setExposureCompensation)
self.camera.setViewfinder(self.ui.viewfinder)
self.updateCameraState(self.camera.state())
# self.updateLockStatus(self.camera.lockStatus(), QCamera.UserRequest)
# self.updateRecorderState(self.mediaRecorder.state())
self.imageCapture.readyForCaptureChanged.connect(self.readyForCapture)
self.imageCapture.imageCaptured.connect(self.processCapturedImage)
self.imageCapture.imageSaved.connect(self.imageSaved)
# self.camera.lockStatusChanged.connect(self.updateLockStatus)
self.ui.captureWidget.setTabEnabled(
0, self.camera.isCaptureModeSupported(QCamera.CaptureStillImage))
self.ui.captureWidget.setTabEnabled(
1, self.camera.isCaptureModeSupported(QCamera.CaptureVideo))
self.updateCaptureMode()
self.camera.start()
def keyPressEvent(self, event):
if event.isAutoRepeat():
return
if event.key() == Qt.Key_CameraFocus:
self.displayViewfinder()
self.camera.searchAndLock()
event.accept()
elif event.key() == Qt.Key_Camera:
if self.camera.captureMode() == QCamera.CaptureStillImage:
self.takeImage()
# elif self.mediaRecorder.state() == QMediaRecorder.RecordingState:
# self.stop()
# else:
# self.record()
event.accept()
else:
super(Camera, self).keyPressEvent(event)
def keyReleaseEvent(self, event):
if event.isAutoRepeat():
return
if event.key() == Qt.Key_CameraFocus:
self.camera.unlock()
else:
super(Camera, self).keyReleaseEvent(event)
# def updateRecordTime(self):
# msg = "Recorded %d sec" % (self.mediaRecorder.duration() // 1000)
# self.ui.statusbar.showMessage(msg)
def processCapturedImage(self, requestId, img):
scaledImage = img.scaled(self.ui.viewfinder.size(), Qt.KeepAspectRatio,
Qt.SmoothTransformation)
self.ui.lastImagePreviewLabel.setPixmap(QPixmap.fromImage(scaledImage))
self.displayCapturedImage()
QTimer.singleShot(4000, self.displayViewfinder)
def configureCaptureSettings(self):
if self.camera.captureMode() == QCamera.CaptureStillImage:
self.configureImageSettings()
elif self.camera.captureMode() == QCamera.CaptureVideo:
self.configureVideoSettings()
# def configureVideoSettings(self):
# settingsDialog = VideoSettings(self.mediaRecorder)
# settingsDialog.setAudioSettings(self.audioSettings)
# settingsDialog.setVideoSettings(self.videoSettings)
# settingsDialog.setFormat(self.videoContainerFormat)
# if settingsDialog.exec_():
# self.audioSettings = settingsDialog.audioSettings()
# self.videoSettings = settingsDialog.videoSettings()
# self.videoContainerFormat = settingsDialog.format()
# self.mediaRecorder.setEncodingSettings(self.audioSettings,
# self.videoSettings, self.videoContainerFormat)
def configureOpenExcels(self):
settingsopenexcelDialog = OpenExcels()
settingsopenexcelDialog.initUI()
def configureImageSettings(self):
settingsDialog = ImageSettings(self.imageCapture)
settingsDialog.setImageSettings(self.imageSettings)
if settingsDialog.exec_():
self.imageSettings = settingsDialog.imageSettings()
self.imageCapture.setEncodingSettings(self.imageSettings)
# def record(self):
# self.mediaRecorder.record()
# self.updateRecordTime()
# def pause(self):
# self.mediaRecorder.pause()
# def stop(self):
# self.mediaRecorder.stop()
# def setMuted(self, muted):
# self.mediaRecorder.setMuted(muted)
def toggleLock(self):
if self.camera.lockStatus() in (QCamera.Searching, QCamera.Locked):
self.camera.unlock()
elif self.camera.lockStatus() == QCamera.Unlocked:
self.camera.searchAndLock()
# def updateLockStatus(self, status, reason):
# indicationColor = Qt.black
# if status == QCamera.Searching:
# self.ui.statusbar.showMessage("Focusing...")
# self.ui.lockButton.setText("Focusing...")
# indicationColor = Qt.yellow
# elif status == QCamera.Locked:
# self.ui.lockButton.setText("Unlock")
# self.ui.statusbar.showMessage("Focused", 2000)
# indicationColor = Qt.darkGreen
# # elif status == QCamera.Unlocked:
# # self.ui.lockButton.setText("Focus")
# if reason == QCamera.LockFailed:
# self.ui.statusbar.showMessage("Focus Failed", 2000)
# indicationColor = Qt.red
# palette = self.ui.lockButton.palette()
# palette.setColor(QPalette.ButtonText, indicationColor)
# self.ui.lockButton.setPalette(palette)
def display_absences(self, absences):
self.ui.absenceNumber.display(absences)
def takeImage(self):
self.isCapturingImage = True
self.imageCapture.capture()
def startCamera(self):
self.camera.start()
def stopCamera(self):
self.camera.stop()
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 updateCameraState(self, state):
if state == QCamera.ActiveState:
self.ui.actionStartCamera.setEnabled(False)
self.ui.actionStopCamera.setEnabled(True)
self.ui.captureWidget.setEnabled(True)
self.ui.actionSettings.setEnabled(True)
elif state in (QCamera.UnloadedState, QCamera.LoadedState):
self.ui.actionStartCamera.setEnabled(True)
self.ui.actionStopCamera.setEnabled(False)
self.ui.captureWidget.setEnabled(False)
self.ui.actionSettings.setEnabled(False)
# 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 setExposureCompensation(self, index):
self.camera.exposure().setExposureCompensation(index * 0.5)
# def displayRecorderError(self):
# QMessageBox.warning(self, "Capture error",
# self.mediaRecorder.errorString())
def displayCameraError(self):
QMessageBox.warning(self, "Camera error", self.camera.errorString())
def updateCameraDevice(self, action):
self.setCamera(action.data())
def displayViewfinder(self):
self.ui.stackedWidget.setCurrentIndex(0)
def displayCapturedImage(self):
self.ui.stackedWidget.setCurrentIndex(1)
def readyForCapture(self, ready):
self.ui.takeImageButton.setEnabled(ready)
def imageSaved(self, id, fileName):
self.isCapturingImage = False
if self.applicationExiting:
self.close()
def closeEvent(self, event):
if self.isCapturingImage:
self.setEnabled(False)
self.applicationExiting = True
event.ignore()
else:
event.accept()
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 Camera(QMainWindow):
def __init__(self, parent=None):
super(Camera, self).__init__(parent)
self.ui = Ui_Camera()
self.camera = None
self.imageCapture = None
self.mediaRecorder = None
self.isCapturingImage = False
self.applicationExiting = False
self.imageSettings = QImageEncoderSettings()
self.audioSettings = QAudioEncoderSettings()
self.videoSettings = QVideoEncoderSettings()
self.videoContainerFormat = ''
self.ui.setupUi(self)
cameraDevice = QByteArray()
videoDevicesGroup = QActionGroup(self)
videoDevicesGroup.setExclusive(True)
for deviceName in QCamera.availableDevices():
description = QCamera.deviceDescription(deviceName)
videoDeviceAction = QAction(description, videoDevicesGroup)
videoDeviceAction.setCheckable(True)
videoDeviceAction.setData(deviceName)
if cameraDevice.isEmpty():
cameraDevice = deviceName
videoDeviceAction.setChecked(True)
self.ui.menuDevices.addAction(videoDeviceAction)
videoDevicesGroup.triggered.connect(self.updateCameraDevice)
self.ui.captureWidget.currentChanged.connect(self.updateCaptureMode)
self.ui.lockButton.hide()
self.setCamera(cameraDevice)
def setCamera(self, cameraDevice):
if cameraDevice.isEmpty():
self.camera = QCamera()
else:
self.camera = QCamera(cameraDevice)
self.camera.stateChanged.connect(self.updateCameraState)
self.camera.error.connect(self.displayCameraError)
self.mediaRecorder = QMediaRecorder(self.camera)
self.mediaRecorder.stateChanged.connect(self.updateRecorderState)
self.imageCapture = QCameraImageCapture(self.camera)
self.mediaRecorder.durationChanged.connect(self.updateRecordTime)
self.mediaRecorder.error.connect(self.displayRecorderError)
self.mediaRecorder.setMetaData(QMediaMetaData.Title, "Test Title")
self.ui.exposureCompensation.valueChanged.connect(
self.setExposureCompensation)
self.camera.setViewfinder(self.ui.viewfinder)
self.updateCameraState(self.camera.state())
self.updateLockStatus(self.camera.lockStatus(), QCamera.UserRequest)
self.updateRecorderState(self.mediaRecorder.state())
self.imageCapture.readyForCaptureChanged.connect(self.readyForCapture)
self.imageCapture.imageCaptured.connect(self.processCapturedImage)
self.imageCapture.imageSaved.connect(self.imageSaved)
self.camera.lockStatusChanged.connect(self.updateLockStatus)
self.ui.captureWidget.setTabEnabled(
0, self.camera.isCaptureModeSupported(QCamera.CaptureStillImage))
self.ui.captureWidget.setTabEnabled(
1, self.camera.isCaptureModeSupported(QCamera.CaptureVideo))
self.updateCaptureMode()
self.camera.start()
def keyPressEvent(self, event):
if event.isAutoRepeat():
return
if event.key() == Qt.Key_CameraFocus:
self.displayViewfinder()
self.camera.searchAndLock()
event.accept()
elif event.key() == Qt.Key_Camera:
if self.camera.captureMode() == QCamera.CaptureStillImage:
self.takeImage()
elif self.mediaRecorder.state() == QMediaRecorder.RecordingState:
self.stop()
else:
self.record()
event.accept()
else:
super(Camera, self).keyPressEvent(event)
def keyReleaseEvent(self, event):
if event.isAutoRepeat():
return
if event.key() == Qt.Key_CameraFocus:
self.camera.unlock()
else:
super(Camera, self).keyReleaseEvent(event)
def updateRecordTime(self):
msg = "Recorded %d sec" % (self.mediaRecorder.duration() // 1000)
self.ui.statusbar.showMessage(msg)
###############################################################################
def detectChars(self, qImg):
incomingImage = qImg.convertToFormat(4)
width = incomingImage.width()
height = incomingImage.height()
ptr = incomingImage.bits()
ptr.setsize(incomingImage.byteCount())
cvImg = np.array(ptr).reshape(height, width, 4) # Copies the data
######################
centerx = int(cvImg.shape[1] / 2)
centery = int(cvImg.shape[0] / 2)
half_width = 200
half_height = 100
y = centery - half_height
x = centerx - half_width
print(type(cvImg))
cvImgCroped = cvImg[y:y + half_height * 2, x:x + half_width *
2] # Crop from x, y, w, h -> 100, 200, 300, 400
cvImgCContinues = np.zeros(cvImgCroped.shape, np.uint8)
cvImgCContinues = cvImgCroped.copy()
# NOTE: its img[y: y + h, x: x + w] and *not* img[x: x + w, y: y + h]
# cvImgCroped = cv2.rectangle(cvImgCroped,
# (centerx - half_width, centery - half_height),
# (centerx + half_width, centery + half_height),
# (0, 0, 255),
# 2)
######################
# Convert to RGB for QImage.
cvImgCContinues = cv2.cvtColor(cvImgCContinues, cv2.COLOR_BGR2RGB)
# cv2.imshow("",cvImgCContinues)
# cv2.waitKey(0)
height, width, bytesPerComponent = cvImgCContinues.shape
bytesPerLine = bytesPerComponent * width
self.image = QImage(cvImgCContinues.data, width, height, bytesPerLine,
QImage.Format_RGB888)
return self.image
###############################################################################
def processCapturedImage(self, requestId, img):
detectedImage = self.detectChars(img)
scaledImage = detectedImage.scaled(self.ui.viewfinder.size(),
Qt.KeepAspectRatio,
Qt.SmoothTransformation)
self.ui.lastImagePreviewLabel.setPixmap(QPixmap.fromImage(scaledImage))
self.displayCapturedImage()
QTimer.singleShot(40000, self.displayViewfinder)
###############################################################################
def configureCaptureSettings(self):
if self.camera.captureMode() == QCamera.CaptureStillImage:
self.configureImageSettings()
elif self.camera.captureMode() == QCamera.CaptureVideo:
self.configureVideoSettings()
def configureVideoSettings(self):
settingsDialog = VideoSettings(self.mediaRecorder)
settingsDialog.setAudioSettings(self.audioSettings)
settingsDialog.setVideoSettings(self.videoSettings)
settingsDialog.setFormat(self.videoContainerFormat)
if settingsDialog.exec_():
self.audioSettings = settingsDialog.audioSettings()
self.videoSettings = settingsDialog.videoSettings()
self.videoContainerFormat = settingsDialog.format()
self.mediaRecorder.setEncodingSettings(self.audioSettings,
self.videoSettings,
self.videoContainerFormat)
def configureImageSettings(self):
settingsDialog = ImageSettings(self.imageCapture)
settingsDialog.setImageSettings(self.imageSettings)
if settingsDialog.exec_():
self.imageSettings = settingsDialog.imageSettings()
self.imageCapture.setEncodingSettings(self.imageSettings)
def record(self):
self.mediaRecorder.record()
self.updateRecordTime()
def pause(self):
self.mediaRecorder.pause()
def stop(self):
self.mediaRecorder.stop()
def setMuted(self, muted):
self.mediaRecorder.setMuted(muted)
def toggleLock(self):
if self.camera.lockStatus() in (QCamera.Searching, QCamera.Locked):
self.camera.unlock()
elif self.camera.lockStatus() == QCamera.Unlocked:
self.camera.searchAndLock()
def updateLockStatus(self, status, reason):
indicationColor = Qt.black
if status == QCamera.Searching:
self.ui.statusbar.showMessage("Focusing...")
self.ui.lockButton.setText("Focusing...")
indicationColor = Qt.yellow
elif status == QCamera.Locked:
self.ui.lockButton.setText("Unlock")
self.ui.statusbar.showMessage("Focused", 2000)
indicationColor = Qt.darkGreen
elif status == QCamera.Unlocked:
self.ui.lockButton.setText("Focus")
if reason == QCamera.LockFailed:
self.ui.statusbar.showMessage("Focus Failed", 2000)
indicationColor = Qt.red
palette = self.ui.lockButton.palette()
palette.setColor(QPalette.ButtonText, indicationColor)
self.ui.lockButton.setPalette(palette)
def takeImage(self):
self.isCapturingImage = True
self.imageCapture.capture()
def startCamera(self):
self.camera.start()
def stopCamera(self):
self.camera.stop()
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 updateCameraState(self, state):
if state == QCamera.ActiveState:
self.ui.actionStartCamera.setEnabled(False)
self.ui.actionStopCamera.setEnabled(True)
self.ui.captureWidget.setEnabled(True)
self.ui.actionSettings.setEnabled(True)
elif state in (QCamera.UnloadedState, QCamera.LoadedState):
self.ui.actionStartCamera.setEnabled(True)
self.ui.actionStopCamera.setEnabled(False)
self.ui.captureWidget.setEnabled(False)
self.ui.actionSettings.setEnabled(False)
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 setExposureCompensation(self, index):
self.camera.exposure().setExposureCompensation(index * 0.5)
def displayRecorderError(self):
QMessageBox.warning(self, "Capture error",
self.mediaRecorder.errorString())
def displayCameraError(self):
QMessageBox.warning(self, "Camera error", self.camera.errorString())
def updateCameraDevice(self, action):
self.setCamera(action.data())
def displayViewfinder(self):
self.ui.stackedWidget.setCurrentIndex(0)
def displayCapturedImage(self):
self.ui.stackedWidget.setCurrentIndex(1)
def readyForCapture(self, ready):
self.ui.takeImageButton.setEnabled(ready)
def imageSaved(self, id, fileName):
self.isCapturingImage = False
if self.applicationExiting:
self.close()
def closeEvent(self, event):
if self.isCapturingImage:
self.setEnabled(False)
self.applicationExiting = True
event.ignore()
else:
event.accept()
def main():
app = QApplication(
sys.argv
) # must be called in order to be able to use all the stuff below(!)
print("The application is executed on: %s" % app.platformName())
l_cameras = QCameraInfo.availableCameras()
if len(l_cameras) == 0:
print("ERROR: no cameras found")
sys.exit(-1)
else:
print("INFO: found %i camera(s)" % len(l_cameras))
print()
for i_idx, oc_caminfo in enumerate(l_cameras):
# QCameraInfo - derived properties
print("Camera #%i:" % i_idx)
print("\t deviceName: %s" % oc_caminfo.deviceName())
print("\t description: %s" % oc_caminfo.description())
print("\t isNull: %s" % oc_caminfo.isNull())
print("\t orientation: %s" % oc_caminfo.orientation())
print("\t position: %s" % oc_caminfo.position())
# QCamera - derived properties
oc_camera = QCamera(i_idx)
camera_sync_load_and_start(oc_camera)
oc_camera_exposure = oc_camera.exposure()
print("\t captureMode: %s" % captureMode2str(oc_camera.captureMode()))
print("\t exposure:")
print("\t\t isAvailabe: %s" % oc_camera_exposure.isAvailable())
if oc_camera_exposure.isAvailable():
print("\t\t aperture: %s" % oc_camera_exposure.aperture())
# TODO test this, add more entries
oc_camera_focus = oc_camera.focus()
print("\t focus:")
print("\t\t isAvailabe: %s" % oc_camera_focus.isAvailable())
if oc_camera_focus.isAvailable():
print("\t\t aperture: %f" % oc_camera_focus.digitalZoom())
# TODO test this, add more entries
oc_cam_img_proc = oc_camera.imageProcessing()
print("\t imageProcessing:")
print("\t\t isAvailabe: %s" % oc_cam_img_proc.isAvailable())
if oc_cam_img_proc.isAvailable():
print("\t\t brightness: %f" % oc_cam_img_proc.brightness())
print("\t\t contrast: %f" % oc_cam_img_proc.contrast())
print("\t\t denoisingLevel: %f" % oc_cam_img_proc.denoisingLevel())
print("\t\t manualWhiteBalance: %f" %
oc_cam_img_proc.manualWhiteBalance())
print("\t\t saturation: %f" % oc_cam_img_proc.saturation())
print("\t\t sharpeningLevel: %f" %
oc_cam_img_proc.sharpeningLevel())
print("\t isVideoCaptureSupported: %s" %
oc_camera.isCaptureModeSupported(QCamera.CaptureVideo))
print("\t lockStatus: %s" % lockStatus2str(oc_camera.lockStatus()))
print("\t requestedLocks: %s" %
lockType2str(oc_camera.requestedLocks()))
print("\t state: %s" % state2str(oc_camera.state()))
print("\t status: %s" % status2str(oc_camera.status()))
print("\t supportedLocks: %s" %
lockType2str(oc_camera.supportedLocks()))
print(
"\t supportedViewfinderFrameRateRanges: %s" %
frameRateRange2str(oc_camera.supportedViewfinderFrameRateRanges()))
print("\t supportedViewfinderPixelFormats: %s" %
repr(oc_camera.supportedViewfinderPixelFormats()))
print("\t supportedViewfinderResolutions: \n\t\t%s" %
frameResolution2str(oc_camera.supportedViewfinderResolutions()))
print("\t len(supportedViewfinderSettings): %s" %
len(oc_camera.supportedViewfinderSettings()))
# QCameraViewfinderSettings - derived properties
oc_vf_settings = oc_camera.viewfinderSettings()
if oc_vf_settings.isNull():
print("\t viewfinderSettings: not supported")
camera_sync_stop_and_unload(oc_camera)
print()
continue
print("\t maximumFrameRate: %f" % oc_vf_settings.maximumFrameRate())
print("\t minimumFrameRate: %f" % oc_vf_settings.minimumFrameRate())
print("\t resolution: %s" %
frameResolution2str([oc_vf_settings.resolution()]))
# TODO the rest of methods...
camera_sync_stop_and_unload(oc_camera)
print()
class Widgets(QWidget):
def __init__(self, dispositivoCamara, parent=None):
super(Widgets, self).__init__(parent)
self.parent = parent
self.estadoFoto = False
self.byteArrayFoto = QByteArray()
# ==========================================================
frame = QFrame(self)
frame.setFrameShape(QFrame.Box)
frame.setFrameShadow(QFrame.Sunken)
frame.setFixedWidth(505)
frame.setFixedHeight(380)
frame.move(10, 10)
# Instancias
self.paginaVisor = QVideoWidget()
self.paginaVisor.resize(500, 375)
self.visor = QCameraViewfinder(self.paginaVisor)
self.visor.resize(500, 375)
self.labelFoto = QLabel()
self.labelFoto.setAlignment(Qt.AlignCenter)
self.labelFoto.resize(500, 375)
# QStackedWidget
self.stackedWidget = QStackedWidget(frame)
self.stackedWidget.addWidget(self.paginaVisor)
self.stackedWidget.addWidget(self.labelFoto)
self.stackedWidget.resize(500, 375)
self.stackedWidget.move(2, 2)
# ======================== BOTONES =========================
self.buttonTomarFoto = QPushButton("Tomar foto", self)
self.buttonTomarFoto.resize(110, 26)
self.buttonTomarFoto.move(525, 10)
self.buttonEliminarFoto = QPushButton("Eliminar foto", self)
self.buttonEliminarFoto.resize(110, 26)
self.buttonEliminarFoto.move(525, 50)
self.buttonGuardarFoto = QPushButton("Guardar foto", self)
self.buttonGuardarFoto.resize(110, 26)
self.buttonGuardarFoto.move(525, 82)
# ======================== EVENTOS =========================
self.buttonTomarFoto.clicked.connect(self.tomarFoto)
self.buttonEliminarFoto.clicked.connect(self.eliminarFoto)
self.buttonGuardarFoto.clicked.connect(self.guardarFoto)
# ================== FUNCIONES AUTOMÁTICAS =================
self.setCamara(dispositivoCamara)
# ======================= FUNCIONES ============================
def setCamara(self, dispositivoCamara):
if dispositivoCamara.isEmpty():
self.camara = QCamera()
else:
self.camara = QCamera(dispositivoCamara)
self.camara.stateChanged.connect(self.actualizarEstadoCamara)
self.capturaImagen = QCameraImageCapture(self.camara)
self.camara.setViewfinder(self.visor)
self.actualizarEstadoCamara(self.camara.state())
self.capturaImagen.imageCaptured.connect(self.procesarImagenCapturada)
self.capturaImagen.imageSaved.connect(self.imagenGuardada)
self.camara.isCaptureModeSupported(QCamera.CaptureStillImage)
self.camara.start()
self.paginaVisor.update()
def actualizarDispositivoCamara(self, action):
self.setCamara(action.data())
def actualizarEstadoCamara(self, estado):
if estado == QCamera.ActiveState:
self.parent.accionIniciarCamara.setEnabled(False)
self.parent.accionDetenerCamara.setEnabled(True)
if not self.estadoFoto:
self.buttonTomarFoto.setEnabled(True)
self.buttonEliminarFoto.setEnabled(False)
self.buttonGuardarFoto.setEnabled(False)
elif estado in (QCamera.UnloadedState, QCamera.LoadedState):
self.parent.accionIniciarCamara.setEnabled(True)
self.parent.accionDetenerCamara.setEnabled(False)
if not self.estadoFoto:
self.buttonTomarFoto.setEnabled(False)
self.buttonEliminarFoto.setEnabled(False)
self.buttonGuardarFoto.setEnabled(False)
def iniciarCamara(self):
self.camara.start()
def detenerCamara(self):
self.camara.stop()
def tomarFoto(self):
rutaFoto = "{}/fotoTemporal.jpg".format(getcwd())
self.capturaImagen.capture(rutaFoto)
self.estadoFoto = True
def procesarImagenCapturada(self, requestId, imagen):
foto = QPixmap.fromImage(imagen)
buffer = QBuffer(self.byteArrayFoto)
buffer.open(QIODevice.WriteOnly)
buffer.close()
foto.save(buffer, "PNG")
fotoEscalada = foto.scaled(self.labelFoto.size())
self.labelFoto.setPixmap(fotoEscalada)
self.mostrarImagenCapturada()
def visualizarVisor(self):
self.stackedWidget.setCurrentIndex(0)
def mostrarImagenCapturada(self):
self.stackedWidget.setCurrentIndex(1)
self.buttonTomarFoto.setEnabled(False)
self.buttonEliminarFoto.setEnabled(True)
self.buttonGuardarFoto.setEnabled(True)
def imagenGuardada(self, id, nombreFoto):
if QFile.exists(nombreFoto):
remove(nombreFoto)
def eliminarFoto(self):
self.estadoFoto = False
self.byteArrayFoto.clear()
self.labelFoto.clear()
self.actualizarEstadoCamara(self.camara.state())
self.visualizarVisor()
def guardarFoto(self):
guardarComo, extension = QFileDialog.getSaveFileName(
self,
"Guardar como",
"Foto",
"JPG (*.jpg);;PNG (*.png);;ICO (*.ico);;BMP (*.bmp)",
options=QFileDialog.Options())
if guardarComo:
foto = QPixmap()
foto.loadFromData(self.byteArrayFoto, "PNG", Qt.AutoColor)
foto.save(guardarComo, quality=100)
QMessageBox.information(
self, "Guardar foto",
"Foto guardada con éxito ")
self.eliminarFoto()
class Camera(QWidget):
def __init__(self, parent=None, standalone=False):
super(Camera, self).__init__(parent)
# This prevents doing unneeded initialization
# when QtDesginer loads the plugin.
if parent is None and not standalone:
return
if not multimedia_available:
return
self.ui = uic.loadUi(os.path.join(WIDGET_PATH, "camera.ui"), self)
self.camera = None
self.imageCapture = None
self.mediaRecorder = None
self.isCapturingImage = False
self.applicationExiting = False
self.imageSettings = QImageEncoderSettings()
self.audioSettings = QAudioEncoderSettings()
self.videoSettings = QVideoEncoderSettings()
self.videoContainerFormat = ''
camera_device = QByteArray()
videoDevicesGroup = QActionGroup(self)
videoDevicesGroup.setExclusive(True)
if not QCamera.availableDevices():
self.ui.devicesCombo.addItem("No Device")
else:
for deviceName in QCamera.availableDevices():
description = QCamera.deviceDescription(deviceName)
self.ui.devicesCombo.addItem(description)
videoDeviceAction = QAction(description, videoDevicesGroup)
videoDeviceAction.setCheckable(True)
videoDeviceAction.setData(deviceName)
if camera_device.isEmpty():
cameraDevice = deviceName
videoDeviceAction.setChecked(True)
self.ui.devicesCombo.addAction(videoDeviceAction)
videoDevicesGroup.triggered.connect(self.updateCameraDevice)
self.ui.captureWidget.currentChanged.connect(self.updateCaptureMode)
self.ui.devicesCombo.currentIndexChanged.connect(
self.get_device_action)
self.ui.lockButton.hide()
# Start camera 2s after the UI has loaded
QTimer.singleShot(2000, lambda: self.setCamera(camera_device))
def setCamera(self, cameraDevice):
try:
if cameraDevice.isEmpty():
self.camera = QCamera()
else:
self.camera = QCamera(cameraDevice)
self.camera.stateChanged.connect(self.updateCameraState)
self.camera.error.connect(self.displayCameraError)
self.mediaRecorder = QMediaRecorder(self.camera)
self.mediaRecorder.stateChanged.connect(self.updateRecorderState)
self.imageCapture = QCameraImageCapture(self.camera)
self.mediaRecorder.durationChanged.connect(self.updateRecordTime)
self.mediaRecorder.error.connect(self.displayRecorderError)
self.mediaRecorder.setMetaData(QMediaMetaData.Title,
"Camera Widget")
self.ui.exposureCompensation.valueChanged.connect(
self.setExposureCompensation)
self.camera.setViewfinder(self.ui.viewfinder)
self.updateCameraState(self.camera.state())
self.updateLockStatus(self.camera.lockStatus(),
QCamera.UserRequest)
self.updateRecorderState(self.mediaRecorder.state())
self.imageCapture.readyForCaptureChanged.connect(
self.readyForCapture)
self.imageCapture.imageCaptured.connect(self.processCapturedImage)
self.imageCapture.imageSaved.connect(self.imageSaved)
self.camera.lockStatusChanged.connect(self.updateLockStatus)
self.ui.captureWidget.setTabEnabled(
0,
self.camera.isCaptureModeSupported(QCamera.CaptureStillImage))
self.ui.captureWidget.setTabEnabled(
1, self.camera.isCaptureModeSupported(QCamera.CaptureVideo))
self.updateCaptureMode()
self.camera.start()
except:
pass
def keyPressEvent(self, event):
if event.isAutoRepeat():
return
if event.key() == Qt.Key_CameraFocus:
self.displayViewfinder()
self.camera.searchAndLock()
event.accept()
elif event.key() == Qt.Key_Camera:
if self.camera.captureMode() == QCamera.CaptureStillImage:
self.takeImage()
elif self.mediaRecorder.state() == QMediaRecorder.RecordingState:
self.stop()
else:
self.record()
event.accept()
else:
super(Camera, self).keyPressEvent(event)
def keyReleaseEvent(self, event):
if event.isAutoRepeat():
return
if event.key() == Qt.Key_CameraFocus:
self.camera.unlock()
else:
super(Camera, self).keyReleaseEvent(event)
def updateRecordTime(self):
msg = "Recorded {} sec".format(self.mediaRecorder.duration())
self.ui.timeLabel.text = msg
print(msg)
def processCapturedImage(self, requestId, img):
scaledImage = img.scaled(self.ui.viewfinder.size(), Qt.KeepAspectRatio,
Qt.SmoothTransformation)
self.ui.lastImagePreviewLabel.setPixmap(QPixmap.fromImage(scaledImage))
self.displayCapturedImage()
QTimer.singleShot(4000, self.displayViewfinder)
def configureSettings(self):
settings_dialog = Settings(self.mediaRecorder, self.imageCapture)
settings_dialog.setImageSettings(self.imageSettings)
settings_dialog.setAudioSettings(self.audioSettings)
settings_dialog.setVideoSettings(self.videoSettings)
settings_dialog.setFormat(self.videoContainerFormat)
# settings_dialog.setStreamingSettings(self.streamingSettings)
if settings_dialog.exec_():
self.imageSettings = settings_dialog.imageSettings()
self.audioSettings = settings_dialog.audioSettings()
self.videoSettings = settings_dialog.videoSettings()
self.videoContainerFormat = settings_dialog.format()
self.imageCapture.setEncodingSettings(self.imageSettings)
self.mediaRecorder.setEncodingSettings(self.audioSettings,
self.videoSettings,
self.videoContainerFormat)
def record(self):
self.mediaRecorder.record()
self.updateRecordTime()
def pause(self):
self.mediaRecorder.pause()
def stop(self):
self.mediaRecorder.stop()
def setMuted(self, muted):
self.mediaRecorder.setMuted(muted)
def toggleLock(self):
if self.camera.lockStatus() in (QCamera.Searching, QCamera.Locked):
self.camera.unlock()
elif self.camera.lockStatus() == QCamera.Unlocked:
self.camera.searchAndLock()
def updateLockStatus(self, status, reason):
indicationColor = Qt.black
if status == QCamera.Searching:
self.ui.statusbar.showMessage("Focusing...")
self.ui.lockButton.setText("Focusing...")
indicationColor = Qt.yellow
elif status == QCamera.Locked:
self.ui.lockButton.setText("Unlock")
self.ui.statusbar.showMessage("Focused", 2000)
indicationColor = Qt.darkGreen
elif status == QCamera.Unlocked:
self.ui.lockButton.setText("Focus")
if reason == QCamera.LockFailed:
self.ui.statusbar.showMessage("Focus Failed", 2000)
indicationColor = Qt.red
palette = self.ui.lockButton.palette()
palette.setColor(QPalette.ButtonText, indicationColor)
self.ui.lockButton.setPalette(palette)
def takeImage(self):
self.isCapturingImage = True
self.imageCapture.capture()
def startCamera(self):
self.camera.start()
def stopCamera(self):
self.camera.stop()
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 updateCameraState(self, state):
if state == QCamera.ActiveState:
self.ui.actionStartCamera.setEnabled(False)
self.ui.actionStopCamera.setEnabled(True)
self.ui.captureWidget.setEnabled(True)
self.ui.actionSettings.setEnabled(True)
elif state in (QCamera.UnloadedState, QCamera.LoadedState):
self.ui.actionStartCamera.setEnabled(True)
self.ui.actionStopCamera.setEnabled(False)
self.ui.captureWidget.setEnabled(False)
self.ui.actionSettings.setEnabled(False)
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 setExposureCompensation(self, index):
self.camera.exposure().setExposureCompensation(index * 0.5)
def displayRecorderError(self):
QMessageBox.warning(self, "Capture error",
self.mediaRecorder.errorString())
def displayCameraError(self):
QMessageBox.warning(self, "Camera error", self.camera.errorString())
def get_device_action(self, index):
self.ui.devicesCombo.actions()[index].trigger()
def updateCameraDevice(self, action):
self.setCamera(action.data())
def displayViewfinder(self):
self.ui.stackedWidget.setCurrentIndex(0)
def displayCapturedImage(self):
self.ui.stackedWidget.setCurrentIndex(1)
def readyForCapture(self, ready):
self.ui.takeImageButton.setEnabled(ready)
def imageSaved(self, id, fileName):
self.isCapturingImage = False
if self.applicationExiting:
self.close()
def closeEvent(self, event):
if self.isCapturingImage:
self.setEnabled(False)
self.applicationExiting = True
event.ignore()
else:
event.accept()
