PyQtGraph科学可视化：PlotWidget原理与性能优化实战

1. PyQtGraph与PlotWidget的定位解析

PyQtGraph作为Python生态中专注于科学计算可视化的图形库，其核心优势在于处理大规模数据时的实时渲染性能。与传统Matplotlib相比，PyQtGraph底层基于Qt的GraphicsView框架构建，这使得它在动态数据展示方面具有天然优势。PlotWidget作为其中最常用的可视化组件，实际上是一个高度封装的图形视图容器，内部整合了PlotItem、ViewBox和AxisItem等核心元素。

在实际工程中，PlotWidget的典型应用场景包括：

• 实时传感器数据的波形展示（如ECG医疗设备监测）
• 高频金融交易数据的动态更新
• 科学实验中的参数变化趋势跟踪
• 工业控制系统的状态监控界面

其架构设计采用了Qt的信号槽机制与Python的高效数值计算结合的模式。当数据量达到10万级点时，PyQtGraph仍能保持30fps以上的渲染帧率，这是通过以下技术实现的：

1. 使用OpenGL加速的图形管线
2. 针对NumPy数组的特殊优化
3. 智能的重绘区域计算算法

2. PlotWidget的核心功能拆解

2.1 基础绘图功能实现

创建基本绘图只需几行代码：

python复制import pyqtgraph as pg
from pyqtgraph.Qt import QtGui

app = QtGui.QApplication([])
pw = pg.PlotWidget(title="基础示例")
pw.plot([1,2,3,4,5], [5,3,7,2,9], pen='r')
pw.show()
app.exec_()

关键参数说明：

• pen：控制线条样式，可接受Qt的QPen对象或简写字符串：
  • 'r'：红色实线
  • 'g--'：绿色虚线
  • 'b:': 蓝色点线
  • 自定义：pg.mkPen(color='#FF00FF', width=2, style=QtCore.Qt.DashLine)

2.2 多图层叠加与坐标轴控制

PlotWidget支持在同一视图中叠加多个数据层：

python复制pw = pg.PlotWidget()
curve1 = pw.plot(x, y1, pen='r', name="温度")
curve2 = pw.plot(x, y2, pen='b', name="湿度")

坐标轴的高级配置方法：

python复制pw.setLabel('left', '幅度值', units='V')
pw.setLabel('bottom', '时间', units='s')
pw.setXRange(0, 100)  # 固定显示范围
pw.setLogMode(x=False, y=True)  # Y轴对数坐标

2.3 交互功能深度定制

通过ViewBox实现的交互功能：

python复制vb = pw.getViewBox()
vb.setMouseMode(vb.RectMode)  # 矩形缩放模式
vb.setAspectLocked(lock=True, ratio=1)  # 锁定纵横比

右键菜单的自定义扩展：

python复制def on_menu(pos):
    menu = QtGui.QMenu()
    export_action = menu.addAction("导出数据")
    action = menu.exec_(pw.mapToGlobal(pos))
    if action == export_action:
        np.savetxt('data.csv', curve1.getData(), delimiter=',')

pw.scene().contextMenu = on_menu

3. 性能优化实战技巧

3.1 大数据量渲染方案

当处理超过1M数据点时，常规绘图方式会导致性能急剧下降。此时应采用以下策略：

分段显示技术：

python复制pw.setDownsampling(auto=True, mode='peak')
pw.setClipToView(True)

GPU加速配置：

python复制pg.setConfigOption('useOpenGL', True)
pg.setConfigOption('enableExperimental', True)  # 启用CUDA加速

3.2 动态数据更新优化

实时数据展示的最佳实践：

python复制data = np.empty(shape=(2,100000))
ptr = 0
def update():
    global ptr
    data[:,ptr] = np.random.normal(size=2)
    ptr = (ptr + 1) % data.shape[1]
    curve.setData(data[:,:ptr])
timer = QtCore.QTimer()
timer.timeout.connect(update)
timer.start(50)  # 20Hz刷新率

