Discussion :

[ashren]

Avec un QRubberBand je pense que c'est assez simple à implémenter.

Voir http://www.riverbankcomputing.co.uk/...ubberband.html, un exemple en C++ facilement transposable en python est sur la page (la doc PyQt4 est un peu fouillis quelques fois).

EDIT: j'ai modifié mon exemple précédent pour inclure la sélection qui est 'print' lorsque la sélection est terminée (le QRect obtenu est la zone de l'image sélectionnée) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
from PySide.QtGui import QApplication, QWidget, QPainter, QImage, QRubberBand
from PySide.QtCore import QSize, QRect
 
class ImageView(QWidget):
    def __init__(self, image, parent=None):
        super(ImageView, self).__init__(parent=parent)
        self.__image = image
        self.__band = QRubberBand(QRubberBand.Rectangle, self)
        self.__origin = None
 
    def mousePressEvent(self, e):
        self.__origin = e.pos()
        self.__band.setGeometry(QRect(self.__origin, QSize()))
        self.__band.show()
 
    def mouseReleaseEvent(self, e):
        self.__band.hide()
        print "La selection est :", QRect.intersect(self.__band.geometry(), self.rect())
 
    def mouseMoveEvent(self, e):
        self.__band.setGeometry(QRect(self.__origin, e.pos()).normalized())
 
    def paintEvent(self, e):
        painter = QPainter(self)
        painter.drawImage(self.rect(), self.__image)
 
if __name__ == '__main__':
    app = QApplication([])
    img = QImage("image.png")
    win = ImageView(img)
    win.show()
    app.exec_()

[electrolover49]

J'arrive à afficher la barre de menu malgré tout je n'arrive pas à voir comment changer le chemin d'accès à l'image pour l'afficher.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
from PySide import QtGui
from PySide.QtGui import QAction
from PySide.QtGui import QApplication, QWidget, QPainter, QImage, QRubberBand
from PySide.QtCore import QSize, QRect
 
class ImageView(QtGui.QMainWindow):
    def __init__(self, image, parent=None):
        super(ImageView, self).__init__(parent=parent)
        self.setWindowTitle("Image rubber")
        self.__image = image
        self.__band = QRubberBand(QRubberBand.Rectangle, self)
        self.__origin = None    
    def open_dial(self) :
        reply = QtGui.QFileDialog.getOpenFileName(self, "Open Image", "", "Image Files (*.png *.jpg *.bmp)")
        if reply:
            self.path = reply
            self.load_pic()
        else:
            self.path = None
            print "Invalid Image"
    def save_image(self):
        path = QtGui.QFileDialog.getSaveFileName(parent=None, caption="")
        print "Access path :" + path
        bool = self.pixmap.save(path,".bmp",-1)
        # Test to know if it's working
        if bool:
            print "Saved successfully"
        else :
            print "Saving failed"
 
    def addMenuBar(self):
        """
            Creation of menuBar with all the option available to work on our image
        """
        menuBar = self.menuBar() 
        file_ = menuBar.addMenu("File")
        self.menuOpen= QtGui.QAction("Open",self,triggered=self.open_dial)
        file_.addAction(self.menuOpen)
        self.menuSave = QtGui.QAction("Save",self,triggered=self.save_image)
        file_.addAction(self.menuSave)
        self.menuQuit = QtGui.QAction("Quit", self,triggered=self.close)   
        file_.addAction(self.menuQuit)
 
    def mousePressEvent(self, e):
        self.__origin = e.pos()
        self.__band.setGeometry(QRect(self.__origin, QSize()))
        self.__band.show()
 
    def mouseReleaseEvent(self, e):
        self.__band.hide()
        print "La selection est :", QRect.intersect(self.__band.geometry(), self.rect())
 
    def mouseMoveEvent(self, e):
        self.__band.setGeometry(QRect(self.__origin, e.pos()).normalized())
 
    def paintEvent(self, e):
        painter = QPainter(self)
        painter.drawImage(self.rect(), self.__image)
 
if __name__ == '__main__':
    app = QApplication([])
    print "Path : " + path
    img = QImage(path)
    win = ImageView(img)
    win.addMenuBar()
    win.show()
    app.exec_()

