Qt et Matplotlib

Version imprimable

Qt et Matplotlib

Bonjour

Mon but est sur un cylindre de le découper en 4 surfaces (voir le code où les quatre surfaces reforment le cylindre) puis d'associer à chacune de ses surfaces un scalaire entre 0 et 100 qui va varier. Je voudrais que chacune des surfaces apparaissent avec une couleur plus ou moins chaudeS selon la valeur du scalaire (par exemple: 100 rouge et 0 violet) de manière dynamique (les couleurs changent pendant qu'on regarde). Pour cela j'ai utilisé à la fois pyqt avec matplotlib qui est pas mal pour les couleurs .
Voilà mon début de code mais je ne suis pas inspiré pour la suite (je suis débutant sur pyqt):

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
 
 
import sys
from PyQt4.QtGui import *
from PyQt4.QtCore import *
 
 
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib.backends.backend_qt4agg import FigureCanvasQTAgg as FigureCanvas
from matplotlib import cm
from matplotlib.ticker import LinearLocator, FormatStrFormatter
 
class Fenetre(QWidget):
    def __init__(self):
        QWidget.__init__(self)
        self.setWindowTitle("Ma fenetre")
        self.layout = QVBoxLayout()
 
        self.fig = plt.figure()
        self.axes = self.fig.gca(projection="3d")
 
        self.canvas = FigureCanvas(self.fig)
        self.layout.addWidget(self.canvas)  # Le canvas matplotlib
 
        self.axes.set_xlabel("X")
        self.axes.set_ylabel("Y")
        self.axes.set_zlabel("Z")
 
        x1=np.linspace(-1,0,20)
        x2=np.linspace(0,1,20)
        z=np.linspace(-2,2,20)
        Xc1,Zc=np.meshgrid(x1, z)
        Yc1 = np.sqrt(1-Xc1**2)
        Xc2,Zc=np.meshgrid(x2,z)
        Yc2=np.sqrt(1-Xc2**2)
 
        surf1=self.axes.plot_surface(Xc1,Yc1,Zc,alpha=0.2,color='r')
        surf2=self.axes.plot_surface(Xc1,-Yc1,Zc,alpha=0.2,color='b')
        surf3=self.axes.plot_surface(Xc2,Yc2,Zc,alpha=0.2,color='g')
        surf4=self.axes.plot_surface(Xc2,-Yc2,Zc,alpha=0.2,color='k')
 
        self.canvas.draw()
 
        self.setLayout(self.layout)
        self.show()
 
 
app = QApplication.instance() 
if not app:
    app = QApplication(sys.argv)
fen = Fenetre()
app.exec_()

Merci d'avance pour toutes idées.

29/01/2019, 09h14
maths30

Savez-vous comment changer la couleur de la surface sans l'effacer et la retracer ?

Merci d'avance

Bonjour

Voici la suite de mon code dans lequel les surfaces changent de couleurs et se déforment quand on appuie sur le bouton (pour l'instant je fais simple avec seulement cette action).
Cependant mon diagramme en bar s'affiche sur la même fenêtre ce qui est illisble. J'aimerais créer une autre fenêtre qui affiche ce diagramme quand j'appuie sur le bouton de la fenêtre 1. Comment lier les deux fenêtres pour que les actions sur l'une influent sur l'autre?

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
 
 
import sys
import time
import random as rand
from PyQt4.QtGui import *
from PyQt4.QtCore import *
 
 
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib.backends.backend_qt4agg import FigureCanvasQTAgg as FigureCanvas
from matplotlib import cm
from matplotlib.ticker import LinearLocator, FormatStrFormatter
 
x1=np.linspace(-1,0,20)
x2=np.linspace(0,1,20)
x3=np.linspace(-1,1,20)
z1=np.linspace(-2, 2,20)
z2=2*np.ones(20)
Xc1,Zc1=np.meshgrid(x1,z1)
Yc1=np.sqrt(1-Xc1**2)
Xc2,Zc2=np.meshgrid(x2,z1)
Yc2=np.sqrt(1-Xc2**2)
Xc3,Zc3=np.meshgrid(x3,z2)
Yc3=np.sqrt(1-Xc3**2)
eps=0.01
 
 
class Fenetre(QWidget):
    def __init__(self):
        QWidget.__init__(self)
        self.setWindowTitle("Cylindre")
        self.layout = QVBoxLayout()
 
        self.fig = plt.figure()
        self.axes = self.fig.gca(projection="3d")
 
        self.canvas = FigureCanvas(self.fig)
        self.layout.addWidget(self.canvas) # le canevas matplotlib
 
        self.bouton_cylindre = QPushButton("Cylindre")
        self.bouton_cylindre.clicked.connect(self.appui_cylindre)
        self.layout.addWidget(self.bouton_cylindre)
 
        self.axes.set_xlabel("X")
        self.axes.set_ylabel("Y")
        self.axes.set_zlabel("Z")
 
        surf1=self.axes.plot_surface(Xc1,Yc1,Zc1,alpha=0.2)
        surf2=self.axes.plot_surface(Xc1,-Yc1,Zc1,alpha=0.2)
        surf3=self.axes.plot_surface(Xc2,Yc2,Zc2,alpha=0.2)
        surf4=self.axes.plot_surface(Xc2,-Yc2,Zc2,alpha=0.2)
        surf5=self.axes.plot_surface(Xc3,Yc3,Zc3,alpha=0.2)
 
        self.canvas.draw()
 
        self.setLayout(self.layout)
        self.show()
 
 
    def appui_cylindre(self):
 
        scalaire1,scalaire2,scalaire3,scalaire4,scalaire5=rand.random(),rand.random(),rand.random(),rand.random(),rand.random()
 
        x=[1,2,3,4,5]
        height=[scalaire1,scalaire2,scalaire3,scalaire4,scalaire5]
        width=1.0
 
        bar=plt.bar(x,height,width,color='b')
 
        Y1=np.sqrt(1-(1+scalaire1)*Xc1**2)
        Y2=np.sqrt(1-(1+scalaire2)*Xc1**2)
        Y3=np.sqrt(1-(1+scalaire3)*Xc2**2)
        Y4=np.sqrt(1-(1+scalaire4)*Xc2**2)
        y=np.linspace(-2-2*scalaire5,2+2*scalaire5,20)
        X5,Y5=np.meshgrid(x3,y)
        Z5=Y5**2
 
        surf1=self.axes.plot_surface(Xc1,Y1,Zc1,alpha=0.2,color=(scalaire1,0,1-scalaire1))
        surf2=self.axes.plot_surface(Xc1,-Y2,Zc1,alpha=0.2,color=(scalaire2,0,1-scalaire2))
        surf3=self.axes.plot_surface(Xc2,Y3,Zc2,alpha=0.2,color=(scalaire3,0,1-scalaire3))
        surf4=self.axes.plot_surface(Xc2,-Y4,Zc2,alpha=0.2,color=(scalaire4,0,1-scalaire4))
        if abs(scalaire5)<eps:
            surf5=self.axes.plot_surface(Xc3,Yc3,Zc3,alpha=0.2)
        else:
             y=np.linspace(-2-2*scalaire5,2+2*scalaire5,20)
             X5,Y5=np.meshgrid(x3,y)
             Z5=Y5**2
             surf5=self.axes.plot_surface(X5,Y5,Z5,alpha=0.2,color=(scalaire5,0,1-scalaire5))
 
        self.canvas.draw()
        plt.cla()
 
app = QApplication.instance() 
if not app:
    app = QApplication(sys.argv)
fen = Fenetre()
app.exec_()

J'ai réussi à relier les deux fenêtres. Cependant j'ai encore un problème: sur le code précédent les tracés ne s'accumulaient pas mais maintenant les tracés s'accumulent.

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
 
 
import sys
import time
import random as rand
from PyQt4.QtGui import *
from PyQt4.QtCore import *
 
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib.backends.backend_qt4agg import FigureCanvasQTAgg as FigureCanvas
from matplotlib import cm
from matplotlib.ticker import LinearLocator, FormatStrFormatter
 
x1=np.linspace(-1,0,20)
x2=np.linspace(0,1,20)
x3=np.linspace(-1,1,20)
z1=np.linspace(-2, 2,20)
z2=2*np.ones(20)
Xc1,Zc1=np.meshgrid(x1,z1)
Yc1=np.sqrt(1-Xc1**2)
Xc2,Zc2=np.meshgrid(x2,z1)
Yc2=np.sqrt(1-Xc2**2)
Xc3,Zc3=np.meshgrid(x3,z2)
Yc3=np.sqrt(1-Xc3**2)
eps=0.01
 
 
class Principal(QWidget):
    def __init__(self,parent=None):
        super(Principal,self).__init__(parent)
        self.setWindowTitle("Cylindre")
        self.layout = QVBoxLayout()
 
        self.fig = plt.figure()
        self.axes = self.fig.gca(projection="3d")
 
        self.canvas = FigureCanvas(self.fig)
        self.layout.addWidget(self.canvas) # le canevas matplotlib
 
        self.secondaire=Secondaire()
 
        self.bouton_cylindre = QPushButton("Cylindre")
        self.bouton_cylindre.clicked.connect(self.appui_cylindre)
        self.layout.addWidget(self.bouton_cylindre)
 
        self.axes.set_xlabel("X")
        self.axes.set_ylabel("Y")
        self.axes.set_zlabel("Z")
 
        #les 5 surfaces initiales
        surf1=self.axes.plot_surface(Xc1,Yc1,Zc1,alpha=0.2)
        surf2=self.axes.plot_surface(Xc1,-Yc1,Zc1,alpha=0.2)
        surf3=self.axes.plot_surface(Xc2,Yc2,Zc2,alpha=0.2)
        surf4=self.axes.plot_surface(Xc2,-Yc2,Zc2,alpha=0.2)
        surf5=self.axes.plot_surface(Xc3,Yc3,Zc3,alpha=0.2)
 
        self.canvas.draw()
 
        self.setLayout(self.layout)
        self.show()
 
 
    def appui_cylindre(self):
 
        scalaire1,scalaire2,scalaire3,scalaire4,scalaire5=rand.random(),rand.random(),rand.random(),rand.random(),rand.random()
 
        Y1=np.sqrt(1-(1+scalaire1)*Xc1**2) # déforme la surface selon la valeur de scalaire1
        Y2=np.sqrt(1-(1+scalaire2)*Xc1**2)
        Y3=np.sqrt(1-(1+scalaire3)*Xc2**2)
        Y4=np.sqrt(1-(1+scalaire4)*Xc2**2)
        y=np.linspace(-2-2*scalaire5,2+2*scalaire5,20)
        X5,Y5=np.meshgrid(x3,y)
        Z5=Y5**2 #Le plateau du cylindre se déformera sous forme de parabole
 
 
        surf1=self.axes.plot_surface(Xc1,Y1,Zc1,alpha=0.2,color=(scalaire1,0,1-scalaire1)) #Couleurs définies en utilisant le code RVB (rouge signifie que scalaire1 est eleve)
        surf2=self.axes.plot_surface(Xc1,-Y2,Zc1,alpha=0.2,color=(scalaire2,0,1-scalaire2))
        surf3=self.axes.plot_surface(Xc2,Y3,Zc2,alpha=0.2,color=(scalaire3,0,1-scalaire3))
        surf4=self.axes.plot_surface(Xc2,-Y4,Zc2,alpha=0.2,color=(scalaire4,0,1-scalaire4))
        if abs(scalaire5)<eps:
            surf5=self.axes.plot_surface(Xc3,Yc3,Zc3,alpha=0.2)
        else:
             y=np.linspace(-2-2*scalaire5,2+2*scalaire5,20)
             X5,Y5=np.meshgrid(x3,y)
             Z5=Y5**2
             surf5=self.axes.plot_surface(X5,Y5,Z5,alpha=0.2,color=(scalaire5,0,1-scalaire5))
 
        self.canvas.draw()
        plt.cla()
 
        self.diag=self.secondaire.diagramme(scalaire1,scalaire2,scalaire3,scalaire4,scalaire5)
 
class Secondaire(QWidget):
    def __init__(self,parent=None):
        super(Secondaire,self).__init__(parent)
        self.setWindowTitle("Diagramme en barre")
        self.layout = QVBoxLayout()
 
        self.fig = plt.figure()
 
        self.canvas = FigureCanvas(self.fig)
        self.layout.addWidget(self.canvas) # le canevas matplotlib
 
        self.setLayout(self.layout)
        self.show()
 
    def diagramme(self,scalaire1,scalaire2,scalaire3,scalaire4,scalaire5):
 
        x=[1,2,3,4,5]
        height=[scalaire1,scalaire2,scalaire3,scalaire4,scalaire5]
        width=1.0
        bar=plt.bar(x,height,width,color='b')
        self.canvas.draw()
        plt.cla()
 
app = QApplication.instance() 
if not app:
    app = QApplication(sys.argv)
fen = Principal()
app.exec_()

30/01/2019, 09h47
maths30

Je pense que ceci est du au fait que plt.cla initialise le tracé dans la dernière fenêtre ouverte qui est dans ce cas la seconde.
Auriez-vous un moyen de régler ceci ?

J'ai réglé le problème de manière peu satisfaisante car je dois supprimer le graphe ce qui ralentit l'application.
Cependant je ne sais pas comment faire pour faire tourner la figure avec la souris ?

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
 
 
import sys
import time
import random as rand
from PyQt4.QtGui import *
from PyQt4.QtCore import *
 
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib.backends.backend_qt4agg import FigureCanvasQTAgg as FigureCanvas
from matplotlib import cm
from matplotlib.ticker import LinearLocator, FormatStrFormatter
 
x1=np.linspace(-1,0,20)
x2=np.linspace(0,1,20)
x3=np.linspace(-1,1,20)
z1=np.linspace(-2, 2,20)
z2=2*np.ones(20)
Xc1,Zc1=np.meshgrid(x1,z1)
Yc1=np.sqrt(1-Xc1**2)
Xc2,Zc2=np.meshgrid(x2,z1)
Yc2=np.sqrt(1-Xc2**2)
Xc3,Zc3=np.meshgrid(x3,z2)
Yc3=np.sqrt(1-Xc3**2)
eps=0.01
 
timer=QTimer()
 
def gen_donnees():
 
    L=[rand.random(),0,0,0,0]
    fen1.change_graph(L)
 
class Principal(QWidget):
    def __init__(self,parent=None):
        super(Principal,self).__init__(parent)
        self.setWindowTitle("Cylindre")
        self.layout = QVBoxLayout()
 
        self.fig = plt.figure()
        self.axes = self.fig.gca(projection="3d")
 
        self.canvas = FigureCanvas(self.fig)
        self.layout.addWidget(self.canvas) # le canevas matplotlib
 
        self.fen2=Secondaire()
 
        self.axes.set_xlabel("X")
        self.axes.set_ylabel("Y")
        self.axes.set_zlabel("Z")
 
        #les 5 surfaces initiales
        surf1=self.axes.plot_surface(Xc1,Yc1,Zc1,alpha=0.2)
        surf2=self.axes.plot_surface(Xc1,-Yc1,Zc1,alpha=0.2)
        surf3=self.axes.plot_surface(Xc2,Yc2,Zc2,alpha=0.2)
        surf4=self.axes.plot_surface(Xc2,-Yc2,Zc2,alpha=0.2)
        surf5=self.axes.plot_surface(Xc3,Yc3,Zc3,alpha=0.2)
 
        self.fig.canvas.draw()
 
        self.setLayout(self.layout)
        self.show()
 
 
    @pyqtSlot() 
    def change_graph(self,L): #liste constituee des 5 valeurs
 
        scalaire1,scalaire2,scalaire3,scalaire4,scalaire5=L[0],L[1],L[2],L[3],L[4]
 
        Y1=np.sqrt((1-scalaire1)-Xc1**2) # déforme la surface selon la valeur de scalaire1
        Y2=np.sqrt((1-scalaire2)-Xc1**2)
        Y3=np.sqrt((1-scalaire3)-Xc2**2)
        Y4=np.sqrt((1-scalaire4)-Xc2**2)
        y=np.linspace(-2-2*scalaire5,2+2*scalaire5,20)
        X5,Y5=np.meshgrid(x3,y)
        Z5=Y5**2 #Le plateau du cylindre se déformera sous forme de parabole
 
        self.axes.plot_surface(Xc1,Yc1,Zc1,alpha=0.2)
        self.axes.plot_surface(Xc1,-Yc1,Zc1,alpha=0.2)
        self.axes.plot_surface(Xc2,Yc2,Zc2,alpha=0.2)
        self.axes.plot_surface(Xc2,-Yc2,Zc2,alpha=0.2)
        self.axes.plot_surface(Xc3,Yc3,Zc3,alpha=0.2)
 
        surf1=self.axes.plot_surface(Xc1,Y1,Zc1,alpha=0.2,color=(scalaire1,0,1-scalaire1)) #Couleurs définies en utilisant le code RVB (rouge signifie que scalaire1 est eleve)
        surf2=self.axes.plot_surface(Xc1,-Y2,Zc1,alpha=0.2,color=(scalaire2,0,1-scalaire2))
        surf3=self.axes.plot_surface(Xc2,Y3,Zc2,alpha=0.2,color=(scalaire3,0,1-scalaire3))
        surf4=self.axes.plot_surface(Xc2,-Y4,Zc2,alpha=0.2,color=(scalaire4,0,1-scalaire4))
        if abs(scalaire5)<eps:
            surf5=self.axes.plot_surface(Xc3,Yc3,Zc3,alpha=0.2)
        else:
             y=np.linspace(-2-2*scalaire5,2+2*scalaire5,20)
             X5,Y5=np.meshgrid(x3,y)
             Z5=Y5**2
             surf5=self.axes.plot_surface(X5,Y5,Z5,alpha=0.2,color=(scalaire5,0,1-scalaire5))
 
        self.fig.canvas.draw()
 
        self.axes.clear()
 
        self.diag=self.fen2.diagramme(L)
 
 
class Secondaire(QWidget): #Vient tracer un diagramme en barre dans une seconde fenêtre
    def __init__(self,parent=None):
        super(Secondaire,self).__init__(parent)
        self.setWindowTitle("Diagramme en barre")
        self.layout = QVBoxLayout()
 
        self.fig2 = plt.figure()
 
        self.canvas = FigureCanvas(self.fig2)
        self.layout.addWidget(self.canvas) # le canevas matplotlib
 
        self.setLayout(self.layout)
        self.show()
 
    def diagramme(self,L): 
 
        x=[1,2,3,4,5]
        height=L
        width=1.0
        bar=plt.bar(x,height,width,color='b')
        self.fig2.canvas.draw()
        plt.cla()
 
app = QApplication.instance() 
if not app:
    app = QApplication(sys.argv)
fen1=Principal()
timer.timeout.connect(gen_donnees)
timer.start(10)
app.exec_()