def take_photo(self, camera_save_path):
     image_capture = QCameraImageCapture(self.camera)
     save_path = str(Path(os.path.expanduser(camera_save_path)))
     photo_path = os.path.join(
         save_path, "EAF_Camera_Photo_" + time.strftime(
             "%Y-%m-%d_%H:%M:%S", time.localtime(int(time.time()))))
     image_capture.capture(photo_path)
     self.message_to_emacs.emit("Captured Photo at " + photo_path)
    def take_photo(self):
        photo_path = os.path.join(
            str(Path.home()), "EAF_Camera_Photo_" + time.strftime(
                "%Y-%m-%d %H:%M:%S", time.localtime(int(time.time()))))

        image_capture = QCameraImageCapture(self.camera)
        image_capture.capture(photo_path)

        self.message_to_emacs.emit("Save photo at: " + photo_path)
 def take_photo(self, camera_save_path):
     image_capture = QCameraImageCapture(self.camera)
     save_path = str(Path(os.path.expanduser(camera_save_path)))
     photo_path = os.path.join(
         save_path, "EAF_Camera_Photo_" +
         time.strftime("%Y%m%d_%H%M%S", time.localtime(int(time.time()))))
     return image_capture.capture(photo_path)
Esempio n. 4
0
class CameraMainWin(QtWidgets.QMainWindow, CameraWin.CameraWin):
    def __init__(self):
        super(CameraMainWin, self).__init__()
        self.setupUi(self)
        #定义相机实例对象并设置捕获模式
        self.camera = QCamera()
        self.camera.setCaptureMode(QCamera.CaptureViewfinder)
        self.cameraOpened = False  # 设置相机打开状态为未打开
        #设置取景器分辨率
        viewFinderSettings = QCameraViewfinderSettings()
        viewFinderSettings.setResolution(800, 600)
        self.camera.setViewfinderSettings(viewFinderSettings)
        #初始化取景器
        self.viewCamera = QtMultimediaWidgets.QCameraViewfinder(self)
        self.camera.setViewfinder(self.viewCamera)
        self.camera.setCaptureMode(QCamera.CaptureStillImage)
        self.camerLayout.addWidget(self.viewCamera)  #取景器放置到预留的布局中
        #设置图像捕获
        self.capture = QCameraImageCapture(self.camera)
        self.capture.setCaptureDestination(
            QCameraImageCapture.CaptureToBuffer)  #CaptureToBuffer
        self.switchCamera: QPushButton
        self.switchCamera.clicked.connect(self.SwitchCamera)
        self.takePic.clicked.connect(self.TakePic)
        self.capture.error.connect(lambda i, e, s: self.alert(s))
        self.capture.imageAvailable.connect(self.saveImage)
        self.capture.imageCaptured.connect(
            lambda d, i: self.status.showMessage("Image %04d captured" % self.
                                                 save_seq))

    #相机(摄像头)开关处理
    def SwitchCamera(self):
        if not self.cameraOpened:
            print('test1')
            self.camera.start()
            print('test2')
            self.cameraOpened = True
            self.switchCamera.setText("关闭摄像头")
        else:
            self.camera.stop()
            self.cameraOpened = False
            self.switchCamera.setText("打开摄像头")

    def TakePic(self):  #拍照响应槽函数,照片保存到文件
        FName = fr"/Users/xiaozhenlong/Desktop/tmp/{time.strftime('%Y%m%d%H%M%S', time.localtime())}"  #文件名初始化
        print(self.capture.capture(FName + '.jpg'))
        print(f"捕获图像保存到文件:{FName}.jpg")

    def saveImage(self, requestId, image):
        print('test3')
        image: PyQt5.QtMultimedia.QVideoFrame
        image = qimage2numpy2(image.image())
        print(image.shape)
        cv2.imwrite('/Users/xiaozhenlong/Desktop/tmp/test3.jpg', image)
Esempio n. 5
0
    def onLogInClicked(self):
        capture = QCameraImageCapture(self.camera_obj)
        capture.capture(__file__[:-14:] + 'capture.jpg')

        sleep(1)

        s_data = {'image': open(__file__[:-14:] + 'capture.jpg', 'rb')}
        r = requests.post(self.veg_cfg.get_db_addr(), files=s_data)

        if r.json()['status'] != 'ok':
            QMessageBox.warning(
                self, 'Verification failed',
                'Failed to pass identity verification.\nTry again or cantact your admin (╯°^°)╯┻━┻',
                QMessageBox.Ok)
        else:
            if self.veg_cfg.get_browser() == 'firefox':
                fire = auth.FirefoxAuth(r.json()['login'], r.json()['passwd'])
                fire.get_auth_token()
            else:
                chrome = auth.ChromeAuth(r.json()['login'], r.json()['passwd'])
                chrome.get_auth_token()
class CameraMainWin(QtWidgets.QMainWindow, CameraWin.Ui_CameraWin):
    def __init__(self):
        super(CameraMainWin, self).__init__()
        self.setupUi(self)
        #定义相机实例对象并设置捕获模式
        self.camera = QCamera()
        self.camera.setCaptureMode(QCamera.CaptureViewfinder)
        self.cameraOpened = False  # 设置相机打开状态为未打开
        #设置取景器分辨率
        viewFinderSettings = QCameraViewfinderSettings()
        viewFinderSettings.setResolution(800, 600)
        self.camera.setViewfinderSettings(viewFinderSettings)
        #初始化取景器
        self.viewCamera = QtMultimediaWidgets.QCameraViewfinder(self)
        self.camera.setViewfinder(self.viewCamera)
        self.camerLayout.addWidget(self.viewCamera)  #取景器放置到预留的布局中
        #设置图像捕获
        self.capImg = QCameraImageCapture(self.camera)
        self.capImg.setCaptureDestination(
            QCameraImageCapture.CaptureToFile)  #CaptureToBuffer

    #相机(摄像头)开关处理
    def switchCamera(self):
        if not self.cameraOpened:
            self.camera.start()
            self.cameraOpened = True
            self.btnSwitchCamera.setText("关闭摄像头")
        else:
            self.camera.stop()
            self.cameraOpened = False
            self.btnSwitchCamera.setText("打开摄像头")

    def takePic(self):  #拍照响应槽函数,照片保存到文件
        FName = fr"E:\iddatabasepic\cap{time.strftime('%Y%m%d%H%M%S', time.localtime())}"  #文件名初始化
        self.capImg.capture(FName)
        print(f"捕获图像保存到文件:{FName}.jpg")
