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)
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
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 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 __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 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 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()
self.show()
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 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()
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 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()
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()
