Logo Mon Club Elec

PyQt Lab’ : Capture Webcam avec GSVideo : capture avec utilisation du signal « pull-buffer » (résultat : jusqu’à 100 fps !)

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

PyQt Lab’ : Capture Webcam avec GSVideo : capture avec utilisation du signal « pull-buffer » (résultat : jusqu’à 100 fps !)

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 :
# -*- coding: utf-8 -*-

# 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

#!/usr/bin/python
# -*- 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
Noter cet article

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Archive Mon Club Elec

Articles populaires

Newsletter

Inscrivez-vous maintenant et bénéficiez d'un soutien continu pour réaliser vos travaux électriques en toute sécurité.