基于pyqtgraph绘制大量矩形的交互流畅度优化问题

核心问题分析 #

你的代码目前卡顿的主要原因：

• boundingRect()实现错误，循环中不断覆盖self.xmin等变量，导致整个图形项的包围盒仅为最后一个矩形的范围，QGraphicsView无法正确进行视口裁剪，始终绘制所有千万级矩形。
• 预先生成包含所有矩形的QPicture，数据量过大，缩放平移时需重绘整个超大Picture，性能瓶颈明显。

针对性优化方案 #

1. 修复全局包围盒计算

先正确计算所有矩形的全局包围盒，让视图能准确判断哪些区域需要绘制：

def __init__(self, data, pen='w', brush=None):
    super().__init__(None)
    self.setCacheMode(QGraphicsItem.DeviceCoordinateCache)  # 改用设备坐标缓存更适合缩放场景
    self.pen = pg.mkPen(pen)
    self.brush = pg.mkBrush(brush) if brush else None
    self.data = data
    # 预计算所有矩形的xmin, ymin, xmax, ymax，并全局包围盒
    self.rects = []
    global_xmin = float('inf')
    global_ymin = float('inf')
    global_xmax = -float('inf')
    global_ymax = -float('inf')
    for rect in data:
        xmin = rect[:, 0].min()
        xmax = rect[:, 0].max()
        ymin = rect[:, 1].min()
        ymax = rect[:, 1].max()
        self.rects.append((xmin, ymin, xmax, ymax))
        # 更新全局包围盒
        if xmin < global_xmin:
            global_xmin = xmin
        if ymin < global_ymin:
            global_ymin = ymin
        if xmax > global_xmax:
            global_xmax = xmax
        if ymax > global_ymax:
            global_ymax = ymax
    self.global_bounds = QtCore.QRectF(global_xmin, global_ymin, global_xmax - global_xmin, global_ymax - global_ymin)

def boundingRect(self):
    return self.global_bounds

2. 视口裁剪：只绘制可见区域的矩形

重写paint()方法，根据当前视口范围过滤需要绘制的矩形，避免绘制不可见内容：

def paint(self, painter, option, widget):
    # 获取当前视口的可见范围（转换为场景坐标）
    view_rect = option.exposedRect
    # 只绘制与视口相交的矩形
    painter.setPen(self.pen)
    if self.brush:
        painter.setBrush(self.brush)
    for (xmin, ymin, xmax, ymax) in self.rects:
        rect = QtCore.QRectF(xmin, ymin, xmax - xmin, ymax - ymin)
        if view_rect.intersects(rect):
            painter.drawRect(rect)

注：如果千万级数据循环过滤仍慢，可以提前将矩形按空间网格分块（比如四叉树或网格索引），快速定位视口对应的块，减少遍历数量。

3. 层级细节（LOD）：根据缩放级别动态调整绘制数量

添加缩放级别判断，当视图缩放比例较小时（显示范围大），只绘制部分矩形或合并矩形；放大到一定比例后再绘制全部：

def paint(self, painter, option, widget):
    view_rect = option.exposedRect
    # 获取当前缩放比例（场景单位 / 设备像素）
    scale = painter.transform().m11()  # x轴缩放因子
    # 定义阈值：缩放比例大于0.5时绘制全部，否则只绘制10%的矩形（可根据实际调整）
    draw_all = scale > 0.5
    painter.setPen(self.pen)
    if self.brush:
        painter.setBrush(self.brush)
    count = 0
    for (xmin, ymin, xmax, ymax) in self.rects:
        rect = QtCore.QRectF(xmin, ymin, xmax - xmin, ymax - ymin)
        if view_rect.intersects(rect):
            if draw_all or count % 10 == 0:  # 缩放小时每10个画1个
                painter.drawRect(rect)
            count += 1

更高级的做法是提前生成不同层级的矩形聚合数据，比如低缩放级别时用合并后的大矩形代替多个小矩形，进一步减少绘制量。

4. 启用OpenGL加速

pyqtgraph支持OpenGL渲染，切换到GLViewWidget能大幅提升大量图形的绘制性能：