[ashren]

path n'est pas définit, et la méthode load_pic n'existe pas.

Par contre, pourquoi avoir changé la classe de base en QMainWindow ?
Le but d'un widget spécifique qui ré-implémente la méthode paintEvent est de bien séparer le code servant à afficher l'image du reste de l'application. Le but en programmation orientée objet est de bien séparer chaque fonctionnalité afin de maximiser la réutilisation des classes et ainsi réduire les endroits où une erreur peut se glisser.

Ma méthodologie serait la suivante:
-Créer une classe héritant de QMainWindow (appelons la MainWindow)
-Initialiser menu et le widget ImageView dans la méthode __init__ de cette MainWindow
-Connecter les signaux des actions du menu à des méthodes de MainWindow qui permettent de ouvrir/sauver/fermer

Sans oublier de créer une méthode dans le widget ImageView pour changer l'image active depuis une classe externe (même si python est très permissif, ça fait toujours plus propre).

J'éditerai mon post si j'ai le temps de faire un nouvel exemple.

[VinsS]

T'as oublié ta fonction 'load_pic()', donc forcément ...

[electrolover49]

Pour l'oubli c'est normal, l'appel de l'image se fait dans la fonction.
Ashren, je vais suivre tes conseils, merci.

[ashren]

Voilà l'exemple modifié (attention il n'y a quasiment pas de code pour gérer les exceptions, c'est juste un exemple) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
from PySide.QtGui import QApplication, QWidget, QPainter, QImage, QRubberBand, QMainWindow, QAction, QMenuBar, QFileDialog
from PySide.QtCore import QSize, QRect
 
class MainWindow(QMainWindow):
    def __init__(self):
        super(MainWindow, self).__init__()
        self.image = ImageView(QImage())
        self.setCentralWidget(self.image)
        menu = QMenuBar()
        self.setMenuBar(menu)
        _file = menu.addMenu('File')
        # Menu ouvrir
        _action = QAction('Ouvrir', _file)
        _action.triggered.connect(self.__actionOpen)
        _file.addAction(_action)
        # Menu sauver
        _action = QAction('Sauver', _file)
        _action.triggered.connect(self.__actionSave)
        _file.addAction(_action)
        # Menu fermer
        _action = QAction('Fermer', _file)
        _action.triggered.connect(self.__actionClose)
        _file.addAction(_action)
 
    def __actionOpen(self):
        _file = QFileDialog.getOpenFileName(self, "Open Image", "", "Image Files (*.png *.jpg *.bmp)")
        if _file:
            self.image.setWorkingImage(QImage(_file[0]))
        else:
            print "Invalid Image"
 
    def __actionSave(self):
        _file = QFileDialog.getSaveFileName(parent=None, caption="Save image as")
        _result = self.image.workingImage().save(_file[0], "BMP", -1)
        # Test to know if it's working
        if _result:
            print "Saved successfully"
        else :
            print "Saving failed"
 
    def __actionClose(self):
        self.close()
 
class ImageView(QWidget):
    def __init__(self, image, parent=None):
        super(ImageView, self).__init__(parent=parent)
        self.__image = image
        self.__band = QRubberBand(QRubberBand.Rectangle, self)
        self.__origin = None
 
    def setWorkingImage(self, img):
        self.__image = img
        self.setMinimumSize(img.size())
        self.update()
 
    def workingImage(self):
        return self.__image
 
    def mousePressEvent(self, e):
        self.__origin = e.pos()
        self.__band.setGeometry(QRect(self.__origin, QSize()))
        self.__band.show()
 
    def mouseReleaseEvent(self, e):
        self.__band.hide()
        print "La selection est :", QRect.intersect(self.__band.geometry(), self.rect())
 
    def mouseMoveEvent(self, e):
        self.__band.setGeometry(QRect(self.__origin, e.pos()).normalized())
 
    def paintEvent(self, e):
        painter = QPainter(self)
        painter.drawImage(self.rect(), self.__image)
 
if __name__ == '__main__':
    app = QApplication([])
    win = MainWindow()
    win.show()
    app.exec_()

