Python + Qt + OpenCV = problème :/

Python + Qt + OpenCV = problème :/ - Python - Programmation

Marsh Posté le 27-10-2011 à 19:56:28    

bonjour :)

 

J'essaye d'interfacer OpenCV avec Qt (pyside) sous python pour afficher ma webcam dans une fenêtre de contrôle.

 

J'ai trouvés des bouts de code pour m'aider. Je précise que je suis débutant en python/Qt/OpenCV :D (en programmation tout court aussi :D )
Mon problème est d'afficher la webcam non pas dans une fenêtre qui pop-up, mais dans la fenêtre de contrôle initiale

 

Le code qui j'utilise est le suivant :

 
Code :
  1. from PySide import QtCore, QtGui
  2. import sys, cv
  4. class IplQImage(QtGui.QImage):
  5.     """A class for converting iplimages to qimages"""
  6.     def __init__(self,iplimage):
  7.     #Rough-n-ready but it works dammit
  8.         alpha = cv.CreateMat(iplimage.height,iplimage.width, cv.CV_8UC1)
  9.         cv.Rectangle(alpha,(0,0),(iplimage.width,iplimage.height),cv.ScalarAll(255),-1)
  10.         rgba = cv.CreateMat(iplimage.height,iplimage.width, cv.CV_8UC4)
  11.         cv.Set(rgba, (1,2,3,4))
  12.         cv.MixChannels([iplimage, alpha],[rgba], [
  13.          (0, 0), # rgba[0] -> bgr[2]
  14.          (1, 1), # rgba[1] -> bgr[1]
  15.          (2, 2), # rgba[2] -> bgr[0]
  16.          (3, 3) # rgba[3] -> alpha[0]
  17.          ])
  18.         self.__imagedata = rgba.tostring()
  19.         super(IplQImage,self).__init__(self.__imagedata,
  20.                                        iplimage.width,iplimage.height, QtGui.QImage.Format_RGB32)
  23. class VideoWidget(QtGui.QWidget):
  24.     """ A class for rendering video coming from OpenCV """
  26.     def __init__(self, parent=None):
  27.         QtGui.QWidget.__init__(self)
  28.         self._capture = cv.CreateCameraCapture(0)
  29.         # Take one frame to query height
  30.         frame = cv.QueryFrame(self._capture)
  31.         self.setMinimumSize(frame.width, frame.height)
  32.         self.setMaximumSize(self.minimumSize())
  33.         self._frame = None
  34.         self._image = self._build_image(frame)
  35.         # Paint every 50 ms
  36.         self._timer = QtCore.QTimer(self)
  37.         self._timer.timeout.connect(self.queryFrame)
  38.         self._timer.start(50)
  40.     def _build_image(self, frame):
  41.         if not self._frame:
  42.             self._frame = cv.CreateImage((frame.width, frame.height), cv.IPL_DEPTH_8U, frame.nChannels)
  43.         if frame.origin == cv.IPL_ORIGIN_TL:
  44.             cv.Copy(frame, self._frame)
  45.         else:
  46.             cv.Flip(frame, self._frame, 0)
  47.         return IplQImage(self._frame)
  49.     def paintEvent(self, event):
  50.         painter = QtGui.QPainter(self)
  51.         painter.drawImage(QtCore.QPoint(0, 0), self._image)
  53.     def queryFrame(self):
  54.         frame = cv.QueryFrame(self._capture)
  55.         self._image = self._build_image(frame)
  56.         self.update()
  60. class Ui_MainWindow(object):
  61.     def setupUi(self, MainWindow):
  62.         MainWindow.setObjectName("MainWindow" )
  63.         MainWindow.setWindowTitle('toto')
  64.         MainWindow.resize(800, 600)
  65.         self.centralwidget = QtGui.QWidget(MainWindow)
  66.         self.centralwidget.setObjectName("centralwidget" )
  67.         self.widget = QtGui.QWidget(self.centralwidget)
  68.         self.widget.setGeometry(QtCore.QRect(110, 80, 321, 181))
  69.         self.widget.setObjectName("widget" )
  70.        
  71.         self.widget_3 = VideoWidget(self.centralwidget)
  72.         self.widget_3.setGeometry(QtCore.QRect(110, 300, 120, 80))
  73.         self.widget_3.setObjectName("widget_3" )
  74.        
  75.         MainWindow.setCentralWidget(self.centralwidget)
  76.         self.menubar = QtGui.QMenuBar(MainWindow)
  77.         self.menubar.setGeometry(QtCore.QRect(0, 0, 800, 21))
  78.         self.menubar.setObjectName("menubar" )
  79.         MainWindow.setMenuBar(self.menubar)
  80.         self.statusbar = QtGui.QStatusBar(MainWindow)
  81.         self.statusbar.setObjectName("statusbar" )
  82.         MainWindow.setStatusBar(self.statusbar)
  83.      
  84.        
  85.         #bouton quitter
  86.         self.quit_0 = QtGui.QPushButton("Quitternsans message", self)
  87.         self.quit_0.setGeometry(490, 450, 100, 30)
  88.         self.quit_0.clicked.connect(quit)
  90.         #bouton affichage_webcam
  91.         self.webcam_button = QtGui.QPushButton("Afficher Webcam", self)
  92.         self.webcam_button.setGeometry(490,400,100,30)
  93.         self.webcam_button.clicked.connect(affiche_webcam)
  94.        
  95.         self.retranslateUi(MainWindow)
  96.         QtCore.QMetaObject.connectSlotsByName(MainWindow)
  98.     def retranslateUi(self, MainWindow):
  99.         MainWindow.setWindowTitle(QtGui.QApplication.translate("MainWindow", "MainWindow", None, QtGui.QApplication.UnicodeUTF8))
  101.    
  102.     def affiche_webcam():
  103.        ecran.widget_3.show()
  106. class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
  107.     def __init__(self, parent=None):
  108.         super(MainWindow, self).__init__(parent)
  109.         self.setupUi(self)
  110.        
  111. if __name__ == '__main__':
  112.     app = QtGui.QApplication(sys.argv)
  113.     ecran = MainWindow()
  114.     ecran.show()   
  115.     app.exec_()
 

