Gomme et QImage

Version imprimable

Voir 40 message(s) de cette discussion en une page

20/06/2012, 11h52
ashren

C'est plus une question de goûts, personnellement je découpe quasiment toutes mes classes dans des fichiers séparés organisés dans des modules de manière logique (ex: gui.layout). C'est plus une habitude qu'autre chose.
20/06/2012, 12h17
electrolover49

D'accord, je pense aussi que cela est mieux donc je vais essayer de tendre vers cela.
Actuellement, j'ai réussi à avoir ma gomme qui efface correctement les choses malheureusement, je ne peux pas récupérer la couleur que j'initialise dans le main .
Je vais essayer de trouver une solution peut - être aurais -je encore besoin de ta précieuse aide.
Bonne journée.^
Edit : J'ai résolu mon problème finalement maintenant je vais gérer la taille de ma gomme aussi tout seul si je peux.

Problème ouverture

J'ai suivi ton conseil, je refais l'architecture de mon programme dans ce but j'ai séparer la vue, la scène et la mainWindow du Main.
Malheureusement, j'ai un problème, je ne peux plus ouvrir mon Image :s

Main.py

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# -*- coding: utf-8 -*-
 
#from ImageView.ImageView import ImageView
from PySide.QtGui import QApplication
from MainWindow.MainWindow import MainWindow
import sys
 
"""
Class calling just the main window and showing it
"""
def main(args):
    app = QApplication(args)
    mainWindow = MainWindow()
    mainWindow.resize(600,400)
    mainWindow.show()
 
    sys.exit(app.exec_()) # Qt Main loop
 
 
if __name__ == "__main__":
    main(sys.argv)

MainWindow.py

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
205
206
207
from PySide.QtCore import QSize, QRect, QRectF, Qt,QFile
from PySide.QtGui import QApplication, QWidget, QPainter, QKeySequence, QColor, \
    QCheckBox, QStatusBar, QIcon, QMessageBox, QImage, QRubberBand, QMainWindow, \
    QAction, QMenuBar, QFileDialog, QScrollArea, QColorDialog, QPalette, QBrush, \
    QPixmap, QGraphicsScene, QGraphicsView, QGraphicsPixmapItem, QPushButton
# We call the class graphicsScene and we import it
from Scene.GraphicsScene import GraphicsScene
from View.GraphicsView import GraphicsView
class MainWindow(QMainWindow):
    def __init__(self, *args):
        QMainWindow.__init__(self, *args)
        self.setWindowTitle("Freehand Line Test")
 
        self._fileName="-1"
 
 
        self.image = QImage()
 
 
        #Init of the Menu with the menubar and the icon
        self._createMenu()
        #Init of the toolbar with all tools rubber etc..
        self._createToolBar()
        #Init of the status bar (at bottom) with ckbox and colorPicker
        self._createStatusBar()
 
 
    def _createMenu(self):
        """
        Adding of actions for the tool bar
        """
        self.iconToolBar = self.addToolBar("iconBar")
 
        """
            Add of the Menu which contains all the features like of Open/Save/..
            and the edit options
        """
        menu = QMenuBar()
        self.setMenuBar(menu)
        _file = menu.addMenu('File')
        _edit = menu.addMenu("Edit")
        # Menu Open
        _action = QAction('Open', _file, shortcut=QKeySequence.Open)
        _action.triggered.connect(self.__actionOpen)
        _file.addAction(_action)
    def _createToolBar(self):
 
        #Adding of actions for the tool bar
 
        self.iconToolBar = self.addToolBar("iconBar")
 
        #About 
        _actionAbout = QAction(self)
        _actionAbout.triggered.connect(self.__actionAbout)
 
        _actionAbout.setIcon(QIcon("Pics\info-icon.jpg"))
        _actionAbout.setStatusTip("Pop up the About dialog.")
        self.iconToolBar.addAction(_actionAbout)
        #Rubber
        _actionRubber = QAction(self)
        _actionRubber.triggered.connect(self.__actionRubber)
        _actionRubber.setIcon(QIcon("Pics\eraser2.png"))
        _actionRubber.setStatusTip("Enable or Disable eraser tool")
        self.iconToolBar.addAction(_actionRubber)
 
 
        #ColorPicker
        _actionColorPicker = QAction(self)
        _actionColorPicker.triggered.connect(self.__actionColorPicker)
        _actionColorPicker.setIcon(QIcon("Pics\Palette2.png"))
        _actionColorPicker.setStatusTip("Chosen color")
        self.iconToolBar.addAction(_actionColorPicker)
    def _createStatusBar(self):
        #Check Box rub
        statusbar = QStatusBar(self)
        self.setStatusBar(statusbar)
 
        self._ckbox = QCheckBox("Rubber On/Off")
        statusbar.addWidget(self._ckbox)
        if self._ckbox.isChecked():
            self._mode = "rub"
        else :
            self._mode = "select"
        #Init of the boolean to know whether we select or rub
        self.image.mode = self._mode
        self._ckbox.stateChanged.connect(self.__rubberBoxChanged)
 
        #ColorPicker
 
        self._buttonColorPicker = QPushButton()
        self.__setColor(QColor(255,255,255))
        self._buttonColorPicker.clicked.connect(self.__actionColorPicker)
        self._buttonColorPicker.setText("Color Picker")
        self._buttonColorPicker.setToolTip("Choose your color")
        #Bottom left
        #statusbar.addWidget(self._buttonColorPicker)
        #Bottom right
        statusbar.addPermanentWidget(self._buttonColorPicker)
    def getFileName(self):
        return self._fileName
    def setFileName(self,fileName):
        self._fileName = fileName
    def __actionOpen(self):
        self.__fileName = QFileDialog.getOpenFileName(self, "Open Image", "", "Image Files (*.png *.jpg *.bmp)")
        #self.setFileName(self._fileName)
        if self.__fileName:
                self.setFileName(self.__fileName[0])
                self.scene = GraphicsScene(self.getFileName())
                self.image = self.scene.img
                self.view = GraphicsView(self.scene)
                self.setCentralWidget(self.view)
                #self.image.setWorkingImage(QImage(self._fileName[0]))
        else:
            print "Invalid Image"
            QMessageBox.about(self, "Opening State",
        """ <p>Opening this image failed </p>
        <p> Check your extension and make sure it is .bmp </p>""")
 
    def __actionSave(self):
        if self._fileName == "-1" :
                self.__actionSaveAs()
        else :
 
            _result = self.image.workingImage().save(self. _fileName[0], "BMP", -1) 
 
            # Test to know if it's working
            if _result:
                print "Saved successfully"
                QMessageBox.information(self, "Saving State",
            """<p> Saved with success </p>""" )
            else :
                print "Saving failed"
 
 
    def __actionSaveAs(self):
        self._fileName = QFileDialog.getSaveFileName(parent=None, caption="Save image as")
        """
        Must check if the .bmp is well written if not message box to show an error
        """
        _result = self.image.workingImage().save(self._fileName[0], "BMP", -1)
        # Test to know if it's working
        if _result:
            print "Saved successfully"
            QMessageBox.about(self, "Saving State",
        """<p> Saved with success </p>""" )
        else :
            print "Saving failed"
            QMessageBox.about(self, "Saving State",
        """ <p>Saving this image failed </p>
        <p> Check your extension and make sure it is .bmp </p>""" )
    def getFileName(self):
        return self._fileName
    def setFileName(self,newFileName):
        self._fileName = newFileName
 
    def __actionClose(self):
        self.close()
    def __actionRubber(self):
 
        if self._ckbox.isChecked():
            print"uncheck"
            self._ckbox.setChecked(False)
        else :
            print "Set check"
            self._ckbox.setChecked(self._ckbox.isCheckable())
 
    def __actionAbout(self):
        '''Popup a box with about message.'''
        QMessageBox.about(self, "About PySide, Platform and the like",
        """<b> About this program </b> 
                <p>Copyright  2012 Maugin Guillaume. 
                All rights reserved in accordance with
                GPL v2 or later 
                <p>This application can be used for
                displaying OS and platform details.
                <p>Python %s - PySide version %s - Qt version %s on %s""" )
    def __actionColorPicker(self):
        dlg = QColorDialog(self)
        if dlg.exec_():
            self.__setColor(dlg.selectedColor())
            #self.image.setPenColor(dlg.selectedColor())
    def __setColor(self, color):
        _img = QPixmap(16, 16)
        _p = QPainter(_img)
        _p.fillRect(_img.rect(), QBrush(color))
        #self.image.setPenColor(color)
        _p.end()
        self._buttonColorPicker.setIcon(QIcon(_img))
    def getPaletteColor(self):
        return self._color
    def setPaletteColor(self,colour):
        self._color=colour
        self.update()
    #Init of the property for mode
    color = property(getPaletteColor, setPaletteColor)
 
    def __rubberBoxChanged(self, state):
        if self._ckbox.isChecked():
            self._mode = 'rub'
        else:
            self._mode = 'select'
        self.image.mode = self._mode
    def _initStyleFile(self):
        styleFile = QFile("CSS\style.qss")
        styleFile.open(QFile().ReadOnly)
        styleSheet = unicode(styleFile.readAll())
        return styleSheet

