PyQt - visualizzazione del widget nella parte superiore del widget

Question

Sto creando un'applicazione che mostra una mappa di un'area e sto cercando di disegnare nodi su di essa che possano rappresentare informazioni.

Ho fatto tutto il lavoro, ma l'ho fatto semplicemente creando un widget personalizzato che mostravo e stampavo tutto ripetutamente ogni volta che cambiavano le informazioni. Inoltre non potevo "connettere" i nodi agli ascoltatori, perché erano solo immagini nel widget originale.

Questo mi ha fatto venire voglia di riformare la mia GUI e ora sto cercando di rendere ogni classe un widget personalizzato! Ma c'è un problema, i miei MapNode non vengono più visualizzati.

ho cercato StackOverflow e trovato questa discussione utile: (?) How to set absolute position of the widgets in qt

quindi devo dare il mio mapnodes un genitore, e genitore = il widget che viene mostrato

Ad ogni modo, ecco il mio lanciatelo incollando qui il codice pertinente. Suggerimento dove roba potrebbe andare storto orribile: tutte le INITs

app = QtGui.QApplication(list()) 
mutexbranch = Lock() 
mutexnode = Lock() 

def exec(): 
    return app.exec_() 

#Singleton Pattern: wanneer en object aan iets moet kunnen 
#     waar het inherent door de structuur niet aankon 
#     wordt dit via dit singleton opgelost 
class GuiInternalCommunication: 
    realmap = 0 


class MapView(QtGui.QWidget, listener.Listener): 
    def __init__(self, mapimagepath): 
     QtGui.QMainWindow.__init__(self) 
     listener.Listener.__init__(self) 

     self.map = Map(self, mapimagepath) 
     #self.setCentralWidget(self.map) 

     self.initUI() 


    def initUI(self): 
     self.setWindowTitle('Population mapping') 

     hbox = QtGui.QHBoxLayout() 
     hbox.addWidget(self.map) 

     self.setLayout(hbox) 

     resolution = QtGui.QDesktopWidget().screenGeometry() 
     self.setGeometry(20,20,550,800) 
     self.show() 



###################################################################### 

class Map(QtGui.QWidget): 
    def __init__(self, parent, mapimagepath): 
     QtGui.QWidget.__init__(self, parent) 

     #self.timer = QtCore.QBasicTimer() 

     #coordinaten hoeken NE en SW voor kaart in map graphics van SKO 
     self.realmap = RealMap( 
      mapimagepath, 
      (51.0442, 3.7268), 
      (51.0405, 3.7242), 
      550, 
      800) 
     GuiInternalCommunication.realmap = self.realmap 

     self.needsupdate = True 
     self.timelabel = 0 

     parent.setGeometry(0,0,self.realmap.width, self.realmap.height) 

     self.mapNodes = {} 
     self.mapBranches = {} 

    def paintEvent(self, event): 
     painter = QtGui.QPainter() 
     painter.begin(self) 
     rect = self.contentsRect() 

     #teken achtergrond 
     self.realmap.drawRealMap(painter) 

     #teken branches 
     mutexbranch.acquire() 
     try: 
      for branch, mapBranch in self.mapBranches.items(): 
       mapBranch.drawMapBranch(painter) 
     finally: 
      mutexbranch.release()   



###################################################################### 

class RealMap(QtGui.QWidget): 
    def __init__(self, path, coordRightTop, coordLeftBot, width, height, pixpermet = 2.6): 
     super(RealMap, self).__init__() 
     self.path = path 
     self.mapimage = QtGui.QImage(self.path) 
     self.coordLeftBot = coordLeftBot 
     self.coordRightTop = coordRightTop 

     self.width = width 
     self.height = height 

     self.realdim = self.calcRealDim() 

     self.pixpermet = pixpermet 

    def paintEvent(self, e): 
     painter = QtGui.QPainter() 
     painter.begin(self) 
     self.drawRealMap(self, painter) 
     painter.end() 

    def drawRealMap(self, painter): 
     painter.drawImage(0,0,self.mapimage) 


###################################################################### 