Remaques: les arguments de la méthode save étaient incorrects et la valeur de retour pour FileDialog est un tuple et non une chaîne de caractère.

PySide et PyQt4 étant quasiment identiques en termes d'API, la consultation de la documentation en ligne permet en général de se sortir de ce genre de situation. Mon conseil lorsque l'on débute dans un langage (et pas que pour python) est de lire des tutoriaux, mais également la documentation. C'est généralement le meilleur moyen de comprendre ce que l'on fait et surtout pourquoi ça ne marche pas.

Ce n'est cependant pas une critique mais un conseil

[electrolover49]

Très bien, je vais encore étudier cela, j'ai bien lu la documentation et j'étudie cela, il faut du temps pour assimiler ces nouvelles connaissances.
Ayant plutôt l'habitude du JAVA, le python semble plus complexe, merci encore pour ces conseils.

[electrolover49]

Je sais qu'il est possible de découper les fichiers, dans l'avenir, est-il plus judicieux de créer une classe ImageView puis de l'instancier dans la mainWindow ?
Je pense à ceci si jamais le code était plus conséquent, je pense au découpage donc je voulais savoir si ceci serait plus "propre" ?

[ashren]

EDIT: Pour ta question précédente, séparer les classes est effectivement plus propre même si en python certains préfèrent regrouper les classes ayant des fonctionnalités similaires ou complémentaires dans un seul fichier (module). Cela dépend en grande partie de ce que tu veut rendre modulaire.

Python est un langage orienté objet comme Java, la différence notable c'est que dans python tout est objet, ce qui permet de faire des choses que Java ne peut pas (ce n'est pas forcément bien pour certaines choses).

Le paradigme POO reste le même que ce soit en pyton, Java ou même .Net.

Personnellement je préfère la POO car elle permet de bien séparer les éléments d'un programme et le garder modulaire et propre. J'ai pour habitude de partir de l'élément parent et créer au fur et à mesure les éléments fils; ici par exemple:

- Je veux afficher une image
- Je veux un widget dédié à cet affichage -> QWidget custom

- Affichage de la QImage

- Changement de la QImage active

- Récupération de la QImage active

- Je veux un menu
- Je veux donc un widget conteneur -> QMainWindow custom
- J'ajoute mon widget d'image dans ce conteneur
- Je défini le menu et je connecte les signaux
- J'affiche le tout

[electrolover49]

Le paradigme est le même mais il reste quand même plus complexe en tout cas pour moi qui début en Python, je comprends bien ta construction.
Je travaille maintenant au redimensionnement de l'image pour qu'elle soit plus facile à utiliser.

J'aurais surement encore besoin d'aide .

[electrolover49]

Un peu comme auparavant avec :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#Image in memory  ( real object)
        self.img = QtGui.QImage(self.name)
        w_vue, h_vue = self.vue.width(), self.vue.height() 
        #Image showed on screen
        self.pixmap = QtGui.QPixmap.fromImage(self.img.scaled(w_vue, h_vue,
                                    QtCore.Qt.KeepAspectRatio, 
                                    QtCore.Qt.SmoothTransformation))
        w_pix, h_pix = self.img.width(), self.img.height()
        self.scene = QtGui.QGraphicsScene()
        self.scene.setSceneRect(0, 0, w_pix, h_pix)
        self.scene.addPixmap(self.pixmap)
        self.vue.setScene(self.scene)

qui me permettait d'avoir une image qui s'affiche qui correctement et de pouvoir naviguer, je souhaiterais faire pareil ici.
Cependant malgré mes recherches, j'ai du mal à trouver une solution.
De plus, la doc ne m'aide guère, je sais qu'il faudrait régler la taille du rectangle d'affichage malheureusement je ne comprends pas trop la doc...
Merci d'éclaircir ceci ^^.

Code :

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

1
2
3
4
5
6
7
8
9
10
11

PySide.QtGui.QPainter.drawImage(x, y, image[, sx=0[, sy=0[, sw=-1[, sh=-1[, flags=Qt.AutoColor]]]]])
Parameters:	
x – PySide.QtCore.int
y – PySide.QtCore.int
image – PySide.QtGui.QImage
sx – PySide.QtCore.int
sy – PySide.QtCore.int
sw – PySide.QtCore.int
sh – PySide.QtCore.int
flags – PySide.QtCore.Qt.ImageConversionFlags

