Пример #1
0
    def setCamera(self, cameraDevice):
        if cameraDevice.isEmpty():
            self.camera = QCamera()
        else:
            self.camera = QCamera(cameraDevice)

        self.captureAction.setEnabled(True)
Пример #2
0
 def setCamera(self, cameraDevice):
     if cameraDevice.isEmpty():
         self.camera = QCamera()
     else:
         self.camera = QCamera(cameraDevice)
     self.camera.setViewfinder(self.viewfinder)
     self.camera.start()
Пример #3
0
    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)
Пример #4
0
 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)
Пример #5
0
    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
Пример #6
0
 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)
Пример #7
0
    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
Пример #8
0
    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()  # 开启摄像头
Пример #9
0
 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))
Пример #10
0
    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 select_camera(self, i):
        """Starts the selected camera. If "Choose webcam" is selected, it stops the camera.

		Parameters
		----------
		i:
			Index of the chosen camera.
		"""
        self.Label_Bild.image = logo_with_text
        self.Label_Bild.setPixmap(QPixmap(self.Label_Bild.image))
        if i == 0:
            self.camera.stop()
            self.detector.disable_detection()
            self.Button_Detection.setText(
                QCoreApplication.translate(WINDOW, START))
            self.stacked_widget.setCurrentIndex(0)
            self.camera_viewfinder.hide()
            self.Label_Bild.show()
            time.sleep(2)
            self.Label_Bild.image = logo_with_text
            self.Label_Bild.setPixmap(QPixmap(self.Label_Bild.image))
            self.Label_Bild.setStyleSheet("""
			""")
        else:
            self.camera_viewfinder.show()
            self.stacked_widget.setCurrentIndex(1)
            self.Label_Bild.hide()
            self.camera = QCamera(self.available_cameras[i - 1])
            self.camera.setViewfinder(self.camera_viewfinder)
            self.camera.error.connect(
                lambda: self.alert(self.camera.errorString()))
            self.camera.start()
            self.Button_Bild.setText(QCoreApplication.translate(
                WINDOW, ENABLE))
Пример #12
0
 def create_camera(cameras: list, index: int, viewfinder: QCameraViewfinder,
                   error: Callable) -> QCamera:
     camera = QCamera(cameras[index])
     camera.setViewfinder(viewfinder)
     camera.setCaptureMode(QCamera.CaptureStillImage)
     camera.error.connect(error)
     return camera
Пример #13
0
    def __init__(self):
        QMainWindow.__init__(self)

        if len(QCameraInfo.availableCameras()) == 0:
            QMessageBox.warning(
                self, 'Camera not found',
                'You don\'t have any cameras on your computer so you can\'t use this app...\nBuy a new camera (╯°^°)╯┻━┻',
                QMessageBox.Ok)
            exit(-1)

        self.central_widget = QWidget(self)
        self.main_grid = QGridLayout(self.central_widget)

        self.option_group = QGroupBox(None)

        self.group_grid = QGridLayout(self.option_group)

        self.addr_msg = QLabel('Database addr')
        self.camera_msg = QLabel('Camera')

        self.camera_combo = QComboBox()
        self.addr_edit = QLineEdit()

        self.camera_place = QGroupBox(None)

        self.auth_btn = QPushButton('Log in')
        self.camera_grid = QGridLayout(self.camera_place)

        self.camera_widget = QCameraViewfinder()
        self.camera_obj = QCamera(QCameraInfo.defaultCamera())

        self.veg_cfg = Config()