Le problème : quand j'appuye sur le bouton pour afficher la webcam, j'ai une fenètre qui pop-up, alors que je pensais que la widget serait incluse dans la MainWindow :/
Autre problème de compréhension : la fonction paintevent déclarée dans la construction de la classe Video_widget n'est jamais utilisée, je ne comprends donc pas à quoi elle sert :??:

Message cité 1 fois
Message édité par _pollux_ le 27-10-2011 à 20:04:00

---------------
Le topic du sport électronique@hfr : watch the l33t !
Reply

Marsh Posté le 27-10-2011 à 19:56:28   

Reply

Marsh Posté le 27-10-2011 à 21:37:34    

_pollux_ a écrit :

Le problème : quand j'appuye sur le bouton pour afficher la webcam, j'ai une fenètre qui pop-up, alors que je pensais que la widget serait incluse dans la MainWindow :/


 
Salut
 
Bon moi je connais bien PyQt mais je ne connais pas OpenCV. Je viens d'aller voir sur le net ce que ça fait mais comme j'ai jamais programmé avec...
 
Le pb c'est que ta fenêtre ecran.widget_3 (qui s'affiche quand on appuie sur le bouton) n'est pas incluse dans la fenêtre principale. Ce n'est pas parce que tu lui donnes "self.centralwidget" comme parent que cela suffit. Il te faut créer un gestionnaire de disposition (un layout) et lui donner comme enfant la widget en question. Ensuite, ton bouton sert juste à la rendre visible ou pas.
Autre chose: personnellement j'utilise à fond les classes. Ca permet d'avoir des éléments vraiment indépendants. Et j'éviterais, si j'étais toi, de passer par designer. Ca n'aide pas à bien comprendre Qt...
 