class Camera(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()
Esempio n. 8
0
class Window(QWidget):

    # конструктор формы
    def __init__(self):
        super().__init__()
        self._Client = Biometric_Client(
            url='https://expasoft.com',
            port=2133,
            subscription_key='9fc9474b4bd16b492276eee41763a3cb')

        self.resize(800, 600)
        self.setObjectName("FormMain")
        self.setWindowTitle("БиоСКУД Archivist")

        self.labelHumans = QtWidgets.QLabel(self)
        self.labelHumans.setObjectName("labelHumans")
        self.labelHumans.setText("Профили сотрудников")
        self.labelHumans.setGeometry(QtCore.QRect(80, 15, 181, 21))
        font = QtGui.QFont()
        font.setPointSize(12)
        self.labelHumans.setFont(font)

        self.labelPhotos = QtWidgets.QLabel(self)
        self.labelPhotos.setObjectName("labelPhotos")
        self.labelPhotos.setText("Фото сотрудника")
        self.labelPhotos.setGeometry(QtCore.QRect(390, 15, 181, 21))
        font = QtGui.QFont()
        font.setPointSize(12)
        self.labelPhotos.setFont(font)

        self.listViewHumans = QtWidgets.QListWidget(self)
        self.listViewHumans.setObjectName("listViewHumans")
        self.listViewHumans.setGeometry(QtCore.QRect(10, 50, 291, 531))
        self.listViewHumans.setIconSize(QtCore.QSize(200, 200))
        self.listViewHumans.itemClicked.connect(self.LoadProfile)

        self.listViewPhotos = QtWidgets.QListWidget(self)
        self.listViewPhotos.setObjectName("listViewPhotos")
        self.listViewPhotos.setGeometry(QtCore.QRect(310, 50, 291, 281))
        self.listViewPhotos.setIconSize(QtCore.QSize(150, 150))

        self.labelName = QLabel(self)
        self.labelName.setText("ФИО:")
        self.labelName.move(310, 355)

        self.lineName = QLineEdit(self)
        self.lineName.resize(140, 25)
        self.lineName.move(350, 350)

        self.labelTag = QLabel(self)
        self.labelTag.setText("Пост:")
        self.labelTag.move(310, 385)

        self.lineTag = QLineEdit(self)
        self.lineTag.resize(140, 25)
        self.lineTag.move(350, 380)

        self.pushButtonAddProfile = QtWidgets.QPushButton(self)
        self.pushButtonAddProfile.setGeometry(QtCore.QRect(310, 420, 181, 51))
        self.pushButtonAddProfile.setObjectName("pushButtonAddProfile")
        self.pushButtonAddProfile.setText("Добавить профиль")
        self.pushButtonAddProfile.clicked.connect(self.AddProfile)

        self.pushButtonUpdateProfile = QtWidgets.QPushButton(self)
        self.pushButtonUpdateProfile.setGeometry(
            QtCore.QRect(310, 475, 181, 51))
        self.pushButtonUpdateProfile.setObjectName("pushButtonAddProfile")
        self.pushButtonUpdateProfile.setText("Обновить профиль")
        self.pushButtonUpdateProfile.clicked.connect(self.UpdateProfile)

        self.pushButtonDelProfile = QtWidgets.QPushButton(self)
        self.pushButtonDelProfile.setGeometry(QtCore.QRect(310, 530, 181, 51))
        self.pushButtonDelProfile.setObjectName("pushButtonDelProfile")
        self.pushButtonDelProfile.setText("Удалить профиль")
        self.pushButtonDelProfile.clicked.connect(self.DelProfile)

        self.CameraStream = QVideoWidget(self)
        self.CameraStream.setObjectName("videoCameraStream")
        self.CameraStream.setGeometry(QtCore.QRect(610, 25, 180, 200))

        self.device = QCamera.availableDevices()[0]
        self.camera = QCamera(self.device)
        self.camera.setViewfinder(self.CameraStream)
        self.camera.setCaptureMode(QCamera.CaptureStillImage)
        self.imageCapture = QCameraImageCapture(self.camera)
        self.imageCapture.imageSaved.connect(self.AddPhotoEnd)
        self.camera.start()

        self.pushButtonAddPhoto = QtWidgets.QPushButton(self)
        self.pushButtonAddPhoto.setObjectName("pushButtonAddPhoto")
        self.pushButtonAddPhoto.setText("Добавить фото")
        self.pushButtonAddPhoto.setGeometry(QtCore.QRect(610, 225, 181, 51))
        self.pushButtonAddPhoto.clicked.connect(self.AddPhotoBegin)

        self.pushButtonDelPhoto = QtWidgets.QPushButton(self)
        self.pushButtonDelPhoto.setObjectName("pushButtonDelPhoto")
        self.pushButtonDelPhoto.setText("Удалить фото")
        self.pushButtonDelPhoto.setGeometry(QtCore.QRect(610, 280, 181, 51))
        self.pushButtonDelPhoto.clicked.connect(self.DelPhoto)

        self.LoadProfiles()

# загружаем список сотрудников

    def LoadProfiles(self):
        self.listViewHumans.clear()
        AllProfiles = self._Client.get_profiles_ids()['result']
        if len(AllProfiles) != 0:
            for profile in AllProfiles:
                item = QtWidgets.QListWidgetItem()
                #item.setText(str(profile))
                if (GetInfo(str(profile)) != None):
                    item.setText(GetInfo(str(profile))["name"])
                item.setToolTip(str(profile))

                AllPhoto = self._Client.get_profile_images_ids(
                    profile)['result']
                if len(AllPhoto) != 0:
                    FileName = "img/" + str(profile) + '-' + str(
                        AllPhoto[0]) + '.jpg'
                    self._Client.get_profile_image(profile, AllPhoto[0],
                                                   FileName)
                    item.setIcon(QtGui.QIcon(FileName))
                self.listViewHumans.addItem(item)

    # загружаем профиль
    def LoadProfile(self, item):
        self.listViewPhotos.clear()
        #idProfile = int(item.text())
        idProfile = int(item.toolTip())
        AllPhoto = self._Client.get_profile_images_ids(idProfile)['result']
        for photo in AllPhoto:
            FileName = "img/" + str(idProfile) + '-' + str(photo) + '.jpg'
            self._Client.get_profile_image(idProfile, photo, FileName)

            item = QtWidgets.QListWidgetItem()
            item.setText(str(photo))
            item.setIcon(QtGui.QIcon(FileName))
            self.listViewPhotos.addItem(item)
        infoProfile = JsonDataBase.GetInfo(idProfile)
        if infoProfile != None:
            self.lineName.setText(infoProfile['name'])
            self.lineTag.setText(infoProfile['tag'])
        else:
            self.lineName.setText("")
            self.lineTag.setText("")

    # добавляем профиль
    def AddProfile(self):
        profile_name = self.lineName.text()
        profile_post = self.lineTag.text()
        Id_Profile = self._Client.add_profile(profile_name,
                                              '01.01.1111',
                                              'm',
                                              tags="").pop('result')
        JsonDataBase.AddInfo(Id_Profile, profile_name, '01.01.1111', "m",
                             profile_post)
        self.LoadProfiles()

    # обновляем профиль
    def UpdateProfile(self):
        Id_Profile = self.listViewHumans.currentItem().toolTip()
        profile_name = self.lineName.text()
        profile_post = self.lineTag.text()
        if (JsonDataBase.GetInfo(Id_Profile) != None):
            JsonDataBase.UpdateInfo(Id_Profile,
                                    name=profile_name,
                                    tag=profile_post)
        else:
            JsonDataBase.AddInfo(Id_Profile,
                                 name=profile_name,
                                 tag=profile_post)
        self.LoadProfiles()

    # удаляем профиль
    def DelProfile(self):
        Id_Profile = self.listViewHumans.currentItem().toolTip()
        self._Client.delete_profile(Id_Profile)
        JsonDataBase.DelInfo(Id_Profile)
        self.LoadProfiles()

    # добавляем фото
    def AddPhotoBegin(self):
        if self.imageCapture.isReadyForCapture():
            imgName = os.getcwd() + "\img\currentPhoto.jpg"
            self.camera.searchAndLock()
            self.imageCapture.capture(imgName)
            self.camera.unlock()

    def AddPhotoEnd(self):
        print(0)
        imgName = os.getcwd() + "\img\currentPhoto.jpg"
        imgName0 = os.getcwd() + "\img\currentPhoto0.jpg"
        idProfile = int(self.listViewHumans.currentItem().toolTip())
        self._Client.get_aligned_faces(imgName, "img\currentPhoto")
        self._Client.enroll_profile_face(idProfile, imgName0)
        self.LoadProfile(self.listViewHumans.currentItem())

    # удаляем фото
    def DelPhoto(self):
        #Id_Profile = self.listViewHumans.currentItem().text()
        Id_Profile = self.listViewHumans.currentItem().toolTip()
        Id_Photo = self.listViewPhotos.currentItem().text()
        self._Client.delete_image(Id_Profile, Id_Photo)
        self.LoadProfile(self.listViewHumans.currentItem())
Esempio n. 9
0
class MainWindow(QWidget):
    face = Face()

    def __init__(self):
        super().__init__()
        self.start_ui()

    def start_ui(self):
        self.zui = Ui_zwin()
        self.zui.setupUi(self)
        self.zui.camera_label.setScaledContents(True)

        # 初始化信息
        self.zui.label_xuehao.setText("工号:")
        self.zui.label_mingzi.setText("姓名:")
        self.zui.label_time.setText("签到时间:")

        # 查询按钮
        self.zui.cxbtn.clicked.connect(self.cx_ui)
        # 注册按钮
        self.zui.zcbtn.clicked.connect(self.zq_zc)
        # 签到按钮
        self.zui.qdbtn.clicked.connect(self.zq_qd)
        # 删除按钮
        self.zui.del_btn.clicked.connect(self.del_yg)
        # 导出按钮
        self.zui.out_btn.clicked.connect(self.out_ex)

        # 摄像头控制
        camera = QCamera(self)  # 创建摄像头
        cameraviewfinder = QCameraViewfinder(self.zui.camera_label)  # 创建显示窗口
        cameraviewfinder.resize(752, 420)
        self.cameraImageCapture = QCameraImageCapture(camera)  # 绑定获取的摄像头
        self.cameraImageCapture.setCaptureDestination(
            QCameraImageCapture.CaptureToFile)  # 获取数据类型
        camera.setCaptureMode(QCamera.CaptureStillImage)
        camera.setViewfinder(cameraviewfinder)  # 绑定窗口
        camera.start()  # 开启摄像头

    def out_ex(self):
        """
        导出考勤记录
        :return:
        """
        wk = Workbook()
        wb = wk.active
        wb.append(['姓名', '工号', '打卡时间', '状态'])
        result = obj.get_list("select name, no, ctime, st from qds", [])
        for i in result:
            wb.append(i)
        wk.save(r'kaoqing.xlsx')
        return QMessageBox.information(self, "提示", '导出成功...', QMessageBox.Yes,
                                       QMessageBox.Yes)

    def del_yg(self):
        """
        删除员工
        :return:
        """
        gh = self.zui.gonghao.text()
        if not gh:
            return QMessageBox.information(self, "提示", '请填写工号...',
                                           QMessageBox.Yes, QMessageBox.Yes)
        if obj.get_list('select no from user where no=%s', [
                gh,
        ]):
            obj.modify('delete from user where no=%s', [
                gh,
            ])
            return QMessageBox.information(self, "提示", '删除成功...',
                                           QMessageBox.Yes, QMessageBox.Yes)
        else:
            return QMessageBox.information(self, "提示", '删除失败...',
                                           QMessageBox.Yes, QMessageBox.Yes)

    def zc(self, xx, image):
        """
        注册
        :return:
        """
        self.cameraImageCapture.disconnect()
        pximap = QPixmap.fromImage(image)  # 获取摄像头图片
        pximap.save('image.jpg')  # 保存图片

        name = self.zui.mingzi.text()
        no = self.zui.xuehao.text()

        if not name or not no:
            QMessageBox.information(self, "提示", '请填写工号跟姓名...', QMessageBox.Yes,
                                    QMessageBox.Yes)
            return self.zui.zcbtn.setDisabled(False)

        path = 'image.jpg'
        print(103)
        face_token = self.face.C_addFace(name, no, path)
        print(105, face_token)

        if face_token:
            try:
                obj.modify(
                    "insert into user(name,no,face_token) values (%s,%s,%s)", [
                        name,
                        no,
                        face_token,
                    ])
            except Exception as e:
                obj.rollback()
                self.zui.zcbtn.setDisabled(False)
                return QMessageBox.information(self, "提示", '用户已存在...',
                                               QMessageBox.Yes,
                                               QMessageBox.Yes)
            QMessageBox.information(self, "提示", '注册成功...', QMessageBox.Yes,
                                    QMessageBox.Yes)
            obj.modify("insert into qds_month(name,no,st_no) values (%s,%s,0)",
                       [
                           name,
                           no,
                       ])
        else:
            QMessageBox.information(self, "提示", '注册失败...', QMessageBox.Yes,
                                    QMessageBox.Yes)
        self.zui.zcbtn.setDisabled(False)

    def qd(self, xx, image):
        """
        签到
        :return:
        """
        self.cameraImageCapture.disconnect()
        pximap = QPixmap.fromImage(image)  # 获取摄像头图片
        pximap.save('image.jpg')  # 保存图片

        t = self.face.C_searchFace('image.jpg')
        if t:
            no = t[1]
            name = t[0]
            face_token = t[2]

            res = obj.get_list("select no from user where face_token=%s", [
                face_token,
            ])
            if len(res) <= 0:
                QMessageBox.information(self, "提示", '数据库无此人信息...',
                                        QMessageBox.Yes, QMessageBox.Yes)
                return self.zui.qdbtn.setDisabled(False)
            ctime = datetime.datetime.today().strftime('%Y-%m-%d %H:%M:%S')
            self.zui.label_xuehao.setText("工号:" + str(no))
            self.zui.label_mingzi.setText("姓名:" + str(name))
            self.zui.label_time.setText("签到时间:" + ctime)
            hour = datetime.datetime.today().hour
            st = '异常'
            if hour < 8 or hour > 17:
                st = '正常'
            # 执行sql语句
            obj.modify(
                "insert into qds(name,no,ctime,st) values (%s,%s,%s,%s)", [
                    name,
                    no,
                    ctime,
                    st,
                ])
            QMessageBox.information(self, "提示", '签到成功...', QMessageBox.Yes,
                                    QMessageBox.Yes)
        else:
            QMessageBox.information(self, "提示", '查无此人...', QMessageBox.Yes,
                                    QMessageBox.Yes)

        self.zui.qdbtn.setDisabled(False)

    def zq_zc(self):
        """注册抓取"""
        self.zui.zcbtn.setDisabled(True)
        self.cameraImageCapture.imageCaptured.connect(self.zc)  # 截取图片后链接显示方法
        self.cameraImageCapture.capture()  # 抓取方法

    def zq_qd(self):
        """签到抓取"""
        self.zui.qdbtn.setDisabled(True)
        self.cameraImageCapture.imageCaptured.connect(self.qd)  # 截取图片后链接显示方法
        self.cameraImageCapture.capture()  # 抓取方法

    def cx_ui(self):
        # 查询窗口
        self.cxui = Ui_cx()
        self.cxw = QDialog()
        self.cxui.setupUi(self.cxw)

        # 设置表格
        self.cxui.tableWidget.horizontalHeader().setStretchLastSection(False)
        self.cxui.tableWidget.setColumnWidth(0, 120)
        self.cxui.tableWidget.setColumnWidth(1, 120)
        # self.cxui.tableWidget.setColumnWidth(2, 100)
        self.cxui.tableWidget.horizontalHeader().setSectionResizeMode(
            0, QHeaderView.Stretch)
        self.cxui.tableWidget.horizontalHeader().setSectionResizeMode(
            1, QHeaderView.Stretch)
        self.cxui.tableWidget.horizontalHeader().setSectionResizeMode(
            2, QHeaderView.Stretch)
        self.cxui.tableWidget.setRowCount(0)  # 设置行=0
        self.cxui.tableWidget.clearContents()  # 清除内容

        # 查询按钮
        self.cxui.btn_cx.disconnect()
        self.cxui.btn_cx.clicked.connect(self.cx)
        self.cxw.exec_()

    def cx(self):
        """查询数据"""
        self.cxui.tableWidget.setRowCount(0)  # 设置行=0
        self.cxui.tableWidget.clearContents()  # 清楚内容
        no = self.cxui.xuehao_cx.text()
        name = self.cxui.mingzi_cx.text()
        print(no, name, 'xxxxxx')
        if name == 'admin':
            data = obj.get_list(
                "select name, no, ctime, st_no from qds_month order by st_no desc",
                [])
            if len(data) <= 0:
                return QMessageBox.information(self, "提示", '查询无记录...',
                                               QMessageBox.Yes,
                                               QMessageBox.Yes)
            for k, i in enumerate(data):
                name = i[0]
                no = i[1]
                ctime = i[2]
                st = i[3]
                self.cxui.tableWidget.insertRow(k)
                self.cxui.tableWidget.setItem(k, 0, QTableWidgetItem(str(no)))
                self.cxui.tableWidget.item(k,
                                           0).setTextAlignment(Qt.AlignCenter)
                self.cxui.tableWidget.setItem(k, 1,
                                              QTableWidgetItem(str(name)))
                self.cxui.tableWidget.item(k,
                                           1).setTextAlignment(Qt.AlignCenter)
                self.cxui.tableWidget.setItem(k, 2,
                                              QTableWidgetItem(str(ctime)))
                self.cxui.tableWidget.item(k,
                                           2).setTextAlignment(Qt.AlignCenter)
                self.cxui.tableWidget.setItem(k, 3, QTableWidgetItem(str(st)))
                self.cxui.tableWidget.item(k,
                                           3).setTextAlignment(Qt.AlignCenter)
                print(i)
            return
        if not no and not name:
            time = datetime.datetime.now()
            sql = "select name, no, ctime, st from qds where st = '异常' " + 'order by ctime desc limit 7'
            print(sql)
            data = obj.get_list(sql, [])
            print(data)
            if len(data) <= 0:
                return QMessageBox.information(self, "提示", '查询无记录...',
                                               QMessageBox.Yes,
                                               QMessageBox.Yes)
            for k, i in enumerate(data):
                name = i[0]
                no = i[1]
                ctime = i[2]
                st = i[3]
                print(type(ctime))
                now = str(ctime)
                cur = str(time)
                now = now[:10]
                cur = cur[:10]
                if now != cur:
                    continue
                self.cxui.tableWidget.insertRow(k)
                self.cxui.tableWidget.setItem(k, 0, QTableWidgetItem(str(no)))
                self.cxui.tableWidget.item(k,
                                           0).setTextAlignment(Qt.AlignCenter)
                self.cxui.tableWidget.setItem(k, 1,
                                              QTableWidgetItem(str(name)))
                self.cxui.tableWidget.item(k,
                                           1).setTextAlignment(Qt.AlignCenter)
                self.cxui.tableWidget.setItem(k, 2,
                                              QTableWidgetItem(str(ctime)))
                self.cxui.tableWidget.item(k,
                                           2).setTextAlignment(Qt.AlignCenter)
                self.cxui.tableWidget.setItem(k, 3, QTableWidgetItem(str(st)))
                self.cxui.tableWidget.item(k,
                                           3).setTextAlignment(Qt.AlignCenter)
                print(i)
            return
            #return QMessageBox.information(self, "提示", '请出入查询条件...', QMessageBox.Yes, QMessageBox.Yes)
        s = ''
        if no:
            s += "and no like '%%{}%%'".format(no, )
        if name:
            s += "and name like '%%{}%%'".format(name, )
        sql = "select name, no, ctime,st from qds where 1=1" + ' ' + s + 'order by ctime desc limit 7'
        print(sql)
        data = obj.get_list(sql, [])
        if len(data) <= 0:
            return QMessageBox.information(self, "提示", '查询无记录...',
                                           QMessageBox.Yes, QMessageBox.Yes)
        for k, i in enumerate(data):
            name = i[0]
            no = i[1]
            ctime = i[2]
            st = i[3]
            self.cxui.tableWidget.insertRow(k)
            self.cxui.tableWidget.setItem(k, 0, QTableWidgetItem(str(no)))
            self.cxui.tableWidget.item(k, 0).setTextAlignment(Qt.AlignCenter)
            self.cxui.tableWidget.setItem(k, 1, QTableWidgetItem(str(name)))
            self.cxui.tableWidget.item(k, 1).setTextAlignment(Qt.AlignCenter)
            self.cxui.tableWidget.setItem(k, 2, QTableWidgetItem(str(ctime)))
            self.cxui.tableWidget.item(k, 2).setTextAlignment(Qt.AlignCenter)
            self.cxui.tableWidget.setItem(k, 3, QTableWidgetItem(str(st)))
            self.cxui.tableWidget.item(k, 3).setTextAlignment(Qt.AlignCenter)
            print(i)
Esempio n. 10
0
class CameraMainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        uic.loadUi('MainWin.ui', self)
        self.setWindowTitle('CamPaint')
        self.setWindowIcon(QIcon('main_icon.ico'))
        self.setCentralWidget(self.tabWidget)
        # Загружаем камеру, холст, sql файл и задаем цвета кнопок
        self.load_cam()
        self.load_painter()
        self.load_sql()
        self.load_colors()

    def load_cam(self):
        self.cam_page.setLayout(self.cam_page_lay)
        self.error_cam.hide()
        self.camera = QCameraInfo.defaultCamera()
        # Проверяем, что камера сущетсвует
        # Если нет, то переключаемся на вторую вкладку
        if self.camera.isNull():
            dialog = QErrorMessage()
            dialog.setWindowTitle('Warning')
            dialog.showMessage(
                'Not enough cameras, the app will only be available in drawing mode'
            )
            dialog.exec()
            self.error_cam.show()
            self.cam_page.setEnabled(False)
            self.tabWidget.setCurrentIndex(1)
        # Если да, то на первую
        else:
            self.tabWidget.setCurrentIndex(0)
            self.camera = QCamera(self.camera)
            self.view_cam = QCameraViewfinder(self)
            self.view_cam.setMediaObject(self.camera)
            self.view_cam.setAutoFillBackground(True)
            self.camera.setViewfinder(self.view_cam)
            self.box_lay = QVBoxLayout(self)
            self.box_lay.addWidget(self.view_cam)
            self.scrolling.setLayout(self.box_lay)
            # Запускаем камеру
            self.camera.start()
            # Подвязываем кнопку к слоту со снимком
            self.bt_cam.clicked.connect(self.make_ph)
            # Можно зумить фотографию
            self.zoom.valueChanged.connect(self.zoom_pict)

    def make_ph(self):
        self.camera.setCaptureMode(QCamera.CaptureStillImage)
        self.capt = QCameraImageCapture(self.camera)
        # Останавливаем съемку
        self.camera.searchAndLock()
        # Вызываем диалог и иохранением файла
        dial = QFileDialog.getSaveFileName(
            self, 'Save file', '',
            'Картинка (*.jpg);;Картинка (*.png);;Все файлы (*)')[0]
        if dial:
            self.capt.capture(dial)
            self.camera.unlock()

    def zoom_pict(self, value):
        # Вычисляем зум камеры по функции zoom=1.0 + value * 3 / 99
        # 1.0 - обязательный параметр
        QCameraFocus.zoomTo(self.camera.focus(), 1.0 + value * 3 / 99, 1.0)

    def load_painter(self):
        # Загружаем холст
        self.paint_page.setLayout(self.paint_page_lay)
        # Текущий цвет - черный, ширина кисти - 10
        self.now_col = QColor(0, 0, 0)
        self.now_width = 10
        self.point_width.setValue(10)
        # Подвязываем кнопку с изменением ширины кисти к соответсвующему слоту
        self.point_width.valueChanged.connect(self.change_width)
        # Создаем холст как экземпляр класса Canvas из доп.модуля Canvas
        self.canvas = Canvas.Canvas(self.main_paint_widg)
        self.canvas.move(1, 1)
        self.canvas.resize(self.main_paint_widg.width() - 1,
                           self.main_paint_widg.height() - 1)
        print(self.main_paint_widg.size(), self.canvas.size(),
              self.border_lab.size())
        # Устанавливаем границы рамки
        self.border_lab.setStyleSheet(
            'border-style: solid; border-width: 2px; border-color: black;')
        self.canvas.setStyleSheet('background-color: white;')
        # Устанавливаем сильный фокус для перехвата всех событий
        # клавиатуры и мыши
        self.setFocusPolicy(Qt.StrongFocus)
        # Подвязываем действия из меню к слотам
        self.actionSave.triggered.connect(self.save_file)
        self.actionSave_as.triggered.connect(self.save_as_file)
        self.actionOpen.triggered.connect(self.open_file)
        self.actionReference.triggered.connect(self.open_reference)
        # и кнопку очистки холста, а также задания цвета кисти
        self.bt_clear.clicked.connect(self.clear_canvas)
        self.bt_set_color.clicked.connect(self.set_color_with_bt)
        # Имя файла изначально не задано, файл не сохранен
        self.file_name = ''
        self.saved = False
        self.resizeEvent(QResizeEvent(self.size(), self.size()))

    def change_width(self, value):
        self.now_width = value

    def keyPressEvent(self, event):
        # Обрабатываем события клавитатуры
        if int(event.modifiers()) == Qt.CTRL and event.key() == Qt.Key_Z:
            # Функция 'назад', удаляем все объекты, которые нарисовали
            if self.canvas.obj:
                del self.canvas.obj[-1]
                self.canvas.update()
        elif int(event.modifiers()) == Qt.CTRL and event.key() == Qt.Key_S:
            # Функция 'сохранить', сохраняем файл, если есть изменения
            if self.canvas.obj:
                self.save_file()
        elif int(event.modifiers()) == Qt.CTRL and event.key() == Qt.Key_O:
            # Функция 'открыть', открываем файл
            self.open_file()
        elif int(event.modifiers()) == Qt.CTRL and event.key() == Qt.Key_H:
            # Функция 'справка', открываем справку
            self.open_reference()

    def resizeEvent(self, event):
        # При изменении размеров окна, устанавливаем соответствующие размеры холста и рамки
        self.canvas.resize(self.main_paint_widg.width() - 1,
                           self.main_paint_widg.height() - 1)
        self.border_lab.resize(self.main_paint_widg.width(),
                               self.main_paint_widg.height())

    def save_as_file(self):
        # Сохранение файла как
        dial = \
            QFileDialog.getSaveFileName(self, 'Save file as', '', 'Картинка (*.jpg);;Картинка (*.png);;Все файлы (*)')[
                0]
        if dial:
            # Захватываем изображжение с холста и сохраняем
            pixmap = QPixmap(self.canvas.grab())
            pixmap.save(dial)
            # Сохраняем имя файла в переменной self.file_name, чтобы использовать в функции save_file
            # Очищаем нарисованные объекты, так как уже их сохранили
            self.file_name = dial
            self.saved = True
            self.canvas.obj = []

    def save_file(self):
        # Если имя файла выбрано, просто сохраняем
        if self.file_name:
            pixmap = QPixmap(self.canvas.grab())
            pixmap.save(self.file_name)
            self.saved = True
            self.canvas.obj = []
        # В ином случае, сохраняем как
        else:
            self.save_as_file()

    def open_file(self):
        # Открываем новый файл
        dial = QFileDialog.getOpenFileName(
            self, 'Open file', '',
            'Картинка (*.jpg);;Картинка (*.png);;Все файлы (*)')[0]
        if dial:
            # Если старый файл не сохранен, предлагаем сохранить его
            if self.canvas.obj and not self.saved:
                dial2 = Dialogs.Message()
                res = dial2.exec()
                if res == dial2.Save:
                    self.save_file()
                if res == dial2.Cancel:
                    pass
            # Сохраняем новое имя файла, вызываем функцию open_file в экземпляре холста
            self.file_name = dial
            self.canvas.obj = []
            self.canvas.open_file()

    def open_reference(self):
        dial = Dialogs.Reference()
        dial.exec()

    def clear_canvas(self):
        # Очищаем нарисованные объекты
        self.canvas.obj.clear()
        self.canvas.update()

    def set_color(self, color):
        # Устанавливаем текущий цвет
        self.now_col = color
        red, green, blue = color.red(), color.green(), color.blue()
        # Подключаемся к базе данных в папке проекта
        # и добавляем его к любимым цветам пользователя
        con = sqlite3.connect('own_colors_db.db')
        cur = con.cursor()
        colors = cur.execute(
            f'''SELECT * from colors WHERE red={red} and green={green} and blue={blue}'''
        ).fetchall()
        if colors:
            id = colors[0][0]
            cur.execute(
                f'''UPDATE colors SET counts=counts + 1 WHERE id={id}''')
        else:
            last_id = cur.execute(
                f'''SELECT id from colors''').fetchall()[-1][0]
            cur.execute(
                f'''INSERT INTO colors VALUES ({last_id + 1}, {red}, {green}, {blue}, 1)'''
            )
        con.commit()
        con.close()

    def set_color_with_bt(self):
        # Слот для кнопки выбора цвета
        color = QColorDialog.getColor()
        self.set_color(color)

    def closeEvent(self, event):
        # Закрываем файл, обнуляя значение зума
        self.zoom.setValue(1)
        # И предлагаем сохранить файл, если он не сохранен
        if self.canvas.obj and not self.saved:
            dial = Dialogs.Message()
            res = dial.exec()
            if res == dial.Save:
                self.save_file()
            if res == dial.Cancel:
                event.ignore()

    def load_sql(self):
        # При отсутствии цветов в базе данных(в первом открытии приложения)
        # добавляем в базу данных новый цвет - черный
        con = sqlite3.connect('own_colors_db.db')
        cur = con.cursor()
        len_sql = len(cur.execute(f'''SELECT * from colors''').fetchall())
        if len_sql == 0:
            cur.execute('''INSERT INTO colors VALUES (1, 0, 0, 0, 1)''')
        con.commit()
        con.close()

    def load_colors(self):
        # Загружаем цвета в кнопки любимых цветов пользователя
        colors = []
        con = sqlite3.connect('own_colors_db.db')
        cur = con.cursor()
        ex_colors = sorted(cur.execute(
            '''SELECT red, green, blue, counts from colors''').fetchall(),
                           key=lambda i: i[3])[:21]
        ex_colors = [(i[0], i[1], i[2]) for i in ex_colors]
        colors.extend(ex_colors)
        # Если цветов недостаточно, заполняем кнопки случайными цветами
        # вдруг какой-нибудь из них ползователю понравится
        if len(colors) < 20:
            for i in range(20 - len(colors)):
                new_color = (randrange(256), randrange(256), randrange(256))
                while new_color in colors:
                    new_color = (randrange(256), randrange(256),
                                 randrange(256))
                colors.append(new_color)
        # Сохраняем цвета кнопок в словарь, где ключ - кнопка, значение - цвет
        # А также подключаем кнопки к слоту и изменением цвета
        self.bt_colors_dict = {}
        for i in range(4):
            for j in range(5):
                exec(
                    f'self.bt{i}{j}.setStyleSheet("background:rgb({colors[0][0]}, {colors[0][1]}, {colors[0][2]});")'
                )
                color = QColor(colors[0][0], colors[0][1], colors[0][2])
                exec(f'self.bt_colors_dict[self.bt{i}{j}] = color')
                exec(f'self.bt{i}{j}.clicked.connect(self.set_color_with_bts)')
                del colors[0]

    def set_color_with_bts(self):
        # Слот для установки цвета кисти
        self.set_color(self.bt_colors_dict[self.sender()])
Esempio n. 11
0
# -*- coding: utf-8 -*-
"""
Spyder Editor

This is a temporary script file.
"""

from PyQt5.QtMultimedia import QCamera, QCameraImageCapture
from PyQt5 import QtMultimediaWidgets

cm = QCamera()
viewfinder = QtMultimediaWidgets.QCameraViewfinder()
viewfinder.show()
cm.setViewfinder(viewfinder)

cp = QCameraImageCapture(cm)
cm.setCaptureMode(cm.CaptureStillImage)
cm.start()
cm.searchAndLock()

cp.capture()

cm.unlock()
Esempio n. 12
0
class Camera(QMainWindow):
    def __init__(self):
        super().__init__()

        self.initializeUI()

    def initializeUI(self):
        """
        Initialize the window and display its contents to the screen
        """
        self.setGeometry(100, 100, 600, 400)
        self.setWindowTitle('12.2 – Camera GUI')

        self.setupWindows()

        self.show()

    def setupWindows(self):
        """
        Set up QMdiArea parent and subwindows.
        Add available cameras on local system as items to 
        list widget.
        """
        # Create images directory if it does not already exist
        path = 'images'
        if not os.path.exists(path):
            os.makedirs(path)

        # Set up list widget that will display identified
        # cameras on your computer.
        picture_label = QLabel("Press 'Spacebar' to take pictures.")
        camera_label = QLabel("Available Cameras")
        self.camera_list_widget = QListWidget()
        self.camera_list_widget.setAlternatingRowColors(True)

        # Add availableCameras to a list to be displayed in
        # list widget. Use QCameraInfo() to list available cameras.
        self.cameras = list(QCameraInfo().availableCameras())
        for camera in self.cameras:
            self.list_item = QListWidgetItem()
            self.list_item.setText(camera.deviceName())
            self.camera_list_widget.addItem(self.list_item)

        # Create button that will allow user to select camera
        choose_cam_button = QPushButton("Select Camera")
        choose_cam_button.clicked.connect(self.selectCamera)

        # Create child widgets and layout for camera controls subwindow
        controls_gbox = QGroupBox()
        controls_gbox.setTitle("Camera Controls")

        v_box = QVBoxLayout()
        v_box.addWidget(picture_label, alignment=Qt.AlignCenter)
        v_box.addWidget(camera_label)
        v_box.addWidget(self.camera_list_widget)
        v_box.addWidget(choose_cam_button)

        controls_gbox.setLayout(v_box)

        controls_sub_window = QMdiSubWindow()
        controls_sub_window.setWidget(controls_gbox)
        controls_sub_window.setAttribute(Qt.WA_DeleteOnClose)

        # Create view finder subwindow
        self.view_finder_window = QMdiSubWindow()
        self.view_finder_window.setWindowTitle("Camera View")
        self.view_finder_window.setAttribute(Qt.WA_DeleteOnClose)

        # Create QMdiArea widget to manage subwindows
        mdi_area = QMdiArea()
        mdi_area.tileSubWindows()
        mdi_area.addSubWindow(self.view_finder_window)
        mdi_area.addSubWindow(controls_sub_window)

        # Set mdi_area widget as the central widget of main window
        self.setCentralWidget(mdi_area)

    def setupCamera(self, cam_name):
        """
        Create and setup camera functions.
        """
        for camera in self.cameras:
            # Select camera by matching cam_name to one of the
            # devices in the cameras list.
            if camera.deviceName() == cam_name:
                self.cam = QCamera(camera)  # Construct QCamera device

                # Create camera viewfinder widget and add it to the
                # view_finder_window.
                self.view_finder = QCameraViewfinder()
                self.view_finder_window.setWidget(self.view_finder)
                self.view_finder.show()

                # Sets the view finder to display video
                self.cam.setViewfinder(self.view_finder)

                # QCameraImageCapture() is used for taking
                # images or recordings.
                self.image_capture = QCameraImageCapture(self.cam)

                # Configure the camera to capture still images.
                self.cam.setCaptureMode(QCamera.CaptureStillImage)
                self.cam.start()  # Slot to start the camera
            else:
                pass

    def selectCamera(self):
        """
        Slot for selecting one of the available cameras displayed 
        in list widget. 
        """
        try:
            if self.list_item.isSelected():
                camera_name = self.list_item.text()
                self.setupCamera(camera_name)
            else:
                print("No camera selected.")
                pass
        except:
            print("No cameras detected.")

    def keyPressEvent(self, event):
        """
        Handle the key press event so that the camera takes images.
        """
        if event.key() == Qt.Key_Space:
            try:
                self.cam.searchAndLock()
                self.image_capture.capture("images/")
                self.cam.unlock()
            except:
                print("No camera in viewfinder.")
Esempio n. 13
0
class LiveFeedWidget(QGraphicsView):
    class _State(Enum):
        Init = "Init"
        Idle = "Idle"
        Preparing = "Preparing"
        WaitingForCapture = "WaitingForCapture"

    error = pyqtSignal(str)
    image_captured = pyqtSignal(QImage)
    initialized = pyqtSignal()

    def __init__(
        self,
        camera: Camera,
        is_mirrored: bool,
        mask: Mask,
        parent=None,
    ):
        super().__init__(parent=parent)
        self._is_mirrored = is_mirrored
        self._mask = mask

        self._state = LiveFeedWidget._State.Init

        self._video_item = QGraphicsVideoItem()
        # I think this is the size in pixels on the screen?
        self._video_item.setSize(QSizeF(self._mask.size))
        # TODO I think this will not draw centrally?  If not should fix this
        self._video_item.setAspectRatioMode(Qt.KeepAspectRatioByExpanding)
        if self._is_mirrored:
            self._video_item.setTransform(QTransform().scale(-1, 1))

        self.setMask(self._mask.clip_region)

        self._scene: OverlayTextGraphicsScene = OverlayTextGraphicsScene(
            self._mask.size)
        self._scene.addItem(self._video_item)
        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.setScene(self._scene)

        # Setup camera
        #
        self._camera = camera
        self._camera.setViewfinder(self._video_item)
        self._camera.setCaptureMode(QCamera.CaptureStillImage)
        self._camera.error.connect(self._on_camera_error)
        self._camera.statusChanged.connect(self._on_camera_status_changed)

        # Setup capture
        #
        self._capture = QCameraImageCapture(self._camera)
        self._capture.setCaptureDestination(
            QCameraImageCapture.CaptureToBuffer)
        self._capture.imageCaptured.connect(self._image_captured)
        self._capture.error.connect(self._on_capture_error)

        self._camera.start()

        logger.info("Camera started")

    def set_overlay_text(self, text: str):
        self._scene.set_overlay_text(text)

    def prepare(self):
        if self._state != LiveFeedWidget._State.Idle:
            logger.warning("Dropping call to prepare when in state: %s",
                           self._state)
        else:
            self._state = LiveFeedWidget._State.Preparing
            self._camera.searchAndLock()

    def trigger_capture(self):
        if self._state != LiveFeedWidget._State.Preparing:
            logger.warning(
                "Dropping call to trigger_capture when in state: %s",
                self._state)
        else:
            logger.debug("trigger_capture")
            self._state = LiveFeedWidget._State.WaitingForCapture
            self._capture.capture()

    # noinspection PyPep8Naming
    def _on_camera_error(self, QCamera_Error: int):
        self._state = LiveFeedWidget._State.Idle
        self.error.emit(f"Camera error, code: {QCamera_Error}")

    # noinspection PyPep8Naming
    def _on_capture_error(self,
                          p_int=None,
                          QCameraImageCapture_Error=None,
                          p_str=None):
        self._state = LiveFeedWidget._State.Idle
        self.error.emit(
            f"Capture error: {p_int} / {QCameraImageCapture_Error} / {p_str}")

    def _image_captured(self, id_: int, image: QImage):
        if self._state != LiveFeedWidget._State.WaitingForCapture:
            logger.warning("Dropping _image_captured when in state: %s",
                           self._state)
        self._state = LiveFeedWidget._State.Idle
        logger.debug("image captured: %s %s", id_, image)
        self._camera.unlock()

        # TODO If I don't unload and the reload the camera, gstreamer dies
        #  with CameraBin error: "Internal data stream error.", not sure why
        #  :(
        self._camera.unload()

        self.image_captured.emit(_mirror_if_necessary(image,
                                                      self._is_mirrored))

    def reload(self):
        # See comment on _image_captured
        self._camera.start()

    def _on_camera_status_changed(self, status):
        logger.debug("_on_camera_status_changed: %s", status)
        if status == QCamera.ActiveStatus:
            self._state = LiveFeedWidget._State.Idle
            self.initialized.emit()
Esempio n. 14
0
class AvatarWidget(QWizardPage):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setSubTitle(self.tr("<h2>Create Your Avatar</h2>"))

        vlayout = QVBoxLayout(self)

        labelLayout = QHBoxLayout()
        labelImage = QLabel()
        labelImage.setPixmap(
            QPixmap(":/data/images/preferences-desktop-personal.png"))
        labelImage.setMaximumSize(64, 64)
        labelLayout.addWidget(labelImage)

        label = QLabel(self)
        label.setWordWrap(True)
        label.setText(
            self.
            tr("<p>This screen helps you set your <strong>user picture</strong>. You can either choose an image from a \
        file or you can capture an image from your camera. Select an option from the <strong>options</strong> menu.</p>"
               ))
        labelLayout.addWidget(label)
        vlayout.addLayout(labelLayout)

        vlayout.addItem(
            QSpacerItem(20, 40, QSizePolicy.Preferred, QSizePolicy.Preferred))

        centerLayout = QHBoxLayout()
        centerLayout.addItem(
            QSpacerItem(40, 20, QSizePolicy.Preferred, QSizePolicy.Preferred))

        groupBox = QGroupBox()
        groupBox.setMaximumWidth(500)
        vlayout2 = QVBoxLayout(groupBox)
        hlayout = QHBoxLayout()

        comboBox = QComboBox()
        comboBox.setMinimumWidth(250)
        comboBox.addItems([self.tr("Options"), self.tr("Choose an image...")])

        #Camera control
        self.cameraInfo = None
        self.camera = None
        self.cameraImageCapture = None
        cameras = QCameraInfo.availableCameras()

        if len(cameras):
            self.cameraInfo = cameras[0]
            comboBox.addItem(self.tr("Camera ") + self.cameraInfo.deviceName())
            self.camera = QCamera(self.cameraInfo)
            self.camera.setCaptureMode(QCamera.CaptureStillImage)
            self.cameraImageCapture = QCameraImageCapture(self.camera)
            self.imageProcessing = self.camera.imageProcessing()
            self.imageProcessing.setWhiteBalanceMode(
                QCameraImageProcessing.WhiteBalanceSunlight)
            self.imageProcessing.setContrast(1)
            self.imageProcessing.setSaturation(1)
            self.imageProcessing.setSharpeningLevel(1)
            self.imageProcessing.setDenoisingLevel(1)
            #self.imageProcessing.setColorFilter(QCameraImageProcessing.ColorFilterWhiteboard) #FIXME Qt5.5
            self.cameraImageCapture.imageCaptured.connect(self.imageCapture)

        self.buttonCam = QPushButton()
        self.buttonCam.setText(self.tr("Capture"))
        self.buttonCam.setIcon(QIcon(":/data/images/webcamreceive.png"))
        self.buttonCam.setVisible(False)

        self.buttonReplay = QPushButton()
        self.buttonReplay.setText(self.tr("Recapture"))
        self.buttonReplay.setIcon(QIcon(":/data/images/view-refresh.png"))
        self.buttonReplay.setVisible(False)

        hlayout.addWidget(comboBox)
        hlayout.addItem(
            QSpacerItem(300, 20, QSizePolicy.Preferred, QSizePolicy.Preferred))
        hlayout.addWidget(self.buttonCam)
        hlayout.addWidget(self.buttonReplay)

        vlayout2.addLayout(hlayout)

        hlayout2 = QHBoxLayout()

        hlayout2.addItem(
            QSpacerItem(40, 20, QSizePolicy.Preferred, QSizePolicy.Preferred))

        self.cameraLabel = QLabel()
        self.cameraLabel.setScaledContents(True)
        self.cameraLabel.setStyleSheet("background-color: black;")
        self.cameraLabel.setMinimumSize(320, 240)
        self.cameraLabel.setMaximumSize(320, 240)

        self.cameraView = QCameraViewfinder()
        self.cameraView.setMaximumSize(320, 240)
        self.cameraView.setMinimumSize(320, 240)
        self.cameraView.hide()

        hlayout2.addWidget(self.cameraLabel)
        hlayout2.addWidget(self.cameraView)

        hlayout2.addItem(
            QSpacerItem(40, 20, QSizePolicy.Preferred, QSizePolicy.Preferred))
        vlayout2.addLayout(hlayout2)

        centerLayout.addWidget(groupBox)
        centerLayout.addItem(
            QSpacerItem(40, 20, QSizePolicy.Preferred, QSizePolicy.Preferred))
        vlayout.addLayout(centerLayout)
        vlayout.addItem(
            QSpacerItem(20, 40, QSizePolicy.Preferred, QSizePolicy.Preferred))

        comboBox.currentIndexChanged.connect(self.avatarSelect)
        self.buttonCam.clicked.connect(self.buttonCamChanged)
        self.buttonReplay.clicked.connect(self.buttonReplayChanged)

        self.userAvatar = None

    def avatarSelect(self, index):
        if index == 0:
            if self.camera != None:
                self.camera.stop()
            self.buttonReplay.hide()
            self.buttonCam.hide()
            self.cameraView.hide()
            self.cameraLabel.show()
        elif index == 1:
            if self.camera != None:
                self.camera.stop()
            self.userAvatar = None
            self.buttonReplay.hide()
            self.buttonCam.hide()
            self.cameraView.hide()
            self.cameraLabel.show()
            file_url, file_type = QFileDialog.getOpenFileName(
                self, self.tr("Choose Avatar"), QDir.homePath(),
                "Image (*.png *.jpg)")
            if file_url != "":
                p = QPixmap(file_url)
                self.cameraLabel.setPixmap(p)
                self.userAvatar = file_url
        elif index == 2:
            self.userAvatar = None
            self.cameraLabel.hide()
            self.cameraView.show()
            self.camera.setViewfinder(self.cameraView)
            self.camera.start()
            self.buttonCam.setVisible(True)
            self.buttonReplay.hide()

    def buttonCamChanged(self):
        self.buttonCam.hide()
        self.buttonReplay.show()
        self.camera.searchAndLock()
        self.cameraImageCapture.capture("/tmp/avatar.png")
        self.camera.unlock()
        self.userAvatar = "/tmp/avatar.png"

    def buttonReplayChanged(self):
        self.userAvatar = None
        self.buttonReplay.hide()
        self.buttonCam.show()
        self.camera.start()
        self.cameraLabel.hide()
        self.cameraView.show()

    def imageCapture(self, id, preview):
        pixmap = QPixmap.fromImage(preview)
        self.camera.stop()
        self.cameraView.hide()
        self.cameraLabel.show()
        self.cameraLabel.setPixmap(pixmap)

    def execute(self):
        if self.userAvatar:
            if os.path.exists(os.path.join(os.environ["HOME"], ".face.icon")):
                os.remove(os.path.join(os.environ["HOME"], ".face.icon"))
            shutil.copy(self.userAvatar,
                        os.path.join(os.environ["HOME"], ".face.icon"))
Esempio n. 15
0
class MainWindow(QMainWindow):
    def __init__(self):
        super(MainWindow, self).__init__()

        self.cameraInfo = QCameraInfo.defaultCamera()
        self.camera = QCamera(self.cameraInfo)
        self.camera.setCaptureMode(QCamera.CaptureStillImage)
        self.imageCapture = QCameraImageCapture(self.camera)
        self.imageCapture.imageCaptured.connect(self.imageCaptured)
        self.imageCapture.imageSaved.connect(self.imageSaved)
        self.currentPreview = QImage()

        toolBar = QToolBar()


        self.addToolBar(toolBar)

        fileMenu = self.menuBar().addMenu("&File")
        shutterIcon = QIcon("/Users/thethelafaltein/PycharmProjects/ResNetApplication/res/img/shutter.svg")
        self.takePictureAction = QAction(shutterIcon, "&Take Picture", self,
                                         shortcut="Ctrl+T",
                                         triggered=self.takePicture)
        self.takePictureAction.setToolTip("Take Picture")
        fileMenu.addAction(self.takePictureAction)
        toolBar.addAction(self.takePictureAction)

        exitAction = QAction(QIcon.fromTheme("application-exit"), "E&xit",
                             self, shortcut="Ctrl+Q", triggered=self.close)
        fileMenu.addAction(exitAction)

        aboutMenu = self.menuBar().addMenu("&About")
        aboutQtAction = QAction("About &Qt", self, triggered=qApp.aboutQt)
        aboutMenu.addAction(aboutQtAction)

        self.tabWidget = QTabWidget()
        self.setCentralWidget(self.tabWidget)


        self.cameraViewfinder = QCameraViewfinder()
        self.camera.setViewfinder(self.cameraViewfinder)
        self.tabWidget.addTab(self.cameraViewfinder, "Viewfinder")




        if self.camera.status() != QCamera.UnavailableStatus:
            name = self.cameraInfo.description()
            self.setWindowTitle("PySide2 Camera Example (" + name + ")")
            self.statusBar().showMessage("Starting: '" + name + "'", 5000)
            self.camera.start()
        else:
            self.setWindowTitle("Object classifier")
            self.takePictureAction.setEnabled(False)
            self.statusBar().showMessage("Camera unavailable", 5000)

    def nextImageFileName(self):
        picturesLocation = QStandardPaths.writableLocation(QStandardPaths.PicturesLocation)
        dateString = QDate.currentDate().toString("yyyyMMdd")
        pattern = picturesLocation + "/pyside2_camera_" + dateString + "_{:03d}.jpg"
        n = 1
        while True:
            result = pattern.format(n)
            if not os.path.exists(result):
                return result
            n = n + 1
        return None


    def predicition(self,filename):

        model = resnet50.ResNet50()

        img = image.load_img(filename,
                             target_size=(224, 224))


        x = image.img_to_array(img)


        x = np.expand_dims(x, axis=0)


        x = resnet50.preprocess_input(x)


        predictions = model.predict(x)

        predicted_classes = resnet50.decode_predictions(predictions, top=9)

        top_value = []

        for imagenet_id, name, likelihood in predicted_classes[0]:
            top_value.append(name)

        if len(top_value)>0:
            return top_value[0]
        else:
            return "Unknown"


    def createAudio(self,text):

        language = 'en'

        myobj = gTTS(text=text, lang=language, slow=False)

        myobj.save(text+".mp3")

        return text+".mp3"


    def takePicture(self):
        self.currentPreview = QImage()
        self.camera.searchAndLock()
        self.imageCapture.capture(self.nextImageFileName())
        self.camera.unlock()

    def imageCaptured(self, id, previewImage):
        self.currentPreview = previewImage

    def imageSaved(self, id, fileName):

        predicitionName = self.predicition(fileName)

        audiofile = self.createAudio(predicitionName)

        index = self.tabWidget.count()

        imageView = ImageView(self.currentPreview, fileName,audiofile)

        self.tabWidget.addTab(imageView, predicitionName)
        self.tabWidget.setCurrentIndex(index)
Esempio n. 16
0
class Window(QWidget):

    _Constant_recognition = 0.8

    
    # конструктор формы
    def __init__(self):
        super().__init__()
        self._Client = Biometric_Client(url='https://expasoft.com', port=2133,
                                        subscription_key='9fc9474b4bd16b492276eee41763a3cb')
        self.imgName = os.getcwd() + "\img\currentPhoto.jpg"
        self.imgName0 = os.getcwd() + "\img\currentPhoto0.jpg"
        self.imgName1 = os.getcwd() + "\img\dbPhoto0.jpg"
        self.setObjectName("FormMain")
        self.setWindowTitle("БиоСКУД Watchman")
        self.resize(1024, 600)

        self.groupBoxCamera = QtWidgets.QGroupBox(self)
        self.groupBoxCamera.setObjectName("groupBoxCamera")
        self.groupBoxCamera.setTitle("")
        self.groupBoxCamera.setGeometry(QtCore.QRect(10, 10, 500, 371))
        
        self.labelCameraTitle = QtWidgets.QLabel(self.groupBoxCamera)
        self.labelCameraTitle.setObjectName("labelCameraTitle")
        self.labelCameraTitle.setText("Изображение с камеры")
        self.labelCameraTitle.setGeometry(QtCore.QRect(160, 10, 181, 21))
        font = QtGui.QFont()
        font.setPointSize(12)
        self.labelCameraTitle.setFont(font)
        
        self.CameraStream = QVideoWidget(self)
        self.CameraStream.setObjectName("videoCameraStream")
        self.CameraStream.setGeometry(QtCore.QRect(10, 50, 481, 261))
        self.CameraStream.setMinimumSize(QtCore.QSize(241, 0))
       
        self.pushButtonRecognition = QtWidgets.QPushButton(self.groupBoxCamera)
        self.pushButtonRecognition.setObjectName("pushButtonRecognition")
        self.pushButtonRecognition.setText("Распознать")
        self.pushButtonRecognition.setGeometry(QtCore.QRect(10, 310, 481, 51))
        self.pushButtonRecognition.clicked.connect(self.identifyPersonBegin)
        
        self.pushButtonLog = QtWidgets.QPushButton(self)
        self.pushButtonLog.setObjectName("pushButtonLog")
        self.pushButtonLog.setText("Журнал")
        self.pushButtonLog.setGeometry(QtCore.QRect(10, 460, 121, 61))
        self.pushButtonLog.clicked.connect(self.OpenLogFile)
        
        self.pushButtonDb = QtWidgets.QPushButton(self)
        self.pushButtonDb.setObjectName("pushButtonDb")
        self.pushButtonDb.setText("База данных")
        self.pushButtonDb.setGeometry(QtCore.QRect(10, 390, 121, 61))
        self.pushButtonDb.clicked.connect(self.OpenArchivist)
        
        self.groupBoxRecognition = QtWidgets.QGroupBox(self)
        self.groupBoxRecognition.setObjectName("groupBoxRecognition")
        self.groupBoxRecognition.setTitle("")
        self.groupBoxRecognition.setGeometry(QtCore.QRect(520, 10, 500, 581))

        self.pushButtonExit = QtWidgets.QPushButton(self)
        self.pushButtonExit.setObjectName("pushButtonExit")
        self.pushButtonExit.setText("Выйти")
        self.pushButtonExit.setGeometry(QtCore.QRect(10, 530, 121, 61))
        self.pushButtonExit.clicked.connect(self.ExitProgream)

        self.labelPersonName = QtWidgets.QLabel(self.groupBoxRecognition)
        self.labelPersonName.setObjectName("labelPersonName")
        self.labelPersonName.setText("")
        self.labelPersonName.setGeometry(QtCore.QRect(20, 320, 271, 31))
        font = QtGui.QFont()
        font.setPointSize(16)
        self.labelPersonName.setFont(font)
        
        self.labelCurrentPhoto = QtWidgets.QLabel(self.groupBoxRecognition)
        self.labelCurrentPhoto.setObjectName("labelCurrentPhoto")
        self.labelCurrentPhoto.setText("")
        self.labelCurrentPhoto.setGeometry(QtCore.QRect(10, 40, 241, 261))
        self.labelCurrentPhoto.setMinimumSize(QtCore.QSize(241, 0))
        self.labelCurrentPhoto.setAlignment(QtCore.Qt.AlignCenter)
        
        self.labelPersonJob = QtWidgets.QLabel(self.groupBoxRecognition)
        self.labelPersonJob.setObjectName("labelPersonJob")
        self.labelPersonJob.setText("")
        self.labelPersonJob.setGeometry(QtCore.QRect(20, 360, 171, 21))
        font = QtGui.QFont()
        font.setPointSize(12)
        self.labelPersonJob.setFont(font)

        self.labelPersonInf = QtWidgets.QLabel(self.groupBoxRecognition)
        self.labelPersonInf.setObjectName("labelPersonJob")
        self.labelPersonInf.setText("")
        self.labelPersonInf.setGeometry(QtCore.QRect(20, 400, 171, 21))
        font = QtGui.QFont()
        font.setPointSize(8)
        self.labelPersonInf.setFont(font)
        
        self.labelAccess = QtWidgets.QLabel(self.groupBoxRecognition)
        self.labelAccess.setObjectName("labelAccess")
        self.labelAccess.setText("<html><head/><body><p align=\"center\">Допущен</p></body></html>")
        self.labelAccess.setGeometry(QtCore.QRect(10, 490, 481, 81))
        palette = QtGui.QPalette()
        brush = QtGui.QBrush(QtGui.QColor(76, 197, 32))
        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Window, brush)
        self.labelAccess.setPalette(palette)
        font = QtGui.QFont()
        font.setPointSize(16)
        font.setBold(True)
        font.setWeight(75)
        self.labelAccess.setFont(font)
        self.labelAccess.setAcceptDrops(False)
        self.labelAccess.setAutoFillBackground(True)
        self.labelAccess.setFrameShape(QtWidgets.QFrame.NoFrame)
        self.labelAccess.setFrameShadow(QtWidgets.QFrame.Plain)
        self.labelAccess.setTextFormat(QtCore.Qt.AutoText)
        self.labelAccess.setTextInteractionFlags(QtCore.Qt.LinksAccessibleByMouse)

        self.labelDbPhoto = QtWidgets.QLabel(self.groupBoxRecognition)
        self.labelDbPhoto.setObjectName("labelDbPhoto")
        self.labelDbPhoto.setText("")
        self.labelDbPhoto.setGeometry(QtCore.QRect(250, 40, 241, 261))
        self.labelDbPhoto.setMinimumSize(QtCore.QSize(241, 0))
        self.labelDbPhoto.setAlignment(QtCore.Qt.AlignCenter)
        
        self.labelCurrentPhotoTitle = QtWidgets.QLabel(self.groupBoxRecognition)
        self.labelCurrentPhotoTitle.setObjectName("labelCurrentPhotoTitle")
        self.labelCurrentPhotoTitle.setText("Текущее фото")
        self.labelCurrentPhotoTitle.setGeometry(QtCore.QRect(80, 10, 111, 21))
        font = QtGui.QFont()
        font.setPointSize(12)
        self.labelCurrentPhotoTitle.setFont(font)

        self.labelDbPhotoTitle = QtWidgets.QLabel(self.groupBoxRecognition)
        self.labelDbPhotoTitle.setObjectName("labelDbPhotoTitle")
        self.labelDbPhotoTitle.setText("Фото в базе")
        self.labelDbPhotoTitle.setGeometry(QtCore.QRect(320, 10, 111, 21))
        font = QtGui.QFont()
        font.setPointSize(12)
        self.labelDbPhotoTitle.setFont(font)

        self.device = QCamera.availableDevices()[0]
        self.camera = QCamera(self.device)
        self.camera.setViewfinder(self.CameraStream)
        self.camera.setCaptureMode(QCamera.CaptureStillImage)
        self.imageCapture=QCameraImageCapture(self.camera)
        self.imageCapture.imageSaved.connect(self.identifyPersonEnd)
        self.camera.start()

    # идентификация человека (фото)
    def identifyPersonBegin(self):
        if self.imageCapture.isReadyForCapture():
            #imgName = os.getcwd() + "\img\currentPhoto.jpg"
            self.camera.searchAndLock()
            self.imageCapture.capture(self.imgName)
            self.camera.unlock()

    # идентификация человека (алгоритм)
    def identifyPersonEnd(self):

        self._Client.get_aligned_faces(self.imgName, "img\currentPhoto")
        
        id_person = self._Client.identify_profile_by_face(self.imgName0, 1, 0).pop("result")[0]
        self._Client.get_profile_image(id_person['profile_id'], id_person['image_id'],self.imgName1)
        self.labelCurrentPhoto.setPixmap(QtGui.QPixmap(self.imgName0))
        self.labelDbPhoto.setPixmap(QtGui.QPixmap(self.imgName1))

        profile = JsonDataBase.GetInfo(id_person['profile_id'])
        if profile != None:
            self.labelPersonName.setText(profile['name'])
            self.labelPersonJob.setText(profile['tag'])
        else:
            self.labelPersonName.setText(profile[''])
            self.labelPersonJob.setText(profile[''])

        if id_person['score'] > self._Constant_recognition :
            palette = QtGui.QPalette()
            brush = QtGui.QBrush(QtGui.QColor(255, 22, 46))
            palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Window, brush)
            self.labelAccess.setPalette(palette)
            self.labelAccess.setText("<html><head/><body><p align=\"center\">Недопущен</p></body></html>")
        else:
            palette = QtGui.QPalette()
            brush = QtGui.QBrush(QtGui.QColor(76, 197, 32))
            palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Window, brush)
            self.labelAccess.setPalette(palette)
            self.labelAccess.setText("<html><head/><body><p align=\"center\">Допущен</p></body></html>")
        self.labelPersonInf.setText('id= ' + str(id_person['profile_id'])+' score= '+str(id_person['score']))

    # открыть управление базой данных
    def OpenArchivist(self):
        self.archivist = Archivist.Window()
        self.archivist.show()

    # открыть файл логов
    def OpenLogFile(self):
        os.system("log.txt")

    # выйти из программы
    def ExitProgream(self):
        self.camera.stop()
        self.close()
