Manipuler les QGraphicsProxyWidget

Version imprimable

Bonjour,
j'ai un petit utilitaire vidéo pour lequel j'ai utilisé la construction ci dessous:
Code:

1 2 3 4 5 6 7 8 9 10 fenetre_widget = QWidget() self.videoWidget = QVideoWidget() self.videoWidget.setStyleSheet("QVideoWidget{background: black}") self.scene= QGraphicsScene() self.view = QGraphicsView() self.view.setScene(self.scene) self.view.setStyleSheet("QGraphicsView{background: transparent}") self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff) self.scene.addWidget(self.videoWidget)
Donc si j'ai bien compris, j'ai une "scene" dans un "view"... sachant que la "scene" contient elle même l'objet QVideoWidget....:?
Par la suite je connecte le QVideoWidget avec un flux vidéo (expl):

Code:

self.camera.setViewfinder(self.videoWidget)

Arrivé à ce stade, pas de problème.

mais quand je demande à la camera de stopper:

Code:

self.camera.stop()

Quand je scanne les objet de ma scene, il me reste un "objet" qui porte le nom suivant : "PyQt5.QtWidgets.QGraphicsProxyWidget"
En visuel, cela me fige la dernière image de mon flux vidéo dans ma scène (et moi, j'aimerais bien avoir un bel écran noir quand je stop)

j'ai essayé de modifier les setStyleSheet du videoWidget, de ma scene et de mon view... mai rien n'y fait
et quand j'essaye de modifier le setStyleSheet de mon "QGraphicsProxyWidget" ça fait rien...

Du coup, une idée pour avoir un ecran noir lors de l'arret du flux vidéo? (Apparemment j'arrive pas à rafraichir/réinitialiser mon QGraphicsProxyWidget...)
y a t-il un effet d'empilage de données (raffraichissement/reset à faire dans mon système scene/view/videowidget)?

NB: quand je relance la caméra tout refonctionne (apparemment bien)...

merci!

19/03/2017, 13h27
VinsS

Salut,

Essaye avec self.scene.clear() dans ta fonction stop, cela impliquera que self.scene.addWidget(self.videoWidget) devra se trouver dans une fonction start pour redémarrer la lecture.
19/03/2017, 15h48
Invité

salut,
j'avais bien essayé le self.scene.clear().
mais il "marche" trop bien... en gros:

avant le 1er lancement de ma camera, j'ai un bel écran noir (qui semble correspondre à mon QVideoWidget puisque lorsque je demande backcolor=pink ou white ça suit).
Dès que je lance (la première fois), j'ai la vidéo qui apparait à la place de mon écran noir (tout apparait en live).
Dès que je stop, j'ai la dernière image figée.

le self.scene.clear, si je le met dans la fonction stop, me supprime tout... je me retrouve avec un écran "transparent" (plus le fond noir du début).
A ce stade, si je relance la caméra, elle se lance bien mais elle ne s'affiche pas (comme si j'avais supprimé l'objet qui la portait).
si j'utilise les fonctions capture image (propre à QCamera) j'arrive bien à récupérer des snapshots mais je n'ai plus le "live" de la camera qui s'affiche.

j'ai essayé de réinitilaiser le qvideowidget en lui réaffectant un background dans ma fonction stop mais ça marche pas non plus.
j'ai aussi essayé de toucher un peu au self.view... sans succès.
du coup j'essayais de toucher au proxy mais je sais pas bien le gérer lui...

au cas ou, un petit bout de code qui tourne...

