如何在二级监视器上全屏显示图像？

Question

如何使用PyQt5/PySide或任何其他Python库以全屏模式在辅助监视器上显示所需的图像？过去，我使用帧缓冲区图像查看器（Fbi和Fbi improved）。然而，这种方法要求我使用Linux。我更喜欢在Windows环境下工作，最好使用Python找到解决方案。在

动机/背景

我正在研究基于DLP投影的3D打印过程。当我使用HDMI将DLP投影仪连接到我的Windows PC时，它会显示为第二个监视器。我想将这个辅助监视器（DLP）专用于显示3D打印过程所需的图案图像（png、bmp或svg）。我想用Python编程控制显示哪个图像。 这是https://3dprinting.stackexchange.com/questions/1217/how-to-display-images-on-dlp-using-hdmi-for-3d-printing的后续问题

下面的代码是一个可能的解决方案，但是我不确定这是正确的还是最有效的方法。我发现使用PyQt5有两种方法：1）使用初始屏幕，2）使用QLabel。我的代码面临以下问题：

• 光标按预期被隐藏，但是如果我不小心在辅助屏幕上单击鼠标，初始屏幕将关闭。在
• 如果我使用QLabel方法，我会看到一个白色屏幕出现，然后我的图像被加载。从出现白屏到显示实际图像之间有明显的延迟~0.5-1s。在
• 如果图像以高频显示（例如：每1秒一次），这个代码就不能正常工作。例如，在代码中，将total_loops=1更改为total_loops=25。当使用初始屏幕方法时，我看到启动屏幕出现在主屏幕上，然后它移动到辅助屏幕。当使用QLabel方法时，我看到的只是一个白色屏幕出现，并且只显示最后一次迭代的图像。此外，QLabel的窗口在主屏幕上变为活动状态，并在任务栏中可见。在
• 如果我想显示视频而不是图像，如何处理这种情况？在

对于3D打印应用，解决方案需要满足以下要求：

• 辅助屏幕是DLP投影仪，它不应该包含任何与操作系统相关的窗口/任务栏等。。。在
• 辅助屏幕上不应出现光标/鼠标或其他应用程序
• 图像/视频需要以全屏模式显示
• 在副屏幕上显示或更新图像时，主屏幕上应无干扰。例如，辅助屏幕中的图像窗口不应将焦点从主屏幕中的当前活动窗口中移开

import time
start_time = time.time() 
import sys
from PyQt5.QtWidgets import QApplication, QLabel, QSplashScreen
from PyQt5.QtGui import QPixmap, QCursor
from PyQt5.QtCore import Qt
import os 

app = QApplication(sys.argv)

total_loops = 1

for i in range(total_loops):    

    # https://doc.qt.io/qtforpython/index.html
    # https://www.riverbankcomputing.com/static/Docs/PyQt5/module_index.html

    s = app.screens()[1] # Get the secondary screen 
    # Display info about secondary screen 
    print('Screen Name: {} Size: {}x{} Available geometry {}x{} '.format(s.name(), s.size().width(), s.size().height(), s.availableGeometry().width(), s.availableGeometry().height()))

    # Hide cursor from appearing on screen 
    app.setOverrideCursor(QCursor(Qt.BlankCursor)) # https://forum.qt.io/topic/49877/hide-cursor 

    # Select desired image to be displayed 
    pixmap = QPixmap('test.png')

    # Splash screen approach 
    # https://doc.qt.io/qtforpython/PySide2/QtWidgets/QSplashScreen.html?highlight=windowflags 
    splash = QSplashScreen(pixmap)      # Set the splash screen to desired image
    splash.show()                       # Show the splash screen
    splash.windowHandle().setScreen(s)  # Set splash screen to secondary monitor https://stackoverflow.com/a/30597458/4988010
    splash.showFullScreen()             # Show in splash screen in full screen mode 

    # # Qlabel apporach 
    # l = QLabel()
    # l.setPixmap(pixmap)
    # l.move(1920,0)
    # l.show()
    # l.windowHandle().setScreen(s) # https://stackoverflow.com/a/30597458/4988010
    # l.showFullScreen()

    time.sleep(0.5) 
    end_time = time.time() 
    print('Execution  time: ', end_time-start_time )

sys.exit(app.exec_())

Answer 1