Esempio n. 17
0
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)
Esempio n. 18
0
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()
Esempio n. 19
0
class UserWidget(QWidget):

    host_name = None
    full_name = None
    user_name = None
    passwd = None
    repasswd = None
    rpasswd = None
    rrepasswd = None

    def __init__(self, parent=None):
        super().__init__()
        self.parent = parent
        self.setStyleSheet("QToolButton {border: none;}")
        self.setLayout(QHBoxLayout())

        left_layout = QVBoxLayout()
        self.layout().addLayout(left_layout)

        self.name_label = QLabel()
        left_layout.addWidget(self.name_label)

        name_layout = QHBoxLayout()
        left_layout.addLayout(name_layout)

        self.name_line = QLineEdit()
        self.name_line.setFixedWidth(450)
        name_layout.addWidget(self.name_line)

        self.name_icon = QLabel()
        self.name_icon.setFixedSize(24, 24)
        self.name_icon.setScaledContents(True)
        name_layout.addWidget(self.name_icon)

        self.user_label = QLabel()
        left_layout.addWidget(self.user_label)

        user_layout = QHBoxLayout()
        left_layout.addLayout(user_layout)

        self.user_line = QLineEdit()
        user_layout.addWidget(self.user_line)

        self.user_icon = QLabel()
        self.user_icon.setScaledContents(True)
        self.user_icon.setFixedSize(24, 24)
        user_layout.addWidget(self.user_icon)

        self.host_label = QLabel()
        left_layout.addWidget(self.host_label)

        host_layout = QHBoxLayout()
        left_layout.addLayout(host_layout)

        self.host_line = QLineEdit()
        host_layout.addWidget(self.host_line)

        self.host_icon = QLabel()
        self.host_icon.setFixedSize(24, 24)
        self.host_icon.setScaledContents(True)
        host_layout.addWidget(self.host_icon)

        self.pass_label = QLabel()
        left_layout.addWidget(self.pass_label)

        pass_layout = QHBoxLayout()
        left_layout.addLayout(pass_layout)

        self.pass_line = QLineEdit()
        self.pass_line.setEchoMode(QLineEdit.Password)
        pass_layout.addWidget(self.pass_line)

        self.pass_icon = QLabel()
        self.pass_icon.setScaledContents(True)
        self.pass_icon.setFixedSize(24, 24)
        pass_layout.addWidget(self.pass_icon)

        repass_layout = QHBoxLayout()
        left_layout.addLayout(repass_layout)

        self.repass_line = QLineEdit()
        self.repass_line.setEchoMode(QLineEdit.Password)
        repass_layout.addWidget(self.repass_line)

        self.repass_icon = QLabel()
        self.repass_icon.setScaledContents(True)
        self.repass_icon.setFixedSize(24, 24)
        repass_layout.addWidget(self.repass_icon)

        self.auto_box = QCheckBox()
        self.auto_box.setChecked(True)
        left_layout.addWidget(self.auto_box)

        self.root_box = QCheckBox()
        self.root_box.setChecked(True)
        left_layout.addWidget(self.root_box)

        rpass_layout = QHBoxLayout()
        left_layout.addLayout(rpass_layout)

        rpass_layout.addSpacerItem(QSpacerItem(0, 40, QSizePolicy.Maximum, QSizePolicy.Expanding))

        self.rpass_line = QLineEdit()
        self.rpass_line.hide()
        self.rpass_line.setEchoMode(QLineEdit.Password)
        rpass_layout.addWidget(self.rpass_line)

        self.rpass_icon = QLabel()
        self.rpass_icon.hide()
        self.rpass_icon.setScaledContents(True)
        self.rpass_icon.setFixedSize(24, 24)
        rpass_layout.addWidget(self.rpass_icon)

        rrepass_layout = QHBoxLayout()
        left_layout.addLayout(rrepass_layout)

        self.rrepass_line = QLineEdit()
        self.rrepass_line.hide()
        self.rrepass_line.setEchoMode(QLineEdit.Password)
        rrepass_layout.addWidget(self.rrepass_line)

        self.rrepass_icon = QLabel()
        self.rrepass_icon.hide()
        self.rrepass_icon.setScaledContents(True)
        self.rrepass_icon.setFixedSize(24, 24)
        rrepass_layout.addWidget(self.rrepass_icon)

        left_layout.addSpacerItem(QSpacerItem(20, 40, QSizePolicy.Maximum, QSizePolicy.Expanding))

        self.layout().addSpacerItem(QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Expanding))

        right_layout = QVBoxLayout()
        self.layout().addLayout(right_layout)

        ######## Camera

        self.cameras = QCameraInfo.availableCameras()

        self.photo_label = QLabel()
        self.photo_label.setFixedSize(192, 192)
        self.photo_label.setScaledContents(True)
        self.photo_label.setPixmap(QPixmap(":/images/user-avatar.svg"))
        self.parent.lilii_settings["avatar"] = None
        right_layout.addWidget(self.photo_label)

        if len(self.cameras):
            self.camera = QCamera(self.cameras[0])
            self.camera.setCaptureMode(QCamera.CaptureStillImage)

            self.image_capture = QCameraImageCapture(self.camera)
            self.image_capture.imageSaved.connect(self.imageConvert)

        button_layout = QHBoxLayout()
        right_layout.addLayout(button_layout)

        self.take_photo = CustomToolButton()
        self.take_photo.setEnabled(len(self.cameras))
        self.take_photo.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
        self.take_photo.setIconSize(QSize(32, 32))
        self.take_photo.setIcon(QIcon(":/images/camera.svg"))
        self.take_photo.setEnterIcon(QIcon(":/images/camera-red.svg"))
        self.take_photo.setLeaveIcon(QIcon(":/images/camera.svg"))
        button_layout.addWidget(self.take_photo)

        self.retake_photo = CustomToolButton()
        self.retake_photo.hide()
        self.retake_photo.setEnabled(len(self.cameras))
        self.retake_photo.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
        self.retake_photo.setIconSize(QSize(32, 32))
        self.retake_photo.setIcon(QIcon(":/images/camera.svg"))
        self.retake_photo.setEnterIcon(QIcon(":/images/camera-red.svg"))
        self.retake_photo.setLeaveIcon(QIcon(":/images/camera.svg"))
        button_layout.addWidget(self.retake_photo)

        self.select_photo = CustomToolButton()
        self.select_photo.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
        self.select_photo.setIconSize(QSize(32, 32))
        self.select_photo.setIcon(QIcon(":/images/users.svg"))
        self.select_photo.setLeaveIcon(QIcon(":/images/users.svg"))
        self.select_photo.setEnterIcon(QIcon(":/images/users-red.svg"))
        button_layout.addWidget(self.select_photo)

        self.layout().addSpacerItem(QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Expanding))

        self.parent.lilii_settings["auto_login"] = self.auto_box.isChecked()
        self.parent.lilii_settings["root_user"] = self.root_box.isChecked()

        self.auto_box.toggled.connect(self.autoControl)
        self.root_box.toggled.connect(self.rootControl)
        self.host_line.textChanged.connect(self.hostnameControl)
        self.name_line.textChanged.connect(self.fullnameControl)
        self.name_line.textChanged.connect(self.fullnameToUsername)
        self.user_line.textChanged.connect(self.usernameControl)
        self.pass_line.textChanged.connect(self.passwordControl)
        self.repass_line.textChanged.connect(self.repasswordControl)
        self.rpass_line.textChanged.connect(self.rpasswordControl)
        self.rrepass_line.textChanged.connect(self.rrepasswordControl)

        self.root_box.toggled.connect(self.lineEditsControl)
        self.host_line.textChanged.connect(self.lineEditsControl)
        self.name_line.textChanged.connect(self.lineEditsControl)
        self.user_line.textChanged.connect(self.lineEditsControl)
        self.pass_line.textChanged.connect(self.lineEditsControl)
        self.repass_line.textChanged.connect(self.lineEditsControl)
        self.rpass_line.textChanged.connect(self.lineEditsControl)
        self.rrepass_line.textChanged.connect(self.lineEditsControl)

        self.select_photo.clicked.connect(self.selectPhoto)
        self.take_photo.clicked.connect(self.takePhoto)
        self.retake_photo.clicked.connect(self.retakePhoto)
        self.parent.languageChanged.connect(self.retranslate)

        self.image_timer = QTimer(self)
        self.image_timer.timeout.connect(self.cameraView)

        self.retranslate()

    def retranslate(self):
        self.select_photo.setText(self.tr("Select Photo"))
        self.retake_photo.setText(self.tr("Retake Photo"))
        self.take_photo.setText(self.tr("Take Photo"))
        self.rrepass_line.setPlaceholderText(self.tr("Root Repassword"))
        self.rpass_line.setPlaceholderText(self.tr("Root Password"))
        self.root_box.setText(self.tr("Should the administrator and the user use the same password?"))
        self.auto_box.setText(self.tr("Sign in without password."))
        self.repass_line.setPlaceholderText(self.tr("Repassword"))
        self.pass_line.setPlaceholderText(self.tr("Password"))
        self.pass_label.setText(self.tr("Enter your user password."))
        self.host_line.setPlaceholderText(self.tr("Hostname"))
        self.host_label.setText(self.tr("What should this computer be named?"))
        self.user_line.setPlaceholderText(self.tr("Username"))
        self.user_label.setText(self.tr("Username to sign in?"))
        self.name_line.setPlaceholderText(self.tr("Fullname"))
        self.name_label.setText(self.tr("What is your name?"))
        self.setWindowTitle(self.tr("User Creation"))

    def showEvent(self, event):
        self.lineEditsControl()
        if len(self.cameras):
            self.retakePhoto()

    def autoControl(self):
        self.parent.lilii_settings["auto_login"] = self.auto_box.isChecked()

    def rootControl(self):
        self.parent.lilii_settings["root_user"] = self.root_box.isChecked()
        if not self.root_box.isChecked():
            self.rpass_line.show()
            self.rpass_icon.show()
            self.rrepass_line.show()
            self.rrepass_icon.show()
        else:
            self.rpass_line.hide()
            self.rpass_icon.hide()
            self.rrepass_line.hide()
            self.rrepass_icon.hide()

    def hostnameControl(self, hostname):
        if hostname.isalnum() and len(hostname) > 3:
            self.host_name = True
            self.host_icon.setPixmap(QPixmap(":/images/apply.svg"))
        else:
            self.host_name = False
            self.host_icon.setPixmap(QPixmap(":/images/xxx.svg"))

    def fullnameControl(self, fullname):
        if len(fullname) > 2:
            self.full_name = True
            self.name_icon.setPixmap(QPixmap(":/images/apply.svg"))
        else:
            self.full_name = False
            self.name_icon.setPixmap(QPixmap(":/images/xxx.svg"))

    def usernameControl(self, username):
        if username.isalnum() and len(username) > 3:
            self.user_name = True
            self.user_icon.setPixmap(QPixmap(":/images/apply.svg"))
        else:
            self.user_name = False
            self.user_icon.setPixmap(QPixmap(":/images/xxx.svg"))

    def fullnameToUsername(self, text):
        self.user_line.setText(text.lower().replace(" ", ""))

    def passwordControl(self, passwd):
        if len(passwd) > 5:
            self.passwd = True
            self.pass_icon.setPixmap(QPixmap(":/images/apply.svg"))
        else:
            self.passwd = False
            self.pass_icon.setPixmap(QPixmap(":/images/xxx.svg"))

        if passwd == self.repass_line.text():
            self.repasswd = True
            self.repass_icon.setPixmap(QPixmap(":/images/apply.svg"))
        else:
            self.repasswd = False
            self.repass_icon.setPixmap(QPixmap(":/images/xxx.svg"))

    def repasswordControl(self, repasswd):
        if repasswd == self.pass_line.text():
            self.repasswd = True
            self.repass_icon.setPixmap(QPixmap(":/images/apply.svg"))
        else:
            self.repasswd = False
            self.repass_icon.setPixmap(QPixmap(":/images/xxx.svg"))

    def rpasswordControl(self, passwd):
        if len(passwd) > 5:
            self.rpasswd = True
            self.rpass_icon.setPixmap(QPixmap(":/images/apply.svg"))
        else:
            self.rpasswd = False
            self.rpass_icon.setPixmap(QPixmap(":/images/xxx.svg"))

        if passwd == self.rrepass_line.text():
            self.rrepasswd = True
            self.rrepass_icon.setPixmap(QPixmap(":/images/apply.svg"))
        else:
            self.rrepasswd = False
            self.rrepass_icon.setPixmap(QPixmap(":/images/xxx.svg"))

    def rrepasswordControl(self, repasswd):
        if repasswd == self.rpass_line.text():
            self.rrepasswd = True
            self.rrepass_icon.setPixmap(QPixmap(":/images/apply.svg"))
        else:
            self.rrepasswd = False
            self.rrepass_icon.setPixmap(QPixmap(":/images/xxx.svg"))

    applyPage = pyqtSignal(bool)

    def lineEditsControl(self):
        if not self.root_box.isChecked():
            if self.host_name and self.full_name and self.user_name and self.passwd and self.repasswd and self.rpasswd \
                                                                                                    and self.rrepasswd:

                self.parent.lilii_settings["root_pass"] = self.rpass_line.text()
                self.applyPage.emit(True)

                self.parent.lilii_settings["fullname"] = self.name_line.text()
                self.parent.lilii_settings["username"] = self.user_line.text()
                self.parent.lilii_settings["password"] = self.pass_line.text()
                self.parent.lilii_settings["hostname"] = self.host_line.text()

            else:
                self.applyPage.emit(False)

        elif self.host_name and self.full_name and self.user_name and self.passwd and self.repasswd:
            self.parent.lilii_settings["fullname"] = self.name_line.text()
            self.parent.lilii_settings["username"] = self.user_line.text()
            self.parent.lilii_settings["password"] = self.pass_line.text()
            self.parent.lilii_settings["hostname"] = self.host_line.text()
            self.applyPage.emit(True)

        else:
            self.applyPage.emit(False)

    def selectPhoto(self):
        avatar_path = QDir.homePath() + "/.face.icon"
        file_path = QFileDialog.getOpenFileName(self, self.tr("Choose a user icon"), QDir.homePath(), "Image (*.png *.jpg)")

        if file_path[0]:
            image = Image.open(file_path[0])
            crop_image = image.crop(imageCrop(image))
            new_image = avatarCreate(crop_image)
            new_image.save(avatar_path, "PNG")
            self.photo_label.setPixmap(QPixmap(avatar_path))

            self.parent.lilii_settings["avatar"] = True

    def takePhoto(self):
        self.take_photo.hide()
        self.retake_photo.show()

        self.parent.lilii_settings["avatar"] = True
        self.image_timer.stop()
        self.camera.stop()

    def retakePhoto(self):
        self.retake_photo.hide()
        self.take_photo.show()
        self.camera.start()
        self.parent.lilii_settings["avatar"] = False
        self.image_timer.start(1000//30)

    def cameraView(self):
        self.image_capture.capture("/tmp/frame")

    def imageConvert(self, id, image):
        path = QDir.homePath() + "/.face.icon"
        im = Image.open(image)
        crop_image = im.crop(imageCrop(im))
        new_image = avatarCreate(crop_image)
        new_image.save(path, "PNG")
        self.photo_label.setPixmap(QPixmap.fromImage(ImageQt.ImageQt(new_image)))
Esempio n. 20
0
class CameraInterface(CameraBase.CameraBase):
    def __init__(self, *args, camera_info=None):
        super(CameraInterface, self).__init__(*args)
        # 定义相机实例对象并设置捕获模式
        if camera_info:
            self.mCamera = QCamera(camera_info)
        else:
            self.mCamera = QCamera()
        self.mCamera.setCaptureMode(QCamera.CaptureViewfinder)
        self.mDisplayWidth = 800
        self.mDisplayHeight = 600
        self.mRate = 10

        # 设置取景器分辨率
        self.setDisplaySize(self.mDisplayWidth, self.mDisplayHeight)

        self.setRate(self.mRate)

        # 初始化取景器
        self.mViewCamera = QtMultimediaWidgets.QCameraViewfinder(self)
        self.mViewCamera.show()
        self.mCamera.setViewfinder(self.mViewCamera)
        self.mCamera.setCaptureMode(QCamera.CaptureStillImage)

        # 设置图像捕获
        self.mCapture = QCameraImageCapture(self.mCamera)
        if self.mCapture.isCaptureDestinationSupported(
                QCameraImageCapture.CaptureToBuffer):
            self.mCapture.setCaptureDestination(
                QCameraImageCapture.CaptureToBuffer)  # CaptureToBuffer

        # self.mCapture.error.connect(lambda i, e, s: self.alert(s))
        self.mCapture.imageAvailable.connect(self.readFrame)

        self.mTimerImageGrab = QTimer(self)
        self.mTimerImageGrab.timeout.connect(self.timerImgGrab)
        # self.t1 = 0.0

    def timerImgGrab(self):
        self.mCapture.capture('tmp.jpg')

    def readFrame(self, requestId, image):
        self.mFrame = image.image().copy()

    def openCamera(self):
        if not self.mCameraOpened:
            self.mCamera.start()

            viewFinderSettings = QCameraViewfinderSettings()
            rate_range = self.mCamera.supportedViewfinderFrameRateRanges()
            if rate_range:
                viewFinderSettings.setMinimumFrameRate(
                    rate_range[0].minimumFrameRate)
                viewFinderSettings.setMaximumFrameRate(
                    rate_range[0].maximumFrameRate)
            else:
                viewFinderSettings.setMinimumFrameRate(1)
                viewFinderSettings.setMaximumFrameRate(self.mRate)
            self.mTimerImageGrab.start(1000 / self.mRate)
            self.mCameraOpened = True

    def releaseCamera(self):
        if self.mCameraOpened:
            self.mCamera.stop()
            self.mCameraOpened = False
            self.signalReleased.emit()

    def takePictures(self, path: str):
        self.mCapture.setCaptureDestination(QCameraImageCapture.CaptureToFile)
        self.mCapImg.capture(path)
        self.mCapture.setCaptureDestination(
            QCameraImageCapture.CaptureToBuffer)

    def takeVideo(self, path: str):
        pass

    def endTakeVideo(self):
        pass

    def setDisplaySize(self, display_width_: int, display_height_: int):
        self.mDisplayWidth = display_width_
        self.mDisplayHeight = display_height_
        viewFinderSettings = QCameraViewfinderSettings()
        viewFinderSettings.setResolution(self.mDisplayWidth,
                                         self.mDisplayHeight)
        self.mCamera.setViewfinderSettings(viewFinderSettings)

    def setRate(self, rate):
        self.mRate = rate
Esempio n. 21
0
class QmyCamerawindow(QMainWindow):
    def __initCamera(self):
        camInfo = QCameraInfo.defaultCamera()
        self.camera = QCamera(camInfo)
        self.camera2 = QCamera(camInfo)
        self.camera.setViewfinder(self._ui.widget)
        self.camera2.setViewfinder(self._ui.widget_2)
        self.camera.setCaptureMode(
            QCamera.CaptureStillImage)  #captureviewfinder
        self.camera2.setCaptureMode(QCamera.CaptureStillImage)

    def _initImageCapture(self):
        self.capture = QCameraImageCapture(self.camera)
        self.capture2 = QCameraImageCapture(self.camera2)
        setting = QImageEncoderSettings()
        setting.setCodec("image/jpeg")
        self.capture.setEncodingSettings(setting)
        self.capture.setBufferFormat(QVideoFrame.Format_Jpeg)
        self.capture.setCaptureDestination(QCameraImageCapture.CaptureToBuffer)
        self.capture.readyForCaptureChanged.connect(self.do_imageReady)
        self.capture.imageCaptured.connect(self.do_imageCaptured)
        self.capture2.setEncodingSettings(setting)
        self.capture2.setBufferFormat(QVideoFrame.Format_Jpeg)
        self.capture2.setCaptureDestination(
            QCameraImageCapture.CaptureToBuffer)
        self.capture2.readyForCaptureChanged.connect(self.do_imageReady)
        self.capture2.imageCaptured.connect(self.do_imageCaptured2)
        # self.capture.setCaptureDestination(QCameraImageCapture.CaptureToFile)
    def do_imageReady(self, ready):
        self._ui.actionActCaputure.setEnabled(ready)

    def do_imageCaptured2(self, image_id, preview):
        self.getpicname2()
        preview.save(self.picname2)
        cv2.waitKey(500)
        resultid = useract.find_one(self.facealbum_token, self.picname2)
        print(resultid)
        cv2.waitKey(500)
        data = sqlact.search_sql("student", resultid)
        print(data)
        self._ui.plainTextEdit_3.setPlainText(data[0][1])
        self._ui.plainTextEdit_4.setPlainText(data[0][2])
        self._ui.plainTextEdit_5.setPlainText(str(data[0][3]))
        # print(preview)
    def do_imageCaptured(self, image_id, preview):
        H = self._ui.label_2.height()
        W = self._ui.label_2.width()
        scaledImage = preview.scaled(W, H, Qt.KeepAspectRatio,
                                     Qt.SmoothTransformation)
        self._ui.label_2.setPixmap(QPixmap.fromImage(scaledImage))
        self.getpicname()
        preview.save(self.picname)

        # useract.add_newone("student",name)

    def on_actionActCaputure_triggered(self):
        # QSound.play("shutter.wav")
        self.camera.searchAndLock()
        self.capture.capture()
        self.camera.unlock()
        # FName = fr"E:\iddatabasepic\cap{time.strftime('%Y%m%d%H%M%S', time.localtime())}"
        # self.flag += 1
        # self.capture.capture(FName)
        # print(f"捕获图像保存到文件:{FName}.jpg")

    def on_actionActStartCamera_triggered(self):
        self.camera.start()
        self.flag = 1

    def on_actionActCloseCamrera_triggered(self):
        self.camera.stop()
        self.flag = 0

    def on_actionActExit_triggered(self):
        self.camera.stop()
        self.close()

    def gettext(self):
        self.text = self._ui.plainTextEdit.toPlainText()
        self.text2 = self._ui.plainTextEdit_2.toPlainText()
        useract.add_newone("student", self.text, self.text2,
                           self.facealbum_token, self.picname)

    def getpicname(self):  #获取图片名
        self.picname = fr"E:\iddatabasepic\cap{time.strftime('%Y%m%d%H%M%S', time.localtime())}" + ".jpg"

        # print(self.text)
    def getpicname2(self):  #获取图片名
        self.picname2 = fr"E:\iddatabasepic\capnew{time.strftime('%Y%m%d%H%M%S', time.localtime())}" + ".jpg"

    def tabshift1(self):
        # print(self.tabWidget.currentIndex())
        # print("hello")
        self._ui.tabWidget.setCurrentIndex(0)
        if self.flag2 == 1:
            self.camera2.stop()
            self.flag2 = 0

    def tabshift2(self):
        self._ui.tabWidget.setCurrentIndex(1)
        if self.flag == 1:
            self.camera.stop()
            self.flag = 0
        self.flag2 = 1
        useract.group_all(self.facealbum_token)
        self.camera2.start()

    def tabshift3(self):
        self._ui.tabWidget.setCurrentIndex(2)
        if self.flag == 1:
            self.camera.stop()
            self.flag = 0
        if self.flag2 == 1:
            self.camera2.stop()
            self.flag2 = 0

    def searchcap(self):
        self.camera2.searchAndLock()
        self.capture2.capture()
        self.camera2.unlock()

    def dataview(self):
        view = sqlact.search_all_sql("student")
        self._ui.plainTextEdit_7.setPlainText(",".join(
            [str(t) for i in view for t in i]))

    def __init__(self, parent=None):
        super().__init__(parent)
        self._ui = Ui_MainWindowcamera()
        self.flag = 1
        self.flag2 = 0
        self._ui.setupUi(self)
        self.camera = None
        self.picname2 = ""
        self.picname = ""
        self.facealbum_token = "1577420387-3990379c-dcc2-4fe8-ae47-bf37a299118d"
        self._ui.btnget.clicked.connect(self.gettext)
        self._ui.addnew.clicked.connect(self.tabshift1)
        self._ui.searchinfo.clicked.connect(self.tabshift2)
        self._ui.pushButton_3.clicked.connect(self.tabshift3)
        self._ui.btncap.clicked.connect(self.searchcap)
        self._ui.btndata.clicked.connect(self.dataview)
        cameras = QCameraInfo.availableCameras()
        if len(cameras) > 0:
            self.__initCamera()
            self._initImageCapture()
            self.camera.start()
Esempio n. 22
0
class mainInterface(QWidget):

    # 定义信号
    processFinished = pyqtSignal(dict)

    def __init__(self):
        """
        初始化
        :return: null
        """
        # 超类初始化
        super().__init__()

        # UI初始化
        self.ui = Ui_mainWidget()
        self.ui.setupUi(self)
        self.grabKeyboard()
        self.setMouseTracking(True)
        self.setWindowFlags(Qt.FramelessWindowHint)
        self.setWindowIcon(QIcon('OCR.ico'))

        # 初始化相机
        self.camera = QCamera()
        self.imageCapture = QCameraImageCapture(self.camera)
        self.viewsetting = QCameraViewfinderSettings()
        self.initimplement()

        # 初始化标题栏
        self.initTitleBar()

        # 初始化系统托盘
        self.tray = QSystemTrayIcon()
        self.tray.setIcon(QIcon('OCR.ico'))
        self.initTray()

        # OCR识别部分
        self.OCR = ocr()
        self.OCR.setappid('1257206643')
        self.OCR.setsecretid('AKIDFTddWEg9Ncsz0sE7oOpBNOExdDdeCUJ3')
        self.OCR.setsecretkey('FQitsgUND8yfrZK0RrBMOJB5tWhCm5Ol')

        # 初始化登录部分
        self.logWidget = QWidget()
        self.logui = Ui_Form()
        self.logui.setupUi(self.logWidget)
        self.logWidget.setWindowFlags(Qt.FramelessWindowHint)
        self.logWidget.setWindowModality(Qt.ApplicationModal)
        self.logui.close_btn.clicked.connect(self.logWidget.close)

        # 初始化变量
        self.mousePressd = False
        self.mousePoint = None
        self.result = {}
        self.isFirst = False
        self.ocrType = ocrType.ocr_general  # 默认为印刷体识别

        # 初始化字定义信号连接
        self.processFinished.connect(self.updateOCRInfo)
        self.ui.btn_login.clicked.connect(self.logWidget.show)
        self.ui.comboBox_choose.currentIndexChanged.connect(self.changeocrType)

    def initTitleBar(self):
        """
        初始化标题栏
        :return: null
        """
        self.ui.frame.setStyleSheet(
            "QFrame#frame{background-color:rgb(244, 76, 76);}")
        self.ui.label_logo.setStyleSheet(
            "QLabel{border-image:url(./image/ocr.png);}")
        self.ui.label_title.setStyleSheet(
            "QLabel{border-image:url(./image/iOCR.png);}")
        self.ui.comboBox_choose.setStyleSheet(
            "QComboBox {border-radius:15px;border: 2px solid #4AFFF4;font-family:'楷体';font-size:20px;}"
            "QComboBox QAbstractItemView::item{height:50px;width:200px;}"
            "QComboBox::down-arrow{image: url(./image/arrow.png);width:25px;height:25px;}"
            "QComboBox::drop-down {subcontrol-origin: padding;subcontrol-position:top right;border:none;margin-right:30px;}"
            "QComboBox::down-arrow:hover{image:url(./image/arrow_hover.png);width:25px;height:25px;}"
            "QComboBox::down-arrow:on {top: 1px;left: 1px;}")
        self.ui.comboBox_choose.insertItem(0, '       印刷体识别')
        self.ui.comboBox_choose.insertItem(1, '       手写体识别')
        self.ui.comboBox_choose.insertItem(2, '       身份证识别')
        self.ui.comboBox_choose.insertItem(3, '       名片识别')
        self.ui.comboBox_choose.insertItem(4, '       银行卡识别')
        self.ui.btn_login.setStyleSheet(
            "QPushButton{border-image:url(./image/default-portrait.png);}")
        self.ui.btn_setting.setStyleSheet(
            "QPushButton{border-image:url(./image/settings.png);}"
            "QPushButton:hover{border-image:url(./image/qcconfig-hover.png);}")
        self.ui.btn_min.setStyleSheet(
            "QPushButton{border-image:url(./image/mini_new.png);}"
            "QPushButton:hover{border-image:url(./image/mini_hover_new.png);}")
        self.ui.btn_close.setStyleSheet(
            "QPushButton{border-image:url(./image/close.png);}"
            "QPushButton:hover{border-image:url(./image/close-hover.png);}")
        self.ui.checkBox_cam.setStyleSheet(
            "QCheckBox{spacing: 5px;font-size: 24px;vertical-align:middle}"
            "QCheckBox::indicator { width: 45px;height: 45px;}"
            "QCheckBox::indicator::unchecked {image: url(./image/close_cam.png);}"
            "QCheckBox::indicator::checked { image: url(./image/open_cam.png);}"
        )
        self.ui.captureBtn.setStyleSheet(
            "QPushButton{border-style: outset;border-width: 2px;border-color: rgb(82,215,100);border-radius: 5px;font-size: 24px;}"
            "QPushButton:pressed{background-color: rgb(176,215,181);border-style: inset;}"
        )

        self.ui.checkBox_cam.setChecked(True)

        self.ui.btn_close.clicked.connect(lambda: qApp.quit())
        self.ui.btn_min.clicked.connect(self.miniToTray)
        self.ui.checkBox_cam.stateChanged.connect(self.camControl)

    def initTray(self):
        """
        初始化系统托盘信息
        :return:
        """
        tray_menu = QMenu()
        restoreAction = QAction('&Show', self)
        quitAction = QAction('&Quit', self)
        tray_menu.addAction(restoreAction)
        tray_menu.addAction(quitAction)
        self.tray.setContextMenu(tray_menu)
        restoreAction.triggered.connect(self.trayActivatedEvent)
        quitAction.triggered.connect(qApp.quit)
        self.tray.activated.connect(self.trayActivatedEvent)

    def initimplement(self):
        """
        初始化实现端口
        :return: ui
        """
        camInfo = QCameraInfo(self.camera)
        if camInfo.defaultCamera().isNull():
            QMessageBox.warning(self, 'Warning', 'No available camera!',
                                QMessageBox.Ok)
            return -1
        else:
            self.ui.caputurePhoto.setText(camInfo.description())
            self.camera.setViewfinder(self.ui.cameraShow)
            self.camera.setCaptureMode(QCamera.CaptureStillImage)
            self.camera.load()
            resolution = self.camera.supportedViewfinderResolutions()
            if len(resolution) != 0:
                if QSize(640, 480) in resolution:
                    self.viewsetting.setResolution(QSize(640, 480))
                elif QSize(640, 360) in resolution:
                    self.viewsetting.setResolution(QSize(640, 360))
                else:
                    self.viewsetting.setResolution(resolution[0])
                self.camera.setViewfinderSettings(self.viewsetting)

            # ------------------------------Note--------------------------------
            # 此种方法利用摄像头准备捕捉图像的状态来进行捕捉图像,readyForCapture
            # 为true时,才进行捕捉图像,详见下面捕捉函数槽函数。这种方法将进行不
            # 停的捕捉,将每次捕捉的相邻图像进行图像相似度判断。当图像相似度低于
            # 阈值时,认定为新图像,才进行OCR识别。否则仅捕捉图像而不进行识别。当
            # 然捕捉图像速度过于太快时,可以用定时器,每隔0.5秒,去检查readyFor
            # Capture状态位,进而有效控制程序资源。
            # 本应用中采用按键捕捉方式,非自动,详见下面按键捕捉事件
            # ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
            # self.imageCapture.readyForCaptureChanged.connect(self.captureimage)

            self.camera.start()

        self.ui.caputurePhoto.setScaledContents(True)

        self.imageCapture.setCaptureDestination(
            QCameraImageCapture.CaptureToBuffer)

        self.imageCapture.imageCaptured.connect(self.displayimage)

        self.ui.captureBtn.clicked.connect(self.openDlg)

    def displayimage(self, num, image):
        """
        显示图形
        :param num: number
        :param image: image
        :return: null
        """
        self.ui.caputurePhoto.setPixmap(QPixmap.fromImage(image))
        self.ui.ocrInfo.setText('识别中......')
        t = threading.Thread(target=self.ocrForImage, args=(image, ))
        t.start()

    # def captureimage(self, state):
    #     """
    #     捕捉图像槽函数
    #     :state: 状态变量
    #     :return: null
    #     """
    #     if state is True:
    #         self.camera.searchAndLock()
    #         self.imageCapture.capture()
    #         self.camera.unlock()

    # def saveimage(self):
    #     """
    #     保存图像槽函数
    #     :return: null
    #     """
    #     pix = QPixmap(self.ui.caputurePhoto.pixmap())
    #     if pix:
    #         pix.save(r'D://1.png', 'PNG')
    #         QMessageBox.information(self, 'Message', 'Capture Successfully', QMessageBox.Ok)

    def ocrForImage(self, image):
        """
        为截取的图片进行ocr识别
        :param image: QImage
        :return: null
        """
        # Note:子线程里不能对ui界面做改动,ui界面修改只能在主线程中修改,下面注释的做法是错误的
        # self.ui.ocrInfo.setText('识别中......')
        byte = QByteArray()
        buffer = QBuffer(byte)
        buffer.open(QIODevice.WriteOnly)
        image.save(buffer, 'PNG')
        if self.ocrType == ocrType.ocr_general:
            self.result = self.OCR.client.general_detect(
                CIBuffers([byte.data()]))
        elif self.ocrType == ocrType.ocr_handwriting:
            self.result = self.OCR.client.handwriting_detect(
                CIBuffers([byte.data()]))
        elif self.ocrType == ocrType.ocr_idcard:
            self.result = self.OCR.client.idcard_detect(
                CIBuffers([byte.data()]), 0)
        elif self.ocrType == ocrType.ocr_namecard:
            self.result = self.OCR.client.namecard_detect(
                CIBuffers([byte.data()]), 0)
        elif self.ocrType == ocrType.ocr_bankcard:
            self.result = self.OCR.client.bankcard_detect(
                CIBuffers([byte.data()]))
        else:
            pass
        self.processFinished.emit(self.result)

    def updateOCRInfo(self, res):
        """
        将ocr识别结果显示在信息框中
        :param res:
        :return:
        """
        if self.ocrType == ocrType.ocr_general or self.ocrType == ocrType.ocr_handwriting:
            if res['code'] == 0 and res['message'] == 'OK':
                self.ui.ocrInfo.setText('OK')
                ocrInfo = []
                for i in range(len(self.result['data']['items'])):
                    ocrInfo.append(
                        self.result['data']['items'][i]['itemstring'])
                self.ui.ocrInfo.setText(''.join(ocrInfo))
            else:
                self.ui.ocrInfo.setText('识别失败!')
        elif self.ocrType == ocrType.ocr_bankcard:
            if res['code'] == 0 and res['message'] == 'OK':
                self.ui.ocrInfo.setText('OK')
                ocrInfo = []
                for i in range(len(self.result['data']['items'])):
                    ocrInfo.append(self.result['data']['items'][i]['item'])
                    ocrInfo.append(':')
                    ocrInfo.append(
                        self.result['data']['items'][i]['itemstring'])
                    ocrInfo.append('\n')
                self.ui.ocrInfo.setText(''.join(ocrInfo))
            else:
                self.ui.ocrInfo.setText('识别失败!')
        elif self.ocrType == ocrType.ocr_idcard:
            if res['result_list'][0]['code'] == 0 and res['result_list'][0][
                    'message'] == 'OK':
                self.ui.ocrInfo.setText('OK')
                ocrInfo = []
                ocrInfo_keys = list(
                    self.result['result_list'][0]['data'].keys())
                ocrInfo_values = list(
                    self.result['result_list'][0]['data'].values())
                for i in range(
                        len(self.result['result_list'][0]['data']) // 2):
                    ocrInfo.append(ocrInfo_keys[i])
                    ocrInfo.append(':')
                    ocrInfo.append(ocrInfo_values[i])
                    ocrInfo.append('\n')
                self.ui.ocrInfo.setText(''.join(ocrInfo))
            else:
                self.ui.ocrInfo.setText('识别失败!')
        elif self.ocrType == ocrType.ocr_namecard:
            if res['result_list'][0]['code'] == 0 and res['result_list'][0][
                    'message'] == 'OK':
                self.ui.ocrInfo.setText('OK')
                ocrInfo = []
                for i in range(len(self.result['result_list'][0]['data'])):
                    ocrInfo.append(
                        self.result['result_list'][0]['data'][i]['item'])
                    ocrInfo.append(':')
                    ocrInfo.append(
                        self.result['result_list'][0]['data'][i]['value'])
                    ocrInfo.append('\n')
                self.ui.ocrInfo.setText(''.join(ocrInfo))
            else:
                self.ui.ocrInfo.setText('识别失败!')
        else:
            pass

    def camControl(self, state):
        """
        槽函数
        控制相机开关
        :param state: checkbox开关状态
        :return:null
        """
        if state == Qt.Unchecked:
            self.ui.cameraShow.setUpdatesEnabled(False)
        elif state == Qt.Checked:
            self.ui.cameraShow.setUpdatesEnabled(True)
        else:
            return -1

    def miniToTray(self):
        """
        槽函数
        最小化到系统托盘
        :return:null
        """
        if not self.tray.isVisible():
            self.tray.show()
        if self.tray.isVisible():
            if self.isFirst is False:
                QMessageBox.information(
                    self, "Systray", "The program will keep running in the "
                    "system tray. To terminate the program, "
                    "choose <b>Quit</b> in the context menu "
                    "of the system tray entry.")
                self.isFirst = True
            self.hide()

    def trayActivatedEvent(self, reason):
        """
        槽函数
        响应点击托盘图标
        :param reason: 响应原因
        :return: null
        """
        if reason == QSystemTrayIcon.Context:
            pass
        else:
            self.tray.hide()
            self.show()

    def openDlg(self):
        """
        槽函数
        打开对话框选取文件
        :return:文件名
        """
        filename, filetype = QFileDialog.getOpenFileName(
            self, '选取图片', path.expanduser('~'),
            "Image Files (*.png *.jpg *.bmp)")
        if filename:
            if QFile(filename).size() >= 6291456:
                QMessageBox.information(self, '打开图片',
                                        '选择图片大于6MB大小,暂不支持识别,请重新选择。')
                self.openDlg()
            else:
                self.displayimage(0, QImage(filename))

    def keyPressEvent(self, e):
        """
        槽函数
        键盘按键响应事件
        :param e: 按键事件
        :return: null
        """
        if e.key() == Qt.Key_Space:
            if self.imageCapture.isReadyForCapture():
                self.camera.searchAndLock()
                self.imageCapture.capture()
                self.camera.unlock()

    def mouseMoveEvent(self, e):
        """
        槽函数
        定义鼠标移动事件
        :param e: QMouseEvent
        :return: null
        """
        if (e.buttons() == Qt.LeftButton) and self.mousePressd:
            self.move(e.globalPos() - self.mousePoint)
            e.accept()

    def mousePressEvent(self, e):
        """
        槽函数
        定义鼠标按下事件
        :param e: QMouseEvent
        :return: null
        """
        if e.button() == Qt.LeftButton:
            self.mousePressd = True
            self.mousePoint = e.globalPos() - self.pos()
            e.accept()

    def mouseReleaseEvent(self, e):
        """
        槽函数
        定义鼠标松开事件
        :param e: QMouseEvent
        :return: null
        """
        self.mousePressd = False

    def changeocrType(self, index):
        """
        槽函数
        改变ocr识别类型
        :param index: int
        :return: null
        """
        if index == 0:
            self.ocrType = ocrType.ocr_general
        elif index == 1:
            self.ocrType = ocrType.ocr_handwriting
        elif index == 2:
            self.ocrType = ocrType.ocr_idcard
        elif index == 3:
            self.ocrType = ocrType.ocr_namecard
        elif index == 4:
            self.ocrType = ocrType.ocr_bankcard
        else:
            pass
Esempio n. 23
0
class TIFgrabGUI(QMainWindow):
    def __init__(self, capcard_full, capcard_short, parent=None):
        super(TIFgrabGUI, self).__init__(parent)

        self.cleanup_side_captures()

        # set up GUI from designer-made layout
        self.ui = Ui_TIFgrabMW()
        self.ui.setupUi(self)

        # Temporarily? hard code the device definition
        self.sys_device = "/dev/video0"
        target_cam_serialnum = capcard_short[self.sys_device]
        target_cam_label = capcard_full[self.sys_device]

        print("Targeting camera device ", self.sys_device)
        print("Labeling as ", target_cam_label)

        self.picframe_width = self.ui.ThumbnailView.frameGeometry().width()
        self.picframe_height = self.ui.ThumbnailView.frameGeometry().height()

        #for device_name in QCamera.availableDevices():
        #    print("Looking at", device_name)
        #    if (device_name == target_cam_dev):
        #self.camera_device = device_name
        #        self.camera_device = target_cam_dev.encode('utf-8')
        self.camera_device = self.sys_device.encode('utf-8')
        self.camera_label = target_cam_label
        self.ui.Sourcename_Disp.setText(self.camera_label)
        self.cam1 = QCamera(self.camera_device)

        #        self.cam1_info = QCameraInfo(self.cam1)
        #        self.cam1_nonhuman_name = self.cam1_info.deviceName()
        #        print("Description= ",self.cam1_info.description())
        #        print("Nonhuman= ", self.cam1_info.deviceName())

        self.cam1_capture = QCameraImageCapture(self.cam1)
        print("Still image capture from device %s, capture card %s)" %
              (self.camera_device, self.camera_label))

        self.cam1.setCaptureMode(QCamera.CaptureStillImage)
        self.cam1_capture.setCaptureDestination(
            QCameraImageCapture.CaptureToBuffer)

        #### Assign a startup image ####
        # print('Displaying startup image')
        #self.tifimage = QPixmap('/home/scotty/src/GrabDev/tasman_island_lighthouse.tif', 'tif')
        self.tifimage = QPixmap('./tasman_island_lighthouse.tif', 'tif')
        self.thumb = self.tifimage.scaled(self.picframe_width,
                                          self.picframe_height,
                                          Qt.KeepAspectRatio)
        self.ui.ThumbnailView.setScaledContents(True)
        self.ui.ThumbnailView.setPixmap(self.thumb)

        # Set event handlers
        self.ui.grabButton.clicked.connect(self.on_grab_button)
        self.ui.TimerRadio.toggled.connect(self.on_timerradio_button)
        self.ui.quitButton.clicked.connect(self.on_quit_button)
        self.cam1_capture.imageCaptured.connect(self.on_image_captured)

        self.ui.FilenameDisp.setText("No image captured")
        self.cam1.start()

    def on_grab_button(self):
        self.cam1.searchAndLock()
        self.capture_time = systime()
        self.capture_name = "./" + self.camera_label + "_" + self.capture_time + ".tif"
        self.cam1_capture.capture()
        self.cam1.unlock()

    def on_image_captured(self, id, captured_image):
        # The image to be displayed on screen
        self.captured2pixmap = QPixmap()
        success = self.captured2pixmap.convertFromImage(captured_image)

        self.list_pic_stats()

        self.thumb_scaled = self.captured2pixmap.scaled(
            self.picframe_width, self.picframe_height, Qt.KeepAspectRatio)
        self.ui.ThumbnailView.setScaledContents(True)
        self.ui.ThumbnailView.setSizePolicy(QSizePolicy.Ignored,
                                            QSizePolicy.Ignored)
        self.ui.FilenameDisp.setText(self.capture_name)
        self.ui.ThumbnailView.setPixmap(self.thumb_scaled)

        # The image to be saved to file as TIF
        # First confirm that the destination folder exists, create if it doesn't.
        self.manage_daily_folder()
        self.capture_fullpath = self.outdirname + "/" + self.capture_name
        outimage = QPixmap()
        outimage.convertFromImage(captured_image)
        outfile = QFile(self.capture_fullpath)
        outfile.open(QIODevice.WriteOnly)
        outimage.save(outfile, "TIFF")
        outfile.close()

    def list_pic_stats(self):

        sizestr = ("Size: %d X %d") % (self.captured2pixmap.width(),
                                       self.captured2pixmap.height())
        depthstr = ("Depth:%s ") % (self.captured2pixmap.depth())
        bmapstr = ("Is Bitmap?:%s") % (self.captured2pixmap.isQBitmap())
        alphastr = ("Has alpha?:%s") % (self.captured2pixmap.hasAlphaChannel())
        self.ui.PicStats.setPlainText(self.sys_device)
        self.ui.PicStats.appendPlainText(sizestr)
        self.ui.PicStats.appendPlainText(depthstr)

    def on_timerradio_button(self):
        if self.ui.TimerRadio.isChecked():
            self.ui.grabButton.setEnabled(False)
            self.add_timer_groupbox()
        if not self.ui.TimerRadio.isChecked():
            if self.timergb:
                self.timergb.grab_timer.stop()
                self.ui.grabButton.setEnabled(True)
                self.timergb.deleteLater()
                self.timergb = None

    def add_timer_groupbox(self):

        self.timergb = TimerGB(75, 100)
        self.timergb.grab_timeout.connect(self.on_grab_button)
        self.timergb.gb_closed.connect(self.on_timergb_closed)
        self.timergb.show()

    def on_timergb_closed(self):
        if self.ui.TimerRadio.isChecked():
            if self.timergb:
                #     self.grab_timer.stop()
                self.timergb.deleteLater()
                self.timergb = None
                self.ui.TimerRadio.setChecked(False)
                self.ui.grabButton.setEnabled(True)

    def cleanup_side_captures(self):
        # Remove jpgs saved by QCameraImageCapture in default location
        defaultlocation = "/home/jason/Pictures"
        print("Removing all jpgs from ", defaultlocation)
        fullpath = ("%s/*.jpg") % (defaultlocation)
        for filename in glob(fullpath):
            print("Removing ", filename)
            os.remove(filename)

    def on_quit_button(self):
        self.cam1.stop()
        try:
            if self.timergb:
                self.timergb.deleteLater()
                self.timergb = None
        except:
            pass

        self.cleanup_side_captures()

        QCoreApplication.exit()

    def sigint_handler(*args):
        try:
            if self.timergb:
                self.timergb.deleteLater()
                self.timergb = None
        except:
            pass
        sys.stderr.write('\r')
        QApplication.quit()

    def do_init(ini_filename):
        cf = ConfigParser()
        cf.read(ini_filename)

    def manage_daily_folder(self):
        # Tests for existence of folder to hold the date's captures.
        # If folder doesn't exist, creates it.
        today = sysdate()

        self.outdirname = "/data/capture_" + today
        if not os.path.exists(self.outdirname):
            os.makedirs(self.outdirname)
Esempio n. 24
0
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()
Esempio n. 25
0
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)
Esempio n. 26
0
class FaceRegistrationView(QDialog):
  def __init__(self, parent=None, face_recognizer=None):
    QDialog.__init__(self, parent=parent)
    self.face_recognizer = face_recognizer
    self.ui = Ui_FaceRegistrationUI()

    self.ui.setupUi(self)

    # Add existing face albums to the combobox
    # FIXME: need to get this list from the face recognizer
    for registry in self.face_recognizer.list_face_registries():
      self.ui.registryNameSelect.addItem(registry)

    self.ui.retakeButton.setEnabled(False)
    self.cur_face_name = None
    self.cur_face_registry = self.ui.registryNameSelect.currentText()
    self.camera = None
    self.image_capture = None
    self.cur_saved_image_path = None
    self.setup_camera()

  def setup_camera(self):
    camera_device = QByteArray()

    for device in QCamera.availableDevices():
      if camera_device.isEmpty():
        camera_device = device
    if camera_device.isEmpty():
      self.camera = QCamera()
    else:
      self.camera = QCamera(camera_device)

    self.image_capture = QCameraImageCapture(self.camera)
    self.image_capture.readyForCaptureChanged.connect(self.ready_for_capture)
    self.image_capture.imageCaptured.connect(self.process_captured_image)
    self.image_capture.imageSaved.connect(self.image_saved)

    self.camera.setViewfinder(self.ui.viewFinder)
    self.camera.start()

  def ready_for_capture(self, ready):
    self.ui.captureButton.setEnabled(ready)

  def process_captured_image(self, request_id, image):
    scaled_image = image.scaled(self.ui.viewFinder.size(),
                                Qt.KeepAspectRatio, Qt.SmoothTransformation)
    self.ui.picturePreview.setPixmap(QPixmap.fromImage(scaled_image))
    self.show_captured_image()

  def image_saved(self, id, file_path):
    self.cur_saved_image_path = file_path
    logger.info('Image saved at {}'.format(file_path))

  def handle_face_name(self, name):
    self.cur_face_name = name

  def register_face(self):
    name = self.ui.nameInput.text()
    if name == '':
      msg_box = QMessageBox()
      msg_box.setIcon(QMessageBox.Critical)
      msg_box.warning(self, 'Error', 'Person name cannot be empty!')
      return

    confirm_msg = 'Register face of {:s} into {:s}?'.format(name,
                                                           self.cur_face_registry)
    reply = QMessageBox.question(self, 'Register face', confirm_msg,
                                   QMessageBox.No, QMessageBox.Yes)
    if reply == QMessageBox.Yes:
      logger.info('Registering {:s}'.format(name))
      try:
        self.face_recognizer.register_face(self.cur_face_registry,
                                           self.cur_saved_image_path, name)
        self.parent().ui.statusbar.showMessage(
          'Successfully registered the face', 2000)

      except Exception as e:
        msg_box = QMessageBox()
        msg_box.setIcon(QMessageBox.Critical)
        msg_box.warning(self, 'Error', str(e))
      # Clean up the captured image and show the video stream again
      self.ui.nameInput.clear()
      # self.ui.nameInput.setText('')
      self.retake_picture()
    else:
      pass

  def retake_picture(self):

    self.delete_current_picture()
    self.ui.captureButton.setEnabled(True)
    self.ui.retakeButton.setEnabled(False)
    self.show_video_stream()

  def capture_picture(self):
    self.image_capture.capture()
    self.ui.captureButton.setEnabled(False)
    self.ui.retakeButton.setEnabled(True)

  def show_captured_image(self):
    self.ui.stackedWidget.setCurrentIndex(1)

  def show_video_stream(self):
    self.ui.stackedWidget.setCurrentIndex(0)

  def set_current_face_registry(self, registry_name):
    self.cur_face_registry = registry_name

  def closeEvent(self, event):
    self.camera.stop()
    self.delete_current_picture()

  def accept(self):
    self.camera.stop()
    self.delete_current_picture()
    QDialog.reject(self)

  def reject(self):
    self.camera.stop()
    logger.info('Cleaning up captured images...')
    self.delete_current_picture()
    QDialog.reject(self)

  def delete_current_picture(self):
    if self.cur_saved_image_path is not None:
      if os.path.exists(self.cur_saved_image_path):
        os.remove(self.cur_saved_image_path)
        logger.info('Deleted {}'.format(self.cur_saved_image_path))
      self.cur_saved_image_path = None
Esempio n. 27
0
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()
Esempio n. 28
0
class AvatarWidget(QWizardPage):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setSubTitle(self.tr("<h2>Create Your Avatar</h2>"))

        vlayout = QVBoxLayout(self)

        labelLayout = QHBoxLayout()
        labelImage = QLabel()
        labelImage.setPixmap(QPixmap(":/data/images/preferences-desktop-personal.png"))
        labelImage.setMaximumSize(64, 64)
        labelLayout.addWidget(labelImage)

        label = QLabel(self)
        label.setWordWrap(True)
        label.setText(self.tr("<p>This screen helps you set your <strong>user picture</strong>. You can either choose an image from a \
        file or you can capture an image from your camera. Select an option from the <strong>options</strong> menu.</p>"))
        labelLayout.addWidget(label)
        vlayout.addLayout(labelLayout)

        vlayout.addItem(QSpacerItem(20, 40, QSizePolicy.Preferred, QSizePolicy.Preferred))

        centerLayout = QHBoxLayout()
        centerLayout.addItem(QSpacerItem(40, 20, QSizePolicy.Preferred, QSizePolicy.Preferred))

        groupBox = QGroupBox()
        groupBox.setMaximumWidth(500)
        vlayout2 = QVBoxLayout(groupBox)
        hlayout = QHBoxLayout()

        comboBox = QComboBox()
        comboBox.setMinimumWidth(250)
        comboBox.addItems([self.tr("Options"), self.tr("Choose an image...")])

        #Camera control
        self.cameraInfo = None
        self.camera = None
        self.cameraImageCapture = None
        cameras = QCameraInfo.availableCameras()

        if len(cameras):
            self.cameraInfo = cameras[0]
            comboBox.addItem(self.tr("Camera ") + self.cameraInfo.deviceName())
            self.camera = QCamera(self.cameraInfo)
            self.camera.setCaptureMode(QCamera.CaptureStillImage)
            self.cameraImageCapture = QCameraImageCapture(self.camera)
            self.imageProcessing = self.camera.imageProcessing()
            self.imageProcessing.setWhiteBalanceMode(QCameraImageProcessing.WhiteBalanceSunlight)
            self.imageProcessing.setContrast(1)
            self.imageProcessing.setSaturation(1)
            self.imageProcessing.setSharpeningLevel(1)
            self.imageProcessing.setDenoisingLevel(1)
            #self.imageProcessing.setColorFilter(QCameraImageProcessing.ColorFilterWhiteboard) #FIXME Qt5.5
            self.cameraImageCapture.imageCaptured.connect(self.imageCapture)

        self.buttonCam = QPushButton()
        self.buttonCam.setText(self.tr("Capture"))
        self.buttonCam.setIcon(QIcon(":/data/images/webcamreceive.png"))
        self.buttonCam.setVisible(False)

        self.buttonReplay = QPushButton()
        self.buttonReplay.setText(self.tr("Recapture"))
        self.buttonReplay.setIcon(QIcon(":/data/images/view-refresh.png"))
        self.buttonReplay.setVisible(False)

        hlayout.addWidget(comboBox)
        hlayout.addItem(QSpacerItem(300, 20, QSizePolicy.Preferred, QSizePolicy.Preferred))
        hlayout.addWidget(self.buttonCam)
        hlayout.addWidget(self.buttonReplay)

        vlayout2.addLayout(hlayout)

        hlayout2 = QHBoxLayout()

        hlayout2.addItem(QSpacerItem(40, 20, QSizePolicy.Preferred, QSizePolicy.Preferred))

        self.cameraLabel = QLabel()
        self.cameraLabel.setScaledContents(True)
        self.cameraLabel.setStyleSheet("background-color: black;")
        self.cameraLabel.setMinimumSize(320, 240)
        self.cameraLabel.setMaximumSize(320, 240)

        self.cameraView = QCameraViewfinder()
        self.cameraView.setMaximumSize(320,240)
        self.cameraView.setMinimumSize(320,240)
        self.cameraView.hide()

        hlayout2.addWidget(self.cameraLabel)
        hlayout2.addWidget(self.cameraView)

        hlayout2.addItem(QSpacerItem(40, 20, QSizePolicy.Preferred, QSizePolicy.Preferred))
        vlayout2.addLayout(hlayout2)

        centerLayout.addWidget(groupBox)
        centerLayout.addItem(QSpacerItem(40, 20, QSizePolicy.Preferred, QSizePolicy.Preferred))
        vlayout.addLayout(centerLayout)
        vlayout.addItem(QSpacerItem(20, 40, QSizePolicy.Preferred, QSizePolicy.Preferred))

        comboBox.currentIndexChanged.connect(self.avatarSelect)
        self.buttonCam.clicked.connect(self.buttonCamChanged)
        self.buttonReplay.clicked.connect(self.buttonReplayChanged)

        self.userAvatar = None

    def avatarSelect(self, index):
        if index == 0:
            if self.camera != None:
                self.camera.stop()
            self.buttonReplay.hide()
            self.buttonCam.hide()
            self.cameraView.hide()
            self.cameraLabel.show()
        elif index == 1:
            if self.camera != None:
                self.camera.stop()
            self.userAvatar = None
            self.buttonReplay.hide()
            self.buttonCam.hide()
            self.cameraView.hide()
            self.cameraLabel.show()
            file_url, file_type = QFileDialog.getOpenFileName(self, self.tr("Choose Avatar"), QDir.homePath(), "Image (*.png *.jpg)")
            if file_url != "":
                p = QPixmap(file_url)
                self.cameraLabel.setPixmap(p)
                self.userAvatar = file_url
        elif index == 2:
            self.userAvatar = None
            self.cameraLabel.hide()
            self.cameraView.show()
            self.camera.setViewfinder(self.cameraView)
            self.camera.start()
            self.buttonCam.setVisible(True)
            self.buttonReplay.hide()

    def buttonCamChanged(self):
        self.buttonCam.hide()
        self.buttonReplay.show()
        self.camera.searchAndLock()
        self.cameraImageCapture.capture("/tmp/avatar.png")
        self.camera.unlock()
        self.userAvatar = "/tmp/avatar.png"

    def buttonReplayChanged(self):
        self.userAvatar = None
        self.buttonReplay.hide()
        self.buttonCam.show()
        self.camera.start()
        self.cameraLabel.hide()
        self.cameraView.show()

    def imageCapture(self, id, preview):
        pixmap = QPixmap.fromImage(preview)
        self.camera.stop()
        self.cameraView.hide()
        self.cameraLabel.show()
        self.cameraLabel.setPixmap(pixmap)

    def execute(self):
        if self.userAvatar:
            if os.path.exists(os.path.join(os.environ["HOME"], ".face.icon")):
                os.remove(os.path.join(os.environ["HOME"], ".face.icon"))
            shutil.copy(self.userAvatar, os.path.join(os.environ["HOME"], ".face.icon"))
Esempio n. 29
0
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()
Esempio n. 30
0
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()