Voici un petit exemple de démo de ce que j'imagine que tu veux faire: une fenêtre principale avec un bouton "webcam" qui affiche ou masque une sous-fenêtre. Je l'ai développé intégralement selon ma façon de faire générale

Code :
  1. #!/usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3.  
  4. import sys
  5.  
  6. from PyQt4.QtCore import *                    # Moteur contrôle Qt
  7. from PyQt4.QtGui import *                    # IHM Qt
  8.  
  9. class QtAppli(
  10.         QApplication):                        # Objet hérité
  11.     "Fenêtre de l'application"
  12.  
  13.     # Constructeur fenêtre
  14.     def __init__(
  15.             self,                            # Instance objet
  16.             argv,                            # Arguments programme
  17.             transFile=None):                # Fichier de traduction
  18.  
  19.         # Message de contrôle
  20.         print "Python version %s - QtAppli (qt v%s, pyqt_v%s)" % (
  21.             sys.version,
  22.             QT_VERSION_STR,
  23.             PYQT_VERSION_STR
  24.         )
  25.  
  26.         # Appel constructeur de l'objet hértié
  27.         QApplication.__init__(self, argv)
  28.         
  29.         # Translations
  30.         if transFile != None:
  31.             self.__trans=QTranslator()
  32.             self.installTranslator(self.__trans)
  33.             self.__trans.load(transFile)
  34.         #if
  35.         
  36.         # Environnement ihm
  37.         self.ihm={}
  38.         self.ihm["appli"]=self
  39.         self.ihm["self"]=self
  40.  
  41.         # Widget principale
  42.         self.mainWid=QMainWindow()
  43.         self.mainWid.setCentralWidget(QWidget(self.mainWid))
  44.         self.mainWid.statusBar()
  45.  
  46.         # Titre
  47.         self.mainWid.setWindowTitle(
  48.             QApplication.translate(
  49.                 "VerifQt",
  50.                 "Exemple Qt (v%1)",
  51.                 "Note: titre de la fenêtre",
  52.                 QApplication.UnicodeUTF8,
  53.             ).arg(QString.fromUtf8(QT_VERSION_STR))
  54.         )
  55.  
  56.         # Le bouton webcam
  57.         btn=QPushButton(
  58.             QApplication.translate(
  59.                 "VerifQt",
  60.                 "Webcam",
  61.                 "Note: titre du bouton",
  62.                 QApplication.UnicodeUTF8,
  63.             ),
  64.             self.mainWid.centralWidget()
  65.         )
  66.         self.connect(
  67.             btn,
  68.             SIGNAL("clicked()" ),
  69.             self.__slotWebcam,
  70.         )
  71.  
  72.         # Le bouton version
  73.         ver=QPushButton(
  74.             QApplication.translate(
  75.                 "VerifQt",
  76.                 "A propos de Qt",
  77.                 "Note: titre du bouton",
  78.                 QApplication.UnicodeUTF8,
  79.             )
  80.         )
  81.         self.connect(
  82.             ver,
  83.             SIGNAL("clicked()" ),
  84.             self.__slotQt,
  85.         )
  86.  
  87.         # Pour quitter
  88.         quit=QPushButton(
  89.             QApplication.translate(
  90.                 "VerifQt",
  91.                 "Quitter",
  92.                 "Note: titre du bouton",
  93.                 QApplication.UnicodeUTF8,
  94.             )
  95.         )
  96.         self.connect(
  97.             quit,
  98.             SIGNAL("clicked()" ),
  99.             self.mainWid,
  100.             SLOT("close()" ),
  101.         )
  102.         
  103.         # La fenêtre webcam
  104.         self.webcam=QtWebcam(self.ihm)
  105.         self.webcam.setVisible(False)
  106.         
  107.         # Rangement des éléments
  108.         mainLayout=QGridLayout(self.mainWid.centralWidget())
  109.         mainLayout.addWidget(self.webcam, 0, 0, 3, 1)
  110.         mainLayout.addWidget(btn, 0, 1)
  111.         mainLayout.addWidget(ver, 1, 1)
  112.         mainLayout.addWidget(quit, 2, 1)
  113.     # __init__()
  114.  
  115.     # Affichage et lancement application
  116.     def run(
  117.             self):                            # Instance objet
  118.         self.mainWid.show()
  119.         self.exec_()
  120.     # run()
  121.  
  122.     # Slot qui affiche la fenêtre webcam
  123.     def __slotWebcam(
  124.             self):                            # Instance objet
  125.  
  126.         print "%s.__slotWebcam" % self.__class__.__name__
  127.  
  128.         # Affichage/Masquage sous-fenêtre
  129.         self.webcam.setVisible(not self.webcam.isVisible())
  130.     # __slotWebcam()
  131.  
  132.     # Slot qui affiche la version de Qt
  133.     def __slotQt(
  134.             self):                            # Instance objet
  135.  
  136.         print "%s.__slotQt" % self.__class__.__name__
  137.  
  138.         # Fenêtre "A propos de Qt"
  139.         QMessageBox.aboutQt(
  140.             self.mainWid,
  141.             QApplication.translate(
  142.                 "VerifQt",
  143.                 "à propos de Qt...",
  144.                 "Note: titre de la fenêtre",
  145.                 QApplication.UnicodeUTF8,
  146.             ),
  147.         )
  148.     # __slotQt()
  149. # class QtAppli
  150.  
  151. # Objet de fenêtre associée à la webcam
  152. class QtWebcam(
  153.         QWidget):                            # Objet hérité
  154.     "Fenêtre de l'application"
  155.  
  156.     # Constructeur fenêtre
  157.     def __init__(
  158.             self,                            # Instance objet
  159.             ihm):                            # Environnement ihm
  160.         
  161.         # Récupération environnement ihm
  162.         self.ihm=dict(ihm)                    # Environnement ihm
  163.         self.ihm["mainWid"]=self
  164.         self.ihm["self"]=self
  165.         
  166.         # Appel constructeur de l'objet hérité
  167.         QWidget.__init__(self)
  168.         
  169.         # Eléments
  170.         self.__text=QTextEdit()
  171.         btn=QPushButton(
  172.             QApplication.translate(
  173.                 "VerifQt",
  174.                 "add text",
  175.                 "Note: texte du bouton",
  176.                 QApplication.UnicodeUTF8,
  177.             )
  178.         )
  179.         self.connect(
  180.             btn,
  181.             SIGNAL("clicked()" ),
  182.             self.__slotAction,
  183.         )
  184.         
  185.         # Rangement de la sous-fenêtre
  186.         mainLayout=QVBoxLayout(self)
  187.         mainLayout.setMargin(0)
  188.         mainLayout.setSpacing(0)
  189.         mainLayout.addWidget(self.__text)
  190.         mainLayout.addWidget(btn)
  191.     # __init__()
  192.     
  193.     # Slot activé lors de l'appel sur le bouton
  194.     def __slotAction(self):
  195.         self.__text.insertPlainText("123" )
  196.     # __slotAction()
  197. # class QtWebcam
  198.  
  199. if __name__ == "__main__":
  200.     # Lancement appli
  201.     Appli=QtAppli(sys.argv, "verifqt_en" )
  202.     Appli.run()
  203. # if


 
