def disable_or_enable_distance_field(count_spin_box: QSpinBox,
distance_spin_box: QDoubleSpinBox):
"""
Disables or enabled the matching distance field of the row/column count spin box in the pixel grid options
depending on if the number of rows/columns has been set to zero.
:param count_spin_box: The row/column count spin box.
:param distance_spin_box: The matching row height/column width spin box.
"""
distance_spin_box.setEnabled(count_spin_box.value() != 0)
class SubtitleInfoDialog(QDialog):
def __init__(self,
subtitle_name="Test",
subtitle_delay=0.0,
subtitle_language=Default_Subtitle_Language,
subtitle_track_name="Test",
subtitle_set_default=False,
subtitle_set_forced=False,
subtitle_default_value_delay=0.0,
subtitle_default_value_language=Default_Subtitle_Language,
subtitle_default_value_track_name="Test",
subtitle_default_value_set_default=False,
subtitle_default_value_set_forced=False,
subtitle_set_default_disabled=False,
subtitle_set_forced_disabled=False,
disable_edit=False,
parent=None):
super().__init__(parent)
self.window_title = "Subtitle Info"
self.state = "no"
self.messageIcon = QLabel()
self.disable_edit = disable_edit
self.current_subtitle_language = str(subtitle_language)
self.current_subtitle_delay = str(subtitle_delay)
self.current_subtitle_track_name = str(subtitle_track_name)
self.current_subtitle_set_default = subtitle_set_default
self.current_subtitle_set_forced = subtitle_set_forced
self.default_subtitle_language = str(subtitle_default_value_language)
self.default_subtitle_delay = str(subtitle_default_value_delay)
self.default_subtitle_track_name = str(
subtitle_default_value_track_name)
self.default_subtitle_set_default = subtitle_default_value_set_default
self.default_subtitle_set_forced = subtitle_default_value_set_forced
self.subtitle_set_default_disabled = subtitle_set_default_disabled
self.subtitle_set_forced_disabled = subtitle_set_forced_disabled
self.subtitle_name_label = QLabel("Subtitle Name:")
self.subtitle_name_value = QLabel(str(subtitle_name))
self.subtitle_delay_label = QLabel("Subtitle Delay:")
self.subtitle_delay_spin = QDoubleSpinBox()
self.setup_subtitle_delay_spin()
self.subtitle_language_label = QLabel("Subtitle Language:")
self.subtitle_language_comboBox = QComboBox()
self.setup_subtitle_language_comboBox()
self.subtitle_track_name_label = QLabel("Subtitle Track Name:")
self.subtitle_track_name_lineEdit = QLineEdit()
self.setup_subtitle_track_name_lineEdit()
self.subtitle_set_forced_label = QLabel("Subtitle Forced State:")
self.subtitle_set_forced_checkBox = QCheckBox()
self.setup_subtitle_set_forced_checkBox()
self.subtitle_set_default_label = QLabel("Subtitle Default State:")
self.subtitle_set_default_checkBox = QCheckBox()
self.setup_subtitle_set_default_checkBox()
self.yes_button = QPushButton("OK")
self.no_button = QPushButton("Cancel")
self.reset_button = QPushButton("Reset To Default")
self.buttons_layout = QHBoxLayout()
self.subtitle_delay_layout = QHBoxLayout()
self.subtitle_language_layout = QHBoxLayout()
self.subtitle_track_name_layout = QHBoxLayout()
self.subtitle_set_default_layout = QHBoxLayout()
self.subtitle_set_forced_layout = QHBoxLayout()
self.buttons_layout.addWidget(QLabel(""), stretch=3)
self.buttons_layout.addWidget(self.reset_button, stretch=2)
self.buttons_layout.addWidget(self.yes_button, stretch=2)
self.buttons_layout.addWidget(self.no_button, stretch=2)
self.buttons_layout.addWidget(QLabel(""), stretch=3)
self.subtitle_setting_layout = QGridLayout()
self.subtitle_changeble_setting_layout = QFormLayout()
self.subtitle_changeble_setting_layout.addRow(self.subtitle_name_label,
self.subtitle_name_value)
self.subtitle_changeble_setting_layout.addRow(
self.subtitle_track_name_label, self.subtitle_track_name_lineEdit)
self.subtitle_changeble_setting_layout.addRow(
self.subtitle_language_label, self.subtitle_language_comboBox)
self.subtitle_changeble_setting_layout.addRow(
self.subtitle_delay_label, self.subtitle_delay_spin)
self.subtitle_changeble_setting_layout.addRow(
self.subtitle_set_default_label,
self.subtitle_set_default_checkBox)
self.subtitle_changeble_setting_layout.addRow(
self.subtitle_set_forced_label, self.subtitle_set_forced_checkBox)
self.subtitle_setting_layout.addLayout(
self.subtitle_changeble_setting_layout, 0, 0, 5, 2)
self.subtitle_setting_layout.addWidget(self.messageIcon, 0, 3, 5, -1)
self.main_layout = QGridLayout()
self.main_layout.addLayout(self.subtitle_setting_layout, 0, 0, 2, 3)
self.main_layout.addLayout(self.buttons_layout, 2, 0, 1, -1)
self.main_layout.setContentsMargins(20, 20, 20, 20)
self.setLayout(self.main_layout)
self.setup_ui()
self.signal_connect()
def setup_ui(self):
self.disable_question_mark_window()
self.messageIcon.setPixmap(
QtGui.QPixmap(GlobalFiles.SubtitleIconPath).scaledToHeight(100))
self.set_dialog_values()
self.set_default_buttons()
if self.subtitle_set_default_disabled:
self.subtitle_set_default_disable()
if self.subtitle_set_forced_disabled:
self.subtitle_set_forced_disable()
if self.disable_edit:
self.subtitle_track_name_lineEdit.setEnabled(False)
self.subtitle_language_comboBox.setEnabled(False)
self.subtitle_delay_spin.setEnabled(False)
self.subtitle_set_default_checkBox.setEnabled(False)
self.subtitle_set_forced_checkBox.setEnabled(False)
self.reset_button.setEnabled(False)
self.setup_tool_tip_hint_subtitle_set_default()
self.setup_tool_tip_hint_subtitle_set_forced()
def signal_connect(self):
self.subtitle_track_name_lineEdit.textEdited.connect(
self.update_current_subtitle_track_name)
self.subtitle_delay_spin.editingFinished.connect(
self.update_current_subtitle_delay)
self.subtitle_language_comboBox.currentTextChanged.connect(
self.update_current_subtitle_language)
self.subtitle_set_default_checkBox.stateChanged.connect(
self.update_current_subtitle_set_default)
self.subtitle_set_forced_checkBox.stateChanged.connect(
self.update_current_subtitle_set_forced)
self.yes_button.clicked.connect(self.click_yes)
self.no_button.clicked.connect(self.click_no)
self.reset_button.clicked.connect(self.reset_subtitle_setting)
def click_yes(self):
self.state = "yes"
self.close()
def click_no(self):
self.close()
def set_dialog_values(self):
self.setWindowTitle(self.window_title)
self.setWindowIcon(GlobalFiles.InfoSettingIcon)
def disable_question_mark_window(self):
self.setWindowFlag(Qt.WindowContextHelpButtonHint, on=False)
def increase_message_font_size(self, value):
message_font = self.message.font()
message_font.setPointSize(self.message.fontInfo().pointSize() + value)
self.message.setFont(message_font)
def set_default_buttons(self):
self.yes_button.setDefault(True)
self.yes_button.setFocus()
def showEvent(self, a0: QtGui.QShowEvent) -> None:
super().showEvent(a0)
self.setFixedSize(self.size())
def setup_subtitle_track_name_lineEdit(self):
self.subtitle_track_name_lineEdit.setClearButtonEnabled(True)
self.subtitle_track_name_lineEdit.setText(
self.current_subtitle_track_name)
def setup_subtitle_language_comboBox(self):
self.subtitle_language_comboBox.addItems(AllSubtitlesLanguages)
self.subtitle_language_comboBox.setCurrentIndex(
AllSubtitlesLanguages.index(self.current_subtitle_language))
self.subtitle_language_comboBox.setMaxVisibleItems(8)
self.subtitle_language_comboBox.setStyleSheet(
"QComboBox { combobox-popup: 0; }")
def setup_subtitle_delay_spin(self):
# self.subtitle_delay_spin.setMaximumWidth(screen_size.width() // 16)
self.subtitle_delay_spin.setDecimals(3)
self.subtitle_delay_spin.setMinimum(-9999.0)
self.subtitle_delay_spin.setMaximum(9999.0)
self.subtitle_delay_spin.setSingleStep(0.5)
self.subtitle_delay_spin.setValue(float(self.current_subtitle_delay))
def setup_subtitle_set_default_checkBox(self):
self.subtitle_set_default_checkBox.setText("Set Default")
self.subtitle_set_default_checkBox.setChecked(
bool(self.current_subtitle_set_default))
def setup_subtitle_set_forced_checkBox(self):
self.subtitle_set_forced_checkBox.setText("Set Forced")
self.subtitle_set_forced_checkBox.setChecked(
bool(self.current_subtitle_set_forced))
def update_current_subtitle_track_name(self):
self.current_subtitle_track_name = str(
self.subtitle_track_name_lineEdit.text())
def update_current_subtitle_delay(self):
self.current_subtitle_delay = round(self.subtitle_delay_spin.value(),
5)
def update_current_subtitle_language(self):
self.current_subtitle_language = str(
self.subtitle_language_comboBox.currentText())
def update_current_subtitle_set_default(self):
self.current_subtitle_set_default = (
self.subtitle_set_default_checkBox.checkState() == Qt.Checked)
def update_current_subtitle_set_forced(self):
self.current_subtitle_set_forced = (
self.subtitle_set_forced_checkBox.checkState() == Qt.Checked)
def reset_subtitle_setting(self):
self.current_subtitle_language = self.default_subtitle_language
self.current_subtitle_delay = self.default_subtitle_delay
self.current_subtitle_track_name = self.default_subtitle_track_name
self.current_subtitle_set_default = self.default_subtitle_set_default
self.current_subtitle_set_forced = self.default_subtitle_set_forced
self.subtitle_language_comboBox.setCurrentIndex(
AllSubtitlesLanguages.index(self.current_subtitle_language))
self.subtitle_delay_spin.setValue(float(self.current_subtitle_delay))
self.subtitle_track_name_lineEdit.setText(
self.current_subtitle_track_name)
self.subtitle_set_default_checkBox.setChecked(
bool(self.current_subtitle_set_default))
self.subtitle_set_forced_checkBox.setChecked(
bool(self.current_subtitle_set_forced))
def subtitle_set_default_disable(self):
self.subtitle_set_default_checkBox.setDisabled(True)
def subtitle_set_forced_disable(self):
self.subtitle_set_forced_checkBox.setDisabled(True)
def setup_tool_tip_hint_subtitle_set_default(self):
if self.subtitle_set_default_checkBox.isEnabled():
self.subtitle_set_default_checkBox.setToolTip(
"<nobr>set this subtitle to be the default subtitle track "
"when play")
self.subtitle_set_default_checkBox.setToolTipDuration(12000)
else:
self.subtitle_set_default_checkBox.setToolTip(
"<nobr>set this subtitle to be the default subtitle track when play<br><b>Disabled</b> because "
"option "
"<b>make this subtitle default</b> is enabled on mux setting tab "
)
self.subtitle_set_default_checkBox.setToolTipDuration(12000)
def setup_tool_tip_hint_subtitle_set_forced(self):
if self.subtitle_set_forced_checkBox.isEnabled():
self.subtitle_set_forced_checkBox.setToolTip(
"<nobr>set this subtitle to be the forced subtitle track when "
"play")
self.subtitle_set_forced_checkBox.setToolTipDuration(12000)
else:
self.subtitle_set_forced_checkBox.setToolTip(
"<nobr>set this subtitle to be the forced subtitle track when play<br><b>Disabled</b> because "
"option "
"<b>make this subtitle default and forced</b> is enabled on mux setting tab "
)
self.subtitle_set_forced_checkBox.setToolTipDuration(12000)
def execute(self):
self.exec_()
class Config(SignalNode.Config):
"""Config widget displayed for BandpassFilter."""
def __init__(self, parent=None):
super().__init__(parent=parent)
# Upper bound ----------------------------------------------------------------------------------------------
self.lower_bound_enable = QCheckBox()
self.lower_bound_enable.setChecked(True)
self.lower_bound_enable.stateChanged.connect(self.updateModel)
self.lower_bound = QDoubleSpinBox()
self.lower_bound.valueChanged.connect(self.updateModel)
self.lower_bound.setMinimum(0)
self.lower_bound.setMaximum(250)
self.lower_bound.setSuffix(" Hz")
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
lower_bound_widget = QWidget()
lower_bound_widget.setContentsMargins(0, 0, 0, 0)
lower_bound_widget.setLayout(layout)
layout.addWidget(self.lower_bound_enable)
layout.addWidget(self.lower_bound)
# Lower bound ----------------------------------------------------------------------------------------------
self.upper_bound_enable = QCheckBox()
self.upper_bound_enable.setChecked(True)
self.upper_bound_enable.stateChanged.connect(self.updateModel)
self.upper_bound = QDoubleSpinBox()
self.upper_bound.valueChanged.connect(self.updateModel)
self.upper_bound.setMinimum(0)
self.upper_bound.setMaximum(250)
self.upper_bound.setSuffix(" Hz")
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
upper_bound_widget = QWidget()
upper_bound_widget.setContentsMargins(0, 0, 0, 0)
upper_bound_widget.setLayout(layout)
layout.addWidget(self.upper_bound_enable)
layout.addWidget(self.upper_bound)
# Filter type and length -----------------------------------------------------------------------------------
self.filter_type = QComboBox()
for name in BandpassFilter.filter_name_to_type:
self.filter_type.addItem(name)
self.filter_type.currentTextChanged.connect(self.updateModel)
self.filter_length = QSpinBox()
self.filter_length.setMinimum(2)
self.filter_length.setMaximum(1000000)
self.filter_length.setValue(1000)
self.filter_length.valueChanged.connect(self.updateModel)
self.filter_order = QSpinBox()
self.filter_order.setRange(1, 4)
self.filter_order.valueChanged.connect(self.updateModel)
# ----------------------------------------------------------------------------------------------------------
layout = QFormLayout()
layout.addRow("Lower bound:", lower_bound_widget)
layout.addRow("Upper bound:", upper_bound_widget)
layout.addRow("Filter type:", self.filter_type)
layout.addRow("Filter order:", self.filter_order)
layout.addRow("Filter length:", self.filter_length)
self.setLayout(layout)
def updateModel(self):
n = self.node()
if n is None:
return
if self.lower_bound_enable.isChecked():
lower_bound = self.lower_bound.value()
else:
lower_bound = None
if self.upper_bound_enable.isChecked():
upper_bound = self.upper_bound.value()
else:
upper_bound = None
filter_type = n.filter_name_to_type[self.filter_type.currentText()]
filter_length = self.filter_length.value()
filter_order = self.filter_order.value()
n.setLowerBound(lower_bound)
n.setUpperBound(upper_bound)
n.setFilterType(filter_type)
n.setFilterLength(filter_length)
n.setFilterOrder(filter_order)
def updateView(self):
n = self.node()
if n is None:
return
# Prevent view fields from emitting signals while they are updated
self.lower_bound.blockSignals(True)
self.upper_bound.blockSignals(True)
self.filter_type.blockSignals(True)
self.filter_length.blockSignals(True)
self.filter_order.blockSignals(True)
if n.upperBound() is None:
self.upper_bound_enable.setChecked(False)
else:
self.upper_bound_enable.setChecked(True)
self.upper_bound.setValue(n.upperBound())
if n.lowerBound() is None:
self.lower_bound_enable.setChecked(False)
else:
self.lower_bound_enable.setChecked(True)
self.lower_bound.setValue(n.lowerBound())
self.filter_type.setCurrentText(
n.filter_type_to_name[n.filterType()])
self.filter_length.setValue(n.filterLength())
self.filter_order.setValue(n.filterOrder())
# Release the block and call adjust
self.lower_bound.blockSignals(False)
self.upper_bound.blockSignals(False)
self.filter_type.blockSignals(False)
self.filter_length.blockSignals(False)
self.filter_order.blockSignals(False)
self._adjust()
def _adjust(self):
"""Adjust displayed values and limits in response to changes."""
# Enable spinbox widgets based on their checkbox
self.lower_bound.setEnabled(self.lower_bound_enable.isChecked())
self.upper_bound.setEnabled(self.upper_bound_enable.isChecked())
# Adjust min and max so that lower_bound is never higher than upper_bound
if self.lower_bound_enable.isChecked():
self.upper_bound.setMinimum(self.lower_bound.value())
else:
self.upper_bound.setMinimum(0)
if self.upper_bound_enable.isChecked():
self.lower_bound.setMaximum(self.upper_bound.value())
else:
self.lower_bound.setMaximum(250)
if self.filter_type.currentText() == "Butterworth":
self.filter_order.setEnabled(True)
else:
self.filter_order.setEnabled(False)
class SCOUTS(QMainWindow):
"""Main Window Widget for SCOUTS."""
style = {
'title': 'QLabel {font-size: 18pt; font-weight: 600}',
'header': 'QLabel {font-size: 12pt; font-weight: 520}',
'label': 'QLabel {font-size: 10pt}',
'button': 'QPushButton {font-size: 10pt}',
'md button': 'QPushButton {font-size: 12pt}',
'run button': 'QPushButton {font-size: 18pt; font-weight: 600}',
'line edit': 'QLineEdit {font-size: 10pt}',
'checkbox': 'QCheckBox {font-size: 10pt}',
'radio button': 'QRadioButton {font-size: 10pt}'
}
def __init__(self) -> None:
"""SCOUTS Constructor. Defines all aspects of the GUI."""
# ###
# ### Main Window setup
# ###
# Inherits from QMainWindow
super().__init__()
self.rootdir = get_project_root()
self.threadpool = QThreadPool()
# Sets values for QMainWindow
self.setWindowTitle("SCOUTS")
self.setWindowIcon(
QIcon(
os.path.abspath(os.path.join(self.rootdir, 'src',
'scouts.ico'))))
# Creates StackedWidget as QMainWindow's central widget
self.stacked_pages = QStackedWidget(self)
self.setCentralWidget(self.stacked_pages)
# Creates Widgets for individual "pages" and adds them to the StackedWidget
self.main_page = QWidget()
self.samples_page = QWidget()
self.gating_page = QWidget()
self.pages = (self.main_page, self.samples_page, self.gating_page)
for page in self.pages:
self.stacked_pages.addWidget(page)
# ## Sets widget at program startup
self.stacked_pages.setCurrentWidget(self.main_page)
# ###
# ### MAIN PAGE
# ###
# Main page layout
self.main_layout = QVBoxLayout(self.main_page)
# Title section
# Title
self.title = QLabel(self.main_page)
self.title.setText('SCOUTS - Single Cell Outlier Selector')
self.title.setStyleSheet(self.style['title'])
self.title.adjustSize()
self.main_layout.addWidget(self.title)
# ## Input section
# Input header
self.input_header = QLabel(self.main_page)
self.input_header.setText('Input settings')
self.input_header.setStyleSheet(self.style['header'])
self.main_layout.addChildWidget(self.input_header)
self.input_header.adjustSize()
self.main_layout.addWidget(self.input_header)
# Input frame
self.input_frame = QFrame(self.main_page)
self.input_frame.setFrameShape(QFrame.StyledPanel)
self.input_frame.setLayout(QFormLayout())
self.main_layout.addWidget(self.input_frame)
# Input button
self.input_button = QPushButton(self.main_page)
self.input_button.setStyleSheet(self.style['button'])
self.set_icon(self.input_button, 'x-office-spreadsheet')
self.input_button.setObjectName('input')
self.input_button.setText(' Select input file (.xlsx or .csv)')
self.input_button.clicked.connect(self.get_path)
# Input path box
self.input_path = QLineEdit(self.main_page)
self.input_path.setObjectName('input_path')
self.input_path.setStyleSheet(self.style['line edit'])
# Go to sample naming page
self.samples_button = QPushButton(self.main_page)
self.samples_button.setStyleSheet(self.style['button'])
self.set_icon(self.samples_button, 'preferences-other')
self.samples_button.setText(' Name samples...')
self.samples_button.clicked.connect(self.goto_samples_page)
# Go to gating page
self.gates_button = QPushButton(self.main_page)
self.gates_button.setStyleSheet(self.style['button'])
self.set_icon(self.gates_button, 'preferences-other')
self.gates_button.setText(' Gating && outlier options...')
self.gates_button.clicked.connect(self.goto_gates_page)
# Add widgets above to input frame Layout
self.input_frame.layout().addRow(self.input_button, self.input_path)
self.input_frame.layout().addRow(self.samples_button)
self.input_frame.layout().addRow(self.gates_button)
# ## Analysis section
# Analysis header
self.analysis_header = QLabel(self.main_page)
self.analysis_header.setText('Analysis settings')
self.analysis_header.setStyleSheet(self.style['header'])
self.analysis_header.adjustSize()
self.main_layout.addWidget(self.analysis_header)
# Analysis frame
self.analysis_frame = QFrame(self.main_page)
self.analysis_frame.setFrameShape(QFrame.StyledPanel)
self.analysis_frame.setLayout(QVBoxLayout())
self.main_layout.addWidget(self.analysis_frame)
# Cutoff text
self.cutoff_text = QLabel(self.main_page)
self.cutoff_text.setText('Type of outlier to select:')
self.cutoff_text.setToolTip(
'Choose whether to select outliers using the cutoff value from a reference\n'
'sample (OutR) or by using the cutoff value calculated for each sample\n'
'individually (OutS)')
self.cutoff_text.setStyleSheet(self.style['label'])
# Cutoff button group
self.cutoff_group = QButtonGroup(self)
# Cutoff by sample
self.cutoff_sample = QRadioButton(self.main_page)
self.cutoff_sample.setText('OutS')
self.cutoff_sample.setObjectName('sample')
self.cutoff_sample.setStyleSheet(self.style['radio button'])
self.cutoff_sample.setChecked(True)
self.cutoff_group.addButton(self.cutoff_sample)
# Cutoff by reference
self.cutoff_reference = QRadioButton(self.main_page)
self.cutoff_reference.setText('OutR')
self.cutoff_reference.setObjectName('ref')
self.cutoff_reference.setStyleSheet(self.style['radio button'])
self.cutoff_group.addButton(self.cutoff_reference)
# Both cutoffs
self.cutoff_both = QRadioButton(self.main_page)
self.cutoff_both.setText('both')
self.cutoff_both.setObjectName('sample ref')
self.cutoff_both.setStyleSheet(self.style['radio button'])
self.cutoff_group.addButton(self.cutoff_both)
# Markers text
self.markers_text = QLabel(self.main_page)
self.markers_text.setStyleSheet(self.style['label'])
self.markers_text.setText('Show results for:')
self.markers_text.setToolTip(
'Individual markers: for each marker, select outliers\n'
'Any marker: select cells that are outliers for AT LEAST one marker'
)
# Markers button group
self.markers_group = QButtonGroup(self)
# Single marker
self.single_marker = QRadioButton(self.main_page)
self.single_marker.setText('individual markers')
self.single_marker.setObjectName('single')
self.single_marker.setStyleSheet(self.style['radio button'])
self.single_marker.setChecked(True)
self.markers_group.addButton(self.single_marker)
# Any marker
self.any_marker = QRadioButton(self.main_page)
self.any_marker.setText('any marker')
self.any_marker.setObjectName('any')
self.any_marker.setStyleSheet(self.style['radio button'])
self.markers_group.addButton(self.any_marker)
# Both methods
self.both_methods = QRadioButton(self.main_page)
self.both_methods.setText('both')
self.both_methods.setObjectName('single any')
self.both_methods.setStyleSheet(self.style['radio button'])
self.markers_group.addButton(self.both_methods)
# Tukey text
self.tukey_text = QLabel(self.main_page)
self.tukey_text.setStyleSheet(self.style['label'])
# Tukey button group
self.tukey_text.setText('Tukey factor:')
self.tukey_group = QButtonGroup(self)
# Low Tukey value
self.tukey_low = QRadioButton(self.main_page)
self.tukey_low.setText('1.5')
self.tukey_low.setStyleSheet(self.style['radio button'])
self.tukey_low.setChecked(True)
self.tukey_group.addButton(self.tukey_low)
# High Tukey value
self.tukey_high = QRadioButton(self.main_page)
self.tukey_high.setText('3.0')
self.tukey_high.setStyleSheet(self.style['radio button'])
self.tukey_group.addButton(self.tukey_high)
# Add widgets above to analysis frame layout
self.analysis_frame.layout().addWidget(self.cutoff_text)
self.cutoff_buttons = QHBoxLayout()
for button in self.cutoff_group.buttons():
self.cutoff_buttons.addWidget(button)
self.analysis_frame.layout().addLayout(self.cutoff_buttons)
self.analysis_frame.layout().addWidget(self.markers_text)
self.markers_buttons = QHBoxLayout()
for button in self.markers_group.buttons():
self.markers_buttons.addWidget(button)
self.analysis_frame.layout().addLayout(self.markers_buttons)
self.analysis_frame.layout().addWidget(self.tukey_text)
self.tukey_buttons = QHBoxLayout()
for button in self.tukey_group.buttons():
self.tukey_buttons.addWidget(button)
self.tukey_buttons.addWidget(QLabel()) # aligns row with 2 buttons
self.analysis_frame.layout().addLayout(self.tukey_buttons)
# ## Output section
# Output header
self.output_header = QLabel(self.main_page)
self.output_header.setText('Output settings')
self.output_header.setStyleSheet(self.style['header'])
self.output_header.adjustSize()
self.main_layout.addWidget(self.output_header)
# Output frame
self.output_frame = QFrame(self.main_page)
self.output_frame.setFrameShape(QFrame.StyledPanel)
self.output_frame.setLayout(QFormLayout())
self.main_layout.addWidget(self.output_frame)
# Output button
self.output_button = QPushButton(self.main_page)
self.output_button.setStyleSheet(self.style['button'])
self.set_icon(self.output_button, 'folder')
self.output_button.setObjectName('output')
self.output_button.setText(' Select output folder')
self.output_button.clicked.connect(self.get_path)
# Output path box
self.output_path = QLineEdit(self.main_page)
self.output_path.setStyleSheet(self.style['line edit'])
# Generate CSV checkbox
self.output_csv = QCheckBox(self.main_page)
self.output_csv.setText('Export multiple text files (.csv)')
self.output_csv.setStyleSheet(self.style['checkbox'])
self.output_csv.setChecked(True)
# Generate XLSX checkbox
self.output_excel = QCheckBox(self.main_page)
self.output_excel.setText('Export multiple Excel spreadsheets (.xlsx)')
self.output_excel.setStyleSheet(self.style['checkbox'])
self.output_excel.clicked.connect(self.enable_single_excel)
# Generate single, large XLSX checkbox
self.single_excel = QCheckBox(self.main_page)
self.single_excel.setText(
'Also save one multi-sheet Excel spreadsheet')
self.single_excel.setToolTip(
'After generating all Excel spreadsheets, SCOUTS combines them into '
'a single\nExcel spreadsheet where each sheet corresponds to an output'
'file from SCOUTS')
self.single_excel.setStyleSheet(self.style['checkbox'])
self.single_excel.setEnabled(False)
self.single_excel.clicked.connect(self.memory_warning)
# Add widgets above to output frame layout
self.output_frame.layout().addRow(self.output_button, self.output_path)
self.output_frame.layout().addRow(self.output_csv)
self.output_frame.layout().addRow(self.output_excel)
self.output_frame.layout().addRow(self.single_excel)
# ## Run & help-quit section
# Run button (stand-alone)
self.run_button = QPushButton(self.main_page)
self.set_icon(self.run_button, 'system-run')
self.run_button.setText(' Run!')
self.run_button.setStyleSheet(self.style['run button'])
self.main_layout.addWidget(self.run_button)
self.run_button.clicked.connect(self.run)
# Help-quit frame (invisible)
self.helpquit_frame = QFrame(self.main_page)
self.helpquit_frame.setLayout(QHBoxLayout())
self.helpquit_frame.layout().setMargin(0)
self.main_layout.addWidget(self.helpquit_frame)
# Help button
self.help_button = QPushButton(self.main_page)
self.set_icon(self.help_button, 'help-about')
self.help_button.setText(' Help')
self.help_button.setStyleSheet(self.style['md button'])
self.help_button.clicked.connect(self.get_help)
# Quit button
self.quit_button = QPushButton(self.main_page)
self.set_icon(self.quit_button, 'process-stop')
self.quit_button.setText(' Quit')
self.quit_button.setStyleSheet(self.style['md button'])
self.quit_button.clicked.connect(self.close)
# Add widgets above to help-quit layout
self.helpquit_frame.layout().addWidget(self.help_button)
self.helpquit_frame.layout().addWidget(self.quit_button)
# ###
# ### SAMPLES PAGE
# ###
# Samples page layout
self.samples_layout = QVBoxLayout(self.samples_page)
# ## Title section
# Title
self.samples_title = QLabel(self.samples_page)
self.samples_title.setText('Name your samples')
self.samples_title.setStyleSheet(self.style['title'])
self.samples_title.adjustSize()
self.samples_layout.addWidget(self.samples_title)
# Subtitle
self.samples_subtitle = QLabel(self.samples_page)
string = (
'Please name the samples to be analysed by SCOUTS.\n\nSCOUTS searches the first '
'column of your data\nand locates the exact string as part of the sample name.'
)
self.samples_subtitle.setText(string)
self.samples_subtitle.setStyleSheet(self.style['label'])
self.samples_subtitle.adjustSize()
self.samples_layout.addWidget(self.samples_subtitle)
# ## Sample addition section
# Sample addition frame
self.samples_frame = QFrame(self.samples_page)
self.samples_frame.setFrameShape(QFrame.StyledPanel)
self.samples_frame.setLayout(QGridLayout())
self.samples_layout.addWidget(self.samples_frame)
# Sample name box
self.sample_name = QLineEdit(self.samples_page)
self.sample_name.setStyleSheet(self.style['line edit'])
self.sample_name.setPlaceholderText('Sample name ...')
# Reference check
self.is_reference = QCheckBox(self.samples_page)
self.is_reference.setText('Reference?')
self.is_reference.setStyleSheet(self.style['checkbox'])
# Add sample to table
self.add_sample_button = QPushButton(self.samples_page)
QShortcut(QKeySequence("Return"), self.add_sample_button,
self.write_to_sample_table)
self.set_icon(self.add_sample_button, 'list-add')
self.add_sample_button.setText(' Add sample (Enter)')
self.add_sample_button.setStyleSheet(self.style['button'])
self.add_sample_button.clicked.connect(self.write_to_sample_table)
# Remove sample from table
self.remove_sample_button = QPushButton(self.samples_page)
QShortcut(QKeySequence("Delete"), self.remove_sample_button,
self.remove_from_sample_table)
self.set_icon(self.remove_sample_button, 'list-remove')
self.remove_sample_button.setText(' Remove sample (Del)')
self.remove_sample_button.setStyleSheet(self.style['button'])
self.remove_sample_button.clicked.connect(
self.remove_from_sample_table)
# Add widgets above to sample addition layout
self.samples_frame.layout().addWidget(self.sample_name, 0, 0)
self.samples_frame.layout().addWidget(self.is_reference, 1, 0)
self.samples_frame.layout().addWidget(self.add_sample_button, 0, 1)
self.samples_frame.layout().addWidget(self.remove_sample_button, 1, 1)
# ## Sample table
self.sample_table = QTableWidget(self.samples_page)
self.sample_table.setColumnCount(2)
self.sample_table.setHorizontalHeaderItem(0,
QTableWidgetItem('Sample'))
self.sample_table.setHorizontalHeaderItem(
1, QTableWidgetItem('Reference?'))
self.sample_table.horizontalHeader().setSectionResizeMode(
0, QHeaderView.Stretch)
self.sample_table.horizontalHeader().setSectionResizeMode(
1, QHeaderView.ResizeToContents)
self.samples_layout.addWidget(self.sample_table)
# ## Save & clear buttons
# Save & clear frame (invisible)
self.saveclear_frame = QFrame(self.samples_page)
self.saveclear_frame.setLayout(QHBoxLayout())
self.saveclear_frame.layout().setMargin(0)
self.samples_layout.addWidget(self.saveclear_frame)
# Clear samples button
self.clear_samples = QPushButton(self.samples_page)
self.set_icon(self.clear_samples, 'edit-delete')
self.clear_samples.setText(' Clear table')
self.clear_samples.setStyleSheet(self.style['md button'])
self.clear_samples.clicked.connect(self.prompt_clear_data)
# Save samples button
self.save_samples = QPushButton(self.samples_page)
self.set_icon(self.save_samples, 'document-save')
self.save_samples.setText(' Save samples')
self.save_samples.setStyleSheet(self.style['md button'])
self.save_samples.clicked.connect(self.goto_main_page)
# Add widgets above to save & clear layout
self.saveclear_frame.layout().addWidget(self.clear_samples)
self.saveclear_frame.layout().addWidget(self.save_samples)
# ###
# ### GATING PAGE
# ###
# Gating page layout
self.gating_layout = QVBoxLayout(self.gating_page)
# ## Title section
# Title
self.gates_title = QLabel(self.gating_page)
self.gates_title.setText('Gating & outlier options')
self.gates_title.setStyleSheet(self.style['title'])
self.gates_title.adjustSize()
self.gating_layout.addWidget(self.gates_title)
# ## Gating options section
# Gating header
self.gate_header = QLabel(self.gating_page)
self.gate_header.setText('Gating')
self.gate_header.setStyleSheet(self.style['header'])
self.gate_header.adjustSize()
self.gating_layout.addWidget(self.gate_header)
# Gating frame
self.gate_frame = QFrame(self.gating_page)
self.gate_frame.setFrameShape(QFrame.StyledPanel)
self.gate_frame.setLayout(QFormLayout())
self.gating_layout.addWidget(self.gate_frame)
# Gating button group
self.gating_group = QButtonGroup(self)
# Do not gate samples
self.no_gates = QRadioButton(self.gating_page)
self.no_gates.setObjectName('no_gate')
self.no_gates.setText("Don't gate samples")
self.no_gates.setStyleSheet(self.style['radio button'])
self.no_gates.setChecked(True)
self.gating_group.addButton(self.no_gates)
self.no_gates.clicked.connect(self.activate_gate)
# CyToF gating
self.cytof_gates = QRadioButton(self.gating_page)
self.cytof_gates.setObjectName('cytof')
self.cytof_gates.setText('Mass Cytometry gating')
self.cytof_gates.setStyleSheet(self.style['radio button'])
self.cytof_gates.setToolTip(
'Exclude cells for which the average expression of all\n'
'markers is below the selected value')
self.gating_group.addButton(self.cytof_gates)
self.cytof_gates.clicked.connect(self.activate_gate)
# CyToF gating spinbox
self.cytof_gates_value = QDoubleSpinBox(self.gating_page)
self.cytof_gates_value.setMinimum(0)
self.cytof_gates_value.setMaximum(1)
self.cytof_gates_value.setValue(0.1)
self.cytof_gates_value.setSingleStep(0.05)
self.cytof_gates_value.setEnabled(False)
# scRNA-Seq gating
self.rnaseq_gates = QRadioButton(self.gating_page)
self.rnaseq_gates.setText('scRNA-Seq gating')
self.rnaseq_gates.setStyleSheet(self.style['radio button'])
self.rnaseq_gates.setToolTip(
'When calculating cutoff, ignore reads below the selected value')
self.rnaseq_gates.setObjectName('rnaseq')
self.gating_group.addButton(self.rnaseq_gates)
self.rnaseq_gates.clicked.connect(self.activate_gate)
# scRNA-Seq gating spinbox
self.rnaseq_gates_value = QDoubleSpinBox(self.gating_page)
self.rnaseq_gates_value.setMinimum(0)
self.rnaseq_gates_value.setMaximum(10)
self.rnaseq_gates_value.setValue(0)
self.rnaseq_gates_value.setSingleStep(1)
self.rnaseq_gates_value.setEnabled(False)
# export gated population checkbox
self.export_gated = QCheckBox(self.gating_page)
self.export_gated.setText('Export gated cells as an output file')
self.export_gated.setStyleSheet(self.style['checkbox'])
self.export_gated.setEnabled(False)
# Add widgets above to Gate frame layout
self.gate_frame.layout().addRow(self.no_gates, QLabel())
self.gate_frame.layout().addRow(self.cytof_gates,
self.cytof_gates_value)
self.gate_frame.layout().addRow(self.rnaseq_gates,
self.rnaseq_gates_value)
self.gate_frame.layout().addRow(self.export_gated, QLabel())
# ## Outlier options section
# Outlier header
self.outlier_header = QLabel(self.gating_page)
self.outlier_header.setText('Outliers')
self.outlier_header.setStyleSheet(self.style['header'])
self.outlier_header.adjustSize()
self.gating_layout.addWidget(self.outlier_header)
# Outlier frame
self.outlier_frame = QFrame(self.gating_page)
self.outlier_frame.setFrameShape(QFrame.StyledPanel)
self.outlier_frame.setLayout(QVBoxLayout())
self.gating_layout.addWidget(self.outlier_frame)
# Top outliers information
self.top_outliers = QLabel(self.gating_page)
self.top_outliers.setStyleSheet(self.style['label'])
self.top_outliers.setText(
'By default, SCOUTS selects the top outliers from the population')
self.top_outliers.setStyleSheet(self.style['label'])
# Bottom outliers data
self.bottom_outliers = QCheckBox(self.gating_page)
self.bottom_outliers.setText('Include results for low outliers')
self.bottom_outliers.setStyleSheet(self.style['checkbox'])
# Non-outliers data
self.not_outliers = QCheckBox(self.gating_page)
self.not_outliers.setText('Include results for non-outliers')
self.not_outliers.setStyleSheet(self.style['checkbox'])
# Add widgets above to Gate frame layout
self.outlier_frame.layout().addWidget(self.top_outliers)
self.outlier_frame.layout().addWidget(self.bottom_outliers)
self.outlier_frame.layout().addWidget(self.not_outliers)
# ## Save/back button
self.save_gates = QPushButton(self.gating_page)
self.set_icon(self.save_gates, 'go-next')
self.save_gates.setText(' Back to main menu')
self.save_gates.setStyleSheet(self.style['md button'])
self.gating_layout.addWidget(self.save_gates)
self.save_gates.clicked.connect(self.goto_main_page)
# ## Add empty label to take vertical space
self.empty_label = QLabel(self.gating_page)
self.empty_label.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.gating_layout.addWidget(self.empty_label)
# ###
# ### ICON SETTING
# ###
def set_icon(self, widget: QWidget, icon: str) -> None:
"""Associates an icon to a widget."""
i = QIcon()
i.addPixmap(
QPixmap(
os.path.abspath(
os.path.join(self.rootdir, 'src', 'default_icons',
f'{icon}.svg'))))
widget.setIcon(QIcon.fromTheme(icon, i))
# ###
# ### STACKED WIDGET PAGE SWITCHING
# ###
def goto_main_page(self) -> None:
"""Switches stacked widget pages to the main page."""
self.stacked_pages.setCurrentWidget(self.main_page)
def goto_samples_page(self) -> None:
"""Switches stacked widget pages to the samples table page."""
self.stacked_pages.setCurrentWidget(self.samples_page)
def goto_gates_page(self) -> None:
"""Switches stacked widget pages to the gating & other options page."""
self.stacked_pages.setCurrentWidget(self.gating_page)
# ###
# ### MAIN PAGE GUI LOGIC
# ###
def get_path(self) -> None:
"""Opens a dialog box and sets the chosen file/folder path, depending on the caller widget."""
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
sender_name = self.sender().objectName()
if sender_name == 'input':
query, _ = QFileDialog.getOpenFileName(self,
"Select file",
"",
"All Files (*)",
options=options)
elif sender_name == 'output':
query = QFileDialog.getExistingDirectory(self,
"Select Directory",
options=options)
else:
return
if query:
getattr(self, f'{sender_name}_path').setText(query)
def enable_single_excel(self) -> None:
"""Enables checkbox for generating a single Excel output."""
if self.output_excel.isChecked():
self.single_excel.setEnabled(True)
else:
self.single_excel.setEnabled(False)
self.single_excel.setChecked(False)
# ###
# ### SAMPLE NAME/SAMPLE TABLE GUI LOGIC
# ###
def write_to_sample_table(self) -> None:
"""Writes data to sample table."""
table = self.sample_table
ref = 'no'
sample = self.sample_name.text()
if sample:
for cell in range(table.rowCount()):
item = table.item(cell, 0)
if item.text() == sample:
self.same_sample()
return
if self.is_reference.isChecked():
for cell in range(table.rowCount()):
item = table.item(cell, 1)
if item.text() == 'yes':
self.more_than_one_reference()
return
ref = 'yes'
sample = QTableWidgetItem(sample)
is_reference = QTableWidgetItem(ref)
is_reference.setFlags(Qt.ItemIsEnabled)
row_position = table.rowCount()
table.insertRow(row_position)
table.setItem(row_position, 0, sample)
table.setItem(row_position, 1, is_reference)
self.is_reference.setChecked(False)
self.sample_name.setText('')
def remove_from_sample_table(self) -> None:
"""Removes data from sample table."""
table = self.sample_table
rows = set(index.row() for index in table.selectedIndexes())
for index in sorted(rows, reverse=True):
self.sample_table.removeRow(index)
def prompt_clear_data(self) -> None:
"""Prompts option to clear all data in the sample table."""
if self.confirm_clear_data():
table = self.sample_table
while table.rowCount():
self.sample_table.removeRow(0)
# ###
# ### GATING GUI LOGIC
# ###
def activate_gate(self) -> None:
"""Activates/deactivates buttons related to gating."""
if self.sender().objectName() == 'no_gate':
self.cytof_gates_value.setEnabled(False)
self.rnaseq_gates_value.setEnabled(False)
self.export_gated.setEnabled(False)
self.export_gated.setChecked(False)
elif self.sender().objectName() == 'cytof':
self.cytof_gates_value.setEnabled(True)
self.rnaseq_gates_value.setEnabled(False)
self.export_gated.setEnabled(True)
elif self.sender().objectName() == 'rnaseq':
self.cytof_gates_value.setEnabled(False)
self.rnaseq_gates_value.setEnabled(True)
self.export_gated.setEnabled(True)
# ###
# ### CONNECT SCOUTS TO ANALYTICAL MODULES
# ###
def run(self) -> None:
"""Runs SCOUTS as a Worker, based on user input in the GUI."""
try:
data = self.parse_input()
except Exception as error:
trace = traceback.format_exc()
self.propagate_error((error, trace))
else:
data['widget'] = self
worker = Worker(func=start_scouts, **data)
worker.signals.started.connect(self.analysis_has_started)
worker.signals.finished.connect(self.analysis_has_finished)
worker.signals.success.connect(self.success_message)
worker.signals.error.connect(self.propagate_error)
self.threadpool.start(worker)
def parse_input(self) -> Dict:
"""Returns user input on the GUI as a dictionary."""
# Input and output
input_dict = {
'input_file': str(self.input_path.text()),
'output_folder': str(self.output_path.text())
}
if not input_dict['input_file'] or not input_dict['output_folder']:
raise NoIOPathError
# Set cutoff by reference or by sample rule
input_dict['cutoff_rule'] = self.cutoff_group.checkedButton(
).objectName() # 'sample', 'ref', 'sample ref'
# Outliers for each individual marker or any marker in row
input_dict['marker_rule'] = self.markers_group.checkedButton(
).objectName() # 'single', 'any', 'single any'
# Tukey factor used for calculating cutoff
input_dict['tukey_factor'] = float(
self.tukey_group.checkedButton().text()) # '1.5', '3.0'
# Output settings
input_dict['export_csv'] = True if self.output_csv.isChecked(
) else False
input_dict['export_excel'] = True if self.output_excel.isChecked(
) else False
input_dict['single_excel'] = True if self.single_excel.isChecked(
) else False
# Retrieve samples from sample table
input_dict['sample_list'] = []
for tuples in self.yield_samples_from_table():
input_dict['sample_list'].append(tuples)
if not input_dict['sample_list']:
raise NoSampleError
# Set gate cutoff (if any)
input_dict['gating'] = self.gating_group.checkedButton().objectName(
) # 'no_gate', 'cytof', 'rnaseq'
input_dict['gate_cutoff_value'] = None
if input_dict['gating'] != 'no_gate':
input_dict['gate_cutoff_value'] = getattr(
self, f'{input_dict["gating"]}_gates_value').value()
input_dict['export_gated'] = True if self.export_gated.isChecked(
) else False
# Generate results for non-outliers
input_dict['non_outliers'] = False
if self.not_outliers.isChecked():
input_dict['non_outliers'] = True
# Generate results for bottom outliers
input_dict['bottom_outliers'] = False
if self.bottom_outliers.isChecked():
input_dict['bottom_outliers'] = True
# return dictionary with all gathered inputs
return input_dict
def yield_samples_from_table(
self) -> Generator[Tuple[str, str], None, None]:
"""Yields sample names from the sample table."""
table = self.sample_table
for cell in range(table.rowCount()):
sample_name = table.item(cell, 0).text()
sample_type = table.item(cell, 1).text()
yield sample_name, sample_type
# ###
# ### MESSAGE BOXES
# ###
def analysis_has_started(self) -> None:
"""Disables run button while SCOUTS analysis is underway."""
self.run_button.setText(' Working...')
self.run_button.setEnabled(False)
def analysis_has_finished(self) -> None:
"""Enables run button after SCOUTS analysis has finished."""
self.run_button.setEnabled(True)
self.run_button.setText(' Run!')
def success_message(self) -> None:
"""Info message box used when SCOUTS finished without errors."""
title = "Analysis finished!"
mes = "Your analysis has finished. No errors were reported."
if self.stacked_pages.isEnabled() is True:
QMessageBox.information(self, title, mes)
def memory_warning(self) -> None:
"""Warning message box used when user wants to generate a single excel file."""
if self.sender().isChecked():
title = 'Memory warning!'
mes = (
"Depending on your dataset, this option can consume a LOT of memory and take"
" a long time to process. Please make sure that your computer can handle it!"
)
QMessageBox.information(self, title, mes)
def same_sample(self) -> None:
"""Error message box used when the user tries to input the same sample twice in the sample table."""
title = 'Error: sample name already in table'
mes = (
"Sorry, you can't do this because this sample name is already in the table. "
"Please select a different name.")
QMessageBox.critical(self, title, mes)
def more_than_one_reference(self) -> None:
"""Error message box used when the user tries to input two reference samples in the sample table."""
title = "Error: more than one reference selected"
mes = (
"Sorry, you can't do this because there is already a reference column in the table. "
"Please remove it before adding a reference.")
QMessageBox.critical(self, title, mes)
def confirm_clear_data(self) -> bool:
"""Question message box used to confirm user action of clearing sample table."""
title = 'Confirm Action'
mes = "Table will be cleared. Are you sure?"
reply = QMessageBox.question(self, title, mes,
QMessageBox.Yes | QMessageBox.No,
QMessageBox.No)
if reply == QMessageBox.Yes:
return True
return False
# ###
# ### EXCEPTIONS & ERRORS
# ###
def propagate_error(self, error: Tuple[Exception, str]) -> None:
"""Calls the appropriate error message box based on type of Exception raised."""
if isinstance(error[0], NoIOPathError):
self.no_io_path_error_message()
elif isinstance(error[0], NoReferenceError):
self.no_reference_error_message()
elif isinstance(error[0], NoSampleError):
self.no_sample_error_message()
elif isinstance(error[0], PandasInputError):
self.pandas_input_error_message()
elif isinstance(error[0], SampleNamingError):
self.sample_naming_error_message()
else:
self.generic_error_message(error)
def no_io_path_error_message(self) -> None:
"""Message displayed when the user did not include an input file path, or an output folder path."""
title = 'Error: no file/folder'
message = ("Sorry, no input file and/or output folder was provided. "
"Please add the path to the necessary file/folder.")
QMessageBox.critical(self, title, message)
def no_reference_error_message(self) -> None:
"""Message displayed when the user wants to analyse cutoff based on a reference, but did not specify what
sample corresponds to the reference."""
title = "Error: No reference selected"
message = (
"Sorry, no reference sample was found on the sample list, but analysis was set to "
"reference. Please add a reference sample, or change the rule for cutoff calculation."
)
QMessageBox.critical(self, title, message)
def no_sample_error_message(self) -> None:
"""Message displayed when the user did not add any samples to the sample table."""
title = "Error: No samples selected"
message = (
"Sorry, the analysis cannot be performed because no sample names were input. "
"Please add your sample names.")
QMessageBox.critical(self, title, message)
def pandas_input_error_message(self) -> None:
"""Message displayed when the input file cannot be read (likely because it is not a Excel or csv file)."""
title = 'Error: unexpected input file'
message = (
"Sorry, the input file could not be read. Please make sure that "
"the data is save in a valid format (supported formats are: "
".csv, .xlsx).")
QMessageBox.critical(self, title, message)
def sample_naming_error_message(self) -> None:
"""Message displayed when none of the sample names passed by the user are found in the input DataFrame."""
title = 'Error: sample names not in input file'
message = (
"Sorry, your sample names were not found in the input file. Please "
"make sure that the names were typed correctly (case-sensitive).")
QMessageBox.critical(self, title, message)
def generic_error_message(self, error: Tuple[Exception, str]) -> None:
"""Error message box used to display any error message (including traceback) for any uncaught errors."""
title = 'An error occurred!'
name, trace = error
QMessageBox.critical(self, title,
f"{str(name)}\n\nfull traceback:\n{trace}")
def not_implemented_error_message(self) -> None:
"""Error message box used when the user accesses a functionality that hasn't been implemented yet."""
title = "Not yet implemented"
mes = "Sorry, this functionality has not been implemented yet."
QMessageBox.critical(self, title, mes)
# ###
# ### HELP & QUIT
# ###
@staticmethod
def get_help() -> None:
"""Opens SCOUTS documentation on the browser. Called when the user clicks the "help" button"""
webbrowser.open('https://scouts.readthedocs.io/en/master/')
def closeEvent(self, event: QEvent) -> None:
"""Defines the message box for when the user wants to quit SCOUTS."""
title = 'Quit SCOUTS'
mes = "Are you sure you want to quit?"
reply = QMessageBox.question(self, title, mes,
QMessageBox.Yes | QMessageBox.No,
QMessageBox.No)
if reply == QMessageBox.Yes:
self.stacked_pages.setEnabled(False)
message = self.quit_message()
waiter = Waiter(waiter_func=self.threadpool.activeThreadCount)
waiter.signals.started.connect(message.show)
waiter.signals.finished.connect(message.destroy)
waiter.signals.finished.connect(sys.exit)
self.threadpool.start(waiter)
event.ignore()
def quit_message(self) -> QDialog:
"""Displays a window while SCOUTS is exiting"""
message = QDialog(self)
message.setWindowTitle('Exiting SCOUTS')
message.resize(300, 50)
label = QLabel('SCOUTS is exiting, please wait...', message)
label.setStyleSheet(self.style['label'])
label.adjustSize()
label.setAlignment(Qt.AlignCenter)
label.move(int((message.width() - label.width()) / 2),
int((message.height() - label.height()) / 2))
return message
class NGL_HKLViewer(QWidget):
def __init__(self, parent=None):
super(NGL_HKLViewer, self).__init__(parent)
self.verbose = 0
self.UseOSbrowser = False
self.jscriptfname = ""
self.devmode = False
for e in sys.argv:
if "verbose" in e:
self.verbose = e.split("verbose=")[1]
if "UseOSbrowser" in e:
self.UseOSbrowser = e.split("UseOSbrowser=")[1]
if "jscriptfname" in e:
self.jscriptfname = e.split("jscriptfname=")[1]
if "devmode" in e:
self.devmode = True
self.zmq_context = None
self.bufsize = 20000
self.originalPalette = QApplication.palette()
self.openFileNameButton = QPushButton("Load reflection file")
self.openFileNameButton.setDefault(True)
self.openFileNameButton.clicked.connect(self.OpenReflectionsFile)
self.debugbutton = QPushButton("Debug")
self.debugbutton.clicked.connect(self.DebugInteractively)
self.settingsbtn = QPushButton("Settings")
self.settingsbtn.clicked.connect(self.SettingsDialog)
self.mousemoveslider = QSlider(Qt.Horizontal)
self.mousemoveslider.setMinimum(0)
self.mousemoveslider.setMaximum(300)
self.mousemoveslider.setValue(0)
self.mousemoveslider.sliderReleased.connect(
self.onFinalMouseSensitivity)
self.mousemoveslider.valueChanged.connect(self.onMouseSensitivity)
self.mousesensitxtbox = QLineEdit('')
self.mousesensitxtbox.setReadOnly(True)
self.fontspinBox = QDoubleSpinBox()
self.fontspinBox.setSingleStep(1)
self.fontspinBox.setRange(4, 50)
self.font = QFont()
self.font.setFamily(self.font.defaultFamily())
self.fontspinBox.setValue(self.font.pointSize())
#self.fontspinBox.setValue(self.font.pixelSize())
self.fontspinBox.valueChanged.connect(self.onFontsizeChanged)
self.Fontsize_labeltxt = QLabel()
self.Fontsize_labeltxt.setText("Font size:")
self.cameraPerspectCheckBox = QCheckBox()
self.cameraPerspectCheckBox.setText("Perspective camera")
self.cameraPerspectCheckBox.clicked.connect(self.onCameraPerspect)
self.cameraPerspectCheckBox.setCheckState(Qt.Unchecked)
self.settingsform = SettingsForm(self)
self.MillerComboBox = QComboBox()
self.MillerComboBox.activated.connect(self.onMillerComboSelchange)
#self.MillerComboBox.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.MillerLabel = QLabel()
self.MillerLabel.setText("Selected HKL Scene")
self.HKLnameedit = QLineEdit('')
self.HKLnameedit.setReadOnly(True)
self.textInfo = QTextEdit()
self.textInfo.setLineWrapMode(QTextEdit.NoWrap)
self.textInfo.setReadOnly(True)
labels = [
"Label", "Type", "no. of HKLs", "Span of HKLs", "Min Max data",
"Min Max sigmas", "d_min, d_max", "Symmetry unique", "Anomalous"
]
self.millertable = QTableWidget(0, len(labels))
self.millertable.setHorizontalHeaderLabels(labels)
self.millertable.horizontalHeader().setDefaultAlignment(Qt.AlignLeft)
# don't allow editing this table
self.millertable.setEditTriggers(QTableWidget.NoEditTriggers)
self.createExpansionBox()
self.createFileInfoBox()
self.CreateSliceTabs()
self.createRadiiScaleGroupBox()
self.createBinsBox()
self.CreateFunctionTabs()
mainLayout = QGridLayout()
mainLayout.addWidget(self.FileInfoBox, 0, 0)
mainLayout.addWidget(self.MillerLabel, 1, 0)
mainLayout.addWidget(self.MillerComboBox, 2, 0)
mainLayout.addWidget(self.functionTabWidget, 3, 0)
mainLayout.addWidget(self.settingsbtn, 4, 0, 1, 1)
#import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) )
if self.UseOSbrowser == False:
self.BrowserBox = QWebEngineView()
mainLayout.addWidget(self.BrowserBox, 0, 1, 5, 3)
self.BrowserBox.setUrl("https://cctbx.github.io/")
#self.BrowserBox.setUrl("https://webglreport.com/")
#self.BrowserBox.loadFinished.connect(self.onLoadFinished)
mainLayout.setColumnStretch(2, 1)
mainLayout.setRowStretch(0, 1)
mainLayout.setRowStretch(1, 0)
mainLayout.setRowStretch(2, 1)
mainLayout.setRowStretch(3, 1)
mainLayout.setColumnStretch(4, 0)
self.setLayout(mainLayout)
self.setWindowTitle("HKL-Viewer")
self.cctbxproc = None
self.LaunchCCTBXPython()
self.out = None
self.err = None
self.comboviewwidth = 0
self.hklscenes_arrays = []
self.array_infotpls = []
self.matching_arrays = []
self.bin_infotpls = None
self.bin_opacities = None
self.html_url = ""
self.spacegroups = []
self.info = []
self.infostr = ""
self.fileisvalid = False
self.NewFileLoaded = False
self.NewHKLscenes = False
self.updatingNbins = False
self.binstableitemchanges = False
self.show()
def SettingsDialog(self):
self.settingsform.show()
def update(self):
if self.cctbxproc:
if self.cctbxproc.stdout:
print(self.cctbxproc.stdout.read().decode("utf-8"))
if self.cctbxproc.stderr:
print(self.cctbxproc.stderr.read().decode("utf-8"))
if self.out:
print(self.out.decode("utf-8"))
if self.err:
print(self.err.decode("utf-8"))
if self.zmq_context:
try:
msg = self.socket.recv(
flags=zmq.NOBLOCK
) #To empty the socket from previous messages
msgstr = msg.decode()
self.infodict = eval(msgstr)
#print("received from cctbx: " + str(self.infodict))
if self.infodict:
if self.infodict.get("hklscenes_arrays"):
self.hklscenes_arrays = self.infodict.get(
"hklscenes_arrays", [])
if self.infodict.get("array_infotpls"):
self.array_infotpls = self.infodict.get(
"array_infotpls", [])
if self.infodict.get("bin_data_label"):
self.BinDataComboBox.setCurrentText(
self.infodict["bin_data_label"])
if self.infodict.get("bin_infotpls"):
self.bin_infotpls = self.infodict["bin_infotpls"]
self.nbins = len(self.bin_infotpls)
self.updatingNbins = True
self.Nbins_spinBox.setValue(self.nbins)
self.updatingNbins = False
self.binstable.clearContents()
self.binstable.setRowCount(self.nbins)
for row, bin_infotpl in enumerate(self.bin_infotpls):
for col, elm in enumerate(bin_infotpl):
# only allow changing the last column with opacity values
if col != 3:
item = QTableWidgetItem(str(elm))
else:
item = QTableWidgetItem()
item.setFlags(Qt.ItemIsUserCheckable
| Qt.ItemIsEnabled)
item.setCheckState(Qt.Checked)
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
self.binstable.setItem(row, col, item)
if self.bin_opacities:
self.update_table_opacities()
if self.infodict.get("bin_opacities"):
self.bin_opacities = self.infodict["bin_opacities"]
if self.binstable.rowCount() > 0:
self.update_table_opacities()
if self.infodict.get("html_url"):
self.html_url = self.infodict["html_url"]
if self.UseOSbrowser == False:
self.BrowserBox.setUrl(self.html_url)
# workaround for background colour bug in chromium
# https://bugreports.qt.io/browse/QTBUG-41960
self.BrowserBox.page().setBackgroundColor(
QColor(100, 100, 100, 1.0))
if self.infodict.get("spacegroups"):
self.spacegroups = self.infodict.get("spacegroups", [])
self.SpaceGroupComboBox.clear()
self.SpaceGroupComboBox.addItems(self.spacegroups)
if self.infodict.get("merge_data"):
self.mergedata = self.infodict["merge_data"]
currentinfostr = ""
if self.infodict.get("info"):
currentinfostr = self.infodict.get("info", [])
if self.infodict.get("NewFileLoaded"):
self.NewFileLoaded = self.infodict.get(
"NewFileLoaded", False)
if self.infodict.get("NewHKLscenes"):
self.NewHKLscenes = self.infodict.get(
"NewHKLscenes", False)
self.fileisvalid = True
#print("ngl_hkl_infodict: " + str(ngl_hkl_infodict))
if currentinfostr:
#print(currentinfostr)
self.infostr += currentinfostr + "\n"
# display no more than self.bufsize bytes of text
self.infostr = self.infostr[-self.bufsize:]
self.textInfo.setPlainText(self.infostr)
self.textInfo.verticalScrollBar().setValue(
self.textInfo.verticalScrollBar().maximum())
if self.NewFileLoaded and self.NewHKLscenes:
#if self.mergedata == True : val = Qt.CheckState.Checked
#if self.mergedata == None : val = Qt.CheckState.PartiallyChecked
#if self.mergedata == False : val = Qt.CheckState.Unchecked
#self.mergecheckbox.setCheckState(val )
#print("got hklscenes: " + str(self.hklscenes_arrays))
self.MillerComboBox.clear()
self.MillerComboBox.addItems(
[e[3] for e in self.hklscenes_arrays])
self.MillerComboBox.setCurrentIndex(
-1) # unselect the first item in the list
self.comboviewwidth = 0
for e in self.hklscenes_arrays:
self.comboviewwidth = max(
self.comboviewwidth,
self.MillerComboBox.fontMetrics().width(e[3]))
self.MillerComboBox.view().setMinimumWidth(
self.comboviewwidth)
self.millertable.clearContents()
self.millertable.setRowCount(len(
self.hklscenes_arrays))
for n, millarr in enumerate(self.array_infotpls):
for m, elm in enumerate(millarr):
self.millertable.setItem(
n, m, QTableWidgetItem(str(elm)))
self.functionTabWidget.setDisabled(True)
self.NewFileLoaded = False
if self.NewHKLscenes:
self.BinDataComboBox.clear()
self.BinDataComboBox.addItems(
["Resolution"] +
[e[3] for e in self.hklscenes_arrays])
self.BinDataComboBox.view().setMinimumWidth(
self.comboviewwidth)
#self.BinDataComboBox.setCurrentIndex(-1) # unselect the first item in the list
self.NewHKLscenes = False
except Exception as e:
errmsg = str(e)
if "Resource temporarily unavailable" not in errmsg:
print(errmsg + traceback.format_exc(limit=10))
pass
def onFinalMouseSensitivity(self):
val = self.mousemoveslider.value() / 100.0
self.NGL_HKL_command(
'NGL_HKLviewer.viewer.NGL.mouse_sensitivity = %f' % val)
def onMouseSensitivity(self):
val = self.mousemoveslider.value() / 100.0
self.mousesensitxtbox.setText("%2.2f" % val)
def onFontsizeChanged(self, val):
font = app.font()
font.setPointSize(val)
app.setFont(font)
self.settingsform.setFixedSize(self.settingsform.sizeHint())
def onCameraPerspect(self, val):
if self.cameraPerspectCheckBox.isChecked():
self.NGL_HKL_command("NGL_HKLviewer.camera_type = perspective")
else:
self.NGL_HKL_command("NGL_HKLviewer.camera_type = orthographic")
def MergeData(self):
if self.mergecheckbox.checkState() == Qt.CheckState.Checked:
self.NGL_HKL_command('NGL_HKLviewer.mergedata = True')
if self.mergecheckbox.checkState() == Qt.CheckState.PartiallyChecked:
self.NGL_HKL_command('NGL_HKLviewer.mergedata = None')
if self.mergecheckbox.checkState() == Qt.CheckState.Unchecked:
self.NGL_HKL_command('NGL_HKLviewer.mergedata = False')
def ExpandToP1(self):
if self.expandP1checkbox.isChecked():
self.NGL_HKL_command('NGL_HKLviewer.viewer.expand_to_p1 = True')
else:
self.NGL_HKL_command('NGL_HKLviewer.viewer.expand_to_p1 = False')
def ExpandAnomalous(self):
if self.expandAnomalouscheckbox.isChecked():
self.NGL_HKL_command(
'NGL_HKLviewer.viewer.expand_anomalous = True')
else:
self.NGL_HKL_command(
'NGL_HKLviewer.viewer.expand_anomalous = False')
def showSysAbsent(self):
if self.sysabsentcheckbox.isChecked():
self.NGL_HKL_command(
'NGL_HKLviewer.viewer.show_systematic_absences = True')
else:
self.NGL_HKL_command(
'NGL_HKLviewer.viewer.show_systematic_absences = False')
def showMissing(self):
if self.missingcheckbox.isChecked():
self.NGL_HKL_command('NGL_HKLviewer.viewer.show_missing = True')
else:
self.NGL_HKL_command('NGL_HKLviewer.viewer.show_missing = False')
def showOnlyMissing(self):
if self.onlymissingcheckbox.isChecked():
self.NGL_HKL_command(
'NGL_HKLviewer.viewer.show_only_missing = True')
else:
self.NGL_HKL_command(
'NGL_HKLviewer.viewer.show_only_missing = False')
def showSlice(self):
if self.showslicecheckbox.isChecked():
self.NGL_HKL_command('NGL_HKLviewer.viewer.slice_mode = True')
if self.expandP1checkbox.isChecked():
self.NGL_HKL_command("""NGL_HKLviewer.viewer {
expand_to_p1 = True
inbrowser = False
}
""")
if self.expandAnomalouscheckbox.isChecked():
self.NGL_HKL_command("""NGL_HKLviewer.viewer {
expand_anomalous = True
inbrowser = False
}
""")
else:
self.NGL_HKL_command("""NGL_HKLviewer.viewer {
slice_mode = False
inbrowser = True
}
""")
def onSliceComboSelchange(self, i):
rmin = self.array_infotpls[self.MillerComboBox.currentIndex()][3][0][i]
rmax = self.array_infotpls[self.MillerComboBox.currentIndex()][3][1][i]
self.sliceindexspinBox.setRange(rmin, rmax)
self.NGL_HKL_command("NGL_HKLviewer.viewer.slice_axis = %s" %
self.sliceaxis[i])
def onSliceIndexChanged(self, val):
self.sliceindex = val
self.NGL_HKL_command("NGL_HKLviewer.viewer.slice_index = %d" %
self.sliceindex)
def onBindataComboSelchange(self, i):
if self.BinDataComboBox.currentText():
if self.BinDataComboBox.currentIndex() > 0:
bin_scene_label = str(self.BinDataComboBox.currentIndex() - 1)
else:
bin_scene_label = "Resolution"
self.NGL_HKL_command("NGL_HKLviewer.bin_scene_label = %s" %
bin_scene_label)
def update_table_opacities(self, allalpha=None):
bin_opacitieslst = eval(self.bin_opacities)
self.binstable_isready = False
for binopacity in bin_opacitieslst:
if not allalpha:
alpha = float(binopacity.split(",")[0])
else:
alpha = allalpha
bin = int(binopacity.split(",")[1])
item = QTableWidgetItem()
item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
if alpha < 0.5:
item.setCheckState(Qt.Unchecked)
else:
item.setCheckState(Qt.Checked)
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
self.binstable.setItem(bin, 3, item)
self.binstable_isready = True
def SetOpaqueAll(self):
if self.binstableitemchanges:
return
bin_opacitieslst = eval(self.bin_opacities)
nbins = len(bin_opacitieslst)
sum = 0
for binopacity in bin_opacitieslst:
sum += float(binopacity.split(",")[0])
if sum >= nbins:
self.OpaqueAllCheckbox.setCheckState(Qt.Checked)
if sum == 0:
self.OpaqueAllCheckbox.setCheckState(Qt.Unchecked)
if sum > 0.0 and sum < nbins:
self.OpaqueAllCheckbox.setCheckState(Qt.PartiallyChecked)
def onBinsTableItemChanged(self, item):
row = item.row()
column = item.column()
try:
if item.checkState() == Qt.Unchecked:
newval = 0
else:
newval = 1.0
if column == 3 and self.binstable_isready: # changing opacity
assert (newval <= 1.0 and newval >= 0.0)
bin_opacitieslst = eval(self.bin_opacities)
bin_opacitieslst[row] = str(newval) + ', ' + str(row)
self.bin_opacities = str(bin_opacitieslst)
self.SetOpaqueAll()
self.NGL_HKL_command(
'NGL_HKLviewer.viewer.NGL.bin_opacities = "%s"' %
self.bin_opacities)
except Exception as e:
print(str(e))
#self.binstable.currentItem().setText( self.currentSelectedBinsTableVal)
def onBinsTableItemSelectionChanged(self):
row = self.binstable.currentItem().row()
column = self.binstable.currentItem().column()
self.currentSelectedBinsTableVal = self.binstable.currentItem().text()
#print( "in itemSelectionChanged " + self.currentSelectedBinsTableVal)
def onOpaqueAll(self):
self.binstableitemchanges = True
bin_opacitieslst = eval(self.bin_opacities)
nbins = len(bin_opacitieslst)
bin_opacitieslst = []
self.binstable_isready = False
if self.OpaqueAllCheckbox.isChecked():
for i in range(nbins):
bin_opacitieslst.append("1.0, %d" % i)
else:
for i in range(nbins):
bin_opacitieslst.append("0.0, %d" % i)
self.bin_opacities = str(bin_opacitieslst)
self.NGL_HKL_command('NGL_HKLviewer.viewer.NGL.bin_opacities = "%s"' %
self.bin_opacities)
self.binstableitemchanges = False
self.binstable_isready = True
"""
def onLoadFinished(self, val):
pass
#print("web page finished loading now")
def onBinsTableitemActivated(self, item):
row = item.row()
column = item.column()
currentval = item.text()
#print( "in itemActivated " + currentval)
def onBinsTableCellentered(self, row, col):
pass
#print( "in Cellentered " + self.binstable.currentItem().text() )
def onBinsTableCellPressed(self, row, col):
pass
#print( "in CellPressed " + self.binstable.currentItem().text() )
"""
def onNbinsChanged(self, val):
self.nbins = val
if not self.updatingNbins: # avoid possible endless loop to cctbx
self.NGL_HKL_command("NGL_HKLviewer.nbins = %d" % self.nbins)
def onRadiiScaleChanged(self, val):
self.radii_scale = val
self.NGL_HKL_command("""
NGL_HKLviewer.viewer {
nth_power_scale_radii = %f
scale = %f
}
""" % (self.nth_power_scale, self.radii_scale))
def onPowerScaleChanged(self, val):
self.nth_power_scale = val
self.NGL_HKL_command("""
NGL_HKLviewer.viewer {
nth_power_scale_radii = %f
scale = %f
}
""" % (self.nth_power_scale, self.radii_scale))
def onManualPowerScale(self):
if self.ManualPowerScalecheckbox.isChecked():
self.NGL_HKL_command(
'NGL_HKLviewer.viewer.nth_power_scale_radii = %f' %
self.nth_power_scale)
self.power_scale_spinBox.setEnabled(True)
else:
self.NGL_HKL_command(
'NGL_HKLviewer.viewer.nth_power_scale_radii = -1.0')
self.power_scale_spinBox.setEnabled(False)
self.nth_power_scale = -1.0
def OpenReflectionsFile(self):
options = QFileDialog.Options()
fileName, filtr = QFileDialog.getOpenFileName(
self, "Load reflections file", "",
"All Files (*);;MTZ Files (*.mtz);;CIF (*.cif)", "", options)
if fileName:
self.HKLnameedit.setText(fileName)
#self.infostr = ""
self.textInfo.setPlainText("")
self.fileisvalid = False
self.NGL_HKL_command('NGL_HKLviewer.filename = "%s"' % fileName)
self.MillerComboBox.clear()
self.BinDataComboBox.clear()
def createExpansionBox(self):
self.SpaceGroupComboBox = QComboBox()
self.SpaceGroupComboBox.activated.connect(self.SpacegroupSelchange)
self.SpacegroupLabel = QLabel()
self.SpacegroupLabel.setText("Space Subgroups")
self.mergecheckbox = QCheckBox()
self.mergecheckbox.setText("Merge data")
#self.mergecheckbox.setTristate (True)
self.mergecheckbox.clicked.connect(self.MergeData)
self.expandP1checkbox = QCheckBox()
self.expandP1checkbox.setText("Expand to P1")
self.expandP1checkbox.clicked.connect(self.ExpandToP1)
self.expandAnomalouscheckbox = QCheckBox()
self.expandAnomalouscheckbox.setText("Show Friedel pairs")
self.expandAnomalouscheckbox.clicked.connect(self.ExpandAnomalous)
self.sysabsentcheckbox = QCheckBox()
self.sysabsentcheckbox.setText("Show Systematic Absences")
self.sysabsentcheckbox.clicked.connect(self.showSysAbsent)
self.missingcheckbox = QCheckBox()
self.missingcheckbox.setText("Show Missing")
self.missingcheckbox.clicked.connect(self.showMissing)
self.onlymissingcheckbox = QCheckBox()
self.onlymissingcheckbox.setText("Only Show Missing")
self.onlymissingcheckbox.clicked.connect(self.showOnlyMissing)
self.ExpansionBox = QGroupBox("Expansions")
layout = QGridLayout()
layout.addWidget(self.SpacegroupLabel, 0, 0)
layout.addWidget(self.SpaceGroupComboBox, 0, 1)
#layout.addWidget(self.mergecheckbox, 1, 0)
layout.addWidget(self.expandP1checkbox, 1, 0)
layout.addWidget(self.expandAnomalouscheckbox, 1, 1)
layout.addWidget(self.sysabsentcheckbox, 2, 0)
layout.addWidget(self.missingcheckbox, 3, 0)
layout.addWidget(self.onlymissingcheckbox, 3, 1)
layout.setRowStretch(0, 0)
layout.setRowStretch(1, 0)
layout.setRowStretch(2, 0)
layout.setRowStretch(3, 1)
self.ExpansionBox.setLayout(layout)
def CreateSliceTabs(self):
self.showslicecheckbox = QCheckBox()
self.showslicecheckbox.setText("Show Slice")
self.showslicecheckbox.clicked.connect(self.showSlice)
self.sliceindexspinBox = QDoubleSpinBox()
self.sliceindex = 0
self.sliceindexspinBox.setValue(self.sliceindex)
self.sliceindexspinBox.setDecimals(0)
self.sliceindexspinBox.setSingleStep(1)
self.sliceindexspinBox.setRange(0, 20)
self.sliceindexspinBox.valueChanged.connect(self.onSliceIndexChanged)
self.SliceLabelComboBox = QComboBox()
self.SliceLabelComboBox.activated.connect(self.onSliceComboSelchange)
self.sliceaxis = ["h", "k", "l"]
self.SliceLabelComboBox.addItems(self.sliceaxis)
self.sliceTabWidget = QTabWidget()
tab1 = QWidget()
layout1 = QGridLayout()
layout1.addWidget(self.showslicecheckbox, 0, 0, 1, 1)
layout1.addWidget(self.SliceLabelComboBox, 0, 1, 1, 1)
layout1.addWidget(self.sliceindexspinBox, 0, 2, 1, 1)
tab1.setLayout(layout1)
tab2 = QWidget()
layout2 = QGridLayout()
self.hvec_spinBox = QDoubleSpinBox(self.sliceTabWidget)
self.hvecval = 2.0
self.hvec_spinBox.setValue(self.hvecval)
self.hvec_spinBox.setDecimals(2)
self.hvec_spinBox.setSingleStep(0.5)
self.hvec_spinBox.setRange(-100.0, 10.0)
self.hvec_spinBox.valueChanged.connect(self.onHvecChanged)
self.hvec_Label = QLabel()
self.hvec_Label.setText("H")
layout2.addWidget(self.hvec_Label, 0, 0, 1, 1)
layout2.addWidget(self.hvec_spinBox, 0, 1, 1, 1)
self.kvec_spinBox = QDoubleSpinBox(self.sliceTabWidget)
self.kvecval = 0.0
self.kvec_spinBox.setValue(self.kvecval)
self.kvec_spinBox.setDecimals(2)
self.kvec_spinBox.setSingleStep(0.5)
self.kvec_spinBox.setRange(-100.0, 100.0)
self.kvec_spinBox.valueChanged.connect(self.onKvecChanged)
self.kvec_Label = QLabel()
self.kvec_Label.setText("K")
layout2.addWidget(self.kvec_Label, 1, 0, 1, 1)
layout2.addWidget(self.kvec_spinBox, 1, 1, 1, 1)
self.lvec_spinBox = QDoubleSpinBox(self.sliceTabWidget)
self.lvecval = 0.0
self.lvec_spinBox.setValue(self.lvecval)
self.lvec_spinBox.setDecimals(2)
self.lvec_spinBox.setSingleStep(0.5)
self.lvec_spinBox.setRange(-100.0, 100.0)
self.lvec_spinBox.valueChanged.connect(self.onLvecChanged)
self.lvec_Label = QLabel()
self.lvec_Label.setText("L")
layout2.addWidget(self.lvec_Label, 2, 0, 1, 1)
layout2.addWidget(self.lvec_spinBox, 2, 1, 1, 1)
self.hkldist_spinBox = QDoubleSpinBox(self.sliceTabWidget)
self.hkldistval = 0.0
self.hkldist_spinBox.setValue(self.hkldistval)
self.hkldist_spinBox.setDecimals(2)
self.hkldist_spinBox.setSingleStep(0.5)
self.hkldist_spinBox.setRange(-100.0, 100.0)
self.hkldist_spinBox.valueChanged.connect(self.onHKLdistChanged)
self.hkldist_Label = QLabel()
self.hkldist_Label.setText("Distance from Origin")
layout2.addWidget(self.hkldist_Label, 3, 0, 1, 1)
layout2.addWidget(self.hkldist_spinBox, 3, 1, 1, 1)
self.clipwidth_spinBox = QDoubleSpinBox(self.sliceTabWidget)
self.clipwidthval = 0.5
self.clipwidth_spinBox.setValue(self.clipwidthval)
self.clipwidth_spinBox.setDecimals(2)
self.clipwidth_spinBox.setSingleStep(0.05)
self.clipwidth_spinBox.setRange(0.0, 100.0)
self.clipwidth_spinBox.valueChanged.connect(self.onClipwidthChanged)
self.clipwidth_Label = QLabel()
self.clipwidth_Label.setText("Clip Plane Width")
layout2.addWidget(self.clipwidth_Label, 4, 0, 1, 1)
layout2.addWidget(self.clipwidth_spinBox, 4, 1, 1, 1)
self.ClipBox = QGroupBox("Normal Vector to Clip Plane")
self.ClipBox.setLayout(layout2)
layout3 = QGridLayout()
self.ClipPlaneChkBox = QCheckBox(self.sliceTabWidget)
self.ClipPlaneChkBox.setText(
"Use clip plane normal to HKL vector pointing out")
self.ClipPlaneChkBox.clicked.connect(self.onClipPlaneChkBox)
layout3.addWidget(self.ClipPlaneChkBox, 0, 0)
layout3.addWidget(self.ClipBox, 1, 0)
tab2.setLayout(layout3)
self.sliceTabWidget.addTab(tab1, "Explicit Slicing")
self.sliceTabWidget.addTab(tab2, "Clip Plane Slicing")
self.ClipBox.setDisabled(True)
def onClipPlaneChkBox(self):
if self.ClipPlaneChkBox.isChecked():
self.ClipBox.setDisabled(False)
philstr = """NGL_HKLviewer.normal_clip_plane {
h = %s
k = %s
l = %s
hkldist = %s
clipwidth = %s
}
NGL_HKLviewer.viewer.NGL.fixorientation = %s
""" %(self.hvecval, self.kvecval, self.lvecval, self.hkldistval, self.clipwidthval, \
str(self.fixedorientcheckbox.isChecked()) )
self.NGL_HKL_command(philstr)
else:
self.ClipBox.setDisabled(True)
self.NGL_HKL_command(
"NGL_HKLviewer.normal_clip_plane.clipwidth = None")
def onClipwidthChanged(self, val):
self.clipwidthval = val
self.NGL_HKL_command("NGL_HKLviewer.normal_clip_plane.clipwidth = %f" %
self.clipwidthval)
def onHKLdistChanged(self, val):
self.hkldistval = val
self.NGL_HKL_command("NGL_HKLviewer.normal_clip_plane.hkldist = %f" %
self.hkldistval)
def onHvecChanged(self, val):
self.hvecval = val
self.NGL_HKL_command("NGL_HKLviewer.normal_clip_plane.h = %f" %
self.hvecval)
def onKvecChanged(self, val):
self.kvecval = val
self.NGL_HKL_command("NGL_HKLviewer.normal_clip_plane.k = %f" %
self.kvecval)
def onLvecChanged(self, val):
self.lvecval = val
self.NGL_HKL_command("NGL_HKLviewer.normal_clip_plane.l = %f" %
self.lvecval)
def onFixedorient(self):
self.NGL_HKL_command('NGL_HKLviewer.viewer.NGL.fixorientation = %s' \
%str(self.fixedorientcheckbox.isChecked()))
def onMillerComboSelchange(self, i):
self.NGL_HKL_command("NGL_HKLviewer.scene_id = %d" % i)
#self.MillerComboBox.setCurrentIndex(i)
if self.MillerComboBox.currentText():
self.functionTabWidget.setEnabled(True)
self.expandAnomalouscheckbox.setEnabled(True)
# don' allow anomalous expansion for data that's already anomalous
for arrayinfo in self.array_infotpls:
isanomalous = arrayinfo[-1]
label = arrayinfo[0]
if isanomalous and label == self.MillerComboBox.currentText(
)[:len(label)]:
self.expandAnomalouscheckbox.setDisabled(True)
else:
self.functionTabWidget.setDisabled(True)
self.SpaceGroupComboBox.clear()
self.SpaceGroupComboBox.addItems(self.spacegroups)
# need to supply issymunique flag in infotuple
#if self.hklscenes_arrays[ i ][6] == 0:
# self.mergecheckbox.setEnabled(True)
#else:
# self.mergecheckbox.setEnabled(False)
def createFileInfoBox(self):
self.FileInfoBox = QGroupBox("Reflection File Information")
layout = QGridLayout()
layout.addWidget(self.openFileNameButton, 0, 0, 1, 2)
if self.devmode:
layout.addWidget(self.debugbutton, 0, 2, 1, 1)
layout.addWidget(self.HKLnameedit, 1, 0, 1, 3)
layout.addWidget(self.millertable, 2, 0, 1, 3)
layout.addWidget(self.textInfo, 3, 0, 1, 3)
#layout.setColumnStretch(1, 2)
self.FileInfoBox.setLayout(layout)
def createRadiiScaleGroupBox(self):
self.RadiiScaleGroupBox = QGroupBox("Radii Size of HKL Spheres")
self.ManualPowerScalecheckbox = QCheckBox()
self.ManualPowerScalecheckbox.setText(
"Manual Power Scaling of Sphere Radii")
self.ManualPowerScalecheckbox.clicked.connect(self.onManualPowerScale)
self.power_scale_spinBox = QDoubleSpinBox(self.RadiiScaleGroupBox)
self.nth_power_scale = 0.5
self.power_scale_spinBox.setValue(self.nth_power_scale)
self.power_scale_spinBox.setDecimals(2)
self.power_scale_spinBox.setSingleStep(0.05)
self.power_scale_spinBox.setRange(0.0, 1.0)
self.power_scale_spinBox.valueChanged.connect(self.onPowerScaleChanged)
self.power_scale_spinBox.setEnabled(False)
self.powerscaleLabel = QLabel()
self.powerscaleLabel.setText("Power scale Factor")
self.radii_scale_spinBox = QDoubleSpinBox(self.RadiiScaleGroupBox)
self.radii_scale = 1.0
self.radii_scale_spinBox.setValue(self.radii_scale)
self.radii_scale_spinBox.setDecimals(1)
self.radii_scale_spinBox.setSingleStep(0.1)
self.radii_scale_spinBox.setRange(0.2, 2.0)
self.radii_scale_spinBox.valueChanged.connect(self.onRadiiScaleChanged)
self.radiiscaleLabel = QLabel()
self.radiiscaleLabel.setText("Linear Scale Factor")
layout = QGridLayout()
layout.addWidget(self.ManualPowerScalecheckbox, 1, 0, 1, 2)
layout.addWidget(self.powerscaleLabel, 2, 0, 1, 2)
layout.addWidget(self.power_scale_spinBox, 2, 1, 1, 2)
layout.addWidget(self.radiiscaleLabel, 3, 0, 1, 2)
layout.addWidget(self.radii_scale_spinBox, 3, 1, 1, 2)
layout.setColumnStretch(0, 1)
layout.setColumnStretch(1, 0)
self.RadiiScaleGroupBox.setLayout(layout)
def createBinsBox(self):
self.binstable = QTableWidget(0, 4)
self.binstable_isready = False
labels = [
"no. of HKLs", "lower bin value", "upper bin value", "opacity"
]
self.binstable.setHorizontalHeaderLabels(labels)
self.binstable.horizontalHeader().setDefaultAlignment(Qt.AlignLeft)
self.bindata_labeltxt = QLabel()
self.bindata_labeltxt.setText("Data binned:")
self.Nbins_spinBox = QSpinBox()
self.Nbins_spinBox.setSingleStep(1)
self.Nbins_spinBox.setRange(1, 40)
self.Nbins_spinBox.valueChanged.connect(self.onNbinsChanged)
self.Nbins_labeltxt = QLabel()
self.Nbins_labeltxt.setText("Number of bins:")
self.OpaqueAllCheckbox = QCheckBox()
#self.OpaqueAllCheckbox.setTristate()
self.OpaqueAllCheckbox.setText("Show all data in bins")
self.OpaqueAllCheckbox.clicked.connect(self.onOpaqueAll)
self.binstable.itemChanged.connect(self.onBinsTableItemChanged)
self.binstable.itemSelectionChanged.connect(
self.onBinsTableItemSelectionChanged)
self.BinDataComboBox = QComboBox()
self.BinDataComboBox.activated.connect(self.onBindataComboSelchange)
self.BinsGroupBox = QGroupBox("Bins")
layout = QGridLayout()
layout.addWidget(self.bindata_labeltxt, 0, 0)
layout.addWidget(self.BinDataComboBox, 0, 1)
layout.addWidget(self.Nbins_labeltxt, 0, 2)
layout.addWidget(self.Nbins_spinBox, 0, 3)
layout.addWidget(self.OpaqueAllCheckbox, 1, 2)
layout.addWidget(self.binstable, 2, 0, 1, 4)
layout.setColumnStretch(0, 0)
layout.setColumnStretch(1, 2)
layout.setColumnStretch(3, 1)
self.BinsGroupBox.setLayout(layout)
def DebugInteractively(self):
import code, traceback
code.interact(local=locals(),
banner="".join(traceback.format_stack(limit=10)))
def CreateFunctionTabs(self):
self.functionTabWidget = QTabWidget()
tab1 = QWidget()
layout1 = QGridLayout()
layout1.addWidget(self.ExpansionBox, 0, 0)
layout1.setRowStretch(0, 0)
tab1.setLayout(layout1)
tab2 = QWidget()
layout2 = QGridLayout()
self.fixedorientcheckbox = QCheckBox(self.sliceTabWidget)
self.fixedorientcheckbox.setText(
"Fix orientation but allow zoom and translation")
self.fixedorientcheckbox.clicked.connect(self.onFixedorient)
layout2.addWidget(self.fixedorientcheckbox, 0, 0)
layout2.addWidget(self.sliceTabWidget, 1, 0)
tab2.setLayout(layout2)
tab3 = QWidget()
layout3 = QGridLayout()
layout3.addWidget(self.RadiiScaleGroupBox, 0, 0)
tab3.setLayout(layout3)
tab4 = QWidget()
layout4 = QGridLayout()
layout4.addWidget(self.BinsGroupBox, 0, 0)
tab4.setLayout(layout4)
self.functionTabWidget.addTab(tab1, "Expand")
self.functionTabWidget.addTab(tab2, "Slice")
self.functionTabWidget.addTab(tab3, "Size")
self.functionTabWidget.addTab(tab4, "Bins")
self.functionTabWidget.setDisabled(True)
def SpacegroupSelchange(self, i):
self.NGL_HKL_command("NGL_HKLviewer.spacegroup_choice = %d" % i)
def find_free_port(self):
import socket
s = socket.socket()
s.bind(('', 0)) # Bind to a free port provided by the host.
port = s.getsockname()[1]
s.close()
return port
def LaunchCCTBXPython(self):
self.sockport = self.find_free_port()
self.zmq_context = zmq.Context()
self.socket = self.zmq_context.socket(zmq.PAIR)
self.socket.bind("tcp://127.0.0.1:%s" % self.sockport)
try:
msg = self.socket.recv(
flags=zmq.NOBLOCK) #To empty the socket from previous messages
except Exception as e:
pass
cmdargs = 'cctbx.python.bat -i -c "from crys3d.hklview import cmdlineframes;' \
+ ' myHKLview = cmdlineframes.HKLViewFrame(useGuiSocket=%s, high_quality=True,' %self.sockport \
+ ' jscriptfname = \'%s\', ' %self.jscriptfname \
+ ' verbose=%s, UseOSBrowser= %s )"\n' %(self.verbose, str(self.UseOSbrowser))
self.cctbxproc = subprocess.Popen(cmdargs,
shell=True,
stdin=subprocess.PIPE,
stdout=sys.stdout,
stderr=sys.stderr)
#time.sleep(1)
def NGL_HKL_command(self, cmdstr):
#print("sending:\n" + cmdstr)
self.socket.send(bytes(cmdstr, "utf-8"))
class TrainingPanel(Panel):
def __init__(self, datasets, testing_panel, threads):
super().__init__()
if isinstance(testing_panel, TestingPanel):
self.testing_panel = testing_panel
else:
raise TypeError('"testing_panel" must be the instance of '
'"TestingPanel"')
self.datasets = datasets
self.threads = threads
self.__set_execution_ui()
self.__set_options_ui()
self.__set_outputs_ui()
self.__set_graphic_ui()
def __set_execution_ui(self):
group_box = QGroupBox('Training Execution')
inner_layout = QHBoxLayout()
group_box.setLayout(inner_layout)
self.data_selector = QComboBox()
self.data_selector.addItems(list(self.datasets.keys()))
self.data_selector.setStatusTip('Select the training dataset.')
self.start_btn = QPushButton('Train')
self.start_btn.setStatusTip('Start training.')
self.start_btn.clicked.connect(self.__run)
self.stop_btn = QPushButton('Stop')
self.stop_btn.setStatusTip('Force the training stop running.')
self.stop_btn.setDisabled(True)
self.multicore_cb = QCheckBox('Multicore')
self.multicore_cb.setStatusTip('Use multiprocessing in calculating '
'fitting for populations.')
self.multicore_cb.setChecked(True)
inner_layout.addWidget(self.data_selector, 1)
inner_layout.addWidget(self.start_btn)
inner_layout.addWidget(self.stop_btn)
inner_layout.addWidget(self.multicore_cb)
self._layout.addWidget(group_box)
def __set_options_ui(self):
group_box = QGroupBox('Training Options')
inner_layout = QFormLayout()
group_box.setLayout(inner_layout)
self.iter_times = QSpinBox()
self.iter_times.setRange(1, 1000000)
self.iter_times.setValue(200)
self.iter_times.setStatusTip('The total iterating times for training.')
self.population_size = QSpinBox()
self.population_size.setRange(1, 100000)
self.population_size.setValue(100)
self.population_size.setStatusTip('The population size for the PSO.')
self.inertia_weight = QDoubleSpinBox()
self.inertia_weight.setRange(0, 50)
self.inertia_weight.setValue(1)
self.inertia_weight.setSingleStep(0.1)
self.inertia_weight.setStatusTip('The inertia weight of the velocity '
' for each individual.')
self.cognitive_const_rand_upper = QDoubleSpinBox()
self.cognitive_const_rand_upper.setRange(0, 50)
self.cognitive_const_rand_upper.setValue(2)
self.cognitive_const_rand_upper.setSingleStep(0.1)
self.cognitive_const_rand_upper.setStatusTip(
'The random upper bound for cognitive accelerate constant.')
self.social_const_rand_upper = QDoubleSpinBox()
self.social_const_rand_upper.setRange(0, 50)
self.social_const_rand_upper.setValue(3)
self.social_const_rand_upper.setSingleStep(0.1)
self.social_const_rand_upper.setStatusTip(
'The random upper bound for social accelerate constant.')
self.v_max = QDoubleSpinBox()
self.v_max.setRange(0.5, 100)
self.v_max.setValue(5)
self.v_max.setSingleStep(1)
self.v_max.setStatusTip('The maximum of velocity for each individual.')
self.nneuron = QSpinBox()
self.nneuron.setRange(1, 100)
self.nneuron.setValue(6)
self.nneuron.setStatusTip('The number of RBFN neuron.')
self.sd_max = QDoubleSpinBox()
self.sd_max.setRange(0.01, 20)
self.sd_max.setValue(10)
self.sd_max.setSingleStep(0.1)
self.sd_max.setStatusTip('The random range maximum of standard '
'deviation of each neuron in RBFN (only for '
'initialization).')
inner_layout.addRow('Iterating Times:', self.iter_times)
inner_layout.addRow('Population Size:', self.population_size)
inner_layout.addRow('Inertia Weight:', self.inertia_weight)
inner_layout.addRow('Cognitive Const Upper:',
self.cognitive_const_rand_upper)
inner_layout.addRow('Social Const Upper:',
self.social_const_rand_upper)
inner_layout.addRow('Maximum of Velocity:', self.v_max)
inner_layout.addRow('Number of Neuron:', self.nneuron)
inner_layout.addRow('Maximum of SD:', self.sd_max)
self._layout.addWidget(group_box)
def __set_outputs_ui(self):
group_box = QGroupBox('Training Details')
inner_layout = QFormLayout()
group_box.setLayout(inner_layout)
self.current_iter_time = QLabel('--')
self.current_error = QLabel('--')
self.avg_error = QLabel('--')
self.global_best_error = QLabel('--')
self.total_best_error = QLabel('--')
self.progressbar = QProgressBar()
self.current_iter_time.setAlignment(Qt.AlignCenter)
self.current_error.setAlignment(Qt.AlignCenter)
self.avg_error.setAlignment(Qt.AlignCenter)
self.global_best_error.setAlignment(Qt.AlignCenter)
self.total_best_error.setAlignment(Qt.AlignCenter)
self.current_iter_time.setStatusTip('The current iterating time of '
'the PSO.')
self.current_error.setStatusTip('The current error from the fitting '
'function. ("( )": normalized error)')
self.avg_error.setStatusTip('The average error from the fitting '
'function in current iteration. ("( )": '
'normalized error)')
self.global_best_error.setStatusTip(
'The error of global best individual from the fitting function in '
'current iteration. ("( )": normalized error)')
self.total_best_error.setStatusTip(
'The error of total best individual from the fitting function in '
'training. ("( )": normalized error)')
inner_layout.addRow('Current Iterating Time:', self.current_iter_time)
inner_layout.addRow('Current Error:', self.current_error)
inner_layout.addRow('Average Error:', self.avg_error)
inner_layout.addRow('Global Best Error:', self.global_best_error)
inner_layout.addRow('Total Best Error:', self.total_best_error)
inner_layout.addRow(self.progressbar)
self._layout.addWidget(group_box)
def __set_graphic_ui(self):
group_box = QGroupBox('Error Line Charts:')
inner_layout = QVBoxLayout()
group_box.setLayout(inner_layout)
self.err_chart = ErrorLineChart(1)
self.err_chart.setStatusTip('The history of error from the fitting '
'of the PSO for each data.')
self.__err_x = 1
self.iter_err_chart = ErrorLineChart(
3, ('Avg', 'Global Best', 'Total Best'))
self.iter_err_chart.setStatusTip('The history of average and least '
'error from the fitting of the PSO '
'for each iteration.')
self.iter_err_chart.setMinimumHeight(150)
inner_layout.addWidget(QLabel('Current Error'))
inner_layout.addWidget(self.err_chart)
inner_layout.addWidget(QLabel('Average Error'))
inner_layout.addWidget(self.iter_err_chart)
self._layout.addWidget(group_box)
@Slot()
def __init_widgets(self):
self.start_btn.setDisabled(True)
self.stop_btn.setEnabled(True)
self.multicore_cb.setDisabled(True)
self.data_selector.setDisabled(True)
self.iter_times.setDisabled(True)
self.population_size.setDisabled(True)
self.inertia_weight.setDisabled(True)
self.cognitive_const_rand_upper.setDisabled(True)
self.social_const_rand_upper.setDisabled(True)
self.v_max.setDisabled(True)
self.nneuron.setDisabled(True)
self.sd_max.setDisabled(True)
self.err_chart.clear()
self.iter_err_chart.clear()
self.__err_x = 1
@Slot()
def __reset_widgets(self):
self.start_btn.setEnabled(True)
self.stop_btn.setDisabled(True)
self.multicore_cb.setEnabled(True)
self.data_selector.setEnabled(True)
self.iter_times.setEnabled(True)
self.population_size.setEnabled(True)
self.inertia_weight.setEnabled(True)
self.cognitive_const_rand_upper.setEnabled(True)
self.social_const_rand_upper.setEnabled(True)
self.v_max.setEnabled(True)
self.nneuron.setEnabled(True)
self.sd_max.setEnabled(True)
self.progressbar.setMinimum(0)
self.progressbar.setMaximum(100)
@Slot()
def __indicate_busy(self):
self.progressbar.setMinimum(0)
self.progressbar.setMaximum(0)
@Slot(int)
def __show_current_iter_time(self, value):
self.current_iter_time.setText(str(value + 1))
self.progressbar.setValue(value + 1)
@Slot(float)
def __show_current_error(self, value):
self.current_error.setText('{:.5f} ({:.5f})'.format(value, value / 40))
self.err_chart.append_point(self.__err_x, value)
self.__err_x += 1
@Slot(float, float, float)
def __show_iter_error(self, avg, glob, total):
self.avg_error.setText('{:.5f} ({:.5f})'.format(avg, avg / 40))
self.global_best_error.setText(
'{:.5f} ({:.5f})'.format(glob, glob / 40))
self.total_best_error.setText(
'{:.5f} ({:.5f})'.format(total, total / 40))
self.iter_err_chart.append_point(
int(self.current_iter_time.text()), total, 2)
self.iter_err_chart.append_point(
int(self.current_iter_time.text()), glob, 1)
self.iter_err_chart.append_point(
int(self.current_iter_time.text()), avg, 0)
def __run(self):
self.progressbar.setMaximum(self.iter_times.value())
self.__current_dataset = self.datasets[
self.data_selector.currentText()]
self.__pso = PSO(self.iter_times.value(), self.population_size.value(),
self.inertia_weight.value(),
self.cognitive_const_rand_upper.value(),
self.social_const_rand_upper.value(),
self.v_max.value(), self.nneuron.value(),
self.__current_dataset, self.sd_max.value(),
is_multicore=self.multicore_cb.isChecked())
self.threads.append(self.__pso)
self.stop_btn.clicked.connect(self.__pso.stop)
self.__pso.started.connect(self.__init_widgets)
self.__pso.finished.connect(self.__reset_widgets)
self.__pso.sig_current_iter_time.connect(self.__show_current_iter_time)
self.__pso.sig_current_error.connect(self.__show_current_error)
self.__pso.sig_iter_error.connect(self.__show_iter_error)
self.__pso.sig_indicate_busy.connect(self.__indicate_busy)
self.__pso.sig_console.connect(self.testing_panel.print_console)
self.__pso.sig_rbfn.connect(self.testing_panel.load_rbfn)
self.__pso.start()
class InputsLayout(QFormLayout):
# this signal is connected to print_output from output_layout class. Connection is done in center_layout
ga_result = Signal(
str
) # a signal that is emitted so it can transfer resulting string to the output_layout class
def __init__(self):
super(InputsLayout, self).__init__()
self.big_font = QFont()
self.medium_font = QFont()
self.header = QLabel()
self.header_general = QLabel()
self.header_fitness_remapping = QLabel()
self.header_stop = QLabel()
self.header_selection = QLabel()
self.header_pairing = QLabel()
self.header_crossover = QLabel()
self.header_mutation = QLabel()
self.inp_functions_combo = QComboBox()
self.inp_num_variables = QSpinBox()
self.inp_extrema_min = QRadioButton("Minimum")
self.inp_extrema_max = QRadioButton("Maximum")
self.inp_pop_size = QSpinBox()
self.inp_lower_bound = QDoubleSpinBox()
self.inp_upper_bound = QDoubleSpinBox()
# Stopping
self.inp_max_iter = QSpinBox()
self.inp_similarity_cb = QCheckBox()
self.inp_similarity = QSpinBox()
self.inp_best_result_cb = QCheckBox()
self.inp_best_result = QDoubleSpinBox()
self.inp_average_result_cb = QCheckBox()
self.inp_average_result = QDoubleSpinBox()
# Fitness remapping
self.inp_fitness_remapping = QComboBox()
# Selection
self.inp_selection_method = QComboBox()
self.inp_elitism = QDoubleSpinBox()
# Pairing
self.inp_pairing_method = QComboBox()
# Crossover
self.inp_crossover_method = QComboBox()
self.inp_crossover_fraction = QDoubleSpinBox()
self.intermediate_offset = QDoubleSpinBox()
# Mutation
self.inp_mutation_method = QComboBox()
self.inp_mutation_intensity = QDoubleSpinBox()
self.inp_mutation_intensity_final = QDoubleSpinBox()
self.init_fonts()
self.init_header()
self.init_row_functions()
self.init_row_general()
self.init_row_fitness_remapping()
self.init_row_stop()
self.init_row_selection()
self.init_row_pairing()
self.init_row_crossover()
self.init_row_mutation()
def init_fonts(self):
self.big_font.setPointSizeF(14)
self.medium_font.setPointSizeF(12)
def init_header(self):
self.header.setFont(self.big_font)
self.header.setAlignment(Qt.AlignCenter)
self.header.setText("Genetic Algorithm Continuous Optimization")
self.addRow(self.header)
self.addRow(QHLine())
def init_row_functions(self):
self.inp_functions_combo.addItem("Ackley", ackley)
self.inp_functions_combo.addItem("Griewank", griewank)
self.inp_functions_combo.addItem("Michalewicz", michalewicz)
self.inp_extrema_min.setChecked(True)
radio_box = QHBoxLayout()
radio_box.addWidget(self.inp_extrema_min)
radio_box.addWidget(self.inp_extrema_max)
self.addRow("Function:", self.inp_functions_combo)
self.inp_num_variables.setMaximum(10000)
self.inp_num_variables.setValue(10)
self.addRow("Number of variables:", self.inp_num_variables)
self.addRow("Find:", radio_box)
self.addRow(QHLine())
def init_row_general(self):
self.header_general.setFont(self.medium_font)
self.header_general.setText("General")
self.inp_pop_size.setMaximum(10000)
self.inp_pop_size.setValue(300)
self.inp_lower_bound.setMaximum(1000000)
self.inp_lower_bound.setMinimum(-1000000.0)
self.inp_lower_bound.setValue(-10)
self.inp_upper_bound.setMaximum(1000000)
self.inp_upper_bound.setMinimum(-1000000.0)
self.inp_upper_bound.setValue(10)
self.addRow(self.header_general)
self.addRow("Population size", self.inp_pop_size)
self.addRow("Lower Bound", self.inp_lower_bound)
self.addRow("Upper Bound", self.inp_upper_bound)
self.addRow(QHLine())
def init_row_fitness_remapping(self):
self.header_fitness_remapping.setFont(self.medium_font)
self.header_fitness_remapping.setText("Fitness Remapping")
self.inp_fitness_remapping.addItem("Rank Scaling", "Rank Scaling")
self.inp_fitness_remapping.addItem("Fitness Scaling",
"Fitness Scaling")
self.addRow(self.header_fitness_remapping)
self.addRow("Fitness remapping", self.inp_fitness_remapping)
self.addRow(QHLine())
def init_row_stop(self):
self.header_stop.setFont(self.medium_font)
self.header_stop.setText("Stopping Criteria")
self.inp_max_iter.setMaximum(100000)
self.inp_similarity.setMaximum(100000)
self.inp_best_result.setMinimum(-100000)
self.inp_best_result.setMaximum(100000)
self.inp_average_result.setMinimum(-100000)
self.inp_average_result.setMaximum(100000)
self.inp_max_iter.setValue(500)
self.inp_similarity.setValue(80)
self.inp_best_result.setValue(-10)
self.inp_average_result.setValue(-10000)
self.inp_similarity_cb.setText("Similar Results")
self.inp_best_result_cb.setText("Best Result")
self.inp_average_result_cb.setText("Average Result")
self.inp_similarity_cb.stateChanged.connect(self.cb_similarity_signal)
self.inp_best_result_cb.stateChanged.connect(
self.cb_best_result_signal)
self.inp_average_result_cb.stateChanged.connect(
self.cb_average_result_signal)
self.inp_similarity_cb.setChecked(False)
self.inp_best_result_cb.setChecked(False)
self.inp_average_result_cb.setChecked(False)
self.inp_similarity.setEnabled(True)
self.inp_best_result.setEnabled(False)
self.inp_best_result.setStyleSheet("background:#555")
self.inp_average_result.setEnabled(False)
self.inp_average_result.setStyleSheet("background:#555")
self.addRow(self.header_stop)
self.addRow("Max iter", self.inp_max_iter)
self.addRow(self.inp_similarity_cb, self.inp_similarity)
self.addRow(self.inp_best_result_cb, self.inp_best_result)
self.addRow(self.inp_average_result_cb, self.inp_average_result)
self.addRow(QHLine())
def init_row_selection(self):
self.header_selection.setFont(self.medium_font)
self.header_selection.setText("Selection")
self.inp_selection_method.addItem("Fittest Half", "Fittest Half")
self.inp_selection_method.addItem("Roulette Wheel", "Roulette Wheel")
self.inp_selection_method.addItem("Random", "Random")
self.inp_selection_method.addItem("Whole Population",
"Whole Population")
self.inp_elitism.setMaximum(1)
self.inp_elitism.setValue(0.01)
self.inp_elitism.setSingleStep(0.01)
self.addRow(self.header_selection)
self.addRow("Selection Method", self.inp_selection_method)
self.addRow("Elitism Percentage", self.inp_elitism)
self.addRow(QHLine())
def init_row_pairing(self):
self.header_pairing.setFont(self.medium_font)
self.header_pairing.setText("Pairing")
self.inp_pairing_method.addItem("Random", "Random")
self.inp_pairing_method.addItem("Roulette Wheel", "Roulette Wheel")
self.inp_pairing_method.addItem("Fittest", "Fittest")
self.addRow(self.header_pairing)
self.addRow("Pairing Method", self.inp_pairing_method)
self.addRow(QHLine())
def init_row_crossover(self):
self.header_crossover.setFont(self.medium_font)
self.header_crossover.setText("Crossover")
self.inp_crossover_method.addItem("Intermediate", "Intermediate")
self.inp_crossover_method.addItem("Line Intermediate",
"Line Intermediate")
self.inp_crossover_method.addItem("Heuristic", "Heuristic")
self.inp_crossover_method.addItem("One point", "One point")
self.inp_crossover_method.addItem("Two point", "Two point")
self.inp_crossover_method.addItem("Random", "Random")
self.inp_mutation_method.setCurrentIndex(2)
self.inp_crossover_fraction.setMaximum(1)
self.inp_crossover_fraction.setValue(0.7)
self.inp_crossover_fraction.setSingleStep(0.05)
self.intermediate_offset.setMaximum(20)
self.intermediate_offset.setValue(1.55)
self.intermediate_offset.setSingleStep(0.05)
self.addRow(self.header_crossover)
self.addRow("Crossover Method", self.inp_crossover_method)
self.addRow("Crossover Fraction", self.inp_crossover_fraction)
self.addRow("Intermediate Offset", self.intermediate_offset)
self.addRow(QHLine())
def init_row_mutation(self):
self.header_mutation.setFont(self.medium_font)
self.header_mutation.setText("Mutation")
self.inp_mutation_method.addItem("Gauss", "Gauss")
self.inp_mutation_method.addItem("Random", "Random")
self.inp_mutation_intensity.setMaximum(200)
self.inp_mutation_intensity.setValue(2)
self.inp_mutation_intensity.setDecimals(4)
self.inp_mutation_intensity.setSingleStep(0.01)
self.inp_mutation_intensity_final.setMaximum(200)
self.inp_mutation_intensity_final.setDecimals(4)
self.inp_mutation_intensity_final.setValue(0.001)
self.inp_mutation_intensity_final.setSingleStep(0.5)
self.addRow(self.header_mutation)
self.addRow("Mutation Method", self.inp_mutation_method)
self.addRow("Mutation Intensity", self.inp_mutation_intensity)
self.addRow("Final Mutation Intensity",
self.inp_mutation_intensity_final)
self.addRow(QHLine())
def get_options(self):
function = self.inp_functions_combo.currentData()
num_var = self.inp_num_variables.text()
if self.inp_extrema_min.isChecked():
extrem = 0
else:
extrem = 1
pop_size = self.inp_pop_size.text()
low_bound = self.inp_lower_bound.text()
upp_bound = self.inp_upper_bound.text()
max_iter = self.inp_max_iter.text()
sim_results = self.inp_similarity.text()
best_res = self.inp_best_result.text()
average_res = self.inp_average_result.text()
select_method = self.inp_selection_method.currentText()
elite_percent = self.inp_elitism.text()
pairing = self.inp_pairing_method.currentText()
crossover_method = self.inp_crossover_method.currentText()
crossover_fraction = self.inp_crossover_fraction.text()
intermediate_offset = self.intermediate_offset.text()
mutation_method = self.inp_mutation_method.currentText()
mutation_intensity = self.inp_mutation_intensity.text()
mutation_intensity_final = self.inp_mutation_intensity_final.text()
fitness_remapping = self.inp_fitness_remapping.currentText()
options = {
"function":
function,
"num_var":
num_var,
"pop_size":
int(pop_size),
"max_iter":
int(max_iter),
"lower_bound":
float(low_bound.replace(",", ".")),
"upper_bound":
float(upp_bound.replace(",", ".")),
"find_max":
extrem,
"prints":
0,
"average_result":
float(average_res.replace(",", ".")),
"best_result":
float(best_res.replace(",", ".")),
"similarity":
float(sim_results.replace(",", ".")),
"selection":
select_method,
"pairing":
pairing,
"crossover":
crossover_method,
"crossover_fraction":
float(crossover_fraction.replace(",", ".")),
"intermediate_offset":
float(intermediate_offset.replace(",", ".")),
# 0 mean child will be between parents, 1 mean offset is same as two parent distance
"mutation":
mutation_method,
"mutation_intensity":
float(mutation_intensity.replace(",", ".")),
"mutation_intensity_final":
float(mutation_intensity_final.replace(",", ".")),
"elitism":
float(elite_percent.replace(",", ".")),
"fitness_remapping":
fitness_remapping
}
if not self.inp_similarity_cb.isChecked():
options["similarity"] = None
if not self.inp_best_result_cb.isChecked():
options["best_result"] = None
if not self.inp_average_result_cb.isChecked():
options["average_result"] = None
return options
def cb_similarity_signal(self):
if self.inp_similarity_cb.isChecked():
self.inp_similarity.setEnabled(True)
self.inp_similarity.setStyleSheet("")
else:
self.inp_similarity.setEnabled(False)
self.inp_similarity.setStyleSheet("background:#555")
def cb_best_result_signal(self):
if self.inp_best_result_cb.isChecked():
self.inp_best_result.setEnabled(True)
self.inp_best_result.setStyleSheet("")
else:
self.inp_best_result.setEnabled(False)
self.inp_best_result.setStyleSheet("background:#555")
def cb_average_result_signal(self):
if self.inp_average_result_cb.isChecked():
self.inp_average_result.setEnabled(True)
self.inp_average_result.setStyleSheet("")
else:
self.inp_average_result.setEnabled(False)
self.inp_average_result.setStyleSheet("background:#555")
class AudioInfoDialog(QDialog):
def __init__(self,
audios_name,
audios_delay,
audios_language,
audios_track_name,
audios_set_default,
audios_set_forced,
audios_default_value_delay,
audios_default_value_language,
audios_default_value_track_name,
audios_default_value_set_default,
audios_default_value_set_forced,
audio_set_default_disabled=False,
audio_set_forced_disabled=False,
disable_edit=False,
parent=None):
super().__init__(parent)
self.window_title = "Audio Info"
self.state = "no"
self.audios_count = len(audios_delay)
self.messageIcon = QLabel()
self.audio_tab_comboBox = InfoCellDialogTabComboBox(
hint="Audios Groups")
for i in range(self.audios_count):
self.audio_tab_comboBox.addItem("Audio #" + str(i + 1))
self.audio_tab_comboBox.setCurrentIndex(0)
self.audio_tab_comboBox.currentIndexChanged.connect(
self.update_current_audio_index)
self.current_audio_index = 0
self.disable_edit = disable_edit
self.current_audio_name = audios_name
self.current_audio_language = audios_language
self.current_audio_delay = audios_delay
self.current_audio_track_name = audios_track_name
self.current_audio_set_default = audios_set_default
self.current_audio_set_forced = audios_set_forced
self.default_audio_language = audios_default_value_language
self.default_audio_delay = audios_default_value_delay
self.default_audio_track_name = audios_default_value_track_name
self.default_audio_set_default = audios_default_value_set_default
self.default_audio_set_forced = audios_default_value_set_forced
self.audio_set_default_disabled = audio_set_default_disabled
self.audio_set_forced_disabled = audio_set_forced_disabled
self.audio_name_label = QLabel("Audio Name:")
self.audio_name_value = QLabel(
str(self.current_audio_name[self.current_audio_index]))
width_to_be_fixed = 0
for i in range(len(self.current_audio_name)):
width_to_be_fixed = max(
width_to_be_fixed,
self.audio_name_value.fontMetrics().boundingRect(
self.current_audio_name[i]).width())
self.audio_name_value.setFixedWidth(width_to_be_fixed + 10)
self.audio_delay_label = QLabel("Audio Delay:")
self.audio_delay_spin = QDoubleSpinBox()
self.setup_audio_delay_spin()
self.audio_language_label = QLabel("Audio Language:")
self.audio_language_comboBox = QComboBox()
self.setup_audio_language_comboBox()
self.audio_track_name_label = QLabel("Audio Track Name:")
self.audio_track_name_lineEdit = QLineEdit()
self.setup_audio_track_name_lineEdit()
self.audio_set_forced_label = QLabel("Audio Forced State:")
self.audio_set_forced_checkBox = QCheckBox()
self.setup_audio_set_forced_checkBox()
self.audio_set_default_label = QLabel("Audio Default State:")
self.audio_set_default_checkBox = QCheckBox()
self.setup_audio_set_default_checkBox()
self.yes_button = QPushButton("OK")
self.no_button = QPushButton("Cancel")
self.reset_button = QPushButton("Reset To Default")
self.buttons_layout = QHBoxLayout()
self.audio_delay_layout = QHBoxLayout()
self.audio_language_layout = QHBoxLayout()
self.audio_track_name_layout = QHBoxLayout()
self.audio_set_default_layout = QHBoxLayout()
self.audio_set_forced_layout = QHBoxLayout()
self.buttons_layout.addWidget(QLabel(""), stretch=3)
self.buttons_layout.addWidget(self.reset_button, stretch=2)
self.buttons_layout.addWidget(self.yes_button, stretch=2)
self.buttons_layout.addWidget(self.no_button, stretch=2)
self.buttons_layout.addWidget(QLabel(""), stretch=3)
self.audio_setting_layout = QGridLayout()
self.audio_editable_setting_layout = QFormLayout()
self.audio_editable_setting_layout.addRow(self.audio_name_label,
self.audio_name_value)
self.audio_editable_setting_layout.addRow(
self.audio_track_name_label, self.audio_track_name_lineEdit)
self.audio_editable_setting_layout.addRow(self.audio_language_label,
self.audio_language_comboBox)
self.audio_editable_setting_layout.addRow(self.audio_delay_label,
self.audio_delay_spin)
self.audio_editable_setting_layout.addRow(
self.audio_set_default_label, self.audio_set_default_checkBox)
self.audio_editable_setting_layout.addRow(
self.audio_set_forced_label, self.audio_set_forced_checkBox)
self.audio_setting_layout.addWidget(self.audio_tab_comboBox, 0, 0)
self.audio_setting_layout.addLayout(self.audio_editable_setting_layout,
1, 0, 5, 2)
self.audio_setting_layout.addWidget(self.messageIcon, 1, 3, 5, -1)
self.main_layout = QGridLayout()
self.main_layout.addLayout(self.audio_setting_layout, 0, 0, 2, 3)
self.main_layout.addLayout(self.buttons_layout, 2, 0, 1, -1)
self.main_layout.setContentsMargins(20, 20, 20, 20)
self.setLayout(self.main_layout)
self.setup_ui()
self.signal_connect()
def setup_ui(self):
self.disable_question_mark_window()
self.messageIcon.setPixmap(
QtGui.QPixmap(GlobalFiles.AudioIconPath).scaledToHeight(100))
self.set_dialog_values()
self.set_default_buttons()
if self.audio_set_default_disabled:
self.audio_set_default_disable()
if self.audio_set_forced_disabled:
self.audio_set_forced_disable()
if self.disable_edit:
self.audio_track_name_lineEdit.setEnabled(False)
self.audio_language_comboBox.setEnabled(False)
self.audio_delay_spin.setEnabled(False)
self.audio_set_default_checkBox.setEnabled(False)
self.audio_set_forced_checkBox.setEnabled(False)
self.reset_button.setEnabled(False)
self.setup_tool_tip_hint_audio_set_default()
self.setup_tool_tip_hint_audio_set_forced()
def signal_connect(self):
self.audio_track_name_lineEdit.textEdited.connect(
self.update_current_audio_track_name)
self.audio_delay_spin.editingFinished.connect(
self.update_current_audio_delay)
self.audio_language_comboBox.currentTextChanged.connect(
self.update_current_audio_language)
self.audio_set_default_checkBox.stateChanged.connect(
self.update_current_audio_set_default)
self.audio_set_forced_checkBox.stateChanged.connect(
self.update_current_audio_set_forced)
self.yes_button.clicked.connect(self.click_yes)
self.no_button.clicked.connect(self.click_no)
self.reset_button.clicked.connect(self.reset_audio_setting)
def click_yes(self):
self.state = "yes"
self.close()
def click_no(self):
self.state = "no"
self.close()
def set_dialog_values(self):
self.setWindowTitle(self.window_title)
self.setWindowIcon(GlobalFiles.InfoSettingIcon)
def disable_question_mark_window(self):
self.setWindowFlag(Qt.WindowContextHelpButtonHint, on=False)
def increase_message_font_size(self, value):
message_font = self.message.font()
message_font.setPointSize(self.message.fontInfo().pointSize() + value)
self.message.setFont(message_font)
def set_default_buttons(self):
self.yes_button.setDefault(True)
self.yes_button.setFocus()
def showEvent(self, a0: QtGui.QShowEvent) -> None:
super().showEvent(a0)
self.setFixedSize(self.size())
def setup_audio_track_name_lineEdit(self):
self.audio_track_name_lineEdit.setClearButtonEnabled(True)
self.audio_track_name_lineEdit.setText(
self.current_audio_track_name[self.current_audio_index])
def setup_audio_language_comboBox(self):
self.audio_language_comboBox.addItems(AllAudiosLanguages)
self.audio_language_comboBox.setCurrentIndex(
AllAudiosLanguages.index(
self.current_audio_language[self.current_audio_index]))
self.audio_language_comboBox.setMaxVisibleItems(8)
self.audio_language_comboBox.setStyleSheet(
"QComboBox { combobox-popup: 0; }")
def setup_audio_delay_spin(self):
# self.audio_delay_spin.setMaximumWidth(screen_size.width() // 16)
self.audio_delay_spin.setDecimals(3)
self.audio_delay_spin.setMinimum(-9999.0)
self.audio_delay_spin.setMaximum(9999.0)
self.audio_delay_spin.setSingleStep(0.5)
self.audio_delay_spin.setValue(
float(self.current_audio_delay[self.current_audio_index]))
def setup_audio_set_default_checkBox(self):
self.audio_set_default_checkBox.setText("Set Default")
self.audio_set_default_checkBox.setChecked(
bool(self.current_audio_set_default[self.current_audio_index]))
def setup_audio_set_forced_checkBox(self):
self.audio_set_forced_checkBox.setText("Set Forced")
self.audio_set_forced_checkBox.setChecked(
bool(self.current_audio_set_forced[self.current_audio_index]))
def update_current_audio_track_name(self):
self.current_audio_track_name[self.current_audio_index] = str(
self.audio_track_name_lineEdit.text())
def update_current_audio_delay(self):
self.current_audio_delay[self.current_audio_index] = round(
self.audio_delay_spin.value(), 5)
def update_current_audio_language(self):
self.current_audio_language[self.current_audio_index] = str(
self.audio_language_comboBox.currentText())
def update_current_audio_set_default(self):
new_state = self.audio_set_default_checkBox.checkState() == Qt.Checked
self.current_audio_set_default[self.current_audio_index] = new_state
if new_state:
for i in range(len(self.current_audio_set_default)):
if i != self.current_audio_index:
self.current_audio_set_default[i] = False
def update_current_audio_set_forced(self):
new_state = self.audio_set_forced_checkBox.checkState() == Qt.Checked
self.current_audio_set_forced[self.current_audio_index] = new_state
if new_state:
for i in range(len(self.current_audio_set_forced)):
if i != self.current_audio_index:
self.current_audio_set_forced[i] = False
def reset_audio_setting(self):
self.current_audio_language[
self.current_audio_index] = self.default_audio_language[
self.current_audio_index]
self.current_audio_delay[
self.current_audio_index] = self.default_audio_delay[
self.current_audio_index]
self.current_audio_track_name[
self.current_audio_index] = self.default_audio_track_name[
self.current_audio_index]
self.current_audio_set_default[
self.current_audio_index] = self.default_audio_set_default[
self.current_audio_index]
self.current_audio_set_forced[
self.current_audio_index] = self.default_audio_set_forced[
self.current_audio_index]
self.audio_language_comboBox.setCurrentIndex(
AllAudiosLanguages.index(
self.current_audio_language[self.current_audio_index]))
self.audio_delay_spin.setValue(
float(self.current_audio_delay[self.current_audio_index]))
self.audio_track_name_lineEdit.setText(
self.current_audio_track_name[self.current_audio_index])
self.audio_set_default_checkBox.setChecked(
bool(self.current_audio_set_default[self.current_audio_index]))
self.audio_set_forced_checkBox.setChecked(
bool(self.current_audio_set_forced[self.current_audio_index]))
def audio_set_default_disable(self):
self.audio_set_default_checkBox.setDisabled(True)
def audio_set_forced_disable(self):
self.audio_set_forced_checkBox.setDisabled(True)
def setup_tool_tip_hint_audio_set_default(self):
if self.audio_set_default_checkBox.isEnabled():
self.audio_set_default_checkBox.setToolTip(
"<nobr>set this audio to be the default audio track "
"when play")
self.audio_set_default_checkBox.setToolTipDuration(12000)
else:
self.audio_set_default_checkBox.setToolTip(
"<nobr>set this audio to be the default audio track when play<br><b>Disabled</b> because "
"option "
"<b>make this audio default</b> is enabled on mux setting tab "
)
self.audio_set_default_checkBox.setToolTipDuration(12000)
def setup_tool_tip_hint_audio_set_forced(self):
if self.audio_set_forced_checkBox.isEnabled():
self.audio_set_forced_checkBox.setToolTip(
"<nobr>set this audio to be the forced audio track when "
"play")
self.audio_set_forced_checkBox.setToolTipDuration(12000)
else:
self.audio_set_forced_checkBox.setToolTip(
"<nobr>set this audio to be the forced audio track when play<br><b>Disabled</b> because "
"option "
"<b>make this audio default and forced</b> is enabled on mux setting tab "
)
self.audio_set_forced_checkBox.setToolTipDuration(12000)
def update_current_audio_index(self, new_index):
self.current_audio_index = new_index
self.audio_delay_spin.setValue(
float(self.current_audio_delay[self.current_audio_index]))
self.audio_set_default_checkBox.setChecked(
bool(self.current_audio_set_default[self.current_audio_index]))
self.audio_set_forced_checkBox.setChecked(
bool(self.current_audio_set_forced[self.current_audio_index]))
self.audio_language_comboBox.setCurrentIndex(
AllAudiosLanguages.index(
self.current_audio_language[self.current_audio_index]))
self.audio_track_name_lineEdit.setText(
self.current_audio_track_name[self.current_audio_index])
self.audio_name_value.setText(
str(self.current_audio_name[self.current_audio_index]))
def execute(self):
self.exec_()
class PlotsWidget(ToolWidget):
def __init__(self, image, parent=None):
super(PlotsWidget, self).__init__(parent)
choices = ['Red', 'Green', 'Blue', 'Hue', 'Saturation', 'Value']
self.xaxis_combo = QComboBox()
self.xaxis_combo.addItems(choices)
self.xaxis_combo.setCurrentIndex(3)
self.yaxis_combo = QComboBox()
self.yaxis_combo.addItems(choices)
self.yaxis_combo.setCurrentIndex(4)
self.zaxis_combo = QComboBox()
self.zaxis_combo.addItems(choices)
self.zaxis_combo.setCurrentIndex(5)
self.sampling_spin = QSpinBox()
levels = int(np.log2(min(image.shape[:-1])))
self.sampling_spin.setRange(0, levels)
self.sampling_spin.setSpecialValueText(self.tr('Off'))
# self.sampling_spin.setSuffix(self.tr(' level(s)'))
self.sampling_spin.setValue(1)
self.size_spin = QSpinBox()
self.size_spin.setRange(1, 10)
self.size_spin.setValue(1)
self.size_spin.setSuffix(self.tr(' pt'))
self.style_combo = QComboBox()
self.markers = [',', '.', 'o', '8', 's', 'p', 'P', '*', 'h', 'H', 'X', 'D']
self.style_combo.addItems(
['pixel', 'point', 'circle', 'octa', 'square', 'penta', 'plus', 'star', 'hexa1', 'hexa2', 'cross', 'diamond'])
self.alpha_spin = QDoubleSpinBox()
self.alpha_spin.setRange(0, 1)
self.alpha_spin.setDecimals(2)
self.alpha_spin.setSingleStep(0.05)
self.alpha_spin.setValue(1)
self.colors_check = QCheckBox(self.tr('Show colors'))
self.grid_check = QCheckBox(self.tr('Show grid'))
self.norm_check = QCheckBox(self.tr('Normalized'))
self.total_label = QLabel()
img = np.copy(image)
self.colors = [None] * (levels + 1)
for scale in range(levels + 1):
rgb = cv.cvtColor(img.astype(np.float32) / 255, cv.COLOR_BGR2RGB)
hsv = cv.cvtColor(rgb, cv.COLOR_RGB2HSV)
hsv[:, :, 0] /= 360
shape = (img.shape[0] * img.shape[1], img.shape[2])
self.colors[scale] = np.concatenate((np.reshape(rgb, shape), np.reshape(hsv, shape)), axis=1)
img = cv.pyrDown(img)
figure2 = Figure()
plot2_canvas = FigureCanvas(figure2)
self.axes2 = plot2_canvas.figure.subplots()
toolbar2 = NavigationToolbar(plot2_canvas, self)
plot2_layout = QVBoxLayout()
plot2_layout.addWidget(plot2_canvas)
plot2_layout.addWidget(toolbar2)
plot2_widget = QWidget()
plot2_widget.setLayout(plot2_layout)
figure3 = Figure()
plot3_canvas = FigureCanvas(figure3)
self.axes3 = plot3_canvas.figure.add_subplot(111, projection='3d')
toolbar3 = NavigationToolbar(plot3_canvas, self)
plot3_layout = QVBoxLayout()
plot3_layout.addWidget(plot3_canvas)
plot3_layout.addWidget(toolbar3)
plot3_widget = QWidget()
plot3_widget.setLayout(plot3_layout)
self.tab_widget = QTabWidget()
self.tab_widget.addTab(plot2_widget, '2D Plot')
self.tab_widget.addTab(plot3_widget, '3D Plot')
self.redraw()
figure2.set_tight_layout(True)
figure3.set_tight_layout(True)
self.xaxis_combo.currentIndexChanged.connect(self.redraw)
self.yaxis_combo.currentIndexChanged.connect(self.redraw)
self.zaxis_combo.currentIndexChanged.connect(self.redraw)
self.sampling_spin.valueChanged.connect(self.redraw)
self.size_spin.valueChanged.connect(self.redraw)
self.style_combo.currentIndexChanged.connect(self.redraw)
self.alpha_spin.valueChanged.connect(self.redraw)
self.colors_check.stateChanged.connect(self.redraw)
self.grid_check.stateChanged.connect(self.redraw)
self.norm_check.stateChanged.connect(self.redraw)
self.tab_widget.currentChanged.connect(self.redraw)
params_layout = QGridLayout()
params_layout.addWidget(QLabel(self.tr('X axis:')), 0, 0)
params_layout.addWidget(self.xaxis_combo, 0, 1)
params_layout.addWidget(QLabel(self.tr('Y axis:')), 1, 0)
params_layout.addWidget(self.yaxis_combo, 1, 1)
params_layout.addWidget(QLabel(self.tr('Z axis:')), 2, 0)
params_layout.addWidget(self.zaxis_combo, 2, 1)
params_layout.addWidget(QLabel(self.tr('Subsampling:')), 0, 2)
params_layout.addWidget(self.sampling_spin, 0, 3)
params_layout.addWidget(QLabel(self.tr('Point size:')), 1, 2)
params_layout.addWidget(self.size_spin, 1, 3)
# params_layout.addWidget(QLabel(self.tr('Point style:')), 2, 2)
# params_layout.addWidget(self.style_combo, 3, 4)
params_layout.addWidget(QLabel(self.tr('Point alpha:')), 2, 2)
params_layout.addWidget(self.alpha_spin, 2, 3)
params_layout.addWidget(self.colors_check, 0, 4)
params_layout.addWidget(self.grid_check, 1, 4)
params_layout.addWidget(self.total_label, 2, 4)
bottom_layout = QHBoxLayout()
bottom_layout.addLayout(params_layout)
bottom_layout.addStretch()
main_layout = QVBoxLayout()
main_layout.addWidget(self.tab_widget)
main_layout.addLayout(bottom_layout)
self.setLayout(main_layout)
def redraw(self):
start = time()
v = self.sampling_spin.value()
x = self.colors[v][:, self.xaxis_combo.currentIndex()]
y = self.colors[v][:, self.yaxis_combo.currentIndex()]
s = self.size_spin.value()**2
c = None if not self.colors_check.isChecked() else self.colors[v][:, :3]
if self.tab_widget.currentIndex() == 0:
self.zaxis_combo.setEnabled(False)
self.grid_check.setEnabled(True)
self.alpha_spin.setEnabled(True)
a = self.alpha_spin.value()
xlim = self.axes2.get_xlim()
ylim = self.axes2.get_ylim()
self.axes2.clear()
self.axes2.set_facecolor([0.5] * 3 if c is not None else [1.0] * 3)
self.axes2.scatter(x, y, s, c, '.', alpha=a)
self.axes2.set_xlabel(self.xaxis_combo.currentText())
self.axes2.set_ylabel(self.yaxis_combo.currentText())
self.axes2.grid(self.grid_check.isChecked(), which='both')
self.axes2.set_xlim(xlim)
self.axes2.set_ylim(ylim)
self.axes2.figure.canvas.draw()
else:
self.zaxis_combo.setEnabled(True)
self.grid_check.setEnabled(False)
self.alpha_spin.setEnabled(False)
z = self.colors[v][:, self.zaxis_combo.currentIndex()]
self.axes3.clear()
self.axes3.set_facecolor([0.5] * 3 if c is not None else [1.0] * 3)
self.axes3.scatter(x, y, z, s=s, c=c, marker='.', depthshade=True)
self.axes3.set_xlabel(self.xaxis_combo.currentText())
self.axes3.set_ylabel(self.yaxis_combo.currentText())
self.axes3.set_zlabel(self.zaxis_combo.currentText())
self.axes3.grid(self.grid_check.isChecked(), which='both')
self.axes3.figure.canvas.draw()
self.total_label.setText(self.tr('[{} points]'.format(len(x))))
self.info_message.emit('Plot redraw = {}'.format(elapsed_time(start)))
class GeneralView(QWidget):
"""Config widget for general properties of an experiment.
This "view" does not have a model. Instead, it is a part of a bigger view called ExperimentView, and gets updated
with it.
"""
inlet_type_export_values = {
"LSL stream": "lsl",
"LSL file stream": "lsl_from_file",
"LSL generator": "lsl_generator",
"Field trip buffer": "ftbuffer"
}
inlet_type_import_values = {
v: k
for k, v in inlet_type_export_values.items()
}
def __init__(self, parent=None):
super().__init__(parent=parent)
layout = QFormLayout()
self.setLayout(layout)
self.name = QLineEdit()
# prefilter_lower_bound ---------------------------------------------------------------------------------------------
self.prefilter_lower_bound_enable = QCheckBox()
self.prefilter_lower_bound_enable.stateChanged.connect(self._adjust)
self.prefilter_lower_bound = QDoubleSpinBox()
self.prefilter_lower_bound.setEnabled(False)
self.prefilter_lower_bound.valueChanged.connect(self._adjust)
self.prefilter_lower_bound.setMinimum(0)
self.prefilter_lower_bound.setMaximum(0) # TODO: add proper value
self.prefilter_lower_bound.setValue(0) # TODO: add proper value
prefilter_lower_bound_widget = QWidget()
prefilter_lower_bound_widget.setContentsMargins(0, 0, 0, 0)
prefilter_lower_bound_widget.setLayout(QHBoxLayout())
prefilter_lower_bound_widget.layout().setContentsMargins(0, 0, 0, 0)
prefilter_lower_bound_widget.layout().addWidget(
self.prefilter_lower_bound_enable)
prefilter_lower_bound_widget.layout().addWidget(
self.prefilter_lower_bound)
# prefilter_upper_bound --------------------------------------------------------------------------------------------
self.prefilter_upper_bound_enable = QCheckBox()
self.prefilter_upper_bound_enable.stateChanged.connect(self._adjust)
self.prefilter_upper_bound = QDoubleSpinBox()
self.prefilter_upper_bound.setEnabled(False)
self.prefilter_upper_bound.valueChanged.connect(self._adjust)
self.prefilter_upper_bound.setMinimum(
self.prefilter_lower_bound.value())
self.prefilter_upper_bound.setMaximum(10000) # TODO: add proper value
self.prefilter_upper_bound.setValue(0) # TODO: add proper value
prefilter_upper_bound_widget = QWidget()
prefilter_upper_bound_widget.setContentsMargins(0, 0, 0, 0)
prefilter_upper_bound_widget.setLayout(QHBoxLayout())
prefilter_upper_bound_widget.layout().setContentsMargins(0, 0, 0, 0)
prefilter_upper_bound_widget.layout().addWidget(
self.prefilter_upper_bound_enable)
prefilter_upper_bound_widget.layout().addWidget(
self.prefilter_upper_bound)
# Inlet selection ----------------------------------------------------------------------------------------------
self.inlet_type = QComboBox()
self.inlet_type.addItem("LSL stream")
self.inlet_type.addItem("LSL file stream")
self.inlet_type.addItem("LSL generator")
self.inlet_type.addItem("Field trip buffer")
self.lsl_stream_name = QComboBox()
self.lsl_stream_name.addItem("NVX136_Data")
self.lsl_stream_name.addItem("Mitsar")
self.lsl_filename = PathEdit()
dialog = QFileDialog(self, "Open")
dialog.setFileMode(dialog.AnyFile)
self.lsl_filename.setDialog(dialog)
self.hostname_port = QLineEdit("localhost:1972")
self.inlet_params = StackedDictWidget()
self.inlet_params.setMaximumHeight(25)
self.inlet_params.addWidget("LSL stream", self.lsl_stream_name)
self.inlet_params.addWidget("LSL file stream", self.lsl_filename)
self.inlet_params.addWidget("LSL generator", QWidget())
self.inlet_params.addWidget("Field trip buffer", self.hostname_port)
# TODO: LSL generator is not reflected in the exported file, even when selected.
self.inlet_type.currentTextChanged.connect(
self.inlet_params.setCurrentKey)
self.inlet_config = QWidget()
self.inlet_config.setContentsMargins(0, 0, 0, 0)
inlet_layout = QHBoxLayout()
inlet_layout.setContentsMargins(0, 0, 0, 0)
inlet_layout.addWidget(self.inlet_type)
inlet_layout.addWidget(self.inlet_params)
self.inlet_config.setLayout(inlet_layout)
# --------------------------------------------------------------------------------------------------------------
self.name = QLineEdit("Experiment")
self.dc = QCheckBox()
self.plot_raw = QCheckBox()
self.plot_raw.setChecked(True)
self.plot_signals = QCheckBox()
self.plot_signals.setChecked(True)
self.discard_channels = QLineEdit()
self.reference_sub = QLineEdit()
self.show_photo_rectangle = QCheckBox()
self.show_notch_filters = QCheckBox()
self.reward_refractory_period = QDoubleSpinBox()
self.reward_refractory_period.setRange(0.1, 10)
self.reward_refractory_period.setValue(0.25)
self.reward_refractory_period.setSuffix(" s")
# Adding properties to the widget ------------------------------------------------------------------------------
layout.addRow("Name", self.name)
layout.addRow("Inlet", self.inlet_config)
layout.addRow("Enable DC blocker", self.dc)
layout.addRow("Prefilter band (lower bound)",
prefilter_lower_bound_widget)
layout.addRow("Prefilter band (upper bound)",
prefilter_upper_bound_widget)
layout.addRow("Plot raw", self.plot_raw)
layout.addRow("Plot signals", self.plot_signals)
layout.addRow("Discard channels", self.discard_channels)
layout.addRow("Reference sub", self.reference_sub)
layout.addRow("Show photo-sensor rectangle", self.show_photo_rectangle)
layout.addRow("Show notch filters", self.show_notch_filters)
layout.addRow("Reward refractory period",
self.reward_refractory_period)
def updateModel(self, ex, /):
ex.name = self.name.text()
ex.inlet = self.inlet_type_export_values[self.inlet_type.currentText()]
ex.lsl_stream_name = self.lsl_stream_name.currentText()
ex.raw_data_path = self.lsl_filename.text()
ex.hostname_port = self.hostname_port.text()
ex.dc = self.dc.isChecked()
if self.prefilter_lower_bound_enable.isChecked():
prefilter_lower_bound = self.prefilter_lower_bound.value()
else:
prefilter_lower_bound = None
if self.prefilter_upper_bound_enable.isChecked():
prefilter_upper_bound = self.prefilter_upper_bound.value()
else:
prefilter_upper_bound = None
ex.prefilter_band = (prefilter_lower_bound, prefilter_upper_bound)
ex.plot_raw = self.plot_raw.isChecked()
ex.plot_signals = self.plot_signals.isChecked()
ex.discard_channels = self.discard_channels.text()
ex.reference_sub = self.reference_sub.text()
ex.show_photo_rectangle = self.show_photo_rectangle.isChecked()
ex.show_notch_filters = self.show_notch_filters.isChecked()
ex.reward_refractory_period = self.reward_refractory_period.value()
def _adjust(self):
if self.prefilter_lower_bound_enable.isChecked():
self.prefilter_lower_bound.setEnabled(True)
self.prefilter_upper_bound.setMinimum(
self.prefilter_lower_bound.value())
else:
self.prefilter_lower_bound.setEnabled(False)
self.prefilter_upper_bound.setMinimum(0)
if self.prefilter_upper_bound_enable.isChecked():
self.prefilter_upper_bound.setEnabled(True)
self.prefilter_lower_bound.setMaximum(
self.prefilter_upper_bound.value())
else:
self.prefilter_upper_bound.setEnabled(False)
self.prefilter_lower_bound.setMaximum(
10000) # TODO: add proper value
class PlotsWidget(ToolWidget):
def __init__(self, image, parent=None):
super(PlotsWidget, self).__init__(parent)
choices = ["Red", "Green", "Blue", "Hue", "Saturation", "Value"]
self.xaxis_combo = QComboBox()
self.xaxis_combo.addItems(choices)
self.xaxis_combo.setCurrentIndex(3)
self.yaxis_combo = QComboBox()
self.yaxis_combo.addItems(choices)
self.yaxis_combo.setCurrentIndex(4)
self.zaxis_combo = QComboBox()
self.zaxis_combo.addItems(choices)
self.zaxis_combo.setCurrentIndex(5)
self.sampling_spin = QSpinBox()
levels = int(np.log2(min(image.shape[:-1])))
self.sampling_spin.setRange(0, levels)
self.sampling_spin.setSpecialValueText(self.tr("Off"))
# self.sampling_spin.setSuffix(self.tr(' level(s)'))
self.sampling_spin.setValue(1)
self.size_spin = QSpinBox()
self.size_spin.setRange(1, 10)
self.size_spin.setValue(1)
self.size_spin.setSuffix(self.tr(" pt"))
self.markers = [
",", ".", "o", "8", "s", "p", "P", "*", "h", "H", "X", "D"
]
self.alpha_spin = QDoubleSpinBox()
self.alpha_spin.setRange(0, 1)
self.alpha_spin.setDecimals(2)
self.alpha_spin.setSingleStep(0.05)
self.alpha_spin.setValue(1)
self.colors_check = QCheckBox(self.tr("Show colors"))
self.grid_check = QCheckBox(self.tr("Show grid"))
self.norm_check = QCheckBox(self.tr("Normalized"))
self.total_label = QLabel()
img = np.copy(image)
self.colors = [None] * (levels + 1)
for scale in range(levels + 1):
rgb = cv.cvtColor(img.astype(np.float32) / 255, cv.COLOR_BGR2RGB)
hsv = cv.cvtColor(rgb, cv.COLOR_RGB2HSV)
hsv[:, :, 0] /= 360
shape = (img.shape[0] * img.shape[1], img.shape[2])
self.colors[scale] = np.concatenate(
(np.reshape(rgb, shape), np.reshape(hsv, shape)), axis=1)
img = cv.pyrDown(img)
figure2 = Figure()
plot2_canvas = FigureCanvas(figure2)
self.axes2 = plot2_canvas.figure.subplots()
toolbar2 = NavigationToolbar(plot2_canvas, self)
plot2_layout = QVBoxLayout()
plot2_layout.addWidget(plot2_canvas)
plot2_layout.addWidget(toolbar2)
plot2_widget = QWidget()
plot2_widget.setLayout(plot2_layout)
figure3 = Figure()
plot3_canvas = FigureCanvas(figure3)
self.axes3 = plot3_canvas.figure.add_subplot(111, projection="3d")
toolbar3 = NavigationToolbar(plot3_canvas, self)
plot3_layout = QVBoxLayout()
plot3_layout.addWidget(plot3_canvas)
plot3_layout.addWidget(toolbar3)
plot3_widget = QWidget()
plot3_widget.setLayout(plot3_layout)
self.tab_widget = QTabWidget()
self.tab_widget.addTab(plot2_widget, "2D Plot")
self.tab_widget.addTab(plot3_widget, "3D Plot")
self.redraw()
figure2.set_tight_layout(True)
figure3.set_tight_layout(True)
self.xaxis_combo.currentIndexChanged.connect(self.redraw)
self.yaxis_combo.currentIndexChanged.connect(self.redraw)
self.zaxis_combo.currentIndexChanged.connect(self.redraw)
self.sampling_spin.valueChanged.connect(self.redraw)
self.size_spin.valueChanged.connect(self.redraw)
self.alpha_spin.valueChanged.connect(self.redraw)
self.colors_check.stateChanged.connect(self.redraw)
self.grid_check.stateChanged.connect(self.redraw)
self.norm_check.stateChanged.connect(self.redraw)
self.tab_widget.currentChanged.connect(self.redraw)
params_layout = QGridLayout()
params_layout.addWidget(QLabel(self.tr("X axis:")), 0, 0)
params_layout.addWidget(self.xaxis_combo, 0, 1)
params_layout.addWidget(QLabel(self.tr("Y axis:")), 1, 0)
params_layout.addWidget(self.yaxis_combo, 1, 1)
params_layout.addWidget(QLabel(self.tr("Z axis:")), 2, 0)
params_layout.addWidget(self.zaxis_combo, 2, 1)
params_layout.addWidget(QLabel(self.tr("Subsampling:")), 0, 2)
params_layout.addWidget(self.sampling_spin, 0, 3)
params_layout.addWidget(QLabel(self.tr("Point size:")), 1, 2)
params_layout.addWidget(self.size_spin, 1, 3)
params_layout.addWidget(QLabel(self.tr("Point alpha:")), 2, 2)
params_layout.addWidget(self.alpha_spin, 2, 3)
params_layout.addWidget(self.colors_check, 0, 4)
params_layout.addWidget(self.grid_check, 1, 4)
params_layout.addWidget(self.total_label, 2, 4)
bottom_layout = QHBoxLayout()
bottom_layout.addLayout(params_layout)
bottom_layout.addStretch()
main_layout = QVBoxLayout()
main_layout.addWidget(self.tab_widget)
main_layout.addLayout(bottom_layout)
self.setLayout(main_layout)
def redraw(self):
start = time()
v = self.sampling_spin.value()
x = self.colors[v][:, self.xaxis_combo.currentIndex()]
y = self.colors[v][:, self.yaxis_combo.currentIndex()]
s = self.size_spin.value()**2
c = None if not self.colors_check.isChecked(
) else self.colors[v][:, :3]
if self.tab_widget.currentIndex() == 0:
self.zaxis_combo.setEnabled(False)
self.grid_check.setEnabled(True)
self.alpha_spin.setEnabled(True)
a = self.alpha_spin.value()
xlim = self.axes2.get_xlim()
ylim = self.axes2.get_ylim()
self.axes2.clear()
self.axes2.set_facecolor([0.5] * 3 if c is not None else [1.0] * 3)
self.axes2.scatter(x, y, s, c, ".", alpha=a)
self.axes2.set_xlabel(self.xaxis_combo.currentText())
self.axes2.set_ylabel(self.yaxis_combo.currentText())
self.axes2.grid(self.grid_check.isChecked(), which="both")
self.axes2.set_xlim(xlim)
self.axes2.set_ylim(ylim)
self.axes2.figure.canvas.draw()
else:
self.zaxis_combo.setEnabled(True)
self.grid_check.setEnabled(False)
self.alpha_spin.setEnabled(False)
z = self.colors[v][:, self.zaxis_combo.currentIndex()]
self.axes3.clear()
self.axes3.set_facecolor([0.5] * 3 if c is not None else [1.0] * 3)
self.axes3.scatter(x, y, z, s=s, c=c, marker=".", depthshade=True)
self.axes3.set_xlabel(self.xaxis_combo.currentText())
self.axes3.set_ylabel(self.yaxis_combo.currentText())
self.axes3.set_zlabel(self.zaxis_combo.currentText())
self.axes3.grid(self.grid_check.isChecked(), which="both")
self.axes3.figure.canvas.draw()
self.total_label.setText(self.tr(f"[{len(x)} points]"))
self.info_message.emit(f"Plot redraw = {elapsed_time(start)}")
class FilterGroup(AbstractProcessGroup):
def __init__(self, title, fs):
AbstractProcessGroup.__init__(self, title, fs)
self.setupFilterLayout()
def setupFilterLayout(self):
filterLayout = QVBoxLayout(self)
filterSettLayout = QHBoxLayout()
self.filterBandChooser = QComboBox()
self.filterTypeChooser = QComboBox()
filterTypeLayout = QFormLayout()
filterTypeLayout.addWidget(QLabel('Type'))
filterTypeLayout.addWidget(self.filterBandChooser)
bandTypes = {
'Low Pass': '******',
'Band Pass': '******',
'High Pass': '******',
'Band Stop': 'bandstop'
}
[self.filterBandChooser.addItem(i, bandTypes[i]) for i in bandTypes]
self.filterBandChooser.setCurrentText('Band Pass')
filterTypeLayout.addWidget(self.filterTypeChooser)
filterTypes = {'Butter': 'butter', 'Bessel': 'bessel'}
[
self.filterTypeChooser.addItem(i, filterTypes[i])
for i in filterTypes
]
self.lowFreqEdit = QDoubleSpinBox()
self.lowFreqEdit.setSuffix(' Hz')
self.lowFreqEdit.setDecimals(1)
self.lowFreqEdit.setRange(0.1, self.fs / 2 - 0.1)
self.highFreqEdit = QDoubleSpinBox()
self.highFreqEdit.setSuffix(' Hz')
self.highFreqEdit.setDecimals(1)
self.highFreqEdit.setLocale(
QLocale(QLocale.Polish, QLocale.EuropeanUnion))
self.highFreqEdit.setRange(0.1, self.fs / 2 - 0.1)
self.filterBandChooser.currentTextChanged.connect(self.setFilterBand)
filterFreqLayout = QFormLayout()
filterFreqLayout.addRow(QLabel('Cutoff Frequencies'))
filterFreqLayout.addRow('Low', self.lowFreqEdit)
filterFreqLayout.addRow('High', self.highFreqEdit)
filterOrdLayout = QFormLayout()
self.filterOrdEdit = QSpinBox()
self.filterOrdEdit.setMinimum(1)
self.filterOrdEdit.setValue(5)
filterOrdLayout.addRow(QLabel('Order'))
filterOrdLayout.addRow(self.filterOrdEdit)
filterSettLayout.addLayout(filterTypeLayout)
filterSettLayout.addSpacing(10)
filterSettLayout.addLayout(filterFreqLayout)
filterSettLayout.addSpacing(10)
filterSettLayout.addLayout(filterOrdLayout)
btn = QPushButton('Show filter response')
btn.clicked.connect(self.showFilterResponse)
filterLayout.addLayout(filterSettLayout)
filterLayout.addWidget(btn, 0, Qt.AlignRight)
def setFilterBand(self):
if self.filterBandChooser.currentText() == 'Low Pass':
self.lowFreqEdit.setDisabled(True)
else:
self.lowFreqEdit.setEnabled(True)
if self.filterBandChooser.currentText() == 'High Pass':
self.highFreqEdit.setDisabled(True)
else:
self.highFreqEdit.setEnabled(True)
def calcFilter(self):
bandArr = [
x.value() for x in (self.lowFreqEdit, self.highFreqEdit)
if x.isEnabled() == True
]
return filterCalc(order=self.filterOrdEdit.value(),
bandarr=bandArr,
fs=self.fs,
btype=self.filterBandChooser.currentData(),
ftype=self.filterTypeChooser.currentData())
def showFilterResponse(self):
bandArr = [
x.value() for x in (self.lowFreqEdit, self.highFreqEdit)
if x.isEnabled() == True
]
b, a = self.calcFilter()
w, h = signal.freqz(b, a)
fig = plt.figure()
ax1 = fig.add_subplot(111)
ax1.set_title(
label='Filter frequency response\n{}, {}, {}Hz, ord={}'.format(
self.filterBandChooser.currentText(),
self.filterTypeChooser.currentText(), bandArr,
self.filterOrdEdit.value()))
ax1.plot(w * (self.fs / (2 * np.pi)), 20 * np.log10(abs(h)), 'b')
ax1.set_ylabel('Amplitude [dB]', color='b')
ax1.set_xlabel('Frequency [Hz]')
ax1.tick_params(axis='y', colors='b')
ax2 = ax1.twinx()
angles = np.unwrap(np.angle(h))
ax2.plot(w * (self.fs / (2 * np.pi)), angles, 'g')
ax2.set_ylabel('Angle (radians)', color='g')
ax2.tick_params(axis='y', colors='g')
plt.grid()
plt.axis('tight')
plt.show()
def process(self, inData):
b, a = self.calcFilter()
outData = []
progStep = 100.0 / len(inData)
prog = 0
for data in inData:
newData = signal.lfilter(b, a, data)
outData.append(newData)
prog = prog + progStep
self.progress.emit(int(prog))
return outData
