pyqtの2Dグリッドのカラープロットの最適化

Question

PyQt4を使ってguiを実装したプログラムがあります。このプログラムはビームプロファイラを制御します。ビームプロファイラは4つの7500要素ベクトルを返します。最初の2つは位置ベクトル（XとY）で、後の2つはXとYのそれぞれの強度ベクトルです。私がしたいのは、グリッド（XY）を作成し、次の図のようにプロットの色として強度をプロットすることです。 Figure 1 - Side Gaussian function are my raw data and I want to plot like this

私は既にこれを行う方法を管理していますが、私は最適化に問題があります。

def emitGraph(self): 
    zz = zeros([len(self.slit_data_pos[self.slit][::100]), len(self.slit_data_pos[self.slit + 1][::100])]) 
    for i in xrange(len(self.slit_data_pos[self.slit][::100])): 
     for j in xrange(len(self.slit_data_pos[self.slit + 1][::100])): 
      zz[i,j] = self.mesh(i, j, self.slit_data_int[self.slit][::100], self.slit_data_int[self.slit + 1][::100]) 

    self.graph.emit(
     self.slit_data_pos[self.slit][::100], 
     self.slit_data_int[self.slit][::100], 
     self.slit_data_pos[self.slit + 1][::100], 
     self.slit_data_int[self.slit + 1][::100], 
     zz 
     ) 
    self.timerGraph = threading.Timer(0.2, self.emitGraph).start() 

def mesh(self, i, j, intx, inty): 
    norm_max = max(max(intx), max(inty)) 
    intx = [x/norm_max for x in intx] 
    inty = [y/norm_max for y in inty] 
    return intx[i]*inty[j] 

次のコードでわかるように、私はzzマトリックス（元は7500x7500）を埋めるために2つのループを持っています。私は現在、各ベクトルに対して75ポイントしか使用せず、タイマーを使用して0.2秒ごとにそれを表示しています。すべてのデータを使用すると、zz行列を塗りつぶしてからプロットするまでに時間がかかるため、これを行う必要がありました。

私はそれが（別のオブジェクト/スレッド内）でプロットしたコードの一部：

def graph_update(self, slit_samples_positionsX, slit_samples_intensitiesX, slit_samples_positionsY, slit_samples_intensitiesY, zz): 

    # self.matplotlibWidget.axis.plot(slit_samples_positionsX, slit_samples_intensitiesX) 
    # self.matplotlibWidget.axis.plot(slit_samples_positionsY, slit_samples_intensitiesY) 
    self.matplotlibWidget.axis.imshow(zz, cmap=cm.jet) 
    self.matplotlibWidget.canvas.draw() 

私の質問はどのように私は私のグラフの解像度や表示速度を増加させるために、私のデータの計算を向上させることができますか？または、このようなプロットを作成するための他の方法が速いのですか？

ありがとうございました！

Answer 1

0.2秒ごとにグリッド全体を作成します。また、0.2秒ごとに新しいプロットを作成します。これにより、アプリケーションの処理速度が低下します。 新しいタイマーを作成するたびに、emitGraphが呼び出されるたびに問題が発生する可能性があります。

プログラムを改善するには、グリッドを一度作成して内部のデータを更新するだけです。 また、プロットを1回作成し、新しいデータで更新します。 原則として、numpyは配列操作で非常に高速で、データを画面にプロットすることは問題ではありません。あなたのコードを見てみると、あなたが実際にnumpy配列の代わりにリストを使って多くの作業をしているという問題があります。リストの作成とfor-loopsを避けるようにしてください。実際には、meshの機能を完全になくし、それによって多くの時間を節約することができると思います。

プロットに関しては、毎回imshow()を呼び出しないでください！たとえばself.imageのためにあなたのimshowは、プロットしたものである場合は、ちょうどあなたが使用している配列の形状に関するより多くの情報を提供し、どのようなself.slitである私たちに伝えることができれば、私はおそらくあなたを助けることができるself.image.set_data(zz)

を呼び出すことによって、このプロットを更新もっと。

この時点で、ビームプロファイラを模倣して非常に高速に実行される次のコードを見てみたいかもしれません。

from PyQt4 import QtGui, QtCore 
import numpy as np 

from matplotlib.backends.backend_qt4agg import FigureCanvasQTAgg as FigureCanvas 
from matplotlib.backends.backend_qt4agg import NavigationToolbar2QT as NavigationToolbar 
from matplotlib.figure import Figure 

import sys, time, random 


