Gomme et QImage

Version imprimable

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

Problème persistant :s

J'ai essayé comme cela voir ligne 174 et malgré tout il n'y a pas de mise à jour malheureusement.
Merci de ta précieuse aide, c'est surement une erreur à la con mais j'ai passé tout l'après midi à chercher , je ne vois pas :s.

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
# -*- coding: utf-8 -*-
from PySide.QtGui import QApplication, QWidget, QPainter, QKeySequence,QColor,QCheckBox,QStatusBar,QIcon,\
                         QMessageBox,QImage, QRubberBand, QMainWindow, QAction,\
                         QMenuBar, QFileDialog, QScrollArea,QColorDialog,QPalette,QBrush,QPixmap,\
                         QPushButton
from PySide.QtCore import QSize, QRect,QRectF,Qt
from ImageView import ImageView

class MainWindow(QMainWindow):
    def __init__(self):
        super(MainWindow, self).__init__()
        self.setWindowTitle("Rub your Image")
        self._color = QColor()
        
        self._fileName=""
        
        self.image = ImageView(QImage(),self.getPaletteColor())
        self.resize(500, 300)
        
        #Init of the Menu with the menubar and the icon
        self._initMenu()
        #Init of the Scrollarea 
        self._initScrollArea()
        #Init of the status bar (at bottom) with ckbox and colorPicker
        self._initStatusBar()
       
    def _initMenu(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)
        
        
        
        
        
        """
            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)
        # 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)
        #Menu Edit
    def _initScrollArea(self):
        """
        Add of scroll bars to see properly the images
        """
        self.area = QScrollArea(self)
        self.area.setWidget(self.image)
        self.area.setWidgetResizable(True)
        self.setCentralWidget(self.area)
        
    def _initStatusBar(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 __actionOpen(self):
        self._fileName = QFileDialog.getOpenFileName(self, "Open Image", "", "Image Files (*.png *.jpg *.bmp)")
        if self._fileName:
            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):
        _result = self.image.workingImage().save(self. _fileName[0], "BMP", -1)
        # Test to know if it's working
        if _result:
            print "Saved successfully"
        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.setPaletteColor(dlg.selectedColor())
    def __setColor(self, color):
        _img = QPixmap(16, 16)
        _p = QPainter(_img)
        _p.fillRect(_img.rect(), QBrush(color))
        self.setPaletteColor(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
 
   
 
if __name__ == '__main__':
    app = QApplication([])
    win = MainWindow()
    win.show()
    app.exec_()

15/06/2012, 21h39
ashren
Dans ton code précédent, tu avais mis un
Code:

1 2 self.image.setPenColor(self._color)
Je te conseillerai de le remettre là où il se trouvait (à moins que tu ai modifié le code), et de l'ajouter également entre les lignes 185 et 186 pour voir si ça marche.
16/06/2012, 17h43
electrolover49

évidemment

J' ai honte lol à force d'être dans mon code je n'avais même pas vu cela.
Cela marche parfaitement maintenant.

Nouvelle direction

Comme tu m'avais conseillé, j'ai fais un mockup et puis un diagramme UML.
Du coup, je vais essayer de le respecter même si cela est plus difficile que je le pensais.
En effet, j'arrive même pas à charger une image avec la QGraphics scene et view lol.
J'ai un problème de récursivité d'appel de constructeur, on dirait.

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
from ImageView import ImageView
from PySide.QtCore import QSize, QRect
from PySide.QtGui import QImage, QRubberBand, QMainWindow, QAction, QMenuBar, \
    QFileDialog, QScrollArea, QPixmap, QApplication, QWidget, QPainter, QKeySequence, \
    QGraphicsPixmapItem, QGraphicsView, QGraphicsScene, QVBoxLayout,QColor,QBoxLayout
 
 
class Image(QGraphicsPixmapItem):
    def __init__(self,fileName):
        super(Image, self).__init__()
        self._color = QColor()
        self.__image = QImage(fileName)
        self.pix = QPixmap()
        self.pix = self.pix.fromImage(self.__image)
 
    def setWorkingImage(self, img):
        self.__image = img
        #self.setMinimumSize(img.size())
        self.update()
 
    def workingImage(self):
        return self.__image
    def getImage(self):
        return self.pix
 
class View(QGraphicsView):
    def __init__(self):
        super(View, self).__init__()
        self.ex = Example()     
        self.setRenderHint(QPainter.Antialiasing)
        self.initScene()
 
    def initScene(self):
        self.scene = QGraphicsScene()
 
        self.img = Image(ex._getFileName())        
        self.scene.addItem(self.img)
 
        self.setScene(self.scene)  
 
 
class Example(QWidget):
    def __init__(self):
        super(Example, self).__init__()
 
        self.setWindowTitle("Redim")
        self.setGeometry(150, 150, 300, 300)
        self.win = QMainWindow()
        menu = QMenuBar()
        self.win.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)
 
        self.initUI()
 
 
    def __actionOpen(self):
        self._fileName = QFileDialog.getOpenFileName(self, "Open Image", "", "Image Files (*.png *.jpg *.bmp)")
        if self._fileName:
            print "Action open file"
            self.__image.setWorkingImage(QImage(self._fileName[0]))
        else:
            print "Invalid Image"
    def _getFileName(self):
        return self._fileName
    def initUI(self):   
 
        vbox = QBoxLayout(QBoxLayout.Direction.TopToBottom)
 
        self.view = View()
 
        vbox.addWidget(self.win)
        vbox.addWidget(self.view)
        self.setLayout(vbox)
 
app = QApplication([])
ex = Example()
ex.show()
app.exec_()

16/06/2012, 19h51
ashren

Problème à la ligne 29, tu recréé une instance de example, qui recréé une instance de View etc ...
16/06/2012, 20h03
electrolover49

Oui je sais bien mon problème est que je ne vois pas comment faire passer le nom de mon fichier à ouvrir dans la classe Image.
Je ne suis pas sur de pouvoir appliquer un modèle MVC pour mon programme.
C'est à dire j'aurais ma vue avec la view , le controller le main ( et d'autres fonctions aussi) et le model avec l'image par exemple.
17/06/2012, 10h48
ashren

Il est difficile de faire du MVC avec Qt4 puisque celui-ci ne l'utilise pas vraiment. Il faut juste essayer de séparer les données (model) de la vue (les widgets).

Dans ce cas ci, le modèle serait la QImage et ImageView la vue. Pour le reste, Qt4 est déjà architecturé de telle sorte que les vues sont séparées des données (QStandardItemModel et QListView par exemple).

Pour le nom de fichier, pourquoi ne pas le mettre en paramètre du __init__ de la classe View ?

EDIT: Voici un lien qui pourrait t'aider à comprendre comment Qt4 fonctionne en terme de séparation des couches : http://qt-project.org/doc/qt-4.8/mod...ogramming.html
17/06/2012, 12h55
electrolover49

Je vais étudier cela pour que cela fonctionne au moins l'ouverture déjà .
Une fois, que cela marchera je pense que le reste sera bon.

Pour pouvoir avancer, j'essaye d'avoir une bonne architecture.
Heureusement,avec tes conseils, cela m'aide pour commencer vu que maintenant cela fait que quelques semaines que je connais le python.

Non affichage de l'image

J'ai résolu le problème de récursivité malgré tout je n'affiche pas l'image que j'envoie.
J'ai aucune erreur de compilation mais surement plusieurs d’exécutions.
J'ai peur que mon modèle soit peut être bancale et qu'il ne peut pas créer l'image ou que l'item n'est pas bien ajouté à la scène.

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
from ImageView import ImageView
from PySide.QtCore import QSize, QRect
from PySide.QtGui import QImage, QRubberBand, QMainWindow, QAction, QMenuBar, \
    QFileDialog, QScrollArea, QPixmap, QApplication, QWidget, QPainter, QKeySequence, \
    QGraphicsPixmapItem, QGraphicsView, QGraphicsScene, QVBoxLayout,QColor,QBoxLayout
 
 
class Image(QGraphicsPixmapItem):
    def __init__(self,fileName):
        super(Image, self).__init__()
        self._color = QColor()
 
        print "File name Image " + fileName[0]
        self.__image = QImage(fileName[0])
        self.pix = QPixmap()
        self.pix = self.pix.fromImage(self.__image)
 
    def setWorkingImage(self, img):
        self.__image = img
        #self.setMinimumSize(img.size())
        self.update()
 
    def workingImage(self):
        return self.__image
 
    def getImage(self):
        return self.pix
 
class View(QGraphicsView):
    def __init__(self,img):
        super(View, self).__init__()
 
        self.setRenderHint(QPainter.Antialiasing)
        self.initScene()
        print "Appel view"
        self.addItem(img)
    def initScene(self):
        self.scene = QGraphicsScene()
 
        self.setScene(self.scene)  
    def addItem(self,img):
        self.scene.addItem(img)
class Example(QWidget):
    def __init__(self):
        super(Example, self).__init__()
 
        self.setWindowTitle("Redim")
        self.setGeometry(150, 150, 300, 300)
        self.win = QMainWindow()
        menu = QMenuBar()
        self.win.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)
 
        self._fileName =""
        self.initUI()
 
 
    def __actionOpen(self):
        self._fileName = QFileDialog.getOpenFileName(self, "Open Image", "", "Image Files (*.png *.jpg *.bmp)")
        if self._fileName:
            print "Action open file"
            self.img = Image(self._fileName)
            self.view = View(self.img) 
            self.vbox.addWidget(self.view)
            #self.__image.setWorkingImage(QImage(self._fileName[0]))
        else:
            print "Invalid Image"
    def _getFileName(self):
        return self._fileName
    def _getImg(self):
        return self.img
    def initUI(self):   
 
        self.vbox = QBoxLayout(QBoxLayout.Direction.TopToBottom)
 
 
        self.vbox.addWidget(self.win)
 
        self.setLayout(self.vbox)
 
app = QApplication([])
ex = Example()
ex.show()
app.exec_()

17/06/2012, 19h06
ashren

Je commence à avoir du mal à comprendre ton code et je suppose que toi aussi :

- pourquoi avoir supprimé l'utilisation de ImageView ? (avec la sélection, etc).
Cela aurait été tout aussi simple d'implémenter la QGraphicsScene directement dans celui-ci.

- pour le non affichage de l'image, un coup d’œil dans la documentation http://www.riverbankcomputing.co.uk/...ixmapitem.html permet de voir qu'il faut définir un pixmap avec setPixmap, sinon rien ne s'affichera.

Mon conseil : prendre une feuille de papier, et faire un diagramme de classes comme tu le sent (pas forcément UML), mais avec quand même les membres de classes et les appartenances. Sinon tu te perdra et t’énervera très vite sur ton propre code.

Je te conseille également de regarder le système de signaux/slots de Qt4 (et donc PySide/PyQt4) car il permet de lier les différentes couches applicatives de manière souple.

1 pièce(s) jointe(s)

Interrogation sur le placement des mouvements de souris

Je vais faire cela.
Je voulais essayer ce découpage et finalement c'est plus complexe que j'imaginais.
EDIT : Voici la version 2 de mon uml pourtant je ne suis pas complétement satisfait, je ne sais pas où placer les actions de mouvement de souris (ImageView et Freehand).

En effet, d'après ce que tu m'as dis
les évènements souris/clavier devront être gérés par la QGraphicsScene et non l'ImageView.
je te crois seulement sur un exemple que j'ai vu pour lancer une freehandline, le mouvement est appelé dans la view ce qui est contradictoire avec ce que tu disais enfin je pense :s
exemple freehand
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 [ #A l'intérieur du main class GraphicsView(QGraphicsView): def __init__(self, parent=None): super(GraphicsView, self).__init__(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) """ 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) def mouseReleaseEvent(self, event): self.freehandTool.pointerReleaseEvent(event)