Donc tu vois, j'ai créé un objet dédié à l'affichage de la webcam. N'ayant pas opencv je n'y ai mis qu'un bouton et un texte mais c'est l'avantage de l'indépendance => il peut évoluer facilement sans toucher au reste de l'appli
 
L'élément "ihm" n'est pas obligatoire mais je l'aime bien. Il s'agit d'un petit dictionnaire que j'embarque dans tous mes objets Qt. Ainsi, chaque objet connait
- son parent
- l'objet "application" et tout ce qui va avec
 

_pollux_ a écrit :

Autre problème de compréhension : la fonction paintevent déclarée dans la construction de la classe Video_widget n'est jamais utilisée, je ne comprends donc pas à quoi elle sert :??:


J'en sais rien. C'est le pb quand on utilise designer => beaucoup de trucs qui sont intégrés (qui doivent être utiles) mais dont on ne perçoit pas l'utilité au premier abord...


Message édité par Sve@r le 27-10-2011 à 21:49:13
Reply

Marsh Posté le 27-10-2011 à 21:56:51    

merci pour la réponse, je vais potasser tout ça :jap:


---------------
Le topic du sport électronique@hfr : watch the l33t !
Reply

Marsh Posté le 28-10-2011 à 10:47:26    

J'ai potassé, ça marche, tu m'as rendu un grand service, merci pour tout :)
 
