Python 如何绘制10000+；二维图形对象快速？

我需要在一个小部件上绘制数万个，将来可能是数十万个简单的2d对象（圆、矩形、一些填充、标记…）

在同一个程序中，我需要GUI小部件（按钮、文本输入、复选框）

<>我用C++和Python尝试了GTK、QT和SDL。第一个结果是可以预料到的：C++和Python显示了相同的性能，因为它们在后端调用相同的C或C++例程。 第二个结果是，没有一个图书馆有很大的不同。数量：22500个矩形（150*150）需要大约一秒钟来更新。由于（a）新数据（即更多的矩形）和（b）用户交互（即缩放、平移等），将不断进行升级，因此第二次升级是漫长的

什么是更快的方法。小的例子是非常感谢。Python和C++是很好的。其他库应易于访问并可在Linux上安装

也许我只是做错了

另外，我不会发布我的测试代码，因为我不想让答案有偏差。我不希望我的代码被更正，我想用最快的方式来做

编辑：

好的，我将添加我的gtk测试：

#!/bin/env python2

import gtk
import gobject
import gtk.gdk

class GraphWidget(gtk.DrawingArea):
    __gsignals__ = {
        'expose-event': 'override',
        'clicked' : (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_STRING, gtk.gdk.Event))
        }

    def __init__(self,window):
        gtk.DrawingArea.__init__(self)
        #self.win = window
        self.zoom_ratio = 1.0
        self.dx = 40
        self.dy = 40

    def do_expose_event(self, event):
        cr = self.window.cairo_create()
        cr.set_source_rgba(1.0, 0.9, 0.8, 1.0)
        cr.paint()

        cr.translate(self.dx, self.dy)
        cr.scale(self.zoom_ratio,self.zoom_ratio)

        self.draw(cr)

    def draw(self, cr):
        n = 150
        cr.set_source_rgba(0.,1.,1.,1.0)
        for i in range(n):
            for j in range(n):
                cr.arc(i*30, j*30, 10, 0, 6.2832)

                cr.close_path()
                cr.fill()

        cr.set_source_rgba(0.,0.,1.,1.0)
        for i in range(n):
            for j in range(n):
                cr.arc(i*30, j*30, 10, 0, 6.2832)
                cr.move_to(i*30-10, j*30)
                cr.show_text("hu")
                cr.stroke()

    def on_zoom(self, zoom_factor):
        self.zoom_ratio *= zoom_factor
        self.queue_draw()

    def on_translate(self,dx,dy):
        self.dx += dx
        self.dy += dy
        self.queue_draw()

class TestWindow(gtk.Window):
    def __init__(self):
        gtk.Window.__init__(self)

        self.widget = GraphWidget(self)

        self.add(self.widget)

        self.show_all()

        # connect key press events

        self.connect('key-press-event', self.on_key_press_event)
        self.connect('destroy', gtk.main_quit)

        self.widget.queue_draw()

    def on_key_press_event(self, widget, event):

        if event.keyval == gtk.keysyms.space and not (event.state & gtk.gdk.CONTROL_MASK):
            self.on_run(widget)
            return True
        elif event.keyval == gtk.keysyms.r:
            self.on_refresh(widget)
            return True
        elif event.keyval == gtk.keysyms.Left:
            self.widget.on_translate(-100, 0)
        elif event.keyval == gtk.keysyms.Right:
            self.widget.on_translate(100, 0)
        elif event.keyval == gtk.keysyms.Up:
            self.widget.on_translate(0, -100)
        elif event.keyval == gtk.keysyms.Down:
            self.widget.on_translate(0, 100)
        elif event.keyval == gtk.keysyms.Page_Down:
            self.widget.on_zoom(0.7)
        elif event.keyval == gtk.keysyms.Page_Up:
            self.widget.on_zoom(1.3)

if __name__ == '__main__':
    win = TestWindow()
    gtk.main()

SDL实验：

#!/usr/bin/env python

import sdl2
import sdl2.ext as sdl2ext

dx = 0
dy = 0
zoom_factor = 1.
n_objects = 150

sdl2ext.init()

window = sdl2ext.Window('hallo', 
                        size=(800, 600), 
                        flags= sdl2.SDL_WINDOW_RESIZABLE)
window.show()

renderer = sdl2ext.RenderContext(window)
renderer.color = sdl2ext.Color(255,155,25)

def draw():
    renderer.clear()
    for i in xrange(n_objects):
        for j in xrange(n_objects):
            renderer.fill([int((i*30+dx)*zoom_factor), 
                           int((j*30+dy)*zoom_factor), 
                           int(20*zoom_factor), 
                           int(20*zoom_factor)], 
                          sdl2ext.Color(255,25,55))
            renderer.draw_rect([int((i*30+dx)*zoom_factor), 
                                int((j*30+dy)*zoom_factor), 
                                int(20*zoom_factor), 
                                int(20*zoom_factor)], 
                               sdl2ext.Color(255,255,255))

    renderer.present()