19/06/2012, 10h47
electrolover49

1 pièce(s) jointe(s)

Ajout UML Freehand

voici aussi celui de la freehand qui sera à la place de freehandtool enfin plutôt freehandtool appelera le modèle freehand.
Peux-tu me dire si je m'égare ou pas ^^?
Merci d'avance.
19/06/2012, 11h58
ashren

De mon expérience avec QGraphicsScene les évènements n'étaient pas transmis aux widgets enfants (après c'est peut-être le contexte dans lequel elle était utilisée qui provoquait ce comportement). Le meilleur moyen d'être sûr est de faire un test : une QGraphicsScene en guise de toplevel widget et quelques widgets dans celle-ci pour voir s'ils réagissent). Pareil avec ton FreeHandTool, fait des tests indépendants et adapte le code fonctionnel de ces tests dans ton code final.

Pour l'UML, l'ensemble à l'air plus ou moins cohérent (l'important est que tu comprenne ta propre démarche même si tu ne code pas pendant 1 mois par exemple). Je ne peux pas trop en dire d'avantage puisque je n'ai pas d'expérience dans la création de logiciels de dessin.
19/06/2012, 12h09
electrolover49

Je vais tester cela, tu m'aides quand vraiment bien, merci encore.
Je suis sur que tu pourras m'aider encore ^^.:ccool:

Nouveau Main

En essayant de respecter mon UML, j'ai essayé d'appeler simplement la vue puis de charger l'image sur ma page mais malgré tout rien ne se passe :s.

Je ne comprends pas pourquoi il n'ajoute pas ma pixmap à la vue.

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
# -*- coding: utf-8 -*-
 
 
 
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
from PySide.QtCore import QSize, QRect,QRectF,Qt
import sys
 
from Tools.freehand import FreehandTool
from ImageView.ImageViewV2 import ImageView
class DiagramScene(QGraphicsScene):
    def __init__(self, *args):
        QGraphicsScene.__init__(self, *args)
        self._color = QColor()
 
        self.img = ImageView(QImage("Pics\mol1.bmp"),self._color)
        self.pix = QPixmap()
        self.pix = self.pix.fromImage(self.img.workingImage())
        self.addPixmap(self.pix)
        #self.addWidget(self.img)
class GraphicsView(QGraphicsView):
    def __init__(self, parent=None):
        super(GraphicsView, self).__init__(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)
 
 
    """ 
    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)
 
    def mouseReleaseEvent(self, event):
        self.freehandTool.pointerReleaseEvent(event)
 
 
 
 
class MainWindow(QMainWindow):
    def __init__(self, *args):
        QMainWindow.__init__(self, *args)
        self.setWindowTitle("Freehand Line Test")
        self.scene = DiagramScene()
        self.view = GraphicsView(self.scene)
        rect =QRect(-500, -500, 500, 500)
        self.view.fitInView(rect)
        self.view.setSceneRect(rect)
        self.setCentralWidget(self.view)
 
 
def main(args):
    app = QApplication(args)
    mainWindow = MainWindow()
    mainWindow.setGeometry(100, 100, 500, 500)
    mainWindow.show()
 
    sys.exit(app.exec_()) # Qt Main loop
 
 
if __name__ == "__main__":
    main(sys.argv)

Commence par regarder la doc pour le constructeur de ta GraphicsView (surtout quand l'objet passé sans spécifier le paramètre est une QGraphicsScene).

Voici un test qui fonctionne (changer le chemin de l'image)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
from PySide.QtGui import QApplication, QGraphicsView, QGraphicsScene, QImage, QPixmap
 
class GraphicsScene(QGraphicsScene):
    def __init__(self, parent=None):
        super(GraphicsScene, self).__init__(parent=parent)
        self.img = QImage("image.png")
        self.addPixmap(QPixmap.fromImage(self.img))
        self.setSceneRect(self.img.rect())
 
class GraphicsView(QGraphicsView):
    def __init__(self, scene, parent=None):
        super(GraphicsView, self).__init__(scene, parent=parent)
 
if __name__ == '__main__':
    app = QApplication([])
    scn = GraphicsScene()
    v = GraphicsView(scn)
    v.show()
    app.exec_()

19/06/2012, 19h50
electrolover49

Je pensais que c'est comme cela qu'on fonctionnait qu'il fallait passer la scène à la vue non ?
19/06/2012, 20h14
ashren

Pour le constructeur je pointai juste le fait que ce que tu passe en paramètre à ton super n'est pas le 'parent' mais la scene (tu risque de t'y perdre).

Sinon l'image s'affiche bien, vire juste le fitInView et setSceneRect (j'ai pas compris à quoi ça servait d'ailleurs).
19/06/2012, 20h44
electrolover49

Ah merci, c'est ça qui faisait tout "buggé". Je suis en train d'améliorer l'architecture, j'essaye d'implémenter ma gomme la freehandline c'est plutôt costaud.
20/06/2012, 10h56
electrolover49

Question d'architecture du projet

C'est une question qui peut paraître bête mais n'étant pas expert en MVC pour Python.

Je me demande encore comment découper mon projet enfin comment séparer les fichiers par exemple dans le main ?
Dois-je laisser la classe Scene et View même si je pense que je peux les mettre dans un autre package car elle sont instanciées dans le MainWindow ?

Pour le tool, et externalisé la commande souris car j'ai peur que si je sépare, il ne gère plus l'événement peut-être :s ?

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