Пример #14
0
def cameraCheck(**kwargs):
    check_status = False
    if kwargs['operating_mode']['cam_path_used'] == '1':
        camera_user = kwargs['cam_user']['cam_path']
        camera_item = kwargs['cam_item']['cam_path']
    else:
        camera_user = int(kwargs['cam_user']['cam_num'])
        camera_item = int(kwargs['cam_item']['cam_num'])
    camera_device = QCamera(
    )  # You have to declare QCamera object before using QCameraInfo.availableCameras()
    camera_list = QCameraInfo.availableCameras()
    # print(camera_list)  # the result is like [<PyQt5.QtMultimedia.QCameraInfo object at 0x0000029C36641828>, <PyQt5.QtMultimedia.QCameraInfo object at 0x0000029C36641898>]
    if len(camera_list) < 2:
        # print('Camera problem happens!')
        sys.exit('Camera problem: available cameras are not enough!'
                 )  # sys.exit just throws an exception.
    else:
        # try to use cameras to see whether there is some unknown issues.
        cap0 = cv2.VideoCapture(camera_item)
        cap1 = cv2.VideoCapture(camera_user)
        ret0, frame0 = cap0.read()
        ret1, frame1 = cap1.read()
        cap0.release()
        cap1.release()
        if not (ret0 and ret1):
            sys.exit(
                'Camera problem: frame cannot be read successfully. Please take them off and then plugs them in.'
            )

    check_status = True
    return check_status
Пример #15
0
 def __init__(self, parent=QObject()):
     super(Camera, self).__init__(parent)
     # chooses the system default camera
     self.cam = QCamera()
     self.caminfo = QCameraInfo(self.cam)
     self.camvfind = QCameraViewfinder()
     self.camvfindset = QCameraViewfinderSettings()
     self.recorder = QMediaRecorder(self.cam)
Пример #16
0
    def showCamera(self):
        self.finder = QCameraViewfinder()
        self.finder.show()

        self.camera = QCamera()
        self.camera.setViewfinder(self.finder)
        self.camera.start()
        self.camera.stop()
Пример #17
0
  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()
Пример #18
0
 def start_preview(self, i_cam_idx):
     if self.oc_camera is not None:
         self.oc_camera.stop()
         del self.oc_camera
     self.oc_camera = QCamera(self.l_cameras[i_cam_idx])
     self.oc_camera.setViewfinder(self.oc_viewfinder)
     self.oc_camera.setCaptureMode(QCamera.CaptureVideo)
     self.oc_camera.error.connect(lambda: self.show_error(self.oc_camera.errorString()))
     self.oc_camera.start()
Пример #19
0
 def __init__(self):
     super(self.__class__, self).__init__()
     self.setupUi(self)  # gets defined in the UI file
     # th = CamThread(self)
     # th.changePixmap.connect(self.setImagae)
     # th.start()
     self.cam = QCamera()
     self.cam.setViewfinder(self.widget)
     self.cam.start()
Пример #20
0
    def setupUi(self):
        """
        设置UI界面
        :return:
        """
        self.resize(600, 600)

        m_camer = QCamera()
        m_ImageCapture = QCameraImageCapture(m_camer)
        m_camerinfo = QCameraInfo()
Пример #21
0
 def __init__(self, parent = QObject()):
     super(Camera, self).__init__(parent)
     print("3")
     self.cam = QCamera(QCameraInfo.defaultCamera())   #"/dev/video0".encode()
     print("4")
     self.caminfo = QCameraInfo(self.cam)
     self.camvfind = QCameraViewfinder()
     self.camvfindset = QCameraViewfinderSettings()
     self.cammode = self.cam.CaptureMode(0)
     self.camimgcap = QCameraImageCapture(self.cam)
Пример #22
0
    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)
Пример #23
0
	def __init__(self,parent = None):
		super(QCameraImageCapture, self).__init__(None,parent)

		self.camera = QCamera()
		self.camera.setCaptureMode(QCamera.CaptureStillImage);

		self.setMediaObject(self.camera)
		# self.setCaptureDestination(QCameraImageCapture.CaptureToFile)

		self.imageSaved.connect(self._captureComplete)
		self.imageCaptured.connect(self._imageCaptured)
Пример #24
0
    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)
Пример #25
0
 def iniCamera(self):
     cameras = QCameraInfo.availableCameras()
     for cameraInfo in cameras:
         # select the capturing device if it is available
         if (cameraInfo.description().find("Capture") is not -1):
             self.cam = QCamera(cameraInfo)
             self.caminfo = QCameraInfo(self.cam)
             self.recorder = QMediaRecorder(self.cam)
         print("Camera Chosen: " + self.caminfo.description())
     print(self.cam.supportedViewfinderFrameRateRanges())
     if self.cam.isCaptureModeSupported(QCamera.CaptureVideo):
         print("Capturemode supported")