内存循环缓冲技术：

python复制class CircularBuffer:
    def __init__(self, size):
        self.buffer = np.zeros(size)
        self.index = 0
        
    def add(self, data):
        self.buffer[self.index] = data
        self.index = (self.index + 1) % len(self.buffer)
        
    def get(self):
        return np.roll(self.buffer, -self.index)

4. 企业级应用中的问题排查

4.1 典型异常场景处理

线程安全问题的解决方案：

python复制class DataThread(QtCore.QThread):
    newData = QtCore.Signal(object)
    def run(self):
        while True:
            data = acquire_data()  # 从硬件获取数据
            self.newData.emit(data)

thread = DataThread()
def handle_data(data):
    curve.setData(data, _callSync='offload')  # 异步更新
thread.newData.connect(handle_data)
thread.start()

内存泄漏检测方法：

python复制app = QtGui.QApplication.instance()
if app is None:
    app = QtGui.QApplication([])
    
def memory_monitor():
    import psutil
    process = psutil.Process()
    print(f"Memory usage: {process.memory_info().rss/1024/1024:.2f}MB")

timer = QtCore.QTimer()
timer.timeout.connect(memory_monitor)
timer.start(5000)

4.2 跨平台兼容性问题

Linux系统下的显示异常通常需要：

bash复制export QT_XCB_GL_INTEGRATION=xcb_egl

高DPI屏幕的适配方案：

python复制QtCore.QCoreApplication.setAttribute(QtCore.Qt.AA_EnableHighDpiScaling)
QtCore.QCoreApplication.setAttribute(QtCore.Qt.AA_UseHighDpiPixmaps)

在嵌入式设备上的部署注意事项：

1. 使用EGLFS平台插件
2. 禁用动画效果：pw.setAnimationEnabled(False)
3. 简化界面元素：pw.showAxis('left', False)

5. 高级可视化功能扩展

5.1 自定义图形项集成

创建带箭头的标注线：

python复制class ArrowItem(pg.GraphicsObject):
    def __init__(self, start, end):
        super().__init__()
        self.start = start
        self.end = end
        self.generatePicture()
        
    def generatePicture(self):
        self.picture = QtGui.QPicture()
        p = QtGui.QPainter(self.picture)
        p.setPen(pg.mkPen('y', width=2))
        p.drawLine(QtCore.QPointF(*self.start), QtCore.QPointF(*self.end))
        # 绘制箭头头部
        angle = np.arctan2(self.end[1]-self.start[1], self.end[0]-self.start[0])
        arrow_size = 10
        p.drawLine(
            QtCore.QPointF(*self.end),
            QtCore.QPointF(
                self.end[0] - arrow_size * np.cos(angle + np.pi/6),
                self.end[1] - arrow_size * np.sin(angle + np.pi/6)
            )
        )
        p.end()
        
    def paint(self, p, *args):
        p.drawPicture(0, 0, self.picture)
        
    def boundingRect(self):
        return QtCore.QRectF(self.picture.boundingRect())

arrow = ArrowItem((0,0), (5,5))
pw.addItem(arrow)

5.2 专业领域图表实现

医学EEG多通道显示：

python复制n_channels = 32
pw = pg.PlotWidget()
for i in range(n_channels):
    curve = pw.plot(offset=i*0.5)
    curve.setData(eeg_data[i])
pw.getViewBox().setYRange(0, n_channels*0.5)

金融K线图的完整实现：

python复制class CandlestickItem(pg.GraphicsObject):
    def __init__(self, data):
        self.data = data  # 需包含OHLC数据
        self.generatePicture()
        
    def generatePicture(self):
        self.picture = QtGui.QPicture()
        p = QtGui.QPainter(self.picture)
        w = 0.4
        for (t, open, high, low, close) in self.data:
            # 绘制影线
            p.setPen(pg.mkPen('k'))
            p.drawLine(QtCore.QPointF(t, low), QtCore.QPointF(t, high))
            # 绘制实体
            if open > close:
                p.setBrush(pg.mkBrush('r'))
            else:
                p.setBrush(pg.mkBrush('g'))
            p.drawRect(QtCore.QRectF(t-w, open, w*2, close-open))
        p.end()
        
    def paint(self, p, *args):
        p.drawPicture(0, 0, self.picture)
        
    def boundingRect(self):
        return QtCore.QRectF(self.picture.boundingRect())