class Visualizer:
    def __init__(self):
        self.app = pg.mkQApp()
        # 改用GLViewWidget
        self.pw = pg.GLViewWidget()
        self.pw.setBackgroundColor('k')
        self.pw.setAspectLocked()

    # 后续需要适配GLRectItem，批量创建或使用GLMeshItem绘制矩形
    def plot(self, elements: list):
        rects_data = [Visualizer._bbox2coords(e.bbox()) for e in elements]
        # 批量创建GLRectItem（注意GL坐标系统可能需要调整）
        for rect in rects_data:
            xmin = rect[:,0].min()
            xmax = rect[:,0].max()
            ymin = rect[:,1].min()
            ymax = rect[:,1].max()
            rect_item = pg.GLRectItem(x=xmin, y=ymin, z=0, width=xmax-xmin, height=ymax-ymin)
            rect_item.setColor((1,1,1,1))
            self.pw.addItem(rect_item)
        self.pw.show()
        self.app.exec()

注意：GLViewWidget的坐标系统与PlotWidget略有不同，需要调整坐标转换逻辑。

5. 懒加载与空间索引

将矩形数据按空间分块存储（比如按网格划分区域），监听视图的viewChanged信号，当视口变化时，仅加载当前视口所在块的矩形数据，避免一次性加载千万级数据到内存：

class Visualizer:
    def __init__(self):
        self.app = pg.mkQApp()
        self.pw = pg.PlotWidget()
        self.pw.setAttribute(QtCore.Qt.WA_DeleteOnClose)
        self.vb = self.pw.getViewBox()
        self.vb.setAspectLocked()
        # 监听视图变化信号
        self.vb.sigRangeChanged.connect(self.update_visible_rects)
        self.current_items = []
        # 存储按网格分块的矩形数据
        self.grid_data = {}

    def preprocess_grid_data(self, elements):
        # 按100x100场景单位为一个网格划分数据
        grid = {}
        for e in elements:
            rect = Visualizer._bbox2coords(e.bbox())
            xmin = rect[:,0].min()
            xmax = rect[:,0].max()
            ymin = rect[:,1].min()
            ymax = rect[:,1].max()
            # 计算所属网格键
            grid_x = int(xmin // 100)
            grid_y = int(ymin // 100)
            key = (grid_x, grid_y)
            if key not in grid:
                grid[key] = []
            grid[key].append((xmin, ymin, xmax, ymax))
        return grid

    def update_visible_rects(self, viewbox, range):
        # 移除当前所有可见项
        for item in self.current_items:
            self.pw.removeItem(item)
        self.current_items.clear()
        # 获取当前视口范围
        x_range, y_range = range
        x_min, x_max = x_range
        y_min, y_max = y_range
        # 计算需要加载的网格
        start_grid_x = int(x_min // 100)
        end_grid_x = int(x_max // 100)
        start_grid_y = int(y_min // 100)
        end_grid_y = int(y_max // 100)
        # 加载对应网格的矩形
        pen = pg.mkPen('w')
        for grid_x in range(start_grid_x, end_grid_x+1):
            for grid_y in range(start_grid_y, end_grid_y+1):
                key = (grid_x, grid_y)
                if key in self.grid_data:
                    for rect in self.grid_data[key]:
                        xmin, ymin, xmax, ymax = rect
                        rect_item = pg.RectROI((xmin, ymin), (xmax-xmin, ymax-ymin), pen=pen, movable=False)
                        self.pw.addItem(rect_item)
                        self.current_items.append(rect_item)

    def plot(self, elements: list):
        self.grid_data = self.preprocess_grid_data(elements)
        # 初始化加载当前视图的矩形
        self.update_visible_rects(self.vb, self.vb.viewRange())
        self.pw.show()
        self.app.exec()

总结 #

优先修复boundingRect的错误，然后结合视口裁剪和LOD机制，能快速改善交互卡顿问题；若性能仍不满足，启用OpenGL或空间索引懒加载是更彻底的解决方案。

内容的提问来源于stack exchange，提问作者Matan Cohen