下面的代码是我问题的一个可能的解决方案。我的解决方案假设Qt只用于全屏显示图像，而不用于其余的逻辑。因此，我不得不run the QT app in a secondary thread。这是因为在我运行函数app.exec_()的那一刻，Qt将连续运行一个事件循环，从而阻塞了不依赖Qt的其余Python逻辑。据我所知，不建议在主线程之外运行QApplication，因此我欢迎有经验的用户发布更好的方法。在

from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from PyQt5.QtCore import QObject, pyqtSignal
import sys
import time
import threading


def main():

    print('Step 1')
    print('     Some logic here without QT')

    print('Step 2')
    print('     Launch QT app to run in background')
    myapp = myImageDisplayApp()

    print('Step 3')
    print('     Continue some logic while QT running in background')
    time.sleep(2)

    print('Step 4')
    print('     Update the displayed image in the QT app running in background')
    myapp.emit_image_update('qt_test_static_1.png')
    time.sleep(2)

    print('Step 5')
    print('     Update displayed image again')
    myapp.emit_image_update('qt_test_static_2.png')
    time.sleep(2)

class myImageDisplayApp (QObject):

    # Define the custom signal
    # https://www.riverbankcomputing.com/static/Docs/PyQt5/signals_slots.html#the-pyqtslot-decorator
    signal_update_image = pyqtSignal(str)

    def __init__ (self):

        super().__init__()

        # Setup the seperate thread 
        # https://stackoverflow.com/a/37694109/4988010
        self.thread = threading.Thread(target=self.run_app_widget_in_background) 
        self.thread.daemon = True
        self.thread.start()

    def run_app_widget_in_background(self):
        self.app = QApplication(sys.argv)
        self.my_bg_qt_app = qtAppWidget(main_thread_object=self)
        self.app.exec_()

    def emit_image_update(self, pattern_file=None):
        print('emit_image_update signal')
        self.signal_update_image.emit(pattern_file)


class qtAppWidget (QLabel):

    def __init__ (self, main_thread_object):

        super().__init__()

        # Connect the singal to slot
        main_thread_object.signal_update_image.connect(self.updateImage)

        self.setupGUI()

    def setupGUI(self):

        self.app = QApplication.instance()

        # Get avaliable screens/monitors
        # https://doc.qt.io/qt-5/qscreen.html
        # Get info on selected screen 
        self.selected_screen = 0            # Select the desired monitor/screen

        self.screens_available = self.app.screens()
        self.screen = self.screens_available[self.selected_screen]
        self.screen_width = self.screen.size().width()
        self.screen_height = self.screen.size().height()

        # Create a black image for init 
        self.pixmap = QPixmap(self.screen_width, self.screen_height)
        self.pixmap.fill(QColor('black'))

        # Create QLabel object
        self.app_widget = QLabel()

        # Varioius flags that can be applied to make displayed window frameless, fullscreen, etc...
        # https://doc.qt.io/qt-5/qt.html#WindowType-enum
        # https://doc.qt.io/qt-5/qt.html#WidgetAttribute-enum
        self.app_widget.setWindowFlags(Qt.FramelessWindowHint | Qt.WindowDoesNotAcceptFocus | Qt.WindowStaysOnTopHint)
        # Hide mouse cursor 
        self.app_widget.setCursor(Qt.BlankCursor)       

        self.app_widget.setGeometry(0, 0, self.screen_width, self.screen_height)            # Set the size of Qlabel to size of the screen
        self.app_widget.setWindowTitle('myImageDisplayApp')
        self.app_widget.setAlignment(Qt.AlignLeft | Qt.AlignTop) #https://doc.qt.io/qt-5/qt.html#AlignmentFlag-enum                         
        self.app_widget.setPixmap(self.pixmap)
        self.app_widget.show()

        # Set the screen on which widget is on
        self.app_widget.windowHandle().setScreen(self.screen)
        # Make full screen 
        self.app_widget.showFullScreen()


    def updateImage(self, pattern_file=None):
        print('Pattern file given: ', pattern_file)
        self.app_widget.clear()                     # Clear all existing content of the QLabel
        self.pixmap = QPixmap(pattern_file)         # Update pixmap with desired image  
        self.app_widget.setPixmap(self.pixmap)      # Show desired image on Qlabel