Пример #26
0
    def __init__(self, parent=None):
        super(VideoWindow, self).__init__(parent)
        self.setWindowTitle(
            "PyQt Video Player Widget Example - pythonprogramminglanguage.com")

        self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
        self.camera = QCamera(0)
        self.cameraviewfinder = QCameraViewfinder()
        self.cameramode = self.camera.CaptureMode(2)
        self.cameraimgcap = QCameraImageCapture(self.camera)

        videoWidget = QVideoWidget()
        self.imageView = QLabel("add a image file")
        self.imageView.setAlignment(Qt.AlignCenter)
        self.playButton = QPushButton()
        self.playButton.setEnabled(True)
        self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
        self.playButton.clicked.connect(self.play)

        self.positionSlider = QSlider(Qt.Horizontal)
        self.positionSlider.setRange(0, 0)

        self.scene1 = QGraphicsScene()
        self.view1 = QGraphicsView(self.scene1)

        # Create new action

        # Create exit action

        # Create a widget for window contents
        wid = QWidget(self)
        self.setCentralWidget(wid)

        # Create layouts to place inside widget
        # controlLayout = QHBoxLayout()
        # controlLayout.setContentsMargins(0, 0, 0, 0)
        # controlLayout.addWidget(self.playButton)
        # controlLayout.addWidget(self.positionSlider)

        videolayout = QVBoxLayout()
        videolayout.addWidget(videoWidget)

        # videolayout.addLayout(controlLayout)
        # Set widget to contain window contents

        layout = QHBoxLayout()
        layout.addLayout(videolayout)
        layout.addWidget(self.cameraviewfinder)
        # layout.addWidget(self.view1)
        wid.setLayout(layout)
        self.mediaPlayer.setVideoOutput(videoWidget)
        self.cameraviewfinder.show()
        self.camera.setViewfinder(self.cameraviewfinder)
Пример #27
0
    def __fetch_cam(self):
        for device_obj in QCamera.availableDevices():
            cam_name = QCamera.deviceDescription(device_obj)

            cam = QCamera(device_obj)
            self.cams[str(cam_name)] = cam

            cam_image_capture = QCameraImageCapture(cam)
            cam_image_capture.setEncodingSettings(QImageEncoderSettings())
            cam_image_capture.captureDestination()
            cam_image_capture.imageSaved.connect(self.on_image_saved)
            self.__cam_image_captures[str(cam_name)] = cam_image_capture
            cam.statusChanged.connect(self.set_resolution)
Пример #28
0
    def start(self, dev=1):
        if self.camera:
            self.camera.stop()
        cameras = QCameraInfo.availableCameras()
        self.camera = QCamera(cameras[dev])
        self.camera.setViewfinder(self.viewfinder)
        self.camera.setCaptureMode(QCamera.CaptureStillImage)
        self.camera.start()

        self.camera_capture = QCameraImageCapture(self.camera)
        self.camera_capture.setCaptureDestination(
            QCameraImageCapture.CaptureToBuffer)
        self.camera_capture.imageCaptured.connect(self.imageCaptured)
Пример #29
0
    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()
Пример #30
0
    def setup_camera(self):
        camera_device = QByteArray()

        video_devices_group = QActionGroup(self)
        video_devices_group.setExclusive(True)

        for device in QCamera.availableDevices():
            description = QCamera.deviceDescription(device)
            video_device_action = QAction(description, video_devices_group)
            video_device_action.setCheckable(True)
            video_device_action.setData(device)

            if camera_device.isEmpty():
                camera_device = device
                video_device_action.setChecked(True)

            self.ui.menuDevices.addAction(video_device_action)
        if camera_device.isEmpty():
            self.camera = QCamera()
        else:
            self.camera = QCamera(camera_device)
        self.camera.setViewfinder(self.ui.cameraViewFinder)