GraphicsScene.py
Je passe à la scène le nom du fichier à metttre dans l'image et rien ne s'affiche

Code:

1
2
3
4
5
6
7
8
9
 from PySide.QtGui import QGraphicsScene, QImage, QPixmap
 
class GraphicsScene(QGraphicsScene):
    def __init__(self,fileName, parent=None ):
        super(GraphicsScene, self).__init__(parent=parent)
        print "Filename", fileName
        self.img = QImage(fileName)
        self.addPixmap(QPixmap.fromImage(self.img))
        self.setSceneRect(self.img.rect())

GraphicsView.py

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
 from PySide.QtGui import QGraphicsView,QPainter
from PySide.QtCore import Qt
from Tools.freehand import FreehandTool
 
class GraphicsView(QGraphicsView):
    def __init__(self, scene, parent=None):
        super(GraphicsView, self).__init__(scene, parent=parent)
 
        assert self.dragMode() is QGraphicsView.NoDrag
        self.setRenderHint(QPainter.Antialiasing)
        self.setRenderHint(QPainter.TextAntialiasing)
        self.setMouseTracking(True);  # Enable mouseMoveEvent without clicking__init__
        self.freehandTool = FreehandTool(self.scene(), self)
        # not working because don't cal the segString where the color is def
        #self.freehandTool.setSegmentColor(colour)
 
 
    """ 
    Delegate events to FreehandTool. 
    """
    def mouseMoveEvent(self, event):
        # print "GV mouse moved"
        self.freehandTool.pointerMoveEvent(event)
 
    def mousePressEvent(self, event):
        # print "GV mouse pressed"
        self.freehandTool.pointerPressEvent(event)
        self.freehandTool.path.penStyle.setWidth(20)
        self.freehandTool.path.penStyle.setColor(Qt.red)
    def mouseReleaseEvent(self, event):
        self.freehandTool.pointerReleaseEvent(event)

20/06/2012, 16h41
ashren

J'ai testé en mettant tout dans un seul fichier et ça marche, essaye donc de séparer élément par élément en testant entre chaque modification.

Sinon tu regardes les messages d'exceptions dans la console ou non ? (s'il y en a).

Quand tu fait une grosse modification, penses à tester de temps en temps et pas tout faire d'un coup, puis si un élément bien spécifique te pose problème et que la documentation et google ne t'aident pas, demandes.

Débugger fait partie de la programmation, et c'est la même méthode peu importe le langage. Tu fait de l'orienté objet depuis combien de temps ? (je suis juste curieux).
20/06/2012, 17h15
electrolover49

Depuis peu de temps, j'en fais 1 ans sérieusement avant j'ai juste fais quelques cours.

Et en plus, je débute vraiment sur Python et Qt genre depuis 2 semaines lol.
Je suis si nul lol ?
Edit :
J'ai fais exactement ce que tu as dis je viens de tester dans un fichier pareil, c'est vrai cela marche, c'est étrange, je vais réessayer dans l'autre.
20/06/2012, 18h26
ashren

Pas nul, mais je pense que tu n'as peut-être pas tous les réflexes de programmation. Avant de faire des projets conséquents, il faut maîtriser la méthodologie (pas forcément le langage) car se jeter dans du code en ayant 1 an d'expérience (autodidacte je présume ?) c'est un peu comme se jeter contre un mûr la tête la première et sans casque.

Je te conseillerai de regarder d'abord des cours sur Python (developpez.net possède une section) puis de faire quelques tests pour te faire la main.

