PyQt Lab est un outil puissant qui permet aux développeurs de créer des applications interactives et des interfaces graphiques. Il offre une variété de fonctionnalités, notamment la possibilité de capturer des images à partir d’une webcam. Grâce à l’utilisation du signal « pull-buffer », PyQt Lab permet aux développeurs de capturer des images à une vitesse allant jusqu’à 100 images par seconde ! Dans cet article, nous allons examiner en détail comment PyQt Lab peut être utilisé pour capturer des images à partir d’une webcam et comment le signal « pull-buffer » peut être utilisé pour obtenir des résultats optimaux.
PyQt Lab’ : Capture Webcam avec GSVideo : capture avec utilisation du signal « pull-buffer » (résultat : jusqu’à 100 fps !)
Par X. HINAULT – Juin 2013
Ce que l’on va faire ici
- Dans ce code PyQt, capture Webcam avec GSVideo : capture avec utilisation du signal « pull-buffer » (résultat : jusqu’à 100 fps !)
Pré-requis
- python 2.7
- pyqt4.x
- modules :
- python-opencv
- pygst
- gst
Téléchargement :
- Ces codes sont disponibles ici :
Le fichier d’interface *.py
- Fichier obtenu automatiquement avec l’utilitaire pyuic4 à partir du fichier *.ui créé avec QtDesigner :
# Form implementation generated from reading ui file
#
# Created: Wed Jun 12 10:09:29 2013
# by: PyQt4 UI code generator 4.9.1
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
try:
_fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
_fromUtf8 = lambda s: s
class Ui_Form(object):
def setupUi(self, Form):
Form.setObjectName(_fromUtf8(« Form »))
Form.resize(341, 265)
self.labelImage = QtGui.QLabel(Form)
self.labelImage.setGeometry(QtCore.QRect(10, 15, 320, 240))
self.labelImage.setStyleSheet(_fromUtf8(« background-color: rgb(180, 180, 180); »))
self.labelImage.setText(_fromUtf8(« »))
self.labelImage.setObjectName(_fromUtf8(« labelImage »))
self.retranslateUi(Form)
QtCore.QMetaObject.connectSlotsByName(Form)
def retranslateUi(self, Form):
Form.setWindowTitle(QtGui.QApplication.translate(« Form », « PyQt : dessin : qpixmap et qimage : numpy », None, QtGui.QApplication.UnicodeUTF8))
if __name__ == « __main__ »:
import sys
app = QtGui.QApplication(sys.argv)
Form = QtGui.QWidget()
ui = Ui_Form()
ui.setupUi(Form)
Form.show()
sys.exit(app.exec_())
Le fichier d’application *Main.py
# -*- coding: utf-8 -*-
# par X. HINAULT – Mai 2013 – Tous droits réservés
# GPLv3 – www.mon-club-elec.fr
# modules a importer
from PyQt4.QtGui import *
from PyQt4.QtCore import * # inclut QTimer..
import os,sys
import time # temps – pour micros
import pygst # gsvideo
pygst.require(‘0.10’)
import gst
import gobject # indispensable pour bon fonctionnement signaux pygst – GObject est utilisé comme base des plugins
gobject.threads_init() # idem..
#from functools import partial # pour connect signal gs
#from weakref import ref # idem
import numpy as np
from tuto_pyqt_dessin_qpixmap_qimage_numpy_rgb_gsvideo import * # fichier obtenu à partir QtDesigner et pyuic4
# +/- variables et objets globaux
class myApp(QWidget, Ui_Form): # la classe reçoit le Qwidget principal ET la classe définie dans test.py obtenu avec pyuic4
def __init__(self, parent=None):
QWidget.__init__(self) # initialise le Qwidget principal
self.setupUi(parent) # Obligatoire
# — Variables de classe
# — Paramétrage des widgets de l’interface GUI si nécessaire —
# — Connexions entre signaux des widgets et fonctions
# connecte chaque signal utilisé des objets à l’appel de la fonction voulue
# — Code actif initial —
« » »
# GS Video :
self.player = gst.Pipeline(« player ») # # déclaration du pipeline
#– source
self.source = gst.element_factory_make(« v4l2src », « vsource »)
self.source.set_property(« device », « /dev/video0 »)
#self.scaler = gst.element_factory_make(« videoscale », « vscale »)
#– sortie
#self.sink = gst.element_factory_make(« autovideosink », « outsink »)
self.sink = gst.element_factory_make(« appsink », « outsink »)
self.sink.set_property(« emit-signals », « True »)
# initialisation du pipeline
#self.player.add(self.source, self.scaler, self.sink)
self.player.add(self.source, self.sink) # ajout des éléments aux pipeline
#gst.element_link_many(self.source,self.scaler, self.sink)
gst.element_link_many(self.source, self.sink) # construction du pipeline
« » »
# initialisation pipeline style « ligne de commande »
self.pipeline = gst.parse_launch(
# »’v4l2src device=/dev/video0 ! video/x-raw-rgb,width=320,height=240,framerate=100/1 ! appsink name=sink emit-signals=true »’ # Haute vitesse… ok avec eye ps3
»‘v4l2src device=/dev/video0 ! video/x-raw-rgb,width=320,height=240,framerate=30/1 ! appsink name=sink emit-signals=true’ »
)
# »’v4l2src device=/dev/video0 ! video/x-raw-rgb,width=320,height=240,framerate=30/1 ! appsink name=sink emit-signals=true »’
#!xvimagesink »’)
#! appsink name=sink sync= False »’)
#! appsink name=sink sync=False »’ % (self.uri, caps))
# définition objets du pipeline pour accès code Python (si besoin)
self.sink = self.pipeline.get_by_name(‘sink’)
# lancement du pipeline
self.pipeline.set_state(gst.STATE_PLAYING)
# affichage de test
buf = self.sink.emit(‘pull-buffer’)
self.pixels = np.frombuffer(buf.data, dtype=np.uint8).reshape((320,240,3))
print type(self.pixels)
print self.pixels
print self.pixels.shape
self.micros0=self.micros()
# voir aussi gestion du bus… et analyse messages…
# dessin : créer image à partir tableau numpy
# initialisation du tableau de pixels
#self.pixels=np.zeros((self.labelImage.height(),self.labelImage.width(),4),np.uint8,’C’) # tableau 320×240 x 4 canaux et 8U
# 4 canaux car image QImage est une une image ARGB… même si format RGB utilisé (qui est en fait ARGB avec A laissé à FF)
# initialisation des canaux
#self.pixels[:,:,1]=255 # canal G
#self.pixels[:,:,0]=127 # canal B
#self.pixels[:,:,2]=64 # canal R
# accès à un pixel unitaire…
#self.pixels[119,159,:]=[0,0,0,0] # accès à un pixel unitaire par pixels[y,x,:] (inversion x,y) et paramétrage de la couleur par (b,g,r,0)
# accès à une ligne entière de pixels
#self.pixels[50,:,:]=[0,0,255,0] # accès à une ligne par pixels[y,:,:] (inversion x,y) et paramétrage de la couleur par (b,g,r,0)
# accès à une colonne entière de pixels
#self.pixels[:,50,:]=[255,0,0,0] # accès à une colonne par pixels[:,x,:] (inversion x,y) et paramétrage de la couleur par (b,g,r,0)
#QImage(self,str data, int width, int height, Format format)
#self.image=QImage(self.pixels.tostring(), self.labelImage.width() , self.labelImage.height() ,QImage.Format_RGB32) # crée image RGB 32 bits même taille que label
self.image=QImage(self.pixels.tostring(), self.labelImage.width() , self.labelImage.height() ,QImage.Format_RGB888) # crée image RGB 32 bits même taille que label
#– affichage du QImage via QPixmap dans QLabel
self.pixmap=QPixmap.fromImage(self.image) # chargement qu QImage dans le QPixmap
self.labelImage.setPixmap(self.pixmap) # met à jour le qpixmap affiché dans le qlabel
#self.connect(self.sink,SIGNAL(« pull-buffer »), self.bufferReady) # ne semble pas fonctionner
#self.connect(self.sink, SIGNAL(« new-buffer »), self.readBuffer)
self.sink.connect(‘new-buffer’, self.readBuffer) # segment fault…
#self.sink.connect(‘new-buffer’, partial(self.readBuffer, ref(self)))
#– initialisation du Timer pour lecture Buffer GStreamer
#self.timerGStreamer=QTimer() # déclare un timer Qt
#self.timerGStreamer.start(30) # lance le timer – durée en ms – délai doit être idem framerate camera
# sinon, décalage si délai plus long et ralentissement prog si délai plus court (car attend buffer dispo…)
#self.connect(self.timerGStreamer, SIGNAL(« timeout() »), self.readBuffer) # connecte le signal timeOut de l’objet timer à l’appel de la fonction voulue
# http://gstreamer-devel.966125.n4.nabble.com/appsink-appsrc-pad-problems-oh-my-td972828.html
# — les fonctions appelées, utilisées par les signaux des widgets —
# — les fonctions appelées, utilisées par les signaux hors widgets —
# fonction micros : renvoie le nombre de microsecondes courant de l’horloge système
def micros(self):
return(int(round(time.time() * 1000000))) # microsecondes de l’horloge système
def bufferReady(self):
print (« Buffer ok »)
#def readBuffer(obj, sinkIn): # appelée par le signal new-buufer.. la fonction reçoit la source
def readBuffer(self, sinkIn): # appelée par le signal new-buufer.. la fonction reçoit la source
print (« Dep dernier : »+ str(self.micros()–self.micros0) + » us »)
micros0=self.micros()
print (« 0: »+ str(self.micros()-micros0) + » us »)
# affichage de test
buf = sinkIn.emit(‘pull-buffer’) # attend l’émission du signal…
# si la fonction est appelée par signal = immédiat – sinon correspond au délai timer…
print (« 1: »+ str(self.micros()-micros0) + » us »)
micros0=self.micros()
self.pixels = np.frombuffer(buf.data, dtype=np.uint8)
print (« 2: »+ str(self.micros()-micros0) + » us »)
micros0=self.micros()
self.pixels=self.pixels.reshape((320,240,3))
print (« 3: »+str(self.micros()-micros0) + » us »)
micros0=self.micros()
self.pixelsOK=np.zeros((320, 240,3), np.uint8)
self.pixelsOK[:,:,0]=self.pixels[:,:,2] # inversion R et B
self.pixelsOK[:,:,1]=self.pixels[:,:,1] # G
self.pixelsOK[:,:,2]=self.pixels[:,:,0] # inversion R et B
# => 2,5ms
print (« 4: »+str(self.micros()-micros0) + » us »)
micros0=self.micros()
#print type(self.pixels)
#print self.pixels
#print self.pixels.shape
self.image=QImage(self.pixelsOK.tostring(), self.labelImage.width() , self.labelImage.height() ,QImage.Format_RGB888) # crée image RGB 32 bits même taille que label
#– affichage du QImage via QPixmap dans QLabel
#self.pixmap=QPixmap.fromImage(self.image) # chargement qu QImage dans le QPixmap – ne marche pas..
self.pixmap.convertFromImage(self.image) # recharge le QImage dans le QPixmap existant – met à jour le QPixmap
self.labelImage.setPixmap(self.pixmap) # met à jour le qpixmap affiché dans le qlabel
print (« 5: »+ str(self.micros()-micros0) + » us »)
self.micros0=self.micros() # pour calcul entre 2
# — fonctions de classes autres—
# — Autres Classes utiles —
# — Classe principale (lancement) —
def main(args):
a=QApplication(args) # crée l’objet application
f=QWidget() # crée le QWidget racine
c=myApp(f) # appelle la classe contenant le code de l’application
f.show() # affiche la fenêtre QWidget
r=a.exec_() # lance l’exécution de l’application
return r
if __name__==« __main__ »: # pour rendre le code exécutable
main(sys.argv) # appelle la fonction main
Utilisation
- Les 2 fichiers suivants sont à enregistrer dans un même répertoire, l’un en nom.py et l’autre en nomMain.py.
- Puis lancer l’application depuis Geany ou équivalent, en exécutant le fichier nomMain.py
- On obtient la fenêtre avec capture vidéo
