Peinture sans paintEvent

Question

J'ai une interface graphique avec un widget de toile. J'ai donc besoin de sentir cette toile avec des points. Le problème est que j'ai besoin de créer un processus séparé pour exécuter l'interface graphique parce que les (x,y) pour les points sont générés à partir d'une autre classe. Donc, je ne peux pas comprendre comment puis-je tirer ce point de l'extérieur de la paintEvent ou comment puis-je (si nécessaire) déclencher le paintEvent à nouveau .-.

modifier:

je dois exécuter un algorithme génétique et obtenir le résultat de remise en forme de chaque génération et la représenter sur la zone de la toile comme un graphique en ligne! Mais j'ai besoin de tracer/dessiner les résultats à la volée.

Donc, chaque fois que l'AG termine un cycle de condition physique, je dois envoyer ces résultats à la zone de canevas.

J'ai cet exemple de code de http://zetcode.com/tutorials/pyqt4/drawing/ et modifié un peu!

#!/usr/bin/python 
# -*- coding: utf-8 -*- 

""" 
ZetCode PyQt4 tutorial 

In the example, we draw randomly 1000 red points 
on the window. 

author: Jan Bodnar 
website: zetcode.com 
last edited: September 2011 
""" 

import sys, random , time 
from multiprocessing import Process 
from PyQt4 import QtGui, QtCore 

class Example(QtGui.QWidget): 

    def status(self , text): 

     print '[GUI] ', text 

    def __init__(self): 

     super(Example, self).__init__() 

     self.initUI() 

    def initUI(self):  

     self.status('init ui') 

     self.setGeometry(300, 300, 280, 170) 
     self.setWindowTitle('Points') 

     self.status('showing widgets') 

     self.show() 

    def paintEvent(self, e): 

     self.status('playing with types : '+str(e)) 

     self.status('paint event was called') 

     qp = QtGui.QPainter() 
     qp.begin(self) 

     #self.drawPoints(qp) 

     #self.drawRectangles(qp) 

     self.draw_all_axis(qp, 300) 

     self.draw_dot(20, 20) 

     qp.end() 

    def draw_all_axis(self , qp , length): 

     self.draw_x_axis(qp , length) 
     self.draw_y_axis(qp , length) 

    def draw_x_axis(self , qp , length): 

     color = QtGui.QColor(0, 0, 0) 
     color.setNamedColor('#d49EBD8') 
     qp.setPen(color) 

     qp.setBrush(QtGui.QColor(73, 235, 216)) 
     qp.drawLine(10 , length , length , length) 

    def draw_y_axis(self , qp , length): 

     color = QtGui.QColor(0, 0, 0) 
     color.setNamedColor('#d49EBD8') 
     qp.setPen(color) 

     qp.setBrush(QtGui.QColor(73, 235, 216)) 
     qp.drawLine(10, 10, 10, length) 

    def draw_dot(self , x , y): 

     qp = QtGui.QPainter() 
     qp.begin(self) 

     color = QtGui.QColor(0, 0, 0) 
     color.setNamedColor('#d4d4d4') 
     qp.setPen(color) 

     qp.setBrush(QtGui.QColor(200, 0, 0)) 
     qp.drawRect(x , y , x + 0.25, y + 0.25) 

    def drawPoints(self, qp): 

     qp.setPen(QtCore.Qt.red) 
     size = self.size() 

     for i in range(1000): 

      x = random.randint(1, size.width()-1) 

      y = random.randint(1, size.height()-1) 

      qp.drawPoint(x, y)  

    def drawRectangles(self, qp): 

     color = QtGui.QColor(0, 0, 0) 
     color.setNamedColor('#d4d4d4') 
     qp.setPen(color) 

     qp.setBrush(QtGui.QColor(200, 0, 0)) 
     qp.drawRect(10, 15, 90, 60) 

     qp.setBrush(QtGui.QColor(255, 80, 0, 160)) 
     qp.drawRect(130, 15, 90, 60) 

     qp.setBrush(QtGui.QColor(25, 0, 90, 200)) 
     qp.drawRect(250, 15, 90, 60)  

def external_dot_drawer(main_window): 


    for i in range(20, 100): 

     main_window.draw_dot(i , i) 


def main(): 

    print 'launching main window obj as app' 
    sys.exit(app.exec_()) 
    print 'done!' 

if __name__ == '__main__': 

    print 'loading application abstraction' 
    app = QtGui.QApplication(sys.argv) 

    print 'building main window obj' 
    gui = Example() 

    print 'preparing to launch window as a separated process' 
    p_main = Process(name='window' , target=main , args=() ) 

    print 'running new process' 
    p_main.start() 

    time.sleep(3) 

    print 'trying to triggering paintEvent' 
    p_external_dot_drawer = Process(name='extern_dot_drawer' , target=external_dot_drawer , args=(gui)) 

Answer 1

La méthode correcte pour planifier un appel à paintEvent est avec QWidget.update().

Je vous recommande également d'utiliser l'une des bibliothèques de traçage python existantes plutôt que d'écrire les vôtres. PyQtGraph a de bonnes fonctionnalités multi-process:

import pyqtgraph as pg 
app = pg.QtGui.QApplication([]) 
import pyqtgraph.multiprocess as mp 

## start child process 
proc = mp.QtProcess() 

## import pyqtgraph in the child process, create a plot window there 
remotepg = proc._import('pyqtgraph') 
win = remotepg.plot() 

## create a scatter plot 
plot = win.plot([1,4,2,3], [4,6,3,4], pen=None, symbol='o') 

## ..after some processing, update the plot data 
plot.setData(x=[1,2,3,4], y=[5,7,2,3])