Va vraiment falloir que j'apprenne les bases pour être capable de coder tout ça moi même :D


---------------
Le topic du sport électronique@hfr : watch the l33t !
Reply

Marsh Posté le 30-10-2011 à 09:09:22    

Bonjour,

 

Je reviens à la charge.
En reprenant l'exemple précédent, je veux créer un bouton dans l'objet Appli qui aurait un effet sur la vidéo de l'objet webcam.

 

Le problème, c'est que si je crée une fonction "aspect_video" un peu n'importe où, quand je l'appelle, il me sort que l'objet webcam n'a pas d'attribut __video.
Alors que si je fais la même action en utilisant un bouton crée dans la classe de webcam, ça marche ...

 
Code :
  1. #!/usr/bin/env python
  2.     # -*- coding: utf-8 -*-
  3.      
  4. import sys,cv
  5.      
  6. from PyQt4.QtCore import *                    # Moteur contrôle Qt
  7. from PyQt4.QtGui import *                    # IHM Qt
  8.  
  9. #variables d'initialisation    
  10. min_size = (30, 30)
  11. image_scale = 4
  12. haar_scale = 1.2
  13. min_neighbors = 1
  14. haar_flags = 0
  15. global detection
  16. detection = False
  17.  
  18.  
  19. def modif_video(frame,bool):
  20.  
  21.     
  22. class IplQImage(QImage):
  23.  
  24.     
  25. class VideoWidget(QWidget):
  26.     """ A class for rendering video coming from OpenCV """
  27.  
  28.     def __init__(self, parent=None):
  29.         QWidget.__init__(self)
  30.         self._capture = cv.CreateCameraCapture(0)
  31.         # Take one frame to query height
  32.         frame = cv.QueryFrame(self._capture)
  33.         self.setMinimumSize(frame.width, frame.height)
  34.         self.setMaximumSize(self.minimumSize())
  35.         self._frame = None
  36.         self._image = self._build_image(frame,bool)
  37.         # Paint every 50 ms
  38.         self._timer = QTimer(self)
  39.         self._timer.timeout.connect(self.queryFrame)
  40.         self._timer.start(50)
  41.  
  42.             
  43.     def _build_image(self, frame,bool):
  44.         if not self._frame:
  45.             self._frame = cv.CreateImage((frame.width, frame.height), cv.IPL_DEPTH_8U, frame.nChannels)
  46.         if frame.origin == cv.IPL_ORIGIN_TL:
  47.             cv.Copy(frame, self._frame)
  48.         else:
  49.             cv.Flip(frame, self._frame, 0)
  50.         modif_video(frame,bool)
  51.         return IplQImage(self._frame)
  52.  
  53.     
  54.     
  55.     def paintEvent(self, event):
  56.         painter = QPainter(self)
  57.         painter.drawImage(QPoint(0, 0), self._image)
  58.  
  59.  
  60.     def queryFrame(self):
  61.         frame = cv.QueryFrame(self._capture)
  62.         self._image = self._build_image(frame,bool)
  63.         self.update()
  64.  
  65.  
  66.      
  67. class QtAppli(
  68.         QApplication):                        # Objet hérité
  69.     "Fenêtre de l'application"
  70.      
  71.     # Constructeur fenêtre
  72.     def __init__(
  73.             self,                            # Instance objet
  74.             argv,                            # Arguments programme
  75.             transFile=None):                # Fichier de traduction
  76.      
  77.         # Message de contrôle
  78.         print "Python version %s - QtAppli (qt v%s, pyqt_v%s)" % (
  79.             sys.version,
  80.             QT_VERSION_STR,
  81.             PYQT_VERSION_STR
  82.         )
  83.      
  84.         # Appel constructeur de l'objet hértié
  85.         QApplication.__init__(self, argv)
  86.             
  87.         # Translations
  88.         if transFile != None:
  89.             self.__trans=QTranslator()
  90.             self.installTranslator(self.__trans)
  91.             self.__trans.load(transFile)
  92.         #if
  93.         
  94.         # Environnement ihm
  95.         self.ihm={}
  96.         self.ihm["appli"]=self
  97.         self.ihm["self"]=self
  98.      
  99.         # Widget principale
  100.         self.mainWid=QMainWindow()
  101.         self.mainWid.setCentralWidget(QWidget(self.mainWid))
  102.         self.mainWid.statusBar()
  103.     
  104.         # Titre
  105.         self.mainWid.setWindowTitle(
  106.             QApplication.translate(
  107.                 "VerifQt",
  108.                 "Exemple Qt (v%1)",
  109.                 "Note: titre de la fenêtre",
  110.                 QApplication.UnicodeUTF8,
  111.             ).arg(QString.fromUtf8(QT_VERSION_STR))
  112.         )
  113.      
  114.         # Le bouton webcam
  115.         btn=QPushButton(
  116.             QApplication.translate(
  117.                 "VerifQt",
  118.                 "Webcam",
  119.                 "Note: titre du bouton",
  120.                 QApplication.UnicodeUTF8,
  121.             ),
  122.             self.mainWid.centralWidget()
  123.         )
  124.         self.connect(
  125.             btn,
  126.             SIGNAL("clicked()" ),
  127.             self.__slotWebcam,
  128.         )
  129.         # Le bouton détection
  130.         btnd=QPushButton(
  131.             QApplication.translate(
  132.                 "VerifQt",
  133.                 "Modification",
  134.                 "Note: titre du bouton",
  135.                 QApplication.UnicodeUTF8,
  136.             ),
  137.             self.mainWid.centralWidget()
  138.         )
  139.         self.connect(
  140.             btnd,
  141.             SIGNAL("clicked()" ),
  142.             self.__slotmodif,
  143.         )
  144.      
  145.         # Pour quitter
  146.         quit=QPushButton(
  147.             QApplication.translate(
  148.                 "VerifQt",
  149.                 "Quitter",
  150.                 "Note: titre du bouton",
  151.                 QApplication.UnicodeUTF8,
  152.             )
  153.         )
  154.         self.connect(
  155.             quit,
  156.             SIGNAL("clicked()" ),
  157.             self.mainWid,
  158.             SLOT("close()" ),
  159.         )
  160.             
  161.         # La fenêtre webcam
  162.         self.webcam=QtWebcam(self.ihm)
  163.         self.webcam.setVisible(False)
  164.             
  165.         # Rangement des éléments
  166.         mainLayout=QGridLayout(self.mainWid.centralWidget())
  167.         mainLayout.addWidget(self.webcam, 0, 0, 3, 1)
  168.         mainLayout.addWidget(btn, 0, 1)
  169.         mainLayout.addWidget(btnd, 1, 1)
  170.         mainLayout.addWidget(quit, 2, 1)
  171.     # __init__()
  172.      
  173.     # Affichage et lancement application
  174.     def run(
  175.             self):                            # Instance objet
  176.         self.mainWid.show()
  177.         self.exec_()
  178.     # run()
  179.      
  180.     # Slot qui affiche la fenêtre webcam
  181.     def __slotWebcam(
  182.             self):                            # Instance objet
  183.      
  184.         print "%s.__slotWebcam" % self.__class__.__name__
  185.      
  186.         # Affichage/Masquage sous-fenêtre
  187.         self.webcam.setVisible(not self.webcam.isVisible())
  188.     # __slotWebcam()
  189.      
  190.     def __slotmodif(
  191.             self):    
  192.         modifvid(True)
  193.     # __slotQt()
  194. # class QtAppli
  195.      
  196. # Objet de fenêtre associée à la webcam
  197. class QtWebcam(
  198.         QWidget):                            # Objet hérité
  199.     "Fenêtre de l'application"
  200.      
  201.     # Constructeur fenêtre
  202.     def __init__(
  203.             self,                            # Instance objet
  204.             ihm):                            # Environnement ihm
  205.             
  206.         # Récupération environnement ihm
  207.         self.ihm=dict(ihm)                    # Environnement ihm
  208.         self.ihm["mainWid"]=self
  209.         self.ihm["self"]=self
  210.             
  211.         # Appel constructeur de l'objet hérité
  212.         QWidget.__init__(self)
  213.             
  214.         # Eléments
  215.         self.__video=VideoWidget(self)
  216.         btn=QPushButton(
  217.             QApplication.translate(
  218.                 "VerifQt",
  219.                 "add text",
  220.                 "Note: texte du bouton",
  221.                 QApplication.UnicodeUTF8,
  222.             )
  223.         )
  224.         self.connect(
  225.             btn,
  226.             SIGNAL("clicked()" ),
  227.             self.__modifvid,
  228.         )
  229.   
  230.         # Rangement de la sous-fenêtre
  231.         mainLayout=QVBoxLayout(self)
  232.         mainLayout.setMargin(0)
  233.         mainLayout.setSpacing(0)
  234.         mainLayout.addWidget(self.__video)
  235.         mainLayout.addWidget(btn)
  236.         #=======================================================================
  237.     
  238.         self.__video.setVisible(True)
  239.     # __init__()
  240.         
  241.     # Slot activé lors de l'appel sur le bouton
  242.     def __modifvid(self):
  243.         bool = True
  244.         self.__video._build_image(self.__video._frame, bool)
  245.  
  246.  
  247.     # __slotAction()
  248. # class QtWebcam
  249.  
  250.  
  251. def modifvid(booleen):
  252.     if booleen == True:
  253.         Appli.webcam.__video._build_image(frame, True)
  254.  
  255. if __name__ == "__main__":
  256.     # Lancement appli
  257.     Appli=QtAppli(sys.argv, "verifqt_en" )
  258.     Appli.run()
  259. # if
 


