class NavEpochsDialog(QDialog):
def __init__(self, parent, epochs):
super().__init__(parent)
self.resize(1000, 800)
self.epochs = epochs.copy().pick_types(eeg=True, meg=True)
channels = self.epochs.info['ch_names']
self.channels = QListWidget()
self.channels.insertItems(0, channels)
self.channels.setSelectionMode(QListWidget.SingleSelection)
self.layout = QHBoxLayout(self)
self.layout.addWidget(self.channels)
self.fig = plt.figure(figsize=(10, 10))
self.canvas = FigureCanvas(self.fig)
self.layout.addWidget(self.canvas)
self.channels.item(0).setSelected(True)
self.channels.itemSelectionChanged.connect(self.update)
self.update()
def update(self):
self.fig.clear()
gs = self.fig.add_gridspec(2, 10)
ax = [self.fig.add_subplot(gs[0, :9]),
self.fig.add_subplot(gs[1, :10]),
self.fig.add_subplot(gs[0, 9])]
index = self.epochs.info['ch_names'].index(
self.channels.selectedItems()[0].data(0))
mne.viz.plot_epochs_image(self.epochs, index,
axes=ax, show=False)[0]
# add the new canvas at the position of the old one
self.canvas.draw()
def __init__(self, fileInfo, parent=None):
super(ApplicationsTab, self).__init__(parent)
topLabel = QLabel("Open with:")
applicationsListBox = QListWidget()
applications = []
for i in range(1, 31):
applications.append("Application %d" % i)
applicationsListBox.insertItems(0, applications)
alwaysCheckBox = QCheckBox()
if fileInfo.suffix():
alwaysCheckBox = QCheckBox("Always use this application to open "
"files with the extension '%s'" % fileInfo.suffix())
else:
alwaysCheckBox = QCheckBox("Always use this application to open "
"this type of file")
layout = QVBoxLayout()
layout.addWidget(topLabel)
layout.addWidget(applicationsListBox)
layout.addWidget(alwaysCheckBox)
self.setLayout(layout)
class EpochingDialog(QDialog):
def __init__(self, parent, events, raw, title="Epoching..."):
super().__init__(parent)
self.setWindowTitle(title)
selected = None
event_labels = unique(events[:, 2]).astype(str)
self.events = events
grid = QGridLayout(self)
grid.addWidget(QLabel("Choose Marker"), 1, 0, 1, 1)
self.labels = QListWidget()
self.labels.insertItems(0, event_labels)
self.labels.setSelectionMode(QListWidget.ExtendedSelection)
if selected is not None:
for i in range(self.labels.count()):
if self.labels.item(i).data(0) == selected:
self.labels.item(i).setSelected(True)
grid.addWidget(self.labels, 1, 1, 1, 2)
grid.addWidget(QLabel("Interval around event"), 2, 0, 1, 1)
self.tmin = QLineEdit(self)
self.tmax = QLineEdit(self)
grid.addWidget(self.tmin, 2, 1, 1, 1)
grid.addWidget(self.tmax, 2, 2, 1, 1)
self.baseline = QCheckBox("&Baseline Correction")
grid.addWidget(self.baseline, 3, 0, 1, 1)
self.a = QLineEdit(self)
self.b = QLineEdit(self)
grid.addWidget(self.a, 3, 1, 1, 1)
grid.addWidget(self.b, 3, 2, 1, 1)
buttonbox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
buttonbox.accepted.connect(self.accept)
buttonbox.rejected.connect(self.reject)
grid.addWidget(buttonbox, 5, 2, 2, 2)
class SelectLocator(QWidget):
def doConnect(self):
i = self.locatorW.selectedItems()
if (i):
item = i[0]
addr = item.text()
try:
port = 15701
self.glob.socket.connect("tcp://" + addr + ":" + str(port))
self.glob.tabW.setTabEnabled(1, True)
self.glob.tabW.setCurrentIndex(1)
self.glob.Session.update()
except Exception as e:
print(e)
def __init__(self, main, parent=None):
super(SelectLocator, self).__init__(parent)
self.glob = main
mainLayout = QVBoxLayout()
self.locatorW = QListWidget()
locators = ['127.0.0.1'] # , '192.168.6.111']
self.locatorW.insertItems(0, locators)
btnW = QPushButton('Connect')
btnW.clicked.connect(self.doConnect)
mainLayout.addWidget(self.locatorW)
mainLayout.addWidget(btnW)
# mainLayout.addStretch(0)
self.setLayout(mainLayout)
class SelectLocator(QWidget):
def doConnect(self):
i = self.locatorW.selectedItems()
if (i):
item = i[0]
addr = item.text()
try:
port = 15701
self.glob.socket.connect("tcp://" + addr + ":" + str(port))
self.glob.tabW.setTabEnabled(1, True)
self.glob.tabW.setCurrentIndex(1)
self.glob.Session.update()
except Exception as e:
print(e)
def __init__(self, main, parent=None):
super(SelectLocator, self).__init__(parent)
self.glob = main
mainLayout = QVBoxLayout()
self.locatorW = QListWidget()
#'127.0.0.1',
locators = ['192.168.6.111']
self.locatorW.insertItems(0, locators)
btnW = QPushButton('Connect')
btnW.clicked.connect(self.doConnect)
mainLayout.addWidget(self.locatorW)
mainLayout.addWidget(btnW)
# mainLayout.addStretch(0)
self.setLayout(mainLayout)
class PickChannelsDialog(QDialog):
def __init__(self, parent, channels, selected=[], title="Pick channels"):
super().__init__(parent)
self.setWindowTitle(title)
self.initial_selection = selected
vbox = QVBoxLayout(self)
self.channels = QListWidget()
self.channels.insertItems(0, channels)
self.channels.setSelectionMode(QListWidget.ExtendedSelection)
for i in range(self.channels.count()):
if self.channels.item(i).data(0) in selected:
self.channels.item(i).setSelected(True)
vbox.addWidget(self.channels)
self.buttonbox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
vbox.addWidget(self.buttonbox)
self.buttonbox.accepted.connect(self.accept)
self.buttonbox.rejected.connect(self.reject)
self.channels.itemSelectionChanged.connect(self.toggle_buttons)
self.toggle_buttons() # initialize OK button state
@pyqtSlot()
def toggle_buttons(self):
"""Toggle OK button.
"""
selected = [item.data(0) for item in self.channels.selectedItems()]
if selected != self.initial_selection:
self.buttonbox.button(QDialogButtonBox.Ok).setEnabled(True)
else:
self.buttonbox.button(QDialogButtonBox.Ok).setEnabled(False)
def __init__(self, fileInfo, parent=None):
super(ApplicationsTab, self).__init__(parent)
topLabel = QLabel("Open with:")
applicationsListBox = QListWidget()
applications = []
for i in range(1, 31):
applications.append("Application %d" % i)
applicationsListBox.insertItems(0, applications)
alwaysCheckBox = QCheckBox()
if fileInfo.suffix():
alwaysCheckBox = QCheckBox(
"Always use this application to open "
"files with the extension '%s'" % fileInfo.suffix()
)
else:
alwaysCheckBox = QCheckBox(
"Always use this application to open " "this type of file"
)
layout = QVBoxLayout()
layout.addWidget(topLabel)
layout.addWidget(applicationsListBox)
layout.addWidget(alwaysCheckBox)
self.setLayout(layout)
class PickChannelsDialog(QDialog):
"""
Defines the Dialog for selected channels for different cases (picked, excluded, filter...)
"""
signal_paramChanged = pyqtSignal(list)
# ----------------------------------------------------------------------
def __init__(self, channels, selected=[], title="Pick channels"):
"""
Constructor.
"""
super().__init__()
self.setWindowTitle(title)
self.selection = selected
vbox = QVBoxLayout(self)
self.channels = QListWidget()
self.channels.insertItems(0, channels)
self.channels.setSelectionMode(QListWidget.ExtendedSelection)
for i in range(self.channels.count()):
if self.channels.item(i).data(0) in selected:
self.channels.item(i).setSelected(True)
vbox.addWidget(self.channels)
self.buttonbox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
vbox.addWidget(self.buttonbox)
self.buttonbox.accepted.connect(self.accept)
self.buttonbox.rejected.connect(self.reject)
self.buttonbox.accepted.connect(self.on_modify)
self.channels.itemSelectionChanged.connect(self.toggle_buttons)
self.toggle_buttons() # initialize OK button state
@pyqtSlot()
# ----------------------------------------------------------------------
def toggle_buttons(self):
"""
Toggle OK button.
"""
selected = [item.data(0) for item in self.channels.selectedItems()]
if selected != self.selection:
self.buttonbox.button(QDialogButtonBox.Ok).setEnabled(True)
self.selected = selected
else:
self.buttonbox.button(QDialogButtonBox.Ok).setEnabled(False)
# ----------------------------------------------------------------------
def on_modify(self):
""""""
self.signal_paramChanged[list].emit(self.selected)
class PickChannels(QDialog):
def __init__(self, parent, channels, selected=[]):
super().__init__(parent)
self.parent = parent
self.setWindowTitle('Pick Channels')
self.initial_selection = selected
self.layout = QVBoxLayout(self)
self.layout.addWidget(
QLabel('Please select all scalp channels \n' +
'for a correct topomap plotting'))
self.init_channel_box(channels, selected)
self.init_buttonbox()
self.ch.itemSelectionChanged.connect(self.init_buttons)
self.init_buttons()
# ---------------------------------------------------------------------
def init_buttonbox(self):
"""Initialize button box
"""
self.buttonbox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
(self.buttonbox.button(QDialogButtonBox.Ok).clicked.connect(
self.close))
(self.buttonbox.button(QDialogButtonBox.Cancel).clicked.connect(
self.close))
self.layout.addWidget(self.buttonbox)
# ---------------------------------------------------------------------
def init_channel_box(self, channels, selected):
"""Initialize list
"""
self.ch = QListWidget()
self.ch.insertItems(0, channels)
self.ch.setSelectionMode(QListWidget.ExtendedSelection)
for i in range(self.ch.count()):
if self.ch.item(i).data(0) in selected:
self.ch.item(i).setSelected(True)
self.layout.addWidget(self.ch)
# ---------------------------------------------------------------------
def init_buttons(self):
"""Toggle OK button
"""
selected = [item.data(0) for item in self.ch.selectedItems()]
if selected != self.initial_selection:
self.buttonbox.button(QDialogButtonBox.Ok).setEnabled(True)
else:
self.buttonbox.button(QDialogButtonBox.Ok).setEnabled(False)
self.parent.set_selected_ch(selected)
def __init__(self, repo, parent=None):
super().__init__()
topLabel = QLabel(_("files in repo") + ':')
applicationsListBox = QListWidget()
applications = []
applications = Pacman.Ql(repo.name)
applicationsListBox.insertItems(0, applications)
layout = QVBoxLayout()
layout.addWidget(topLabel)
layout.addWidget(applicationsListBox)
self.setLayout(layout)
def __init__(self, repo, parent=None):
super().__init__()
topLabel = QLabel(_("files in repo")+':')
applicationsListBox = QListWidget()
applications = []
applications = Pacman.Ql(repo.name)
applicationsListBox.insertItems(0, applications)
layout = QVBoxLayout()
layout.addWidget(topLabel)
layout.addWidget(applicationsListBox)
self.setLayout(layout)
class MontageDialog(QDialog):
def __init__(self, parent, montages, selected=None):
super().__init__(parent)
self.setWindowTitle("Set montage")
vbox = QVBoxLayout(self)
self.montages = QListWidget()
self.montages.insertItems(0, montages)
self.montages.setSelectionMode(QListWidget.SingleSelection)
if selected is not None:
for i in range(self.montages.count()):
if self.montages.item(i).data(0) == selected:
self.montages.item(i).setSelected(True)
vbox.addWidget(self.montages)
hbox = QHBoxLayout()
self.view_button = QPushButton("View")
self.view_button.clicked.connect(self.view_montage)
hbox.addWidget(self.view_button)
hbox.addStretch()
self.buttonbox = QDialogButtonBox(QDialogButtonBox.Ok |
QDialogButtonBox.Cancel)
hbox.addWidget(self.buttonbox)
vbox.addLayout(hbox)
self.buttonbox.accepted.connect(self.accept)
self.buttonbox.rejected.connect(self.reject)
self.montages.itemSelectionChanged.connect(self.toggle_buttons)
self.toggle_buttons() # initialize OK and View buttons state
@pyqtSlot()
def toggle_buttons(self):
"""Toggle OK and View buttons.
"""
if self.montages.selectedItems():
self.buttonbox.button(QDialogButtonBox.Ok).setEnabled(True)
self.view_button.setEnabled(True)
else:
self.buttonbox.button(QDialogButtonBox.Ok).setEnabled(False)
self.view_button.setEnabled(False)
def view_montage(self):
name = self.montages.selectedItems()[0].data(0)
montage = make_standard_montage(name)
fig = montage.plot(show_names=True, show=False)
win = fig.canvas.manager.window
win.setWindowModality(Qt.WindowModal)
win.setWindowTitle("Montage")
win.findChild(QStatusBar).hide()
win.findChild(QToolBar).hide()
fig.show()
def run(self):
items = []
for i in range(1, 50):
items.append("Application %d" % i)
listBox = QListWidget()
listBox.insertItems(0, items)
listBox.insertItem(1, 'insert %d' % listBox.__len__())
listBox.resize(200, 150)
listBox.move(10, 10)
layout = QVBoxLayout()
layout.addWidget(listBox)
self.setLayout(layout)
self.setGeometry(300, 300, 300, 200)
self.setWindowTitle('Tooltips')
self.show()
class PickChannelsDialog(QDialog):
def __init__(self, parent, channels, selected=[], title="Pick channels"):
super().__init__(parent)
self.setWindowTitle(title)
vbox = QVBoxLayout(self)
self.channels = QListWidget()
self.channels.insertItems(0, channels)
self.channels.setSelectionMode(QListWidget.ExtendedSelection)
for i in range(self.channels.count()):
if self.channels.item(i).data(0) in selected:
self.channels.item(i).setSelected(True)
vbox.addWidget(self.channels)
buttonbox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
vbox.addWidget(buttonbox)
buttonbox.accepted.connect(self.accept)
buttonbox.rejected.connect(self.reject)
class Export(QDialog):
def __init__(self, df, *args, **kwargs):
super(Export, self).__init__(*args, **kwargs)
self.df = df
self.selected_columns = []
self.setWindowTitle("Export")
self.layout = QVBoxLayout()
self.__init_list()
self.__init_buttons()
self.setLayout(self.layout)
def __init_list(self):
self.selected = QLabel('Export columns: ')
self.listwidget = QListWidget()
self.listwidget.setSelectionMode(2)
self.listwidget.insertItems(0, self.df.columns.tolist())
self.listwidget.clicked.connect(self.__add_columns)
self.layout.addWidget(self.selected)
self.layout.addWidget(self.listwidget)
def __add_columns(self):
self.selected_columns = [e.text() for e in self.listwidget.selectedItems()]
self.selected.setText(f'Export columns')
def __init_buttons(self):
buttons = QDialogButtonBox.Ok | QDialogButtonBox.Cancel
button_box = QDialogButtonBox(buttons)
button_box.accepted.connect(self.accept)
button_box.rejected.connect(self.reject)
self.layout.addWidget(button_box)
def export_to_file(self):
if self.selected_columns:
dlg = QFileDialog()
dlg.setFileMode(QFileDialog.AnyFile)
if dlg.exec_():
filenames = dlg.selectedFiles()
self.df[self.selected_columns].to_csv(filenames[0], index=False)
def __init__(self):
super().__init__()
label = QLabel("Terms And Conditions")
listWidget = QListWidget()
list = []
for i in range(1, 20):
list.append("This Is Terms And Condition")
listWidget.insertItems(0, list)
checkBox = QCheckBox("Check The Terms And Conditions")
layout = QVBoxLayout()
layout.addWidget(label)
layout.addWidget(listWidget)
layout.addWidget(checkBox)
self.setLayout(layout)
def __init__(self):
super().__init__()
label = QLabel("Visualización de resultados")
listWidget = QListWidget()
list = []
for i in range(1,7):
list.append("Punto de medición número N")
listWidget.insertItems(0, list)
checkBox = QCheckBox("Guardar imagen como archivo PNG")
layout = QVBoxLayout()
layout.addWidget(label)
layout.addWidget(listWidget)
layout.addWidget(checkBox)
self.setLayout(layout)
class PrestadorIn(QWidget):
def __init__(self, prestador):
self.prestador = prestador
super().__init__()
self.resize(200, 200)
self.move(200, 100)
self.setWindowTitle('BIENVENIDO ' + prestador.nombre)
mainlay = QVBoxLayout()
self.solicitudes = QListWidget(self)
opciones = buscar.solicitudesprestador(self.prestador)
opciones = [(x.nombre + '\t' + x.celular) for x in opciones]
self.solicitudes.insertItems(0, ['Nombre\tCelular'])
self.solicitudes.insertItems(1, opciones)
mainlay.addWidget(self.solicitudes)
self.closebutton = QPushButton('CERRAR')
self.closebutton.clicked.connect(self.close)
mainlay.addWidget(self.closebutton)
self.setLayout(mainlay)
class PDFMerger(QMainWindow):
def __init__(self):
super().__init__()
self.file_list = QListWidget()
self.init_ui()
def init_ui(self):
self.setCentralWidget(self.file_list)
self.statusBar()
menu_open_file = QAction(QIcon('open.png'), 'Open', self)
menu_open_file.setShortcut('Ctrl+O')
menu_open_file.setStatusTip('Open new Files')
menu_open_file.triggered.connect(self.show_dialog)
btn_merge_files = QPushButton("Merge Files", self)
btn_merge_files.move(60, 64)
btn_merge_files.clicked.connect(self.merge_files)
menu = self.menuBar()
menu = menu.addMenu('&File')
menu.addAction(menu_open_file)
self.setGeometry(300, 300, 550, 450)
self.setWindowTitle('PDF Merger')
self.show()
def show_dialog(self):
home_dir = str(Path.home())
filenames = QFileDialog.getOpenFileNames(self, 'Open file', home_dir)
if filenames[0]:
self.file_list.insertItems(0, filenames[0])
def merge_files(self):
print("Merge files")
class ActorWidget(QWidget):
def __init__(self, parent=None):
super().__init__(parent)
mainLayout = QHBoxLayout()
mainLayout.setContentsMargins(0, 0, 0, 0)
self._listWidget = QListWidget()
self._listWidget.itemDoubleClicked.connect(self.onActorNameDblClicked)
mainLayout.addWidget(self._listWidget)
right = QVBoxLayout()
right.setAlignment(Qt.AlignTop)
self._newItem = QLineEdit()
self._add = QPushButton('Add')
self._add.clicked.connect(self.onAddClicked)
self._remove = QPushButton('Remove')
self._remove.clicked.connect(self.onRemoveClicked)
right.addWidget(self._newItem)
right.addWidget(self._add)
right.addWidget(self._remove)
mainLayout.addLayout(right)
self.setLayout(mainLayout)
def onActorNameDblClicked(self, item):
self._newItem.setText(item.text())
def onAddClicked(self):
text = self._newItem.text().strip()
if not len(text): return
items = self._listWidget.findItems(text, Qt.MatchExactly)
if (len(items) > 0):
print('already exists actor name!')
return
self._listWidget.addItem(text)
self._newItem.clear()
QApplication.postEvent(
self, QKeyEvent(QEvent.KeyPress, Qt.Key_Enter, Qt.NoModifier))
def onRemoveClicked(self):
if not self._listWidget.currentItem():
return
item = self._listWidget.currentItem()
#print(item.text())
self._listWidget.takeItem(self._listWidget.row(item))
QApplication.postEvent(
self, QKeyEvent(QEvent.KeyPress, Qt.Key_Enter, Qt.NoModifier))
def getValue(self):
vals = []
for i in range(self._listWidget.count()):
vals.append(self._listWidget.item(i).text())
return ';'.join(vals)
def setValue(self, value):
self._listWidget.clear()
if not value: return
self._listWidget.insertItems(0, value.split(';'))
Value = pyqtProperty(str, getValue, setValue)
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.status_bar = QStatusBar()
self.samples_list_widget = QListWidget()
self.button_process = QPushButton()
self.label_panel_title = QLabel('<b>Samples Panel</b>')
self.plt = Plotter(self)
self.active_plt = False
self.init_ui()
def init_ui(self):
# Setup the actions =======================================================
# Open Action
open_action = QAction(QIcon('Resources/Icons/fileopen.png'),
'Load &ERP data', self)
open_action.setStatusTip('Open Data Samples')
open_action.triggered.connect(self.menu_open)
# Exit Action
exit_action = QAction(QIcon('Resources/Icons/exit.png'), '&Exit', self)
exit_action.setShortcut('Ctrl+Q')
exit_action.setStatusTip('Exit application')
exit_action.triggered.connect(qApp.quit)
# About Action
about_action = QAction(QIcon('Resources/Icons/about.png'), '&About',
self)
about_action.setStatusTip('About')
about_action.triggered.connect(self.menu_about)
# Generate the menu bar ====================================================
menu_bar = self.menuBar()
file_menu = menu_bar.addMenu('&File')
help_menu = menu_bar.addMenu('&Help')
# Add actions to file menu
file_menu.addAction(open_action)
file_menu.addAction(exit_action)
# Add actions to Help menu
help_menu.addAction(about_action)
# Set status bar
self.setStatusBar(self.status_bar)
# Connect list with status bar
self.samples_list_widget.itemClicked.connect(self.item_selected)
# Set the main window content ==================================================================================
self.samples_list_widget.setMaximumWidth(200)
self.button_process.setText('Plot Sample...')
self.label_panel_title.setAlignment(QtCore.Qt.AlignHCenter)
# Set the params plot Group box ============================
param_gb = QGroupBox()
param_gb.setTitle('Plot Parameters')
layout_params = QVBoxLayout(param_gb)
label_params1 = QLabel('Time Interval: ')
self.spinbox_params1 = QSpinBox()
label_params2 = QLabel('Amplitude Min: ')
self.spinbox_params2 = QDoubleSpinBox()
self.spinbox_params1.setMaximum(TIME_MAX)
self.spinbox_params1.setValue(80)
self.spinbox_params2.setValue(0.0)
self.spinbox_params2.setSingleStep(0.1)
self.spinbox_params2.setDecimals(1)
layout_amplitude = QHBoxLayout()
layout_amplitude.addWidget(label_params1)
layout_amplitude.addWidget(self.spinbox_params1)
layout_time = QHBoxLayout()
layout_time.addWidget(label_params2)
layout_time.addWidget(self.spinbox_params2)
self.radio_mode1 = QRadioButton()
self.radio_mode2 = QRadioButton()
self.radio_mode1.setText('Channel Order')
self.radio_mode2.setText('Head Order')
self.radio_mode1.setChecked(True)
self.grid_checkbox = QCheckBox()
self.grid_checkbox.setText('Show Grid')
self.grid_checkbox.setChecked(True)
self.grid_checkbox.clicked.connect(self.grid_selection)
layout_params.addLayout(layout_amplitude)
layout_params.addLayout(layout_time)
layout_params.addWidget(self.radio_mode1)
layout_params.addWidget(self.radio_mode2)
panel_layout = QVBoxLayout()
panel_layout.addWidget(self.label_panel_title)
panel_layout.addWidget(self.samples_list_widget)
panel_layout.addWidget(param_gb)
panel_layout.addStretch(1)
panel_layout.addWidget(self.grid_checkbox)
panel_layout.addWidget(self.button_process)
central_widget = QWidget()
self.setCentralWidget(central_widget)
main_layout = QHBoxLayout()
central_widget.setLayout(main_layout)
main_layout.addWidget(self.plt)
main_layout.addLayout(panel_layout)
# Set window parameters
self.status_bar.showMessage("Welcome to ERP Visualization Tool")
self.setGeometry(0, 0, 1000, 600)
self.setWindowTitle('Visual ERP')
self.button_process.clicked.connect(self.plot_sample)
self.showMaximized()
self.show()
# For debug purposes
self.menu_open()
def grid_selection(self, state):
if not self.active_plt:
return
self.plt.plotter.grid(state)
self.plt.plotter.axes.get_xaxis().set_visible(state)
self.plt.plotter.axes.get_yaxis().set_visible(state)
self.plt.draw()
def item_selected(self, item):
# TODO: Manage changes in selection with keys
self.status_bar.showMessage('Sample: %s' % item.text())
def menu_open(self):
# TODO: File chooser
self.data_object = DataObject('data_erp.mat')
self.samples_list_widget.clear()
self.samples_list_widget.insertItems(0, self.data_object.get_titles())
def menu_about(self):
print("About")
def plot_sample(self):
# Error management
selected = self.samples_list_widget.currentItem()
if selected is None:
return
self.plt.renew()
sample_title = selected.text()
self.status_bar.showMessage('Plotting (%s), Please wait ...' %
sample_title)
self.plot_mode1(self.data_object.get_sample(sample_title))
self.status_bar.showMessage('Plotting (%s), Done.' % sample_title)
self.active_plt = True
def plot_mode1(self, data):
time_interval = self.spinbox_params1.value()
amplitude_min = self.spinbox_params2.value()
shape = self.data_object.get_shape(data)
angle_interval = 360. / shape[0]
pc = PolarConverter(x_range=time_interval, y_min=amplitude_min)
# [Time, Amplitude] vectors
angle = 0
ch = 1
angles = np.arange(0., 2 * 3.1416, angle_interval * 3.1416 / 180)
# big_plot = []
model1_labels = []
for channel in data:
polar_data = pc.polar_scatter_conversion(channel)
r = polar_data[0]
theta = np.ones([1, len(r)]) * angle * np.pi / 180.0
size = np.abs(polar_data[1]) * FAC_AMP
color = polar_data[2]
model1_labels.append('[%i]' % ch)
# big_plot.append([theta, r, size, color])
self.plt.plot_scatter(theta, r, size, color)
angle += angle_interval
ch += 1
self.plt.plotter.set_ylim(0, shape[1] + 100)
self.plt.plotter.set_xticks(angles)
self.plt.plotter.set_xticklabels(model1_labels)
self.grid_selection(self.grid_checkbox.isChecked())
self.plt.draw()
class Solicitar(QWidget):
def __init__(self, user, prestadores, text):
super().__init__()
self.user = user
self.prestadores = prestadores
self.resize(200, 250)
self.move(200, 100)
self.setWindowTitle('SOLICITAR')
mainlay = QVBoxLayout()
self.aquevino = QLabel(text.upper() + ' DISPONIBLES')
self.aquevino.setAlignment(Qt.AlignCenter)
mainlay.addWidget(self.aquevino)
self.lista = QComboBox(self)
mainlay.addWidget(self.lista)
if not len(self.prestadores) == 0:
opciones = []
for p in self.prestadores:
opciones.append(p.nombre)
self.lista.insertItems(0, opciones)
self.lista.setCurrentIndex(0)
self.lista.currentIndexChanged.connect(self.changeshit)
self.dirlabel = QLabel('Direccion:')
self.dirinfo = QLabel(self.prestadores[0].direccion)
dirlay = QHBoxLayout()
dirlay.addWidget(self.dirlabel)
dirlay.addWidget(self.dirinfo)
mainlay.addLayout(dirlay)
self.emaillabel = QLabel('Correo:')
self.emailinfo = QLabel(self.prestadores[0].email)
emaillay = QHBoxLayout()
emaillay.addWidget(self.emaillabel)
emaillay.addWidget(self.emailinfo)
mainlay.addLayout(emaillay)
self.cellabel = QLabel('Celular:')
self.celinfo = QLabel(self.prestadores[0].celular)
cellay = QHBoxLayout()
cellay.addWidget(self.cellabel)
cellay.addWidget(self.celinfo)
mainlay.addLayout(cellay)
rating = '-/-'
self.ratelabel = QLabel('Calificaion:')
if len(self.prestadores[0].calificacion) > 0:
rating = str(
average([int(x)
for x in self.prestadores[0].calificacion]))
self.rateinfo = QLabel(rating)
ratelay = QHBoxLayout()
ratelay.addWidget(self.ratelabel)
ratelay.addWidget(self.rateinfo)
mainlay.addLayout(ratelay)
self.comments = QListWidget(self)
if len(self.prestadores[0].comentarios) > 0:
self.comments.insertItems(0, self.prestadores[0].comentarios)
else:
self.comments.insertItems(0, ['-----NO HAY COMENTARIOS-----'])
commentlay = QHBoxLayout()
commentlay.addWidget(self.comments)
commentlay.setAlignment(Qt.AlignCenter)
mainlay.addLayout(commentlay)
self.solicitarbutton = QPushButton('SOLICITAR')
self.solicitarbutton.clicked.connect(self.solicitar)
mainlay.addWidget(self.solicitarbutton)
else:
self.empty = QLabel('NO HAY PRESTADORES\nDISPONIBLES PARA USTED')
self.empty.setAlignment(Qt.AlignCenter)
mainlay.addWidget(self.empty)
self.cancelarbutton = QPushButton('CANCELAR')
self.cancelarbutton.clicked.connect(self.close)
mainlay.addWidget(self.cancelarbutton)
self.setLayout(mainlay)
def solicitar(self):
response = solicitar.ejecutar(
self.prestadores[self.lista.currentIndex()], self.user)
if response:
QMessageBox.about(self, 'EXITO', 'Se registro la solicitud')
else:
QMessageBox.about(self, 'ERROR',
'Ya tiene una solicitud\ncon este prestador.')
def changeshit(self):
i = self.lista.currentIndex()
self.dirinfo.setText(self.prestadores[i].direccion)
self.emailinfo.setText(self.prestadores[i].email)
self.celinfo.setText(self.prestadores[i].celular)
rating = '-/-'
if len(self.prestadores[i].calificacion) > 0:
rating = str(
average([int(x) for x in self.prestadores[i].calificacion]))
self.rateinfo.setText(rating)
self.comments.clear()
if len(self.prestadores[i].comentarios) > 0:
self.comments.insertItems(0, self.prestadores[i].comentarios)
else:
self.comments.insertItems(0, ['-----NO HAY COMENTARIOS-----'])
class EpochDialog(QDialog):
def __init__(self, parent, events):
super().__init__(parent)
self.setWindowTitle("Create Epochs")
grid = QGridLayout(self)
label = QLabel("Events:")
label.setAlignment(Qt.AlignTop)
grid.addWidget(label, 0, 0, 1, 1)
self.events = QListWidget()
self.events.insertItems(0, unique(events[:, 2]).astype(str))
self.events.setSelectionMode(QListWidget.ExtendedSelection)
grid.addWidget(self.events, 0, 1, 1, 2)
grid.addWidget(QLabel("Interval around events:"), 1, 0, 1, 1)
self.tmin = QDoubleSpinBox()
self.tmin.setMinimum(-10000)
self.tmin.setValue(-0.2)
self.tmin.setSingleStep(0.1)
self.tmin.setAlignment(Qt.AlignRight)
self.tmax = QDoubleSpinBox()
self.tmax.setMinimum(-10000)
self.tmax.setValue(0.5)
self.tmax.setSingleStep(0.1)
self.tmax.setAlignment(Qt.AlignRight)
grid.addWidget(self.tmin, 1, 1, 1, 1)
grid.addWidget(self.tmax, 1, 2, 1, 1)
self.baseline = QCheckBox("Baseline Correction:")
self.baseline.setChecked(True)
self.baseline.stateChanged.connect(self.toggle_baseline)
grid.addWidget(self.baseline, 2, 0, 1, 1)
self.a = QDoubleSpinBox()
self.a.setMinimum(-10000)
self.a.setValue(-0.2)
self.a.setSingleStep(0.1)
self.a.setAlignment(Qt.AlignRight)
self.b = QDoubleSpinBox()
self.b.setMinimum(-10000)
self.b.setValue(0)
self.b.setSingleStep(0.1)
self.b.setAlignment(Qt.AlignRight)
grid.addWidget(self.a, 2, 1, 1, 1)
grid.addWidget(self.b, 2, 2, 1, 1)
self.buttonbox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.buttonbox.accepted.connect(self.accept)
self.buttonbox.rejected.connect(self.reject)
grid.addWidget(self.buttonbox, 3, 0, 1, -1)
self.events.itemSelectionChanged.connect(self.toggle_ok)
self.toggle_ok()
grid.setSizeConstraint(QGridLayout.SetFixedSize)
@pyqtSlot()
def toggle_ok(self):
if self.events.selectedItems():
self.buttonbox.button(QDialogButtonBox.Ok).setEnabled(True)
else:
self.buttonbox.button(QDialogButtonBox.Ok).setEnabled(False)
@pyqtSlot()
def toggle_baseline(self):
if self.baseline.isChecked():
self.a.setEnabled(True)
self.b.setEnabled(True)
else:
self.a.setEnabled(False)
self.b.setEnabled(False)
class WidgetGallery(QDialog):
def __init__(self, parent=None):
super(WidgetGallery, self).__init__(parent)
self.init_mediaplayer()
self.originalPalette = QApplication.palette()
styleComboBox = QComboBox()
styleComboBox.addItems(QStyleFactory.keys())
styleLabel = QLabel("&Style:")
styleLabel.setBuddy(styleComboBox)
disableWidgetsCheckBox = QCheckBox("&Inactive Buttons")
self.createTopLeftGroupBox()
self.createTopRightGroupBox()
styleComboBox.activated[str].connect(self.changeStyle)
disableWidgetsCheckBox.toggled.connect(
self.topLeftGroupBox.setDisabled)
disableWidgetsCheckBox.toggled.connect(
self.topRightGroupBox.setDisabled)
topLayout = QHBoxLayout()
topLayout.addWidget(styleLabel)
topLayout.addWidget(styleComboBox)
topLayout.addStretch(1)
topLayout.addWidget(disableWidgetsCheckBox)
mainLayout = QGridLayout()
mainLayout.addLayout(topLayout, 0, 0, 1, 2)
mainLayout.addWidget(self.topLeftGroupBox, 1, 0)
mainLayout.addWidget(self.topRightGroupBox, 1, 1)
mainLayout.setRowStretch(5, 5)
mainLayout.setRowStretch(2, 1)
mainLayout.setColumnStretch(0, 1)
mainLayout.setColumnStretch(1, 1)
self.setLayout(mainLayout)
self.setWindowTitle("Radios Angola")
self.changeStyle('windows')
def init_mediaplayer(self):
self.instance = vlc.Instance(
'--quiet --audio-visual visualizer --effect-list spectrum')
self.media = None
# Create an empty vlc media player
self.mediaplayer = self.instance.media_player_new()
self.mediaplayer.video_set_aspect_ratio("16:5")
self.mediaplayer.video_set_scale(0.25)
self.alsa = alsaaudio.Mixer(alsaaudio.mixers()[0])
self.is_paused = False
def getStatus(self):
status = {
"stream length": self.mediaplayer.get_length(),
"current time": self.mediaplayer.get_time(),
"volume media player": self.mediaplayer.audio_get_volume(),
"volume ": self.alsa.getvolume()[0],
"state": self.mediaplayer.get_state()
}
return status
def changeStyle(self, styleName):
QApplication.setStyle(QStyleFactory.create(styleName))
def select_radio(self, qmodelindex):
self.stop_stream()
self.station_name = self.radio_stations_list.currentItem()
if self.station_name is None:
self.video_frame.setText("reloading ... ")
else:
self.radio_obj = network.get_station_obj(self.radio_json)
self.selected = [
radio for radio in self.radio_obj
if radio.r_name == self.station_name.text()
]
self.load_station(self.selected[0])
def set_volume(self, volume):
self.alsa.setvolume(volume)
def refresh_stream(self):
self.video_frame.setText("reloading ... ")
self.stop_stream()
self.play_pause()
def previous_station(self, qmodelindex):
self.stop_stream()
try:
curr_position = self.radio_stations_list.indexFromItem(
self.station_name).row()
previous_pos = curr_position - 1
if previous_pos < 0:
previous_station = self.radio_stations_list.item(
len(self.radio_obj) - 1)
self.radio_stations_list.setCurrentItem(previous_station)
self.select_radio(qmodelindex)
else:
previous_station = self.radio_stations_list.item(previous_pos)
self.radio_stations_list.setCurrentItem(previous_station)
self.select_radio(qmodelindex)
except AttributeError:
self.video_frame.setText("select a radio station")
pass
def next_station(self, qmodelindex):
self.stop_stream()
try:
curr_position = self.radio_stations_list.indexFromItem(
self.station_name).row()
next_pos = curr_position + 1
if (next_pos > len(self.radio_obj) - 1):
next_station = self.radio_stations_list.item(0)
self.radio_stations_list.setCurrentItem(next_station)
self.select_radio(qmodelindex)
else:
next_station = self.radio_stations_list.item(next_pos)
self.radio_stations_list.setCurrentItem(next_station)
self.select_radio(qmodelindex)
except AttributeError:
self.video_frame.setText("select a radio station")
pass
def stop_stream(self):
self.reset_video_frame()
self.mediaplayer.stop()
self.b_play.setIcon(QIcon('application/img/play.png'))
self.is_paused = False
def load_station(self, radio_station):
self.video_frame.setText("loading ... ")
try:
self.media = self.instance.media_new(radio_station.stream_link)
self.mediaplayer.set_media(self.media)
self.media.parse()
# for Linux using the X Server
if sys.platform.startswith('linux'):
self.mediaplayer.set_xwindow(self.video_frame.winId())
# for Windows
elif sys.platform == "win32":
self.mediaplayer.set_hwnd(self.video_frame.winId())
# for MacOS(
elif sys.platform == "darwin":
self.mediaplayer.set_nsobject(int(self.video_frame.winId()))
self.play_pause()
except VLCException as err:
raise err
def play_pause(self):
if self.mediaplayer.is_playing():
self.stop_stream()
self.b_play.setIcon(QIcon('application/img/play.png'))
self.is_paused = True
else:
if self.mediaplayer.play() == -1:
self.video_frame.setText("select a radio station")
self.video_frame.setAlignment(Qt.AlignCenter)
return
self.mediaplayer.play()
self.b_play.setIcon(QIcon('application/img/pause.png'))
self.is_paused = False
self.video_frame.setText("")
def createTopLeftGroupBox(self):
self.topLeftGroupBox = QGroupBox("")
self.video_frame = QLabel()
self.reset_video_frame()
self.b_refresh = QPushButton()
self.b_refresh.setIcon(QIcon("application/img/refresh.png"))
self.b_refresh.setIconSize(QSize(30, 30))
self.b_refresh.setGeometry(QRect(30, 10, 10, 30))
self.b_refresh.setToolTip("Refresh stream")
self.b_refresh.clicked.connect(self.refresh_stream)
self.b_previous = QPushButton()
self.b_previous.setIcon(QIcon("application/img/back.png"))
self.b_previous.setIconSize(QSize(30, 30))
self.b_previous.setGeometry(QRect(30, 10, 10, 30))
self.b_previous.setToolTip("Previous Radio Station")
self.b_previous.clicked.connect(self.previous_station)
self.b_play = QPushButton()
self.b_play.setIcon(QIcon("application/img/play.png"))
self.b_play.setIconSize(QSize(30, 30))
self.b_play.setGeometry(QRect(30, 30, 30, 30))
self.b_play.clicked.connect(self.play_pause)
self.b_next = QPushButton()
self.b_next.setIcon(QIcon("application/img/next.png"))
self.b_next.setIconSize(QSize(30, 30))
self.b_next.setGeometry(QRect(30, 30, 30, 30))
self.b_next.setToolTip("Next Radio Station")
self.b_next.clicked.connect(self.next_station)
self.b_stop = QPushButton()
self.b_stop.setIcon(QIcon("application/img/stop.png"))
self.b_stop.setIconSize(QSize(30, 30))
self.b_stop.setGeometry(QRect(30, 30, 30, 3))
self.b_stop.setToolTip("Stop Streaming")
self.b_stop.clicked.connect(self.stop_stream)
layoutbuttons = QHBoxLayout()
layoutbuttons.addWidget(self.b_refresh)
layoutbuttons.addWidget(self.b_previous)
layoutbuttons.addWidget(self.b_play)
layoutbuttons.addWidget(self.b_next)
layoutbuttons.addWidget(self.b_stop)
self.dial_volume = QDial()
#self.dial_volume.setMaximum(100)
#self.dial_volume.setValue(self.mediaplayer.audio_get_volume())
self.dial_volume.setValue(self.alsa.getvolume()[0])
self.dial_volume.setNotchesVisible(True)
self.dial_volume.setToolTip("Volume")
self.dial_volume.valueChanged.connect(self.set_volume)
layoutbuttons.addWidget(self.dial_volume)
layout = QVBoxLayout()
layout.addWidget(self.video_frame)
layout.addLayout(layoutbuttons)
self.topLeftGroupBox.setLayout(layout)
def createTopRightGroupBox(self):
self.topRightGroupBox = QGroupBox("radio stations")
self.radio_json = network.get_stations_from_api()
if self.radio_json is not None:
self.station_names = network.get_station_names(self.radio_json)
self.radio_stations_list = QListWidget()
self.radio_stations_list.insertItems(0, self.station_names)
self.radio_stations_list.clicked.connect(self.select_radio)
else:
self.radio_stations_list = QListWidget()
self.radio_stations_list.insertItems(
0, ["Server Down .... no radio stations"])
layout = QVBoxLayout()
layout.addWidget(self.radio_stations_list)
self.topRightGroupBox.setLayout(layout)
def reset_video_frame(self):
self.video_frame.setStyleSheet("background-color: black")
self.video_frame.setAutoFillBackground(True)
class FirFilterDialog(QDialog):
def __init__(self, parent, raw):
super().__init__(parent)
self.setWindowTitle("Filter data")
self.raw = raw
vbox = QVBoxLayout(self)
grid = QGridLayout()
grid.addWidget(QLabel("Lower pass-band edge (Hz):"), 0, 0)
self.lowedit = QLineEdit()
self.lowedit.setToolTip("Lower pass-band edge")
grid.addWidget(self.lowedit, 0, 1)
grid.addWidget(QLabel("Upper pass-band edge (Hz):"), 1, 0)
self.highedit = QLineEdit()
self.highedit.setToolTip("Lower pass-band edge")
grid.addWidget(self.highedit, 1, 1)
grid.addWidget(QLabel("Filter_length:"), 2, 0)
self.filter_length_edit = QLineEdit()
self.filter_length_edit.setToolTip(
"""Length of the FIR filter to use:\n """ +
"""‘auto’ (default): The filter length is chosen based""" +
""" on the size of the transition regions""" +
""" (6.6 times the reciprocal of the shortest transition """ +
""" band for fir_window=’hamming’ and fir_design=”firwin2”,""" +
""" and half that for “firwin”). \n """ +
"""str: A human-readable time in units of “s” or “ms”""" +
""" (e.g., “10s” or “5500ms”) will be converted""" +
""" to that number of samples if phase="zero",""" +
""" or the shortest power-of-two length""" +
""" at least that duration for phase="zero-double". \n """ +
""" int: Specified length in samples.""" +
""" For fir_design=”firwin”, this should not be used.""")
self.filter_length_edit.setText("auto")
grid.addWidget(self.filter_length_edit, 2, 1)
grid.addWidget(QLabel("l_trans_bandwidthfloat (Hz):"), 3, 0)
self.l_trans_bandwidth_edit = QLineEdit()
self.l_trans_bandwidth_edit.setToolTip(
"""Width of the transition band""" +
""" at the low cut-off frequency in Hz""" +
""" (high pass or cutoff 1 in bandpass).""" +
""" Can be “auto” (default) to use a multiple of l_freq:")""")
self.l_trans_bandwidth_edit.setText("auto")
grid.addWidget(self.l_trans_bandwidth_edit, 3, 1)
grid.addWidget(QLabel("h_trans_bandwidthfloat (Hz):"), 4, 0)
self.h_trans_bandwidth_edit = QLineEdit()
self.h_trans_bandwidth_edit.setToolTip(
"""Width of the transition band""" +
""" at the high cut-off frequency in Hz""" +
""" (low pass or cutoff 2 in bandpass).""" +
""" Can be “auto” (default) to use a multiple of h_freq:")""")
self.h_trans_bandwidth_edit.setText("auto")
grid.addWidget(self.h_trans_bandwidth_edit, 4, 1)
grid.addWidget(QLabel("Phase:"), 5, 0)
self.phase_edit = QComboBox()
self.phases = {
"Zero": "zero",
"Zero-double": "zero-double",
"Minimum": "minimum"
}
self.phase_edit.addItems(self.phases.keys())
self.phase_edit.setToolTip(
"""if phase='zero',""" +
""" the delay of this filter is compensated for,""" +
""" making it non-causal. If phase=='zero-double',""" +
""" then this filter is applied twice, once forward,""" +
""" and once backward (also making it non-causal).""" +
""" If ‘minimum’, then a minimum-phase filter will be """ +
""" constricted and applied, which is causal but has weaker""" +
""" stop-band suppression.""")
self.phase_edit.setCurrentText("zero")
grid.addWidget(self.phase_edit, 5, 1)
grid.addWidget(QLabel("Fir window:"), 6, 0)
self.fir_window_edit = QComboBox()
self.fir_windows = {
"Hamming": "hamming",
"Hann": "hann",
"Blackman": "blackman"
}
self.fir_window_edit.addItems(self.fir_windows.keys())
self.fir_window_edit.setToolTip("""The window to use in FIR design""")
self.fir_window_edit.setCurrentText("“hamming”")
grid.addWidget(self.fir_window_edit, 6, 1)
grid.addWidget(QLabel("Fir design:"), 7, 0)
self.fir_design_edit = QComboBox()
self.fir_designs = {
"firwin": "firwin",
"firwin2": "firwin2",
}
self.fir_design_edit.addItems(self.fir_designs.keys())
self.fir_design_edit.setToolTip(
"""“firwin” uses a time-domain design""" +
""" technique that generally gives improved attenuation """ +
""" using fewer samples than “firwin2”.""")
self.fir_design_edit.setCurrentText("firwin")
grid.addWidget(self.fir_design_edit, 7, 1)
grid.addWidget(QLabel("Skip by annotation:"), 8, 0)
self.annotations = list(set(self.raw.annotations.description))
self.skip_by_annotation_list = QListWidget()
self.skip_by_annotation_list.insertItems(0, self.annotations)
self.skip_by_annotation_list.setSelectionMode(
QListWidget.ExtendedSelection)
self.skip_by_annotation_list.setToolTip(
"""Selected Annotation segment""" +
""" will not be included in filtering, and segments on""" +
""" either side of the given excluded annotated segment""" +
""" will be filtered separately """)
for i in range(len(self.annotations)):
if self.annotations[i] in ('edge', 'bad_acq_skip'):
self.skip_by_annotation_list.item(i).setSelected(True)
else:
self.skip_by_annotation_list.item(i).setSelected(False)
grid.addWidget(self.skip_by_annotation_list, 8, 1)
grid.addWidget(QLabel("pad:"), 9, 0)
self.pads_edit = QComboBox()
self.pads = {
"edge": "edge",
"linear_ramp": "linear_ramp",
"maximum": "maximum",
"mean": "mean",
"median": "median",
"minimum": "minimum",
"reflect": "reflect",
"wrap": "wrap",
"empty": "empty",
"reflect-limited": "reflect-limited"
}
self.pads_edit.addItems(self.pads.keys())
self.pads_edit.setToolTip("""The type of padding to use.""")
self.pads_edit.setCurrentText("reflect-limited")
grid.addWidget(self.pads_edit, 9, 1)
vbox.addLayout(grid)
buttonbox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
vbox.addWidget(buttonbox)
buttonbox.accepted.connect(self.accept)
buttonbox.rejected.connect(self.reject)
vbox.setSizeConstraint(QVBoxLayout.SetFixedSize)
@property
def low(self):
low = self.lowedit.text()
return float(low) if low else None
@property
def high(self):
high = self.highedit.text()
return float(high) if high else None
class MontageDialog(QDialog):
def __init__(self, parent, montages, selected=None):
super().__init__(parent)
self.setWindowTitle("Set montage")
vbox = QVBoxLayout(self)
self.montages = QListWidget()
self.montages.insertItems(0, montages)
self.montages.setSelectionMode(QListWidget.SingleSelection)
if selected is not None:
for i in range(self.montages.count()):
if self.montages.item(i).data(0) == selected:
self.montages.item(i).setSelected(True)
vbox.addWidget(self.montages)
self.imported = QLabel("No file imported... Using builtin montages")
vbox.addWidget(self.imported)
hbox = QHBoxLayout()
self.import_button = QPushButton("Import file")
self.import_button.clicked.connect(self.import_montage)
self.view_button = QPushButton("View")
self.view_button.clicked.connect(self.view_montage)
hbox.addWidget(self.import_button)
hbox.addWidget(self.view_button)
hbox.addStretch()
self.buttonbox = QDialogButtonBox(QDialogButtonBox.Ok |
QDialogButtonBox.Cancel)
hbox.addWidget(self.buttonbox)
vbox.addLayout(hbox)
self.buttonbox.accepted.connect(self.accept)
self.buttonbox.rejected.connect(self.reject)
self.montages.itemSelectionChanged.connect(self.toggle_buttons)
self.is_imported = False
self.montage_path = ''
self.toggle_buttons() # initialize OK and View buttons state
@pyqtSlot()
def toggle_buttons(self):
"""Toggle OK and View buttons.
"""
if self.montages.selectedItems() or self.is_imported:
self.buttonbox.button(QDialogButtonBox.Ok).setEnabled(True)
self.view_button.setEnabled(True)
else:
self.buttonbox.button(QDialogButtonBox.Ok).setEnabled(False)
self.view_button.setEnabled(False)
def view_montage(self):
if self.montage_path == '':
kind = self.montages.selectedItems()[0].data(0)
montage = read_montage(kind)
else:
from ..utils.montage import xyz_to_montage
montage = xyz_to_montage(self.montage_path)
fig = montage.plot(show_names=True, show=False)
win = fig.canvas.manager.window
win.setWindowModality(Qt.WindowModal)
win.setWindowTitle("Montage")
win.findChild(QStatusBar).hide()
win.findChild(QToolBar).hide()
fig.show()
def import_montage(self):
self.montage_path, _ = QFileDialog.getOpenFileName(
self, "Choose montage path", '',
"3D Coordinates (*.xyz)")
self.imported.setText('File succesfully imported from : \n'
+ self.montage_path)
self.is_imported = True
self.toggle_buttons()
class RoisTcToolbox(QDialog):
def __init__(self, parent=None, QApplication=None):
super().__init__(parent)
self.setWindowTitle(' Compute Rois time course')
vbox = QVBoxLayout(self)
grid = QGridLayout()
# Init
self.fname_rois = None
self.rois = None
self.ris_files = None
self.output_directory = None
self.scalings = {"None": "none",
"Eigenvalue": "Eigenvalues"}
# Ris files
grid.addWidget(QLabel('Ris files:'), 0, 0)
self.QListWidget_ris = QListWidget()
grid.addWidget(self.QListWidget_ris, 0, 1)
self.QPushButton_ris = QPushButton('Open')
self.QPushButton_ris.clicked.connect(self.open_ris)
grid.addWidget(self.QPushButton_ris, 0, 3)
# ROI file
grid.addWidget(QLabel('ROI file:'), 1, 0)
self.QLineEdit_rois = QLineEdit()
grid.addWidget(self.QLineEdit_rois, 1, 1)
self.QPushButton_rois = QPushButton('Open')
self.QPushButton_rois.clicked.connect(self.open_rois)
grid.addWidget(self.QPushButton_rois, 1, 3)
# scaling
grid.addWidget(QLabel('Scaling:'), 4, 0)
self.QComboBox_scaling = QComboBox()
self.QComboBox_scaling.addItems(self.scalings.keys())
self.QComboBox_scaling.setCurrentText('None')
grid.addWidget(self.QComboBox_scaling, 4, 1)
# outputdir
grid.addWidget(QLabel('Output directory:'), 5, 0)
self.QLineEdit_output_dir = QLineEdit()
self.output_directory = os.getcwd()
self.QLineEdit_output_dir.setText(self.output_directory)
grid.addWidget(self.QLineEdit_output_dir, 5, 1)
self.QPushButton_open_output_dir = QPushButton('Open')
self.QPushButton_open_output_dir.clicked.connect(
self.open_output_directory)
grid.addWidget(self.QPushButton_open_output_dir, 5, 3)
# run
self.buttonbox = QDialogButtonBox(QDialogButtonBox.Ok |
QDialogButtonBox.Cancel)
grid.addWidget(self.buttonbox, 6, 1, 1, 4)
self.buttonbox.accepted.connect(self.run)
self.buttonbox.rejected.connect(self.reject)
# self.buttonbox.setEnabled(False)
vbox.addLayout(grid)
def open_ris(self):
filter = "RIS (*.ris)"
names, _ = QFileDialog.getOpenFileNames(self, "Open RIS files",
filter=filter)
self.ris_files = names
self.QListWidget_ris.clear()
self.QListWidget_ris.insertItems(0, self.ris_files)
self.data_changed()
return()
def open_rois(self):
filter = "ROIs(*.rois)"
fname, _ = QFileDialog.getOpenFileName(self,
'Open ROI',
filter=filter)
if fname:
self.fname_rois = fname
try:
with open(self.fname_rois) as f:
self.rois = pycartool.regions_of_interest.read_roi(self.fname_rois)
except Exception as e:
QApplication.restoreOverrideCursor()
self.QErrorMessage = QErrorMessage()
self.QErrorMessage.showMessage(str(e))
else:
self.fname_rois = None
self.rois = None
self.QLineEdit_rois.setText(self.fname_rois)
self.data_changed()
return()
def open_output_directory(self):
dirname = QFileDialog.getExistingDirectory(self, 'Output directory')
if dirname:
self.output_directory = dirname
else:
self.output_directory = None
self.QLineEdit_output_dir.setText(self.output_directory)
self.data_changed()
return()
def data_changed(self):
if any(x is None for x in [self.rois, self.fname_rois,
self.ris_files,
self.output_directory]):
self.buttonbox.setEnabled(False)
else:
self.buttonbox.setEnabled(True)
return()
def run(self):
try:
QApplication.setOverrideCursor(Qt.WaitCursor)
transform_svds(self.ris_files,
self.rois,
self.QComboBox_scaling.currentText(),
self.output_directory)
QApplication.restoreOverrideCursor()
self.QMessageBox_finnish = QMessageBox()
self.QMessageBox_finnish.setWindowTitle("Finished")
self.QMessageBox_finnish.setText("Done.")
self.QMessageBox_finnish.exec_()
except Exception as e:
QApplication.restoreOverrideCursor()
self.QErrorMessage = QErrorMessage()
self.QErrorMessage.showMessage(str(e))
