def bn_browse_for(vip, k):
Dialog = QWidget()
Dialog.resize(50, 70) # *cs.RESIZE_BROWSE_DIALOG
Dialog.move(100, 100)
def _set_file_path(sk, file_extension):
new_path = str(QFileDialog.getOpenFileName(Dialog, 'Open a file', os.sep, "*."+file_extension))
if new_path: vip.set(sk, {k : new_path}) # this is a le change, triggered from this bn action
return new_path
def _set_dir_path(sk):
new_path = str(QFileDialog.getExistingDirectory(Dialog, 'Open a folder', os.sep, QFileDialog.ShowDirsOnly))
if new_path: vip.set(sk, {k : new_path}) # this is a le change, triggered from this bn action
return new_path
if k == 'FILE_PATH_session':
new_path = _set_file_path('Session', "txt")
if new_path:
bn_load_session_to_vip(vip)
elif k == 'DIR_PATH_results':
_set_dir_path('Results')
elif k in ['FILE_PATH_waveform_'+str(j) for j in range(4)]:
_set_file_path('H3344_1', "csv")
else:
vip.GUI_feedback("!!! (bn_browse_for) A strange key was passed.")
Dialog.close()
l_keywords.setText(str(keywords).encode('UTF-8').decode('UTF-8'))
posX, posY = GetCursorPos()
w.move(posX, posY)
w.adjustSize()
w.update()
w.show()
#w.raise_()
#w.activateWindow()
shell = client.Dispatch("WScript.Shell")
shell.SendKeys('%')
window = win32gui.FindWindow(None, u'By ddd')
win32gui.SetForegroundWindow(window)
except:
button = QMessageBox.warning(w, "Error", u'无法完成窗口更新，请尝试重启软件！',
QMessageBox.Ok)
if button == QMessageBox.Ok:
w.close()
win32api.CloseHandle(hmutex)
exit()
try:
clipboard.dataChanged.connect(on_clipboard_change)
except:
w.close()
win32api.CloseHandle(hmutex)
exit()
app.exec_()
class Protocol:
def __init__(self, fileName, callback):
with open(fileName) as contents:
try:
json_protocol = json.load(contents)
except ValueError as e:
print "Protocol file could not be loaded. It might have a typo."
print "This is the error code the file gave us:"
print e
raise ProtocolNotLoaded
self.steps = []
for step in json_protocol['steps']:
if 'type' in step:
if step['type'] == 'calibration':
self.steps.append(CalibrationStep(step))
elif step['type'] == 'connection':
self.steps.append(ConnectionStep(step))
else:
print u"Unknown step type '{0:s}'".format(step['type'])
else:
self.steps.append(Step(step))
self.session = {
'num_steps': len(self.steps),
'steps': []
}
self.callback = callback
self.current_step_idx = 0
self.current_step = self.steps[self.current_step_idx]
self.main_widget = QWidget()
self.layout = QGridLayout()
self.main_widget.setLayout(self.layout)
@classmethod
def validate(cls, filename):
schema_location = "protocols/protocol_schema.json"
schema = json.load(open(schema_location))
pcl = json.load(open(filename))
jsonschema.validate(pcl, schema)
def start(self):
print "starting protocol"
self.current_step.startStep(self.end_step)
self.current_widget = self.current_step.widget
self.layout.addWidget(self.current_widget)
self.session['start'] = datetime.datetime.now()
def end(self):
self.session['end'] = datetime.datetime.now()
with open("./recordings/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S"), "w+") as file:
json.dump(self.session, file, default=self.default_serializer)
print "protocol ended. Data:"
print self.session
self.current_widget.close()
self.main_widget.close()
self.callback()
def default_serializer(self, obj):
if isinstance(obj, datetime.datetime):
serial = obj.isoformat()
return serial
def end_step(self, data_dict):
self.session['steps'].append({})
self.session['steps'][self.current_step_idx]['end'] = datetime.datetime.now()
self.session['steps'][self.current_step_idx]['data'] = data_dict
self.next_step()
def next_step(self):
if len(self.steps) > self.current_step_idx + 1:
self.session['steps'][self.current_step_idx]['end'] = datetime.datetime.now()
self.current_step_idx += 1
self.current_step = self.steps[self.current_step_idx]
self.current_widget.close()
self.layout.removeWidget(self.current_widget)
self.current_step.startStep(self.end_step)
self.current_widget = self.current_step.widget
self.layout.addWidget(self.current_widget)
else:
self.end()
class RingWindow(QMainWindow):
image: RingImageQLabel
statusbar: QtGui.QStatusBar
def __init__(self):
super(RingWindow, self).__init__()
path = os.path.join(sys.path[0], __package__)
uic.loadUi(os.path.join(path, 'gui_ring.ui'), self)
self.move(50, 0)
self.ctrl = QWidget()
uic.loadUi(os.path.join(path, 'gui_ring_controls.ui'), self.ctrl)
self.ctrl.show()
self.ctrl.zSpin.valueChanged.connect(self.onZValueChange)
self.ctrl.openButton.pressed.connect(self.onOpenButton)
self.ctrl.addButton.pressed.connect(self.onAddButton)
self.ctrl.plotButton.pressed.connect(self.onPlotButton)
self.ctrl.measureButton.pressed.connect(self.onMeasureButton)
self.ctrl.dnaSpin.valueChanged.connect(self.onDnaValChange)
self.ctrl.actSpin.valueChanged.connect(self.onActValChange)
self.ctrl.dnaChk.toggled.connect(self.onImgToggle)
self.ctrl.actChk.toggled.connect(self.onImgToggle)
self.ctrl.renderChk.stateChanged.connect(self.onRenderChk)
self.image.clicked.connect(self.onImgUpdate)
self.image.lineUpdated.connect(self.onImgUpdate)
self.image.linePicked.connect(self.onLinePickedFromImage)
self.image.dnaChannel = self.ctrl.dnaSpin.value()
self.image.actChannel = self.ctrl.actSpin.value()
self.grph = GraphWidget()
self.grph.show()
self.grph.linePicked.connect(self.onLinePickedFromGraph)
self.ctrl.setWindowFlags(self.ctrl.windowFlags() & ~QtCore.Qt.WindowStaysOnTopHint)
self.grph.setWindowFlags(self.grph.windowFlags() & ~QtCore.Qt.WindowStaysOnTopHint)
self.image.dnaChannel = self.ctrl.dnaSpin.value()
self.image.actChannel = self.ctrl.actSpin.value()
self.measure_n = 0
self.selectedLine = None
self.df = pd.DataFrame()
self.file = "/Users/Fabio/data/lab/airyscan/nil.czi"
self.resizeEvent(None)
self.moveEvent(None)
def resizeEvent(self, event):
# this is a hack to resize everithing when the user resizes the main window
self.grph.setFixedWidth(self.width())
self.image.setFixedWidth(self.width())
self.image.setFixedHeight(self.height())
self.image.resizeEvent(None)
self.moveEvent(None)
def moveEvent(self, QMoveEvent):
px = self.geometry().x()
py = self.geometry().y()
pw = self.geometry().width()
ph = self.geometry().height()
dw = self.ctrl.width()
dh = self.ctrl.height()
self.ctrl.setGeometry(px + pw, py, dw, dh)
dw = self.grph.width()
dh = self.grph.height()
self.grph.setGeometry(px, py + ph + 20, dw, dh)
# super(RingWindow, self).mouseMoveEvent(event)
def closeEvent(self, event):
if not self.df.empty:
self.df.loc[:, "condition"] = self.ctrl.experimentLineEdit.text()
self.df.loc[:, "l"] = self.df.loc[:, "l"].apply(lambda v: np.array2string(v, separator=','))
self.df.to_csv(os.path.join(os.path.dirname(self.image.file), "ringlines.csv"))
self.grph.close()
self.ctrl.close()
def focusInEvent(self, QFocusEvent):
logger.debug('focusInEvent')
self.ctrl.activateWindow()
self.grph.activateWindow()
def showEvent(self, event):
self.setFocus()
def _graphTendency(self):
df = pd.DataFrame(self.image.measurements).drop(['x', 'y', 'c', 'ls0', 'ls1', 'd', 'sum'], axis=1)
df.loc[:, "xx"] = df.loc[:, "l"].apply(
lambda v: np.arange(start=0, stop=len(v) * self.image.dl, step=self.image.dl))
df = m.vector_column_to_long_fmt(df, val_col="l", ix_col="xx")
sns.lineplot(x="xx", y="l", data=df, ax=self.grph.ax, color='k', ci="sd", zorder=20)
self.grph.ax.set_ylabel('')
self.grph.ax.set_xlabel('')
self.grph.canvas.draw()
def _graph(self, alpha=1.0):
self.grph.clear()
if self.image.measurements is not None:
for me in self.image.measurements:
x = np.arange(start=0, stop=len(me['l']) * self.image.dl, step=self.image.dl)
lw = 0.1 if self.image.selectedLine is not None and me != self.image.selectedLine else 0.5
self.grph.ax.plot(x, me['l'], linewidth=lw, linestyle='-', color=me['c'], alpha=alpha, zorder=10,
picker=5, label=me['n'])
self.grph.format_ax()
self.statusbar.showMessage("ptp: %s" % ["%d " % me['d'] for me in self.image.measurements])
self.grph.canvas.draw()
@QtCore.pyqtSlot()
def onImgToggle(self):
logger.debug('onImgToggle')
if self.ctrl.dnaChk.isChecked():
self.image.activeCh = "dna"
if self.ctrl.actChk.isChecked():
self.image.activeCh = "act"
@QtCore.pyqtSlot()
def onRenderChk(self):
logger.debug('onRenderChk')
self.image.render = self.ctrl.renderChk.isChecked()
@QtCore.pyqtSlot()
def onOpenButton(self):
logger.debug('onOpenButton')
qfd = QtGui.QFileDialog()
path = os.path.dirname(self.file)
if self.image.file is not None:
self.statusbar.showMessage("current file: %s" % os.path.basename(self.image.file))
flt = "zeiss(*.czi)"
f = QtGui.QFileDialog.getOpenFileName(qfd, "Open File", path, flt)
if len(f) > 0:
self.image.file = f
self.image.zstack = self.ctrl.zSpin.value()
self.image.dnaChannel = self.ctrl.dnaSpin.value()
self.ctrl.nchLbl.setText("%d channels" % self.image.nChannels)
self.ctrl.nzsLbl.setText("%d z-stacks" % self.image.nZstack)
self.ctrl.nfrLbl.setText("%d %s" % (self.image.nFrames, "frames" if self.image.nFrames > 1 else "frame"))
@QtCore.pyqtSlot()
def onImgUpdate(self):
logger.debug('onImgUpdate')
self.ctrl.renderChk.setChecked(True)
self._graph()
@QtCore.pyqtSlot()
def onMeasureButton(self):
logger.debug('onMeasureButton')
self.image.paint_measures()
self._graph(alpha=0.2)
self._graphTendency()
@QtCore.pyqtSlot()
def onZValueChange(self):
logger.debug('onZValueChange')
self.image.zstack = self.ctrl.zSpin.value() % self.image.nZstack
self.ctrl.zSpin.setValue(self.image.zstack)
self._graph()
@QtCore.pyqtSlot()
def onDnaValChange(self):
logger.debug('onDnaValChange')
val = self.ctrl.dnaSpin.value() % self.image.nChannels
self.ctrl.dnaSpin.setValue(val)
self.image.dnaChannel = val
if self.ctrl.dnaChk.isChecked():
self.image.activeCh = "dna"
self.ctrl.dnaChk.setChecked(True)
@QtCore.pyqtSlot()
def onActValChange(self):
logger.debug('onActValChange')
val = self.ctrl.actSpin.value() % self.image.nChannels
self.ctrl.actSpin.setValue(val)
self.image.actChannel = val
if self.ctrl.actChk.isChecked():
self.image.activeCh = "act"
self.ctrl.actChk.setChecked(True)
@QtCore.pyqtSlot()
def onAddButton(self):
logger.debug('onAddButton')
if self.image.measurements is not None:
new = pd.DataFrame(self.image.measurements)
if self.selectedLine is not None:
new = new.loc[new["n"] == self.selectedLine]
new.loc[:, "m"] = self.measure_n
new.loc[:, "z"] = self.image.zstack
new.loc[:, "file"] = os.path.basename(self.image.file)
# new.loc[:, "x"] = new.loc[:, "l"].apply(lambda v: np.arange(start=0, stop=len(v), step=self.image.dl))
self.df = self.df.append(new, ignore_index=True, sort=False)
self.measure_n += 1
print(self.df)
@QtCore.pyqtSlot()
def onPlotButton(self):
logger.debug('onPlotButton')
if self.image.measurements is None: return
import matplotlib.pyplot as plt
import seaborn as sns
from matplotlib.gridspec import GridSpec
plt.style.use('bmh')
pal = sns.color_palette("Blues", n_colors=len(self.image.measurements))
fig = plt.figure(figsize=(2, 2 * 4), dpi=300)
gs = GridSpec(nrows=2, ncols=1, height_ratios=[4, 0.5])
ax1 = plt.subplot(gs[0, 0])
ax2 = plt.subplot(gs[1, 0])
self.image.drawMeasurements(ax1, pal)
lw = 1
for me, c in zip(self.image.measurements, pal):
x = np.arange(start=0, stop=len(me['l']) * self.image.dl, step=self.image.dl)
ax2.plot(x, me['l'], linewidth=lw, linestyle='-', color=c, alpha=1, zorder=10)
ax1.xaxis.set_major_locator(ticker.MultipleLocator(20))
ax1.xaxis.set_minor_locator(ticker.MultipleLocator(10))
ax1.yaxis.set_major_locator(ticker.MultipleLocator(20))
ax1.yaxis.set_minor_locator(ticker.MultipleLocator(10))
ax2.xaxis.set_major_locator(ticker.MultipleLocator(1))
ax2.xaxis.set_minor_locator(ticker.MultipleLocator(0.5))
ax2.yaxis.set_major_locator(ticker.MultipleLocator(1e4))
ax2.yaxis.set_minor_locator(ticker.MultipleLocator(5e3))
ax2.yaxis.set_major_formatter(EngFormatter(unit=''))
fig.savefig(os.path.basename(self.image.file) + ".pdf")
@QtCore.pyqtSlot()
def onLinePickedFromGraph(self):
logger.debug('onLinePickedFromGraph')
self.selectedLine = self.grph.selectedLine if self.grph.selectedLine is not None else None
if self.selectedLine is not None:
self.image.selectedLine = self.selectedLine
self.statusbar.showMessage("line %d selected" % self.selectedLine)
@QtCore.pyqtSlot()
def onLinePickedFromImage(self):
logger.debug('onLinePickedFromImage')
self.selectedLine = self.image.selectedLine['n'] if self.image.selectedLine is not None else None
if self.selectedLine is not None:
self.statusbar.showMessage("line %d selected" % self.selectedLine)
class ConnectionStep(Step):
"""
A connection step which waits for all sensors to have good signal for 10 seconds.
"""
update_bars_signal = pyqtSignal()
end_connection_signal = pyqtSignal()
def __init__(self, params):
params["next_button"] = True
super(ConnectionStep, self).__init__(params)
self.time_to_finish = 5
self.f_widget = QWidget()
self.f_layout = QVBoxLayout()
self.progress_bars = [QProgressBar() for _ in range(4)]
self.timers = [QElapsedTimer() for _ in range(4)]
for timer in self.timers:
timer.invalidate()
self.title_label = QLabel("Adjust the headband until all of the bars are full.")
font = self.title_label.font()
font.setPointSize(28)
font.setBold(False)
self.title_label.setFont(font)
self.title_label.setAlignment(Qt.AlignCenter)
self.title_label.setMaximumHeight(100)
self.f_layout.addWidget(self.title_label)
self.colors = ["#ea6a1f", "#009986", "#555c99", "#d20e8a"]
for bar, color in zip(self.progress_bars, self.colors):
bar.setMinimum(0)
bar.setMaximum(self.time_to_finish * 1000)
bar.setTextVisible(False)
bar.setStyleSheet(
(
u" QProgressBar::chunk {{ background: {0:s}; }}"
+ u" QProgressBar {{border: 1px solid gray; height: 60px}}"
).format(color)
)
self.f_layout.addWidget(bar)
self.update_bars_signal.connect(self.update_bars)
self.end_connection_signal.connect(self.endStep)
self.f_widget.setLayout(self.f_layout)
self.grid.addWidget(self.f_widget)
def startStep(self, callback):
print "starting connection step"
muselo.server.register_listener("/muse/elements/horseshoe", self.receive_horseshoe)
super(ConnectionStep, self).startStep(callback)
def receive_horseshoe(self, path, args):
good = 0
for idx, (conn, timer) in enumerate(zip(args, self.timers)):
if conn == 1:
if not timer.isValid():
timer.start()
else:
if timer.elapsed() / 1e3 > self.time_to_finish:
good += 1
else:
timer.invalidate()
self.update_bars_signal.emit()
if good == 4:
self.end_connection_signal.emit()
def update_bars(self):
for bar, timer in zip(self.progress_bars, self.timers):
if timer.isValid():
bar.setValue(timer.elapsed()) # / 10)
else:
bar.setValue(0)
def endStep(self):
muselo.server.remove_listener("/muse/elements/horseshoe", self.receive_horseshoe)
self.horseshoe.stop()
self.f_widget.close()
super(ConnectionStep, self).endStep()