J'ai volontairement viré quelques trucs pour plus de visibilité...

Message cité 1 fois
Message édité par _pollux_ le 30-10-2011 à 09:13:05

---------------
Le topic du sport électronique@hfr : watch the l33t !
Reply

Marsh Posté le 30-10-2011 à 20:41:18    

_pollux_ a écrit :

Bonjour,  
 
Je reviens à la charge.
En reprenant l'exemple précédent, je veux créer un bouton dans l'objet Appli qui aurait un effet sur la vidéo de l'objet webcam.


Personnellement je mettrais le bouton directement dans l'objet webcam !!!
Mais sinon c'est possible. Tu mets dans l'objet webcam un slot "xxx" et tu relies le bouton de l'appli au slot xxx de l'objet webcam.
Ou alors, tu te la joues pro qt à fond et tu relies ton bouton de l'appli à l'émission d'un signal par l'application. Puis tu connectes le signal de l'application au slot xxx de ton objet webcam...
 

_pollux_ a écrit :

Le problème, c'est que si je crée une fonction "aspect_video" un peu n'importe où, quand je l'appelle, il me sort que l'objet webcam n'a pas d'attribut __video.


Le double underscore d'une variable ou une méthode rend la variable ou méthode privée à la classe. Et donc aucun élément extérieur à la classe ne pourra accéder à la variable ou méthode en question...
 