[ashren]

Qu'entends-tu par naviguer ? pouvoir scroller l'image ? si c'est ca, cherche à encapsuler ton widget image dans une QScrollArea.

Sinon pour drawImage à première vue (il faudrait faire des tests):
x et y - coordonnées de destination sur le QPainter
sx et sy - coordonnées source (pas sûr)
sw et sh - taille de la zone source à copier (la aussi pas sûr)

Le mieux est de faire des tests dans des fichiers python indépendants histoire de pas casser ce que tu as déjà de fonctionnel.

[electrolover49]

Parfait, je vais surement encapsuler avec le Scrolling bien sur.
Alors, j'ai essayé de voir avec cela cependant j'affiche une image vide, j'ai remplacé la méthode paintEvent par :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
def viewImage(self):
 
        image = QImage(self.__image)
        self.setPixmap(QPixmap.fromImage(image))
 
        scrollArea = QScrollArea()
        scrollArea.setBackgroundRole(QPalette.Dark)
        # child widget self => imageView
        scrollArea.setWidget(self)

[electrolover49]

J'ai trouvé un moyen de "scroller" sur une image avec le QGraphics et le scene.
Malgré tout, il faudrait que mon image soit une Item pour que cela fonctionne et dans la bibliothèque, il n'existe que le QGraphicsPixmapItem.
Cela m’embête car je ne sais pas si cela sera aussi bien que d'avoir la Qimage directement .
Enfin, voici mon exemple, si il y a encore des conseils, je suis preneur , merci de me faire progresser ^^.
Finalement, j'arrive à afficher mon problème est l'intégration au projet précédent, je vois mal comment le faire :s

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
from PySide.QtGui import *
from PySide.QtCore import QSize, QRect
 
 
class Image(QGraphicsPixmapItem):
    def __init__(self):
        super(Image, self).__init__()
 
        self.image = QImage("C:\desert.jpg")
        self.setPixmap(QPixmap.fromImage(self.image))
 
 
class View(QGraphicsView):
    def __init__(self):
        super(View, self).__init__()
 
        self.setRenderHint(QPainter.Antialiasing)
        self.initScene()
 
 
    def initScene(self):
 
 
        self.scene = QGraphicsScene()
        self.setSceneRect(0, 0, 400, 400)  
 
        self.img = Image()        
        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.initUI()
 
 
    def initUI(self):   
 
        vbox = QVBoxLayout()
 
        self.view = View()
 
        vbox.addWidget(self.view)
        self.setLayout(vbox)
 
app = QApplication([])
ex = Example()
ex.show()
app.exec_()

[tyrtamos]

Bonjour,

Comme je suis sur PyQt4, je ne sais pas si ce sera utile, mais j'imprime souvent du texte et des images sur des pages pdf en haute résolution (1200 dpi).

Pour ce qui concerne les images:

- je charge les images dans des QImage

- je les redimensionne avec les méthodes scaledToHeight ou scaledToWidth de QImage, avec l'avantage de conserver le ratio, et en utilisant l'option QtCore.Qt.SmoothTransformation pour améliorer la qualité du redimensionnement.

- et j'écris les images avec le drawImage du painter. Comme l'image est déjà à la bonne dimension, on utilise le drawImage avec QPoint, et pas celui avec QRect.

En effet, après de nombreux essais, j'ai pu constater que même si le redimensionnement de l'image parait automatique dans certains cas, on augmente la qualité de l'image en provoquant son redimensionnement avant son insertion comme ci-dessus.

Un truc en bonus: comme je veux un moyen simple de faire une composition de page précise, je fais une conversion mm => pixels avec:

Code :

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

mm2px = lambda mm: int(mm/25.4*printer.resolution())

De ce fait, je mesure toutes les dimensions en mm sur la page, et mon code se "débrouille" avec, en faisant la conversion en pixels. A l'expérience, ça permet de faire des compositions "léchées" sans trop de mal.