if __name__ == "__main__":

    main() 

我还要感谢@ekhurvo为我指出了QWidget属性/标志。在

Answer 2

您不应该在主线程之外运行GUI，因为Qt不能保证它按照the docs指示正确工作。您必须在另一个线程中执行其他繁重的任务，而不是在另一个线程中执行GUI。在

您必须改变传统顺序逻辑的方法，但必须使用面向事件的编程，在事件发生之前执行操作，在Qt through信号的情况下。在

考虑到上述情况，解决方案是：

import sys
import time


from PyQt5.QtCore import pyqtSignal, pyqtSlot, QObject, Qt, QThread, QTimer
from PyQt5.QtGui import QColor, QPixmap
from PyQt5.QtWidgets import QApplication, QLabel, QWidget


class TaskManager(QObject):
    task3Finished = pyqtSignal()
    task4Finished = pyqtSignal()

    @pyqtSlot()
    def task3(self):
        print("Step 3")
        print("     Continue some logic while QT running in background")
        time.sleep(2)
        self.task3Finished.emit()

    @pyqtSlot()
    def task4(self):
        print("Step 4")
        print("     Update the displayed image in the QT app running in background")
        time.sleep(2)
        self.task4Finished.emit()


class qtAppWidget(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setupGUI()

    def setupGUI(self):
        self.app = QApplication.instance()

        # Get avaliable screens/monitors
        # https://doc.qt.io/qt-5/qscreen.html
        # Get info on selected screen
        self.selected_screen = 0  # Select the desired monitor/screen

        self.screens_available = self.app.screens()
        self.screen = self.screens_available[self.selected_screen]
        self.screen_width = self.screen.size().width()
        self.screen_height = self.screen.size().height()

        # Create a black image for init
        self.pixmap = QPixmap(self.screen_width, self.screen_height)
        self.pixmap.fill(QColor("black"))

        # Create QLabel object
        self.app_widget = QLabel()

        # Varioius flags that can be applied to make displayed window frameless, fullscreen, etc...
        # https://doc.qt.io/qt-5/qt.html#WindowType-enum
        # https://doc.qt.io/qt-5/qt.html#WidgetAttribute-enum
        self.app_widget.setWindowFlags(
            Qt.FramelessWindowHint
            | Qt.WindowDoesNotAcceptFocus
            | Qt.WindowStaysOnTopHint
        )
        # Hide mouse cursor
        self.app_widget.setCursor(Qt.BlankCursor)

        self.app_widget.setGeometry(
            0, 0, self.screen_width, self.screen_height
        )  # Set the size of Qlabel to size of the screen
        self.app_widget.setWindowTitle("myImageDisplayApp")
        self.app_widget.setAlignment(
            Qt.AlignLeft | Qt.AlignTop
        )  # https://doc.qt.io/qt-5/qt.html#AlignmentFlag-enum
        self.app_widget.setPixmap(self.pixmap)
        self.app_widget.show()

        # Set the screen on which widget is on
        self.app_widget.windowHandle().setScreen(self.screen)
        # Make full screen
        self.app_widget.show()

    @pyqtSlot()
    def on_task3_finished(self):
        pixmap = QPixmap("qt_test_static_1.png")
        self.app_widget.setPixmap(pixmap)

    @pyqtSlot()
    def on_task4_finished(self):
        pixmap = QPixmap("qt_test_static_2.png")
        self.app_widget.setPixmap(pixmap)

        # quit application after to 2 secons
        QTimer.singleShot(2 * 1000, QApplication.quit)


def main(args):
    print("Step 1")
    print("     Some logic here without QT")

    print("Step 2")
    print("     Launch QT app to run")
    app = QApplication(args)
    myapp = qtAppWidget()

    thread = QThread()
    thread.start()

    manager = TaskManager()
    # move the QObject to the other thread
    manager.moveToThread(thread)

    manager.task3Finished.connect(myapp.on_task3_finished)
    manager.task3Finished.connect(manager.task4)
    manager.task4Finished.connect(myapp.on_task4_finished)

    # start task
    QTimer.singleShot(0, manager.task3)

    ret = app.exec_()

    thread.quit()
    thread.wait()

    del thread, app

    return ret


if __name__ == "__main__":

    sys.exit(main(sys.argv))