Bonjour,

Je découvre le gestionnaire de fenêtres en Python PyQT. J'ai trouvé dans les fils de discussions passés de ce forum pas mal d'indications qui m'ont permis de débuter en PyQt un afficheur de carte OpenStreetMap à la manière d'un gps. Cela m'a incité à m'inscrire. Ces cartes sont constitués de fichiers tuiles *.png de 256 x 256 pixels. J'arrive à les afficher cote-à-cote pour construire une plus grande carte... La partie centrale de l'affichage est dans la fonction buildMap.

Je n'arrive pas à trouver la méthode qui permet de placer une image QPixmap sous une autre pour qu'elle soit partiellement recouverte par une autre QPixmap.

Je rencontre ce besoin par exemple lorsqu'il manque une tuile d'un certain niveau, elle peut être approchée par la tuile correspondante d'un niveau immédiatement inférieur avec un zoom "x2". Il en est de même pour peindre en gris un morceau de tuile pour n'en faire ressortir qu'une partie à l'écran.

Voilà donc la partie centrale du "code qui marche".

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
 
 
class MaFenetre (QWidget) : 
 
  # initialisation des variables...
 
  def buildMap (self):    
 
    for xx in range (xcentre-3, xcentre+3) :
      for yy in range (ycentre-2, ycentre+2) :
 
        # affichage d'une carte de taille 7x5 tuiles
        image = QLabel ("", self)
        pixmap = QPixmap (nom(self.level,xx,yy)) # lit la tuile par exemple .../12/123/456.png
        image.setPixmap(pixmap)
        image.move((xx-xcentre)*256, (yy-ycentre)*256
        image.show()
 
  def keyPressEvent (self, e):
        if e.key() == QtCore.Qt.Key_Escape : self.close()
        elif e.key() == QtCore.Qt.Key_Z : 
          if self.level < 18 : self.level += 1 
          else : return 
        elif e.key() == QtCore.Qt.Key_A : 
          if self.level > 0 : self.level -= 1
          else : return 
        elif e.key() == QtCore.Qt.Key_M: 
          self.long += 360/2**self.level
          if self.long > 180 : self.long -= 360
        elif e.key() == QtCore.Qt.Key_K:
          self.long -= 360/2**self.level
          if self.long < -180 : self.long += 360
        elif e.key() == QtCore.Qt.Key_O:
          self.lat += 180/2**self.level
          if self.lat > 90 : self.lat = 89
        elif e.key() == QtCore.Qt.Key_L: 
          self.lat -= 180/2**self.level
          if self.lat < -90 : self.lat = -89
        else:
          print('bad key !')
          return 
 
        self.buildMap()
 
  def __init__ (self,long,lat,level) :
    self.level = level
    self.long  = long
    self.lat   = lat
    QWidget.__init__(self)
    self.setMinimumSize(100, 100)
    self.buildMap()
 
def main () :
  app = QApplication.instance () 
  if not app : app = QApplication(sys.argv)
  fenetre = MaFenetre (long  = -2, lat = 48, level = 6)
  fenetre.show ()
  app.exec_()
 
main()
Je réussis aussi à créer des rectangles de couleurs, mais je n'arrive pas à les placer "au dessus" d'une carte déjà dessinée pour en masquer une partie, même en permutant l'ordre des méthodes .show().

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
 
        qp = QPixmap (70, 256) # pour créer un rectangle de 70x256 pixels
        qp.fill (Qt.gray)
        ig = QLabel ("gris", self)
        ig.setPixmap (qp)
        ig.show()
Par ailleurs, la bibliothèque de manipulations d'images PIL permet de créer des images "déjà découpées" par la méthode .crop, et de traiter des pixels un par un, mais je n'ai pas trouvé de moulinette qui transforme un Qpixmap en image pour PIL et réciproquement.

Je demande donc à bien plus savant que moi s'il possible de "découper" ou de "recouvrir" des morceaux d'images QPixmap, ou d'indiquer les pistes habituellement retenues pour résoudre ce problème.

Bien cordialement à tous, et un grand merci à ceux qui m'aideront à avancer !

F.