kline = CandlestickItem(stock_data)
pw.addItem(kline)

6. 实际项目中的架构设计

6.1 MVC模式实现

模型层（数据处理）：

python复制class DataModel(QtCore.QObject):
    dataUpdated = QtCore.Signal(object)
    
    def __init__(self):
        super().__init__()
        self._data = np.random.normal(size=100)
        
    def update(self):
        self._data = np.roll(self._data, -1)
        self._data[-1] = np.random.normal()
        self.dataUpdated.emit(self._data)

视图层（PlotWidget封装）：

python复制class PlotView(pg.PlotWidget):
    def __init__(self):
        super().__init__()
        self.curve = self.plot(pen='y')
        
    def update_view(self, data):
        self.curve.setData(data)

控制器（业务逻辑）：

python复制class MainController:
    def __init__(self):
        self.model = DataModel()
        self.view = PlotView()
        self.model.dataUpdated.connect(self.view.update_view)
        self.timer = QtCore.QTimer()
        self.timer.timeout.connect(self.model.update)
        self.timer.start(100)

6.2 多视图同步方案

跨PlotWidget的视图联动：

python复制def create_synced_views():
    views = [pg.PlotWidget() for _ in range(3)]
    for v in views:
        v.setXLink(views[0])
        v.setYLink(views[0])
    return views

共享ViewBox的实现：

python复制vb = pg.ViewBox()
pw1 = pg.PlotWidget(viewBox=vb)
pw2 = pg.PlotWidget(viewBox=vb)

7. 性能基准测试数据

通过实际测试对比不同数据量下的帧率表现（测试环境：Intel i7-11800H, RTX 3060）：

优化模式配置参数：

python复制pg.setConfigOptions(
    useOpenGL=True,
    enableExperimental=True,
    leftButtonPan=False
)
pw.setDownsampling(auto=True, mode='subsample')

8. 样式主题深度定制

8.1 全局样式配置

创建暗黑主题：

python复制pg.setConfigOption('background', 'k')
pg.setConfigOption('foreground', 'w')
pg.setConfigOption('antialias', True)

自定义颜色主题：

python复制palette = {
    'background': '#2E3440',
    'foreground': '#D8DEE9',
    'axis': '#4C566A',
    'text': '#ECEFF4'
}
pw.setBackground(palette['background'])
pw.getAxis('left').setPen(palette['axis'])
pw.getAxis('bottom').setPen(palette['axis'])

8.2 动态主题切换

实现运行时主题切换：

python复制themes = {
    'light': {
        'bg': (240,240,240),
        'text': (0,0,0)
    },
    'dark': {
        'bg': (30,30,30),
        'text': (255,255,255)
    }
}

def apply_theme(name):
    theme = themes[name]
    pw.setBackground(theme['bg'])
    for axis in ['left', 'bottom']:
        pw.getAxis(axis).setPen(theme['text'])
        pw.getAxis(axis).setTextPen(theme['text'])

9. 与PyQt/PySide的深度集成

9.1 嵌入主窗口布局

在复杂界面中的集成示例：

python复制class MainWindow(QtGui.QMainWindow):
    def __init__(self):
        super().__init__()
        
        # 创建中心Widget和布局
        central = QtGui.QWidget()
        layout = QtGui.QHBoxLayout()
        central.setLayout(layout)
        
        # 左侧控制面板
        control_panel = QtGui.QWidget()
        control_layout = QtGui.QVBoxLayout()
        control_panel.setLayout(control_layout)
        
        # 右侧绘图区域
        self.plot_widget = pg.PlotWidget()
        
        # 组装界面
        layout.addWidget(control_panel, stretch=1)
        layout.addWidget(self.plot_widget, stretch=4)
        
        self.setCentralWidget(central)