_pollux_ a écrit :

Code :
  1. #variables d'initialisation    
  2. min_size = (30, 30)
  3. image_scale = 4
  4. haar_scale = 1.2
  5. min_neighbors = 1
  6. haar_flags = 0
  7. global detection
  8. detection = False



 
L'avantage de créer des objets indépendants c'est aussi de pouvoir éviter les variables globales. Tu mets tes variables dans la classe QtAppli et grâce à l'élément "ihm" tu peux accéder à l'objet "QtAppli" et à ses variables...

Message cité 3 fois
Reply

Marsh Posté le 30-10-2011 à 20:45:16    

Sve@r a écrit :


Personnellement je mettrais le bouton directement dans l'objet webcam !!!
Mais sinon c'est possible. Tu mets dans l'objet webcam un slot "xxx" et tu relies le bouton de l'appli au slot xxx de l'objet webcam.
Ou alors, tu te la joues pro qt à fond et tu relies ton bouton de l'appli à l'émission d'un signal par l'application. Puis tu connectes le signal de l'application au slot xxx de ton objet webcam...
 


 
le problème, c'est que si je le mets dans l'objet webcam, le bouton n'apparaîtra que si je montre l'objet ?

Sve@r a écrit :


Le double underscore d'une variable ou une méthode rend la variable ou méthode privée à la classe. Et donc aucun élément extérieur à la classe ne pourra accéder à la variable ou méthode en question...
 


 
putain, je savais même pas ça :/ (c'est nul d'être débutant -_-)