donc le play/pause marchent plutôt bien (d'ailleurs le pause n'est qu'un effet visuel parce que c'est une image qui est surimposée au flux vidéo... en fait la camera ne s'arrête jamais.
par contre le bouton rose ("stop") m'arrête bien la camera... Et soit je n'ai pas droit à un écran noir entre deux "play" (et je garde la dernière image saisie en visuel), soit je perd mon support pour le live de la camera lors du replay.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
#import pdb
from PyQt5 import QtCore
from PyQt5.QtWidgets import *
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtMultimedia import *
from PyQt5.QtMultimediaWidgets import QVideoWidget
from io import BytesIO
import os,sys,time,os.path
from os.path import expanduser
from numpy import sqrt
 
 
class fenPrincipale(QMainWindow):
    def __init__(self):
        QMainWindow.__init__(self)
 
        fenetre_widget = QWidget()
        fenetre_widget.setStyleSheet("background-image: url(fond.jpg)")
 
        self.videoWidget = QVideoWidget()
        self.videoWidget.setStyleSheet("QVideoWidget{background: black}")
        self.scene= QGraphicsScene()
        self.view = QGraphicsView()
        self.view.setScene(self.scene)
        self.view.setStyleSheet("QGraphicsView{background: transparent}")
        self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.scene.addWidget(self.videoWidget)
 
        self.camera=QCamera(QCamera.FrontFace)
        self.camera.setViewfinder(self.videoWidget)
 
        self.resox=800
        self.resoy=600
        self.videoWidget.setFixedSize(self.resox,self.resoy)
        self.view.setFixedSize(self.resox,self.resoy)
 
        #Boutons
        self.bouton_play = QPushButton()
        self.bouton_play.setIcon(QIcon("play2.png"))
        self.bouton_play.setStyleSheet("QPushButton{background: transparent}")
        self.bouton_play.setIconSize(QtCore.QSize(70,70))
        self.bouton_play.setFixedWidth(70)
        self.bouton_pause = QPushButton()
        self.bouton_pause.setIcon(QIcon("pause2.png"))
        self.bouton_pause.setStyleSheet("QPushButton{background: transparent}")
        self.bouton_pause.setIconSize(QtCore.QSize(70,70))
        self.bouton_pause.setFixedWidth(70)
        self.bouton_stop = QPushButton()
        self.bouton_stop.setStyleSheet("QPushButton{background: pink}")
        self.bouton_stop.setIconSize(QtCore.QSize(70,70))
        self.bouton_stop.setFixedWidth(70)
 
 
        #menu bar
        self.menucameras = self.menuBar().addMenu("Cameras")
 
        #Layout
        layoutverticalglobal=QVBoxLayout()
 
        layoutvertical1 = QVBoxLayout()
 
        layoutvertical1.addWidget(self.bouton_play)        
        layoutvertical1.addWidget(self.bouton_pause)
        layoutvertical1.addWidget(self.bouton_stop)
        layoutvertical1.addWidget(self.view)
 
        #Intégration    
        fenetre_widget.setLayout(layoutvertical1)        
        self.setCentralWidget(fenetre_widget)
 
        #Fonctions Connect
        self.bouton_play.clicked.connect(self.play)
        self.bouton_pause.clicked.connect(self.takeImage)
        self.bouton_stop.clicked.connect(self.stop)
 
        self.imageCapture = QCameraImageCapture(self.camera)
        self.imageCapture.readyForCaptureChanged.connect(self.readyForCapture)
        self.imageCapture.imageCaptured.connect(self.processCapturedImage)
 
        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.menucameras.addAction(videoDeviceAction)
            videoDevicesGroup.triggered.connect(self.updateCameraDevice)
 
        self.showMaximized()
 
    def updateCameraDevice(self, action):
        self.setCamera(action.data())        
    def setCamera(self, cameraDevice):
        if cameraDevice.isEmpty():
            self.camera = QCamera()
        else:
            self.camera = QCamera(cameraDevice)
            self.camera.setViewfinder(self.videoWidget)
    def takeImage(self):
        self.isCapturingImage = True
        self.imageCapture.capture("Image.jpg")
    def readyForCapture(self, ready):
        self.bouton_pause.setEnabled(True)
    def processCapturedImage(self, requestId, img):
        self.image_originale1 = img.scaled(200,150, Qt.KeepAspectRatio,Qt.SmoothTransformation)
        self.image_originale2 = img.scaled(self.resox,self.resoy, Qt.KeepAspectRatio,Qt.SmoothTransformation)
        self.item_issu_originale2=self.scene.addPixmap(QPixmap.fromImage(self.image_originale2))
        self.nb_droite=0
 
    def play(self):
        for item in self.scene.items():
            type_item_selectionne=str(type(item))
            if "QGraphicsPixmapItem" in type_item_selectionne:
                try:
                    self.scene.removeItem(item)
                except:
                    pass
        self.camera.start()
    def stop(self):
        #self.scene.clear()
        self.camera.stop()
        #try:
        #    self.scene.removeItem(self.item_issu_originale2)
        #except:
        #    pass
        #try:
        #    self.scene.removeItem(self.item_modifiee)
        #except:
        #    pass
def main(args):
    appli=QApplication(args)
    fenetre=fenPrincipale()
    fenetre.show()
    r=appli.exec_()
    return r
 
if __name__=="__main__":
    main(sys.argv)

19/03/2017, 17h46
VinsS

Ce que tu décris est le comportement normal de tout media player, la touche stop fait un arrêt sur image, elle n'efface pas le contenu, pour cela il fait aller jusqu'au bout du media mais comme ici il s'agit d'une camera le média n'a pas de fin.

La méthode scene.clear() va enlever le QVideoWidget de la scène il faudra donc le replacer dedans à la fonction play.

Pour garder le fond noir j'applique la styleSheet sur le QGraphicsView. Quand la scène est vidée le fond est bien noir.

c'est bon, ça marche :-)
j'ai finalement modifié la fonction stop comme suivant:
Code:

1 2 3 4 5 6 7 8 def stop(self): self.scene.clear() self.camera.stop() self.videoWidget = QVideoWidget() self.videoWidget.setStyleSheet("QVideoWidget{background: black}") self.scene.addWidget(self.videoWidget) self.camera.setViewfinder(self.videoWidget) self.videoWidget.setFixedSize(self.resox,self.resoy)
je pensais pas que le self.scene.clear() m'obligerais à redéclarer le videowidget et son setstylesheet.
meri pour les conseils!