class MapNode(QtGui.QWidget): 
    dangertocolor = {"normal":"graphics//gradients//green.png", 
        "elevated":"graphics//gradients//orange.png", 
        "danger":"graphics//gradients//red.png"} 

    gradimage = {"normal":QtGui.QImage(dangertocolor["normal"]), 
        "elevated":QtGui.QImage(dangertocolor["elevated"]), 
        "danger":QtGui.QImage(dangertocolor["danger"])} 
    btimage = QtGui.QImage("graphics//BT-icon.png") 

    def __init__(self, scanner, x, y, danger = 0, parent = None): 
     # MapNode erft over van QWidget 
     super(MapNode, self).__init__() 
     QtGui.QWidget.__init__(self, parent) 

     self.scanner = scanner 
     self.x = x 
     self.y = y 
     self.danger = 'normal' 
     self.calcDanger(danger) 

     self.grads = {} 
     self.grad = QtGui.QImage(MapNode.dangertocolor[self.danger]) 


    def paintEvent(self, e): 
     painter = QtGui.QPainter() 
     painter.begin(self) 
     self.drawMapNode(painter) 
     painter.end() 

    def drawMapNode(self, painter): 
     realmap = GuiInternalCommunication.realmap 
     radiusm = self.scanner.range 
     radiusp = radiusm*realmap.pixpermet 
     factor = radiusp/200  # basis grootte gradiënten is 200 pixels. 

     grad = MapNode.gradimage[self.danger] 
     grad = grad.scaled(grad.size().width()*factor, grad.size().height()*factor) 

     painter.drawImage(self.x-100*factor,self.y-100*factor, grad) 
     painter.drawImage(self.x-10, self.y-10,MapNode.btimage) 
     painter.drawText(self.x-15, self.y+20, str(self.scanner.sensorid) + '-' + str(self.scanner.name)) 


###################################################################### 

class MapBranch: 
    branchpens = {"normal": QtGui.QPen(QtCore.Qt.green, 3, QtCore.Qt.DashLine), 
       "elevated": QtGui.QPen(QtGui.QColor(255, 51, 0), 3, QtCore.Qt.DashLine), #mandarine orange hex is 255-165-0 
       "danger": QtGui.QPen(QtCore.Qt.red, 3, QtCore.Qt.DashLine)} 

    def __init__(self, branch, mapnode1, mapnode2, danger = 0): 
     self.mapnode1 = mapnode1 
     self.mapnode2 = mapnode2 
     self.branch = branch 
     self.danger = danger 

     self.calcDanger(danger) 

    def drawMapBranch(self, painter): 
     painter.setPen(MapBranch.branchpens[self.danger]) 
     painter.drawLine(self.mapnode1.x, 
         self.mapnode1.y, 
         self.mapnode2.x, 
         self.mapnode2.y) 

EDIT - Ho dimenticato di aggiungere il codice che aggiunge i nodi. Così, dopo un evento entra nel nodo deve essere creato, questo metodo incendi creando il nodo:

def addNode(self, scanner): 
    mutexnode.acquire() 
    try: 
     coord = self.realmap.convertLatLon2Pix((scanner.latitude, scanner.longitude)) 
     self.mapNodes[scanner.sensorid] = MapNode(scanner, coord[0], coord[1], parent = self) 
     self.mapNodes[scanner.sensorid].move(coord[0],coord[1]) 
     #self.mapNodes[scanner.sensorid].show() 
    finally: 
     mutexnode.release() 

Answer 1

vorrei si consiglia di utilizzare le classi QGraphicsScene e QGraphicsItem per la mappa, invece di normali classi QWidget, dal momento che sono fatta esattamente per lo scopo di visualizzare un gran numero di elementi grafici:

• QGraphicsScene http://doc.qt.io/qt-5/qgraphicsscene.html
• QGraphicsItem: http://doc.qt.io/qt-5/qgraphicsitem-members.html

Dalla documentazione:

La classe QGraphicsScene fornisce una superficie per la gestione di un gran numero di elementi grafici 2D.

La classe funge da contenitore per QGraphicsItems. Viene utilizzato insieme a QGraphicsView per visualizzare elementi grafici, come linee, rettangoli, testo o anche oggetti personalizzati, su una superficie 2D. QGraphicsScene è parte del Graphics View Framework.

QGraphicsScene fornisce anche funzionalità che consentono di determinare in modo efficiente sia la posizione degli elementi, sia di determinare quali elementi sono visibili all'interno di un'area arbitraria sulla scena. Con il widget QGraphicsView, è possibile visualizzare l'intera scena o ingrandire e visualizzare solo parti della scena.

È anche possibile incorporare widget derivati ​​da QWidget nella scena, che dovrebbero consentire di visualizzare praticamente qualsiasi tipo di informazione. Come bonus, otterrai stratificazione, trasformazioni rapide e la gestione pronta all'uso delle interazioni del mouse, che dovrebbe essere molto utile per realizzare una mappa interattiva.