9.2 信号槽高级应用

实现界面交互联动：

python复制class InteractivePlot(QtGui.QWidget):
    def __init__(self):
        super().__init__()
        
        # 创建滑块控件
        self.slider = QtGui.QSlider(QtCore.Qt.Horizontal)
        self.slider.setRange(1, 100)
        
        # 创建绘图部件
        self.plot = pg.PlotWidget()
        
        # 布局
        layout = QtGui.QVBoxLayout()
        layout.addWidget(self.plot)
        layout.addWidget(self.slider)
        self.setLayout(layout)
        
        # 连接信号
        self.slider.valueChanged.connect(self.update_plot)
        
    def update_plot(self, value):
        x = np.linspace(0, 10, 1000)
        y = np.sin(x * value / 10)
        self.plot.plot(x, y, clear=True)

10. 扩展生态与插件开发

10.1 常用插件介绍

内置的ROI插件使用示例：

python复制roi = pg.RectROI([0,0], [10,10])
pw.addItem(roi)

def roi_changed():
    print("ROI区域变化:", roi.getArrayRegion(data, img))

roi.sigRegionChanged.connect(roi_changed)

10.2 自定义插件开发

开发一个简单的数据标注插件：

python复制class AnnotationPlugin:
    def __init__(self, plot_widget):
        self.pw = plot_widget
        self.annotations = []
        self.current_text = None
        
        # 连接鼠标事件
        self.pw.scene().sigMouseClicked.connect(self.on_click)
        
    def on_click(self, event):
        if event.button() == QtCore.Qt.RightButton:
            pos = self.pw.getViewBox().mapSceneToView(event.scenePos())
            self.current_text = pg.TextItem(text="标注", color='w')
            self.current_text.setPos(pos.x(), pos.y())
            self.pw.addItem(self.current_text)
            self.annotations.append(self.current_text)
            
    def clear(self):
        for item in self.annotations:
            self.pw.removeItem(item)
        self.annotations = []

plugin = AnnotationPlugin(pw)

11. 调试与性能分析技巧

11.1 渲染问题诊断

检查渲染时间的实用方法：

python复制class ProfilerPlot(pg.PlotWidget):
    def paintEvent(self, event):
        start = time.perf_counter()
        super().paintEvent(event)
        elapsed = (time.perf_counter() - start) * 1000
        print(f"渲染耗时: {elapsed:.2f}ms")

11.2 内存使用分析

使用tracemalloc跟踪内存分配：

python复制import tracemalloc

tracemalloc.start()

# ...执行绘图操作...

snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')
for stat in top_stats[:10]:
    print(stat)

12. 跨版本兼容性处理

12.1 API变更适配

处理0.12.x到1.0.x的迁移问题：

python复制try:
    # 新版本API
    pw.setAntialiasing(True)
except AttributeError:
    # 旧版本回退
    pw.setRenderHints(QtGui.QPainter.Antialiasing)

12.2 多版本共存方案

使用版本隔离环境：

bash复制# 创建专用环境
conda create -n pg_legacy python=3.6 pyqtgraph=0.12
conda create -n pg_latest python=3.9 pyqtgraph=1.0

13. 教育领域应用实例

13.1 物理实验模拟

弹簧振子动态演示：

python复制class HarmonicOscillator:
    def __init__(self, plot_widget):
        self.pw = plot_widget
        self.curve = self.pw.plot(pen='y')
        self.t = 0
        self.data = np.zeros(100)
        
        self.timer = QtCore.QTimer()
        self.timer.timeout.connect(self.update)
        self.timer.start(50)
        
    def update(self):
        self.data = np.roll(self.data, -1)
        self.data[-1] = np.sin(self.t)
        self.curve.setData(self.data)
        self.t += 0.1

osc = HarmonicOscillator(pw)

13.2 数学函数可视化