draw()

running = True
while running:
    for e in sdl2ext.get_events():
        if e.type == sdl2.SDL_QUIT:
            running = False
            break
        if e.type == sdl2.SDL_KEYDOWN:
            if e.key.keysym.sym == sdl2.SDLK_ESCAPE:
                running = False
                break
            elif e.key.keysym.sym == sdl2.SDLK_RIGHT:
                dx += 50
                draw()
            elif e.key.keysym.sym == sdl2.SDLK_LEFT:
                dx -= 50
                draw()
            elif e.key.keysym.sym == sdl2.SDLK_UP:
                dy += 50
                draw()
            elif e.key.keysym.sym == sdl2.SDLK_DOWN:
                dy -= 50
                draw()
            elif e.key.keysym.sym == sdl2.SDLK_PAGEUP:
                zoom_factor *= 1.2
                draw()
            elif e.key.keysym.sym == sdl2.SDLK_PAGEDOWN:
                zoom_factor /= 1.2
                draw()

---

Qt测试是由我的同事完成的，所以我现在没有代码…

看起来您正在绘制每个对象，不管它是否在可视区域中。您是否考虑过存储每个对象的位置数组，然后在绘制之前测试每个对象以确定它是否位于屏幕的可视区域

我做了一个快速而肮脏的测试来尝试它（我敢肯定，代码可能会更干净），它的响应性更高，只绘制可见的图形：

首先，我创建了一些变量来确定可见边界（您将在每次移动和缩放、窗口大小调整等时更新边界）：

在draw事件中，我将在绘制之前检查位置是否在边界内。我还整合了您的循环以提高效率，您可以在同一迭代中绘制和添加文本。即使是使用

n=50000

进行测试，也比以前的测试更具响应性

def draw(self, cr):
    n = 150

    for i in range(n):
        if min(boundX) < i * 30 < max(boundX):
            for j in range(n):
                if min(boundY) < j * 30 < max(boundY):
                    cr.set_source_rgba(0.,1.,1.,1.0)
                    cr.arc(i*30, j*30, 10, 0, 6.2832)

                    cr.close_path()
                    cr.fill()

                    cr.set_source_rgba(0.,0.,1.,1.0)
                    cr.arc(i*30, j*30, 10, 0, 6.2832)
                    cr.move_to(i*30-10, j*30)
                    cr.show_text("hu")
                    cr.stroke()

---

你想让我们从头开始为你编码？如果你包含了一些代码，你得到答案的可能性会显著增加。你考虑过OpenGL吗？@ KRISTANDUSSKE：是的，但是还没有尝试过。你可能受限于硬件的缺乏。@ Duffic：程序应该在工作站和笔记本电脑上运行。

def draw(self, cr):
    n = 150

    for i in range(n):
        if min(boundX) < i * 30 < max(boundX):
            for j in range(n):
                if min(boundY) < j * 30 < max(boundY):
                    cr.set_source_rgba(0.,1.,1.,1.0)
                    cr.arc(i*30, j*30, 10, 0, 6.2832)

                    cr.close_path()
                    cr.fill()

                    cr.set_source_rgba(0.,0.,1.,1.0)
                    cr.arc(i*30, j*30, 10, 0, 6.2832)
                    cr.move_to(i*30-10, j*30)
                    cr.show_text("hu")
                    cr.stroke()

def on_key_press_event(self, widget, event):

    if event.keyval == gtk.keysyms.space and not (event.state & gtk.gdk.CONTROL_MASK):
        self.on_run(widget)
        return True
    elif event.keyval == gtk.keysyms.r:
        self.on_refresh(widget)
        return True
    elif event.keyval == gtk.keysyms.Left:
        boundX[0] += 100
        boundX[1] += 100
        self.widget.on_translate(-100, 0)
    elif event.keyval == gtk.keysyms.Right:
        boundX[0] -= 100
        boundX[1] -= 100
        self.widget.on_translate(100, 0)
    elif event.keyval == gtk.keysyms.Up:
        boundY[0] += 100
        boundY[1] += 100
        self.widget.on_translate(0, -100)
    elif event.keyval == gtk.keysyms.Down:
        boundY[0] -= 100
        boundY[1] -= 100
        self.widget.on_translate(0, 100)
    elif event.keyval == gtk.keysyms.Page_Down:
        self.widget.on_zoom(0.7)
    elif event.keyval == gtk.keysyms.Page_Up:
        self.widget.on_zoom(1.3)