Discussion :

[frisou65]

Bonjour,

j'utilise le code suivant pour afficher une interface avec des boutons commandant des fonctions affichant des graphs :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
# -*- coding: iso-8859-1 -*-
 
import sys,os
from Tkinter import *
import tkFileDialog
from PyQt4 import QtCore, QtGui
from Carte_defaut import *
from Traitements_image import *
from exemple_3D import *
from fileopen import *
 
h = 300
l = 575
 
class Frame(QtGui.QMainWindow):
    def __init__(self, parent=None):
        QtGui.QMainWindow.__init__(self, parent)
        self.resize(l,h)
        self.setFont(QtGui.QFont("Verdana"))
        self.setWindowTitle("Traitement données thermographie IR")
        try:
            self.setWindowIcon(QtGui.Icon("icon.jpg"))
        except:pass
 
        fen = QtGui.QDesktopWidget().screenGeometry()
        size = self.geometry()
        self.move((fen.width()-size.width())/2, (fen.height()-size.height())/2)
 
 
        #Création de la barre de statut avec les informations voulues.
        self.statusBar().showMessage("Identification de la taille des défauts")
 
        menubar = self.menuBar() ## Création d'une barre de menu
        file_ = menubar.addMenu("Fichier") ## Ajout d'un menu.
 
 
        #Ajout de la fenêtre Ã* onglets
        self.tabWidget = QtGui.QTabWidget(self)
        self.tabWidget.setGeometry(0,20,l,h-40)
 
        #Création de deux QWidget qui permettront ensuite de créer les pages du QTabWidget
        self.pnl_1 = QtGui.QWidget(self.tabWidget)
 
        #À noter que le parent du QWidget peut aussi bien être le QTabWidget 
    #ou le QMainWindows. Personnellement, je préfère la première solution afin 
    #de garder une hiérarchie cohérente dans le code.
        self.pnl_2 = QtGui.QWidget(self)
        self.pnl_3 = QtGui.QWidget(self)
 
        #Ajout des QWidgets en temps que Tab du QTabWidget.
    #Le premier Tab portera le nom Entrée et le deuxième le nom Lecture.
        self.tabWidget.addTab(self.pnl_1, "Courbe d'erreurs 2D")
        self.tabWidget.addTab(self.pnl_2, "Courbe d'erreurs 3D")
        self.tabWidget.addTab(self.pnl_3, "Traitement images")
 
        #Modification de la couleur de fond des QWidget.
        self.pnl_1.setPalette(QtGui.QPalette(QtGui.QColor("white")))
        self.pnl_1.setAutoFillBackground(True)
        self.pnl_2.setPalette(QtGui.QPalette(QtGui.QColor("white")))
        self.pnl_2.setAutoFillBackground(True)
        self.pnl_3.setPalette(QtGui.QPalette(QtGui.QColor("white")))
        self.pnl_3.setAutoFillBackground(True)
 
 
 
        self.gene = QtGui.QPushButton("Carte temperature 2D (couleur)", self.pnl_1)
        self.gene.move(110, 50)
        self.gene.clicked.connect(Carte_erreur_C)
 
        self.gene = QtGui.QPushButton("Carte temperature 2D (niveau de gris)", self.pnl_1)
        self.gene.move(110, 150)
        self.gene.clicked.connect(Carte_erreur_NB)
 
 
        self.gene = QtGui.QPushButton("Carte temperature 3D (points)", self.pnl_2)
        self.gene.move(110, 50)
        self.gene.clicked.connect(Carte_erreur_3D_P)
 
        self.gene = QtGui.QPushButton("Carte temperature 3D (contour)", self.pnl_2)
        self.gene.move(110, 100)
        self.gene.clicked.connect(Carte_erreur_3D_contour)
 
        self.gene = QtGui.QPushButton("Carte temperature 3D (surface)", self.pnl_2)
        self.gene.move(110, 150)
        self.gene.clicked.connect(exemple3D_2)
 
        self.gene = QtGui.QPushButton("Seuillage", self.pnl_3)
        self.gene.move(110, 50)
        self.gene.clicked.connect(Seuillage)
 
        self.gene = QtGui.QPushButton("Coupe sur X", self.pnl_3)
        self.gene.move(110, 100)
        self.gene.clicked.connect(Coupe_sur_x)
 
        self.gene = QtGui.QPushButton("Coupe sur Y", self.pnl_3)
        self.gene.move(110, 150)
        self.gene.clicked.connect(Coupe_sur_y)
 
 
if __name__ == '__main__':
    app = QtGui.QApplication(sys.argv)
    frame = Frame()
    frame.show()
    sys.exit(app.exec_())

Ce code fonctionne par contre je ne peux utiliser qu'une fonction pour chaque affichage de l'interface. En effet, chaque fonction marche et affiche le graph en Tkinter par contre pour un affichage de l'interface, si j'active une deuxième fonctionne celle-ci marchera mais le graph s'affichera vide....

Est ce que quelqu'un aurait une solution à me proposer ??

Merci d'avance.

Cordialement.

[VinsS]

Ils sont si difficiles à faire avec Qt ces graphes?

Je dis ça parce que mélanger TKinter et Qt, ça me semble promettre beaucoup de travail aussi. Peut-être plus.

Ce sont des graphes fait avec une bibliothèque pour python?

[wiztricks]

Salut,

Dans la pratique, un gui comme Tk, Qt, GTK,... met à jour ses "windows" en traitant les événements qui lui ont été expédiés.

Le fonctionnement "normal" est de construire une interface "minimale" au lancement de l'application et de passer la main à la boucle de traitement(*) des événements pour que "çà bouge" en fonction des requêtes "utilisateurs".
(*) c'est ce qui se passe avec l'appel a app.exec_() ou tk.mainloop().

Afin de permettre le traitement des événements accumulés (la réactivité de l'interface) lors de traitements "longs", tous les gui permettent de vider la pile d'événements .update_idletasks pour tk, .processEvents pour Qt.

Appeler .update_idletasks "de temps en temps" devrait permettre de faire avancer les choses côté tk mais le résultat est hypothétique: çà marchera (ou pas) jusqu'à la prochaine modification de code.

Le vrai soucis de cette cohabitation est qu'en cas de dysfonctionnement tout le monde pointera du doigt l'aspect hors des règles de l'art, "jamais vu", "jamais fait",... et abandonné à une grande solitude.

Il serait quand même plus sage d'envisager d'autres options:
- Un seul GUI? Si vous connaissez bien Qt, démarrer sur Tk sera facile.
- Placer chaque GUI dans une boîte (process ou threads) et réaliser une communication ad hoc entre eux (IPC/D-bus, event). Le but étant de pouvoir tester indépendamment l'un et l'autre.

Bon courage
- W