Message cité 2 fois

---------------
Le topic du sport électronique@hfr : watch the l33t !
Reply

Marsh Posté le 30-10-2011 à 20:46:16    

Sve@r a écrit :


 
L'avantage de créer des objets indépendants c'est aussi de pouvoir éviter les variables globales. Tu mets tes variables dans la classe QtAppli et grâce à l'élément "ihm" tu peux accéder à l'objet "QtAppli" et à ses variables...


 
Ouaip, je dois avouer que j'ai pas encore eu le temps de penser à tout ça. :jap: (mais je suivrai ton conseil)


---------------
Le topic du sport électronique@hfr : watch the l33t !
Reply

Marsh Posté le 30-10-2011 à 21:03:09    

_pollux_ a écrit :


 
putain, je savais même pas ça :/ (c'est nul d'être débutant -_-)


c'était la cause de tous mes problèmes :sweat:


---------------
Le topic du sport électronique@hfr : watch the l33t !
Reply

Marsh Posté le 31-10-2011 à 11:06:33    

_pollux_ a écrit :


 
le problème, c'est que si je le mets dans l'objet webcam, le bouton n'apparaîtra que si je montre l'objet ?


Tout à fait. Tu commences à comprendre les principes Qt. A toi de voir si ça t'arrange ou pas...
 

_pollux_ a écrit :


 
putain, je savais même pas ça :/ (c'est nul d'être débutant -_-)


On l'a tous été mais ça s'arrangera...


Message édité par Sve@r le 31-10-2011 à 11:11:57
Reply

Marsh Posté le 31-10-2011 à 11:06:33   

Reply

Marsh Posté le 13-11-2011 à 00:57:42    

Sve@r a écrit :

Le double underscore d'une variable ou une méthode rend la variable ou méthode privée à la classe.


Ça fait juste du name mangling, donc on peut y accéder si on veut :o
 
Mais plus important, c'est pas à utiliser pour de la visibilité, ça existe pour des contextes d'héritage, histoire de pas se faire écraser des variables par des classes enfant.


---------------
Stick a parrot in a Call of Duty lobby, and you're gonna get a racist parrot. — Cody
Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed