QGraphicsScene image et buffer

Version imprimable

Bonjour,
ci dessous un code qui affiche une photo dans un qgraphiscene (jusque là pas de pb).
ensuite j'utilise pillow (judicieux ou mieux vaut éviter???) pour traiter l'image chargée.

le code semble "bien" fonctionner mais je trouve dommage de devoir travailler qu'avec des fichier image existant... ça nécessite d'enregistrer (à chaque action) un nouveau fichier et je pense que c'est pour cela que le tout rame un peu...

dans la doc je croise parfois des appels à des "buffer" ou des "stringIO" qui je crois pourraient m'être utile mais je n'arrive pas à les faire fonctionner...
globalement j'aimerais pouvoir jouer avec des commandes (bouton ou slider) sur différentes options d'imagerie (contraste, lum etc...)

merci!

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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
from PyQt5 import QtCore
from PyQt5.QtWidgets import *
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtMultimedia import *
from PyQt5.QtMultimediaWidgets import QVideoWidget
from PIL import ImageEnhance
from PIL import Image
from PIL import ImageFilter
import os,sys
 
class fenPrincipale(QMainWindow):
    def __init__(self):
        QMainWindow.__init__(self)
 
        fenetre_widget = QWidget()
        self.videoWidget = QVideoWidget()
        self.camera=QCamera(QCamera.FrontFace)
        self.camera.setViewfinder(self.videoWidget)
        self.scene=QGraphicsScene()
        self.view =QGraphicsView()
        self.view.setStyleSheet("background: transparent")
 
        #self.camera.start()
 
        #Boutons
        self.bouton_refresh = QPushButton("charger photo")
        self.bouton_refresh.setIconSize(QtCore.QSize(70,70))
        self.bouton_refresh.setFixedWidth(100)
        self.bouton_refresh.setFixedHeight(85)
 
        self.bouton_valider= QPushButton("test1")
        self.bouton_valider.setIconSize(QtCore.QSize(70,70))
        self.bouton_valider.setFixedWidth(100)
        self.bouton_valider.setFixedHeight(85)
 
        self.bouton_stop= QPushButton("test2")
        self.bouton_stop.setIconSize(QtCore.QSize(70,70))
        self.bouton_stop.setFixedWidth(100)
        self.bouton_stop.setFixedHeight(85)
 
        self.bouton_pillow = QPushButton("test3")
        self.bouton_pillow.setFixedWidth(100)
        self.bouton_pillow.setFixedHeight(85)
 
        #slider et lcd
        self.slider = QSlider(QtCore.Qt.Horizontal)
        self.ecranlcd = QLCDNumber()
        self.slider.setMinimum(-10)
        self.slider.setMaximum(10)
        self.slider.setFixedHeight(40)
        self.slider.valueChanged.connect(self.ecranlcd.display)
 
        #Layout
        layoutvertical1=QVBoxLayout()
        layouthorizontal1 = QHBoxLayout()
        layouthorizontal2 = QHBoxLayout()
        layouthorizontal3 = QHBoxLayout()
 
 
        layoutvertical1.addLayout(layouthorizontal1)
        layoutvertical1.addLayout(layouthorizontal2)
        layoutvertical1.addLayout(layouthorizontal3)
 
        layouthorizontal2.addWidget(self.bouton_refresh)
        layouthorizontal2.addWidget(self.bouton_valider)
        layouthorizontal2.addWidget(self.bouton_stop)
        layouthorizontal3.addWidget(self.slider)
        layouthorizontal3.addWidget(self.ecranlcd)
        layouthorizontal2.addWidget(self.bouton_pillow)
        layouthorizontal1.addWidget(self.view)
        #layouthorizontal2.addWidget(self.videoWidget)
 
        #Intégration    
        fenetre_widget.setLayout(layoutvertical1)        
        self.setCentralWidget(fenetre_widget)
 
        #Fonctions Connect
        self.bouton_refresh.clicked.connect(self.charger)
        self.bouton_stop.clicked.connect(self.test1)
        self.bouton_valider.clicked.connect(self.test2)
        self.bouton_pillow.clicked.connect(self.test3)
        self.view.setScene(self.scene)
 
        self.slider.sliderMoved.connect(self.contrast)
 
        #refresh = resizeEvent()
        self.c=1.1
        self.scene.setSceneRect(0, 0, self.width(), self.height())
        self.view.setSceneRect(0, 0, self.width(), self.height())
 
    def resizeEvent(self,resizeEvent):
        self.scene.setSceneRect(0, 0, self.width(), self.height())
        self.view.setSceneRect(0, 0, self.width(), self.height())
 
        self.view.setScene(self.scene)
    def contrast(self):
        self.scene.clear()
        self.a=self.ecranlcd.value()+1
        print(self.a)
        self.image_originale = Image.open('moi2.jpeg')
        self.modification = ImageEnhance.Contrast(self.image_originale)
        self.modification.enhance(self.c).save("test3.jpeg","JPEG")
        self.image_modifiee = QImage('test3.jpeg')
        self.pixmap = QPixmap.fromImage(self.image_modifiee.scaled(800, 600, Qt.KeepAspectRatio, Qt.SmoothTransformation))
        self.scene.addPixmap(self.pixmap)
        self.view.setScene(self.scene)
    def charger(self):
        self.scene.clear()
        self.im0 = QImage("moi2.jpeg")
        self.pixmap = QPixmap.fromImage(self.im0.scaled(300, 300, Qt.KeepAspectRatio, Qt.SmoothTransformation))
        w_pix, h_pix = self.pixmap.width(), self.pixmap.height()
        self.scene.setSceneRect(0, 0, w_pix, h_pix)
        self.scene.addPixmap(self.pixmap)
        self.view.setSceneRect(0, 0, w_pix, h_pix)
        self.view.setScene(self.scene)
 
    def test1(self):
        self.scene.clear()
        self.image_originale = Image.open('moi2.jpeg')
        self.modif = ImageEnhance.Sharpness(self.image_originale)
        self.modif.enhance(self.c).save("test1.jpeg","JPEG")
        self.im0 = QImage('test1.jpeg')
        self.pixmap = QPixmap.fromImage(self.im0.scaled(800, 600, Qt.KeepAspectRatio, Qt.SmoothTransformation))
        self.scene.addPixmap(self.pixmap)
        self.scene.setSceneRect(0, 0, 800, 600)
        self.view.setSceneRect(0, 0, 800, 600)
 
        self.view.setScene(self.scene)
 
    def test2(self):
        self.scene.clear()
        self.image_originale = Image.open('moi2.jpeg')
        self.modif = self.image_originale.filter(ImageFilter.CONTOUR)
        self.modif.save("test2.jpeg","JPEG")
        self.im0 = QImage('test2.jpeg')
        self.pixmap = QPixmap.fromImage(self.im0.scaled(800, 600, Qt.KeepAspectRatio, Qt.SmoothTransformation))
        self.scene.addPixmap(self.pixmap)
        self.view.setScene(self.scene)
 
    def test3(self):
        self.scene.clear()
        self.c=self.c + 0.1
        self.image_originale = Image.open('moi2.jpeg')
        self.modification = ImageEnhance.Contrast(self.image_originale)
        self.modification.enhance(self.c).save("test3.jpeg","JPEG")
        self.image_modifiee = QImage('test3.jpeg')
        self.pixmap = QPixmap.fromImage(self.image_modifiee.scaled(800, 600, Qt.KeepAspectRatio, Qt.SmoothTransformation))
        self.scene.addPixmap(self.pixmap)
        self.view.setScene(self.scene)
        #ImageEnhance.Brightness(image)
        #ImageEnhance.Sharpness(image)
        #ImageEnhance.Color(image)
        #im = Image.frombuffer(mode, size, data, "raw", mode, 0, 1)    /   ('RGBA', (w, h), imgdata, 'raw', 'RGBA', 0, 1)
        #im.load()???
def main(args):
    appli=QApplication(args)
    fenetre=fenPrincipale()
    fenetre.show()    
    r=appli.exec_()
    return r
 
if __name__=="__main__":
    main(sys.argv)

12/12/2015, 17h56
VinsS

Salut,

Pour convertir une image de Pillow vers QImage c'est inclus dans Pillow.

http://pillow.readthedocs.org/en/3.0...e/ImageQt.html

Pour le contraire il faut écrire du code, par exemple ceci:

https://github.com/python-pillow/Pil...PIL/ImageQt.py

J'ai jeté un oeil, ça ne me parait pas trop compliqué.

buffer et images pil

salut,
merci pour les liens!

donc pour éviter d'avoir à ouvrir/enregistrer des fichiers au cours des modifs d'images, j'ai bien basculer sur l'utilisation de "buffer" (si j'ai bien tout compris).
Ma bidouille semble marcher mais j'ai deux interrogations dont une qui me pose problème:

1- Mes lignes de code, je les trouve pas très élégantes... je pars d'un pixmap pour le faire passer dans un buffer puis j'applique une conversion en imageQt pour enfin basculer en QImage:? et idem dans l'autre sens... je pars d'une image pil->traitement de l'image->buffer->imageQ->Qimage->pixmap...

il n'y a pas un moyen plus propre? plus direct?

2-(c'est ce point là qui me dérange le plus) A cause de mes multiples conversions, j'ai l'impression que les images que je traite deviennent floues (perte de qualité). j'ai essayé de travailler en png (et non en jpeg) mais ça n'empêche pas la dégradation de la qualité... j'ai des rendus plus propres quand je passe par des sauvegardes de fichiers intermédiaires...

ici le code (désolé il y a tout et c'est un peu long... mais au moins ça tourne)
donc c'est de "def test3(self)" dont je parle ici (fonction sensée augmenter le contraste d'une photo initialement chargée dans un graphicsscene... chargement avec le bouton "charger"):

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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
from PyQt5 import QtCore
from PyQt5.QtWidgets import *
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtMultimedia import *
from PyQt5.QtMultimediaWidgets import QVideoWidget
from PIL import ImageEnhance
from PIL import Image
from PIL.ImageQt import ImageQt
from PIL import ImageFilter
from io import BytesIO
import os,sys,time
 
class fenPrincipale(QMainWindow):
    def __init__(self):
        QMainWindow.__init__(self)
 
        fenetre_widget = QWidget()
        self.videoWidget = QVideoWidget()
        self.camera=QCamera(QCamera.FrontFace)
        self.camera.setViewfinder(self.videoWidget)
        self.scene=QGraphicsScene()
        self.view =QGraphicsView()
        self.view.setStyleSheet("background: transparent")
 
        #self.camera.start()
 
        #Boutons
        self.bouton_refresh = QPushButton("charger photo")
        self.bouton_refresh.setIconSize(QtCore.QSize(70,70))
        self.bouton_refresh.setFixedWidth(100)
        self.bouton_refresh.setFixedHeight(85)
 
        self.bouton_valider= QPushButton("test1")
        self.bouton_valider.setIconSize(QtCore.QSize(70,70))
        self.bouton_valider.setFixedWidth(100)
        self.bouton_valider.setFixedHeight(85)
 
        self.bouton_stop= QPushButton("test2")
        self.bouton_stop.setIconSize(QtCore.QSize(70,70))
        self.bouton_stop.setFixedWidth(100)
        self.bouton_stop.setFixedHeight(85)
 
        self.bouton_pillow = QPushButton("test3")
        self.bouton_pillow.setFixedWidth(100)
        self.bouton_pillow.setFixedHeight(85)
 
        #slider et lcd
        self.slider = QSlider(QtCore.Qt.Horizontal)
        self.ecranlcd = QLCDNumber()
        self.slider.setMinimum(-10)
        self.slider.setMaximum(10)
        self.slider.setFixedHeight(40)
        self.slider.valueChanged.connect(self.ecranlcd.display)
 
        #Layout
        layoutvertical1=QVBoxLayout()
        layouthorizontal1 = QHBoxLayout()
        layouthorizontal2 = QHBoxLayout()
        layouthorizontal3 = QHBoxLayout()
 
 
        layoutvertical1.addLayout(layouthorizontal1)
        layoutvertical1.addLayout(layouthorizontal2)
        layoutvertical1.addLayout(layouthorizontal3)
 
        layouthorizontal2.addWidget(self.bouton_refresh)
        layouthorizontal2.addWidget(self.bouton_valider)
        layouthorizontal2.addWidget(self.bouton_stop)
        layouthorizontal3.addWidget(self.slider)
        layouthorizontal3.addWidget(self.ecranlcd)
        layouthorizontal2.addWidget(self.bouton_pillow)
        layouthorizontal1.addWidget(self.view)
        #layouthorizontal2.addWidget(self.videoWidget)
 
        #Intégration    
        fenetre_widget.setLayout(layoutvertical1)        
        self.setCentralWidget(fenetre_widget)
 
        #Fonctions Connect
        self.bouton_refresh.clicked.connect(self.charger)
        self.bouton_stop.clicked.connect(self.test1)
        self.bouton_valider.clicked.connect(self.test2)
        self.bouton_pillow.clicked.connect(self.test3)
        self.view.setScene(self.scene)
 
        self.slider.sliderMoved.connect(self.contrast)
 
        #refresh = resizeEvent()
        self.c=1.1
        self.scene.setSceneRect(0, 0, self.width(), self.height())
        self.view.setSceneRect(0, 0, self.width(), self.height())
 
    def resizeEvent(self,resizeEvent):
        self.scene.setSceneRect(0, 0, self.width(), self.height())
        self.view.setSceneRect(0, 0, self.width(), self.height())
        self.view.setScene(self.scene)
    def contrast(self):
        self.scene.clear()
        self.a=self.ecranlcd.value()+1
        print(self.a)
        self.image_originale = Image.open('moi2.jpeg')
        self.modification = ImageEnhance.Contrast(self.image_originale)
        self.modification.enhance(self.c).save("test3.jpeg","JPEG")
        self.image_modifiee = QImage('test3.jpeg')
        self.pixmap = QPixmap.fromImage(self.image_modifiee.scaled(800, 600, Qt.KeepAspectRatio, Qt.SmoothTransformation))
        self.scene.addPixmap(self.pixmap)
        self.view.setScene(self.scene)
    def charger(self):
        self.scene.clear()
        self.im0 = QImage("moi2.jpeg")
        self.pixmap = QPixmap.fromImage(self.im0.scaled(300, 300, Qt.KeepAspectRatio, Qt.SmoothTransformation))
        w_pix, h_pix = self.pixmap.width(), self.pixmap.height()
        self.scene.setSceneRect(0, 0, w_pix, h_pix)
        self.scene.addPixmap(self.pixmap)
        self.view.setSceneRect(0, 0, w_pix, h_pix)
        self.view.setScene(self.scene)
 
    def test1(self):
        tstart=time.time()
        print(time.time()-tstart)
        self.scene.clear()
        buffer = QBuffer()
        buffer.open(QIODevice.ReadWrite)
        print(time.time()-tstart)
        self.image_originale = Image.open('moi2.jpeg')
        #self.modif = ImageEnhance.Sharpness(self.image_originale)
        self.modif = ImageEnhance.Sharpness(self.image_originale)
        self.modif.enhance(self.c).save(buffer,"jpeg")
        print(time.time()-tstart)
        b = BytesIO()
        b.write(buffer.data())
        #buffer.close()
        b.seek(0)
        print(time.time()-tstart)
        self.modif2 = Image.open(b)
        self.imageq=ImageQt(self.modif2)
        self.qimage=QImage(self.imageq)
        self.pixmap = QPixmap.fromImage(self.qimage.scaled(800, 600, Qt.KeepAspectRatio, Qt.SmoothTransformation))
        print(time.time()-tstart)
        self.scene.addPixmap(self.pixmap)
        self.scene.setSceneRect(0, 0, 800, 600)
        self.view.setSceneRect(0, 0, 800, 600)
        print(time.time()-tstart)
        self.view.setScene(self.scene)
        buffer.close()
        print(time.time()-tstart)
    def test3(self):
        buffer1 = QBuffer()
        buffer2 = QBuffer()
        buffer1.open(QIODevice.ReadWrite)
        buffer2.open(QIODevice.ReadWrite)
        self.scene.clear()
        self.c=self.c + 0.1
 
        self.image_originale = QImage(self.pixmap)
        self.image_originale.save(buffer1,"jpeg")
 
        b1 = BytesIO()
        b1.write(buffer1.data())
        b1.seek(0)
        self.image_originale2 = Image.open(b1)
        self.modification = ImageEnhance.Contrast(self.image_originale2)
        self.modification.enhance(self.c).save(buffer2,"jpeg")
 
        b2 = BytesIO()
        b2.write(buffer2.data())
        b2.seek(0)
        self.modif2 = Image.open(b2)
 
        self.imageq=ImageQt(self.modif2)
        self.qimage=QImage(self.imageq)
        self.pixmap = QPixmap.fromImage(self.qimage.scaled(800, 600, Qt.KeepAspectRatio, Qt.SmoothTransformation))
        self.scene.addPixmap(self.pixmap)
        self.scene.setSceneRect(0, 0, 800, 600)
        self.view.setSceneRect(0, 0, 800, 600)
        self.view.setScene(self.scene)
        buffer1.close()
        buffer2.close()
 
 
        #self.image_originale = self.image_originale.convert("RGBA")
        #self.data = self.image_originale.tostring('raw', "RGBA")
        #self.qimage = QImage(self.data)
 
    def test2(self):
        self.scene.clear()
        self.image_originale = Image.open('moi2.jpeg')
        self.modif = self.image_originale.filter(ImageFilter.CONTOUR)
        self.modif.save("test2.jpeg","JPEG")
        self.im0 = QImage('test2.jpeg')
        self.pixmap = QPixmap.fromImage(self.im0.scaled(800, 600, Qt.KeepAspectRatio, Qt.SmoothTransformation))
        self.scene.addPixmap(self.pixmap)
        self.view.setScene(self.scene)
 
def main(args):
    appli=QApplication(args)
    fenetre=fenPrincipale()
    fenetre.show()    
    r=appli.exec_()
    return r
 
if __name__=="__main__":
    main(sys.argv)

13/12/2015, 11h18
Invité

pour le souci de qualité, je crois que j'ai trouvé... je chargeais la photo de base sous une résolution trop faible par rapport à la résolution affichée après traitement...

Code:

self.pixmap = QPixmap.fromImage(self.im0.scaled(800, 600, Qt.KeepAspectRatio, Qt.SmoothTransformation))

Tu as quelques étapes en trop.

Je te montre avec la troisième transformation:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
    def test3(self):
        buffer1 = QBuffer()
        buffer1.open(QIODevice.ReadWrite)
 
        self.c = self.c + 0.1
        self.image_originale = QImage(self.pixmap) # ! la pixmap est réduite en taille !
        self.image_originale.save(buffer1,"jpeg")
        b1 = BytesIO()
        b1.write(buffer1.data())
        b1.seek(0)
        self.image_originale2 = Image.open(b1)
        self.modification = ImageEnhance.Contrast(self.image_originale2)
        md = self.modification.enhance(self.c)
        self.imageq = ImageQt(md)
        self.scene.clear()
        print(self.imageq.size()) # confirmation !
        self.pixmap = QPixmap.fromImage(self.imageq.scaled(800, 600, 
                                        Qt.KeepAspectRatio, 
                                        Qt.SmoothTransformation))
        self.scene.setSceneRect(0, 0, self.pixmap.width(), self.pixmap.height())
        self.scene.addPixmap(self.pixmap)
        buffer1.close()

L'image apparaît dégradée mais c'est un effet de redimensionnement.

Comme je l'ai mis en commentaire, tu utilises la pixmap créée au départ mais celle-ci est réduite à 300x200 dans la méthode charger() ensuite après filtrage, elle est agrandie à 800x600.

Pareil avec test1()

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
    def test1(self):
        tstart=time.time()
        self.image_originale = Image.open('Images/people/_DSC0050_1.TIFF')
        self.modif = ImageEnhance.Sharpness(self.image_originale)
        md = self.modif.enhance(self.c)
        print(time.time()-tstart)
        self.qimage = ImageQt(md)
        self.scene.clear()
        self.pixmap = QPixmap.fromImage(self.qimage.scaled(800, 600, 
                                        Qt.KeepAspectRatio, 
                                        Qt.SmoothTransformation))
        self.scene.setSceneRect(0, 0, self.pixmap.width(), self.pixmap.height())
        print(time.time()-tstart)
        self.scene.addPixmap(self.pixmap)

avec une image de 4310x2868 (50 Mo) le sharpness prend entre 2.6 et 2.8 secondes ce qui me parait normal.

Ah oui, supprime tous les self.view.setSceneRect(0, 0, x, y) inutiles.

13/12/2015, 12h43
Invité

super,
merci pour la simplification du code!