Pour debug, ma méthode (en python et d'autres):
- analyser le problème pour savoir d'où ça peut venir
- tester en commentant des bouts de code qui pourraient être mauvais
- si ce n'est pas ça, retour à la première étape, sinon
- analyser le code incriminé
- commenter les parties de code que l'on juge être responsables, tester, recommencer l'analyse jusqu'à conclusion.

Tu peux aussi utiliser un debugger si ton environnement de développement est adapté (le mien ne l'est pas).
20/06/2012, 21h15
electrolover49

Je ne suis pas vraiment autoditacte, je suis en école d'électronique et informatique donc je programme réellement depuis 4 ans mais de l'objet (Java,J2EE) depuis un an on va dire.

J'ai déjà réalisé quelques projets déjà donc je connais la méthodologie seulement je ne connais pas le langage et cela me pose quelques soucis mais j'ai déjà fais des tutos sur Python depuis 3 semaines.

EDIT :
Mon environnement est fonctionnel, j'ai eclipse avec PyDev.
De plus, j'ai testé tes méthodes malgré tout, j'ai pas encore trouvé mon erreur, je vais continuer à chercher.
20/06/2012, 22h06
ashren

1 pièce(s) jointe(s)

J'ai copié-collé tes bouts de code dans les bons fichiers, lancé, et ... ça fonctionne ...

Quand tu créés tes modules, tu créés bien un fichier '__init__.py' vide dedans ?

PS: joint au post un rar avec les fichiers
20/06/2012, 22h24
electrolover49

Oui , cela se fait automatiquement par mon IDE lorsque je le lance.
En tout cas merci de ton aide, je vais continuer à professionnaliser ma démarche, cela n'est pas facile en étant seul mais c'est des personnes comme toi qui donne envie de persévérer .
20/06/2012, 23h09
electrolover49

Pourquoi cela fonctionne ^^?

J'avoue que ton fichier rar marche bien, c'est étonnant.
Es- tu magicien ? Sérieusement, je ne vois pas trop ce que tu as changé sauf les move ou tu as mis x devant. Merci de me dire ton secret .

Ps : sinon demain, je te dirais pourquoi je dois réaliser mon programme en 3 mois.
Bonne soirée.
20/06/2012, 23h19
ashren

Les x c'est pour empêcher que les fonctions soient appelées (j'avais la flemme de supprimer le code) et c'est uniquement parce-que je n'avais pas le code du free hand tool.

Sinon pour les 3 mois je suppose que c'est un projet d'été ou quelque chose dans le genre ?

PS: Je ne suis pas magicien, je programme juste depuis longtemps. Ce que je ferai c'est prendre ton code, le faire ressembler au mien, puis ré-implémenter ce que j'ai commenté/renommé jusqu'à ce que ça soit le code que tu as actuellement. Tu trouveras forcément ce qui cloche.
20/06/2012, 23h40
electrolover49

Oui , c'est un projet d'été pour mon école , un genre de paint mais surtout une gomme perfectionnée pour les images techniques pour enlever les annotations ou autres.
Je vais reprendre ce que tu m'as passé et ajouté le freehandtool pour tester.
EDIT :
J'ai compris mon erreur, je n'appelai pas bien le bon d'image, quelques images ont du mal à s'afficher mais je pense que cela est un problème d'extension donc cela n'est pas trop grave, je me concentre sur le .bmp.

1 pièce(s) jointe(s)

Fichiers du freehandTool

Tu trouveras ci-joint les fichiers du freehand pour comprendre comment je l'ai intégré.
Je ne l'ai pas développé (surement je le reprendrais de façon plus simple moi-même) mais étant libre, je peux l'utiliser sans problème.

De plus, si je suis si pressé, c'est parce que ce projet compte pour la moitié de ma note annuelle pour mon cursus donc tu comprendras que je veuille le réussir.
C'est pourquoi ton aide est si précieuse.
EDIT: avec la pj, c'est mieux. Dedans, tu as tout les fichiers pour le freehand et aussi une classe perso , "penStyle" qui permet de passer la couleur , la largeur et après le style de la gomme.
EDIT 2 :
J'ai réussi à externaliser la classe Pixmap comme je souhaitais pour découper réellement la vue, la scène et l'item.
Du coup, voici mes nouveaux fichiers scène et item.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 from PySide.QtGui import QGraphicsScene, QImage, QPixmap from Item.PixmapItem import PixmapItem class GraphicsScene(QGraphicsScene): def __init__(self,fileName,parent=None ): super(GraphicsScene, self).__init__(parent=parent) print "Filename", fileName self.img = QImage(fileName) #We give the image to have a pixItem in return self.pixItem = PixmapItem(self.img).getPixmapItem() self.addItem(self.pixItem) self.setSceneRect(self.img.rect())
Code:

1 2 3 4 5 6 7 8 9 10 from PySide.QtGui import QGraphicsPixmapItem,QPixmap class PixmapItem(QGraphicsPixmapItem): def __init__(self,image,parent=None ): self.pixItem = QGraphicsPixmapItem() self.pixMap = QPixmap.fromImage(image) self.pixItem.setPixmap(self.pixMap) def getPixmapItem(self): return self.pixItem

21/06/2012, 12h05
ashren

Pour changer la couleur de ton free hand, dans ta GraphicsView, ajoute une variable self.maCouleur = Qt.white dans le __init__, utilise là à la place du Qt.red dans le mousePressEvent, et dans ta MainWindow, si self.view est initialisée, dans __setColor change self.view.maCouleur par le paramètre color de __setColor.

Ça devrait le faire.

Très bien, je l'ai déjà fais en faite lol.
Et cela marche bien, j'arrive à changer la couleur.
J'ai du mal à sauvegarder dorénavant :s
EDIT :
En effet, j'ai plus le workingImage() du coup il ne sauvegarde plus les changements effectués par dans la vue donc je me demande si je dois sauvegarder l'image ou la vue ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
self._fileName = QFileDialog.getSaveFileName(parent=None, caption="Save image as")
        """
        Must check if the .bmp is well written if not message box to show an error
        """
     # ou self.view :s
        _result = self.image.save(self._fileName[0], "BMP", -1)
        # Test to know if it's working
        if _result:
            print "Saved successfully"
            QMessageBox.about(self, "Saving State",
        """<p> Saved with success </p>""" )
        else :
            print "Saving failed"
            QMessageBox.about(self, "Saving State",
        """ <p>Saving this image failed </p>
        <p> Check your extension and make sure it is .bmp </p>""" )

22/06/2012, 13h57
electrolover49

Question pour la sauvegarde.

Bonjour, je suis toujours bloqué sur la sauvegarde, je vois mal comment faire avec ma view car si je la sauvegarde, je perds le contenu dessiné dessus :s.
Pourrais - tu m'indiquer dans quelle direction aller ?

Je te remercie d'avance ^^.
22/06/2012, 20h00
ashren

Les changements sont dans la GraphicsScene ? Dans ce cas, QGraphicsScene possède une méthode render(...) qui te permettrait d'obtenir un résultat final.

Changement de conception

Euh , comment dire ... , maintenant je réalise les événements dans l'item GraphicsPixmapItem, je ne sais pas si cela est bien.
C'est la seule façon qui marchait donc du coup j'ai changé mon freehandTool et je l'ai simplifié.
Donc je ne sais pas si je peux toujours sauvegarder cet item comme tu as dis ;s ?
Donc voilà à quoi ressemble mon PixmapItem.py

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
from PySide.QtGui import QGraphicsPixmapItem,QGraphicsScene, QImage, QPixmap, QBrush, QPen,\
                         QPainter,QColor,QRubberBand
from PySide.QtCore import QSize, QRect,QRectF,Qt
 
'''
 PixmapItem handles :
     + Mouses events
     + Drawing of shapes
'''
class PixmapItem(QGraphicsPixmapItem):
    def __init__(self,scene,pixmap=None,parent=None ):
        super(PixmapItem,self).__init__()
 
        # We make the scene of proper attribute of the class
        self.scene = scene
 
        self.x, self.y = -1, -1        
        '''
        Init of the mode
        FIXME:
        Get/set for the different mode :
                    + select , allows you to select the area to delete
                    + rub , allows you to rub with the chosen color
                    + autorub, allows you to rub automatically the color selected from the pixel
                    + pipette , allows you to select the color you want to
        
        '''
        #By default , we presume selection
        self.mode = 'select'
        '''
        #Init of the color,width
        FIXME:
        maybe need of the style of the pen, .. 
        '''
        self.pen = QPen(Qt.SolidLine)
        self.brush = QBrush()
        self.color = QColor()
        self.width = 1
 
         #Init of selection 
        self.__band = QRubberBand(QRubberBand.Rectangle,None)
        self.__origin = None
 
    def getColor(self):
        return self.color
    def setColor(self,_color):
        self.color = _color
        self.update()
    def getWidth(self):
        return self.width
    def setWidth(self,_witdh):
        self.width = _witdh
        self.update()
    def getMode(self):
        return self.mode
    def setMode(self,_mode):
        self.mode = _mode
        self.update()
 
    def paint(self, painter, option, widget=None):               
        painter.drawPixmap(0, 0, self.pixmap())
        self.pen.setColor(self.getColor())
        self.pen.setWidth(self.getWidth())                
        painter.setPen(self.pen)
        painter.setBrush(self.brush)
        if self.getMode()== 'rub':        
            if self.x >= 0 and self.y >= 0:
                painter.drawEllipse(self.x-self.width, self.y-self.width, 2*self.width, 2*self.width)
 
    def paintEvent(self,event):
        '''
        FIXME:
           + have an shape button to choose if you want an ellipse or a rectangle 
        '''
        self.x=event.pos().x()
        self.y=event.pos().y()
        if self.getMode()== 'rub':        
            if self.x >= 0 and self.y >= 0:
                self.scene.addEllipse(self.x-self.width, self.y-self.width, 2*self.width, 2*self.width,self.getColor(),self.getColor())       
    def mousePressEvent (self, event):
        self.__origin = event.pos()
        if self.getMode() =="select":
            #__ private variable 
            self.__band.setGeometry(QRect(self.__origin, QSize()))
            self.__band.show()
 
        self.x=event.pos().x()
        self.y=event.pos().y() 
        '''
        FIXME :
        Have an option to see when you click on it or not the size of the rub  
        '''
        #self.paintEvent(event)         
        self.update()
 
    def mouseMoveEvent (self, event):
        #self.__band.setGeometry(QRect(self.__origin, event.pos()).normalized())
        self.x=event.pos().x()
        self.y=event.pos().y()     
        self.paintEvent(event)       
        self.update()        
    def mouseReleaseEvent(self, event):
        self.__band.hide()
        if self.getMode()=="select":
            print "Selected Zone : ", QRect.intersect(self.__band.geometry(), QRect())
        self.x=0
        self.y=0
        self.update()

22/06/2012, 21h52
ashren

De ce que j'ai compris du fonctionnement de QGraphicsScene, c'est elle qui contient les QGraphicsItem non ? De toute manière un simple test isolé devrait dissoudre toute confusion:

résultat -> ça fonctionne.

-Créé une QImage des dimensions de ta scene
-Créé un QPainter sur cette image
-Invoque la méthode render de ta scene en spécifiant le painter
-Invoque save de la QImage
22/06/2012, 22h04
electrolover49

Oui, c'est cela. De ce que j'ai compris aussi, les Items sont contenus dans la scène.
Je vais tester ce que tu me dis, je reviendrais si nécessaire, merci.
Bon week end.
PS : Merci pour tes conseils, j'ai réussi facilement du coup, je vais essayer d'améliorer la sauvegarde mais ça devrait marcher pareil.
23/06/2012, 16h25
electrolover49

Implémentation d'un Undo

J'aimerais avoir un Undo maintenant donc je me demandes un peu comment faire.
Je me disais que je devrais "sauvegarder" ou mettre dans un tableau, les images précédentes et les recharger à chaque fois.

J'aimerais avoir la solution optimale enfin si jamais tu as une idée qui pourrait m'aider, n'hésite pas ^^.
24/06/2012, 12h01
ashren

Je dirai bien de regarder du côté de QUndoStack http://qt-project.org/doc/qt-4.8/qundostack.html, par contre je n'ai jamais utilisé cette classe donc aucune idée de sa pertinence pour ton utilisation.
24/06/2012, 19h35
electrolover49

Très bien, après y avoir jeter un oeil (après il faut que j'essaye vraiment),
je suis pas certains que cela soit la meilleure solution enfin sinon je pensais plutôt faire un tableau d'item.
Et à chaque fois enregistré la pixItem précédente avant de faire des changements.
25/06/2012, 00h05
ashren

Si tu veux mais à ce moment là impose une limite sur le nombre de undo/redo car sinon tu va vite consommer de la mémoire.
25/06/2012, 12h14
electrolover49

Bien sur, je ferais une taille limite pour limiter la mémoire .
EDIT : 3H dessus, je vais peut-être avoir besoin d'aide, j'ai pas trouvé d'exemple en Python donc c'est un peu dur de passer du C++ au python pour moi :s
25/06/2012, 13h59
ashren

Ben avec un tableau, à chaque fois que tu fais une opération avec un QPainter, tu ajoute le pixmap actuel. Après si tu as d'autres actions (comme des ajouts de QGraphicsItem) c'est plus compliqué et le QUndoStack serait une solution plus aisée (attention c'est tout de même complexe en termes de logique).
25/06/2012, 14h18
electrolover49

Citation:

Envoyé par ashren

Ben avec un tableau, à chaque fois que tu fais une opération avec un QPainter, tu ajoute le pixmap actuel. Après si tu as d'autres actions (comme des ajouts de QGraphicsItem) c'est plus compliqué et le QUndoStack serait une solution plus aisée (attention c'est tout de même complexe en termes de logique).

J'ajoute des formes à chaque fois, c'est vrai donc normalement cela devrait marcher sauf que j'ajoute mais forme à la QGraphicsPixmapItem donc je devrais peu-être utilisé le Undostack.
Merci de dire que logiquement c'est assez complexe, je m'en suis rendu compte lol.

Framework ou non ?

En faite, après plusieurs essais , je me rends compte que c'est vraiment assez complexe :s le framework.

Le problème majeur est que si je veux implémenter le framework correctement je vais surement devoir changer comment j'ajoute mes formes à ma scène.
cf.
Code:

1 2 3 4 5 void MainWindow::addBox() { QUndoCommand *addCommand = new AddCommand(DiagramItem::Box, diagramScene); undoStack->push(addCommand); }
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 AddCommand::AddCommand(DiagramItem::DiagramType addType, QGraphicsScene *scene, QUndoCommand *parent) : QUndoCommand(parent) { static int itemCount = 0; myGraphicsScene = scene; myDiagramItem = new DiagramItem(addType); initialPosition = QPointF((itemCount * 15) % int(scene->width()), (itemCount * 15) % int(scene->height())); scene->update(); ++itemCount; setText(QObject::tr("Add %1") .arg(createCommandString(myDiagramItem, initialPosition))); }
Dans cet exemple,il ajoute une item comme moi j'ajoute une ellipse ou un rect mais si je fais ça je perds la couleur et je dois changer l'appel de la fonction alors qu'en penses -tu ? :s

26/06/2012, 15h14
ashren

Tu pourrais avoir des commandes pour 'set' la couleur en plus des commandes pour ajouter des éléments. Tu pourrais même avoir des commandes d'ajout directement avec un paramètre couleur qui combinerai les deux.

Désolé, je peux pas trop regarder ça en ce moment (boulot).
26/06/2012, 15h33
electrolover49

J'ai réussi le problème maintenant est que j'ai plus la couleur de la gomme que je veux alors comment dois - je faire pour changer la couleur de mon item ?
peut - être avec path non ?
EDIT:
RESOLU, finalement lol.
Tu dois m'inspirer car j'ai trouvé facilement, on peut faire setpen sur un item donc j'ai ma couleur c'est bon ^^.

Merci d'avance.

Problème pipette

En faite, avant de modifier mon architecture du layout, j'ai voulu essayer la pipette pensant que c'était simple en effet, j'y arrive facilement malgré tout le comportement résultant n'est pas celui souhaité.

En effet, je voudrais cliquer sur la pipette puis sur l'image et avoir la couleur alors que là je clique sur la pipette (activée à ce moment) puis je clique sur l'image et je dois recliquer une deuxieme fois pour avoir la couleur :s.
Je ne vois pas trop comment automatiser l'action et que cela soit comme sur Paint.
I.e tu clique une fois sur pipette et quand tu clique sur l'image la couleur s'affiche :s

EDIT:
j'ai avancé sur l'architecture de mon application qui semble plutôt stable, j'ai découpé mes outils en tool et je sélectionne à chaque fois le currentTool le problème est que je ne vois toujours pas mal comment instancier la couleur de mon icone à chaque clique :s.
MainWindow.py L.420 pour action pipette

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
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
from PySide.QtCore import QSize, QRect, QRectF, Qt, QFile
from PySide.QtGui import QApplication, QWidget, QPainter, QKeySequence, QColor, \
    QCheckBox, QStatusBar, QIcon, QMessageBox, QImage, QRubberBand, QMainWindow, \
    QAction, QMenuBar, QFileDialog, QScrollArea, QColorDialog, QPalette, QBrush, \
    QPixmap, QGraphicsScene, QGraphicsView, QGraphicsPixmapItem, QPushButton,\
    QSlider,QDockWidget,QListWidget, QUndoStack,QUndoView
from Scene.GraphicsScene import GraphicsScene
from View.GraphicsView import GraphicsView
from Tools.AddCommand import AddCommand
from Tools.ColorPickerTool import ColorPickerTool
# We call the class graphicsScene and we import it
class MainWindow(QMainWindow):
    def __init__(self, *args):
        QMainWindow.__init__(self, *args)
        self.setWindowTitle("Rub on your Image")
 
 
        self._fileName="-1"
        self.sliderValue = 0
        '''
        Declarations of the bool to block an action 
        when another is selected
        FIXME:
        Change the layout system suppress the tool bar maybe ..
        add square, circle ...
        maybe do the trick with the rubber box to change the value.
        '''
        #Init rubberBool so rub is disabled by def 
        self.rubberBool = True
        #Init selectBool to true so by def it's enabled
        self.selectBool = False
        #we suppose select by def but can it be rub to test
        self._mode = 'select'
 
        '''
        TODO:
        Use of undofmwork
       
        '''
 
 
        """ remove that => """
 
 
        self.setFileName("C:\Users\Guillaume\Qt\workspaceQt\EraserV2\Pics\mol1.bmp")
        self.scene = GraphicsScene(self.getFileName())
        #Init of the value of the width so that you will see the rub !!! 
        self.scene.setWidth(1)
        self.image = self.scene.img
        self.view = GraphicsView(self.scene)
 
        self.setCentralWidget(self.view)
 
 
        """
        and place it in open
        """
        self._color = QColor()
        #self.image = QImage()
 
 
        #Init of the Menu with the menubar and the icon
        self._createMenu()
        #Init of the toolbar with all tools rubber etc..
        self._createToolBar()
        #Init of the dockWidget
        self._createDockWidget()
        #Init of the status bar (at bottom) with ckbox and colorPicker
        self._createStatusBar()
 
 
    def _createMenu(self):
        """
        Adding of actions for the tool bar
        """
        self.iconToolBar = self.addToolBar("iconBar")
 
        """
            Add of the Menu which contains all the features like of Open/Save/..
            and the edit options
        """
        menu = QMenuBar()
        self.setMenuBar(menu)
        # File menu
        _file = menu.addMenu('File')
        # Menu Open
        _action = QAction('Open', _file, shortcut=QKeySequence.Open)
        _action.triggered.connect(self.__actionOpen)
        _file.addAction(_action)
        # Menu Save 
        _action = QAction('Save ', _file,shortcut=QKeySequence.Save)
        _action.triggered.connect(self.__actionSave)
        _file.addAction(_action)
        # Menu Save As
        _action = QAction('Save image As', _file,shortcut=QKeySequence(Qt.CTRL+Qt.SHIFT+Qt.Key_S))
        _action.triggered.connect(self.__actionSaveAs)
        _file.addAction(_action)
        # Menu Close
        _action = QAction('Close', _file,shortcut=QKeySequence.Close)
        _action.triggered.connect(self.__actionClose)
        _file.addAction(_action)
 
        #Edit menu
        _edit = menu.addMenu("Edit")
 
        '''
        FIXME:
        another try we ve an another stack
          _action = QAction('Undo',_edit,shortcut=QKeySequence.Undo)
        _action.triggered.connect(self.__actionUndo)
        _edit.addAction(_action
        def __actionUndo(self):
        self.scene.removePixItem()
                
        =======
        undo Fmwk
       '''
        undoAction = self.scene.pixItem.undoStack.createUndoAction(self,'Undo')
        undoAction.setShortcuts(QKeySequence.Undo)
        _edit.addAction(undoAction)
 
        redoAction = self.scene.pixItem.undoStack.createRedoAction(self,'Redo')
        redoAction.setShortcuts(QKeySequence.Redo)
        _edit.addAction(redoAction) 
    def _createToolBar(self):
 
        #Adding of actions for the tool bar
 
        self.iconToolBar = self.addToolBar("iconBar")
 
        #About 
        _actionAbout = QAction(self)
        _actionAbout.triggered.connect(self.__actionAbout)
 
        _actionAbout.setIcon(QIcon("Pics\info-icon.jpg"))
        _actionAbout.setStatusTip("Pop up the About dialog.")
 
 
        self.iconToolBar.addAction(_actionAbout)
        #Rubber
        self._actionRubber = QAction(self)
        self._actionRubber.triggered.connect(self.__actionRubber)
        self._actionRubber.setIcon(QIcon("Pics\eraser2.png"))
        # on/ off by statusTip maybe or with the icon ...
        ''''
        FIXME:
        Add the rectangle rubber with the icon ... and a variable to disabled 
        circle when you have the rect ..
        '''
        self._actionRubber.setStatusTip("Enable or Disable eraser tool")
        self._actionRubber.setText("Rubber Tool")
        self.iconToolBar.addAction(self._actionRubber)
 
        #Select
        _actionSelect = QAction(self)
        _actionSelect.triggered.connect(self.__actionSelect)
        _actionSelect.setIcon(QIcon("Pics\selectTool.png"))
        # on/ off by statusTip maybe or with the icon ...
        ''''
        FIXME:
        Add the rectangle Select with the icon ... and a variable to disabled 
        circle when you have the rect ..
        '''
        _actionSelect.setStatusTip("Enable Select Tool")
        _actionSelect.setText("SelectTool")
        _actionSelect.setEnabled(True)
        self.iconToolBar.addAction(_actionSelect)
 
 
        #ColorPicker
        _actionColorPicker = QAction(self)
        _actionColorPicker.triggered.connect(self.__actionColorPicker)
        _actionColorPicker.setIcon(QIcon("Pics\Palette2.png"))
        _actionColorPicker.setStatusTip("Chosen color")
        self.iconToolBar.addAction(_actionColorPicker)
 
        #Circle rubber 
        self._actionCircleRub = QAction(self)
        self._actionCircleRub.triggered.connect(self.__actionCircleRub)
        self._actionCircleRub.setIcon(QIcon("Pics\circle.jpg"))
        self._actionCircleRub.setStatusTip("Circle rub")
        self.iconToolBar.addAction(self._actionCircleRub)
 
 
        #Rectangle
 
 
        self._actionRectRub = QAction(self)
        #_img = QPixmap(16, 16)
        # to have the size of the rubber
        _img = QPixmap(16,16)
        _p = QPainter(_img)
        _p.fillRect(_img.rect(), QBrush(Qt.black))
        _p.end()
        self._actionRectRub.setIcon(QIcon(_img))
        self._actionRectRub.triggered.connect(self.__actionRectRub)
        self._actionRectRub.setStatusTip("Rect rubber")
        self.iconToolBar.addAction(self._actionRectRub)
        #Pipette
        '''
        Au lieu de cliquer a chaque fois pour avoir la couleur, utilise le truc
        de la check box pour garder l a pipette
        et peut etre passer la couleur a la palette ...
        '''
        self._actionPipette = QAction(self)
        self._actionPipette.triggered.connect(self.__actionPipette)
        self._actionPipette.setText('Pipette')
        self._actionPipette.setToolTip("Pipette, click to choose your color")
        self.iconToolBar.addAction(self._actionPipette)
 
 
    def _createDockWidget(self):
        #self.dockWidget = QDockWidget()
        print "Dock widgt"
        #self.addDockWidget()
#        dock =QDockWidget(self.tr("Customers"), self)
#        dock.setAllowedAreas(Qt.TopDockWidgetArea | Qt.BottomDockWidgetArea)
#        self.customerList =QListWidget(dock)
#        self.customerList.addItems((
#             "E"
#             ))
#        dock.setWidget(self.customerList)
        #self.addDockWidget(Qt.TopDockWidgetArea, dock)
    def _createStatusBar(self):
        #Check Box rub
        statusbar = QStatusBar(self)
        self.setStatusBar(statusbar)
 
        self._ckbox = QCheckBox("Rubber On/Off")
        statusbar.addWidget(self._ckbox)
        #Trick so that we can change mode of select or rub
        self._ckbox.setVisible(False)
        self._ckbox.stateChanged.connect(self.__rubberBoxChanged)
 
        self._pkbox = QCheckBox("Pippette On/Off")
        statusbar.addWidget(self._pkbox)
        self._pkbox.stateChanged.connect(self.__pipetteBoxChanged)
        #Pipette
        self._buttonPipette = QPushButton(self)
        self._buttonPipette.clicked.connect(self.__actionPipette)
        self._buttonPipette.setText('Pipette')
        self._buttonPipette.setToolTip("Pipette, click to choose your color")
        statusbar.addWidget(self._buttonPipette)
 
 
        #ColorPicker
 
        self._buttonColorPicker = QPushButton()
        self.__setPaletteColor(QColor(Qt.black))
        self._buttonColorPicker.clicked.connect(self.__actionColorPicker)
        self._buttonColorPicker.setText("Color Picker")
        self._buttonColorPicker.setToolTip("Choose your color")
        # hide the border of the button
        self._buttonColorPicker.setFlat(True)
 
        # Make the button selected or not (appuyer ou non genre Paint)
        #self._buttonColorPicker.setDown(True)
 
        #Bottom left
        #statusbar.addWidget(self._buttonColorPicker)
        #Bottom right
        statusbar.addPermanentWidget(self._buttonColorPicker)
 
        #Slider to choose the stroke 
 
        self.slider =QSlider(Qt.Horizontal , self)
        self.slider.setRange(1, 30)
        self.slider.setValue(1)
        self.slider.setToolTip("Choose your stroke")
        #self.slider.connect()
        self.slider.valueChanged.connect(self.__sliderChanged)
        statusbar.addWidget(self.slider)
 
    def getFileName(self):
        return self._fileName
    def setFileName(self,fileName):
        self._fileName = fileName
    def __actionOpen(self):
        self.__fileName = QFileDialog.getOpenFileName(self, "Open Image", "", "Image Files (*.png *.jpg *.bmp)")
        #self.setFileName(self._fileName)
        if self.__fileName:
                '''
                self.setFileName(self.__fileName[0])
                self.scene = GraphicsScene(self.getFileName())
                self.view = GraphicsView(self.scene)
                self.setCentralWidget(self.view)
                '''
        else:
            print "Invalid Image"
            QMessageBox.about(self, "Opening State",
        """ <p>Opening this image failed </p>
        <p> Check your extension and make sure it is .bmp </p>""")
 
    def __actionSave(self):
        if self._fileName == "-1" :
                self.__actionSaveAs()
        else :
            _result = self.scene.saveImage()
 
            # Test to know if it's working
            if _result:
                print "Saved successfully"
                QMessageBox.information(self, "Saving State",
            """<p> Saved with success </p>""" )
            else :
                print "Saving failed"
 
 
    def __actionSaveAs(self):
        self._fileName = QFileDialog.getSaveFileName(parent=None, caption="Save image as")
        """
        Must check if the .bmp is well written if not message box to show an error
        """
        _result = self.scene.saveImageAs(self._fileName[0])
        # Test to know if it's working
        if _result:
            print "Saved successfully"
            QMessageBox.about(self, "Saving State",
        """<p> Saved with success </p>""" )
        else :
            print "Saving failed"
            QMessageBox.about(self, "Saving State",
        """ <p>Saving this image failed </p>
        <p> Check your extension and make sure it is .bmp </p>""" )
 
    def __actionClose(self):
        self.close()
    def __actionRubber(self):
        if self._ckbox.isChecked():
            print"uncheck"
            self._ckbox.setChecked(False)
            self._actionRectRub.setEnabled(False)
            self._actionCircleRub.setEnabled(False)
        else :
            print "Set check"
            self._ckbox.setChecked(self._ckbox.isCheckable())
            self._actionRectRub.setEnabled(True)
            self._actionCircleRub.setEnabled(True)
 
    def __actionSelect(self):
        print "mode action select : ",self._mode 
        if self._mode =='rub' or self._mode == '-1':
            self._mode = 'select'
            self.scene.setMode('select')
        if self._mode == 'select':
            print "mode action select if select ::"
            # Wait till' user press anothe button
            self._mode = ''
            self.selectBool = True
    def __actionAbout(self):
        '''Popup a box with about message.'''
        QMessageBox.about(self, "About PySide, Platform and the like",
        """<b> About this program </b> 
                <p>Copyright  2012 Maugin Guillaume. 
                All rights reserved in accordance with
                GPL v2 or later 
                <p>This application can be used for
                displaying OS and platform details.
                <p>Python %s - PySide version %s - Qt version %s on %s""" )
    def __actionColorPicker(self):
        dlg = QColorDialog(self)
        if dlg.exec_():
            self.__setPaletteColor(dlg.selectedColor())
            self.setPaletteColor(dlg.selectedColor())
        if self._mode =='pipette':
            print 'Action pipette in color picker'
            self.__setPaletteColor(QColor(self.scene.pixItem.getPipetteColor()))
    def __actionPipette(self):
        '''
        TODO:
         ne pas avoir besoin de cliquer pour afficher la couleur surement combiner avec 
         le color picker
         peut etre avoir un bouton pour la pipette puis avoir un affichage en bas
         Have an another class with tool (ColorPicker)
         inherits from QObject to connect directly (dir connec connect type) so
         that image can be changed every time
        '''
        if self._pkbox.isChecked():
            print"unchecking the pbox"
 
            self._pkbox.setChecked(False)
            self._actionRectRub.setEnabled(False)
            self._actionCircleRub.setEnabled(False)
        else :
            print "Set check"
            self._mode = 'pipette'
            self._pkbox.setChecked(self._pkbox.isCheckable())
            self._actionRectRub.setEnabled(True)
            self._actionCircleRub.setEnabled(True)
 
 
    def __actionCircleRub(self):
        if self._mode == 'rub':
            self.scene.setShape('circle')
    def __actionRectRub(self):
        print "action Rect rubs"
        print "mode :", self._mode
        if self._mode == 'rub':
            self.scene.setShape('rect')
 
    def __setPaletteColor(self, color):
        _img = QPixmap(16, 16)
        _p = QPainter(_img)
        _p.fillRect(_img.rect(), QBrush(color))
        _p.end()
        self._buttonColorPicker.setIcon(QIcon(_img))
 
    def __sliderChanged(self,val):
        self.scene.setWidth(val)
        self.setF
    def __rubberBoxChanged(self, state):
        print "mode rubberBoxChanged",self._mode 
        if self._ckbox.isChecked():
            self._mode = 'rub'
        else:
            self._mode = 'select'
            self._actionRubber.setEnabled(self.getRubberBool())
        # We give the view the mode in order to select the right tool to use
        self.scene.setMode(self._mode)
    def __pipetteBoxChanged(self,state):
        print "mode pippettebox chnged",self._mode
        if self._pkbox.isChecked()  :
            #& self.scene.pixItem.getMousePressBool()
            self._mode = 'pipette'
            self.scene.pixItem.setMode(self._mode)
            _img = QPixmap(16, 16)
            _p = QPainter(_img)
            '''
            FIXME:
            connect with a qobject to have the color instantly like PAint
            '''
            self.pipetteColor = QColor(self.scene.pixItem.getPipetteColor())
            #self.pipetteColor = ColorPickerTool.getPipetteColor(self.scene)
            _p.fillRect(_img.rect(), QBrush(self.pipetteColor))
            _p.end()
            self._buttonPipette.setIcon(QIcon(_img))
            self.__setPaletteColor(self.pipetteColor)
        else :
            self._mode = 'select'
    def getRubberBool(self):
        print "get rubBool",self.rubberBool
        return self.rubberBool
    def setRubberBool(self,_bool):
        self.rubberBool = _bool
 
    def getPaletteColor(self):
        return self._color
    def setPaletteColor(self,colour):
        self._color=colour
        self.scene.setColor(colour)
        self.update()
 
    def _initStyleFile(self):
        styleFile = QFile("QSS\style.qss")
        styleFile.open(QFile().ReadOnly)
        styleSheet = unicode(styleFile.readAll())
        return styleSheet

PixmapItem.py
si mouse press alors envoie la couleur du pixel sélectionné à colorPix

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
from PySide.QtCore import QSize, QRect, QRectF, Qt
from PySide.QtGui import QGraphicsPixmapItem, QGraphicsScene, QImage, QPixmap, \
    QBrush, QPen, QPainter, QColor, QRubberBand, QPainterPath, QGraphicsEllipseItem, \
    QUndoStack, QGraphicsRectItem, QLabel, QIcon
from Tools.AddCommand import AddCommand
from Tools.ColorPickerTool import ColorPickerTool
 
'''
 PixmapItem handles :
     + Mouses events
     + Drawing of shapes
'''
class PixmapItem(QGraphicsPixmapItem):
    def __init__(self,scene,pixmap=None,parent=None ):
        super(PixmapItem,self).__init__()
        self.scene = scene
        self.x, self.y = -1, -1        
 
        #trick for the pipette    
        self.pixMap = QPixmap()
        #trick to get to know whether or not mouse was pressed after the pkbox chnaged
        self.mousePressBool = False
        #get the color of the pix selected
        self.colorPix = QColor()
 
 
 
        '''
        Undostack has all the actions to undo/redo shapes
        '''
        self.undoStack = QUndoStack()
 
 
        '''
        Init of the mode
        TODO:
        Get/set for the different mode :
                    + select , allows you to select the area to delete
                    + autorub, allows you to rub automatically the color selected from the pixel
                    + pipette , allows you to select the color you want to
        
        '''
        #By default , we presume selection, here rub to test
        self.mode = 'rub'
        #Init of the color,width
        '''
        Init of the style of pen, rub size and shape 
        '''
        self.pen = QPen(Qt.SolidLine)
        self.brush = QBrush()
        self.color = QColor()
        self.width = 1
        self._shape  = 'circle'
        #Init of selection 
        self.__band = QRubberBand(QRubberBand.Rectangle,None)
        self.__origin = None
    def getColor(self):
        return self.color
    def setColor(self,_color):
        self.color = _color
        self.update()
    def getWidth(self):
        return self.width
    def setWidth(self,_witdh):
        self.width = _witdh
        self.update()
    def getMode(self):
        return self.mode
    def setMode(self,_mode):
        self.mode = _mode
        self.update()
    def getShape(self):
        return self._shape
    def setShape(self,_shape):
        self._shape = _shape
        self.update()
    def getPipetteColor(self):
        print "get pippete color"   
        #Trick : give it to the scene 
        return self.colorPix
    #bool to know whether or not presseE
    def getMousePressBool(self):
        return self.mousePressBool
    '''
    Paint used to have the pointer with the shape selected
    '''
    def paint(self, painter, option, widget=None): 
        # Pointer track              
        painter.drawPixmap(0, 0, self.pixmap())
        self.pen.setColor(self.getColor())
        self.pen.setWidth(self.getWidth())                
 
        if self.getMode()== 'rub':
            if self.getShape()=='circle':
                self.pen.setCapStyle(Qt.RoundCap)
                self.pen.setJoinStyle(Qt.RoundJoin)
                painter.setPen(self.pen)
                painter.setBrush(self.brush)
                self.update()     
                if self.x >= 0 and self.y >= 0:
                    '''
                    Witdh / 2 to have the pointer the same size of the shape 
                    not fill try path maybe ...
                    '''
                    painter.drawEllipse(self.x-self.width, self.y-self.width,
                                 self.width, self.width)
 
            if self.getShape()=='rect':
                self.pen.setCapStyle(Qt.SquareCap)
                self.pen.setJoinStyle(Qt.MiterJoin)
                painter.setPen(self.pen)
                painter.setBrush(self.brush)
                self.update()
                if self.x >= 0 and self.y >= 0:
                    painter.drawRect(self.x-self.width, self.y-self.width,
                                 self.width, self.width)
                    #painter.drawPath(path1),self.pen,self.brush)
    def paintEvent(self,event):
 
    #sPaintEvent where you add the shape to the scene 
 
        self.x=event.pos().x()
        self.y=event.pos().y()
        if self.getMode()== 'rub':
 
            if self.getShape() == 'circle' :
 
                if self.x >= 0 and self.y >= 0:
                    self.pen.setCapStyle(Qt.RoundCap)
                    self.pen.setJoinStyle(Qt.RoundJoin)
                    '''
                    Here we create an item to give to undostack
                    '''
                    ellipseItem = QGraphicsEllipseItem(QRectF(self.x-self.width, self.y-self.width, 
                                         self.width, self.width))
                    # give the item the color
                    ellipseItem.setBrush(self.brush)
                    ellipseItem.setPen(self.pen)
                    addCmd = AddCommand(ellipseItem, self.scene, self.getShape())
                    self.undoStack.push(addCmd)
 
            '''
            FIXME:
            print the square on the screen like the ellipse
            '''
 
            if self.getShape()=='rect':
                if self.x >=0 and self.y >= 0:
                    # init the style of the pen to match to the rect
                    self.pen.setCapStyle(Qt.SquareCap)
                    self.pen.setJoinStyle(Qt.MiterJoin)
                    rectItem = QGraphicsRectItem(QRectF(self.x-self.width, self.y-self.width, 
                                         self.width, self.width))
                    # give the item the color
                    rectItem.setBrush(self.brush)
                    rectItem.setPen(self.pen)
                    addCmd = AddCommand(rectItem, self.scene, 'rectangle')
                    self.undoStack.push(addCmd)
                    #old system #self.scene.addPixItem(self)
    def mousePressEvent (self, event):
        #At anytime we want to know the pos of the pointer
        self.x=event.pos().x()
        self.y=event.pos().y() 
        if self.getMode() =='select':
            self.__origin = event.pos()
            self.__origin = self.__origin.toPoint()
            #__ private variable 
            self.__band.setGeometry(QRect(self.__origin, QSize()))
            self.__band.show(
 
        if self.getMode()=='pipette':
            self.colorPix = self.scene.img.pixel(self.x,self.y)
            #self.colorPix = ColorPickerTool(self.scene).getPipetteColor()
 
            self.mousePressBool = True
        '''
        FIXME :
        Have an option to see when you click on it or not the size of the rub  
        '''
        #self.paintEvent(event)         
        self.update()
 
    def mouseMoveEvent (self, event):
            self.paintEvent(event)
            if self.getMode()=='select': 
            #.normalized() to have it in the right place :s
                self.__band.setGeometry(QRect(self.__origin, event.pos().toPoint()))
            if self.getMode()=='rub':
                self.x=event.pos().x()
                self.y=event.pos().y()     
 
            self.update()        
    def mouseReleaseEvent(self, event):
        if self.getMode()=='select':
            self.__band.hide()
            print "Selected Zone : ", QRect.intersect(self.__band.geometry(), QRect())
        if self.getMode()=='rub':
            self.x=0
            self.y=0
        self.update()

Voir 40 message(s) de cette discussion en une page