class WorkerObject(QtCore.QObject): 

    signalStatus = QtCore.pyqtSignal(object) 

    def __init__(self, parent=None): 
     super(self.__class__, self).__init__(parent) 

     self.data = np.zeros((600,800)) 
     self.x = np.arange(0,800) 
     self.y = np.arange(0,600) 
     self.Y, self.X = np.meshgrid(self.x, self.y) 
     self.f = lambda x, y, x0, y0, sigmax, sigmay : 0.96*np.exp(-((x-x0)/float(sigmax))**2)*np.exp(-((y-y0)/float(sigmay))**2) 


    @QtCore.pyqtSlot()   
    def startWork(self): 
     print "StartWork" 
     x0 = random.randint(250,550) 
     y0 = random.randint(250,350) 
     sigmax = random.randint(100,200) 
     sigmay = random.randint(100,200) 
     while 1 > 0: 
      x0, y0, sigmax, sigmay = self.doWork(x0, y0, sigmax, sigmay) 

    def doWork(self, x0, y0, sigmax, sigmay): 
     dx, dy, dsx, dsy = random.randint(0,1)*2-1, random.randint(0,1)*2-1, random.randint(0,1)*2-1, random.randint(0,1)*2-1 
     self.data[:,:] = (self.f(self.X, self.Y, x0+dx, y0+dy, sigmax+dsx, sigmay+dsy)+np.random.random((600,800))*0.04)*(1.+np.random.rand()*0.04-0.02) 
     self.signalStatus.emit(self.data) 
     time.sleep(0.04) 
     return x0+dx, y0+dy, sigmax+dsx, sigmay+dsy 



class App(QtGui.QMainWindow): 

    signalStatus = QtCore.pyqtSignal(object) 
    abortSignal = QtCore.pyqtSignal() 

    def __init__(self, parent=None): 
     super(App, self).__init__(parent) 

     self.button_start = QtGui.QPushButton('Start',self) 
     self.button_cancel = QtGui.QPushButton('Cancel', self) 
     self.label_status = QtGui.QLabel('', self) 

     self.mainbox = QtGui.QWidget(self) 
     self.layout = QtGui.QVBoxLayout() 
     self.mainbox.setLayout(self.layout) 
     self.setCentralWidget(self.mainbox) 
     self.layout.addWidget(self.button_start) 
     self.layout.addWidget(self.button_cancel) 
     self.layout.addWidget(self.label_status) 

     self.fig = Figure((6.0, 3.0), dpi=72) 
     self.canvas = FigureCanvas(self.fig) 
     self.canvas.setParent(self) 
     self.canvastoolbar = NavigationToolbar(self.canvas, self) 
     self.fig.patch.set_alpha(0.0) 
     self.ax = self.fig.add_subplot(111) 
     self.x = np.arange(0,800); self.y = np.arange(0,600) 
     self.im = self.ax.imshow(np.zeros((600, 800)), origin='upper', vmin=0, vmax=1) 
     self.pv, = self.ax.plot(np.zeros(600) ,self.y , color="white" , alpha=0.6, lw=2) 
     self.ph, = self.ax.plot(self.x ,np.zeros(800) , color="white" , alpha=0.6, lw=2) 
     self.ax.set_xlim([0,800]); self.ax.set_ylim([0,600]) 
     self.layout.addWidget(self.canvas) 
     self.layout.addWidget(self.canvastoolbar) 

     self.initWorker() 



    def initWorker(self): 
     self.worker = WorkerObject() 
     self.worker_thread = QtCore.QThread() 
     self._connectSignals() 
     self.worker.moveToThread(self.worker_thread) 
     self.worker_thread.start() 


    def _connectSignals(self): 
     self.button_start.clicked.connect(self.worker.startWork) 
     self.button_cancel.clicked.connect(self.forceWorkerQuit) 
     self.worker.signalStatus.connect(self.updateStatus) 


    def forceWorkerQuit(self): 
     print "calculation aborted" 
     if self.worker_thread.isRunning(): 
      self.worker_thread.terminate() 
     self.worker_thread.start() 


    @QtCore.pyqtSlot(object) 
    def updateStatus(self, obj): 
     self.im.set_data(obj) 
     argm = np.unravel_index(np.argmax(obj), (600,800)) 
     self.pv.set_data(obj[:,argm[0]]*250, self.y) 
     self.ph.set_data(self.x, obj[argm[1], :]*250) 
     self.fig.canvas.draw() 


if __name__=='__main__': 
    app = QtGui.QApplication(sys.argv) 
    thisapp = App() 
    thisapp.show() 
    sys.exit(app.exec_()) 

編集（zzを計算する方法を求めて、下記のコメント答）：

私が正しく理解していれば、あなたのslit_data_int[0]はX方向に蓄積された強度であり、slit_data_int[1]は、Y方向の一方です。zz[j,i] = slit_data_int[1][j]*slit_data_int[0][i]場合、これはnumpyのでは行列の乗算（np.outer）を使用して、より良い計算されます。

zz[:,:] = np.outer(slit_data_int[1], slit_data_int[0])