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()
class Camera(QObject):
def __init__(self, parent = QObject()):
super(Camera, self).__init__(parent)
print("3")
self.cam = QCamera(QCameraInfo.defaultCamera()) #"/dev/video0".encode()
print("4")
self.caminfo = QCameraInfo(self.cam)
self.camvfind = QCameraViewfinder()
self.camvfindset = QCameraViewfinderSettings()
self.cammode = self.cam.CaptureMode(0)
self.camimgcap = QCameraImageCapture(self.cam)
def iniCamera(self):
print(self.caminfo.description())
print(self.caminfo.availableCameras())
for caminfo in QCameraInfo.availableCameras():
print(caminfo.deviceName())
if self.cam.isCaptureModeSupported(self.cammode):
print("Capturemode supported")
def startVid(self):
#self.camimgcap.CaptureDestination(2)
self.camvfind.show()
self.cam.setViewfinder(self.camvfind)
self.cam.setCaptureMode(self.cammode)
self.cam.start()
def __init__(self, parent=QObject()):
super(Camera, self).__init__(parent)
# chooses the system default camera
self.cam = QCamera()
self.caminfo = QCameraInfo(self.cam)
self.camvfind = QCameraViewfinder()
self.camvfindset = QCameraViewfinderSettings()
self.recorder = QMediaRecorder(self.cam)
def __init__(self, parent = QObject()):
super(Camera, self).__init__(parent)
print("3")
self.cam = QCamera(QCameraInfo.defaultCamera()) #"/dev/video0".encode()
print("4")
self.caminfo = QCameraInfo(self.cam)
self.camvfind = QCameraViewfinder()
self.camvfindset = QCameraViewfinderSettings()
self.cammode = self.cam.CaptureMode(0)
self.camimgcap = QCameraImageCapture(self.cam)
def iniCamera(self):
cameras = QCameraInfo.availableCameras()
for cameraInfo in cameras:
# select the capturing device if it is available
if (cameraInfo.description().find("Capture") is not -1):
self.cam = QCamera(cameraInfo)
self.caminfo = QCameraInfo(self.cam)
self.recorder = QMediaRecorder(self.cam)
print("Camera Chosen: " + self.caminfo.description())
print(self.cam.supportedViewfinderFrameRateRanges())
if self.cam.isCaptureModeSupported(QCamera.CaptureVideo):
print("Capturemode supported")
def start_scan(self, device: str = ''):
"""
Scans a QR code from the given camera device.
If no QR code is found the returned string will be empty.
If the camera is not found or can't be opened NoCamerasFound will be raised.
"""
self.validator = QrReaderValidatorCounted()
self.validator.strong_count = 5 # FIXME: make this time based rather than framect based
device_info = None
for camera in QCameraInfo.availableCameras():
if camera.deviceName() == device:
device_info = camera
break
if not device_info:
self.logger.info(
'Failed to open selected camera, trying to use default camera')
device_info = QCameraInfo.defaultCamera()
if not device_info or device_info.isNull():
raise NoCamerasFound(
_("Cannot start QR scanner, no usable camera found.") +
self._linux_pyqt5bug_msg())
self._init_stats()
self.qrreader_res = []
self.validator_res = None
self._ok_done = False
self._error_message = None
if self.camera:
self.logger.info(
"Warning: start_scan already called for this instance.")
self.camera = QCamera(device_info)
self.camera.setViewfinder(self.video_surface)
self.camera.setCaptureMode(QCamera.CaptureViewfinder)
# this operates on camera from within the signal handler, so should be a queued connection
self.camera_sc_conn = self.camera.statusChanged.connect(
self._on_camera_status_changed, Qt.QueuedConnection)
self.camera.error.connect(
self._on_camera_error
) # log the errors we get, if any, for debugging
# Camera needs to be loaded to query resolutions, this tries to open the camera
self.camera.load()
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
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 __init__(self, *args, **kwargs):
super(CMainWindow, self).__init__(*args, **kwargs)
self.oc_camera = None
self.l_cameras = QCameraInfo.availableCameras()
if len(self.l_cameras) == 0:
self.fatal_error("No cameras found!")
# Top tool-bar
self.oc_toolbar = QtWidgets.QToolBar("Video source selector")
self.oc_toolbar.setMovable(False)
lbl = QtWidgets.QLabel("Select video source:")
self.oc_toolbar.addWidget(lbl)
camera_selector = QtWidgets.QComboBox()
camera_selector.addItems([ "[ %i ] %s" % (i_idx, oc_cam.description()) for i_idx, oc_cam in enumerate(self.l_cameras)])
camera_selector.currentIndexChanged.connect( self.start_preview )
self.oc_toolbar.addWidget(camera_selector)
self.oc_toolbar.layout().setSpacing(5)
self.oc_toolbar.layout().setContentsMargins(5, 5, 5, 5)
self.addToolBar(self.oc_toolbar)
# Central part (video frame)
self.oc_viewfinder = QCameraViewfinder()
self.setCentralWidget(self.oc_viewfinder)
# Bottom status bar
self.status = QtWidgets.QStatusBar()
self.setStatusBar(self.status)
self.setWindowTitle("CamView")
self.start_preview(0)
def CamerasDetect(self):
# myDebug(self.__class__.__name__, get_current_function_name())
detects_usb = QCameraInfo.availableCameras()
if not CameraController.isMindVisionDetectedOn and mvsdk:
CameraController.isMindVisionDetectedOn = True
threading.Thread(target=CameraController.CamerasMindVisionDetect_thread_func).start()
# detects_MindVision = Common.mvsdk.CameraEnumerateDevice()
detects_MindVision = CameraController.detects_MindVision
detects_usb_size = len(detects_usb)
detects_MindVision_size = 0
if detects_MindVision:
detects_MindVision_size = len(detects_MindVision)
isChanged = False
if len(self.mCameraAvailable) == detects_usb_size + detects_MindVision_size:
for i, data in enumerate(detects_usb):
if self.mCameraAvailable[i] != data:
isChanged = True
self.mCameraAvailable[i] = data
if detects_MindVision:
for i, data in enumerate(detects_MindVision):
if self.mCameraAvailable[i+detects_usb_size] != data:
isChanged = True
self.mCameraAvailable[i+detects_usb_size] = data
else:
isChanged = True
self.mCameraAvailable = []
for data in detects_usb:
self.mCameraAvailable.append(data)
if detects_MindVision:
for data in detects_MindVision:
self.mCameraAvailable.append((data))
if isChanged:
self.signalCamerasChanged.emit()
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 __init__(self, background_color):
QWidget.__init__(self)
self.scene = QGraphicsScene(self)
self.scene.setBackgroundBrush(QBrush(background_color))
self.graphics_view = QGraphicsView(self.scene)
self.graphics_view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.graphics_view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.graphics_view.setFrameStyle(0)
self.graphics_view.setStyleSheet(
"QGraphicsView {background: transparent; border: 3px; outline: none;}"
)
self.graphics_view.scale(-1,
1) # this make live video from camero mirror.
self.video_item = QGraphicsVideoItem()
self.scene.addItem(self.video_item)
self.layout = QVBoxLayout(self)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.graphics_view)
self.available_cameras = QCameraInfo.availableCameras()
# Set the default camera.
self.select_camera(0)
def __init__(self, oc_global_cfg, *args, **kwargs):
super(CMainWindow, self).__init__(*args, **kwargs)
self.oc_global_cfg = oc_global_cfg
self.f_initial_frame_rate = float(
self.oc_global_cfg['general']['initial_frame_rate'])
self.oc_frame_cap_thread = None
self.win_preview = None
# check if we have any cameras before doing anything else
self.l_cameras = QCameraInfo.availableCameras()
if len(self.l_cameras) == 0:
self.fatal_error("No cameras found!")
self.lbl_video_source = QtWidgets.QLabel("Select video source:")
self.cbox_cam_selector = QtWidgets.QComboBox()
self.cbox_cam_selector.addItems([
"[ %i ] %s" % (i_idx, oc_cam.description())
for i_idx, oc_cam in enumerate(self.l_cameras)
])
self.btn_preview = QtWidgets.QPushButton("Preview")
self.btn_preview.clicked.connect(self.__cb_on_btn_preview)
layout = QtWidgets.QGridLayout()
layout.addWidget(self.lbl_video_source, 0, 0, 1, 1)
layout.addWidget(self.cbox_cam_selector, 1, 0, 1, 1)
layout.addWidget(self.btn_preview, 1, 1, 1, 1)
self.setLayout(layout)
self.setMinimumWidth(350)
self.setWindowTitle("Video Source Selector")
def openCameras(self):
self.setBScale(False)
self.setBDraw(False)
for info in QCameraInfo.availableCameras():
self.m_camera.append(info)
if len(self.m_camera) < 2:
messageBox_info('please get your binocular cameras', self)
else:
self.camerasSelectDialog = QDialog(self)
self.camerasSelectDialog.setMinimumWidth(950)
self.camerasSelectDialog.setWindowTitle('Select your disired cameras')
camerasSelectDialogLayout = QGridLayout()
leftLabel = QLabel('left')
rightLabel = QLabel('right')
leftCameraButtonGroup = QButtonGroup(self.camerasSelectDialog)
rightCameraButtonGroup = QButtonGroup(self.camerasSelectDialog)
camerasSelectDialogLayout.addWidget(leftLabel, 1, 0)
camerasSelectDialogLayout.addWidget(rightLabel, 2, 0)
for i in range(len(self.m_camera)):
capLabel = QLabel()
capLabel.setFixedSize(400, 300)
cap = cv2.VideoCapture(i)
_, then_cap = cap.read()
cap.release()
cv2.destroyAllWindows()
capLabel.setPixmap(QPixmap.fromImage(npndarray2qimage(then_cap)))
camerasSelectDialogLayout.addWidget(capLabel, 0, i+1)
indexStr = 'Index: %d'%i
optionalLeftCameraRadioButton = QRadioButton(indexStr)
leftCameraButtonGroup.addButton(optionalLeftCameraRadioButton, i)
optionalRightCameraRadioButton = QRadioButton(indexStr)
rightCameraButtonGroup.addButton(optionalRightCameraRadioButton, i)
if i == 0:
optionalLeftCameraRadioButton.setChecked(True)
optionalRightCameraRadioButton.setChecked(True)
camerasSelectDialogLayout.addWidget(optionalLeftCameraRadioButton, 1, i+1)
camerasSelectDialogLayout.addWidget(optionalRightCameraRadioButton, 2, i+1)
button = QDialogButtonBox(self.camerasSelectDialog)
button.addButton('OK', QDialogButtonBox.YesRole)
button.addButton('Cancel', QDialogButtonBox.NoRole)
button.accepted.connect(self.camerasSelectDialog.accept)
button.rejected.connect(self.camerasSelectDialog.reject)
camerasSelectDialogLayout.addWidget(button, 3, 0, 1, -1)
self.camerasSelectDialog.setLayout(camerasSelectDialogLayout)
res = self.camerasSelectDialog.exec_()
if res == QDialog.Accepted:
if self.leftCameraId > -1:
self.left_cap.release()
if self.rightCameraId > -1:
self.right_cap.release()
cv2.destroyAllWindows()
self.leftCameraId = leftCameraButtonGroup.checkedId()
self.rightCameraId = rightCameraButtonGroup.checkedId()
self.cfg.set('binocular_cameras', 'leftCameraId', str(self.leftCameraId))
self.cfg.set('binocular_cameras', 'rightCameraId', str(self.rightCameraId))
self.cfg.write(open('SWQT.ini', 'w'))
self.left_cap = cv2.VideoCapture(self.leftCameraId)
self.right_cap = cv2.VideoCapture(self.rightCameraId)
self.m_camera.clear()
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 get_available_cameras():
qcameras = QCameraInfo.availableCameras()
res = []
for cam in qcameras:
# pretty ugly hack...
if cam.description().startswith("DMK"):
res.append(cam)
return res
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 swapcamera(self):
cameras = QCameraInfo.availableCameras()
if self.current_camera_index + 1 == len(cameras):
self.current_camera_index = 0
else:
self.current_camera_index += 1
self.start(self.current_camera_index)
def iniCamera(self):
print(self.caminfo.description())
print(self.caminfo.availableCameras())
for caminfo in QCameraInfo.availableCameras():
print(caminfo.deviceName())
if self.cam.isCaptureModeSupported(self.cammode):
print("Capturemode supported")
def __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 setupUi(self):
"""
设置UI界面
:return:
"""
self.resize(600, 600)
m_camer = QCamera()
m_ImageCapture = QCameraImageCapture(m_camer)
m_camerinfo = QCameraInfo()
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 initValues(self):
self.addr_edit.setText(self.veg_cfg.get_db_addr())
self.camera_obj.setCaptureMode(QCamera.CaptureStillImage)
if self.veg_cfg.get_debug() == True:
self.group_grid.addWidget(self.addr_msg, 0, 0, 1, 2)
self.group_grid.addWidget(self.camera_msg, 1, 0, 1, 2)
self.addr_edit.setAlignment(Qt.AlignRight)
self.group_grid.addWidget(self.addr_edit, 0, 2, 1, 5)
for i in QCameraInfo.availableCameras():
self.camera_combo.addItem(i.deviceName())
self.camera_combo.setCurrentText(
QCameraInfo.defaultCamera().deviceName())
self.group_grid.addWidget(self.camera_combo, 1, 2, 1, 5)
self.option_group.setTitle('Option')
self.main_grid.addWidget(self.option_group, 0, 0, 2, 5)
else:
self.option_group.hide()
class Camera(QObject):
def __init__(self, parent=QObject()):
super(Camera, self).__init__(parent)
# chooses the system default camera
self.cam = QCamera()
self.caminfo = QCameraInfo(self.cam)
self.camvfind = QCameraViewfinder()
self.camvfindset = QCameraViewfinderSettings()
self.recorder = QMediaRecorder(self.cam)
def iniCamera(self):
cameras = QCameraInfo.availableCameras()
for cameraInfo in cameras:
# select the capturing device if it is available
if (cameraInfo.description().find("Capture") is not -1):
self.cam = QCamera(cameraInfo)
self.caminfo = QCameraInfo(self.cam)
self.recorder = QMediaRecorder(self.cam)
print("Camera Chosen: " + self.caminfo.description())
print(self.cam.supportedViewfinderFrameRateRanges())
if self.cam.isCaptureModeSupported(QCamera.CaptureVideo):
print("Capturemode supported")
def startVid(self):
self.cam.load()
# self.camvfind.show()
self.cam.setViewfinder(self.camvfind)
self.cam.setCaptureMode(QCamera.CaptureVideo)
self.cam.start()
audio = QAudioEncoderSettings()
audio.setCodec("audio/amr")
audio.setQuality(QtMultimedia.QMultimedia.NormalQuality)
video = QVideoEncoderSettings()
# video.setCodec("video/mp4")
video.setQuality(QtMultimedia.QMultimedia.NormalQuality)
video.setResolution(1920, 1080)
video.setFrameRate(30.0)
# self.recorder.setAudioSettings(audio)
self.recorder.setVideoSettings(video)
self.recorder.setContainerFormat("mp4")
def startRecording(self, filename):
directory = os.path.abspath(str(os.getcwd()))
abs_path = os.path.join(directory, filename)
self.recorder.setOutputLocation(QUrl(abs_path))
self.recorder.record()
def stopRecording(self):
self.recorder.stop()
def getViewFinder(self):
return self.camvfind
def __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 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)
def __init__(self):
super().__init__()
self.cams: Dict[str, QCamera] = {}
self.__cam_image_captures: Dict[str, QCameraImageCapture] = {}
self.__fetch_cam()
self.selected_cam_names = []
try:
default_camera_name = QCameraInfo.defaultCamera().description()
if default_camera_name is not '':
self.selected_cam_names.append(default_camera_name)
# TODO: Find correct error by using the computer which has no default camera
except Exception:
print('No default camera')
def init_camera_and_capture(self) -> bool:
available_cameras = QCameraInfo.availableCameras()
if not available_cameras:
return False
self.camera = self.create_camera(available_cameras, 0,
self.cameraViewfinder,
self.error_camera)
self.capture = self.create_capture(self.camera,
self.process_image_on_threadpool,
self.error_camera)
if self.camera.isAvailable():
self.camera.start()
return True
def _find_camera_info(requested_device_name):
if requested_device_name is None or requested_device_name == "":
camera = QCameraInfo.defaultCamera()
else:
matching_cameras = [
c for c in QCameraInfo.availableCameras()
if c.deviceName() == requested_device_name
]
try:
camera = one(matching_cameras)
except ValueError as e:
raise ValueError(
"Multiple cameras found with requested device name: "
f"{requested_device_name}") from e
except IndexError as e:
available_cameras = ", ".join(
c.deviceName() for c in QCameraInfo.availableCameras())
raise ValueError("No camera found with requested device name: "
f"{requested_device_name}, available devices: "
f"{available_cameras}") from e
logging.info("Found QCamera: %s", camera.deviceName())
return camera
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.ui = Ui_CameraDialog()
self.ui.setupUi(self)
self.ui.libraryButton.clicked.connect(self.choose_library_files)
settings = QSettings("Fringes", "Fringes")
zwo_library_path = settings.value("zwo_library_path")
if zwo_library_path is None:
zwo_library_path = self.get_zwo_library_path()
settings.setValue("zwo_library_path", zwo_library_path)
self.current_camera = None
self.available_cameras = []
try:
ZwoCamera.init_library(zwo_library_path)
for num in ZwoCamera.get_available_cameras():
self.available_cameras.append(
self.Available_Camera(name="ZWO camera #{}".format(num),
class_=ZwoCamera,
kwargs=dict(cam_number=num)))
except (zwoasi.ZWO_Error, OSError) as err:
qDebug(str(err))
qcameras = QCameraInfo.availableCameras()
try:
tiscameras = TisCamera.get_available_cameras()
except NameError:
qDebug("Unable to open TIS camera interface.")
tiscameras = []
for device in qcameras:
if device in tiscameras:
self.available_cameras.append(
self.Available_Camera(name=device.description(),
class_=TisCamera,
kwargs=dict(device=device)))
elif not device.description().startswith("ASI"):
self.available_cameras.append(
self.Available_Camera(name=device.description(),
class_=QtCamera,
kwargs=dict(device=device)))
names = [cam.name for cam in self.available_cameras]
model = QStringListModel(names)
self.ui.listView.setModel(model)
def __init__(self, background_color):
QWidget.__init__(self)
self.scene = QGraphicsScene(self)
self.scene.setBackgroundBrush(QBrush(background_color))
self.graphics_view = QGraphicsView(self.scene)
self.graphics_view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.graphics_view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.graphics_view.setFrameStyle(0)
self.graphics_view.setStyleSheet("QGraphicsView {background: transparent; border: 3px; outline: none;}")
self.graphics_view.scale(-1, 1) # this make live video from camero mirror.
self.video_item = QGraphicsVideoItem()
self.scene.addItem(self.video_item)
self.layout = QVBoxLayout(self)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.graphics_view)
self.available_cameras = QCameraInfo.availableCameras()
# Set the default camera.
self.select_camera(0)
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