交互式函数探索器：

python复制class FunctionExplorer:
    def __init__(self):
        self.app = QtGui.QApplication([])
        self.win = QtGui.QWidget()
        layout = QtGui.QVBoxLayout()
        
        # 函数选择
        self.func_selector = QtGui.QComboBox()
        self.func_selector.addItems(['sin', 'cos', 'tan', 'exp'])
        
        # 参数控制
        self.param_slider = QtGui.QSlider(QtCore.Qt.Horizontal)
        self.param_slider.setRange(1, 100)
        
        # 绘图区域
        self.plot = pg.PlotWidget()
        
        # 信号连接
        self.func_selector.currentTextChanged.connect(self.update)
        self.param_slider.valueChanged.connect(self.update)
        
        # 布局
        layout.addWidget(self.func_selector)
        layout.addWidget(self.param_slider)
        layout.addWidget(self.plot)
        self.win.setLayout(layout)
        
    def update(self):
        func_name = self.func_selector.currentText()
        param = self.param_slider.value() / 10
        x = np.linspace(-10, 10, 1000)
        y = getattr(np, func_name)(x * param)
        self.plot.plot(x, y, clear=True)
        
    def run(self):
        self.win.show()
        self.app.exec_()

explorer = FunctionExplorer()
explorer.run()

14. 工业自动化集成案例

14.1 PLC数据监控

OPC UA数据采集集成：

python复制from opcua import Client

class PLCMonitor:
    def __init__(self, plot_widget):
        self.pw = plot_widget
        self.curve = self.pw.plot(pen='g')
        self.data = np.zeros(200)
        
        # OPC UA连接
        self.client = Client("opc.tcp://plc_address:4840")
        self.client.connect()
        self.node = self.client.get_node("ns=2;s=PLC1.AnalogInput1")
        
        # 定时器
        self.timer = QtCore.QTimer()
        self.timer.timeout.connect(self.update)
        self.timer.start(100)
        
    def update(self):
        value = self.node.get_value()
        self.data = np.roll(self.data, -1)
        self.data[-1] = value
        self.curve.setData(self.data)
        
    def close(self):
        self.timer.stop()
        self.client.disconnect()

monitor = PLCMonitor(pw)

14.2 异常检测算法集成

实时峰值检测实现：

python复制class PeakDetector:
    def __init__(self, plot_widget):
        self.pw = plot_widget
        self.data_curve = self.pw.plot(pen='b')
        self.peak_curve = self.pw.plot(pen='r', symbol='o', symbolSize=10)
        self.raw_data = np.zeros(500)
        self.peaks = []
        
    def update(self, new_value):
        self.raw_data = np.roll(self.raw_data, -1)
        self.raw_data[-1] = new_value
        
        # 简单峰值检测算法
        avg = np.mean(self.raw_data[-50:])
        std = np.std(self.raw_data[-50:])
        if new_value > avg + 3*std:
            self.peaks.append((len(self.raw_data)-1, new_value))
            
        # 更新曲线
        self.data_curve.setData(self.raw_data)
        if self.peaks:
            x, y = zip(*self.peaks[-10:])
            self.peak_curve.setData(x, y)

15. 移动端适配方案

15.1 触摸交互优化

针对触摸屏的交互配置：

python复制pw.getViewBox().setMouseEnabled(x=False, y=False)  # 禁用默认平移
pw.getViewBox().setTouchEnabled(True)  # 启用触摸事件

# 添加缩放手势
from PyQt5.QtWidgets import QGestureRecognizer
pinch = QtGui.QPinchGesture()
pw.grabGesture(QtCore.Qt.PinchGesture)

15.2 响应式布局设计

自适应屏幕尺寸的方案：