[ashren]

Je ne vois pas trop le soucis pour le scroll, ceci fonctionne très bien chez moi (modification de mon code précédent pour ajouter une scroll area) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
from PySide.QtGui import QApplication, QWidget, QPainter, QImage, QRubberBand, QMainWindow, QAction, QMenuBar, QFileDialog, QScrollArea
from PySide.QtCore import QSize, QRect
 
class MainWindow(QMainWindow):
    def __init__(self):
        super(MainWindow, self).__init__()
        self.image = ImageView(QImage())
        self.area = QScrollArea(self)
        self.area.setWidget(self.image)
        self.area.setWidgetResizable(True)
        self.setCentralWidget(self.area)
        menu = QMenuBar()
        self.setMenuBar(menu)
        _file = menu.addMenu('File')
        # Menu ouvrir
        _action = QAction('Ouvrir', _file)
        _action.triggered.connect(self.__actionOpen)
        _file.addAction(_action)
        # Menu sauver
        _action = QAction('Sauver', _file)
        _action.triggered.connect(self.__actionSave)
        _file.addAction(_action)
        # Menu fermer
        _action = QAction('Fermer', _file)
        _action.triggered.connect(self.__actionClose)
        _file.addAction(_action)
 
    def __actionOpen(self):
        _file = QFileDialog.getOpenFileName(self, "Open Image", "", "Image Files (*.png *.jpg *.bmp)")
        if _file:
            self.image.setWorkingImage(QImage(_file[0]))
        else:
            print "Invalid Image"
 
    def __actionSave(self):
        _file = QFileDialog.getSaveFileName(parent=None, caption="Save image as")
        _result = self.image.workingImage().save(_file[0], "BMP", -1)
        # Test to know if it's working
        if _result:
            print "Saved successfully"
        else :
            print "Saving failed"
 
    def __actionClose(self):
        self.close()
 
class ImageView(QWidget):
    def __init__(self, image, parent=None):
        super(ImageView, self).__init__(parent=parent)
        self.__image = image
        self.__band = QRubberBand(QRubberBand.Rectangle, self)
        self.__origin = None
 
    def setWorkingImage(self, img):
        self.__image = img
        self.setMinimumSize(img.size())
        self.update()
 
    def workingImage(self):
        return self.__image
 
    def mousePressEvent(self, e):
        self.__origin = e.pos()
        self.__band.setGeometry(QRect(self.__origin, QSize()))
        self.__band.show()
 
    def mouseReleaseEvent(self, e):
        self.__band.hide()
        print "La selection est :", QRect.intersect(self.__band.geometry(), self.rect())
 
    def mouseMoveEvent(self, e):
        self.__band.setGeometry(QRect(self.__origin, e.pos()).normalized())
 
    def paintEvent(self, e):
        painter = QPainter(self)
        painter.drawImage(self.rect(), self.__image)
 
if __name__ == '__main__':
    app = QApplication([])
    win = MainWindow()
    win.show()
    app.exec_()

A moins que j'ai mal interprété ton problème ?

[electrolover49]

C'est exactement seulement je cherchais trop compliqué, je voulais intégrer l'image dans une graphicScene alors qu'avec le scroll c'est beaucoup plus simple.

Ma prochaine étape serait de voir à créer une sorte de gomme pour effacer les imperfections d'une image, dois créer un nouveau sujet ou pouvons continuer ici sur ce super topic ^^?

Bonne journée.

[ashren]

Je pense qu'un nouveau sujet serait plus approprié puisque la question est différente mais ça reste à voir.

Pour la gomme, un QPainter peut être appliqué à la QImage, et regarder du côté de QUndoStack peut-être une piste pour implémenter une commande annuler (même si je n'ai personnellement jamais utilisé cette classe).

De manière générale, regarder la liste exhaustive des classes disponibles dans Qt4 serait utile, car la plupart du temps les noms associés à celles-ci sont explicites (et quelques fois non).

[electrolover49]

Je vais étudier les différentes solutions dans la docs PySide et je reviendrais ^^.
Pour la suite, cf. http://www.developpez.net/forums/d12...e/#post6731520

Merci