def __init__(self): # initializes the main window
super(Window, self).__init__()
background(self) # acquires some features from the background function we defined earlier
pg.setConfigOption('background', 'w')
pg.setConfigOption('foreground', 'k')
if getattr(sys, 'frozen', False):
# frozen
self.setWindowTitle(
os.path.splitext(os.path.basename(sys.executable))[
0] + " - Main Window") # sets the title of the window
else:
# unfrozen
self.setWindowTitle(
os.path.splitext(os.path.basename(__file__))[
0] + " - Main Window") # sets the title of the window
self.ErrorDialogue = Communicate()
self.ErrorDialogue.myGUI_signal.connect(self.PopUpMessage)
self.scrollbar_thread = QtCore.QThread()
self.plot_thread = QtCore.QThread()
self.home() # runs the home function
def __init__(self, port, name, parent=None,):
QtGui.QWidget.__init__(self, parent)
self.resize(800, 600)
self.setWindowTitle("GraphName:{0} Port:{1}".format(name, port))
## Create some widgets to be placed inside
self.runCheck = QtGui.QCheckBox('Running')
#self.exportButton = QtGui.QPushButton("Export to CSV")
#self.exportButton.clicked.connect(self.ExportCSV)
# Plot objects
pg.setConfigOptions(antialias=False)
pg.setConfigOption('background', (255, 255, 255))
self.plt = pg.PlotWidget()
self.plt.showGrid(x=True, y=True)
## Create a grid layout to manage the widgets size and position
layout = QtGui.QGridLayout()
self.setLayout(layout)
## Add widgets to the layout in their proper positions
layout.addWidget(self.runCheck, 0, 0)
#layout.addWidget(self.exportButton, 0, 2)
layout.addWidget(self.plt, 1, 0, 1, 3)
## zmq worker
self.thread = QtCore.QThread()
self.zeromqListener = ZeroMQListener(port, name)
self.zeromqListener.moveToThread(self.thread)
self.thread.started.connect(self.zeromqListener.Loop)
self.zeromqListener.sigGetData.connect(self.UpdatePlot)
QtCore.QTimer.singleShot(0, self.thread.start)
def __init__(self, converter=csv_to_float):
super(StdinReader, self).__init__()
self.conv = converter
self.running = False
self.thread = QtCore.QThread()
self.moveToThread(self.thread)
self.thread.started.connect(self.run)
def liveviewStart(self):
''' Threading below is done in this way since making LVThread a
QThread resulted in QTimer not functioning in the thread. Image is now
also saved as latest_image in TormentaGUI class since setting image in
GUI from thread results in issues when interacting with the viewbox
from GUI. Maybe due to simultaneous manipulation of viewbox from GUI
and thread.'''
self.crosshairButton.setEnabled(True)
self.gridButton.setEnabled(True)
self.levelsButton.setEnabled(True)
self.recWidget.readyToRecord = True
self.lvworkers = [None] * len(self.cameras)
self.lvthreads = [None] * len(self.cameras)
for i in np.arange(len(self.cameras)):
self.lvworkers[i] = LVWorker(self, i, self.cameras[i])
self.lvthreads[i] = QtCore.QThread()
self.lvworkers[i].moveToThread(self.lvthreads[i])
self.lvthreads[i].started.connect(self.lvworkers[i].run)
self.lvthreads[i].start()
self.viewtimer.start(30)
self.liveviewRun()
def doRecording(self):
if not self.main.scanWidget.scanning:
self.makeSavenames()
for i in range(0, self.nCameras):
ind = np.mod(self.main.currCamIdx + i, 2)
# Creates an instance of RecWorker class.
self.recworkers[ind] = RecWorker(
self, self.main.cameras[ind], self.recMode,
self.getTimeOrFrames(), self.main.shapes[ind],
self.main.lvworkers[ind], self.main.RealExpPar,
self.savenames[ind], self.dataname, self.getAttrs())
# Connects the updatesignal that is continously emitted
# from recworker to updateGUI function.
self.recworkers[ind].updateSignal.connect(self.updateGUI)
# Connects the donesignal emitted from recworker to
# endrecording function.
self.recworkers[ind].doneSignal.connect(self.endRecording)
# Creates a new thread
self.recthreads[ind] = QtCore.QThread()
# moves the worker object to this thread.
self.recworkers[ind].moveToThread(self.recthreads[ind])
self.recthreads[ind].started.connect(
self.recworkers[ind].start)
for i in range(0, self.nCameras):
ind = np.mod(self.main.currCamIdx + i, 2)
self.recthreads[ind].start()
def __init__(self, parent=None):
super(AppWindow, self).__init__(parent)
self.setupUi(self)
self.statusBar = self.statusBar()
pg.setConfigOptions(antialias=True)
self.w = gl.GLViewWidget()
self.w.setSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
self.w.opts['distance'] = 40
self.w.setWindowTitle('ISING MODEL SIMULATION')
self.g = gl.GLGridItem()
self.w.addItem(self.g)
self.plotLayout.addWidget(self.w)
self.simul = simulator()
self.simul.newData.connect(self.gotParams)
self.simulthread = QtCore.QThread()
self.simul.moveToThread(self.simulthread)
self.simulthread.started.connect(self.simul.simulateData)
####################### GRAPHICS ###############
self.paramMessage = ''
self.hideStatusUp = False
self.hideStatusDown = False
self.doSlice = False
self.sliceLevel = 50
self.sliceArea = (self.simul.nSites**2)
self.sliceStart = int(self.sliceArea * self.sliceLevel *
self.simul.nSites / 100.)
self.sliceZ = int(self.sliceLevel * self.simul.nSites / 100.)
self.pos3 = np.zeros(
(self.simul.nSites, self.simul.nSites, self.simul.nSites, 3))
self.pos3[:, :, :, :
3] = np.mgrid[:self.simul.nSites, :self.simul.nSites, :self.
simul.nSites].transpose(1, 3, 2, 0) * [
-20. / self.simul.nSites, -20. /
self.simul.nSites, 20. / self.simul.nSites
]
self.pos3 += [10, 10, -10]
self.points = self.simul.nSites**3
self.pos3 = self.pos3.reshape(self.points, 3)
self.sp3 = gl.GLScatterPlotItem(pos=self.pos3,
color=(1, 1, 1, .3),
size=20. / self.simul.nSites,
pxMode=False)
self.w.addItem(self.sp3)
###################
self.t = QtCore.QTimer()
self.t.timeout.connect(self.update)
self.t.start(100)
self.simulthread.start()
def __init__(self):
super().__init__()
self._running = True
self._path_to_address = {}
self._server_thread = QtCore.QThread()
self.moveToThread(self._server_thread)
self._server_thread.started.connect(self.work)
self._sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
def setup_receiver_device(self): # start new receiver thread
logging.info("Start %s receiver %s at %s", self.kind, self.name,
self.frontend_address)
self.thread = QtCore.QThread() # no parent
self.worker = DataWorker(self.deserialze_data) # no parent
self.worker.moveToThread(
self.thread) # move worker instance to new thread
def __init__(
self,
port1,
port2,
name,
parent=None,
):
QtGui.QWidget.__init__(self, parent)
self.resize(800, 600)
self.setWindowTitle("GraphName:{0} Port:{1}and{2}".format(
name, port1, port2))
## port
self.port1 = port1
self.port2 = port2
## Create some widgets to be placed inside
self.runCheck = QtGui.QCheckBox('Running')
# Plot objects
pg.setConfigOptions(antialias=False)
pg.setConfigOption('background', (255, 255, 255))
self.plt = pg.PlotWidget()
self.plt.showGrid(x=True, y=True)
## Create a grid layout to manage the widgets size and position
layout = QtGui.QGridLayout()
self.setLayout(layout)
## Add widgets to the layout in their proper positions
layout.addWidget(self.runCheck, 0, 0)
layout.addWidget(self.plt, 1, 0)
## zmq worker
self.thread1 = QtCore.QThread()
self.thread2 = QtCore.QThread()
self.zeromqListener1 = ZeroMQListener(port1, name)
self.zeromqListener2 = ZeroMQListener(port2, name)
self.zeromqListener1.moveToThread(self.thread1)
self.zeromqListener2.moveToThread(self.thread2)
self.thread1.started.connect(self.zeromqListener1.Loop)
self.thread2.started.connect(self.zeromqListener2.Loop)
self.zeromqListener1.sigGetData.connect(self.UpdatePlot)
self.zeromqListener2.sigGetData.connect(self.UpdatePlot)
QtCore.QTimer.singleShot(0, self.thread1.start)
QtCore.QTimer.singleShot(0, self.thread2.start)
def __init__(self, worker):
self.interval = 1000 * interval
self.function = function
self.args = args
self.kwargs = kwargs
self.thread = QtCore.QThread()
self.worker = worker
self.worker.moveToThread(self.thread)
self.thread.start()
def __init__(self, device, baud, converter=float, timeout=0.001, **kwargs): super(SerialReader, self).__init__() self.serial = serial.Serial(device, baud, timeout=timeout, **kwargs) self.conv = converter self.fragment = bytearray() self.running = False self.thread = QtCore.QThread() self.moveToThread(self.thread) self.thread.started.connect(self.run)
def setup_data_worker(self, socket_addr):
self.thread = QtCore.QThread() # no parent!
self.worker_data = DataWorker() # no parent!
self.worker_data.data_ready.connect(self.update_monitor)
self.worker_data.connected.connect(self.setup_status_text)
self.worker_data.moveToThread(self.thread)
self.worker_data.connect(socket_addr)
self.thread.started.connect(self.worker_data.process_data)
self.aboutToQuit.connect(self.thread.quit)
def updateIndex(self):
"""
Crystal indexing is usually a long running task (unlike peak finding)
Hence a thread is used to indexing in the background
"""
if self.indexingOn:
self.indexCounter += 1
if self.parent.pk.peaks is None:
self.parent.index.clearIndexedPeaks()
else:
if self.parent.pk.numPeaksFound >= self.parent.pk.minPeaks and \
self.parent.pk.numPeaksFound <= self.parent.pk.maxPeaks and \
self.parent.pk.peaksMaxRes >= self.parent.pk.minRes:
print("OK, I'll index this pattern now")
if self.parent.args.v >= 1: print("Running indexing!!!!!!!!!!!!")
# Running indexing ...
self.parent.index.numIndexedPeaksFound = 0
self.parent.index.indexedPeaks = None
self.parent.index.clearIndexedPeaks()
self.parent.index.displayWaiting()
# Write list of files to index
with open(self.parent.index.hiddenCrystfelList, "w") as text_file:
text_file.write("{} //0".format(self.parent.index.hiddenCXI))
# Generate a static mask of bad pixels for indexing
self.parent.mk.saveCheetahStaticMask()
# Step 2: Create a QThread object
thread = QtCore.QThread()
self.threadpool.append(thread)
# Step 3: Create a worker object
worker = IndexWorker()
self.workerpool.append(worker)
self.workerpool[-1].setup(self.indexCounter, self.parent.index.hiddenCrystfelList, self.geom, self.peakMethod,
self.intRadius, self.pdb, self.indexingMethod,
self.parent.index.hiddenCrystfelStream, self.extra,
self.parent.runNumber, self.parent.eventNumber, self.tolerance, self.outDir)
# Step 4: Move worker to the thread
self.workerpool[-1].moveToThread(self.threadpool[-1])
# Step 5: Connect signals and slots
self.threadpool[-1].started.connect(self.workerpool[-1].run)
self.workerpool[-1].finished.connect(self.threadpool[-1].quit)
self.workerpool[-1].finished.connect(self.workerpool[-1].deleteLater)
self.threadpool[-1].finished.connect(self.threadpool[-1].deleteLater)
self.workerpool[-1].progress.connect(self.reportProgress)
# Step 6: Start the thread
self.threadpool[-1].start()
# Final resets
self.workerpool[-1].finished.connect(self.reportResults)
else:
# do not display predicted spots
self.parent.index.clearIndexedPeaks()
def startRecording(self):
if self.recButton.isChecked():
ret = QtGui.QMessageBox.Yes
if self.filesize > 1500000000: # Checks if estimated file size is dangourusly large, > 1,5GB-.
ret = self.filesizewar.exec_()
folder = self.folderEdit.text()
if os.path.exists(folder) and ret == QtGui.QMessageBox.Yes:
self.writable = False # Sets Recording widget to not be writable during recording.
self.readyToRecord = False
self.recButton.setEnabled(True)
self.recButton.setText('STOP')
self.main.tree.writable = False # Sets camera parameters to not be writable during recording.
self.main.liveviewButton.setEnabled(False)
# self.main.liveviewStop() # Stops liveview from updating
self.savename = (os.path.join(folder, self.getFileName()) +
'_rec.hdf5'
) # Sets name for final output file
self.savename = guitools.getUniqueName(
self.savename
) # If same filename exists it is appended by (1) or (2) etc.
self.startTime = ptime.time(
) # Saves the time when started to calculate remaining time.
self.worker = RecWorker(
self.main.orcaflash,
self.getRecTime(),
self.main.shape,
self.main.
lvworker, #Creates an instance of RecWorker class.
self.main.RealExpPar,
self.savename,
self.dataname,
self.getAttrs())
self.worker.updateSignal.connect(
self.updateGUI
) # Connects the updatesignal that is continously emitted from recworker to updateGUI function.
self.worker.doneSignal.connect(
self.endRecording
) # Connects the donesignal emitted from recworker to endrecording function.
self.recordingThread = QtCore.QThread() # Creates a new thread
self.worker.moveToThread(
self.recordingThread
) # moves the worker object to this thread.
self.recordingThread.started.connect(self.worker.start)
self.recordingThread.start()
else:
self.recButton.setChecked(False)
self.folderWarning()
else:
self.worker.pressed = False
def __init__(self, interval, function, *args, **kwargs):
self.interval = 1000 * interval
self.function = function
self.args = args
self.kwargs = kwargs
self.thread = QtCore.QThread()
self.worker = repeatedWorker(interval, function, *args, **kwargs)
self.worker.moveToThread(self.thread)
self.thread.started.connect(self.worker.loop)
self.thread.start()
self.thread.setPriority(QThread.TimeCriticalPriority)
def __init__(self):
QtGui.QMainWindow.__init__(self)
x_axis_min_range = 0
x_axis_max_range = 100
y_axis_min_range = 0
y_axis_max_range = 100
win2 = pg.GraphicsWindow(title="Test Plots")
win2.resize(640, 480)
pg.setConfigOptions(antialias=True)
self.setCentralWidget(win2)
self.p1 = win2.addPlot(title="Plot 1")
self.p1curve = self.p1.plot(pen=(255, 0, 0))
self.p1.showGrid(x=True, y=True)
self.p1.setYRange(y_axis_min_range, y_axis_max_range)
self.p1.setXRange(x_axis_min_range, x_axis_max_range)
self.p2 = win2.addPlot(title="Plot 2")
self.p2curve = self.p2.plot(pen=(0, 255, 0))
self.p2.showGrid(x=True, y=True)
self.p2.setYRange(y_axis_min_range, y_axis_max_range)
self.p2.setXRange(x_axis_min_range, x_axis_max_range)
self.x1 = range(1, 101)
self.thread1 = QtCore.QThread()
self.dgen1 = DataGenerator(self, len(self.x1), [0, 100], 1000)
self.dgen1.moveToThread(self.thread1)
self.dgen1.newData.connect(self.update_plot1)
self.thread1.started.connect(self.dgen1.generateData)
self.thread1.start()
self.x2 = range(1, 101)
self.thread2 = QtCore.QThread()
self.dgen2 = DataGenerator(self, len(self.x2), [0, 100], 500)
self.dgen2.moveToThread(self.thread2)
self.dgen2.newData.connect(self.update_plot2)
self.thread2.started.connect(self.dgen2.generateData)
self.thread2.start()
def __init__(self, *args, **kargs):
self.shouldPaint = False
self.onlyRenderVisible = True
super().__init__(*args, **kargs)
# Prepare image computation worker
self.imageARGBWorker = ImageARGBWorker()
self.imageARGBWorker.qimageProduced.connect(self.updateQImage)
self.imageARGBThread = QtCore.QThread()
self.imageARGBWorker.moveToThread(self.imageARGBThread)
self.sigImageReadyForARGB.connect(self.imageARGBWorker.produceARGB)
self.imageARGBThread.start()
def __init__(self, lasers, daq, *args, **kwargs):
super().__init__(*args, **kwargs)
self.actlaser, self.offlaser, self.exclaser = lasers
self.mW = Q_(1, 'mW')
self.daq = daq
self.actControl = LaserControl(self.actlaser,
'<h3>405<h3>',
color=(130, 0, 200),
prange=(0, 200),
tickInterval=5,
singleStep=0.1)
self.offControl = LaserControl(self.offlaser,
'<h3>488<h3>',
color=(0, 247, 255),
prange=(0, 200),
tickInterval=100,
singleStep=10,
daq=self.daq,
port=0)
self.excControl = LaserControlTTL(self.exclaser,
'<h3>473<h3>',
color=(0, 183, 255))
self.actlaser.autostart = False
self.offlaser.autostart = False
self.controls = (self.actControl, self.offControl, self.excControl)
self.setFrameStyle(QtGui.QFrame.Panel | QtGui.QFrame.Raised)
grid = QtGui.QGridLayout()
self.setLayout(grid)
self.DigCtrl = DigitalControl(controls=(self.actControl,
self.offControl,
self.excControl))
grid.addWidget(self.actControl, 0, 0, 4, 1)
grid.addWidget(self.offControl, 0, 1, 4, 1)
grid.addWidget(self.excControl, 0, 2, 4, 1)
grid.addWidget(self.DigCtrl, 4, 0, 2, 3)
# Current power update routine
self.updatePowers = UpdatePowers(self)
self.updateThread = QtCore.QThread()
self.updatePowers.moveToThread(self.updateThread)
self.updateThread.start()
self.updateThread.started.connect(self.updatePowers.update)
def _init_data_receiver(self):
# Create the connection handler object
self.data_receiver = DataReceiver(None, self.connection_handler)
# Create a thread for it
self.data_receiver_thread = QtCore.QThread()
self.data_receiver.moveToThread(self.data_receiver_thread)
# Connect slots
self.data_receiver.data_received_signal.connect(
self.main_window.data_received)
self.data_receiver_thread.started.connect(
self.data_receiver.receive_data)
self.aboutToQuit.connect(self.data_receiver_thread.quit)
# Start the thread
self.data_receiver_thread.start()
def __init__(self, parent, rc):
super(App, self).__init__(parent)
#### Create Gui Elements ###########
self.mainbox = QtGui.QWidget()
self.setCentralWidget(self.mainbox)
self.mainbox.setLayout(QtGui.QVBoxLayout())
self.canvas = pg.GraphicsLayoutWidget()
self.mainbox.layout().addWidget(self.canvas)
self.label = QtGui.QLabel()
self.mainbox.layout().addWidget(self.label)
self.rc = rc
self.starttime = time.time()
# self.view = self.canvas.addViewBox()
# self.view.setAspectLocked(True)
# self.view.setRange(QtCore.QRectF(0,0, 100, 100))
# image plot
# self.img = pg.ImageItem(border='w')
# self.view.addItem(self.img)
self.canvas.nextRow()
# line plot
self.otherplot = self.canvas.addPlot()
self.h2 = self.otherplot.plot(pen='y')
self.button = QPushButton('Test', self)
self.label = QLabel(self)
self.signal_start_background_job = QtCore.pyqtSignal()
self.worker = WorkerObject()
self.thread = QtCore.QThread()
self.worker.moveToThread(self.thread)
self.signal_start_background_job.connect(self.worker.background_job)
self.button.clicked.connect(self.start_background_job)
#### Set Data #####################
self.xdata = []
# self.X, self.Y = np.meshgrid(self.x, self.x)
self.ydata = []
self.counter = 0
# self.fps = 0.
self.lastupdate = time.time()
#### Start #####################
self._update()
def _init_connection_handler(self):
# Create the connection handler object
self.connection_handler = ConnectionHandler()
# Create a thread for it
self.connection_handler_thread = QtCore.QThread()
self.connection_handler.moveToThread(self.connection_handler_thread)
# Connect slots
self.main_window.connect_signal.connect(
self.connection_handler.connect)
self.main_window.disconnect_signal.connect(
self.connection_handler.disconnect)
self.aboutToQuit.connect(self.connection_handler_thread.quit)
# Start the thread
self.connection_handler_thread.start()
def liveviewStart(self):
# self.orcaflash.startAcquisition()
# time.sleep(0.3)
# time.sleep(np.max((5 * self.t_exp_real.magnitude, 1)))
self.updateFrame()
self.vb.scene().sigMouseMoved.connect(self.mouseMoved)
self.recWidget.readyToRecord = True
self.lvworker = LVWorker(self, self.orcaflash)
self.lvthread = QtCore.QThread()
self.lvworker.moveToThread(self.lvthread)
self.lvthread.started.connect(self.lvworker.run)
self.lvthread.start()
self.viewtimer.start(30)
self.liveviewRun()
def setup_data_worker_and_start(self, socket_addr):
self.thread = QtCore.QThread() # no parent
self.worker = DataWorker() # no parent
self.worker.interpreted_data.connect(self.on_interpreted_data)
self.worker.run_start.connect(self.on_run_start)
self.worker.run_config_data.connect(self.on_run_config_data)
# self.worker.run_config_data.connect(self.on_run_config_data)
self.worker.global_config_data.connect(self.on_global_config_data)
self.worker.moveToThread(self.thread)
self.worker.connect(socket_addr)
# self.aboutToQuit.connect(self.worker.stop) # QtGui.QApplication
self.thread.started.connect(self.worker.process_data)
self.worker.finished.connect(self.thread.quit)
self.worker.finished.connect(self.worker.deleteLater)
self.thread.finished.connect(self.thread.deleteLater)
self.thread.start()
def __init__(self, plot, fltr, rate):
super(App, self).__init__()
self._QUIT = False
self._plt = plot
self._filter = fltr
self._title = 'Filter Visualizer'
self._left = 0
self._top = 0
self._width = 500
self._height = 500
self.initUI()
self._filter_updater = FilterUpdater(plot, fltr, rate)
self._thread = QtCore.QThread(self)
self._filter_updater.moveToThread(self._thread)
self._thread.started.connect(self._filter_updater.update)
self._thread.start()
def __init__(self, records, name, timer, function, *args):
# Initialize the PunchingBag as a QObject
QObject.__init__(self)
self.records = records
self.records[name] = {
'name': name,
'pen': 'r',
'timer': timer,
'function': function,
'ploton': True,
'data': []
}
self.name = name
self.signal = createSignalTimer(name, function, *args)
self.thread = QtCore.QThread()
self.worker = recordWorker(self.records, self.signal, name)
self.worker.moveToThread(self.thread)
self.thread.start()
self.signal.startTimer(timer)
def setup_data_worker_and_start(self, socket_addr):
self.thread = QtCore.QThread() # no parent
self.worker = DataWorker() # no parent
self.worker.meta_data.connect(self.on_meta_data)
self.worker.interpreted_data.connect(self.on_interpreted_data)
self.worker.run_start.connect(self.on_run_start)
self.worker.run_config_data.connect(self.on_run_config_data)
self.worker.global_config_data.connect(self.on_global_config_data)
self.worker.filename.connect(self.on_filename)
self.spin_box.valueChanged.connect(
self.worker.on_set_integrate_readouts)
self.reset_button.clicked.connect(self.on_reset)
self.worker.moveToThread(self.thread)
self.worker.connect(socket_addr)
# self.aboutToQuit.connect(self.worker.stop) # QtGui.QApplication
self.thread.started.connect(self.worker.process_data)
self.worker.finished.connect(self.thread.quit)
self.worker.finished.connect(self.worker.deleteLater)
self.thread.finished.connect(self.thread.deleteLater)
self.thread.start()
def __init__(self, interval_ms, acquisition, parent=None):
super().__init__(parent=parent)
self._thread = QtCore.QThread()
self.moveToThread(self._thread)
self._interval = interval_ms / 1000
self._target = _now()
self._continue = False
self.wait = self._thread.wait
self.quit = self._thread.quit
self._timing = QtCore.QMutex()
self._waitAcq = acquisition.triggerAndWait
acquisition.setStaticMetadata(
"interval", dict(mode="busy-wait", target_ms=interval_ms))
acquisition.acquisitionStarting.connect(self._thread.start)
acquisition.acquisitionEnding.connect(self.signal,
QtCore.Qt.DirectConnection)
self._thread.started.connect(self.run, QtCore.Qt.DirectConnection)
self._thread.started.connect(self.raisePriority)
self.timeout.connect(acquisition.trigger_capture,
QtCore.Qt.QueuedConnection)
def __init__(self):
QtGui.QMainWindow.__init__(self)
pg.setConfigOptions(antialias=True)
self.w = gl.GLViewWidget()
self.w.opts['distance'] = 40
self.w.setWindowTitle('ISING MODEL SIMULATION')
self.g = gl.GLGridItem()
self.w.addItem(self.g)
self.setCentralWidget(self.w)
self.simul = simulator()
self.simulthread = QtCore.QThread()
self.simul.moveToThread(self.simulthread)
self.simulthread.started.connect(self.simul.simulateData)
####################### GRAPHICS ###############
self.pos3 = np.zeros((self.simul.nSites, self.simul.nSites, 3))
print len(self.pos3), self.pos3.shape
self.pos3[:, :, :2] = np.mgrid[:self.simul.nSites, :self.simul.
nSites].transpose(1, 2, 0) * [
-20. / self.simul.nSites,
20. / self.simul.nSites
]
self.pos3 += [10, -10, 0.5]
self.points = self.simul.nSites**2
self.pos3 = self.pos3.reshape(self.points, 3)
self.sp3 = gl.GLScatterPlotItem(pos=self.pos3,
color=(1, 1, 1, .3),
size=20. / self.simul.nSites,
pxMode=False)
self.w.addItem(self.sp3)
###################
self.t = QtCore.QTimer()
self.t.timeout.connect(self.update)
self.t.start(100)
self.simulthread.start()
def __init__(self,
records,
name,
pen,
timer,
maxlength,
function,
args=[],
functionForm=None,
functionArgument=None,
logScale=False,
verticalRange=None,
verticalMeanSubtraction=False,
axis=None):
QtCore.QObject.__init__(self)
self.records = records
self.name = name
self.timer = timer
self.signal = createSignalTimer(function, args=args)
self.records[name] = {
'name': name,
'record': self,
'pen': pen,
'timer': timer,
'maxlength': maxlength,
'data': collections.deque(maxlen=maxlength),
'function': function,
'args': args,
'functionForm': functionForm,
'functionArgument': functionArgument,
'signal': self.signal,
'logScale': logScale,
'verticalRange': verticalRange,
'axisname': axis
}
self.thread = QtCore.QThread()
self.worker = recordWorker(self.records, self.signal, name)
self.records[name]['worker'] = self.worker
self.worker.moveToThread(self.thread)
def ringFinder(self, show=True, batch=False):
"""RingFinder handles the input data, and then evaluates every subimg
using the given algorithm which decides if there are rings or not.
Subsequently gives the output data and plots it."""
if self.corrButton.isChecked():
# shape the data into the subimg that we need for the analysis
nblocks = np.array(self.inputData.shape) / self.n
blocksInput = tools.blockshaped(self.inputData, *nblocks)
blocksInputS = tools.blockshaped(self.inputDataS, *nblocks)
blocksMask = tools.blockshaped(self.mask, *nblocks)
# for each subimg, we apply the correlation method for ring finding
intThr = np.float(self.intThresEdit.text())
corrThres = np.float(self.corrThresEdit.text())
minLen = np.float(self.lineLengthEdit.text()) / self.pxSize
thetaStep = np.float(self.deltaAngleEdit.text())
deltaTh = np.float(self.deltaAngleEdit.text())
wvlen = np.float(self.wvlenEdit.text()) / self.pxSize
sinPow = np.float(self.sinPowerEdit.text())
cArgs = corrThres, minLen, thetaStep, deltaTh, wvlen, sinPow
args = self.n, blocksInput, blocksInputS, blocksMask, intThr, cArgs
self.localCorr = np.zeros(len(blocksInput))
self.singleObj = Single(*args)
self.updateFileStatus()
# self.singleObj.signals.start.connect(self.updateFileStatus)
self.singleObj.doneSignal.connect(self.updateOutput)
self.workerThread = QtCore.QThread(self)
self.singleObj.moveToThread(self.workerThread)
self.workerThread.started.connect(self.singleObj.start)
self.workerThread.start()
else:
self.corrResult.clear()
self.ringResult.clear()