python复制class ResponsivePlot(QtGui.QWidget):
    def __init__(self):
        super().__init__()
        self.plot = pg.PlotWidget()
        layout = QtGui.QVBoxLayout()
        layout.addWidget(self.plot)
        self.setLayout(layout)
        
    def resizeEvent(self, event):
        # 根据窗口大小调整字体
        size = min(self.width(), self.height()) / 30
        font = QtGui.QFont()
        font.setPixelSize(int(size))
        self.plot.getAxis('left').setTickFont(font)
        self.plot.getAxis('bottom').setTickFont(font)
        super().resizeEvent(event)

16. 打印与导出功能

16.1 高质量输出生成

生成打印用PDF：

python复制def export_pdf(filename):
    exporter = pg.exporters.PDFExporter(pw.plotItem)
    exporter.export(filename)

配置打印参数：

python复制exporter = pg.exporters.PrintExporter(pw.plotItem)
exporter.parameters()['width'] = 210  # A4宽度(mm)
exporter.parameters()['height'] = 297  # A4高度(mm)
exporter.parameters()['dpi'] = 300  # 打印分辨率

16.2 数据导出方案

导出CSV数据：

python复制def export_data(filename):
    curves = pw.plotItem.curves
    with open(filename, 'w') as f:
        for curve in curves:
            x, y = curve.getData()
            np.savetxt(f, np.column_stack((x,y)), delimiter=',')

导出为可交互HTML：

python复制def export_html(filename):
    exporter = pg.exporters.HTMLExporter(pw.plotItem)
    exporter.export(filename)

17. 测试驱动开发实践

17.1 可视化测试框架

基于pytest的自动化测试：

python复制def test_plot_rendering(qtbot):
    pw = pg.PlotWidget()
    qtbot.addWidget(pw)
    
    # 验证初始状态
    assert len(pw.plotItem.curves) == 0
    
    # 执行绘图操作
    curve = pw.plot([1,2,3], [4,5,6])
    
    # 验证结果
    assert len(pw.plotItem.curves) == 1
    x, y = curve.getData()
    assert np.array_equal(x, np.array([1,2,3]))

17.2 性能回归测试

绘制时间变化监控：

python复制class PerformanceMonitor:
    def __init__(self, plot_widget):
        self.pw = plot_widget
        self.times = []
        self.curve = self.pw.plot(pen='m')
        
    def measure(self, func, *args):
        start = time.perf_counter()
        result = func(*args)
        elapsed = time.perf_counter() - start
        self.times.append(elapsed)
        if len(self.times) > 100:
            self.times.pop(0)
        self.curve.setData(self.times)
        return result

monitor = PerformanceMonitor(pw)
monitor.measure(lambda: pw.plot(np.random.rand(1000000)))

18. 三维可视化扩展

18.1 3D绘图基础

使用GLViewWidget实现3D可视化：

python复制from pyqtgraph.opengl import GLViewWidget, GLMeshItem

app = QtGui.QApplication([])
view = GLViewWidget()
view.show()

# 创建三维网格
vertices = np.array([
    [0,0,0], [1,0,0], [1,1,0], [0,1,0],
    [0,0,1], [1,0,1], [1,1,1], [0,1,1]
])
faces = np.array([
    [0,1,2], [0,2,3], [4,5,6], [4,6,7],
    [0,1,5], [0,5,4], [1,2,6], [1,6,5],
    [2,3,7], [2,7,6], [3,0,4], [3,4,7]
])
mesh = GLMeshItem(vertexes=vertices, faces=faces, color=(0,1,0,1))
view.addItem(mesh)
app.exec_()

18.2 与PlotWidget的联动

实现2D与3D视图同步：

