I am writing a program in pyqt that needs to display a real-time video stream acquired via an Allied Vision camera (Alvium G1-500m). In the code I have made a mainthread that manages the gui and launches the various routines via QThread. The QThread that launches the stream works and returns the image correctly, the problem occurs at the moment when I want to close the program. The moment the program is closed, the closure is done in a forced manner, it crashes since the QThread of the stream is not killed in a safe manner. Now it will be logical to say " Close the QThread in a safe way," here, I can't find the right way. This code works, the QThread is only killed in a safe manner when the enter key is pressed from the terminal, but I need the use of a signal or something similar to do it automatically
from PyQt5.QtCore import QThread, pyqtSignal
from PyQt5.QtGui import QImage
from PyQt5 import QtGui
from vmbpy import *
import sys
class VideoThread(QThread):
change_pixmap_signal = pyqtSignal(QImage)
stop_stream_signal = pyqtSignal()
def __init__(self, size_image: list, offset_image: list, exposure: int):
QThread.__init__(self)
self.cam = None
self.allocation_mode = AllocationMode.AnnounceFrame
self.opencv_display_format = PixelFormat.Mono8
self.exposure = exposure
self.widthFrameCamera = size_image[0]
self.heightFrameCamera = size_image[1]
self.offsetXCamera = offset_image[0]
self.offsetYCamera = offset_image[1]
self.mutex = True
def run(self) -> None:
with VmbSystem.get_instance() as vmb:
cams = vmb.get_all_cameras()
with cams[0] as cam:
self.cam = cam
self.setup_camera(cam)
try:
# Start Streaming with a custom a buffer of 10 Frames (defaults to 5)
cam.start_streaming(handler=self.frame_handler,
buffer_count=10,
allocation_mode=self.allocation_mode)
input() # That function is waiting for enter button in the command line
finally: # once the enter key has been pressed the finally is executed
cam.stop_streaming()
def setup_camera(self, cam: Camera):
#Some code
def setup_pixel_format(self, ):
#Some code
def frame_handler(self, cam: Camera, stream: Stream, frame: Frame):
# print('{} acquired {}'.format(cam, frame), flush=True)
image = frame.as_opencv_image()
bytes_per_frame = self.widthFrameCamera
qt_format = QtGui.QImage(image,
self.widthFrameCamera,
self.heightFrameCamera,
bytes_per_frame,
QImage.Format_Grayscale8)
self.change_pixmap_signal.emit(qt_format) #Image emitted to GUI
self.cam.queue_frame(frame)
That's my main window, the code currently being closed does not handle the safe closure of the stream
import time
import numpy as np
from PyQt5.QtWidgets import QMainWindow, QMessageBox, QWidget, QApplication, QVBoxLayout, QShortcut, QLabel, QFrame
from PyQt5.QtCore import Qt, pyqtSlot, QRect
from PyQt5.QtGui import QImage, QPixmap, QKeySequence, QPen, QPainter, QCloseEvent, QStandardItemModel, QStandardItem
from PIL import Image
import shutil
from frontend.gui import Ui_MainWindow
import sys
import cameraThread
import azureThread
import os
import json
class OcrWindow(QMainWindow, Ui_MainWindow, QWidget):
def __init__(self, parent=None):
super().__init__(parent)
self.setupUi(self)
##Read config file where are stored Azure API KEY and some info about the camera
##TODO: think about what kind of info about the camera put in this file
file_config = self.readConfigFile()
size_image = file_config['sizeImage']
offset_image = file_config['offsetImage']
exposure = file_config['exposure']
azureconfig = file_config['azure']
##Stream box
streamBox = QVBoxLayout()
streamBox.addWidget(self.imageStream)
self.imageTemp = None
self.streamThread = cameraThread.VideoThread(size_image,offset_image,exposure)
self.streamThread.start()
@pyqtSlot(QImage)
def renderStreamImage(self, img):
new_image = QPixmap.fromImage(img)
painterInstance = QPainter(new_image)
penRectangle = QPen(Qt.red)
penRectangle.setWidth(3)
painterInstance.setPen(penRectangle)
painterInstance.drawRect(182.5, 247.5, 605, 205)
self.imageStream.setPixmap(new_image)
self.imageTemp = new_image
def closeEvent(self, event: QCloseEvent):
time.sleep(2) # Wait for the thread to stop gracefully
sys.exit(app.exec()) # Accept the close event
if __name__ == "__main__":
app = QApplication(sys.argv)
win = OcrWindow()
win.show()
sys.exit(app.exec())
The first thing I did was try to add a flag that is set to False when the stream is to be closed. This resolution does not work since the stream still does not terminate.
class VideoThread(QThread):
def __init__(self, size_image: list, offset_image: list, exposure: int):
QThread.__init__(self)
self.mutex = True
def run(self) -> None:
with VmbSystem.get_instance() as vmb:
cams = vmb.get_all_cameras()
with cams[0] as cam:
self.cam = cam
self.setup_camera(cam)
try:
# Start Streaming with a custom a buffer of 10 Frames (defaults to 5)
cam.start_streaming(handler=self.frame_handler,
buffer_count=10,
allocation_mode=self.allocation_mode)
#Deleted Input() function
while self.mutex: ## < --
pass
finally: # once the enter key has been pressed the finally is executed
cam.stop_streaming()
def setup_camera(self, cam: Camera):
#Some code
def setup_pixel_format(self, ):
#Some code
def frame_handler(self, cam: Camera, stream: Stream, frame: Frame):
#Some code
def abort(self, return_code: int = 1): ## <--
self.mutex = False
class OcrWindow(QMainWindow, Ui_MainWindow, QWidget):
def __init__(self, parent=None):
super().__init__(parent)
#Same code
def closeEvent(self, event: QCloseEvent):
self.streamThread.abort() ## <--
time.sleep(2) # Wait for the thread to stop gracefully
sys.exit(app.exec()) # Accept the close event
The second option I used was to use a pyqtSignal() signal so as to pass in a thread safe way the notification of an event. In this way, closing in safe mode works, but it creates another basic problem, which is a drastic drop in FPS and a flickering of the camera stream while using it
class VideoThread(QThread):
stop_stream_signal = pyqtSignal() ## <-
def __init__(self, size_image: list, offset_image: list, exposure: int):
QThread.__init__(self)
def run(self) -> None:
with VmbSystem.get_instance() as vmb:
cams = vmb.get_all_cameras()
with cams[0] as cam:
self.cam = cam
self.setup_camera(cam)
try:
# Start Streaming with a custom a buffer of 10 Frames (defaults to 5)
cam.start_streaming(handler=self.frame_handler,
buffer_count=10,
allocation_mode=self.allocation_mode)
self.stop_stream_signal.connect(self.stop_stream) ## <-
while self.isRunning(): #<--
pass
finally: # once the enter key has been pressed the finally is executed
cam.stop_streaming()
def stop_stream(self): ## <--
self.quit()
def setup_camera(self, cam: Camera):
#Some code
def setup_pixel_format(self, ):
#Some code
def frame_handler(self, cam: Camera, stream: Stream, frame: Frame):
#Some code
class OcrWindow(QMainWindow, Ui_MainWindow, QWidget):
def __init__(self, parent=None):
super().__init__(parent)
#Same code
def closeEvent(self, event: QCloseEvent):
self.streamThread.stop_stream_signal.emit() ## <--
time.sleep(2) # Wait for the thread to stop gracefully
sys.exit(app.exec()) # Accept the close event
Could you also explain why the input function does not create these problems? Thanks!