python复制class LinkedViews:
    def __init__(self):
        self.app = QtGui.QApplication([])
        
        # 创建2D视图
        self.plot2d = pg.PlotWidget()
        
        # 创建3D视图
        self.view3d = GLViewWidget()
        
        # 布局
        self.win = QtGui.QWidget()
        layout = QtGui.QHBoxLayout()
        layout.addWidget(self.plot2d)
        layout.addWidget(self.view3d)
        self.win.setLayout(layout)
        
        # 数据
        self.x = np.linspace(-10, 10, 100)
        self.y = np.sin(self.x)
        self.z = np.cos(self.x)
        
        # 初始化视图
        self.plot2d.plot(self.x, self.y)
        points = np.column_stack((self.x, self.y, self.z))
        scatter = GLScatterPlotItem(pos=points, color=(1,1,0,1), size=5)
        self.view3d.addItem(scatter)
        
        # 连接信号
        self.plot2d.scene().sigMouseMoved.connect(self.sync_views)
        
    def sync_views(self, pos):
        mouse_point = self.plot2d.getViewBox().mapSceneToView(pos)
        idx = np.argmin(np.abs(self.x - mouse_point.x()))
        self.view3d.opts['center'] = QtGui.QVector3D(
            self.x[idx], self.y[idx], self.z[idx]
        )
        
    def run(self):
        self.win.show()
        self.app.exec_()

linked = LinkedViews()
linked.run()

19. 机器学习可视化应用

19.1 训练过程监控

实时损失曲线展示：

python复制class TrainingMonitor:
    def __init__(self):
        self.pw = pg.PlotWidget()
        self.loss_curve = self.pw.plot(pen='r', name='训练损失')
        self.val_curve = self.pw.plot(pen='g', name='验证损失')
        self.loss_data = []
        self.val_data = []
        
    def update(self, epoch, loss, val_loss):
        self.loss_data.append(loss)
        self.val_data.append(val_loss)
        x = np.arange(len(self.loss_data))
        self.loss_curve.setData(x, self.loss_data)
        self.val_curve.setData(x, self.val_data)
        
    def show(self):
        self.pw.show()

19.2 特征空间可视化

PCA降维结果展示：

python复制def plot_embedding(features, labels):
    from sklearn.decomposition import PCA
    
    # 降维到2D
    pca = PCA(n_components=2)
    embedding = pca.fit_transform(features)
    
    # 创建散点图
    pw = pg.PlotWidget()
    scatter = pg.ScatterPlotItem(size=10, pen=pg.mkPen(None))
    
    # 按类别着色
    unique_labels = np.unique(labels)
    colors = [pg.intColor(i, hues=len(unique_labels)) 
              for i in range(len(unique_labels))]
    
    for label, color in zip(unique_labels, colors):
        mask = labels == label
        scatter.addPoints(
            x=embedding[mask, 0], 
            y=embedding[mask, 1],
            brush=pg.mkBrush(color),
            name=f'类别{label}'
        )
    
    pw.addItem(scatter)
    pw.showGrid(True, True)
    return pw

20. 部署与打包方案

20.1 独立可执行文件

使用PyInstaller打包：

bash复制pyinstaller --onefile --windowed --add-data "pyqtgraph;pyqtgraph" app.py

处理资源文件的特殊配置：

python复制# 在应用入口处添加资源路径
import os
import sys

if getattr(sys, 'frozen', False):
    # 打包后模式
    os.chdir(sys._MEIPASS)
    pg.setConfigOption('background', 'w')

20.2 WebAssembly移植

通过Pyodide在浏览器中运行：

html复制<!DOCTYPE html>
<html>
<head>
    <script src="https://cdn.jsdelivr.net/pyodide/v0.21.3/full/pyodide.js"></script>
</head>
<body>
    <div id="plot-container"></div>
    <script>
        async function main() {
            let pyodide = await loadPyodide();
            await pyodide.loadPackage("micropip");
            await pyodide.runPythonAsync(`
                import micropip
                await micropip.install('pyqtgraph')
                
                from pyqtgraph import PlotWidget
                import numpy as np
                
                pw = PlotWidget()
                x = np.linspace(0, 10, 100)
                y = np.sin(x)
                pw.plot(x, y)
                
                # 将绘图导出为HTML
                from pyqtgraph.exporters import HTMLExporter
                exporter = HTMLExporter(pw.plotItem)
                html = exporter.export(toBytes=True)
                js.document.getElementById('plot-container').innerHTML = html
            `);
        }
        main();
    </script>
</body>
</html>